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