efm32gg12b330_pac/wtimer1/
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 = "I/O Location\n\nValue on reset: 0"]
38#[derive(Clone, Copy, Debug, PartialEq)]
39#[repr(u8)]
40pub enum CC0LOC_A {
41 #[doc = "0: Location 0"]
42 LOC0 = 0,
43 #[doc = "1: Location 1"]
44 LOC1 = 1,
45 #[doc = "2: Location 2"]
46 LOC2 = 2,
47 #[doc = "3: Location 3"]
48 LOC3 = 3,
49 #[doc = "4: Location 4"]
50 LOC4 = 4,
51 #[doc = "5: Location 5"]
52 LOC5 = 5,
53 #[doc = "6: Location 6"]
54 LOC6 = 6,
55 #[doc = "7: Location 7"]
56 LOC7 = 7,
57}
58impl From<CC0LOC_A> for u8 {
59 #[inline(always)]
60 fn from(variant: CC0LOC_A) -> Self {
61 variant as _
62 }
63}
64#[doc = "Field `CC0LOC` reader - I/O Location"]
65pub type CC0LOC_R = crate::FieldReader<u8, CC0LOC_A>;
66impl CC0LOC_R {
67 #[doc = "Get enumerated values variant"]
68 #[inline(always)]
69 pub fn variant(&self) -> Option<CC0LOC_A> {
70 match self.bits {
71 0 => Some(CC0LOC_A::LOC0),
72 1 => Some(CC0LOC_A::LOC1),
73 2 => Some(CC0LOC_A::LOC2),
74 3 => Some(CC0LOC_A::LOC3),
75 4 => Some(CC0LOC_A::LOC4),
76 5 => Some(CC0LOC_A::LOC5),
77 6 => Some(CC0LOC_A::LOC6),
78 7 => Some(CC0LOC_A::LOC7),
79 _ => None,
80 }
81 }
82 #[doc = "Checks if the value of the field is `LOC0`"]
83 #[inline(always)]
84 pub fn is_loc0(&self) -> bool {
85 *self == CC0LOC_A::LOC0
86 }
87 #[doc = "Checks if the value of the field is `LOC1`"]
88 #[inline(always)]
89 pub fn is_loc1(&self) -> bool {
90 *self == CC0LOC_A::LOC1
91 }
92 #[doc = "Checks if the value of the field is `LOC2`"]
93 #[inline(always)]
94 pub fn is_loc2(&self) -> bool {
95 *self == CC0LOC_A::LOC2
96 }
97 #[doc = "Checks if the value of the field is `LOC3`"]
98 #[inline(always)]
99 pub fn is_loc3(&self) -> bool {
100 *self == CC0LOC_A::LOC3
101 }
102 #[doc = "Checks if the value of the field is `LOC4`"]
103 #[inline(always)]
104 pub fn is_loc4(&self) -> bool {
105 *self == CC0LOC_A::LOC4
106 }
107 #[doc = "Checks if the value of the field is `LOC5`"]
108 #[inline(always)]
109 pub fn is_loc5(&self) -> bool {
110 *self == CC0LOC_A::LOC5
111 }
112 #[doc = "Checks if the value of the field is `LOC6`"]
113 #[inline(always)]
114 pub fn is_loc6(&self) -> bool {
115 *self == CC0LOC_A::LOC6
116 }
117 #[doc = "Checks if the value of the field is `LOC7`"]
118 #[inline(always)]
119 pub fn is_loc7(&self) -> bool {
120 *self == CC0LOC_A::LOC7
121 }
122}
123#[doc = "Field `CC0LOC` writer - I/O Location"]
124pub type CC0LOC_W<'a> = crate::FieldWriter<'a, u32, ROUTELOC0_SPEC, u8, CC0LOC_A, 6, 0>;
125impl<'a> CC0LOC_W<'a> {
126 #[doc = "Location 0"]
127 #[inline(always)]
128 pub fn loc0(self) -> &'a mut W {
129 self.variant(CC0LOC_A::LOC0)
130 }
131 #[doc = "Location 1"]
132 #[inline(always)]
133 pub fn loc1(self) -> &'a mut W {
134 self.variant(CC0LOC_A::LOC1)
135 }
136 #[doc = "Location 2"]
137 #[inline(always)]
138 pub fn loc2(self) -> &'a mut W {
139 self.variant(CC0LOC_A::LOC2)
140 }
141 #[doc = "Location 3"]
142 #[inline(always)]
143 pub fn loc3(self) -> &'a mut W {
144 self.variant(CC0LOC_A::LOC3)
145 }
146 #[doc = "Location 4"]
147 #[inline(always)]
148 pub fn loc4(self) -> &'a mut W {
149 self.variant(CC0LOC_A::LOC4)
150 }
151 #[doc = "Location 5"]
152 #[inline(always)]
153 pub fn loc5(self) -> &'a mut W {
154 self.variant(CC0LOC_A::LOC5)
155 }
156 #[doc = "Location 6"]
157 #[inline(always)]
158 pub fn loc6(self) -> &'a mut W {
159 self.variant(CC0LOC_A::LOC6)
160 }
161 #[doc = "Location 7"]
162 #[inline(always)]
163 pub fn loc7(self) -> &'a mut W {
164 self.variant(CC0LOC_A::LOC7)
165 }
166}
167#[doc = "I/O Location\n\nValue on reset: 0"]
168#[derive(Clone, Copy, Debug, PartialEq)]
169#[repr(u8)]
170pub enum CC1LOC_A {
171 #[doc = "0: Location 0"]
172 LOC0 = 0,
173 #[doc = "1: Location 1"]
174 LOC1 = 1,
175 #[doc = "2: Location 2"]
176 LOC2 = 2,
177 #[doc = "3: Location 3"]
178 LOC3 = 3,
179 #[doc = "4: Location 4"]
180 LOC4 = 4,
181 #[doc = "5: Location 5"]
182 LOC5 = 5,
183 #[doc = "6: Location 6"]
184 LOC6 = 6,
185 #[doc = "7: Location 7"]
186 LOC7 = 7,
187}
188impl From<CC1LOC_A> for u8 {
189 #[inline(always)]
190 fn from(variant: CC1LOC_A) -> Self {
191 variant as _
192 }
193}
194#[doc = "Field `CC1LOC` reader - I/O Location"]
195pub type CC1LOC_R = crate::FieldReader<u8, CC1LOC_A>;
196impl CC1LOC_R {
197 #[doc = "Get enumerated values variant"]
198 #[inline(always)]
199 pub fn variant(&self) -> Option<CC1LOC_A> {
200 match self.bits {
201 0 => Some(CC1LOC_A::LOC0),
202 1 => Some(CC1LOC_A::LOC1),
203 2 => Some(CC1LOC_A::LOC2),
204 3 => Some(CC1LOC_A::LOC3),
205 4 => Some(CC1LOC_A::LOC4),
206 5 => Some(CC1LOC_A::LOC5),
207 6 => Some(CC1LOC_A::LOC6),
208 7 => Some(CC1LOC_A::LOC7),
209 _ => None,
210 }
211 }
212 #[doc = "Checks if the value of the field is `LOC0`"]
213 #[inline(always)]
214 pub fn is_loc0(&self) -> bool {
215 *self == CC1LOC_A::LOC0
216 }
217 #[doc = "Checks if the value of the field is `LOC1`"]
218 #[inline(always)]
219 pub fn is_loc1(&self) -> bool {
220 *self == CC1LOC_A::LOC1
221 }
222 #[doc = "Checks if the value of the field is `LOC2`"]
223 #[inline(always)]
224 pub fn is_loc2(&self) -> bool {
225 *self == CC1LOC_A::LOC2
226 }
227 #[doc = "Checks if the value of the field is `LOC3`"]
228 #[inline(always)]
229 pub fn is_loc3(&self) -> bool {
230 *self == CC1LOC_A::LOC3
231 }
232 #[doc = "Checks if the value of the field is `LOC4`"]
233 #[inline(always)]
234 pub fn is_loc4(&self) -> bool {
235 *self == CC1LOC_A::LOC4
236 }
237 #[doc = "Checks if the value of the field is `LOC5`"]
238 #[inline(always)]
239 pub fn is_loc5(&self) -> bool {
240 *self == CC1LOC_A::LOC5
241 }
242 #[doc = "Checks if the value of the field is `LOC6`"]
243 #[inline(always)]
244 pub fn is_loc6(&self) -> bool {
245 *self == CC1LOC_A::LOC6
246 }
247 #[doc = "Checks if the value of the field is `LOC7`"]
248 #[inline(always)]
249 pub fn is_loc7(&self) -> bool {
250 *self == CC1LOC_A::LOC7
251 }
252}
253#[doc = "Field `CC1LOC` writer - I/O Location"]
254pub type CC1LOC_W<'a> = crate::FieldWriter<'a, u32, ROUTELOC0_SPEC, u8, CC1LOC_A, 6, 8>;
255impl<'a> CC1LOC_W<'a> {
256 #[doc = "Location 0"]
257 #[inline(always)]
258 pub fn loc0(self) -> &'a mut W {
259 self.variant(CC1LOC_A::LOC0)
260 }
261 #[doc = "Location 1"]
262 #[inline(always)]
263 pub fn loc1(self) -> &'a mut W {
264 self.variant(CC1LOC_A::LOC1)
265 }
266 #[doc = "Location 2"]
267 #[inline(always)]
268 pub fn loc2(self) -> &'a mut W {
269 self.variant(CC1LOC_A::LOC2)
270 }
271 #[doc = "Location 3"]
272 #[inline(always)]
273 pub fn loc3(self) -> &'a mut W {
274 self.variant(CC1LOC_A::LOC3)
275 }
276 #[doc = "Location 4"]
277 #[inline(always)]
278 pub fn loc4(self) -> &'a mut W {
279 self.variant(CC1LOC_A::LOC4)
280 }
281 #[doc = "Location 5"]
282 #[inline(always)]
283 pub fn loc5(self) -> &'a mut W {
284 self.variant(CC1LOC_A::LOC5)
285 }
286 #[doc = "Location 6"]
287 #[inline(always)]
288 pub fn loc6(self) -> &'a mut W {
289 self.variant(CC1LOC_A::LOC6)
290 }
291 #[doc = "Location 7"]
292 #[inline(always)]
293 pub fn loc7(self) -> &'a mut W {
294 self.variant(CC1LOC_A::LOC7)
295 }
296}
297#[doc = "I/O Location\n\nValue on reset: 0"]
298#[derive(Clone, Copy, Debug, PartialEq)]
299#[repr(u8)]
300pub enum CC2LOC_A {
301 #[doc = "0: Location 0"]
302 LOC0 = 0,
303 #[doc = "1: Location 1"]
304 LOC1 = 1,
305 #[doc = "2: Location 2"]
306 LOC2 = 2,
307 #[doc = "3: Location 3"]
308 LOC3 = 3,
309 #[doc = "4: Location 4"]
310 LOC4 = 4,
311 #[doc = "5: Location 5"]
312 LOC5 = 5,
313 #[doc = "6: Location 6"]
314 LOC6 = 6,
315 #[doc = "7: Location 7"]
316 LOC7 = 7,
317}
318impl From<CC2LOC_A> for u8 {
319 #[inline(always)]
320 fn from(variant: CC2LOC_A) -> Self {
321 variant as _
322 }
323}
324#[doc = "Field `CC2LOC` reader - I/O Location"]
325pub type CC2LOC_R = crate::FieldReader<u8, CC2LOC_A>;
326impl CC2LOC_R {
327 #[doc = "Get enumerated values variant"]
328 #[inline(always)]
329 pub fn variant(&self) -> Option<CC2LOC_A> {
330 match self.bits {
331 0 => Some(CC2LOC_A::LOC0),
332 1 => Some(CC2LOC_A::LOC1),
333 2 => Some(CC2LOC_A::LOC2),
334 3 => Some(CC2LOC_A::LOC3),
335 4 => Some(CC2LOC_A::LOC4),
336 5 => Some(CC2LOC_A::LOC5),
337 6 => Some(CC2LOC_A::LOC6),
338 7 => Some(CC2LOC_A::LOC7),
339 _ => None,
340 }
341 }
342 #[doc = "Checks if the value of the field is `LOC0`"]
343 #[inline(always)]
344 pub fn is_loc0(&self) -> bool {
345 *self == CC2LOC_A::LOC0
346 }
347 #[doc = "Checks if the value of the field is `LOC1`"]
348 #[inline(always)]
349 pub fn is_loc1(&self) -> bool {
350 *self == CC2LOC_A::LOC1
351 }
352 #[doc = "Checks if the value of the field is `LOC2`"]
353 #[inline(always)]
354 pub fn is_loc2(&self) -> bool {
355 *self == CC2LOC_A::LOC2
356 }
357 #[doc = "Checks if the value of the field is `LOC3`"]
358 #[inline(always)]
359 pub fn is_loc3(&self) -> bool {
360 *self == CC2LOC_A::LOC3
361 }
362 #[doc = "Checks if the value of the field is `LOC4`"]
363 #[inline(always)]
364 pub fn is_loc4(&self) -> bool {
365 *self == CC2LOC_A::LOC4
366 }
367 #[doc = "Checks if the value of the field is `LOC5`"]
368 #[inline(always)]
369 pub fn is_loc5(&self) -> bool {
370 *self == CC2LOC_A::LOC5
371 }
372 #[doc = "Checks if the value of the field is `LOC6`"]
373 #[inline(always)]
374 pub fn is_loc6(&self) -> bool {
375 *self == CC2LOC_A::LOC6
376 }
377 #[doc = "Checks if the value of the field is `LOC7`"]
378 #[inline(always)]
379 pub fn is_loc7(&self) -> bool {
380 *self == CC2LOC_A::LOC7
381 }
382}
383#[doc = "Field `CC2LOC` writer - I/O Location"]
384pub type CC2LOC_W<'a> = crate::FieldWriter<'a, u32, ROUTELOC0_SPEC, u8, CC2LOC_A, 6, 16>;
385impl<'a> CC2LOC_W<'a> {
386 #[doc = "Location 0"]
387 #[inline(always)]
388 pub fn loc0(self) -> &'a mut W {
389 self.variant(CC2LOC_A::LOC0)
390 }
391 #[doc = "Location 1"]
392 #[inline(always)]
393 pub fn loc1(self) -> &'a mut W {
394 self.variant(CC2LOC_A::LOC1)
395 }
396 #[doc = "Location 2"]
397 #[inline(always)]
398 pub fn loc2(self) -> &'a mut W {
399 self.variant(CC2LOC_A::LOC2)
400 }
401 #[doc = "Location 3"]
402 #[inline(always)]
403 pub fn loc3(self) -> &'a mut W {
404 self.variant(CC2LOC_A::LOC3)
405 }
406 #[doc = "Location 4"]
407 #[inline(always)]
408 pub fn loc4(self) -> &'a mut W {
409 self.variant(CC2LOC_A::LOC4)
410 }
411 #[doc = "Location 5"]
412 #[inline(always)]
413 pub fn loc5(self) -> &'a mut W {
414 self.variant(CC2LOC_A::LOC5)
415 }
416 #[doc = "Location 6"]
417 #[inline(always)]
418 pub fn loc6(self) -> &'a mut W {
419 self.variant(CC2LOC_A::LOC6)
420 }
421 #[doc = "Location 7"]
422 #[inline(always)]
423 pub fn loc7(self) -> &'a mut W {
424 self.variant(CC2LOC_A::LOC7)
425 }
426}
427#[doc = "I/O Location\n\nValue on reset: 0"]
428#[derive(Clone, Copy, Debug, PartialEq)]
429#[repr(u8)]
430pub enum CC3LOC_A {
431 #[doc = "0: Location 0"]
432 LOC0 = 0,
433 #[doc = "1: Location 1"]
434 LOC1 = 1,
435 #[doc = "2: Location 2"]
436 LOC2 = 2,
437 #[doc = "3: Location 3"]
438 LOC3 = 3,
439 #[doc = "4: Location 4"]
440 LOC4 = 4,
441 #[doc = "5: Location 5"]
442 LOC5 = 5,
443 #[doc = "6: Location 6"]
444 LOC6 = 6,
445}
446impl From<CC3LOC_A> for u8 {
447 #[inline(always)]
448 fn from(variant: CC3LOC_A) -> Self {
449 variant as _
450 }
451}
452#[doc = "Field `CC3LOC` reader - I/O Location"]
453pub type CC3LOC_R = crate::FieldReader<u8, CC3LOC_A>;
454impl CC3LOC_R {
455 #[doc = "Get enumerated values variant"]
456 #[inline(always)]
457 pub fn variant(&self) -> Option<CC3LOC_A> {
458 match self.bits {
459 0 => Some(CC3LOC_A::LOC0),
460 1 => Some(CC3LOC_A::LOC1),
461 2 => Some(CC3LOC_A::LOC2),
462 3 => Some(CC3LOC_A::LOC3),
463 4 => Some(CC3LOC_A::LOC4),
464 5 => Some(CC3LOC_A::LOC5),
465 6 => Some(CC3LOC_A::LOC6),
466 _ => None,
467 }
468 }
469 #[doc = "Checks if the value of the field is `LOC0`"]
470 #[inline(always)]
471 pub fn is_loc0(&self) -> bool {
472 *self == CC3LOC_A::LOC0
473 }
474 #[doc = "Checks if the value of the field is `LOC1`"]
475 #[inline(always)]
476 pub fn is_loc1(&self) -> bool {
477 *self == CC3LOC_A::LOC1
478 }
479 #[doc = "Checks if the value of the field is `LOC2`"]
480 #[inline(always)]
481 pub fn is_loc2(&self) -> bool {
482 *self == CC3LOC_A::LOC2
483 }
484 #[doc = "Checks if the value of the field is `LOC3`"]
485 #[inline(always)]
486 pub fn is_loc3(&self) -> bool {
487 *self == CC3LOC_A::LOC3
488 }
489 #[doc = "Checks if the value of the field is `LOC4`"]
490 #[inline(always)]
491 pub fn is_loc4(&self) -> bool {
492 *self == CC3LOC_A::LOC4
493 }
494 #[doc = "Checks if the value of the field is `LOC5`"]
495 #[inline(always)]
496 pub fn is_loc5(&self) -> bool {
497 *self == CC3LOC_A::LOC5
498 }
499 #[doc = "Checks if the value of the field is `LOC6`"]
500 #[inline(always)]
501 pub fn is_loc6(&self) -> bool {
502 *self == CC3LOC_A::LOC6
503 }
504}
505#[doc = "Field `CC3LOC` writer - I/O Location"]
506pub type CC3LOC_W<'a> = crate::FieldWriter<'a, u32, ROUTELOC0_SPEC, u8, CC3LOC_A, 6, 24>;
507impl<'a> CC3LOC_W<'a> {
508 #[doc = "Location 0"]
509 #[inline(always)]
510 pub fn loc0(self) -> &'a mut W {
511 self.variant(CC3LOC_A::LOC0)
512 }
513 #[doc = "Location 1"]
514 #[inline(always)]
515 pub fn loc1(self) -> &'a mut W {
516 self.variant(CC3LOC_A::LOC1)
517 }
518 #[doc = "Location 2"]
519 #[inline(always)]
520 pub fn loc2(self) -> &'a mut W {
521 self.variant(CC3LOC_A::LOC2)
522 }
523 #[doc = "Location 3"]
524 #[inline(always)]
525 pub fn loc3(self) -> &'a mut W {
526 self.variant(CC3LOC_A::LOC3)
527 }
528 #[doc = "Location 4"]
529 #[inline(always)]
530 pub fn loc4(self) -> &'a mut W {
531 self.variant(CC3LOC_A::LOC4)
532 }
533 #[doc = "Location 5"]
534 #[inline(always)]
535 pub fn loc5(self) -> &'a mut W {
536 self.variant(CC3LOC_A::LOC5)
537 }
538 #[doc = "Location 6"]
539 #[inline(always)]
540 pub fn loc6(self) -> &'a mut W {
541 self.variant(CC3LOC_A::LOC6)
542 }
543}
544impl R {
545 #[doc = "Bits 0:5 - I/O Location"]
546 #[inline(always)]
547 pub fn cc0loc(&self) -> CC0LOC_R {
548 CC0LOC_R::new((self.bits & 0x3f) as u8)
549 }
550 #[doc = "Bits 8:13 - I/O Location"]
551 #[inline(always)]
552 pub fn cc1loc(&self) -> CC1LOC_R {
553 CC1LOC_R::new(((self.bits >> 8) & 0x3f) as u8)
554 }
555 #[doc = "Bits 16:21 - I/O Location"]
556 #[inline(always)]
557 pub fn cc2loc(&self) -> CC2LOC_R {
558 CC2LOC_R::new(((self.bits >> 16) & 0x3f) as u8)
559 }
560 #[doc = "Bits 24:29 - I/O Location"]
561 #[inline(always)]
562 pub fn cc3loc(&self) -> CC3LOC_R {
563 CC3LOC_R::new(((self.bits >> 24) & 0x3f) as u8)
564 }
565}
566impl W {
567 #[doc = "Bits 0:5 - I/O Location"]
568 #[inline(always)]
569 pub fn cc0loc(&mut self) -> CC0LOC_W {
570 CC0LOC_W::new(self)
571 }
572 #[doc = "Bits 8:13 - I/O Location"]
573 #[inline(always)]
574 pub fn cc1loc(&mut self) -> CC1LOC_W {
575 CC1LOC_W::new(self)
576 }
577 #[doc = "Bits 16:21 - I/O Location"]
578 #[inline(always)]
579 pub fn cc2loc(&mut self) -> CC2LOC_W {
580 CC2LOC_W::new(self)
581 }
582 #[doc = "Bits 24:29 - I/O Location"]
583 #[inline(always)]
584 pub fn cc3loc(&mut self) -> CC3LOC_W {
585 CC3LOC_W::new(self)
586 }
587 #[doc = "Writes raw bits to the register."]
588 #[inline(always)]
589 pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
590 self.0.bits(bits);
591 self
592 }
593}
594#[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"]
595pub struct ROUTELOC0_SPEC;
596impl crate::RegisterSpec for ROUTELOC0_SPEC {
597 type Ux = u32;
598}
599#[doc = "`read()` method returns [routeloc0::R](R) reader structure"]
600impl crate::Readable for ROUTELOC0_SPEC {
601 type Reader = R;
602}
603#[doc = "`write(|w| ..)` method takes [routeloc0::W](W) writer structure"]
604impl crate::Writable for ROUTELOC0_SPEC {
605 type Writer = W;
606}
607#[doc = "`reset()` method sets ROUTELOC0 to value 0"]
608impl crate::Resettable for ROUTELOC0_SPEC {
609 #[inline(always)]
610 fn reset_value() -> Self::Ux {
611 0
612 }
613}