1#[doc = "Register `PDISC` reader"]
2pub type R = crate::R<PDISC_SPEC>;
3#[doc = "Pad Disable for Port n Pin 0\n\nValue on reset: 0"]
4#[derive(Clone, Copy, Debug, PartialEq, Eq)]
5pub enum PDIS0_A {
6 #[doc = "0: Pad Pn.x is enabled."]
7 VALUE1 = 0,
8 #[doc = "1: Pad Pn.x is disabled."]
9 VALUE2 = 1,
10}
11impl From<PDIS0_A> for bool {
12 #[inline(always)]
13 fn from(variant: PDIS0_A) -> Self {
14 variant as u8 != 0
15 }
16}
17#[doc = "Field `PDIS0` reader - Pad Disable for Port n Pin 0"]
18pub type PDIS0_R = crate::BitReader<PDIS0_A>;
19impl PDIS0_R {
20 #[doc = "Get enumerated values variant"]
21 #[inline(always)]
22 pub const fn variant(&self) -> PDIS0_A {
23 match self.bits {
24 false => PDIS0_A::VALUE1,
25 true => PDIS0_A::VALUE2,
26 }
27 }
28 #[doc = "Pad Pn.x is enabled."]
29 #[inline(always)]
30 pub fn is_value1(&self) -> bool {
31 *self == PDIS0_A::VALUE1
32 }
33 #[doc = "Pad Pn.x is disabled."]
34 #[inline(always)]
35 pub fn is_value2(&self) -> bool {
36 *self == PDIS0_A::VALUE2
37 }
38}
39#[doc = "Pad Disable for Port n Pin 1\n\nValue on reset: 0"]
40#[derive(Clone, Copy, Debug, PartialEq, Eq)]
41pub enum PDIS1_A {
42 #[doc = "0: Pad Pn.x is enabled."]
43 VALUE1 = 0,
44 #[doc = "1: Pad Pn.x is disabled."]
45 VALUE2 = 1,
46}
47impl From<PDIS1_A> for bool {
48 #[inline(always)]
49 fn from(variant: PDIS1_A) -> Self {
50 variant as u8 != 0
51 }
52}
53#[doc = "Field `PDIS1` reader - Pad Disable for Port n Pin 1"]
54pub type PDIS1_R = crate::BitReader<PDIS1_A>;
55impl PDIS1_R {
56 #[doc = "Get enumerated values variant"]
57 #[inline(always)]
58 pub const fn variant(&self) -> PDIS1_A {
59 match self.bits {
60 false => PDIS1_A::VALUE1,
61 true => PDIS1_A::VALUE2,
62 }
63 }
64 #[doc = "Pad Pn.x is enabled."]
65 #[inline(always)]
66 pub fn is_value1(&self) -> bool {
67 *self == PDIS1_A::VALUE1
68 }
69 #[doc = "Pad Pn.x is disabled."]
70 #[inline(always)]
71 pub fn is_value2(&self) -> bool {
72 *self == PDIS1_A::VALUE2
73 }
74}
75#[doc = "Pad Disable for Port n Pin 2\n\nValue on reset: 0"]
76#[derive(Clone, Copy, Debug, PartialEq, Eq)]
77pub enum PDIS2_A {
78 #[doc = "0: Pad Pn.x is enabled."]
79 VALUE1 = 0,
80 #[doc = "1: Pad Pn.x is disabled."]
81 VALUE2 = 1,
82}
83impl From<PDIS2_A> for bool {
84 #[inline(always)]
85 fn from(variant: PDIS2_A) -> Self {
86 variant as u8 != 0
87 }
88}
89#[doc = "Field `PDIS2` reader - Pad Disable for Port n Pin 2"]
90pub type PDIS2_R = crate::BitReader<PDIS2_A>;
91impl PDIS2_R {
92 #[doc = "Get enumerated values variant"]
93 #[inline(always)]
94 pub const fn variant(&self) -> PDIS2_A {
95 match self.bits {
96 false => PDIS2_A::VALUE1,
97 true => PDIS2_A::VALUE2,
98 }
99 }
100 #[doc = "Pad Pn.x is enabled."]
101 #[inline(always)]
102 pub fn is_value1(&self) -> bool {
103 *self == PDIS2_A::VALUE1
104 }
105 #[doc = "Pad Pn.x is disabled."]
106 #[inline(always)]
107 pub fn is_value2(&self) -> bool {
108 *self == PDIS2_A::VALUE2
109 }
110}
111#[doc = "Pad Disable for Port n Pin 3\n\nValue on reset: 0"]
112#[derive(Clone, Copy, Debug, PartialEq, Eq)]
113pub enum PDIS3_A {
114 #[doc = "0: Pad Pn.x is enabled."]
115 VALUE1 = 0,
116 #[doc = "1: Pad Pn.x is disabled."]
117 VALUE2 = 1,
118}
119impl From<PDIS3_A> for bool {
120 #[inline(always)]
121 fn from(variant: PDIS3_A) -> Self {
122 variant as u8 != 0
123 }
124}
125#[doc = "Field `PDIS3` reader - Pad Disable for Port n Pin 3"]
126pub type PDIS3_R = crate::BitReader<PDIS3_A>;
127impl PDIS3_R {
128 #[doc = "Get enumerated values variant"]
129 #[inline(always)]
130 pub const fn variant(&self) -> PDIS3_A {
131 match self.bits {
132 false => PDIS3_A::VALUE1,
133 true => PDIS3_A::VALUE2,
134 }
135 }
136 #[doc = "Pad Pn.x is enabled."]
137 #[inline(always)]
138 pub fn is_value1(&self) -> bool {
139 *self == PDIS3_A::VALUE1
140 }
141 #[doc = "Pad Pn.x is disabled."]
142 #[inline(always)]
143 pub fn is_value2(&self) -> bool {
144 *self == PDIS3_A::VALUE2
145 }
146}
147#[doc = "Pad Disable for Port n Pin 4\n\nValue on reset: 0"]
148#[derive(Clone, Copy, Debug, PartialEq, Eq)]
149pub enum PDIS4_A {
150 #[doc = "0: Pad Pn.x is enabled."]
151 VALUE1 = 0,
152 #[doc = "1: Pad Pn.x is disabled."]
153 VALUE2 = 1,
154}
155impl From<PDIS4_A> for bool {
156 #[inline(always)]
157 fn from(variant: PDIS4_A) -> Self {
158 variant as u8 != 0
159 }
160}
161#[doc = "Field `PDIS4` reader - Pad Disable for Port n Pin 4"]
162pub type PDIS4_R = crate::BitReader<PDIS4_A>;
163impl PDIS4_R {
164 #[doc = "Get enumerated values variant"]
165 #[inline(always)]
166 pub const fn variant(&self) -> PDIS4_A {
167 match self.bits {
168 false => PDIS4_A::VALUE1,
169 true => PDIS4_A::VALUE2,
170 }
171 }
172 #[doc = "Pad Pn.x is enabled."]
173 #[inline(always)]
174 pub fn is_value1(&self) -> bool {
175 *self == PDIS4_A::VALUE1
176 }
177 #[doc = "Pad Pn.x is disabled."]
178 #[inline(always)]
179 pub fn is_value2(&self) -> bool {
180 *self == PDIS4_A::VALUE2
181 }
182}
183#[doc = "Pad Disable for Port n Pin 5\n\nValue on reset: 0"]
184#[derive(Clone, Copy, Debug, PartialEq, Eq)]
185pub enum PDIS5_A {
186 #[doc = "0: Pad Pn.x is enabled."]
187 VALUE1 = 0,
188 #[doc = "1: Pad Pn.x is disabled."]
189 VALUE2 = 1,
190}
191impl From<PDIS5_A> for bool {
192 #[inline(always)]
193 fn from(variant: PDIS5_A) -> Self {
194 variant as u8 != 0
195 }
196}
197#[doc = "Field `PDIS5` reader - Pad Disable for Port n Pin 5"]
198pub type PDIS5_R = crate::BitReader<PDIS5_A>;
199impl PDIS5_R {
200 #[doc = "Get enumerated values variant"]
201 #[inline(always)]
202 pub const fn variant(&self) -> PDIS5_A {
203 match self.bits {
204 false => PDIS5_A::VALUE1,
205 true => PDIS5_A::VALUE2,
206 }
207 }
208 #[doc = "Pad Pn.x is enabled."]
209 #[inline(always)]
210 pub fn is_value1(&self) -> bool {
211 *self == PDIS5_A::VALUE1
212 }
213 #[doc = "Pad Pn.x is disabled."]
214 #[inline(always)]
215 pub fn is_value2(&self) -> bool {
216 *self == PDIS5_A::VALUE2
217 }
218}
219#[doc = "Pad Disable for Port n Pin 6\n\nValue on reset: 0"]
220#[derive(Clone, Copy, Debug, PartialEq, Eq)]
221pub enum PDIS6_A {
222 #[doc = "0: Pad Pn.x is enabled."]
223 VALUE1 = 0,
224 #[doc = "1: Pad Pn.x is disabled."]
225 VALUE2 = 1,
226}
227impl From<PDIS6_A> for bool {
228 #[inline(always)]
229 fn from(variant: PDIS6_A) -> Self {
230 variant as u8 != 0
231 }
232}
233#[doc = "Field `PDIS6` reader - Pad Disable for Port n Pin 6"]
234pub type PDIS6_R = crate::BitReader<PDIS6_A>;
235impl PDIS6_R {
236 #[doc = "Get enumerated values variant"]
237 #[inline(always)]
238 pub const fn variant(&self) -> PDIS6_A {
239 match self.bits {
240 false => PDIS6_A::VALUE1,
241 true => PDIS6_A::VALUE2,
242 }
243 }
244 #[doc = "Pad Pn.x is enabled."]
245 #[inline(always)]
246 pub fn is_value1(&self) -> bool {
247 *self == PDIS6_A::VALUE1
248 }
249 #[doc = "Pad Pn.x is disabled."]
250 #[inline(always)]
251 pub fn is_value2(&self) -> bool {
252 *self == PDIS6_A::VALUE2
253 }
254}
255#[doc = "Pad Disable for Port n Pin 7\n\nValue on reset: 0"]
256#[derive(Clone, Copy, Debug, PartialEq, Eq)]
257pub enum PDIS7_A {
258 #[doc = "0: Pad Pn.x is enabled."]
259 VALUE1 = 0,
260 #[doc = "1: Pad Pn.x is disabled."]
261 VALUE2 = 1,
262}
263impl From<PDIS7_A> for bool {
264 #[inline(always)]
265 fn from(variant: PDIS7_A) -> Self {
266 variant as u8 != 0
267 }
268}
269#[doc = "Field `PDIS7` reader - Pad Disable for Port n Pin 7"]
270pub type PDIS7_R = crate::BitReader<PDIS7_A>;
271impl PDIS7_R {
272 #[doc = "Get enumerated values variant"]
273 #[inline(always)]
274 pub const fn variant(&self) -> PDIS7_A {
275 match self.bits {
276 false => PDIS7_A::VALUE1,
277 true => PDIS7_A::VALUE2,
278 }
279 }
280 #[doc = "Pad Pn.x is enabled."]
281 #[inline(always)]
282 pub fn is_value1(&self) -> bool {
283 *self == PDIS7_A::VALUE1
284 }
285 #[doc = "Pad Pn.x is disabled."]
286 #[inline(always)]
287 pub fn is_value2(&self) -> bool {
288 *self == PDIS7_A::VALUE2
289 }
290}
291#[doc = "Pad Disable for Port n Pin 8\n\nValue on reset: 0"]
292#[derive(Clone, Copy, Debug, PartialEq, Eq)]
293pub enum PDIS8_A {
294 #[doc = "0: Pad Pn.x is enabled."]
295 VALUE1 = 0,
296 #[doc = "1: Pad Pn.x is disabled."]
297 VALUE2 = 1,
298}
299impl From<PDIS8_A> for bool {
300 #[inline(always)]
301 fn from(variant: PDIS8_A) -> Self {
302 variant as u8 != 0
303 }
304}
305#[doc = "Field `PDIS8` reader - Pad Disable for Port n Pin 8"]
306pub type PDIS8_R = crate::BitReader<PDIS8_A>;
307impl PDIS8_R {
308 #[doc = "Get enumerated values variant"]
309 #[inline(always)]
310 pub const fn variant(&self) -> PDIS8_A {
311 match self.bits {
312 false => PDIS8_A::VALUE1,
313 true => PDIS8_A::VALUE2,
314 }
315 }
316 #[doc = "Pad Pn.x is enabled."]
317 #[inline(always)]
318 pub fn is_value1(&self) -> bool {
319 *self == PDIS8_A::VALUE1
320 }
321 #[doc = "Pad Pn.x is disabled."]
322 #[inline(always)]
323 pub fn is_value2(&self) -> bool {
324 *self == PDIS8_A::VALUE2
325 }
326}
327#[doc = "Pad Disable for Port n Pin 9\n\nValue on reset: 0"]
328#[derive(Clone, Copy, Debug, PartialEq, Eq)]
329pub enum PDIS9_A {
330 #[doc = "0: Pad Pn.x is enabled."]
331 VALUE1 = 0,
332 #[doc = "1: Pad Pn.x is disabled."]
333 VALUE2 = 1,
334}
335impl From<PDIS9_A> for bool {
336 #[inline(always)]
337 fn from(variant: PDIS9_A) -> Self {
338 variant as u8 != 0
339 }
340}
341#[doc = "Field `PDIS9` reader - Pad Disable for Port n Pin 9"]
342pub type PDIS9_R = crate::BitReader<PDIS9_A>;
343impl PDIS9_R {
344 #[doc = "Get enumerated values variant"]
345 #[inline(always)]
346 pub const fn variant(&self) -> PDIS9_A {
347 match self.bits {
348 false => PDIS9_A::VALUE1,
349 true => PDIS9_A::VALUE2,
350 }
351 }
352 #[doc = "Pad Pn.x is enabled."]
353 #[inline(always)]
354 pub fn is_value1(&self) -> bool {
355 *self == PDIS9_A::VALUE1
356 }
357 #[doc = "Pad Pn.x is disabled."]
358 #[inline(always)]
359 pub fn is_value2(&self) -> bool {
360 *self == PDIS9_A::VALUE2
361 }
362}
363#[doc = "Pad Disable for Port n Pin 10\n\nValue on reset: 0"]
364#[derive(Clone, Copy, Debug, PartialEq, Eq)]
365pub enum PDIS10_A {
366 #[doc = "0: Pad Pn.x is enabled."]
367 VALUE1 = 0,
368 #[doc = "1: Pad Pn.x is disabled."]
369 VALUE2 = 1,
370}
371impl From<PDIS10_A> for bool {
372 #[inline(always)]
373 fn from(variant: PDIS10_A) -> Self {
374 variant as u8 != 0
375 }
376}
377#[doc = "Field `PDIS10` reader - Pad Disable for Port n Pin 10"]
378pub type PDIS10_R = crate::BitReader<PDIS10_A>;
379impl PDIS10_R {
380 #[doc = "Get enumerated values variant"]
381 #[inline(always)]
382 pub const fn variant(&self) -> PDIS10_A {
383 match self.bits {
384 false => PDIS10_A::VALUE1,
385 true => PDIS10_A::VALUE2,
386 }
387 }
388 #[doc = "Pad Pn.x is enabled."]
389 #[inline(always)]
390 pub fn is_value1(&self) -> bool {
391 *self == PDIS10_A::VALUE1
392 }
393 #[doc = "Pad Pn.x is disabled."]
394 #[inline(always)]
395 pub fn is_value2(&self) -> bool {
396 *self == PDIS10_A::VALUE2
397 }
398}
399#[doc = "Pad Disable for Port n Pin 11\n\nValue on reset: 0"]
400#[derive(Clone, Copy, Debug, PartialEq, Eq)]
401pub enum PDIS11_A {
402 #[doc = "0: Pad Pn.x is enabled."]
403 VALUE1 = 0,
404 #[doc = "1: Pad Pn.x is disabled."]
405 VALUE2 = 1,
406}
407impl From<PDIS11_A> for bool {
408 #[inline(always)]
409 fn from(variant: PDIS11_A) -> Self {
410 variant as u8 != 0
411 }
412}
413#[doc = "Field `PDIS11` reader - Pad Disable for Port n Pin 11"]
414pub type PDIS11_R = crate::BitReader<PDIS11_A>;
415impl PDIS11_R {
416 #[doc = "Get enumerated values variant"]
417 #[inline(always)]
418 pub const fn variant(&self) -> PDIS11_A {
419 match self.bits {
420 false => PDIS11_A::VALUE1,
421 true => PDIS11_A::VALUE2,
422 }
423 }
424 #[doc = "Pad Pn.x is enabled."]
425 #[inline(always)]
426 pub fn is_value1(&self) -> bool {
427 *self == PDIS11_A::VALUE1
428 }
429 #[doc = "Pad Pn.x is disabled."]
430 #[inline(always)]
431 pub fn is_value2(&self) -> bool {
432 *self == PDIS11_A::VALUE2
433 }
434}
435#[doc = "Pad Disable for Port n Pin 12\n\nValue on reset: 0"]
436#[derive(Clone, Copy, Debug, PartialEq, Eq)]
437pub enum PDIS12_A {
438 #[doc = "0: Pad Pn.x is enabled."]
439 VALUE1 = 0,
440 #[doc = "1: Pad Pn.x is disabled."]
441 VALUE2 = 1,
442}
443impl From<PDIS12_A> for bool {
444 #[inline(always)]
445 fn from(variant: PDIS12_A) -> Self {
446 variant as u8 != 0
447 }
448}
449#[doc = "Field `PDIS12` reader - Pad Disable for Port n Pin 12"]
450pub type PDIS12_R = crate::BitReader<PDIS12_A>;
451impl PDIS12_R {
452 #[doc = "Get enumerated values variant"]
453 #[inline(always)]
454 pub const fn variant(&self) -> PDIS12_A {
455 match self.bits {
456 false => PDIS12_A::VALUE1,
457 true => PDIS12_A::VALUE2,
458 }
459 }
460 #[doc = "Pad Pn.x is enabled."]
461 #[inline(always)]
462 pub fn is_value1(&self) -> bool {
463 *self == PDIS12_A::VALUE1
464 }
465 #[doc = "Pad Pn.x is disabled."]
466 #[inline(always)]
467 pub fn is_value2(&self) -> bool {
468 *self == PDIS12_A::VALUE2
469 }
470}
471#[doc = "Pad Disable for Port n Pin 13\n\nValue on reset: 0"]
472#[derive(Clone, Copy, Debug, PartialEq, Eq)]
473pub enum PDIS13_A {
474 #[doc = "0: Pad Pn.x is enabled."]
475 VALUE1 = 0,
476 #[doc = "1: Pad Pn.x is disabled."]
477 VALUE2 = 1,
478}
479impl From<PDIS13_A> for bool {
480 #[inline(always)]
481 fn from(variant: PDIS13_A) -> Self {
482 variant as u8 != 0
483 }
484}
485#[doc = "Field `PDIS13` reader - Pad Disable for Port n Pin 13"]
486pub type PDIS13_R = crate::BitReader<PDIS13_A>;
487impl PDIS13_R {
488 #[doc = "Get enumerated values variant"]
489 #[inline(always)]
490 pub const fn variant(&self) -> PDIS13_A {
491 match self.bits {
492 false => PDIS13_A::VALUE1,
493 true => PDIS13_A::VALUE2,
494 }
495 }
496 #[doc = "Pad Pn.x is enabled."]
497 #[inline(always)]
498 pub fn is_value1(&self) -> bool {
499 *self == PDIS13_A::VALUE1
500 }
501 #[doc = "Pad Pn.x is disabled."]
502 #[inline(always)]
503 pub fn is_value2(&self) -> bool {
504 *self == PDIS13_A::VALUE2
505 }
506}
507#[doc = "Pad Disable for Port n Pin 14\n\nValue on reset: 0"]
508#[derive(Clone, Copy, Debug, PartialEq, Eq)]
509pub enum PDIS14_A {
510 #[doc = "0: Pad Pn.x is enabled."]
511 VALUE1 = 0,
512 #[doc = "1: Pad Pn.x is disabled."]
513 VALUE2 = 1,
514}
515impl From<PDIS14_A> for bool {
516 #[inline(always)]
517 fn from(variant: PDIS14_A) -> Self {
518 variant as u8 != 0
519 }
520}
521#[doc = "Field `PDIS14` reader - Pad Disable for Port n Pin 14"]
522pub type PDIS14_R = crate::BitReader<PDIS14_A>;
523impl PDIS14_R {
524 #[doc = "Get enumerated values variant"]
525 #[inline(always)]
526 pub const fn variant(&self) -> PDIS14_A {
527 match self.bits {
528 false => PDIS14_A::VALUE1,
529 true => PDIS14_A::VALUE2,
530 }
531 }
532 #[doc = "Pad Pn.x is enabled."]
533 #[inline(always)]
534 pub fn is_value1(&self) -> bool {
535 *self == PDIS14_A::VALUE1
536 }
537 #[doc = "Pad Pn.x is disabled."]
538 #[inline(always)]
539 pub fn is_value2(&self) -> bool {
540 *self == PDIS14_A::VALUE2
541 }
542}
543#[doc = "Pad Disable for Port n Pin 15\n\nValue on reset: 0"]
544#[derive(Clone, Copy, Debug, PartialEq, Eq)]
545pub enum PDIS15_A {
546 #[doc = "0: Pad Pn.x is enabled."]
547 VALUE1 = 0,
548 #[doc = "1: Pad Pn.x is disabled."]
549 VALUE2 = 1,
550}
551impl From<PDIS15_A> for bool {
552 #[inline(always)]
553 fn from(variant: PDIS15_A) -> Self {
554 variant as u8 != 0
555 }
556}
557#[doc = "Field `PDIS15` reader - Pad Disable for Port n Pin 15"]
558pub type PDIS15_R = crate::BitReader<PDIS15_A>;
559impl PDIS15_R {
560 #[doc = "Get enumerated values variant"]
561 #[inline(always)]
562 pub const fn variant(&self) -> PDIS15_A {
563 match self.bits {
564 false => PDIS15_A::VALUE1,
565 true => PDIS15_A::VALUE2,
566 }
567 }
568 #[doc = "Pad Pn.x is enabled."]
569 #[inline(always)]
570 pub fn is_value1(&self) -> bool {
571 *self == PDIS15_A::VALUE1
572 }
573 #[doc = "Pad Pn.x is disabled."]
574 #[inline(always)]
575 pub fn is_value2(&self) -> bool {
576 *self == PDIS15_A::VALUE2
577 }
578}
579impl R {
580 #[doc = "Bit 0 - Pad Disable for Port n Pin 0"]
581 #[inline(always)]
582 pub fn pdis0(&self) -> PDIS0_R {
583 PDIS0_R::new((self.bits & 1) != 0)
584 }
585 #[doc = "Bit 1 - Pad Disable for Port n Pin 1"]
586 #[inline(always)]
587 pub fn pdis1(&self) -> PDIS1_R {
588 PDIS1_R::new(((self.bits >> 1) & 1) != 0)
589 }
590 #[doc = "Bit 2 - Pad Disable for Port n Pin 2"]
591 #[inline(always)]
592 pub fn pdis2(&self) -> PDIS2_R {
593 PDIS2_R::new(((self.bits >> 2) & 1) != 0)
594 }
595 #[doc = "Bit 3 - Pad Disable for Port n Pin 3"]
596 #[inline(always)]
597 pub fn pdis3(&self) -> PDIS3_R {
598 PDIS3_R::new(((self.bits >> 3) & 1) != 0)
599 }
600 #[doc = "Bit 4 - Pad Disable for Port n Pin 4"]
601 #[inline(always)]
602 pub fn pdis4(&self) -> PDIS4_R {
603 PDIS4_R::new(((self.bits >> 4) & 1) != 0)
604 }
605 #[doc = "Bit 5 - Pad Disable for Port n Pin 5"]
606 #[inline(always)]
607 pub fn pdis5(&self) -> PDIS5_R {
608 PDIS5_R::new(((self.bits >> 5) & 1) != 0)
609 }
610 #[doc = "Bit 6 - Pad Disable for Port n Pin 6"]
611 #[inline(always)]
612 pub fn pdis6(&self) -> PDIS6_R {
613 PDIS6_R::new(((self.bits >> 6) & 1) != 0)
614 }
615 #[doc = "Bit 7 - Pad Disable for Port n Pin 7"]
616 #[inline(always)]
617 pub fn pdis7(&self) -> PDIS7_R {
618 PDIS7_R::new(((self.bits >> 7) & 1) != 0)
619 }
620 #[doc = "Bit 8 - Pad Disable for Port n Pin 8"]
621 #[inline(always)]
622 pub fn pdis8(&self) -> PDIS8_R {
623 PDIS8_R::new(((self.bits >> 8) & 1) != 0)
624 }
625 #[doc = "Bit 9 - Pad Disable for Port n Pin 9"]
626 #[inline(always)]
627 pub fn pdis9(&self) -> PDIS9_R {
628 PDIS9_R::new(((self.bits >> 9) & 1) != 0)
629 }
630 #[doc = "Bit 10 - Pad Disable for Port n Pin 10"]
631 #[inline(always)]
632 pub fn pdis10(&self) -> PDIS10_R {
633 PDIS10_R::new(((self.bits >> 10) & 1) != 0)
634 }
635 #[doc = "Bit 11 - Pad Disable for Port n Pin 11"]
636 #[inline(always)]
637 pub fn pdis11(&self) -> PDIS11_R {
638 PDIS11_R::new(((self.bits >> 11) & 1) != 0)
639 }
640 #[doc = "Bit 12 - Pad Disable for Port n Pin 12"]
641 #[inline(always)]
642 pub fn pdis12(&self) -> PDIS12_R {
643 PDIS12_R::new(((self.bits >> 12) & 1) != 0)
644 }
645 #[doc = "Bit 13 - Pad Disable for Port n Pin 13"]
646 #[inline(always)]
647 pub fn pdis13(&self) -> PDIS13_R {
648 PDIS13_R::new(((self.bits >> 13) & 1) != 0)
649 }
650 #[doc = "Bit 14 - Pad Disable for Port n Pin 14"]
651 #[inline(always)]
652 pub fn pdis14(&self) -> PDIS14_R {
653 PDIS14_R::new(((self.bits >> 14) & 1) != 0)
654 }
655 #[doc = "Bit 15 - Pad Disable for Port n Pin 15"]
656 #[inline(always)]
657 pub fn pdis15(&self) -> PDIS15_R {
658 PDIS15_R::new(((self.bits >> 15) & 1) != 0)
659 }
660}
661#[doc = "Port 6 Pin Function Decision Control Register\n\nYou can [`read`](crate::Reg::read) this register and get [`pdisc::R`](R). See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
662pub struct PDISC_SPEC;
663impl crate::RegisterSpec for PDISC_SPEC {
664 type Ux = u32;
665}
666#[doc = "`read()` method returns [`pdisc::R`](R) reader structure"]
667impl crate::Readable for PDISC_SPEC {}
668#[doc = "`reset()` method sets PDISC to value 0"]
669impl crate::Resettable for PDISC_SPEC {
670 const RESET_VALUE: u32 = 0;
671}