1#[doc = "Register `PMCFG` reader"]
2pub struct R(crate::R<PMCFG_SPEC>);
3impl core::ops::Deref for R {
4 type Target = crate::R<PMCFG_SPEC>;
5 #[inline(always)]
6 fn deref(&self) -> &Self::Target {
7 &self.0
8 }
9}
10impl From<crate::R<PMCFG_SPEC>> for R {
11 #[inline(always)]
12 fn from(reader: crate::R<PMCFG_SPEC>) -> Self {
13 R(reader)
14 }
15}
16#[doc = "Register `PMCFG` writer"]
17pub struct W(crate::W<PMCFG_SPEC>);
18impl core::ops::Deref for W {
19 type Target = crate::W<PMCFG_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<PMCFG_SPEC>> for W {
32 #[inline(always)]
33 fn from(writer: crate::W<PMCFG_SPEC>) -> Self {
34 W(writer)
35 }
36}
37#[doc = "Determines whether slice 0 is an endpoint.\n\nValue on reset: 0"]
38#[derive(Clone, Copy, Debug, PartialEq)]
39pub enum PROD_ENDPTS0_A {
40 #[doc = "0: No effect. Slice 0 is not an endpoint."]
41 NO_EFFECT = 0,
42 #[doc = "1: endpoint. Slice 0 is the endpoint of a product term (minterm). Pin interrupt 0 in the NVIC is raised if the minterm evaluates as true."]
43 ENDPOINT = 1,
44}
45impl From<PROD_ENDPTS0_A> for bool {
46 #[inline(always)]
47 fn from(variant: PROD_ENDPTS0_A) -> Self {
48 variant as u8 != 0
49 }
50}
51#[doc = "Field `PROD_ENDPTS0` reader - Determines whether slice 0 is an endpoint."]
52pub struct PROD_ENDPTS0_R(crate::FieldReader<bool, PROD_ENDPTS0_A>);
53impl PROD_ENDPTS0_R {
54 pub(crate) fn new(bits: bool) -> Self {
55 PROD_ENDPTS0_R(crate::FieldReader::new(bits))
56 }
57 #[doc = r"Get enumerated values variant"]
58 #[inline(always)]
59 pub fn variant(&self) -> PROD_ENDPTS0_A {
60 match self.bits {
61 false => PROD_ENDPTS0_A::NO_EFFECT,
62 true => PROD_ENDPTS0_A::ENDPOINT,
63 }
64 }
65 #[doc = "Checks if the value of the field is `NO_EFFECT`"]
66 #[inline(always)]
67 pub fn is_no_effect(&self) -> bool {
68 **self == PROD_ENDPTS0_A::NO_EFFECT
69 }
70 #[doc = "Checks if the value of the field is `ENDPOINT`"]
71 #[inline(always)]
72 pub fn is_endpoint(&self) -> bool {
73 **self == PROD_ENDPTS0_A::ENDPOINT
74 }
75}
76impl core::ops::Deref for PROD_ENDPTS0_R {
77 type Target = crate::FieldReader<bool, PROD_ENDPTS0_A>;
78 #[inline(always)]
79 fn deref(&self) -> &Self::Target {
80 &self.0
81 }
82}
83#[doc = "Field `PROD_ENDPTS0` writer - Determines whether slice 0 is an endpoint."]
84pub struct PROD_ENDPTS0_W<'a> {
85 w: &'a mut W,
86}
87impl<'a> PROD_ENDPTS0_W<'a> {
88 #[doc = r"Writes `variant` to the field"]
89 #[inline(always)]
90 pub fn variant(self, variant: PROD_ENDPTS0_A) -> &'a mut W {
91 self.bit(variant.into())
92 }
93 #[doc = "No effect. Slice 0 is not an endpoint."]
94 #[inline(always)]
95 pub fn no_effect(self) -> &'a mut W {
96 self.variant(PROD_ENDPTS0_A::NO_EFFECT)
97 }
98 #[doc = "endpoint. Slice 0 is the endpoint of a product term (minterm). Pin interrupt 0 in the NVIC is raised if the minterm evaluates as true."]
99 #[inline(always)]
100 pub fn endpoint(self) -> &'a mut W {
101 self.variant(PROD_ENDPTS0_A::ENDPOINT)
102 }
103 #[doc = r"Sets the field bit"]
104 #[inline(always)]
105 pub fn set_bit(self) -> &'a mut W {
106 self.bit(true)
107 }
108 #[doc = r"Clears the field bit"]
109 #[inline(always)]
110 pub fn clear_bit(self) -> &'a mut W {
111 self.bit(false)
112 }
113 #[doc = r"Writes raw bits to the field"]
114 #[inline(always)]
115 pub fn bit(self, value: bool) -> &'a mut W {
116 self.w.bits = (self.w.bits & !0x01) | (value as u32 & 0x01);
117 self.w
118 }
119}
120#[doc = "Determines whether slice 1 is an endpoint.\n\nValue on reset: 0"]
121#[derive(Clone, Copy, Debug, PartialEq)]
122pub enum PROD_ENDPTS1_A {
123 #[doc = "0: No effect. Slice 1 is not an endpoint."]
124 NO_EFFECT = 0,
125 #[doc = "1: endpoint. Slice 1 is the endpoint of a product term (minterm). Pin interrupt 1 in the NVIC is raised if the minterm evaluates as true."]
126 ENDPOINT = 1,
127}
128impl From<PROD_ENDPTS1_A> for bool {
129 #[inline(always)]
130 fn from(variant: PROD_ENDPTS1_A) -> Self {
131 variant as u8 != 0
132 }
133}
134#[doc = "Field `PROD_ENDPTS1` reader - Determines whether slice 1 is an endpoint."]
135pub struct PROD_ENDPTS1_R(crate::FieldReader<bool, PROD_ENDPTS1_A>);
136impl PROD_ENDPTS1_R {
137 pub(crate) fn new(bits: bool) -> Self {
138 PROD_ENDPTS1_R(crate::FieldReader::new(bits))
139 }
140 #[doc = r"Get enumerated values variant"]
141 #[inline(always)]
142 pub fn variant(&self) -> PROD_ENDPTS1_A {
143 match self.bits {
144 false => PROD_ENDPTS1_A::NO_EFFECT,
145 true => PROD_ENDPTS1_A::ENDPOINT,
146 }
147 }
148 #[doc = "Checks if the value of the field is `NO_EFFECT`"]
149 #[inline(always)]
150 pub fn is_no_effect(&self) -> bool {
151 **self == PROD_ENDPTS1_A::NO_EFFECT
152 }
153 #[doc = "Checks if the value of the field is `ENDPOINT`"]
154 #[inline(always)]
155 pub fn is_endpoint(&self) -> bool {
156 **self == PROD_ENDPTS1_A::ENDPOINT
157 }
158}
159impl core::ops::Deref for PROD_ENDPTS1_R {
160 type Target = crate::FieldReader<bool, PROD_ENDPTS1_A>;
161 #[inline(always)]
162 fn deref(&self) -> &Self::Target {
163 &self.0
164 }
165}
166#[doc = "Field `PROD_ENDPTS1` writer - Determines whether slice 1 is an endpoint."]
167pub struct PROD_ENDPTS1_W<'a> {
168 w: &'a mut W,
169}
170impl<'a> PROD_ENDPTS1_W<'a> {
171 #[doc = r"Writes `variant` to the field"]
172 #[inline(always)]
173 pub fn variant(self, variant: PROD_ENDPTS1_A) -> &'a mut W {
174 self.bit(variant.into())
175 }
176 #[doc = "No effect. Slice 1 is not an endpoint."]
177 #[inline(always)]
178 pub fn no_effect(self) -> &'a mut W {
179 self.variant(PROD_ENDPTS1_A::NO_EFFECT)
180 }
181 #[doc = "endpoint. Slice 1 is the endpoint of a product term (minterm). Pin interrupt 1 in the NVIC is raised if the minterm evaluates as true."]
182 #[inline(always)]
183 pub fn endpoint(self) -> &'a mut W {
184 self.variant(PROD_ENDPTS1_A::ENDPOINT)
185 }
186 #[doc = r"Sets the field bit"]
187 #[inline(always)]
188 pub fn set_bit(self) -> &'a mut W {
189 self.bit(true)
190 }
191 #[doc = r"Clears the field bit"]
192 #[inline(always)]
193 pub fn clear_bit(self) -> &'a mut W {
194 self.bit(false)
195 }
196 #[doc = r"Writes raw bits to the field"]
197 #[inline(always)]
198 pub fn bit(self, value: bool) -> &'a mut W {
199 self.w.bits = (self.w.bits & !(0x01 << 1)) | ((value as u32 & 0x01) << 1);
200 self.w
201 }
202}
203#[doc = "Determines whether slice 2 is an endpoint.\n\nValue on reset: 0"]
204#[derive(Clone, Copy, Debug, PartialEq)]
205pub enum PROD_ENDPTS2_A {
206 #[doc = "0: No effect. Slice 2 is not an endpoint."]
207 NO_EFFECT = 0,
208 #[doc = "1: endpoint. Slice 2 is the endpoint of a product term (minterm). Pin interrupt 2 in the NVIC is raised if the minterm evaluates as true."]
209 ENDPOINT = 1,
210}
211impl From<PROD_ENDPTS2_A> for bool {
212 #[inline(always)]
213 fn from(variant: PROD_ENDPTS2_A) -> Self {
214 variant as u8 != 0
215 }
216}
217#[doc = "Field `PROD_ENDPTS2` reader - Determines whether slice 2 is an endpoint."]
218pub struct PROD_ENDPTS2_R(crate::FieldReader<bool, PROD_ENDPTS2_A>);
219impl PROD_ENDPTS2_R {
220 pub(crate) fn new(bits: bool) -> Self {
221 PROD_ENDPTS2_R(crate::FieldReader::new(bits))
222 }
223 #[doc = r"Get enumerated values variant"]
224 #[inline(always)]
225 pub fn variant(&self) -> PROD_ENDPTS2_A {
226 match self.bits {
227 false => PROD_ENDPTS2_A::NO_EFFECT,
228 true => PROD_ENDPTS2_A::ENDPOINT,
229 }
230 }
231 #[doc = "Checks if the value of the field is `NO_EFFECT`"]
232 #[inline(always)]
233 pub fn is_no_effect(&self) -> bool {
234 **self == PROD_ENDPTS2_A::NO_EFFECT
235 }
236 #[doc = "Checks if the value of the field is `ENDPOINT`"]
237 #[inline(always)]
238 pub fn is_endpoint(&self) -> bool {
239 **self == PROD_ENDPTS2_A::ENDPOINT
240 }
241}
242impl core::ops::Deref for PROD_ENDPTS2_R {
243 type Target = crate::FieldReader<bool, PROD_ENDPTS2_A>;
244 #[inline(always)]
245 fn deref(&self) -> &Self::Target {
246 &self.0
247 }
248}
249#[doc = "Field `PROD_ENDPTS2` writer - Determines whether slice 2 is an endpoint."]
250pub struct PROD_ENDPTS2_W<'a> {
251 w: &'a mut W,
252}
253impl<'a> PROD_ENDPTS2_W<'a> {
254 #[doc = r"Writes `variant` to the field"]
255 #[inline(always)]
256 pub fn variant(self, variant: PROD_ENDPTS2_A) -> &'a mut W {
257 self.bit(variant.into())
258 }
259 #[doc = "No effect. Slice 2 is not an endpoint."]
260 #[inline(always)]
261 pub fn no_effect(self) -> &'a mut W {
262 self.variant(PROD_ENDPTS2_A::NO_EFFECT)
263 }
264 #[doc = "endpoint. Slice 2 is the endpoint of a product term (minterm). Pin interrupt 2 in the NVIC is raised if the minterm evaluates as true."]
265 #[inline(always)]
266 pub fn endpoint(self) -> &'a mut W {
267 self.variant(PROD_ENDPTS2_A::ENDPOINT)
268 }
269 #[doc = r"Sets the field bit"]
270 #[inline(always)]
271 pub fn set_bit(self) -> &'a mut W {
272 self.bit(true)
273 }
274 #[doc = r"Clears the field bit"]
275 #[inline(always)]
276 pub fn clear_bit(self) -> &'a mut W {
277 self.bit(false)
278 }
279 #[doc = r"Writes raw bits to the field"]
280 #[inline(always)]
281 pub fn bit(self, value: bool) -> &'a mut W {
282 self.w.bits = (self.w.bits & !(0x01 << 2)) | ((value as u32 & 0x01) << 2);
283 self.w
284 }
285}
286#[doc = "Determines whether slice 3 is an endpoint.\n\nValue on reset: 0"]
287#[derive(Clone, Copy, Debug, PartialEq)]
288pub enum PROD_ENDPTS3_A {
289 #[doc = "0: No effect. Slice 3 is not an endpoint."]
290 NO_EFFECT = 0,
291 #[doc = "1: endpoint. Slice 3 is the endpoint of a product term (minterm). Pin interrupt 3 in the NVIC is raised if the minterm evaluates as true."]
292 ENDPOINT = 1,
293}
294impl From<PROD_ENDPTS3_A> for bool {
295 #[inline(always)]
296 fn from(variant: PROD_ENDPTS3_A) -> Self {
297 variant as u8 != 0
298 }
299}
300#[doc = "Field `PROD_ENDPTS3` reader - Determines whether slice 3 is an endpoint."]
301pub struct PROD_ENDPTS3_R(crate::FieldReader<bool, PROD_ENDPTS3_A>);
302impl PROD_ENDPTS3_R {
303 pub(crate) fn new(bits: bool) -> Self {
304 PROD_ENDPTS3_R(crate::FieldReader::new(bits))
305 }
306 #[doc = r"Get enumerated values variant"]
307 #[inline(always)]
308 pub fn variant(&self) -> PROD_ENDPTS3_A {
309 match self.bits {
310 false => PROD_ENDPTS3_A::NO_EFFECT,
311 true => PROD_ENDPTS3_A::ENDPOINT,
312 }
313 }
314 #[doc = "Checks if the value of the field is `NO_EFFECT`"]
315 #[inline(always)]
316 pub fn is_no_effect(&self) -> bool {
317 **self == PROD_ENDPTS3_A::NO_EFFECT
318 }
319 #[doc = "Checks if the value of the field is `ENDPOINT`"]
320 #[inline(always)]
321 pub fn is_endpoint(&self) -> bool {
322 **self == PROD_ENDPTS3_A::ENDPOINT
323 }
324}
325impl core::ops::Deref for PROD_ENDPTS3_R {
326 type Target = crate::FieldReader<bool, PROD_ENDPTS3_A>;
327 #[inline(always)]
328 fn deref(&self) -> &Self::Target {
329 &self.0
330 }
331}
332#[doc = "Field `PROD_ENDPTS3` writer - Determines whether slice 3 is an endpoint."]
333pub struct PROD_ENDPTS3_W<'a> {
334 w: &'a mut W,
335}
336impl<'a> PROD_ENDPTS3_W<'a> {
337 #[doc = r"Writes `variant` to the field"]
338 #[inline(always)]
339 pub fn variant(self, variant: PROD_ENDPTS3_A) -> &'a mut W {
340 self.bit(variant.into())
341 }
342 #[doc = "No effect. Slice 3 is not an endpoint."]
343 #[inline(always)]
344 pub fn no_effect(self) -> &'a mut W {
345 self.variant(PROD_ENDPTS3_A::NO_EFFECT)
346 }
347 #[doc = "endpoint. Slice 3 is the endpoint of a product term (minterm). Pin interrupt 3 in the NVIC is raised if the minterm evaluates as true."]
348 #[inline(always)]
349 pub fn endpoint(self) -> &'a mut W {
350 self.variant(PROD_ENDPTS3_A::ENDPOINT)
351 }
352 #[doc = r"Sets the field bit"]
353 #[inline(always)]
354 pub fn set_bit(self) -> &'a mut W {
355 self.bit(true)
356 }
357 #[doc = r"Clears the field bit"]
358 #[inline(always)]
359 pub fn clear_bit(self) -> &'a mut W {
360 self.bit(false)
361 }
362 #[doc = r"Writes raw bits to the field"]
363 #[inline(always)]
364 pub fn bit(self, value: bool) -> &'a mut W {
365 self.w.bits = (self.w.bits & !(0x01 << 3)) | ((value as u32 & 0x01) << 3);
366 self.w
367 }
368}
369#[doc = "Determines whether slice 4 is an endpoint.\n\nValue on reset: 0"]
370#[derive(Clone, Copy, Debug, PartialEq)]
371pub enum PROD_ENDPTS4_A {
372 #[doc = "0: No effect. Slice 4 is not an endpoint."]
373 NO_EFFECT = 0,
374 #[doc = "1: endpoint. Slice 4 is the endpoint of a product term (minterm). Pin interrupt 4 in the NVIC is raised if the minterm evaluates as true."]
375 ENDPOINT = 1,
376}
377impl From<PROD_ENDPTS4_A> for bool {
378 #[inline(always)]
379 fn from(variant: PROD_ENDPTS4_A) -> Self {
380 variant as u8 != 0
381 }
382}
383#[doc = "Field `PROD_ENDPTS4` reader - Determines whether slice 4 is an endpoint."]
384pub struct PROD_ENDPTS4_R(crate::FieldReader<bool, PROD_ENDPTS4_A>);
385impl PROD_ENDPTS4_R {
386 pub(crate) fn new(bits: bool) -> Self {
387 PROD_ENDPTS4_R(crate::FieldReader::new(bits))
388 }
389 #[doc = r"Get enumerated values variant"]
390 #[inline(always)]
391 pub fn variant(&self) -> PROD_ENDPTS4_A {
392 match self.bits {
393 false => PROD_ENDPTS4_A::NO_EFFECT,
394 true => PROD_ENDPTS4_A::ENDPOINT,
395 }
396 }
397 #[doc = "Checks if the value of the field is `NO_EFFECT`"]
398 #[inline(always)]
399 pub fn is_no_effect(&self) -> bool {
400 **self == PROD_ENDPTS4_A::NO_EFFECT
401 }
402 #[doc = "Checks if the value of the field is `ENDPOINT`"]
403 #[inline(always)]
404 pub fn is_endpoint(&self) -> bool {
405 **self == PROD_ENDPTS4_A::ENDPOINT
406 }
407}
408impl core::ops::Deref for PROD_ENDPTS4_R {
409 type Target = crate::FieldReader<bool, PROD_ENDPTS4_A>;
410 #[inline(always)]
411 fn deref(&self) -> &Self::Target {
412 &self.0
413 }
414}
415#[doc = "Field `PROD_ENDPTS4` writer - Determines whether slice 4 is an endpoint."]
416pub struct PROD_ENDPTS4_W<'a> {
417 w: &'a mut W,
418}
419impl<'a> PROD_ENDPTS4_W<'a> {
420 #[doc = r"Writes `variant` to the field"]
421 #[inline(always)]
422 pub fn variant(self, variant: PROD_ENDPTS4_A) -> &'a mut W {
423 self.bit(variant.into())
424 }
425 #[doc = "No effect. Slice 4 is not an endpoint."]
426 #[inline(always)]
427 pub fn no_effect(self) -> &'a mut W {
428 self.variant(PROD_ENDPTS4_A::NO_EFFECT)
429 }
430 #[doc = "endpoint. Slice 4 is the endpoint of a product term (minterm). Pin interrupt 4 in the NVIC is raised if the minterm evaluates as true."]
431 #[inline(always)]
432 pub fn endpoint(self) -> &'a mut W {
433 self.variant(PROD_ENDPTS4_A::ENDPOINT)
434 }
435 #[doc = r"Sets the field bit"]
436 #[inline(always)]
437 pub fn set_bit(self) -> &'a mut W {
438 self.bit(true)
439 }
440 #[doc = r"Clears the field bit"]
441 #[inline(always)]
442 pub fn clear_bit(self) -> &'a mut W {
443 self.bit(false)
444 }
445 #[doc = r"Writes raw bits to the field"]
446 #[inline(always)]
447 pub fn bit(self, value: bool) -> &'a mut W {
448 self.w.bits = (self.w.bits & !(0x01 << 4)) | ((value as u32 & 0x01) << 4);
449 self.w
450 }
451}
452#[doc = "Determines whether slice 5 is an endpoint.\n\nValue on reset: 0"]
453#[derive(Clone, Copy, Debug, PartialEq)]
454pub enum PROD_ENDPTS5_A {
455 #[doc = "0: No effect. Slice 5 is not an endpoint."]
456 NO_EFFECT = 0,
457 #[doc = "1: endpoint. Slice 5 is the endpoint of a product term (minterm). Pin interrupt 5 in the NVIC is raised if the minterm evaluates as true."]
458 ENDPOINT = 1,
459}
460impl From<PROD_ENDPTS5_A> for bool {
461 #[inline(always)]
462 fn from(variant: PROD_ENDPTS5_A) -> Self {
463 variant as u8 != 0
464 }
465}
466#[doc = "Field `PROD_ENDPTS5` reader - Determines whether slice 5 is an endpoint."]
467pub struct PROD_ENDPTS5_R(crate::FieldReader<bool, PROD_ENDPTS5_A>);
468impl PROD_ENDPTS5_R {
469 pub(crate) fn new(bits: bool) -> Self {
470 PROD_ENDPTS5_R(crate::FieldReader::new(bits))
471 }
472 #[doc = r"Get enumerated values variant"]
473 #[inline(always)]
474 pub fn variant(&self) -> PROD_ENDPTS5_A {
475 match self.bits {
476 false => PROD_ENDPTS5_A::NO_EFFECT,
477 true => PROD_ENDPTS5_A::ENDPOINT,
478 }
479 }
480 #[doc = "Checks if the value of the field is `NO_EFFECT`"]
481 #[inline(always)]
482 pub fn is_no_effect(&self) -> bool {
483 **self == PROD_ENDPTS5_A::NO_EFFECT
484 }
485 #[doc = "Checks if the value of the field is `ENDPOINT`"]
486 #[inline(always)]
487 pub fn is_endpoint(&self) -> bool {
488 **self == PROD_ENDPTS5_A::ENDPOINT
489 }
490}
491impl core::ops::Deref for PROD_ENDPTS5_R {
492 type Target = crate::FieldReader<bool, PROD_ENDPTS5_A>;
493 #[inline(always)]
494 fn deref(&self) -> &Self::Target {
495 &self.0
496 }
497}
498#[doc = "Field `PROD_ENDPTS5` writer - Determines whether slice 5 is an endpoint."]
499pub struct PROD_ENDPTS5_W<'a> {
500 w: &'a mut W,
501}
502impl<'a> PROD_ENDPTS5_W<'a> {
503 #[doc = r"Writes `variant` to the field"]
504 #[inline(always)]
505 pub fn variant(self, variant: PROD_ENDPTS5_A) -> &'a mut W {
506 self.bit(variant.into())
507 }
508 #[doc = "No effect. Slice 5 is not an endpoint."]
509 #[inline(always)]
510 pub fn no_effect(self) -> &'a mut W {
511 self.variant(PROD_ENDPTS5_A::NO_EFFECT)
512 }
513 #[doc = "endpoint. Slice 5 is the endpoint of a product term (minterm). Pin interrupt 5 in the NVIC is raised if the minterm evaluates as true."]
514 #[inline(always)]
515 pub fn endpoint(self) -> &'a mut W {
516 self.variant(PROD_ENDPTS5_A::ENDPOINT)
517 }
518 #[doc = r"Sets the field bit"]
519 #[inline(always)]
520 pub fn set_bit(self) -> &'a mut W {
521 self.bit(true)
522 }
523 #[doc = r"Clears the field bit"]
524 #[inline(always)]
525 pub fn clear_bit(self) -> &'a mut W {
526 self.bit(false)
527 }
528 #[doc = r"Writes raw bits to the field"]
529 #[inline(always)]
530 pub fn bit(self, value: bool) -> &'a mut W {
531 self.w.bits = (self.w.bits & !(0x01 << 5)) | ((value as u32 & 0x01) << 5);
532 self.w
533 }
534}
535#[doc = "Determines whether slice 6 is an endpoint.\n\nValue on reset: 0"]
536#[derive(Clone, Copy, Debug, PartialEq)]
537pub enum PROD_ENDPTS6_A {
538 #[doc = "0: No effect. Slice 6 is not an endpoint."]
539 NO_EFFECT = 0,
540 #[doc = "1: endpoint. Slice 6 is the endpoint of a product term (minterm). Pin interrupt 6 in the NVIC is raised if the minterm evaluates as true."]
541 ENDPOINT = 1,
542}
543impl From<PROD_ENDPTS6_A> for bool {
544 #[inline(always)]
545 fn from(variant: PROD_ENDPTS6_A) -> Self {
546 variant as u8 != 0
547 }
548}
549#[doc = "Field `PROD_ENDPTS6` reader - Determines whether slice 6 is an endpoint."]
550pub struct PROD_ENDPTS6_R(crate::FieldReader<bool, PROD_ENDPTS6_A>);
551impl PROD_ENDPTS6_R {
552 pub(crate) fn new(bits: bool) -> Self {
553 PROD_ENDPTS6_R(crate::FieldReader::new(bits))
554 }
555 #[doc = r"Get enumerated values variant"]
556 #[inline(always)]
557 pub fn variant(&self) -> PROD_ENDPTS6_A {
558 match self.bits {
559 false => PROD_ENDPTS6_A::NO_EFFECT,
560 true => PROD_ENDPTS6_A::ENDPOINT,
561 }
562 }
563 #[doc = "Checks if the value of the field is `NO_EFFECT`"]
564 #[inline(always)]
565 pub fn is_no_effect(&self) -> bool {
566 **self == PROD_ENDPTS6_A::NO_EFFECT
567 }
568 #[doc = "Checks if the value of the field is `ENDPOINT`"]
569 #[inline(always)]
570 pub fn is_endpoint(&self) -> bool {
571 **self == PROD_ENDPTS6_A::ENDPOINT
572 }
573}
574impl core::ops::Deref for PROD_ENDPTS6_R {
575 type Target = crate::FieldReader<bool, PROD_ENDPTS6_A>;
576 #[inline(always)]
577 fn deref(&self) -> &Self::Target {
578 &self.0
579 }
580}
581#[doc = "Field `PROD_ENDPTS6` writer - Determines whether slice 6 is an endpoint."]
582pub struct PROD_ENDPTS6_W<'a> {
583 w: &'a mut W,
584}
585impl<'a> PROD_ENDPTS6_W<'a> {
586 #[doc = r"Writes `variant` to the field"]
587 #[inline(always)]
588 pub fn variant(self, variant: PROD_ENDPTS6_A) -> &'a mut W {
589 self.bit(variant.into())
590 }
591 #[doc = "No effect. Slice 6 is not an endpoint."]
592 #[inline(always)]
593 pub fn no_effect(self) -> &'a mut W {
594 self.variant(PROD_ENDPTS6_A::NO_EFFECT)
595 }
596 #[doc = "endpoint. Slice 6 is the endpoint of a product term (minterm). Pin interrupt 6 in the NVIC is raised if the minterm evaluates as true."]
597 #[inline(always)]
598 pub fn endpoint(self) -> &'a mut W {
599 self.variant(PROD_ENDPTS6_A::ENDPOINT)
600 }
601 #[doc = r"Sets the field bit"]
602 #[inline(always)]
603 pub fn set_bit(self) -> &'a mut W {
604 self.bit(true)
605 }
606 #[doc = r"Clears the field bit"]
607 #[inline(always)]
608 pub fn clear_bit(self) -> &'a mut W {
609 self.bit(false)
610 }
611 #[doc = r"Writes raw bits to the field"]
612 #[inline(always)]
613 pub fn bit(self, value: bool) -> &'a mut W {
614 self.w.bits = (self.w.bits & !(0x01 << 6)) | ((value as u32 & 0x01) << 6);
615 self.w
616 }
617}
618#[doc = "Specifies the match contribution condition for bit slice 0.\n\nValue on reset: 0"]
619#[derive(Clone, Copy, Debug, PartialEq)]
620#[repr(u8)]
621pub enum CFG0_A {
622 #[doc = "0: Constant HIGH. This bit slice always contributes to a product term match."]
623 CONSTANT_HIGH = 0,
624 #[doc = "1: Sticky rising edge. Match occurs if a rising edge on the specified input has occurred since the last time the edge detection for this bit slice was cleared. This bit is only cleared when the PMCFG or the PMSRC registers are written to."]
625 STICKY_RISING_EDGE = 1,
626 #[doc = "2: Sticky falling edge. Match occurs if a falling edge on the specified input has occurred since the last time the edge detection for this bit slice was cleared. This bit is only cleared when the PMCFG or the PMSRC registers are written to."]
627 STICKY_FALLING_EDGE = 2,
628 #[doc = "3: Sticky rising or falling edge. Match occurs if either a rising or falling edge on the specified input has occurred since the last time the edge detection for this bit slice was cleared. This bit is only cleared when the PMCFG or the PMSRC registers are written to."]
629 STICKY_RISING_FALLING_EDGE = 3,
630 #[doc = "4: High level. Match (for this bit slice) occurs when there is a high level on the input specified for this bit slice in the PMSRC register."]
631 HIGH_LEVEL = 4,
632 #[doc = "5: Low level. Match occurs when there is a low level on the specified input."]
633 LOW_LEVEL = 5,
634 #[doc = "6: Constant 0. This bit slice never contributes to a match (should be used to disable any unused bit slices)."]
635 CONSTANT_ZERO = 6,
636 #[doc = "7: Event. Non-sticky rising or falling edge. Match occurs on an event - i.e. when either a rising or falling edge is first detected on the specified input (this is a non-sticky version of value 0x3) . This bit is cleared after one clock cycle."]
637 EVENT = 7,
638}
639impl From<CFG0_A> for u8 {
640 #[inline(always)]
641 fn from(variant: CFG0_A) -> Self {
642 variant as _
643 }
644}
645#[doc = "Field `CFG0` reader - Specifies the match contribution condition for bit slice 0."]
646pub struct CFG0_R(crate::FieldReader<u8, CFG0_A>);
647impl CFG0_R {
648 pub(crate) fn new(bits: u8) -> Self {
649 CFG0_R(crate::FieldReader::new(bits))
650 }
651 #[doc = r"Get enumerated values variant"]
652 #[inline(always)]
653 pub fn variant(&self) -> CFG0_A {
654 match self.bits {
655 0 => CFG0_A::CONSTANT_HIGH,
656 1 => CFG0_A::STICKY_RISING_EDGE,
657 2 => CFG0_A::STICKY_FALLING_EDGE,
658 3 => CFG0_A::STICKY_RISING_FALLING_EDGE,
659 4 => CFG0_A::HIGH_LEVEL,
660 5 => CFG0_A::LOW_LEVEL,
661 6 => CFG0_A::CONSTANT_ZERO,
662 7 => CFG0_A::EVENT,
663 _ => unreachable!(),
664 }
665 }
666 #[doc = "Checks if the value of the field is `CONSTANT_HIGH`"]
667 #[inline(always)]
668 pub fn is_constant_high(&self) -> bool {
669 **self == CFG0_A::CONSTANT_HIGH
670 }
671 #[doc = "Checks if the value of the field is `STICKY_RISING_EDGE`"]
672 #[inline(always)]
673 pub fn is_sticky_rising_edge(&self) -> bool {
674 **self == CFG0_A::STICKY_RISING_EDGE
675 }
676 #[doc = "Checks if the value of the field is `STICKY_FALLING_EDGE`"]
677 #[inline(always)]
678 pub fn is_sticky_falling_edge(&self) -> bool {
679 **self == CFG0_A::STICKY_FALLING_EDGE
680 }
681 #[doc = "Checks if the value of the field is `STICKY_RISING_FALLING_EDGE`"]
682 #[inline(always)]
683 pub fn is_sticky_rising_falling_edge(&self) -> bool {
684 **self == CFG0_A::STICKY_RISING_FALLING_EDGE
685 }
686 #[doc = "Checks if the value of the field is `HIGH_LEVEL`"]
687 #[inline(always)]
688 pub fn is_high_level(&self) -> bool {
689 **self == CFG0_A::HIGH_LEVEL
690 }
691 #[doc = "Checks if the value of the field is `LOW_LEVEL`"]
692 #[inline(always)]
693 pub fn is_low_level(&self) -> bool {
694 **self == CFG0_A::LOW_LEVEL
695 }
696 #[doc = "Checks if the value of the field is `CONSTANT_ZERO`"]
697 #[inline(always)]
698 pub fn is_constant_zero(&self) -> bool {
699 **self == CFG0_A::CONSTANT_ZERO
700 }
701 #[doc = "Checks if the value of the field is `EVENT`"]
702 #[inline(always)]
703 pub fn is_event(&self) -> bool {
704 **self == CFG0_A::EVENT
705 }
706}
707impl core::ops::Deref for CFG0_R {
708 type Target = crate::FieldReader<u8, CFG0_A>;
709 #[inline(always)]
710 fn deref(&self) -> &Self::Target {
711 &self.0
712 }
713}
714#[doc = "Field `CFG0` writer - Specifies the match contribution condition for bit slice 0."]
715pub struct CFG0_W<'a> {
716 w: &'a mut W,
717}
718impl<'a> CFG0_W<'a> {
719 #[doc = r"Writes `variant` to the field"]
720 #[inline(always)]
721 pub fn variant(self, variant: CFG0_A) -> &'a mut W {
722 self.bits(variant.into())
723 }
724 #[doc = "Constant HIGH. This bit slice always contributes to a product term match."]
725 #[inline(always)]
726 pub fn constant_high(self) -> &'a mut W {
727 self.variant(CFG0_A::CONSTANT_HIGH)
728 }
729 #[doc = "Sticky rising edge. Match occurs if a rising edge on the specified input has occurred since the last time the edge detection for this bit slice was cleared. This bit is only cleared when the PMCFG or the PMSRC registers are written to."]
730 #[inline(always)]
731 pub fn sticky_rising_edge(self) -> &'a mut W {
732 self.variant(CFG0_A::STICKY_RISING_EDGE)
733 }
734 #[doc = "Sticky falling edge. Match occurs if a falling edge on the specified input has occurred since the last time the edge detection for this bit slice was cleared. This bit is only cleared when the PMCFG or the PMSRC registers are written to."]
735 #[inline(always)]
736 pub fn sticky_falling_edge(self) -> &'a mut W {
737 self.variant(CFG0_A::STICKY_FALLING_EDGE)
738 }
739 #[doc = "Sticky rising or falling edge. Match occurs if either a rising or falling edge on the specified input has occurred since the last time the edge detection for this bit slice was cleared. This bit is only cleared when the PMCFG or the PMSRC registers are written to."]
740 #[inline(always)]
741 pub fn sticky_rising_falling_edge(self) -> &'a mut W {
742 self.variant(CFG0_A::STICKY_RISING_FALLING_EDGE)
743 }
744 #[doc = "High level. Match (for this bit slice) occurs when there is a high level on the input specified for this bit slice in the PMSRC register."]
745 #[inline(always)]
746 pub fn high_level(self) -> &'a mut W {
747 self.variant(CFG0_A::HIGH_LEVEL)
748 }
749 #[doc = "Low level. Match occurs when there is a low level on the specified input."]
750 #[inline(always)]
751 pub fn low_level(self) -> &'a mut W {
752 self.variant(CFG0_A::LOW_LEVEL)
753 }
754 #[doc = "Constant 0. This bit slice never contributes to a match (should be used to disable any unused bit slices)."]
755 #[inline(always)]
756 pub fn constant_zero(self) -> &'a mut W {
757 self.variant(CFG0_A::CONSTANT_ZERO)
758 }
759 #[doc = "Event. Non-sticky rising or falling edge. Match occurs on an event - i.e. when either a rising or falling edge is first detected on the specified input (this is a non-sticky version of value 0x3) . This bit is cleared after one clock cycle."]
760 #[inline(always)]
761 pub fn event(self) -> &'a mut W {
762 self.variant(CFG0_A::EVENT)
763 }
764 #[doc = r"Writes raw bits to the field"]
765 #[inline(always)]
766 pub fn bits(self, value: u8) -> &'a mut W {
767 self.w.bits = (self.w.bits & !(0x07 << 8)) | ((value as u32 & 0x07) << 8);
768 self.w
769 }
770}
771#[doc = "Specifies the match contribution condition for bit slice 1.\n\nValue on reset: 0"]
772#[derive(Clone, Copy, Debug, PartialEq)]
773#[repr(u8)]
774pub enum CFG1_A {
775 #[doc = "0: Constant HIGH. This bit slice always contributes to a product term match."]
776 CONSTANT_HIGH = 0,
777 #[doc = "1: Sticky rising edge. Match occurs if a rising edge on the specified input has occurred since the last time the edge detection for this bit slice was cleared. This bit is only cleared when the PMCFG or the PMSRC registers are written to."]
778 STICKY_RISING_EDGE = 1,
779 #[doc = "2: Sticky falling edge. Match occurs if a falling edge on the specified input has occurred since the last time the edge detection for this bit slice was cleared. This bit is only cleared when the PMCFG or the PMSRC registers are written to."]
780 STICKY_FALLING_EDGE = 2,
781 #[doc = "3: Sticky rising or falling edge. Match occurs if either a rising or falling edge on the specified input has occurred since the last time the edge detection for this bit slice was cleared. This bit is only cleared when the PMCFG or the PMSRC registers are written to."]
782 STICKY_RISING_FALLING_EDGE = 3,
783 #[doc = "4: High level. Match (for this bit slice) occurs when there is a high level on the input specified for this bit slice in the PMSRC register."]
784 HIGH_LEVEL = 4,
785 #[doc = "5: Low level. Match occurs when there is a low level on the specified input."]
786 LOW_LEVEL = 5,
787 #[doc = "6: Constant 0. This bit slice never contributes to a match (should be used to disable any unused bit slices)."]
788 CONSTANT_ZERO = 6,
789 #[doc = "7: Event. Non-sticky rising or falling edge. Match occurs on an event - i.e. when either a rising or falling edge is first detected on the specified input (this is a non-sticky version of value 0x3) . This bit is cleared after one clock cycle."]
790 EVENT = 7,
791}
792impl From<CFG1_A> for u8 {
793 #[inline(always)]
794 fn from(variant: CFG1_A) -> Self {
795 variant as _
796 }
797}
798#[doc = "Field `CFG1` reader - Specifies the match contribution condition for bit slice 1."]
799pub struct CFG1_R(crate::FieldReader<u8, CFG1_A>);
800impl CFG1_R {
801 pub(crate) fn new(bits: u8) -> Self {
802 CFG1_R(crate::FieldReader::new(bits))
803 }
804 #[doc = r"Get enumerated values variant"]
805 #[inline(always)]
806 pub fn variant(&self) -> CFG1_A {
807 match self.bits {
808 0 => CFG1_A::CONSTANT_HIGH,
809 1 => CFG1_A::STICKY_RISING_EDGE,
810 2 => CFG1_A::STICKY_FALLING_EDGE,
811 3 => CFG1_A::STICKY_RISING_FALLING_EDGE,
812 4 => CFG1_A::HIGH_LEVEL,
813 5 => CFG1_A::LOW_LEVEL,
814 6 => CFG1_A::CONSTANT_ZERO,
815 7 => CFG1_A::EVENT,
816 _ => unreachable!(),
817 }
818 }
819 #[doc = "Checks if the value of the field is `CONSTANT_HIGH`"]
820 #[inline(always)]
821 pub fn is_constant_high(&self) -> bool {
822 **self == CFG1_A::CONSTANT_HIGH
823 }
824 #[doc = "Checks if the value of the field is `STICKY_RISING_EDGE`"]
825 #[inline(always)]
826 pub fn is_sticky_rising_edge(&self) -> bool {
827 **self == CFG1_A::STICKY_RISING_EDGE
828 }
829 #[doc = "Checks if the value of the field is `STICKY_FALLING_EDGE`"]
830 #[inline(always)]
831 pub fn is_sticky_falling_edge(&self) -> bool {
832 **self == CFG1_A::STICKY_FALLING_EDGE
833 }
834 #[doc = "Checks if the value of the field is `STICKY_RISING_FALLING_EDGE`"]
835 #[inline(always)]
836 pub fn is_sticky_rising_falling_edge(&self) -> bool {
837 **self == CFG1_A::STICKY_RISING_FALLING_EDGE
838 }
839 #[doc = "Checks if the value of the field is `HIGH_LEVEL`"]
840 #[inline(always)]
841 pub fn is_high_level(&self) -> bool {
842 **self == CFG1_A::HIGH_LEVEL
843 }
844 #[doc = "Checks if the value of the field is `LOW_LEVEL`"]
845 #[inline(always)]
846 pub fn is_low_level(&self) -> bool {
847 **self == CFG1_A::LOW_LEVEL
848 }
849 #[doc = "Checks if the value of the field is `CONSTANT_ZERO`"]
850 #[inline(always)]
851 pub fn is_constant_zero(&self) -> bool {
852 **self == CFG1_A::CONSTANT_ZERO
853 }
854 #[doc = "Checks if the value of the field is `EVENT`"]
855 #[inline(always)]
856 pub fn is_event(&self) -> bool {
857 **self == CFG1_A::EVENT
858 }
859}
860impl core::ops::Deref for CFG1_R {
861 type Target = crate::FieldReader<u8, CFG1_A>;
862 #[inline(always)]
863 fn deref(&self) -> &Self::Target {
864 &self.0
865 }
866}
867#[doc = "Field `CFG1` writer - Specifies the match contribution condition for bit slice 1."]
868pub struct CFG1_W<'a> {
869 w: &'a mut W,
870}
871impl<'a> CFG1_W<'a> {
872 #[doc = r"Writes `variant` to the field"]
873 #[inline(always)]
874 pub fn variant(self, variant: CFG1_A) -> &'a mut W {
875 self.bits(variant.into())
876 }
877 #[doc = "Constant HIGH. This bit slice always contributes to a product term match."]
878 #[inline(always)]
879 pub fn constant_high(self) -> &'a mut W {
880 self.variant(CFG1_A::CONSTANT_HIGH)
881 }
882 #[doc = "Sticky rising edge. Match occurs if a rising edge on the specified input has occurred since the last time the edge detection for this bit slice was cleared. This bit is only cleared when the PMCFG or the PMSRC registers are written to."]
883 #[inline(always)]
884 pub fn sticky_rising_edge(self) -> &'a mut W {
885 self.variant(CFG1_A::STICKY_RISING_EDGE)
886 }
887 #[doc = "Sticky falling edge. Match occurs if a falling edge on the specified input has occurred since the last time the edge detection for this bit slice was cleared. This bit is only cleared when the PMCFG or the PMSRC registers are written to."]
888 #[inline(always)]
889 pub fn sticky_falling_edge(self) -> &'a mut W {
890 self.variant(CFG1_A::STICKY_FALLING_EDGE)
891 }
892 #[doc = "Sticky rising or falling edge. Match occurs if either a rising or falling edge on the specified input has occurred since the last time the edge detection for this bit slice was cleared. This bit is only cleared when the PMCFG or the PMSRC registers are written to."]
893 #[inline(always)]
894 pub fn sticky_rising_falling_edge(self) -> &'a mut W {
895 self.variant(CFG1_A::STICKY_RISING_FALLING_EDGE)
896 }
897 #[doc = "High level. Match (for this bit slice) occurs when there is a high level on the input specified for this bit slice in the PMSRC register."]
898 #[inline(always)]
899 pub fn high_level(self) -> &'a mut W {
900 self.variant(CFG1_A::HIGH_LEVEL)
901 }
902 #[doc = "Low level. Match occurs when there is a low level on the specified input."]
903 #[inline(always)]
904 pub fn low_level(self) -> &'a mut W {
905 self.variant(CFG1_A::LOW_LEVEL)
906 }
907 #[doc = "Constant 0. This bit slice never contributes to a match (should be used to disable any unused bit slices)."]
908 #[inline(always)]
909 pub fn constant_zero(self) -> &'a mut W {
910 self.variant(CFG1_A::CONSTANT_ZERO)
911 }
912 #[doc = "Event. Non-sticky rising or falling edge. Match occurs on an event - i.e. when either a rising or falling edge is first detected on the specified input (this is a non-sticky version of value 0x3) . This bit is cleared after one clock cycle."]
913 #[inline(always)]
914 pub fn event(self) -> &'a mut W {
915 self.variant(CFG1_A::EVENT)
916 }
917 #[doc = r"Writes raw bits to the field"]
918 #[inline(always)]
919 pub fn bits(self, value: u8) -> &'a mut W {
920 self.w.bits = (self.w.bits & !(0x07 << 11)) | ((value as u32 & 0x07) << 11);
921 self.w
922 }
923}
924#[doc = "Specifies the match contribution condition for bit slice 2.\n\nValue on reset: 0"]
925#[derive(Clone, Copy, Debug, PartialEq)]
926#[repr(u8)]
927pub enum CFG2_A {
928 #[doc = "0: Constant HIGH. This bit slice always contributes to a product term match."]
929 CONSTANT_HIGH = 0,
930 #[doc = "1: Sticky rising edge. Match occurs if a rising edge on the specified input has occurred since the last time the edge detection for this bit slice was cleared. This bit is only cleared when the PMCFG or the PMSRC registers are written to."]
931 STICKY_RISING_EDGE = 1,
932 #[doc = "2: Sticky falling edge. Match occurs if a falling edge on the specified input has occurred since the last time the edge detection for this bit slice was cleared. This bit is only cleared when the PMCFG or the PMSRC registers are written to."]
933 STICKY_FALLING_EDGE = 2,
934 #[doc = "3: Sticky rising or falling edge. Match occurs if either a rising or falling edge on the specified input has occurred since the last time the edge detection for this bit slice was cleared. This bit is only cleared when the PMCFG or the PMSRC registers are written to."]
935 STICKY_RISING_FALLING_EDGE = 3,
936 #[doc = "4: High level. Match (for this bit slice) occurs when there is a high level on the input specified for this bit slice in the PMSRC register."]
937 HIGH_LEVEL = 4,
938 #[doc = "5: Low level. Match occurs when there is a low level on the specified input."]
939 LOW_LEVEL = 5,
940 #[doc = "6: Constant 0. This bit slice never contributes to a match (should be used to disable any unused bit slices)."]
941 CONSTANT_ZERO = 6,
942 #[doc = "7: Event. Non-sticky rising or falling edge. Match occurs on an event - i.e. when either a rising or falling edge is first detected on the specified input (this is a non-sticky version of value 0x3) . This bit is cleared after one clock cycle."]
943 EVENT = 7,
944}
945impl From<CFG2_A> for u8 {
946 #[inline(always)]
947 fn from(variant: CFG2_A) -> Self {
948 variant as _
949 }
950}
951#[doc = "Field `CFG2` reader - Specifies the match contribution condition for bit slice 2."]
952pub struct CFG2_R(crate::FieldReader<u8, CFG2_A>);
953impl CFG2_R {
954 pub(crate) fn new(bits: u8) -> Self {
955 CFG2_R(crate::FieldReader::new(bits))
956 }
957 #[doc = r"Get enumerated values variant"]
958 #[inline(always)]
959 pub fn variant(&self) -> CFG2_A {
960 match self.bits {
961 0 => CFG2_A::CONSTANT_HIGH,
962 1 => CFG2_A::STICKY_RISING_EDGE,
963 2 => CFG2_A::STICKY_FALLING_EDGE,
964 3 => CFG2_A::STICKY_RISING_FALLING_EDGE,
965 4 => CFG2_A::HIGH_LEVEL,
966 5 => CFG2_A::LOW_LEVEL,
967 6 => CFG2_A::CONSTANT_ZERO,
968 7 => CFG2_A::EVENT,
969 _ => unreachable!(),
970 }
971 }
972 #[doc = "Checks if the value of the field is `CONSTANT_HIGH`"]
973 #[inline(always)]
974 pub fn is_constant_high(&self) -> bool {
975 **self == CFG2_A::CONSTANT_HIGH
976 }
977 #[doc = "Checks if the value of the field is `STICKY_RISING_EDGE`"]
978 #[inline(always)]
979 pub fn is_sticky_rising_edge(&self) -> bool {
980 **self == CFG2_A::STICKY_RISING_EDGE
981 }
982 #[doc = "Checks if the value of the field is `STICKY_FALLING_EDGE`"]
983 #[inline(always)]
984 pub fn is_sticky_falling_edge(&self) -> bool {
985 **self == CFG2_A::STICKY_FALLING_EDGE
986 }
987 #[doc = "Checks if the value of the field is `STICKY_RISING_FALLING_EDGE`"]
988 #[inline(always)]
989 pub fn is_sticky_rising_falling_edge(&self) -> bool {
990 **self == CFG2_A::STICKY_RISING_FALLING_EDGE
991 }
992 #[doc = "Checks if the value of the field is `HIGH_LEVEL`"]
993 #[inline(always)]
994 pub fn is_high_level(&self) -> bool {
995 **self == CFG2_A::HIGH_LEVEL
996 }
997 #[doc = "Checks if the value of the field is `LOW_LEVEL`"]
998 #[inline(always)]
999 pub fn is_low_level(&self) -> bool {
1000 **self == CFG2_A::LOW_LEVEL
1001 }
1002 #[doc = "Checks if the value of the field is `CONSTANT_ZERO`"]
1003 #[inline(always)]
1004 pub fn is_constant_zero(&self) -> bool {
1005 **self == CFG2_A::CONSTANT_ZERO
1006 }
1007 #[doc = "Checks if the value of the field is `EVENT`"]
1008 #[inline(always)]
1009 pub fn is_event(&self) -> bool {
1010 **self == CFG2_A::EVENT
1011 }
1012}
1013impl core::ops::Deref for CFG2_R {
1014 type Target = crate::FieldReader<u8, CFG2_A>;
1015 #[inline(always)]
1016 fn deref(&self) -> &Self::Target {
1017 &self.0
1018 }
1019}
1020#[doc = "Field `CFG2` writer - Specifies the match contribution condition for bit slice 2."]
1021pub struct CFG2_W<'a> {
1022 w: &'a mut W,
1023}
1024impl<'a> CFG2_W<'a> {
1025 #[doc = r"Writes `variant` to the field"]
1026 #[inline(always)]
1027 pub fn variant(self, variant: CFG2_A) -> &'a mut W {
1028 self.bits(variant.into())
1029 }
1030 #[doc = "Constant HIGH. This bit slice always contributes to a product term match."]
1031 #[inline(always)]
1032 pub fn constant_high(self) -> &'a mut W {
1033 self.variant(CFG2_A::CONSTANT_HIGH)
1034 }
1035 #[doc = "Sticky rising edge. Match occurs if a rising edge on the specified input has occurred since the last time the edge detection for this bit slice was cleared. This bit is only cleared when the PMCFG or the PMSRC registers are written to."]
1036 #[inline(always)]
1037 pub fn sticky_rising_edge(self) -> &'a mut W {
1038 self.variant(CFG2_A::STICKY_RISING_EDGE)
1039 }
1040 #[doc = "Sticky falling edge. Match occurs if a falling edge on the specified input has occurred since the last time the edge detection for this bit slice was cleared. This bit is only cleared when the PMCFG or the PMSRC registers are written to."]
1041 #[inline(always)]
1042 pub fn sticky_falling_edge(self) -> &'a mut W {
1043 self.variant(CFG2_A::STICKY_FALLING_EDGE)
1044 }
1045 #[doc = "Sticky rising or falling edge. Match occurs if either a rising or falling edge on the specified input has occurred since the last time the edge detection for this bit slice was cleared. This bit is only cleared when the PMCFG or the PMSRC registers are written to."]
1046 #[inline(always)]
1047 pub fn sticky_rising_falling_edge(self) -> &'a mut W {
1048 self.variant(CFG2_A::STICKY_RISING_FALLING_EDGE)
1049 }
1050 #[doc = "High level. Match (for this bit slice) occurs when there is a high level on the input specified for this bit slice in the PMSRC register."]
1051 #[inline(always)]
1052 pub fn high_level(self) -> &'a mut W {
1053 self.variant(CFG2_A::HIGH_LEVEL)
1054 }
1055 #[doc = "Low level. Match occurs when there is a low level on the specified input."]
1056 #[inline(always)]
1057 pub fn low_level(self) -> &'a mut W {
1058 self.variant(CFG2_A::LOW_LEVEL)
1059 }
1060 #[doc = "Constant 0. This bit slice never contributes to a match (should be used to disable any unused bit slices)."]
1061 #[inline(always)]
1062 pub fn constant_zero(self) -> &'a mut W {
1063 self.variant(CFG2_A::CONSTANT_ZERO)
1064 }
1065 #[doc = "Event. Non-sticky rising or falling edge. Match occurs on an event - i.e. when either a rising or falling edge is first detected on the specified input (this is a non-sticky version of value 0x3) . This bit is cleared after one clock cycle."]
1066 #[inline(always)]
1067 pub fn event(self) -> &'a mut W {
1068 self.variant(CFG2_A::EVENT)
1069 }
1070 #[doc = r"Writes raw bits to the field"]
1071 #[inline(always)]
1072 pub fn bits(self, value: u8) -> &'a mut W {
1073 self.w.bits = (self.w.bits & !(0x07 << 14)) | ((value as u32 & 0x07) << 14);
1074 self.w
1075 }
1076}
1077#[doc = "Specifies the match contribution condition for bit slice 3.\n\nValue on reset: 0"]
1078#[derive(Clone, Copy, Debug, PartialEq)]
1079#[repr(u8)]
1080pub enum CFG3_A {
1081 #[doc = "0: Constant HIGH. This bit slice always contributes to a product term match."]
1082 CONSTANT_HIGH = 0,
1083 #[doc = "1: Sticky rising edge. Match occurs if a rising edge on the specified input has occurred since the last time the edge detection for this bit slice was cleared. This bit is only cleared when the PMCFG or the PMSRC registers are written to."]
1084 STICKY_RISING_EDGE = 1,
1085 #[doc = "2: Sticky falling edge. Match occurs if a falling edge on the specified input has occurred since the last time the edge detection for this bit slice was cleared. This bit is only cleared when the PMCFG or the PMSRC registers are written to."]
1086 STICKY_FALLING_EDGE = 2,
1087 #[doc = "3: Sticky rising or falling edge. Match occurs if either a rising or falling edge on the specified input has occurred since the last time the edge detection for this bit slice was cleared. This bit is only cleared when the PMCFG or the PMSRC registers are written to."]
1088 STICKY_RISING_FALLING_EDGE = 3,
1089 #[doc = "4: High level. Match (for this bit slice) occurs when there is a high level on the input specified for this bit slice in the PMSRC register."]
1090 HIGH_LEVEL = 4,
1091 #[doc = "5: Low level. Match occurs when there is a low level on the specified input."]
1092 LOW_LEVEL = 5,
1093 #[doc = "6: Constant 0. This bit slice never contributes to a match (should be used to disable any unused bit slices)."]
1094 CONSTANT_ZERO = 6,
1095 #[doc = "7: Event. Non-sticky rising or falling edge. Match occurs on an event - i.e. when either a rising or falling edge is first detected on the specified input (this is a non-sticky version of value 0x3) . This bit is cleared after one clock cycle."]
1096 EVENT = 7,
1097}
1098impl From<CFG3_A> for u8 {
1099 #[inline(always)]
1100 fn from(variant: CFG3_A) -> Self {
1101 variant as _
1102 }
1103}
1104#[doc = "Field `CFG3` reader - Specifies the match contribution condition for bit slice 3."]
1105pub struct CFG3_R(crate::FieldReader<u8, CFG3_A>);
1106impl CFG3_R {
1107 pub(crate) fn new(bits: u8) -> Self {
1108 CFG3_R(crate::FieldReader::new(bits))
1109 }
1110 #[doc = r"Get enumerated values variant"]
1111 #[inline(always)]
1112 pub fn variant(&self) -> CFG3_A {
1113 match self.bits {
1114 0 => CFG3_A::CONSTANT_HIGH,
1115 1 => CFG3_A::STICKY_RISING_EDGE,
1116 2 => CFG3_A::STICKY_FALLING_EDGE,
1117 3 => CFG3_A::STICKY_RISING_FALLING_EDGE,
1118 4 => CFG3_A::HIGH_LEVEL,
1119 5 => CFG3_A::LOW_LEVEL,
1120 6 => CFG3_A::CONSTANT_ZERO,
1121 7 => CFG3_A::EVENT,
1122 _ => unreachable!(),
1123 }
1124 }
1125 #[doc = "Checks if the value of the field is `CONSTANT_HIGH`"]
1126 #[inline(always)]
1127 pub fn is_constant_high(&self) -> bool {
1128 **self == CFG3_A::CONSTANT_HIGH
1129 }
1130 #[doc = "Checks if the value of the field is `STICKY_RISING_EDGE`"]
1131 #[inline(always)]
1132 pub fn is_sticky_rising_edge(&self) -> bool {
1133 **self == CFG3_A::STICKY_RISING_EDGE
1134 }
1135 #[doc = "Checks if the value of the field is `STICKY_FALLING_EDGE`"]
1136 #[inline(always)]
1137 pub fn is_sticky_falling_edge(&self) -> bool {
1138 **self == CFG3_A::STICKY_FALLING_EDGE
1139 }
1140 #[doc = "Checks if the value of the field is `STICKY_RISING_FALLING_EDGE`"]
1141 #[inline(always)]
1142 pub fn is_sticky_rising_falling_edge(&self) -> bool {
1143 **self == CFG3_A::STICKY_RISING_FALLING_EDGE
1144 }
1145 #[doc = "Checks if the value of the field is `HIGH_LEVEL`"]
1146 #[inline(always)]
1147 pub fn is_high_level(&self) -> bool {
1148 **self == CFG3_A::HIGH_LEVEL
1149 }
1150 #[doc = "Checks if the value of the field is `LOW_LEVEL`"]
1151 #[inline(always)]
1152 pub fn is_low_level(&self) -> bool {
1153 **self == CFG3_A::LOW_LEVEL
1154 }
1155 #[doc = "Checks if the value of the field is `CONSTANT_ZERO`"]
1156 #[inline(always)]
1157 pub fn is_constant_zero(&self) -> bool {
1158 **self == CFG3_A::CONSTANT_ZERO
1159 }
1160 #[doc = "Checks if the value of the field is `EVENT`"]
1161 #[inline(always)]
1162 pub fn is_event(&self) -> bool {
1163 **self == CFG3_A::EVENT
1164 }
1165}
1166impl core::ops::Deref for CFG3_R {
1167 type Target = crate::FieldReader<u8, CFG3_A>;
1168 #[inline(always)]
1169 fn deref(&self) -> &Self::Target {
1170 &self.0
1171 }
1172}
1173#[doc = "Field `CFG3` writer - Specifies the match contribution condition for bit slice 3."]
1174pub struct CFG3_W<'a> {
1175 w: &'a mut W,
1176}
1177impl<'a> CFG3_W<'a> {
1178 #[doc = r"Writes `variant` to the field"]
1179 #[inline(always)]
1180 pub fn variant(self, variant: CFG3_A) -> &'a mut W {
1181 self.bits(variant.into())
1182 }
1183 #[doc = "Constant HIGH. This bit slice always contributes to a product term match."]
1184 #[inline(always)]
1185 pub fn constant_high(self) -> &'a mut W {
1186 self.variant(CFG3_A::CONSTANT_HIGH)
1187 }
1188 #[doc = "Sticky rising edge. Match occurs if a rising edge on the specified input has occurred since the last time the edge detection for this bit slice was cleared. This bit is only cleared when the PMCFG or the PMSRC registers are written to."]
1189 #[inline(always)]
1190 pub fn sticky_rising_edge(self) -> &'a mut W {
1191 self.variant(CFG3_A::STICKY_RISING_EDGE)
1192 }
1193 #[doc = "Sticky falling edge. Match occurs if a falling edge on the specified input has occurred since the last time the edge detection for this bit slice was cleared. This bit is only cleared when the PMCFG or the PMSRC registers are written to."]
1194 #[inline(always)]
1195 pub fn sticky_falling_edge(self) -> &'a mut W {
1196 self.variant(CFG3_A::STICKY_FALLING_EDGE)
1197 }
1198 #[doc = "Sticky rising or falling edge. Match occurs if either a rising or falling edge on the specified input has occurred since the last time the edge detection for this bit slice was cleared. This bit is only cleared when the PMCFG or the PMSRC registers are written to."]
1199 #[inline(always)]
1200 pub fn sticky_rising_falling_edge(self) -> &'a mut W {
1201 self.variant(CFG3_A::STICKY_RISING_FALLING_EDGE)
1202 }
1203 #[doc = "High level. Match (for this bit slice) occurs when there is a high level on the input specified for this bit slice in the PMSRC register."]
1204 #[inline(always)]
1205 pub fn high_level(self) -> &'a mut W {
1206 self.variant(CFG3_A::HIGH_LEVEL)
1207 }
1208 #[doc = "Low level. Match occurs when there is a low level on the specified input."]
1209 #[inline(always)]
1210 pub fn low_level(self) -> &'a mut W {
1211 self.variant(CFG3_A::LOW_LEVEL)
1212 }
1213 #[doc = "Constant 0. This bit slice never contributes to a match (should be used to disable any unused bit slices)."]
1214 #[inline(always)]
1215 pub fn constant_zero(self) -> &'a mut W {
1216 self.variant(CFG3_A::CONSTANT_ZERO)
1217 }
1218 #[doc = "Event. Non-sticky rising or falling edge. Match occurs on an event - i.e. when either a rising or falling edge is first detected on the specified input (this is a non-sticky version of value 0x3) . This bit is cleared after one clock cycle."]
1219 #[inline(always)]
1220 pub fn event(self) -> &'a mut W {
1221 self.variant(CFG3_A::EVENT)
1222 }
1223 #[doc = r"Writes raw bits to the field"]
1224 #[inline(always)]
1225 pub fn bits(self, value: u8) -> &'a mut W {
1226 self.w.bits = (self.w.bits & !(0x07 << 17)) | ((value as u32 & 0x07) << 17);
1227 self.w
1228 }
1229}
1230#[doc = "Specifies the match contribution condition for bit slice 4.\n\nValue on reset: 0"]
1231#[derive(Clone, Copy, Debug, PartialEq)]
1232#[repr(u8)]
1233pub enum CFG4_A {
1234 #[doc = "0: Constant HIGH. This bit slice always contributes to a product term match."]
1235 CONSTANT_HIGH = 0,
1236 #[doc = "1: Sticky rising edge. Match occurs if a rising edge on the specified input has occurred since the last time the edge detection for this bit slice was cleared. This bit is only cleared when the PMCFG or the PMSRC registers are written to."]
1237 STICKY_RISING_EDGE = 1,
1238 #[doc = "2: Sticky falling edge. Match occurs if a falling edge on the specified input has occurred since the last time the edge detection for this bit slice was cleared. This bit is only cleared when the PMCFG or the PMSRC registers are written to."]
1239 STICKY_FALLING_EDGE = 2,
1240 #[doc = "3: Sticky rising or falling edge. Match occurs if either a rising or falling edge on the specified input has occurred since the last time the edge detection for this bit slice was cleared. This bit is only cleared when the PMCFG or the PMSRC registers are written to."]
1241 STICKY_RISING_FALLING_EDGE = 3,
1242 #[doc = "4: High level. Match (for this bit slice) occurs when there is a high level on the input specified for this bit slice in the PMSRC register."]
1243 HIGH_LEVEL = 4,
1244 #[doc = "5: Low level. Match occurs when there is a low level on the specified input."]
1245 LOW_LEVEL = 5,
1246 #[doc = "6: Constant 0. This bit slice never contributes to a match (should be used to disable any unused bit slices)."]
1247 CONSTANT_ZERO = 6,
1248 #[doc = "7: Event. Non-sticky rising or falling edge. Match occurs on an event - i.e. when either a rising or falling edge is first detected on the specified input (this is a non-sticky version of value 0x3) . This bit is cleared after one clock cycle."]
1249 EVENT = 7,
1250}
1251impl From<CFG4_A> for u8 {
1252 #[inline(always)]
1253 fn from(variant: CFG4_A) -> Self {
1254 variant as _
1255 }
1256}
1257#[doc = "Field `CFG4` reader - Specifies the match contribution condition for bit slice 4."]
1258pub struct CFG4_R(crate::FieldReader<u8, CFG4_A>);
1259impl CFG4_R {
1260 pub(crate) fn new(bits: u8) -> Self {
1261 CFG4_R(crate::FieldReader::new(bits))
1262 }
1263 #[doc = r"Get enumerated values variant"]
1264 #[inline(always)]
1265 pub fn variant(&self) -> CFG4_A {
1266 match self.bits {
1267 0 => CFG4_A::CONSTANT_HIGH,
1268 1 => CFG4_A::STICKY_RISING_EDGE,
1269 2 => CFG4_A::STICKY_FALLING_EDGE,
1270 3 => CFG4_A::STICKY_RISING_FALLING_EDGE,
1271 4 => CFG4_A::HIGH_LEVEL,
1272 5 => CFG4_A::LOW_LEVEL,
1273 6 => CFG4_A::CONSTANT_ZERO,
1274 7 => CFG4_A::EVENT,
1275 _ => unreachable!(),
1276 }
1277 }
1278 #[doc = "Checks if the value of the field is `CONSTANT_HIGH`"]
1279 #[inline(always)]
1280 pub fn is_constant_high(&self) -> bool {
1281 **self == CFG4_A::CONSTANT_HIGH
1282 }
1283 #[doc = "Checks if the value of the field is `STICKY_RISING_EDGE`"]
1284 #[inline(always)]
1285 pub fn is_sticky_rising_edge(&self) -> bool {
1286 **self == CFG4_A::STICKY_RISING_EDGE
1287 }
1288 #[doc = "Checks if the value of the field is `STICKY_FALLING_EDGE`"]
1289 #[inline(always)]
1290 pub fn is_sticky_falling_edge(&self) -> bool {
1291 **self == CFG4_A::STICKY_FALLING_EDGE
1292 }
1293 #[doc = "Checks if the value of the field is `STICKY_RISING_FALLING_EDGE`"]
1294 #[inline(always)]
1295 pub fn is_sticky_rising_falling_edge(&self) -> bool {
1296 **self == CFG4_A::STICKY_RISING_FALLING_EDGE
1297 }
1298 #[doc = "Checks if the value of the field is `HIGH_LEVEL`"]
1299 #[inline(always)]
1300 pub fn is_high_level(&self) -> bool {
1301 **self == CFG4_A::HIGH_LEVEL
1302 }
1303 #[doc = "Checks if the value of the field is `LOW_LEVEL`"]
1304 #[inline(always)]
1305 pub fn is_low_level(&self) -> bool {
1306 **self == CFG4_A::LOW_LEVEL
1307 }
1308 #[doc = "Checks if the value of the field is `CONSTANT_ZERO`"]
1309 #[inline(always)]
1310 pub fn is_constant_zero(&self) -> bool {
1311 **self == CFG4_A::CONSTANT_ZERO
1312 }
1313 #[doc = "Checks if the value of the field is `EVENT`"]
1314 #[inline(always)]
1315 pub fn is_event(&self) -> bool {
1316 **self == CFG4_A::EVENT
1317 }
1318}
1319impl core::ops::Deref for CFG4_R {
1320 type Target = crate::FieldReader<u8, CFG4_A>;
1321 #[inline(always)]
1322 fn deref(&self) -> &Self::Target {
1323 &self.0
1324 }
1325}
1326#[doc = "Field `CFG4` writer - Specifies the match contribution condition for bit slice 4."]
1327pub struct CFG4_W<'a> {
1328 w: &'a mut W,
1329}
1330impl<'a> CFG4_W<'a> {
1331 #[doc = r"Writes `variant` to the field"]
1332 #[inline(always)]
1333 pub fn variant(self, variant: CFG4_A) -> &'a mut W {
1334 self.bits(variant.into())
1335 }
1336 #[doc = "Constant HIGH. This bit slice always contributes to a product term match."]
1337 #[inline(always)]
1338 pub fn constant_high(self) -> &'a mut W {
1339 self.variant(CFG4_A::CONSTANT_HIGH)
1340 }
1341 #[doc = "Sticky rising edge. Match occurs if a rising edge on the specified input has occurred since the last time the edge detection for this bit slice was cleared. This bit is only cleared when the PMCFG or the PMSRC registers are written to."]
1342 #[inline(always)]
1343 pub fn sticky_rising_edge(self) -> &'a mut W {
1344 self.variant(CFG4_A::STICKY_RISING_EDGE)
1345 }
1346 #[doc = "Sticky falling edge. Match occurs if a falling edge on the specified input has occurred since the last time the edge detection for this bit slice was cleared. This bit is only cleared when the PMCFG or the PMSRC registers are written to."]
1347 #[inline(always)]
1348 pub fn sticky_falling_edge(self) -> &'a mut W {
1349 self.variant(CFG4_A::STICKY_FALLING_EDGE)
1350 }
1351 #[doc = "Sticky rising or falling edge. Match occurs if either a rising or falling edge on the specified input has occurred since the last time the edge detection for this bit slice was cleared. This bit is only cleared when the PMCFG or the PMSRC registers are written to."]
1352 #[inline(always)]
1353 pub fn sticky_rising_falling_edge(self) -> &'a mut W {
1354 self.variant(CFG4_A::STICKY_RISING_FALLING_EDGE)
1355 }
1356 #[doc = "High level. Match (for this bit slice) occurs when there is a high level on the input specified for this bit slice in the PMSRC register."]
1357 #[inline(always)]
1358 pub fn high_level(self) -> &'a mut W {
1359 self.variant(CFG4_A::HIGH_LEVEL)
1360 }
1361 #[doc = "Low level. Match occurs when there is a low level on the specified input."]
1362 #[inline(always)]
1363 pub fn low_level(self) -> &'a mut W {
1364 self.variant(CFG4_A::LOW_LEVEL)
1365 }
1366 #[doc = "Constant 0. This bit slice never contributes to a match (should be used to disable any unused bit slices)."]
1367 #[inline(always)]
1368 pub fn constant_zero(self) -> &'a mut W {
1369 self.variant(CFG4_A::CONSTANT_ZERO)
1370 }
1371 #[doc = "Event. Non-sticky rising or falling edge. Match occurs on an event - i.e. when either a rising or falling edge is first detected on the specified input (this is a non-sticky version of value 0x3) . This bit is cleared after one clock cycle."]
1372 #[inline(always)]
1373 pub fn event(self) -> &'a mut W {
1374 self.variant(CFG4_A::EVENT)
1375 }
1376 #[doc = r"Writes raw bits to the field"]
1377 #[inline(always)]
1378 pub fn bits(self, value: u8) -> &'a mut W {
1379 self.w.bits = (self.w.bits & !(0x07 << 20)) | ((value as u32 & 0x07) << 20);
1380 self.w
1381 }
1382}
1383#[doc = "Specifies the match contribution condition for bit slice 5.\n\nValue on reset: 0"]
1384#[derive(Clone, Copy, Debug, PartialEq)]
1385#[repr(u8)]
1386pub enum CFG5_A {
1387 #[doc = "0: Constant HIGH. This bit slice always contributes to a product term match."]
1388 CONSTANT_HIGH = 0,
1389 #[doc = "1: Sticky rising edge. Match occurs if a rising edge on the specified input has occurred since the last time the edge detection for this bit slice was cleared. This bit is only cleared when the PMCFG or the PMSRC registers are written to."]
1390 STICKY_RISING_EDGE = 1,
1391 #[doc = "2: Sticky falling edge. Match occurs if a falling edge on the specified input has occurred since the last time the edge detection for this bit slice was cleared. This bit is only cleared when the PMCFG or the PMSRC registers are written to."]
1392 STICKY_FALLING_EDGE = 2,
1393 #[doc = "3: Sticky rising or falling edge. Match occurs if either a rising or falling edge on the specified input has occurred since the last time the edge detection for this bit slice was cleared. This bit is only cleared when the PMCFG or the PMSRC registers are written to."]
1394 STICKY_RISING_FALLING_EDGE = 3,
1395 #[doc = "4: High level. Match (for this bit slice) occurs when there is a high level on the input specified for this bit slice in the PMSRC register."]
1396 HIGH_LEVEL = 4,
1397 #[doc = "5: Low level. Match occurs when there is a low level on the specified input."]
1398 LOW_LEVEL = 5,
1399 #[doc = "6: Constant 0. This bit slice never contributes to a match (should be used to disable any unused bit slices)."]
1400 CONSTANT_ZERO = 6,
1401 #[doc = "7: Event. Non-sticky rising or falling edge. Match occurs on an event - i.e. when either a rising or falling edge is first detected on the specified input (this is a non-sticky version of value 0x3) . This bit is cleared after one clock cycle."]
1402 EVENT = 7,
1403}
1404impl From<CFG5_A> for u8 {
1405 #[inline(always)]
1406 fn from(variant: CFG5_A) -> Self {
1407 variant as _
1408 }
1409}
1410#[doc = "Field `CFG5` reader - Specifies the match contribution condition for bit slice 5."]
1411pub struct CFG5_R(crate::FieldReader<u8, CFG5_A>);
1412impl CFG5_R {
1413 pub(crate) fn new(bits: u8) -> Self {
1414 CFG5_R(crate::FieldReader::new(bits))
1415 }
1416 #[doc = r"Get enumerated values variant"]
1417 #[inline(always)]
1418 pub fn variant(&self) -> CFG5_A {
1419 match self.bits {
1420 0 => CFG5_A::CONSTANT_HIGH,
1421 1 => CFG5_A::STICKY_RISING_EDGE,
1422 2 => CFG5_A::STICKY_FALLING_EDGE,
1423 3 => CFG5_A::STICKY_RISING_FALLING_EDGE,
1424 4 => CFG5_A::HIGH_LEVEL,
1425 5 => CFG5_A::LOW_LEVEL,
1426 6 => CFG5_A::CONSTANT_ZERO,
1427 7 => CFG5_A::EVENT,
1428 _ => unreachable!(),
1429 }
1430 }
1431 #[doc = "Checks if the value of the field is `CONSTANT_HIGH`"]
1432 #[inline(always)]
1433 pub fn is_constant_high(&self) -> bool {
1434 **self == CFG5_A::CONSTANT_HIGH
1435 }
1436 #[doc = "Checks if the value of the field is `STICKY_RISING_EDGE`"]
1437 #[inline(always)]
1438 pub fn is_sticky_rising_edge(&self) -> bool {
1439 **self == CFG5_A::STICKY_RISING_EDGE
1440 }
1441 #[doc = "Checks if the value of the field is `STICKY_FALLING_EDGE`"]
1442 #[inline(always)]
1443 pub fn is_sticky_falling_edge(&self) -> bool {
1444 **self == CFG5_A::STICKY_FALLING_EDGE
1445 }
1446 #[doc = "Checks if the value of the field is `STICKY_RISING_FALLING_EDGE`"]
1447 #[inline(always)]
1448 pub fn is_sticky_rising_falling_edge(&self) -> bool {
1449 **self == CFG5_A::STICKY_RISING_FALLING_EDGE
1450 }
1451 #[doc = "Checks if the value of the field is `HIGH_LEVEL`"]
1452 #[inline(always)]
1453 pub fn is_high_level(&self) -> bool {
1454 **self == CFG5_A::HIGH_LEVEL
1455 }
1456 #[doc = "Checks if the value of the field is `LOW_LEVEL`"]
1457 #[inline(always)]
1458 pub fn is_low_level(&self) -> bool {
1459 **self == CFG5_A::LOW_LEVEL
1460 }
1461 #[doc = "Checks if the value of the field is `CONSTANT_ZERO`"]
1462 #[inline(always)]
1463 pub fn is_constant_zero(&self) -> bool {
1464 **self == CFG5_A::CONSTANT_ZERO
1465 }
1466 #[doc = "Checks if the value of the field is `EVENT`"]
1467 #[inline(always)]
1468 pub fn is_event(&self) -> bool {
1469 **self == CFG5_A::EVENT
1470 }
1471}
1472impl core::ops::Deref for CFG5_R {
1473 type Target = crate::FieldReader<u8, CFG5_A>;
1474 #[inline(always)]
1475 fn deref(&self) -> &Self::Target {
1476 &self.0
1477 }
1478}
1479#[doc = "Field `CFG5` writer - Specifies the match contribution condition for bit slice 5."]
1480pub struct CFG5_W<'a> {
1481 w: &'a mut W,
1482}
1483impl<'a> CFG5_W<'a> {
1484 #[doc = r"Writes `variant` to the field"]
1485 #[inline(always)]
1486 pub fn variant(self, variant: CFG5_A) -> &'a mut W {
1487 self.bits(variant.into())
1488 }
1489 #[doc = "Constant HIGH. This bit slice always contributes to a product term match."]
1490 #[inline(always)]
1491 pub fn constant_high(self) -> &'a mut W {
1492 self.variant(CFG5_A::CONSTANT_HIGH)
1493 }
1494 #[doc = "Sticky rising edge. Match occurs if a rising edge on the specified input has occurred since the last time the edge detection for this bit slice was cleared. This bit is only cleared when the PMCFG or the PMSRC registers are written to."]
1495 #[inline(always)]
1496 pub fn sticky_rising_edge(self) -> &'a mut W {
1497 self.variant(CFG5_A::STICKY_RISING_EDGE)
1498 }
1499 #[doc = "Sticky falling edge. Match occurs if a falling edge on the specified input has occurred since the last time the edge detection for this bit slice was cleared. This bit is only cleared when the PMCFG or the PMSRC registers are written to."]
1500 #[inline(always)]
1501 pub fn sticky_falling_edge(self) -> &'a mut W {
1502 self.variant(CFG5_A::STICKY_FALLING_EDGE)
1503 }
1504 #[doc = "Sticky rising or falling edge. Match occurs if either a rising or falling edge on the specified input has occurred since the last time the edge detection for this bit slice was cleared. This bit is only cleared when the PMCFG or the PMSRC registers are written to."]
1505 #[inline(always)]
1506 pub fn sticky_rising_falling_edge(self) -> &'a mut W {
1507 self.variant(CFG5_A::STICKY_RISING_FALLING_EDGE)
1508 }
1509 #[doc = "High level. Match (for this bit slice) occurs when there is a high level on the input specified for this bit slice in the PMSRC register."]
1510 #[inline(always)]
1511 pub fn high_level(self) -> &'a mut W {
1512 self.variant(CFG5_A::HIGH_LEVEL)
1513 }
1514 #[doc = "Low level. Match occurs when there is a low level on the specified input."]
1515 #[inline(always)]
1516 pub fn low_level(self) -> &'a mut W {
1517 self.variant(CFG5_A::LOW_LEVEL)
1518 }
1519 #[doc = "Constant 0. This bit slice never contributes to a match (should be used to disable any unused bit slices)."]
1520 #[inline(always)]
1521 pub fn constant_zero(self) -> &'a mut W {
1522 self.variant(CFG5_A::CONSTANT_ZERO)
1523 }
1524 #[doc = "Event. Non-sticky rising or falling edge. Match occurs on an event - i.e. when either a rising or falling edge is first detected on the specified input (this is a non-sticky version of value 0x3) . This bit is cleared after one clock cycle."]
1525 #[inline(always)]
1526 pub fn event(self) -> &'a mut W {
1527 self.variant(CFG5_A::EVENT)
1528 }
1529 #[doc = r"Writes raw bits to the field"]
1530 #[inline(always)]
1531 pub fn bits(self, value: u8) -> &'a mut W {
1532 self.w.bits = (self.w.bits & !(0x07 << 23)) | ((value as u32 & 0x07) << 23);
1533 self.w
1534 }
1535}
1536#[doc = "Specifies the match contribution condition for bit slice 6.\n\nValue on reset: 0"]
1537#[derive(Clone, Copy, Debug, PartialEq)]
1538#[repr(u8)]
1539pub enum CFG6_A {
1540 #[doc = "0: Constant HIGH. This bit slice always contributes to a product term match."]
1541 CONSTANT_HIGH = 0,
1542 #[doc = "1: Sticky rising edge. Match occurs if a rising edge on the specified input has occurred since the last time the edge detection for this bit slice was cleared. This bit is only cleared when the PMCFG or the PMSRC registers are written to."]
1543 STICKY_RISING_EDGE = 1,
1544 #[doc = "2: Sticky falling edge. Match occurs if a falling edge on the specified input has occurred since the last time the edge detection for this bit slice was cleared. This bit is only cleared when the PMCFG or the PMSRC registers are written to."]
1545 STICKY_FALLING_EDGE = 2,
1546 #[doc = "3: Sticky rising or falling edge. Match occurs if either a rising or falling edge on the specified input has occurred since the last time the edge detection for this bit slice was cleared. This bit is only cleared when the PMCFG or the PMSRC registers are written to."]
1547 STICKY_RISING_FALLING_EDGE = 3,
1548 #[doc = "4: High level. Match (for this bit slice) occurs when there is a high level on the input specified for this bit slice in the PMSRC register."]
1549 HIGH_LEVEL = 4,
1550 #[doc = "5: Low level. Match occurs when there is a low level on the specified input."]
1551 LOW_LEVEL = 5,
1552 #[doc = "6: Constant 0. This bit slice never contributes to a match (should be used to disable any unused bit slices)."]
1553 CONSTANT_ZERO = 6,
1554 #[doc = "7: Event. Non-sticky rising or falling edge. Match occurs on an event - i.e. when either a rising or falling edge is first detected on the specified input (this is a non-sticky version of value 0x3) . This bit is cleared after one clock cycle."]
1555 EVENT = 7,
1556}
1557impl From<CFG6_A> for u8 {
1558 #[inline(always)]
1559 fn from(variant: CFG6_A) -> Self {
1560 variant as _
1561 }
1562}
1563#[doc = "Field `CFG6` reader - Specifies the match contribution condition for bit slice 6."]
1564pub struct CFG6_R(crate::FieldReader<u8, CFG6_A>);
1565impl CFG6_R {
1566 pub(crate) fn new(bits: u8) -> Self {
1567 CFG6_R(crate::FieldReader::new(bits))
1568 }
1569 #[doc = r"Get enumerated values variant"]
1570 #[inline(always)]
1571 pub fn variant(&self) -> CFG6_A {
1572 match self.bits {
1573 0 => CFG6_A::CONSTANT_HIGH,
1574 1 => CFG6_A::STICKY_RISING_EDGE,
1575 2 => CFG6_A::STICKY_FALLING_EDGE,
1576 3 => CFG6_A::STICKY_RISING_FALLING_EDGE,
1577 4 => CFG6_A::HIGH_LEVEL,
1578 5 => CFG6_A::LOW_LEVEL,
1579 6 => CFG6_A::CONSTANT_ZERO,
1580 7 => CFG6_A::EVENT,
1581 _ => unreachable!(),
1582 }
1583 }
1584 #[doc = "Checks if the value of the field is `CONSTANT_HIGH`"]
1585 #[inline(always)]
1586 pub fn is_constant_high(&self) -> bool {
1587 **self == CFG6_A::CONSTANT_HIGH
1588 }
1589 #[doc = "Checks if the value of the field is `STICKY_RISING_EDGE`"]
1590 #[inline(always)]
1591 pub fn is_sticky_rising_edge(&self) -> bool {
1592 **self == CFG6_A::STICKY_RISING_EDGE
1593 }
1594 #[doc = "Checks if the value of the field is `STICKY_FALLING_EDGE`"]
1595 #[inline(always)]
1596 pub fn is_sticky_falling_edge(&self) -> bool {
1597 **self == CFG6_A::STICKY_FALLING_EDGE
1598 }
1599 #[doc = "Checks if the value of the field is `STICKY_RISING_FALLING_EDGE`"]
1600 #[inline(always)]
1601 pub fn is_sticky_rising_falling_edge(&self) -> bool {
1602 **self == CFG6_A::STICKY_RISING_FALLING_EDGE
1603 }
1604 #[doc = "Checks if the value of the field is `HIGH_LEVEL`"]
1605 #[inline(always)]
1606 pub fn is_high_level(&self) -> bool {
1607 **self == CFG6_A::HIGH_LEVEL
1608 }
1609 #[doc = "Checks if the value of the field is `LOW_LEVEL`"]
1610 #[inline(always)]
1611 pub fn is_low_level(&self) -> bool {
1612 **self == CFG6_A::LOW_LEVEL
1613 }
1614 #[doc = "Checks if the value of the field is `CONSTANT_ZERO`"]
1615 #[inline(always)]
1616 pub fn is_constant_zero(&self) -> bool {
1617 **self == CFG6_A::CONSTANT_ZERO
1618 }
1619 #[doc = "Checks if the value of the field is `EVENT`"]
1620 #[inline(always)]
1621 pub fn is_event(&self) -> bool {
1622 **self == CFG6_A::EVENT
1623 }
1624}
1625impl core::ops::Deref for CFG6_R {
1626 type Target = crate::FieldReader<u8, CFG6_A>;
1627 #[inline(always)]
1628 fn deref(&self) -> &Self::Target {
1629 &self.0
1630 }
1631}
1632#[doc = "Field `CFG6` writer - Specifies the match contribution condition for bit slice 6."]
1633pub struct CFG6_W<'a> {
1634 w: &'a mut W,
1635}
1636impl<'a> CFG6_W<'a> {
1637 #[doc = r"Writes `variant` to the field"]
1638 #[inline(always)]
1639 pub fn variant(self, variant: CFG6_A) -> &'a mut W {
1640 self.bits(variant.into())
1641 }
1642 #[doc = "Constant HIGH. This bit slice always contributes to a product term match."]
1643 #[inline(always)]
1644 pub fn constant_high(self) -> &'a mut W {
1645 self.variant(CFG6_A::CONSTANT_HIGH)
1646 }
1647 #[doc = "Sticky rising edge. Match occurs if a rising edge on the specified input has occurred since the last time the edge detection for this bit slice was cleared. This bit is only cleared when the PMCFG or the PMSRC registers are written to."]
1648 #[inline(always)]
1649 pub fn sticky_rising_edge(self) -> &'a mut W {
1650 self.variant(CFG6_A::STICKY_RISING_EDGE)
1651 }
1652 #[doc = "Sticky falling edge. Match occurs if a falling edge on the specified input has occurred since the last time the edge detection for this bit slice was cleared. This bit is only cleared when the PMCFG or the PMSRC registers are written to."]
1653 #[inline(always)]
1654 pub fn sticky_falling_edge(self) -> &'a mut W {
1655 self.variant(CFG6_A::STICKY_FALLING_EDGE)
1656 }
1657 #[doc = "Sticky rising or falling edge. Match occurs if either a rising or falling edge on the specified input has occurred since the last time the edge detection for this bit slice was cleared. This bit is only cleared when the PMCFG or the PMSRC registers are written to."]
1658 #[inline(always)]
1659 pub fn sticky_rising_falling_edge(self) -> &'a mut W {
1660 self.variant(CFG6_A::STICKY_RISING_FALLING_EDGE)
1661 }
1662 #[doc = "High level. Match (for this bit slice) occurs when there is a high level on the input specified for this bit slice in the PMSRC register."]
1663 #[inline(always)]
1664 pub fn high_level(self) -> &'a mut W {
1665 self.variant(CFG6_A::HIGH_LEVEL)
1666 }
1667 #[doc = "Low level. Match occurs when there is a low level on the specified input."]
1668 #[inline(always)]
1669 pub fn low_level(self) -> &'a mut W {
1670 self.variant(CFG6_A::LOW_LEVEL)
1671 }
1672 #[doc = "Constant 0. This bit slice never contributes to a match (should be used to disable any unused bit slices)."]
1673 #[inline(always)]
1674 pub fn constant_zero(self) -> &'a mut W {
1675 self.variant(CFG6_A::CONSTANT_ZERO)
1676 }
1677 #[doc = "Event. Non-sticky rising or falling edge. Match occurs on an event - i.e. when either a rising or falling edge is first detected on the specified input (this is a non-sticky version of value 0x3) . This bit is cleared after one clock cycle."]
1678 #[inline(always)]
1679 pub fn event(self) -> &'a mut W {
1680 self.variant(CFG6_A::EVENT)
1681 }
1682 #[doc = r"Writes raw bits to the field"]
1683 #[inline(always)]
1684 pub fn bits(self, value: u8) -> &'a mut W {
1685 self.w.bits = (self.w.bits & !(0x07 << 26)) | ((value as u32 & 0x07) << 26);
1686 self.w
1687 }
1688}
1689#[doc = "Specifies the match contribution condition for bit slice 7.\n\nValue on reset: 0"]
1690#[derive(Clone, Copy, Debug, PartialEq)]
1691#[repr(u8)]
1692pub enum CFG7_A {
1693 #[doc = "0: Constant HIGH. This bit slice always contributes to a product term match."]
1694 CONSTANT_HIGH = 0,
1695 #[doc = "1: Sticky rising edge. Match occurs if a rising edge on the specified input has occurred since the last time the edge detection for this bit slice was cleared. This bit is only cleared when the PMCFG or the PMSRC registers are written to."]
1696 STICKY_RISING_EDGE = 1,
1697 #[doc = "2: Sticky falling edge. Match occurs if a falling edge on the specified input has occurred since the last time the edge detection for this bit slice was cleared. This bit is only cleared when the PMCFG or the PMSRC registers are written to."]
1698 STICKY_FALLING_EDGE = 2,
1699 #[doc = "3: Sticky rising or falling edge. Match occurs if either a rising or falling edge on the specified input has occurred since the last time the edge detection for this bit slice was cleared. This bit is only cleared when the PMCFG or the PMSRC registers are written to."]
1700 STICKY_RISING_FALLING_EDGE = 3,
1701 #[doc = "4: High level. Match (for this bit slice) occurs when there is a high level on the input specified for this bit slice in the PMSRC register."]
1702 HIGH_LEVEL = 4,
1703 #[doc = "5: Low level. Match occurs when there is a low level on the specified input."]
1704 LOW_LEVEL = 5,
1705 #[doc = "6: Constant 0. This bit slice never contributes to a match (should be used to disable any unused bit slices)."]
1706 CONSTANT_ZERO = 6,
1707 #[doc = "7: Event. Non-sticky rising or falling edge. Match occurs on an event - i.e. when either a rising or falling edge is first detected on the specified input (this is a non-sticky version of value 0x3) . This bit is cleared after one clock cycle."]
1708 EVENT = 7,
1709}
1710impl From<CFG7_A> for u8 {
1711 #[inline(always)]
1712 fn from(variant: CFG7_A) -> Self {
1713 variant as _
1714 }
1715}
1716#[doc = "Field `CFG7` reader - Specifies the match contribution condition for bit slice 7."]
1717pub struct CFG7_R(crate::FieldReader<u8, CFG7_A>);
1718impl CFG7_R {
1719 pub(crate) fn new(bits: u8) -> Self {
1720 CFG7_R(crate::FieldReader::new(bits))
1721 }
1722 #[doc = r"Get enumerated values variant"]
1723 #[inline(always)]
1724 pub fn variant(&self) -> CFG7_A {
1725 match self.bits {
1726 0 => CFG7_A::CONSTANT_HIGH,
1727 1 => CFG7_A::STICKY_RISING_EDGE,
1728 2 => CFG7_A::STICKY_FALLING_EDGE,
1729 3 => CFG7_A::STICKY_RISING_FALLING_EDGE,
1730 4 => CFG7_A::HIGH_LEVEL,
1731 5 => CFG7_A::LOW_LEVEL,
1732 6 => CFG7_A::CONSTANT_ZERO,
1733 7 => CFG7_A::EVENT,
1734 _ => unreachable!(),
1735 }
1736 }
1737 #[doc = "Checks if the value of the field is `CONSTANT_HIGH`"]
1738 #[inline(always)]
1739 pub fn is_constant_high(&self) -> bool {
1740 **self == CFG7_A::CONSTANT_HIGH
1741 }
1742 #[doc = "Checks if the value of the field is `STICKY_RISING_EDGE`"]
1743 #[inline(always)]
1744 pub fn is_sticky_rising_edge(&self) -> bool {
1745 **self == CFG7_A::STICKY_RISING_EDGE
1746 }
1747 #[doc = "Checks if the value of the field is `STICKY_FALLING_EDGE`"]
1748 #[inline(always)]
1749 pub fn is_sticky_falling_edge(&self) -> bool {
1750 **self == CFG7_A::STICKY_FALLING_EDGE
1751 }
1752 #[doc = "Checks if the value of the field is `STICKY_RISING_FALLING_EDGE`"]
1753 #[inline(always)]
1754 pub fn is_sticky_rising_falling_edge(&self) -> bool {
1755 **self == CFG7_A::STICKY_RISING_FALLING_EDGE
1756 }
1757 #[doc = "Checks if the value of the field is `HIGH_LEVEL`"]
1758 #[inline(always)]
1759 pub fn is_high_level(&self) -> bool {
1760 **self == CFG7_A::HIGH_LEVEL
1761 }
1762 #[doc = "Checks if the value of the field is `LOW_LEVEL`"]
1763 #[inline(always)]
1764 pub fn is_low_level(&self) -> bool {
1765 **self == CFG7_A::LOW_LEVEL
1766 }
1767 #[doc = "Checks if the value of the field is `CONSTANT_ZERO`"]
1768 #[inline(always)]
1769 pub fn is_constant_zero(&self) -> bool {
1770 **self == CFG7_A::CONSTANT_ZERO
1771 }
1772 #[doc = "Checks if the value of the field is `EVENT`"]
1773 #[inline(always)]
1774 pub fn is_event(&self) -> bool {
1775 **self == CFG7_A::EVENT
1776 }
1777}
1778impl core::ops::Deref for CFG7_R {
1779 type Target = crate::FieldReader<u8, CFG7_A>;
1780 #[inline(always)]
1781 fn deref(&self) -> &Self::Target {
1782 &self.0
1783 }
1784}
1785#[doc = "Field `CFG7` writer - Specifies the match contribution condition for bit slice 7."]
1786pub struct CFG7_W<'a> {
1787 w: &'a mut W,
1788}
1789impl<'a> CFG7_W<'a> {
1790 #[doc = r"Writes `variant` to the field"]
1791 #[inline(always)]
1792 pub fn variant(self, variant: CFG7_A) -> &'a mut W {
1793 self.bits(variant.into())
1794 }
1795 #[doc = "Constant HIGH. This bit slice always contributes to a product term match."]
1796 #[inline(always)]
1797 pub fn constant_high(self) -> &'a mut W {
1798 self.variant(CFG7_A::CONSTANT_HIGH)
1799 }
1800 #[doc = "Sticky rising edge. Match occurs if a rising edge on the specified input has occurred since the last time the edge detection for this bit slice was cleared. This bit is only cleared when the PMCFG or the PMSRC registers are written to."]
1801 #[inline(always)]
1802 pub fn sticky_rising_edge(self) -> &'a mut W {
1803 self.variant(CFG7_A::STICKY_RISING_EDGE)
1804 }
1805 #[doc = "Sticky falling edge. Match occurs if a falling edge on the specified input has occurred since the last time the edge detection for this bit slice was cleared. This bit is only cleared when the PMCFG or the PMSRC registers are written to."]
1806 #[inline(always)]
1807 pub fn sticky_falling_edge(self) -> &'a mut W {
1808 self.variant(CFG7_A::STICKY_FALLING_EDGE)
1809 }
1810 #[doc = "Sticky rising or falling edge. Match occurs if either a rising or falling edge on the specified input has occurred since the last time the edge detection for this bit slice was cleared. This bit is only cleared when the PMCFG or the PMSRC registers are written to."]
1811 #[inline(always)]
1812 pub fn sticky_rising_falling_edge(self) -> &'a mut W {
1813 self.variant(CFG7_A::STICKY_RISING_FALLING_EDGE)
1814 }
1815 #[doc = "High level. Match (for this bit slice) occurs when there is a high level on the input specified for this bit slice in the PMSRC register."]
1816 #[inline(always)]
1817 pub fn high_level(self) -> &'a mut W {
1818 self.variant(CFG7_A::HIGH_LEVEL)
1819 }
1820 #[doc = "Low level. Match occurs when there is a low level on the specified input."]
1821 #[inline(always)]
1822 pub fn low_level(self) -> &'a mut W {
1823 self.variant(CFG7_A::LOW_LEVEL)
1824 }
1825 #[doc = "Constant 0. This bit slice never contributes to a match (should be used to disable any unused bit slices)."]
1826 #[inline(always)]
1827 pub fn constant_zero(self) -> &'a mut W {
1828 self.variant(CFG7_A::CONSTANT_ZERO)
1829 }
1830 #[doc = "Event. Non-sticky rising or falling edge. Match occurs on an event - i.e. when either a rising or falling edge is first detected on the specified input (this is a non-sticky version of value 0x3) . This bit is cleared after one clock cycle."]
1831 #[inline(always)]
1832 pub fn event(self) -> &'a mut W {
1833 self.variant(CFG7_A::EVENT)
1834 }
1835 #[doc = r"Writes raw bits to the field"]
1836 #[inline(always)]
1837 pub fn bits(self, value: u8) -> &'a mut W {
1838 self.w.bits = (self.w.bits & !(0x07 << 29)) | ((value as u32 & 0x07) << 29);
1839 self.w
1840 }
1841}
1842impl R {
1843 #[doc = "Bit 0 - Determines whether slice 0 is an endpoint."]
1844 #[inline(always)]
1845 pub fn prod_endpts0(&self) -> PROD_ENDPTS0_R {
1846 PROD_ENDPTS0_R::new((self.bits & 0x01) != 0)
1847 }
1848 #[doc = "Bit 1 - Determines whether slice 1 is an endpoint."]
1849 #[inline(always)]
1850 pub fn prod_endpts1(&self) -> PROD_ENDPTS1_R {
1851 PROD_ENDPTS1_R::new(((self.bits >> 1) & 0x01) != 0)
1852 }
1853 #[doc = "Bit 2 - Determines whether slice 2 is an endpoint."]
1854 #[inline(always)]
1855 pub fn prod_endpts2(&self) -> PROD_ENDPTS2_R {
1856 PROD_ENDPTS2_R::new(((self.bits >> 2) & 0x01) != 0)
1857 }
1858 #[doc = "Bit 3 - Determines whether slice 3 is an endpoint."]
1859 #[inline(always)]
1860 pub fn prod_endpts3(&self) -> PROD_ENDPTS3_R {
1861 PROD_ENDPTS3_R::new(((self.bits >> 3) & 0x01) != 0)
1862 }
1863 #[doc = "Bit 4 - Determines whether slice 4 is an endpoint."]
1864 #[inline(always)]
1865 pub fn prod_endpts4(&self) -> PROD_ENDPTS4_R {
1866 PROD_ENDPTS4_R::new(((self.bits >> 4) & 0x01) != 0)
1867 }
1868 #[doc = "Bit 5 - Determines whether slice 5 is an endpoint."]
1869 #[inline(always)]
1870 pub fn prod_endpts5(&self) -> PROD_ENDPTS5_R {
1871 PROD_ENDPTS5_R::new(((self.bits >> 5) & 0x01) != 0)
1872 }
1873 #[doc = "Bit 6 - Determines whether slice 6 is an endpoint."]
1874 #[inline(always)]
1875 pub fn prod_endpts6(&self) -> PROD_ENDPTS6_R {
1876 PROD_ENDPTS6_R::new(((self.bits >> 6) & 0x01) != 0)
1877 }
1878 #[doc = "Bits 8:10 - Specifies the match contribution condition for bit slice 0."]
1879 #[inline(always)]
1880 pub fn cfg0(&self) -> CFG0_R {
1881 CFG0_R::new(((self.bits >> 8) & 0x07) as u8)
1882 }
1883 #[doc = "Bits 11:13 - Specifies the match contribution condition for bit slice 1."]
1884 #[inline(always)]
1885 pub fn cfg1(&self) -> CFG1_R {
1886 CFG1_R::new(((self.bits >> 11) & 0x07) as u8)
1887 }
1888 #[doc = "Bits 14:16 - Specifies the match contribution condition for bit slice 2."]
1889 #[inline(always)]
1890 pub fn cfg2(&self) -> CFG2_R {
1891 CFG2_R::new(((self.bits >> 14) & 0x07) as u8)
1892 }
1893 #[doc = "Bits 17:19 - Specifies the match contribution condition for bit slice 3."]
1894 #[inline(always)]
1895 pub fn cfg3(&self) -> CFG3_R {
1896 CFG3_R::new(((self.bits >> 17) & 0x07) as u8)
1897 }
1898 #[doc = "Bits 20:22 - Specifies the match contribution condition for bit slice 4."]
1899 #[inline(always)]
1900 pub fn cfg4(&self) -> CFG4_R {
1901 CFG4_R::new(((self.bits >> 20) & 0x07) as u8)
1902 }
1903 #[doc = "Bits 23:25 - Specifies the match contribution condition for bit slice 5."]
1904 #[inline(always)]
1905 pub fn cfg5(&self) -> CFG5_R {
1906 CFG5_R::new(((self.bits >> 23) & 0x07) as u8)
1907 }
1908 #[doc = "Bits 26:28 - Specifies the match contribution condition for bit slice 6."]
1909 #[inline(always)]
1910 pub fn cfg6(&self) -> CFG6_R {
1911 CFG6_R::new(((self.bits >> 26) & 0x07) as u8)
1912 }
1913 #[doc = "Bits 29:31 - Specifies the match contribution condition for bit slice 7."]
1914 #[inline(always)]
1915 pub fn cfg7(&self) -> CFG7_R {
1916 CFG7_R::new(((self.bits >> 29) & 0x07) as u8)
1917 }
1918}
1919impl W {
1920 #[doc = "Bit 0 - Determines whether slice 0 is an endpoint."]
1921 #[inline(always)]
1922 pub fn prod_endpts0(&mut self) -> PROD_ENDPTS0_W {
1923 PROD_ENDPTS0_W { w: self }
1924 }
1925 #[doc = "Bit 1 - Determines whether slice 1 is an endpoint."]
1926 #[inline(always)]
1927 pub fn prod_endpts1(&mut self) -> PROD_ENDPTS1_W {
1928 PROD_ENDPTS1_W { w: self }
1929 }
1930 #[doc = "Bit 2 - Determines whether slice 2 is an endpoint."]
1931 #[inline(always)]
1932 pub fn prod_endpts2(&mut self) -> PROD_ENDPTS2_W {
1933 PROD_ENDPTS2_W { w: self }
1934 }
1935 #[doc = "Bit 3 - Determines whether slice 3 is an endpoint."]
1936 #[inline(always)]
1937 pub fn prod_endpts3(&mut self) -> PROD_ENDPTS3_W {
1938 PROD_ENDPTS3_W { w: self }
1939 }
1940 #[doc = "Bit 4 - Determines whether slice 4 is an endpoint."]
1941 #[inline(always)]
1942 pub fn prod_endpts4(&mut self) -> PROD_ENDPTS4_W {
1943 PROD_ENDPTS4_W { w: self }
1944 }
1945 #[doc = "Bit 5 - Determines whether slice 5 is an endpoint."]
1946 #[inline(always)]
1947 pub fn prod_endpts5(&mut self) -> PROD_ENDPTS5_W {
1948 PROD_ENDPTS5_W { w: self }
1949 }
1950 #[doc = "Bit 6 - Determines whether slice 6 is an endpoint."]
1951 #[inline(always)]
1952 pub fn prod_endpts6(&mut self) -> PROD_ENDPTS6_W {
1953 PROD_ENDPTS6_W { w: self }
1954 }
1955 #[doc = "Bits 8:10 - Specifies the match contribution condition for bit slice 0."]
1956 #[inline(always)]
1957 pub fn cfg0(&mut self) -> CFG0_W {
1958 CFG0_W { w: self }
1959 }
1960 #[doc = "Bits 11:13 - Specifies the match contribution condition for bit slice 1."]
1961 #[inline(always)]
1962 pub fn cfg1(&mut self) -> CFG1_W {
1963 CFG1_W { w: self }
1964 }
1965 #[doc = "Bits 14:16 - Specifies the match contribution condition for bit slice 2."]
1966 #[inline(always)]
1967 pub fn cfg2(&mut self) -> CFG2_W {
1968 CFG2_W { w: self }
1969 }
1970 #[doc = "Bits 17:19 - Specifies the match contribution condition for bit slice 3."]
1971 #[inline(always)]
1972 pub fn cfg3(&mut self) -> CFG3_W {
1973 CFG3_W { w: self }
1974 }
1975 #[doc = "Bits 20:22 - Specifies the match contribution condition for bit slice 4."]
1976 #[inline(always)]
1977 pub fn cfg4(&mut self) -> CFG4_W {
1978 CFG4_W { w: self }
1979 }
1980 #[doc = "Bits 23:25 - Specifies the match contribution condition for bit slice 5."]
1981 #[inline(always)]
1982 pub fn cfg5(&mut self) -> CFG5_W {
1983 CFG5_W { w: self }
1984 }
1985 #[doc = "Bits 26:28 - Specifies the match contribution condition for bit slice 6."]
1986 #[inline(always)]
1987 pub fn cfg6(&mut self) -> CFG6_W {
1988 CFG6_W { w: self }
1989 }
1990 #[doc = "Bits 29:31 - Specifies the match contribution condition for bit slice 7."]
1991 #[inline(always)]
1992 pub fn cfg7(&mut self) -> CFG7_W {
1993 CFG7_W { w: self }
1994 }
1995 #[doc = "Writes raw bits to the register."]
1996 #[inline(always)]
1997 pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
1998 self.0.bits(bits);
1999 self
2000 }
2001}
2002#[doc = "Pattern match interrupt bit slice configuration 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 [pmcfg](index.html) module"]
2003pub struct PMCFG_SPEC;
2004impl crate::RegisterSpec for PMCFG_SPEC {
2005 type Ux = u32;
2006}
2007#[doc = "`read()` method returns [pmcfg::R](R) reader structure"]
2008impl crate::Readable for PMCFG_SPEC {
2009 type Reader = R;
2010}
2011#[doc = "`write(|w| ..)` method takes [pmcfg::W](W) writer structure"]
2012impl crate::Writable for PMCFG_SPEC {
2013 type Writer = W;
2014}
2015#[doc = "`reset()` method sets PMCFG to value 0"]
2016impl crate::Resettable for PMCFG_SPEC {
2017 #[inline(always)]
2018 fn reset_value() -> Self::Ux {
2019 0
2020 }
2021}