1#[doc = "Register `PDR1` reader"]
2pub type R = crate::R<PDR1_SPEC>;
3#[doc = "Register `PDR1` writer"]
4pub type W = crate::W<PDR1_SPEC>;
5#[doc = "Pad Driver Mode for Pn.8\n\nValue on reset: 2"]
6#[derive(Clone, Copy, Debug, PartialEq, Eq)]
7#[repr(u8)]
8pub enum PD8_A {
9 #[doc = "0: A2 strong driver, sharp edge"]
10 SD_SHE = 0,
11 #[doc = "1: A2 strong driver, medium edge"]
12 SD_MEE = 1,
13 #[doc = "2: A2 strong driver, soft edge"]
14 SD_SOE = 2,
15 #[doc = "4: A2 medium driver"]
16 MD = 4,
17 #[doc = "7: A2 weak driver"]
18 WD = 7,
19}
20impl From<PD8_A> for u8 {
21 #[inline(always)]
22 fn from(variant: PD8_A) -> Self {
23 variant as _
24 }
25}
26impl crate::FieldSpec for PD8_A {
27 type Ux = u8;
28}
29impl crate::IsEnum for PD8_A {}
30#[doc = "Field `PD8` reader - Pad Driver Mode for Pn.8"]
31pub type PD8_R = crate::FieldReader<PD8_A>;
32impl PD8_R {
33 #[doc = "Get enumerated values variant"]
34 #[inline(always)]
35 pub const fn variant(&self) -> Option<PD8_A> {
36 match self.bits {
37 0 => Some(PD8_A::SD_SHE),
38 1 => Some(PD8_A::SD_MEE),
39 2 => Some(PD8_A::SD_SOE),
40 4 => Some(PD8_A::MD),
41 7 => Some(PD8_A::WD),
42 _ => None,
43 }
44 }
45 #[doc = "A2 strong driver, sharp edge"]
46 #[inline(always)]
47 pub fn is_sd_she(&self) -> bool {
48 *self == PD8_A::SD_SHE
49 }
50 #[doc = "A2 strong driver, medium edge"]
51 #[inline(always)]
52 pub fn is_sd_mee(&self) -> bool {
53 *self == PD8_A::SD_MEE
54 }
55 #[doc = "A2 strong driver, soft edge"]
56 #[inline(always)]
57 pub fn is_sd_soe(&self) -> bool {
58 *self == PD8_A::SD_SOE
59 }
60 #[doc = "A2 medium driver"]
61 #[inline(always)]
62 pub fn is_md(&self) -> bool {
63 *self == PD8_A::MD
64 }
65 #[doc = "A2 weak driver"]
66 #[inline(always)]
67 pub fn is_wd(&self) -> bool {
68 *self == PD8_A::WD
69 }
70}
71#[doc = "Field `PD8` writer - Pad Driver Mode for Pn.8"]
72pub type PD8_W<'a, REG> = crate::FieldWriter<'a, REG, 3, PD8_A>;
73impl<'a, REG> PD8_W<'a, REG>
74where
75 REG: crate::Writable + crate::RegisterSpec,
76 REG::Ux: From<u8>,
77{
78 #[doc = "A2 strong driver, sharp edge"]
79 #[inline(always)]
80 pub fn sd_she(self) -> &'a mut crate::W<REG> {
81 self.variant(PD8_A::SD_SHE)
82 }
83 #[doc = "A2 strong driver, medium edge"]
84 #[inline(always)]
85 pub fn sd_mee(self) -> &'a mut crate::W<REG> {
86 self.variant(PD8_A::SD_MEE)
87 }
88 #[doc = "A2 strong driver, soft edge"]
89 #[inline(always)]
90 pub fn sd_soe(self) -> &'a mut crate::W<REG> {
91 self.variant(PD8_A::SD_SOE)
92 }
93 #[doc = "A2 medium driver"]
94 #[inline(always)]
95 pub fn md(self) -> &'a mut crate::W<REG> {
96 self.variant(PD8_A::MD)
97 }
98 #[doc = "A2 weak driver"]
99 #[inline(always)]
100 pub fn wd(self) -> &'a mut crate::W<REG> {
101 self.variant(PD8_A::WD)
102 }
103}
104#[doc = "Pad Driver Mode for Pn.9\n\nValue on reset: 2"]
105#[derive(Clone, Copy, Debug, PartialEq, Eq)]
106#[repr(u8)]
107pub enum PD9_A {
108 #[doc = "0: A2 strong driver, sharp edge"]
109 SD_SHE = 0,
110 #[doc = "1: A2 strong driver, medium edge"]
111 SD_MEE = 1,
112 #[doc = "2: A2 strong driver, soft edge"]
113 SD_SOE = 2,
114 #[doc = "4: A2 medium driver"]
115 MD = 4,
116 #[doc = "7: A2 weak driver"]
117 WD = 7,
118}
119impl From<PD9_A> for u8 {
120 #[inline(always)]
121 fn from(variant: PD9_A) -> Self {
122 variant as _
123 }
124}
125impl crate::FieldSpec for PD9_A {
126 type Ux = u8;
127}
128impl crate::IsEnum for PD9_A {}
129#[doc = "Field `PD9` reader - Pad Driver Mode for Pn.9"]
130pub type PD9_R = crate::FieldReader<PD9_A>;
131impl PD9_R {
132 #[doc = "Get enumerated values variant"]
133 #[inline(always)]
134 pub const fn variant(&self) -> Option<PD9_A> {
135 match self.bits {
136 0 => Some(PD9_A::SD_SHE),
137 1 => Some(PD9_A::SD_MEE),
138 2 => Some(PD9_A::SD_SOE),
139 4 => Some(PD9_A::MD),
140 7 => Some(PD9_A::WD),
141 _ => None,
142 }
143 }
144 #[doc = "A2 strong driver, sharp edge"]
145 #[inline(always)]
146 pub fn is_sd_she(&self) -> bool {
147 *self == PD9_A::SD_SHE
148 }
149 #[doc = "A2 strong driver, medium edge"]
150 #[inline(always)]
151 pub fn is_sd_mee(&self) -> bool {
152 *self == PD9_A::SD_MEE
153 }
154 #[doc = "A2 strong driver, soft edge"]
155 #[inline(always)]
156 pub fn is_sd_soe(&self) -> bool {
157 *self == PD9_A::SD_SOE
158 }
159 #[doc = "A2 medium driver"]
160 #[inline(always)]
161 pub fn is_md(&self) -> bool {
162 *self == PD9_A::MD
163 }
164 #[doc = "A2 weak driver"]
165 #[inline(always)]
166 pub fn is_wd(&self) -> bool {
167 *self == PD9_A::WD
168 }
169}
170#[doc = "Field `PD9` writer - Pad Driver Mode for Pn.9"]
171pub type PD9_W<'a, REG> = crate::FieldWriter<'a, REG, 3, PD9_A>;
172impl<'a, REG> PD9_W<'a, REG>
173where
174 REG: crate::Writable + crate::RegisterSpec,
175 REG::Ux: From<u8>,
176{
177 #[doc = "A2 strong driver, sharp edge"]
178 #[inline(always)]
179 pub fn sd_she(self) -> &'a mut crate::W<REG> {
180 self.variant(PD9_A::SD_SHE)
181 }
182 #[doc = "A2 strong driver, medium edge"]
183 #[inline(always)]
184 pub fn sd_mee(self) -> &'a mut crate::W<REG> {
185 self.variant(PD9_A::SD_MEE)
186 }
187 #[doc = "A2 strong driver, soft edge"]
188 #[inline(always)]
189 pub fn sd_soe(self) -> &'a mut crate::W<REG> {
190 self.variant(PD9_A::SD_SOE)
191 }
192 #[doc = "A2 medium driver"]
193 #[inline(always)]
194 pub fn md(self) -> &'a mut crate::W<REG> {
195 self.variant(PD9_A::MD)
196 }
197 #[doc = "A2 weak driver"]
198 #[inline(always)]
199 pub fn wd(self) -> &'a mut crate::W<REG> {
200 self.variant(PD9_A::WD)
201 }
202}
203#[doc = "Pad Driver Mode for Pn.10\n\nValue on reset: 2"]
204#[derive(Clone, Copy, Debug, PartialEq, Eq)]
205#[repr(u8)]
206pub enum PD10_A {
207 #[doc = "0: A2 strong driver, sharp edge"]
208 SD_SHE = 0,
209 #[doc = "1: A2 strong driver, medium edge"]
210 SD_MEE = 1,
211 #[doc = "2: A2 strong driver, soft edge"]
212 SD_SOE = 2,
213 #[doc = "4: A2 medium driver"]
214 MD = 4,
215 #[doc = "7: A2 weak driver"]
216 WD = 7,
217}
218impl From<PD10_A> for u8 {
219 #[inline(always)]
220 fn from(variant: PD10_A) -> Self {
221 variant as _
222 }
223}
224impl crate::FieldSpec for PD10_A {
225 type Ux = u8;
226}
227impl crate::IsEnum for PD10_A {}
228#[doc = "Field `PD10` reader - Pad Driver Mode for Pn.10"]
229pub type PD10_R = crate::FieldReader<PD10_A>;
230impl PD10_R {
231 #[doc = "Get enumerated values variant"]
232 #[inline(always)]
233 pub const fn variant(&self) -> Option<PD10_A> {
234 match self.bits {
235 0 => Some(PD10_A::SD_SHE),
236 1 => Some(PD10_A::SD_MEE),
237 2 => Some(PD10_A::SD_SOE),
238 4 => Some(PD10_A::MD),
239 7 => Some(PD10_A::WD),
240 _ => None,
241 }
242 }
243 #[doc = "A2 strong driver, sharp edge"]
244 #[inline(always)]
245 pub fn is_sd_she(&self) -> bool {
246 *self == PD10_A::SD_SHE
247 }
248 #[doc = "A2 strong driver, medium edge"]
249 #[inline(always)]
250 pub fn is_sd_mee(&self) -> bool {
251 *self == PD10_A::SD_MEE
252 }
253 #[doc = "A2 strong driver, soft edge"]
254 #[inline(always)]
255 pub fn is_sd_soe(&self) -> bool {
256 *self == PD10_A::SD_SOE
257 }
258 #[doc = "A2 medium driver"]
259 #[inline(always)]
260 pub fn is_md(&self) -> bool {
261 *self == PD10_A::MD
262 }
263 #[doc = "A2 weak driver"]
264 #[inline(always)]
265 pub fn is_wd(&self) -> bool {
266 *self == PD10_A::WD
267 }
268}
269#[doc = "Field `PD10` writer - Pad Driver Mode for Pn.10"]
270pub type PD10_W<'a, REG> = crate::FieldWriter<'a, REG, 3, PD10_A>;
271impl<'a, REG> PD10_W<'a, REG>
272where
273 REG: crate::Writable + crate::RegisterSpec,
274 REG::Ux: From<u8>,
275{
276 #[doc = "A2 strong driver, sharp edge"]
277 #[inline(always)]
278 pub fn sd_she(self) -> &'a mut crate::W<REG> {
279 self.variant(PD10_A::SD_SHE)
280 }
281 #[doc = "A2 strong driver, medium edge"]
282 #[inline(always)]
283 pub fn sd_mee(self) -> &'a mut crate::W<REG> {
284 self.variant(PD10_A::SD_MEE)
285 }
286 #[doc = "A2 strong driver, soft edge"]
287 #[inline(always)]
288 pub fn sd_soe(self) -> &'a mut crate::W<REG> {
289 self.variant(PD10_A::SD_SOE)
290 }
291 #[doc = "A2 medium driver"]
292 #[inline(always)]
293 pub fn md(self) -> &'a mut crate::W<REG> {
294 self.variant(PD10_A::MD)
295 }
296 #[doc = "A2 weak driver"]
297 #[inline(always)]
298 pub fn wd(self) -> &'a mut crate::W<REG> {
299 self.variant(PD10_A::WD)
300 }
301}
302#[doc = "Pad Driver Mode for Pn.11\n\nValue on reset: 2"]
303#[derive(Clone, Copy, Debug, PartialEq, Eq)]
304#[repr(u8)]
305pub enum PD11_A {
306 #[doc = "0: A2 strong driver, sharp edge"]
307 SD_SHE = 0,
308 #[doc = "1: A2 strong driver, medium edge"]
309 SD_MEE = 1,
310 #[doc = "2: A2 strong driver, soft edge"]
311 SD_SOE = 2,
312 #[doc = "4: A2 medium driver"]
313 MD = 4,
314 #[doc = "7: A2 weak driver"]
315 WD = 7,
316}
317impl From<PD11_A> for u8 {
318 #[inline(always)]
319 fn from(variant: PD11_A) -> Self {
320 variant as _
321 }
322}
323impl crate::FieldSpec for PD11_A {
324 type Ux = u8;
325}
326impl crate::IsEnum for PD11_A {}
327#[doc = "Field `PD11` reader - Pad Driver Mode for Pn.11"]
328pub type PD11_R = crate::FieldReader<PD11_A>;
329impl PD11_R {
330 #[doc = "Get enumerated values variant"]
331 #[inline(always)]
332 pub const fn variant(&self) -> Option<PD11_A> {
333 match self.bits {
334 0 => Some(PD11_A::SD_SHE),
335 1 => Some(PD11_A::SD_MEE),
336 2 => Some(PD11_A::SD_SOE),
337 4 => Some(PD11_A::MD),
338 7 => Some(PD11_A::WD),
339 _ => None,
340 }
341 }
342 #[doc = "A2 strong driver, sharp edge"]
343 #[inline(always)]
344 pub fn is_sd_she(&self) -> bool {
345 *self == PD11_A::SD_SHE
346 }
347 #[doc = "A2 strong driver, medium edge"]
348 #[inline(always)]
349 pub fn is_sd_mee(&self) -> bool {
350 *self == PD11_A::SD_MEE
351 }
352 #[doc = "A2 strong driver, soft edge"]
353 #[inline(always)]
354 pub fn is_sd_soe(&self) -> bool {
355 *self == PD11_A::SD_SOE
356 }
357 #[doc = "A2 medium driver"]
358 #[inline(always)]
359 pub fn is_md(&self) -> bool {
360 *self == PD11_A::MD
361 }
362 #[doc = "A2 weak driver"]
363 #[inline(always)]
364 pub fn is_wd(&self) -> bool {
365 *self == PD11_A::WD
366 }
367}
368#[doc = "Field `PD11` writer - Pad Driver Mode for Pn.11"]
369pub type PD11_W<'a, REG> = crate::FieldWriter<'a, REG, 3, PD11_A>;
370impl<'a, REG> PD11_W<'a, REG>
371where
372 REG: crate::Writable + crate::RegisterSpec,
373 REG::Ux: From<u8>,
374{
375 #[doc = "A2 strong driver, sharp edge"]
376 #[inline(always)]
377 pub fn sd_she(self) -> &'a mut crate::W<REG> {
378 self.variant(PD11_A::SD_SHE)
379 }
380 #[doc = "A2 strong driver, medium edge"]
381 #[inline(always)]
382 pub fn sd_mee(self) -> &'a mut crate::W<REG> {
383 self.variant(PD11_A::SD_MEE)
384 }
385 #[doc = "A2 strong driver, soft edge"]
386 #[inline(always)]
387 pub fn sd_soe(self) -> &'a mut crate::W<REG> {
388 self.variant(PD11_A::SD_SOE)
389 }
390 #[doc = "A2 medium driver"]
391 #[inline(always)]
392 pub fn md(self) -> &'a mut crate::W<REG> {
393 self.variant(PD11_A::MD)
394 }
395 #[doc = "A2 weak driver"]
396 #[inline(always)]
397 pub fn wd(self) -> &'a mut crate::W<REG> {
398 self.variant(PD11_A::WD)
399 }
400}
401#[doc = "Pad Driver Mode for Pn.12\n\nValue on reset: 2"]
402#[derive(Clone, Copy, Debug, PartialEq, Eq)]
403#[repr(u8)]
404pub enum PD12_A {
405 #[doc = "0: A2 strong driver, sharp edge"]
406 SD_SHE = 0,
407 #[doc = "1: A2 strong driver, medium edge"]
408 SD_MEE = 1,
409 #[doc = "2: A2 strong driver, soft edge"]
410 SD_SOE = 2,
411 #[doc = "4: A2 medium driver"]
412 MD = 4,
413 #[doc = "7: A2 weak driver"]
414 WD = 7,
415}
416impl From<PD12_A> for u8 {
417 #[inline(always)]
418 fn from(variant: PD12_A) -> Self {
419 variant as _
420 }
421}
422impl crate::FieldSpec for PD12_A {
423 type Ux = u8;
424}
425impl crate::IsEnum for PD12_A {}
426#[doc = "Field `PD12` reader - Pad Driver Mode for Pn.12"]
427pub type PD12_R = crate::FieldReader<PD12_A>;
428impl PD12_R {
429 #[doc = "Get enumerated values variant"]
430 #[inline(always)]
431 pub const fn variant(&self) -> Option<PD12_A> {
432 match self.bits {
433 0 => Some(PD12_A::SD_SHE),
434 1 => Some(PD12_A::SD_MEE),
435 2 => Some(PD12_A::SD_SOE),
436 4 => Some(PD12_A::MD),
437 7 => Some(PD12_A::WD),
438 _ => None,
439 }
440 }
441 #[doc = "A2 strong driver, sharp edge"]
442 #[inline(always)]
443 pub fn is_sd_she(&self) -> bool {
444 *self == PD12_A::SD_SHE
445 }
446 #[doc = "A2 strong driver, medium edge"]
447 #[inline(always)]
448 pub fn is_sd_mee(&self) -> bool {
449 *self == PD12_A::SD_MEE
450 }
451 #[doc = "A2 strong driver, soft edge"]
452 #[inline(always)]
453 pub fn is_sd_soe(&self) -> bool {
454 *self == PD12_A::SD_SOE
455 }
456 #[doc = "A2 medium driver"]
457 #[inline(always)]
458 pub fn is_md(&self) -> bool {
459 *self == PD12_A::MD
460 }
461 #[doc = "A2 weak driver"]
462 #[inline(always)]
463 pub fn is_wd(&self) -> bool {
464 *self == PD12_A::WD
465 }
466}
467#[doc = "Field `PD12` writer - Pad Driver Mode for Pn.12"]
468pub type PD12_W<'a, REG> = crate::FieldWriter<'a, REG, 3, PD12_A>;
469impl<'a, REG> PD12_W<'a, REG>
470where
471 REG: crate::Writable + crate::RegisterSpec,
472 REG::Ux: From<u8>,
473{
474 #[doc = "A2 strong driver, sharp edge"]
475 #[inline(always)]
476 pub fn sd_she(self) -> &'a mut crate::W<REG> {
477 self.variant(PD12_A::SD_SHE)
478 }
479 #[doc = "A2 strong driver, medium edge"]
480 #[inline(always)]
481 pub fn sd_mee(self) -> &'a mut crate::W<REG> {
482 self.variant(PD12_A::SD_MEE)
483 }
484 #[doc = "A2 strong driver, soft edge"]
485 #[inline(always)]
486 pub fn sd_soe(self) -> &'a mut crate::W<REG> {
487 self.variant(PD12_A::SD_SOE)
488 }
489 #[doc = "A2 medium driver"]
490 #[inline(always)]
491 pub fn md(self) -> &'a mut crate::W<REG> {
492 self.variant(PD12_A::MD)
493 }
494 #[doc = "A2 weak driver"]
495 #[inline(always)]
496 pub fn wd(self) -> &'a mut crate::W<REG> {
497 self.variant(PD12_A::WD)
498 }
499}
500#[doc = "Pad Driver Mode for Pn.13\n\nValue on reset: 2"]
501#[derive(Clone, Copy, Debug, PartialEq, Eq)]
502#[repr(u8)]
503pub enum PD13_A {
504 #[doc = "0: A2 strong driver, sharp edge"]
505 SD_SHE = 0,
506 #[doc = "1: A2 strong driver, medium edge"]
507 SD_MEE = 1,
508 #[doc = "2: A2 strong driver, soft edge"]
509 SD_SOE = 2,
510 #[doc = "4: A2 medium driver"]
511 MD = 4,
512 #[doc = "7: A2 weak driver"]
513 WD = 7,
514}
515impl From<PD13_A> for u8 {
516 #[inline(always)]
517 fn from(variant: PD13_A) -> Self {
518 variant as _
519 }
520}
521impl crate::FieldSpec for PD13_A {
522 type Ux = u8;
523}
524impl crate::IsEnum for PD13_A {}
525#[doc = "Field `PD13` reader - Pad Driver Mode for Pn.13"]
526pub type PD13_R = crate::FieldReader<PD13_A>;
527impl PD13_R {
528 #[doc = "Get enumerated values variant"]
529 #[inline(always)]
530 pub const fn variant(&self) -> Option<PD13_A> {
531 match self.bits {
532 0 => Some(PD13_A::SD_SHE),
533 1 => Some(PD13_A::SD_MEE),
534 2 => Some(PD13_A::SD_SOE),
535 4 => Some(PD13_A::MD),
536 7 => Some(PD13_A::WD),
537 _ => None,
538 }
539 }
540 #[doc = "A2 strong driver, sharp edge"]
541 #[inline(always)]
542 pub fn is_sd_she(&self) -> bool {
543 *self == PD13_A::SD_SHE
544 }
545 #[doc = "A2 strong driver, medium edge"]
546 #[inline(always)]
547 pub fn is_sd_mee(&self) -> bool {
548 *self == PD13_A::SD_MEE
549 }
550 #[doc = "A2 strong driver, soft edge"]
551 #[inline(always)]
552 pub fn is_sd_soe(&self) -> bool {
553 *self == PD13_A::SD_SOE
554 }
555 #[doc = "A2 medium driver"]
556 #[inline(always)]
557 pub fn is_md(&self) -> bool {
558 *self == PD13_A::MD
559 }
560 #[doc = "A2 weak driver"]
561 #[inline(always)]
562 pub fn is_wd(&self) -> bool {
563 *self == PD13_A::WD
564 }
565}
566#[doc = "Field `PD13` writer - Pad Driver Mode for Pn.13"]
567pub type PD13_W<'a, REG> = crate::FieldWriter<'a, REG, 3, PD13_A>;
568impl<'a, REG> PD13_W<'a, REG>
569where
570 REG: crate::Writable + crate::RegisterSpec,
571 REG::Ux: From<u8>,
572{
573 #[doc = "A2 strong driver, sharp edge"]
574 #[inline(always)]
575 pub fn sd_she(self) -> &'a mut crate::W<REG> {
576 self.variant(PD13_A::SD_SHE)
577 }
578 #[doc = "A2 strong driver, medium edge"]
579 #[inline(always)]
580 pub fn sd_mee(self) -> &'a mut crate::W<REG> {
581 self.variant(PD13_A::SD_MEE)
582 }
583 #[doc = "A2 strong driver, soft edge"]
584 #[inline(always)]
585 pub fn sd_soe(self) -> &'a mut crate::W<REG> {
586 self.variant(PD13_A::SD_SOE)
587 }
588 #[doc = "A2 medium driver"]
589 #[inline(always)]
590 pub fn md(self) -> &'a mut crate::W<REG> {
591 self.variant(PD13_A::MD)
592 }
593 #[doc = "A2 weak driver"]
594 #[inline(always)]
595 pub fn wd(self) -> &'a mut crate::W<REG> {
596 self.variant(PD13_A::WD)
597 }
598}
599#[doc = "Pad Driver Mode for Pn.14\n\nValue on reset: 2"]
600#[derive(Clone, Copy, Debug, PartialEq, Eq)]
601#[repr(u8)]
602pub enum PD14_A {
603 #[doc = "0: A2 strong driver, sharp edge"]
604 SD_SHE = 0,
605 #[doc = "1: A2 strong driver, medium edge"]
606 SD_MEE = 1,
607 #[doc = "2: A2 strong driver, soft edge"]
608 SD_SOE = 2,
609 #[doc = "4: A2 medium driver"]
610 MD = 4,
611 #[doc = "7: A2 weak driver"]
612 WD = 7,
613}
614impl From<PD14_A> for u8 {
615 #[inline(always)]
616 fn from(variant: PD14_A) -> Self {
617 variant as _
618 }
619}
620impl crate::FieldSpec for PD14_A {
621 type Ux = u8;
622}
623impl crate::IsEnum for PD14_A {}
624#[doc = "Field `PD14` reader - Pad Driver Mode for Pn.14"]
625pub type PD14_R = crate::FieldReader<PD14_A>;
626impl PD14_R {
627 #[doc = "Get enumerated values variant"]
628 #[inline(always)]
629 pub const fn variant(&self) -> Option<PD14_A> {
630 match self.bits {
631 0 => Some(PD14_A::SD_SHE),
632 1 => Some(PD14_A::SD_MEE),
633 2 => Some(PD14_A::SD_SOE),
634 4 => Some(PD14_A::MD),
635 7 => Some(PD14_A::WD),
636 _ => None,
637 }
638 }
639 #[doc = "A2 strong driver, sharp edge"]
640 #[inline(always)]
641 pub fn is_sd_she(&self) -> bool {
642 *self == PD14_A::SD_SHE
643 }
644 #[doc = "A2 strong driver, medium edge"]
645 #[inline(always)]
646 pub fn is_sd_mee(&self) -> bool {
647 *self == PD14_A::SD_MEE
648 }
649 #[doc = "A2 strong driver, soft edge"]
650 #[inline(always)]
651 pub fn is_sd_soe(&self) -> bool {
652 *self == PD14_A::SD_SOE
653 }
654 #[doc = "A2 medium driver"]
655 #[inline(always)]
656 pub fn is_md(&self) -> bool {
657 *self == PD14_A::MD
658 }
659 #[doc = "A2 weak driver"]
660 #[inline(always)]
661 pub fn is_wd(&self) -> bool {
662 *self == PD14_A::WD
663 }
664}
665#[doc = "Field `PD14` writer - Pad Driver Mode for Pn.14"]
666pub type PD14_W<'a, REG> = crate::FieldWriter<'a, REG, 3, PD14_A>;
667impl<'a, REG> PD14_W<'a, REG>
668where
669 REG: crate::Writable + crate::RegisterSpec,
670 REG::Ux: From<u8>,
671{
672 #[doc = "A2 strong driver, sharp edge"]
673 #[inline(always)]
674 pub fn sd_she(self) -> &'a mut crate::W<REG> {
675 self.variant(PD14_A::SD_SHE)
676 }
677 #[doc = "A2 strong driver, medium edge"]
678 #[inline(always)]
679 pub fn sd_mee(self) -> &'a mut crate::W<REG> {
680 self.variant(PD14_A::SD_MEE)
681 }
682 #[doc = "A2 strong driver, soft edge"]
683 #[inline(always)]
684 pub fn sd_soe(self) -> &'a mut crate::W<REG> {
685 self.variant(PD14_A::SD_SOE)
686 }
687 #[doc = "A2 medium driver"]
688 #[inline(always)]
689 pub fn md(self) -> &'a mut crate::W<REG> {
690 self.variant(PD14_A::MD)
691 }
692 #[doc = "A2 weak driver"]
693 #[inline(always)]
694 pub fn wd(self) -> &'a mut crate::W<REG> {
695 self.variant(PD14_A::WD)
696 }
697}
698#[doc = "Pad Driver Mode for Pn.15\n\nValue on reset: 2"]
699#[derive(Clone, Copy, Debug, PartialEq, Eq)]
700#[repr(u8)]
701pub enum PD15_A {
702 #[doc = "0: A2 strong driver, sharp edge"]
703 SD_SHE = 0,
704 #[doc = "1: A2 strong driver, medium edge"]
705 SD_MEE = 1,
706 #[doc = "2: A2 strong driver, soft edge"]
707 SD_SOE = 2,
708 #[doc = "4: A2 medium driver"]
709 MD = 4,
710 #[doc = "7: A2 weak driver"]
711 WD = 7,
712}
713impl From<PD15_A> for u8 {
714 #[inline(always)]
715 fn from(variant: PD15_A) -> Self {
716 variant as _
717 }
718}
719impl crate::FieldSpec for PD15_A {
720 type Ux = u8;
721}
722impl crate::IsEnum for PD15_A {}
723#[doc = "Field `PD15` reader - Pad Driver Mode for Pn.15"]
724pub type PD15_R = crate::FieldReader<PD15_A>;
725impl PD15_R {
726 #[doc = "Get enumerated values variant"]
727 #[inline(always)]
728 pub const fn variant(&self) -> Option<PD15_A> {
729 match self.bits {
730 0 => Some(PD15_A::SD_SHE),
731 1 => Some(PD15_A::SD_MEE),
732 2 => Some(PD15_A::SD_SOE),
733 4 => Some(PD15_A::MD),
734 7 => Some(PD15_A::WD),
735 _ => None,
736 }
737 }
738 #[doc = "A2 strong driver, sharp edge"]
739 #[inline(always)]
740 pub fn is_sd_she(&self) -> bool {
741 *self == PD15_A::SD_SHE
742 }
743 #[doc = "A2 strong driver, medium edge"]
744 #[inline(always)]
745 pub fn is_sd_mee(&self) -> bool {
746 *self == PD15_A::SD_MEE
747 }
748 #[doc = "A2 strong driver, soft edge"]
749 #[inline(always)]
750 pub fn is_sd_soe(&self) -> bool {
751 *self == PD15_A::SD_SOE
752 }
753 #[doc = "A2 medium driver"]
754 #[inline(always)]
755 pub fn is_md(&self) -> bool {
756 *self == PD15_A::MD
757 }
758 #[doc = "A2 weak driver"]
759 #[inline(always)]
760 pub fn is_wd(&self) -> bool {
761 *self == PD15_A::WD
762 }
763}
764#[doc = "Field `PD15` writer - Pad Driver Mode for Pn.15"]
765pub type PD15_W<'a, REG> = crate::FieldWriter<'a, REG, 3, PD15_A>;
766impl<'a, REG> PD15_W<'a, REG>
767where
768 REG: crate::Writable + crate::RegisterSpec,
769 REG::Ux: From<u8>,
770{
771 #[doc = "A2 strong driver, sharp edge"]
772 #[inline(always)]
773 pub fn sd_she(self) -> &'a mut crate::W<REG> {
774 self.variant(PD15_A::SD_SHE)
775 }
776 #[doc = "A2 strong driver, medium edge"]
777 #[inline(always)]
778 pub fn sd_mee(self) -> &'a mut crate::W<REG> {
779 self.variant(PD15_A::SD_MEE)
780 }
781 #[doc = "A2 strong driver, soft edge"]
782 #[inline(always)]
783 pub fn sd_soe(self) -> &'a mut crate::W<REG> {
784 self.variant(PD15_A::SD_SOE)
785 }
786 #[doc = "A2 medium driver"]
787 #[inline(always)]
788 pub fn md(self) -> &'a mut crate::W<REG> {
789 self.variant(PD15_A::MD)
790 }
791 #[doc = "A2 weak driver"]
792 #[inline(always)]
793 pub fn wd(self) -> &'a mut crate::W<REG> {
794 self.variant(PD15_A::WD)
795 }
796}
797impl R {
798 #[doc = "Bits 0:2 - Pad Driver Mode for Pn.8"]
799 #[inline(always)]
800 pub fn pd8(&self) -> PD8_R {
801 PD8_R::new((self.bits & 7) as u8)
802 }
803 #[doc = "Bits 4:6 - Pad Driver Mode for Pn.9"]
804 #[inline(always)]
805 pub fn pd9(&self) -> PD9_R {
806 PD9_R::new(((self.bits >> 4) & 7) as u8)
807 }
808 #[doc = "Bits 8:10 - Pad Driver Mode for Pn.10"]
809 #[inline(always)]
810 pub fn pd10(&self) -> PD10_R {
811 PD10_R::new(((self.bits >> 8) & 7) as u8)
812 }
813 #[doc = "Bits 12:14 - Pad Driver Mode for Pn.11"]
814 #[inline(always)]
815 pub fn pd11(&self) -> PD11_R {
816 PD11_R::new(((self.bits >> 12) & 7) as u8)
817 }
818 #[doc = "Bits 16:18 - Pad Driver Mode for Pn.12"]
819 #[inline(always)]
820 pub fn pd12(&self) -> PD12_R {
821 PD12_R::new(((self.bits >> 16) & 7) as u8)
822 }
823 #[doc = "Bits 20:22 - Pad Driver Mode for Pn.13"]
824 #[inline(always)]
825 pub fn pd13(&self) -> PD13_R {
826 PD13_R::new(((self.bits >> 20) & 7) as u8)
827 }
828 #[doc = "Bits 24:26 - Pad Driver Mode for Pn.14"]
829 #[inline(always)]
830 pub fn pd14(&self) -> PD14_R {
831 PD14_R::new(((self.bits >> 24) & 7) as u8)
832 }
833 #[doc = "Bits 28:30 - Pad Driver Mode for Pn.15"]
834 #[inline(always)]
835 pub fn pd15(&self) -> PD15_R {
836 PD15_R::new(((self.bits >> 28) & 7) as u8)
837 }
838}
839impl W {
840 #[doc = "Bits 0:2 - Pad Driver Mode for Pn.8"]
841 #[inline(always)]
842 pub fn pd8(&mut self) -> PD8_W<PDR1_SPEC> {
843 PD8_W::new(self, 0)
844 }
845 #[doc = "Bits 4:6 - Pad Driver Mode for Pn.9"]
846 #[inline(always)]
847 pub fn pd9(&mut self) -> PD9_W<PDR1_SPEC> {
848 PD9_W::new(self, 4)
849 }
850 #[doc = "Bits 8:10 - Pad Driver Mode for Pn.10"]
851 #[inline(always)]
852 pub fn pd10(&mut self) -> PD10_W<PDR1_SPEC> {
853 PD10_W::new(self, 8)
854 }
855 #[doc = "Bits 12:14 - Pad Driver Mode for Pn.11"]
856 #[inline(always)]
857 pub fn pd11(&mut self) -> PD11_W<PDR1_SPEC> {
858 PD11_W::new(self, 12)
859 }
860 #[doc = "Bits 16:18 - Pad Driver Mode for Pn.12"]
861 #[inline(always)]
862 pub fn pd12(&mut self) -> PD12_W<PDR1_SPEC> {
863 PD12_W::new(self, 16)
864 }
865 #[doc = "Bits 20:22 - Pad Driver Mode for Pn.13"]
866 #[inline(always)]
867 pub fn pd13(&mut self) -> PD13_W<PDR1_SPEC> {
868 PD13_W::new(self, 20)
869 }
870 #[doc = "Bits 24:26 - Pad Driver Mode for Pn.14"]
871 #[inline(always)]
872 pub fn pd14(&mut self) -> PD14_W<PDR1_SPEC> {
873 PD14_W::new(self, 24)
874 }
875 #[doc = "Bits 28:30 - Pad Driver Mode for Pn.15"]
876 #[inline(always)]
877 pub fn pd15(&mut self) -> PD15_W<PDR1_SPEC> {
878 PD15_W::new(self, 28)
879 }
880}
881#[doc = "Port 2 Pad Driver Mode 1 Register\n\nYou can [`read`](crate::Reg::read) this register and get [`pdr1::R`](R). You can [`reset`](crate::Reg::reset), [`write`](crate::Reg::write), [`write_with_zero`](crate::Reg::write_with_zero) this register using [`pdr1::W`](W). You can also [`modify`](crate::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
882pub struct PDR1_SPEC;
883impl crate::RegisterSpec for PDR1_SPEC {
884 type Ux = u32;
885}
886#[doc = "`read()` method returns [`pdr1::R`](R) reader structure"]
887impl crate::Readable for PDR1_SPEC {}
888#[doc = "`write(|w| ..)` method takes [`pdr1::W`](W) writer structure"]
889impl crate::Writable for PDR1_SPEC {
890 type Safety = crate::Unsafe;
891 const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
892 const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
893}
894#[doc = "`reset()` method sets PDR1 to value 0x2222_2222"]
895impl crate::Resettable for PDR1_SPEC {
896 const RESET_VALUE: u32 = 0x2222_2222;
897}