1#[doc = "Register `GTICLF` reader"]
2pub struct R(crate::R<GTICLF_SPEC>);
3impl core::ops::Deref for R {
4 type Target = crate::R<GTICLF_SPEC>;
5 #[inline(always)]
6 fn deref(&self) -> &Self::Target {
7 &self.0
8 }
9}
10impl From<crate::R<GTICLF_SPEC>> for R {
11 #[inline(always)]
12 fn from(reader: crate::R<GTICLF_SPEC>) -> Self {
13 R(reader)
14 }
15}
16#[doc = "Register `GTICLF` writer"]
17pub struct W(crate::W<GTICLF_SPEC>);
18impl core::ops::Deref for W {
19 type Target = crate::W<GTICLF_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<GTICLF_SPEC>> for W {
32 #[inline(always)]
33 fn from(writer: crate::W<GTICLF_SPEC>) -> Self {
34 W(writer)
35 }
36}
37#[doc = "Field `ICLFA` reader - GTIOCnA Output Logical Operation Function Select"]
38pub type ICLFA_R = crate::FieldReader<u8, ICLFA_A>;
39#[doc = "GTIOCnA Output Logical Operation Function Select\n\nValue on reset: 0"]
40#[derive(Clone, Copy, Debug, PartialEq, Eq)]
41#[repr(u8)]
42pub enum ICLFA_A {
43 #[doc = "0: A (no delay)"]
44 _000 = 0,
45 #[doc = "1: NOT A (no delay)"]
46 _001 = 1,
47 #[doc = "2: C (1PCLKD delay)"]
48 _010 = 2,
49 #[doc = "3: NOT C (1PCLKD delay)"]
50 _011 = 3,
51 #[doc = "4: A AND C (1PCLKD delay)"]
52 _100 = 4,
53 #[doc = "5: A OR C (1PCLKD delay)"]
54 _101 = 5,
55 #[doc = "6: A EXOR C (1PCLKD delay)"]
56 _110 = 6,
57 #[doc = "7: A NOR C (1PCLKD delay)"]
58 _111 = 7,
59}
60impl From<ICLFA_A> for u8 {
61 #[inline(always)]
62 fn from(variant: ICLFA_A) -> Self {
63 variant as _
64 }
65}
66impl ICLFA_R {
67 #[doc = "Get enumerated values variant"]
68 #[inline(always)]
69 pub fn variant(&self) -> ICLFA_A {
70 match self.bits {
71 0 => ICLFA_A::_000,
72 1 => ICLFA_A::_001,
73 2 => ICLFA_A::_010,
74 3 => ICLFA_A::_011,
75 4 => ICLFA_A::_100,
76 5 => ICLFA_A::_101,
77 6 => ICLFA_A::_110,
78 7 => ICLFA_A::_111,
79 _ => unreachable!(),
80 }
81 }
82 #[doc = "Checks if the value of the field is `_000`"]
83 #[inline(always)]
84 pub fn is_000(&self) -> bool {
85 *self == ICLFA_A::_000
86 }
87 #[doc = "Checks if the value of the field is `_001`"]
88 #[inline(always)]
89 pub fn is_001(&self) -> bool {
90 *self == ICLFA_A::_001
91 }
92 #[doc = "Checks if the value of the field is `_010`"]
93 #[inline(always)]
94 pub fn is_010(&self) -> bool {
95 *self == ICLFA_A::_010
96 }
97 #[doc = "Checks if the value of the field is `_011`"]
98 #[inline(always)]
99 pub fn is_011(&self) -> bool {
100 *self == ICLFA_A::_011
101 }
102 #[doc = "Checks if the value of the field is `_100`"]
103 #[inline(always)]
104 pub fn is_100(&self) -> bool {
105 *self == ICLFA_A::_100
106 }
107 #[doc = "Checks if the value of the field is `_101`"]
108 #[inline(always)]
109 pub fn is_101(&self) -> bool {
110 *self == ICLFA_A::_101
111 }
112 #[doc = "Checks if the value of the field is `_110`"]
113 #[inline(always)]
114 pub fn is_110(&self) -> bool {
115 *self == ICLFA_A::_110
116 }
117 #[doc = "Checks if the value of the field is `_111`"]
118 #[inline(always)]
119 pub fn is_111(&self) -> bool {
120 *self == ICLFA_A::_111
121 }
122}
123#[doc = "Field `ICLFA` writer - GTIOCnA Output Logical Operation Function Select"]
124pub type ICLFA_W<'a, const O: u8> = crate::FieldWriterSafe<'a, u32, GTICLF_SPEC, u8, ICLFA_A, 3, O>;
125impl<'a, const O: u8> ICLFA_W<'a, O> {
126 #[doc = "A (no delay)"]
127 #[inline(always)]
128 pub fn _000(self) -> &'a mut W {
129 self.variant(ICLFA_A::_000)
130 }
131 #[doc = "NOT A (no delay)"]
132 #[inline(always)]
133 pub fn _001(self) -> &'a mut W {
134 self.variant(ICLFA_A::_001)
135 }
136 #[doc = "C (1PCLKD delay)"]
137 #[inline(always)]
138 pub fn _010(self) -> &'a mut W {
139 self.variant(ICLFA_A::_010)
140 }
141 #[doc = "NOT C (1PCLKD delay)"]
142 #[inline(always)]
143 pub fn _011(self) -> &'a mut W {
144 self.variant(ICLFA_A::_011)
145 }
146 #[doc = "A AND C (1PCLKD delay)"]
147 #[inline(always)]
148 pub fn _100(self) -> &'a mut W {
149 self.variant(ICLFA_A::_100)
150 }
151 #[doc = "A OR C (1PCLKD delay)"]
152 #[inline(always)]
153 pub fn _101(self) -> &'a mut W {
154 self.variant(ICLFA_A::_101)
155 }
156 #[doc = "A EXOR C (1PCLKD delay)"]
157 #[inline(always)]
158 pub fn _110(self) -> &'a mut W {
159 self.variant(ICLFA_A::_110)
160 }
161 #[doc = "A NOR C (1PCLKD delay)"]
162 #[inline(always)]
163 pub fn _111(self) -> &'a mut W {
164 self.variant(ICLFA_A::_111)
165 }
166}
167#[doc = "Field `ICLFSELC` reader - Inter Channel Signal C Select"]
168pub type ICLFSELC_R = crate::FieldReader<u8, ICLFSELC_A>;
169#[doc = "Inter Channel Signal C Select\n\nValue on reset: 0"]
170#[derive(Clone, Copy, Debug, PartialEq, Eq)]
171#[repr(u8)]
172pub enum ICLFSELC_A {
173 #[doc = "0: GTIOC0A"]
174 _0X00 = 0,
175 #[doc = "1: GTIOC0B"]
176 _0X01 = 1,
177 #[doc = "2: GTIOC1A"]
178 _0X02 = 2,
179 #[doc = "3: GTIOC1B"]
180 _0X03 = 3,
181 #[doc = "4: GTIOC2A"]
182 _0X04 = 4,
183 #[doc = "5: GTIOC2B"]
184 _0X05 = 5,
185 #[doc = "6: GTIOC3A"]
186 _0X06 = 6,
187 #[doc = "7: GTIOC3B"]
188 _0X07 = 7,
189 #[doc = "8: GTIOC4A"]
190 _0X08 = 8,
191 #[doc = "9: GTIOC4B"]
192 _0X09 = 9,
193 #[doc = "10: GTIOC5A"]
194 _0X0A = 10,
195 #[doc = "11: GTIOC5B"]
196 _0X0B = 11,
197 #[doc = "12: GTIOC6A"]
198 _0X0C = 12,
199 #[doc = "13: GTIOC6B"]
200 _0X0D = 13,
201 #[doc = "14: GTIOC7A"]
202 _0X0E = 14,
203 #[doc = "15: GTIOC7B"]
204 _0X0F = 15,
205 #[doc = "16: GTIOC8A"]
206 _0X10 = 16,
207 #[doc = "17: GTIOC8B"]
208 _0X11 = 17,
209 #[doc = "18: GTIOC9A"]
210 _0X12 = 18,
211 #[doc = "19: GTIOC9B"]
212 _0X13 = 19,
213}
214impl From<ICLFSELC_A> for u8 {
215 #[inline(always)]
216 fn from(variant: ICLFSELC_A) -> Self {
217 variant as _
218 }
219}
220impl ICLFSELC_R {
221 #[doc = "Get enumerated values variant"]
222 #[inline(always)]
223 pub fn variant(&self) -> Option<ICLFSELC_A> {
224 match self.bits {
225 0 => Some(ICLFSELC_A::_0X00),
226 1 => Some(ICLFSELC_A::_0X01),
227 2 => Some(ICLFSELC_A::_0X02),
228 3 => Some(ICLFSELC_A::_0X03),
229 4 => Some(ICLFSELC_A::_0X04),
230 5 => Some(ICLFSELC_A::_0X05),
231 6 => Some(ICLFSELC_A::_0X06),
232 7 => Some(ICLFSELC_A::_0X07),
233 8 => Some(ICLFSELC_A::_0X08),
234 9 => Some(ICLFSELC_A::_0X09),
235 10 => Some(ICLFSELC_A::_0X0A),
236 11 => Some(ICLFSELC_A::_0X0B),
237 12 => Some(ICLFSELC_A::_0X0C),
238 13 => Some(ICLFSELC_A::_0X0D),
239 14 => Some(ICLFSELC_A::_0X0E),
240 15 => Some(ICLFSELC_A::_0X0F),
241 16 => Some(ICLFSELC_A::_0X10),
242 17 => Some(ICLFSELC_A::_0X11),
243 18 => Some(ICLFSELC_A::_0X12),
244 19 => Some(ICLFSELC_A::_0X13),
245 _ => None,
246 }
247 }
248 #[doc = "Checks if the value of the field is `_0X00`"]
249 #[inline(always)]
250 pub fn is_0x00(&self) -> bool {
251 *self == ICLFSELC_A::_0X00
252 }
253 #[doc = "Checks if the value of the field is `_0X01`"]
254 #[inline(always)]
255 pub fn is_0x01(&self) -> bool {
256 *self == ICLFSELC_A::_0X01
257 }
258 #[doc = "Checks if the value of the field is `_0X02`"]
259 #[inline(always)]
260 pub fn is_0x02(&self) -> bool {
261 *self == ICLFSELC_A::_0X02
262 }
263 #[doc = "Checks if the value of the field is `_0X03`"]
264 #[inline(always)]
265 pub fn is_0x03(&self) -> bool {
266 *self == ICLFSELC_A::_0X03
267 }
268 #[doc = "Checks if the value of the field is `_0X04`"]
269 #[inline(always)]
270 pub fn is_0x04(&self) -> bool {
271 *self == ICLFSELC_A::_0X04
272 }
273 #[doc = "Checks if the value of the field is `_0X05`"]
274 #[inline(always)]
275 pub fn is_0x05(&self) -> bool {
276 *self == ICLFSELC_A::_0X05
277 }
278 #[doc = "Checks if the value of the field is `_0X06`"]
279 #[inline(always)]
280 pub fn is_0x06(&self) -> bool {
281 *self == ICLFSELC_A::_0X06
282 }
283 #[doc = "Checks if the value of the field is `_0X07`"]
284 #[inline(always)]
285 pub fn is_0x07(&self) -> bool {
286 *self == ICLFSELC_A::_0X07
287 }
288 #[doc = "Checks if the value of the field is `_0X08`"]
289 #[inline(always)]
290 pub fn is_0x08(&self) -> bool {
291 *self == ICLFSELC_A::_0X08
292 }
293 #[doc = "Checks if the value of the field is `_0X09`"]
294 #[inline(always)]
295 pub fn is_0x09(&self) -> bool {
296 *self == ICLFSELC_A::_0X09
297 }
298 #[doc = "Checks if the value of the field is `_0X0A`"]
299 #[inline(always)]
300 pub fn is_0x0a(&self) -> bool {
301 *self == ICLFSELC_A::_0X0A
302 }
303 #[doc = "Checks if the value of the field is `_0X0B`"]
304 #[inline(always)]
305 pub fn is_0x0b(&self) -> bool {
306 *self == ICLFSELC_A::_0X0B
307 }
308 #[doc = "Checks if the value of the field is `_0X0C`"]
309 #[inline(always)]
310 pub fn is_0x0c(&self) -> bool {
311 *self == ICLFSELC_A::_0X0C
312 }
313 #[doc = "Checks if the value of the field is `_0X0D`"]
314 #[inline(always)]
315 pub fn is_0x0d(&self) -> bool {
316 *self == ICLFSELC_A::_0X0D
317 }
318 #[doc = "Checks if the value of the field is `_0X0E`"]
319 #[inline(always)]
320 pub fn is_0x0e(&self) -> bool {
321 *self == ICLFSELC_A::_0X0E
322 }
323 #[doc = "Checks if the value of the field is `_0X0F`"]
324 #[inline(always)]
325 pub fn is_0x0f(&self) -> bool {
326 *self == ICLFSELC_A::_0X0F
327 }
328 #[doc = "Checks if the value of the field is `_0X10`"]
329 #[inline(always)]
330 pub fn is_0x10(&self) -> bool {
331 *self == ICLFSELC_A::_0X10
332 }
333 #[doc = "Checks if the value of the field is `_0X11`"]
334 #[inline(always)]
335 pub fn is_0x11(&self) -> bool {
336 *self == ICLFSELC_A::_0X11
337 }
338 #[doc = "Checks if the value of the field is `_0X12`"]
339 #[inline(always)]
340 pub fn is_0x12(&self) -> bool {
341 *self == ICLFSELC_A::_0X12
342 }
343 #[doc = "Checks if the value of the field is `_0X13`"]
344 #[inline(always)]
345 pub fn is_0x13(&self) -> bool {
346 *self == ICLFSELC_A::_0X13
347 }
348}
349#[doc = "Field `ICLFSELC` writer - Inter Channel Signal C Select"]
350pub type ICLFSELC_W<'a, const O: u8> =
351 crate::FieldWriter<'a, u32, GTICLF_SPEC, u8, ICLFSELC_A, 6, O>;
352impl<'a, const O: u8> ICLFSELC_W<'a, O> {
353 #[doc = "GTIOC0A"]
354 #[inline(always)]
355 pub fn _0x00(self) -> &'a mut W {
356 self.variant(ICLFSELC_A::_0X00)
357 }
358 #[doc = "GTIOC0B"]
359 #[inline(always)]
360 pub fn _0x01(self) -> &'a mut W {
361 self.variant(ICLFSELC_A::_0X01)
362 }
363 #[doc = "GTIOC1A"]
364 #[inline(always)]
365 pub fn _0x02(self) -> &'a mut W {
366 self.variant(ICLFSELC_A::_0X02)
367 }
368 #[doc = "GTIOC1B"]
369 #[inline(always)]
370 pub fn _0x03(self) -> &'a mut W {
371 self.variant(ICLFSELC_A::_0X03)
372 }
373 #[doc = "GTIOC2A"]
374 #[inline(always)]
375 pub fn _0x04(self) -> &'a mut W {
376 self.variant(ICLFSELC_A::_0X04)
377 }
378 #[doc = "GTIOC2B"]
379 #[inline(always)]
380 pub fn _0x05(self) -> &'a mut W {
381 self.variant(ICLFSELC_A::_0X05)
382 }
383 #[doc = "GTIOC3A"]
384 #[inline(always)]
385 pub fn _0x06(self) -> &'a mut W {
386 self.variant(ICLFSELC_A::_0X06)
387 }
388 #[doc = "GTIOC3B"]
389 #[inline(always)]
390 pub fn _0x07(self) -> &'a mut W {
391 self.variant(ICLFSELC_A::_0X07)
392 }
393 #[doc = "GTIOC4A"]
394 #[inline(always)]
395 pub fn _0x08(self) -> &'a mut W {
396 self.variant(ICLFSELC_A::_0X08)
397 }
398 #[doc = "GTIOC4B"]
399 #[inline(always)]
400 pub fn _0x09(self) -> &'a mut W {
401 self.variant(ICLFSELC_A::_0X09)
402 }
403 #[doc = "GTIOC5A"]
404 #[inline(always)]
405 pub fn _0x0a(self) -> &'a mut W {
406 self.variant(ICLFSELC_A::_0X0A)
407 }
408 #[doc = "GTIOC5B"]
409 #[inline(always)]
410 pub fn _0x0b(self) -> &'a mut W {
411 self.variant(ICLFSELC_A::_0X0B)
412 }
413 #[doc = "GTIOC6A"]
414 #[inline(always)]
415 pub fn _0x0c(self) -> &'a mut W {
416 self.variant(ICLFSELC_A::_0X0C)
417 }
418 #[doc = "GTIOC6B"]
419 #[inline(always)]
420 pub fn _0x0d(self) -> &'a mut W {
421 self.variant(ICLFSELC_A::_0X0D)
422 }
423 #[doc = "GTIOC7A"]
424 #[inline(always)]
425 pub fn _0x0e(self) -> &'a mut W {
426 self.variant(ICLFSELC_A::_0X0E)
427 }
428 #[doc = "GTIOC7B"]
429 #[inline(always)]
430 pub fn _0x0f(self) -> &'a mut W {
431 self.variant(ICLFSELC_A::_0X0F)
432 }
433 #[doc = "GTIOC8A"]
434 #[inline(always)]
435 pub fn _0x10(self) -> &'a mut W {
436 self.variant(ICLFSELC_A::_0X10)
437 }
438 #[doc = "GTIOC8B"]
439 #[inline(always)]
440 pub fn _0x11(self) -> &'a mut W {
441 self.variant(ICLFSELC_A::_0X11)
442 }
443 #[doc = "GTIOC9A"]
444 #[inline(always)]
445 pub fn _0x12(self) -> &'a mut W {
446 self.variant(ICLFSELC_A::_0X12)
447 }
448 #[doc = "GTIOC9B"]
449 #[inline(always)]
450 pub fn _0x13(self) -> &'a mut W {
451 self.variant(ICLFSELC_A::_0X13)
452 }
453}
454#[doc = "Field `ICLFB` reader - GTIOCnB Output Logical Operation Function Select"]
455pub type ICLFB_R = crate::FieldReader<u8, ICLFB_A>;
456#[doc = "GTIOCnB Output Logical Operation Function Select\n\nValue on reset: 0"]
457#[derive(Clone, Copy, Debug, PartialEq, Eq)]
458#[repr(u8)]
459pub enum ICLFB_A {
460 #[doc = "0: B (no delay)"]
461 _000 = 0,
462 #[doc = "1: NOT B (no delay)"]
463 _001 = 1,
464 #[doc = "2: D (1PCLKD delay)"]
465 _010 = 2,
466 #[doc = "3: NOT D (1PCLKD delay)"]
467 _011 = 3,
468 #[doc = "4: B AND D (1PCLKD delay)"]
469 _100 = 4,
470 #[doc = "5: B OR D (1PCLKDn delay)"]
471 _101 = 5,
472 #[doc = "6: B EXOR D (1PCLKD delay)"]
473 _110 = 6,
474 #[doc = "7: B NOR D (1PCLKD delay)"]
475 _111 = 7,
476}
477impl From<ICLFB_A> for u8 {
478 #[inline(always)]
479 fn from(variant: ICLFB_A) -> Self {
480 variant as _
481 }
482}
483impl ICLFB_R {
484 #[doc = "Get enumerated values variant"]
485 #[inline(always)]
486 pub fn variant(&self) -> ICLFB_A {
487 match self.bits {
488 0 => ICLFB_A::_000,
489 1 => ICLFB_A::_001,
490 2 => ICLFB_A::_010,
491 3 => ICLFB_A::_011,
492 4 => ICLFB_A::_100,
493 5 => ICLFB_A::_101,
494 6 => ICLFB_A::_110,
495 7 => ICLFB_A::_111,
496 _ => unreachable!(),
497 }
498 }
499 #[doc = "Checks if the value of the field is `_000`"]
500 #[inline(always)]
501 pub fn is_000(&self) -> bool {
502 *self == ICLFB_A::_000
503 }
504 #[doc = "Checks if the value of the field is `_001`"]
505 #[inline(always)]
506 pub fn is_001(&self) -> bool {
507 *self == ICLFB_A::_001
508 }
509 #[doc = "Checks if the value of the field is `_010`"]
510 #[inline(always)]
511 pub fn is_010(&self) -> bool {
512 *self == ICLFB_A::_010
513 }
514 #[doc = "Checks if the value of the field is `_011`"]
515 #[inline(always)]
516 pub fn is_011(&self) -> bool {
517 *self == ICLFB_A::_011
518 }
519 #[doc = "Checks if the value of the field is `_100`"]
520 #[inline(always)]
521 pub fn is_100(&self) -> bool {
522 *self == ICLFB_A::_100
523 }
524 #[doc = "Checks if the value of the field is `_101`"]
525 #[inline(always)]
526 pub fn is_101(&self) -> bool {
527 *self == ICLFB_A::_101
528 }
529 #[doc = "Checks if the value of the field is `_110`"]
530 #[inline(always)]
531 pub fn is_110(&self) -> bool {
532 *self == ICLFB_A::_110
533 }
534 #[doc = "Checks if the value of the field is `_111`"]
535 #[inline(always)]
536 pub fn is_111(&self) -> bool {
537 *self == ICLFB_A::_111
538 }
539}
540#[doc = "Field `ICLFB` writer - GTIOCnB Output Logical Operation Function Select"]
541pub type ICLFB_W<'a, const O: u8> = crate::FieldWriterSafe<'a, u32, GTICLF_SPEC, u8, ICLFB_A, 3, O>;
542impl<'a, const O: u8> ICLFB_W<'a, O> {
543 #[doc = "B (no delay)"]
544 #[inline(always)]
545 pub fn _000(self) -> &'a mut W {
546 self.variant(ICLFB_A::_000)
547 }
548 #[doc = "NOT B (no delay)"]
549 #[inline(always)]
550 pub fn _001(self) -> &'a mut W {
551 self.variant(ICLFB_A::_001)
552 }
553 #[doc = "D (1PCLKD delay)"]
554 #[inline(always)]
555 pub fn _010(self) -> &'a mut W {
556 self.variant(ICLFB_A::_010)
557 }
558 #[doc = "NOT D (1PCLKD delay)"]
559 #[inline(always)]
560 pub fn _011(self) -> &'a mut W {
561 self.variant(ICLFB_A::_011)
562 }
563 #[doc = "B AND D (1PCLKD delay)"]
564 #[inline(always)]
565 pub fn _100(self) -> &'a mut W {
566 self.variant(ICLFB_A::_100)
567 }
568 #[doc = "B OR D (1PCLKDn delay)"]
569 #[inline(always)]
570 pub fn _101(self) -> &'a mut W {
571 self.variant(ICLFB_A::_101)
572 }
573 #[doc = "B EXOR D (1PCLKD delay)"]
574 #[inline(always)]
575 pub fn _110(self) -> &'a mut W {
576 self.variant(ICLFB_A::_110)
577 }
578 #[doc = "B NOR D (1PCLKD delay)"]
579 #[inline(always)]
580 pub fn _111(self) -> &'a mut W {
581 self.variant(ICLFB_A::_111)
582 }
583}
584#[doc = "Field `ICLFSELD` reader - Inter Channel Signal D Select"]
585pub type ICLFSELD_R = crate::FieldReader<u8, ICLFSELD_A>;
586#[doc = "Inter Channel Signal D Select\n\nValue on reset: 0"]
587#[derive(Clone, Copy, Debug, PartialEq, Eq)]
588#[repr(u8)]
589pub enum ICLFSELD_A {
590 #[doc = "0: GTIOC0A"]
591 _0X00 = 0,
592 #[doc = "1: GTIOC0B"]
593 _0X01 = 1,
594 #[doc = "2: GTIOC1A"]
595 _0X02 = 2,
596 #[doc = "3: GTIOC1B"]
597 _0X03 = 3,
598 #[doc = "4: GTIOC2A"]
599 _0X04 = 4,
600 #[doc = "5: GTIOC2B"]
601 _0X05 = 5,
602 #[doc = "6: GTIOC3A"]
603 _0X06 = 6,
604 #[doc = "7: GTIOC3B"]
605 _0X07 = 7,
606 #[doc = "8: GTIOC4A"]
607 _0X08 = 8,
608 #[doc = "9: GTIOC4B"]
609 _0X09 = 9,
610 #[doc = "10: GTIOC5A"]
611 _0X0A = 10,
612 #[doc = "11: GTIOC5B"]
613 _0X0B = 11,
614 #[doc = "12: GTIOC6A"]
615 _0X0C = 12,
616 #[doc = "13: GTIOC6B"]
617 _0X0D = 13,
618 #[doc = "14: GTIOC7A"]
619 _0X0E = 14,
620 #[doc = "15: GTIOC7B"]
621 _0X0F = 15,
622 #[doc = "16: GTIOC8A"]
623 _0X10 = 16,
624 #[doc = "17: GTIOC8B"]
625 _0X11 = 17,
626 #[doc = "18: GTIOC9A"]
627 _0X12 = 18,
628 #[doc = "19: GTIOC9B"]
629 _0X13 = 19,
630}
631impl From<ICLFSELD_A> for u8 {
632 #[inline(always)]
633 fn from(variant: ICLFSELD_A) -> Self {
634 variant as _
635 }
636}
637impl ICLFSELD_R {
638 #[doc = "Get enumerated values variant"]
639 #[inline(always)]
640 pub fn variant(&self) -> Option<ICLFSELD_A> {
641 match self.bits {
642 0 => Some(ICLFSELD_A::_0X00),
643 1 => Some(ICLFSELD_A::_0X01),
644 2 => Some(ICLFSELD_A::_0X02),
645 3 => Some(ICLFSELD_A::_0X03),
646 4 => Some(ICLFSELD_A::_0X04),
647 5 => Some(ICLFSELD_A::_0X05),
648 6 => Some(ICLFSELD_A::_0X06),
649 7 => Some(ICLFSELD_A::_0X07),
650 8 => Some(ICLFSELD_A::_0X08),
651 9 => Some(ICLFSELD_A::_0X09),
652 10 => Some(ICLFSELD_A::_0X0A),
653 11 => Some(ICLFSELD_A::_0X0B),
654 12 => Some(ICLFSELD_A::_0X0C),
655 13 => Some(ICLFSELD_A::_0X0D),
656 14 => Some(ICLFSELD_A::_0X0E),
657 15 => Some(ICLFSELD_A::_0X0F),
658 16 => Some(ICLFSELD_A::_0X10),
659 17 => Some(ICLFSELD_A::_0X11),
660 18 => Some(ICLFSELD_A::_0X12),
661 19 => Some(ICLFSELD_A::_0X13),
662 _ => None,
663 }
664 }
665 #[doc = "Checks if the value of the field is `_0X00`"]
666 #[inline(always)]
667 pub fn is_0x00(&self) -> bool {
668 *self == ICLFSELD_A::_0X00
669 }
670 #[doc = "Checks if the value of the field is `_0X01`"]
671 #[inline(always)]
672 pub fn is_0x01(&self) -> bool {
673 *self == ICLFSELD_A::_0X01
674 }
675 #[doc = "Checks if the value of the field is `_0X02`"]
676 #[inline(always)]
677 pub fn is_0x02(&self) -> bool {
678 *self == ICLFSELD_A::_0X02
679 }
680 #[doc = "Checks if the value of the field is `_0X03`"]
681 #[inline(always)]
682 pub fn is_0x03(&self) -> bool {
683 *self == ICLFSELD_A::_0X03
684 }
685 #[doc = "Checks if the value of the field is `_0X04`"]
686 #[inline(always)]
687 pub fn is_0x04(&self) -> bool {
688 *self == ICLFSELD_A::_0X04
689 }
690 #[doc = "Checks if the value of the field is `_0X05`"]
691 #[inline(always)]
692 pub fn is_0x05(&self) -> bool {
693 *self == ICLFSELD_A::_0X05
694 }
695 #[doc = "Checks if the value of the field is `_0X06`"]
696 #[inline(always)]
697 pub fn is_0x06(&self) -> bool {
698 *self == ICLFSELD_A::_0X06
699 }
700 #[doc = "Checks if the value of the field is `_0X07`"]
701 #[inline(always)]
702 pub fn is_0x07(&self) -> bool {
703 *self == ICLFSELD_A::_0X07
704 }
705 #[doc = "Checks if the value of the field is `_0X08`"]
706 #[inline(always)]
707 pub fn is_0x08(&self) -> bool {
708 *self == ICLFSELD_A::_0X08
709 }
710 #[doc = "Checks if the value of the field is `_0X09`"]
711 #[inline(always)]
712 pub fn is_0x09(&self) -> bool {
713 *self == ICLFSELD_A::_0X09
714 }
715 #[doc = "Checks if the value of the field is `_0X0A`"]
716 #[inline(always)]
717 pub fn is_0x0a(&self) -> bool {
718 *self == ICLFSELD_A::_0X0A
719 }
720 #[doc = "Checks if the value of the field is `_0X0B`"]
721 #[inline(always)]
722 pub fn is_0x0b(&self) -> bool {
723 *self == ICLFSELD_A::_0X0B
724 }
725 #[doc = "Checks if the value of the field is `_0X0C`"]
726 #[inline(always)]
727 pub fn is_0x0c(&self) -> bool {
728 *self == ICLFSELD_A::_0X0C
729 }
730 #[doc = "Checks if the value of the field is `_0X0D`"]
731 #[inline(always)]
732 pub fn is_0x0d(&self) -> bool {
733 *self == ICLFSELD_A::_0X0D
734 }
735 #[doc = "Checks if the value of the field is `_0X0E`"]
736 #[inline(always)]
737 pub fn is_0x0e(&self) -> bool {
738 *self == ICLFSELD_A::_0X0E
739 }
740 #[doc = "Checks if the value of the field is `_0X0F`"]
741 #[inline(always)]
742 pub fn is_0x0f(&self) -> bool {
743 *self == ICLFSELD_A::_0X0F
744 }
745 #[doc = "Checks if the value of the field is `_0X10`"]
746 #[inline(always)]
747 pub fn is_0x10(&self) -> bool {
748 *self == ICLFSELD_A::_0X10
749 }
750 #[doc = "Checks if the value of the field is `_0X11`"]
751 #[inline(always)]
752 pub fn is_0x11(&self) -> bool {
753 *self == ICLFSELD_A::_0X11
754 }
755 #[doc = "Checks if the value of the field is `_0X12`"]
756 #[inline(always)]
757 pub fn is_0x12(&self) -> bool {
758 *self == ICLFSELD_A::_0X12
759 }
760 #[doc = "Checks if the value of the field is `_0X13`"]
761 #[inline(always)]
762 pub fn is_0x13(&self) -> bool {
763 *self == ICLFSELD_A::_0X13
764 }
765}
766#[doc = "Field `ICLFSELD` writer - Inter Channel Signal D Select"]
767pub type ICLFSELD_W<'a, const O: u8> =
768 crate::FieldWriter<'a, u32, GTICLF_SPEC, u8, ICLFSELD_A, 6, O>;
769impl<'a, const O: u8> ICLFSELD_W<'a, O> {
770 #[doc = "GTIOC0A"]
771 #[inline(always)]
772 pub fn _0x00(self) -> &'a mut W {
773 self.variant(ICLFSELD_A::_0X00)
774 }
775 #[doc = "GTIOC0B"]
776 #[inline(always)]
777 pub fn _0x01(self) -> &'a mut W {
778 self.variant(ICLFSELD_A::_0X01)
779 }
780 #[doc = "GTIOC1A"]
781 #[inline(always)]
782 pub fn _0x02(self) -> &'a mut W {
783 self.variant(ICLFSELD_A::_0X02)
784 }
785 #[doc = "GTIOC1B"]
786 #[inline(always)]
787 pub fn _0x03(self) -> &'a mut W {
788 self.variant(ICLFSELD_A::_0X03)
789 }
790 #[doc = "GTIOC2A"]
791 #[inline(always)]
792 pub fn _0x04(self) -> &'a mut W {
793 self.variant(ICLFSELD_A::_0X04)
794 }
795 #[doc = "GTIOC2B"]
796 #[inline(always)]
797 pub fn _0x05(self) -> &'a mut W {
798 self.variant(ICLFSELD_A::_0X05)
799 }
800 #[doc = "GTIOC3A"]
801 #[inline(always)]
802 pub fn _0x06(self) -> &'a mut W {
803 self.variant(ICLFSELD_A::_0X06)
804 }
805 #[doc = "GTIOC3B"]
806 #[inline(always)]
807 pub fn _0x07(self) -> &'a mut W {
808 self.variant(ICLFSELD_A::_0X07)
809 }
810 #[doc = "GTIOC4A"]
811 #[inline(always)]
812 pub fn _0x08(self) -> &'a mut W {
813 self.variant(ICLFSELD_A::_0X08)
814 }
815 #[doc = "GTIOC4B"]
816 #[inline(always)]
817 pub fn _0x09(self) -> &'a mut W {
818 self.variant(ICLFSELD_A::_0X09)
819 }
820 #[doc = "GTIOC5A"]
821 #[inline(always)]
822 pub fn _0x0a(self) -> &'a mut W {
823 self.variant(ICLFSELD_A::_0X0A)
824 }
825 #[doc = "GTIOC5B"]
826 #[inline(always)]
827 pub fn _0x0b(self) -> &'a mut W {
828 self.variant(ICLFSELD_A::_0X0B)
829 }
830 #[doc = "GTIOC6A"]
831 #[inline(always)]
832 pub fn _0x0c(self) -> &'a mut W {
833 self.variant(ICLFSELD_A::_0X0C)
834 }
835 #[doc = "GTIOC6B"]
836 #[inline(always)]
837 pub fn _0x0d(self) -> &'a mut W {
838 self.variant(ICLFSELD_A::_0X0D)
839 }
840 #[doc = "GTIOC7A"]
841 #[inline(always)]
842 pub fn _0x0e(self) -> &'a mut W {
843 self.variant(ICLFSELD_A::_0X0E)
844 }
845 #[doc = "GTIOC7B"]
846 #[inline(always)]
847 pub fn _0x0f(self) -> &'a mut W {
848 self.variant(ICLFSELD_A::_0X0F)
849 }
850 #[doc = "GTIOC8A"]
851 #[inline(always)]
852 pub fn _0x10(self) -> &'a mut W {
853 self.variant(ICLFSELD_A::_0X10)
854 }
855 #[doc = "GTIOC8B"]
856 #[inline(always)]
857 pub fn _0x11(self) -> &'a mut W {
858 self.variant(ICLFSELD_A::_0X11)
859 }
860 #[doc = "GTIOC9A"]
861 #[inline(always)]
862 pub fn _0x12(self) -> &'a mut W {
863 self.variant(ICLFSELD_A::_0X12)
864 }
865 #[doc = "GTIOC9B"]
866 #[inline(always)]
867 pub fn _0x13(self) -> &'a mut W {
868 self.variant(ICLFSELD_A::_0X13)
869 }
870}
871impl R {
872 #[doc = "Bits 0:2 - GTIOCnA Output Logical Operation Function Select"]
873 #[inline(always)]
874 pub fn iclfa(&self) -> ICLFA_R {
875 ICLFA_R::new((self.bits & 7) as u8)
876 }
877 #[doc = "Bits 4:9 - Inter Channel Signal C Select"]
878 #[inline(always)]
879 pub fn iclfselc(&self) -> ICLFSELC_R {
880 ICLFSELC_R::new(((self.bits >> 4) & 0x3f) as u8)
881 }
882 #[doc = "Bits 16:18 - GTIOCnB Output Logical Operation Function Select"]
883 #[inline(always)]
884 pub fn iclfb(&self) -> ICLFB_R {
885 ICLFB_R::new(((self.bits >> 16) & 7) as u8)
886 }
887 #[doc = "Bits 20:25 - Inter Channel Signal D Select"]
888 #[inline(always)]
889 pub fn iclfseld(&self) -> ICLFSELD_R {
890 ICLFSELD_R::new(((self.bits >> 20) & 0x3f) as u8)
891 }
892}
893impl W {
894 #[doc = "Bits 0:2 - GTIOCnA Output Logical Operation Function Select"]
895 #[inline(always)]
896 #[must_use]
897 pub fn iclfa(&mut self) -> ICLFA_W<0> {
898 ICLFA_W::new(self)
899 }
900 #[doc = "Bits 4:9 - Inter Channel Signal C Select"]
901 #[inline(always)]
902 #[must_use]
903 pub fn iclfselc(&mut self) -> ICLFSELC_W<4> {
904 ICLFSELC_W::new(self)
905 }
906 #[doc = "Bits 16:18 - GTIOCnB Output Logical Operation Function Select"]
907 #[inline(always)]
908 #[must_use]
909 pub fn iclfb(&mut self) -> ICLFB_W<16> {
910 ICLFB_W::new(self)
911 }
912 #[doc = "Bits 20:25 - Inter Channel Signal D Select"]
913 #[inline(always)]
914 #[must_use]
915 pub fn iclfseld(&mut self) -> ICLFSELD_W<20> {
916 ICLFSELD_W::new(self)
917 }
918 #[doc = "Writes raw bits to the register."]
919 #[inline(always)]
920 pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
921 self.0.bits(bits);
922 self
923 }
924}
925#[doc = "General PWM Timer Inter Channel Logical Operation Function Setting 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 [gticlf](index.html) module"]
926pub struct GTICLF_SPEC;
927impl crate::RegisterSpec for GTICLF_SPEC {
928 type Ux = u32;
929}
930#[doc = "`read()` method returns [gticlf::R](R) reader structure"]
931impl crate::Readable for GTICLF_SPEC {
932 type Reader = R;
933}
934#[doc = "`write(|w| ..)` method takes [gticlf::W](W) writer structure"]
935impl crate::Writable for GTICLF_SPEC {
936 type Writer = W;
937 const ZERO_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
938 const ONE_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
939}
940#[doc = "`reset()` method sets GTICLF to value 0"]
941impl crate::Resettable for GTICLF_SPEC {
942 const RESET_VALUE: Self::Ux = 0;
943}