1#[doc = "Reader of register PADREGM"]
2pub type R = crate::R<u32, super::PADREGM>;
3#[doc = "Writer for register PADREGM"]
4pub type W = crate::W<u32, super::PADREGM>;
5#[doc = "Register PADREGM `reset()`'s with value 0x1818"]
6impl crate::ResetValue for super::PADREGM {
7 type Type = u32;
8 #[inline(always)]
9 fn reset_value() -> Self::Type {
10 0x1818
11 }
12}
13#[doc = "Pad 49 function select\n\nValue on reset: 3"]
14#[derive(Clone, Copy, Debug, PartialEq)]
15#[repr(u8)]
16pub enum PAD49FNCSEL_A {
17 #[doc = "0: Pad disabled"]
18 DIS = 0,
19 #[doc = "1: Configure as the SPI channel 7 nCE signal from IOMSTR0"]
20 M0NCE7 = 1,
21 #[doc = "2: Configure as the input/output signal from CTIMER B3"]
22 TCTB3 = 2,
23 #[doc = "3: Configure as GPIO49"]
24 GPIO49 = 3,
25}
26impl From<PAD49FNCSEL_A> for u8 {
27 #[inline(always)]
28 fn from(variant: PAD49FNCSEL_A) -> Self {
29 variant as _
30 }
31}
32#[doc = "Reader of field `PAD49FNCSEL`"]
33pub type PAD49FNCSEL_R = crate::R<u8, PAD49FNCSEL_A>;
34impl PAD49FNCSEL_R {
35 #[doc = r"Get enumerated values variant"]
36 #[inline(always)]
37 pub fn variant(&self) -> PAD49FNCSEL_A {
38 match self.bits {
39 0 => PAD49FNCSEL_A::DIS,
40 1 => PAD49FNCSEL_A::M0NCE7,
41 2 => PAD49FNCSEL_A::TCTB3,
42 3 => PAD49FNCSEL_A::GPIO49,
43 _ => unreachable!(),
44 }
45 }
46 #[doc = "Checks if the value of the field is `DIS`"]
47 #[inline(always)]
48 pub fn is_dis(&self) -> bool {
49 *self == PAD49FNCSEL_A::DIS
50 }
51 #[doc = "Checks if the value of the field is `M0NCE7`"]
52 #[inline(always)]
53 pub fn is_m0n_ce7(&self) -> bool {
54 *self == PAD49FNCSEL_A::M0NCE7
55 }
56 #[doc = "Checks if the value of the field is `TCTB3`"]
57 #[inline(always)]
58 pub fn is_tctb3(&self) -> bool {
59 *self == PAD49FNCSEL_A::TCTB3
60 }
61 #[doc = "Checks if the value of the field is `GPIO49`"]
62 #[inline(always)]
63 pub fn is_gpio49(&self) -> bool {
64 *self == PAD49FNCSEL_A::GPIO49
65 }
66}
67#[doc = "Write proxy for field `PAD49FNCSEL`"]
68pub struct PAD49FNCSEL_W<'a> {
69 w: &'a mut W,
70}
71impl<'a> PAD49FNCSEL_W<'a> {
72 #[doc = r"Writes `variant` to the field"]
73 #[inline(always)]
74 pub fn variant(self, variant: PAD49FNCSEL_A) -> &'a mut W {
75 {
76 self.bits(variant.into())
77 }
78 }
79 #[doc = "Pad disabled"]
80 #[inline(always)]
81 pub fn dis(self) -> &'a mut W {
82 self.variant(PAD49FNCSEL_A::DIS)
83 }
84 #[doc = "Configure as the SPI channel 7 nCE signal from IOMSTR0"]
85 #[inline(always)]
86 pub fn m0n_ce7(self) -> &'a mut W {
87 self.variant(PAD49FNCSEL_A::M0NCE7)
88 }
89 #[doc = "Configure as the input/output signal from CTIMER B3"]
90 #[inline(always)]
91 pub fn tctb3(self) -> &'a mut W {
92 self.variant(PAD49FNCSEL_A::TCTB3)
93 }
94 #[doc = "Configure as GPIO49"]
95 #[inline(always)]
96 pub fn gpio49(self) -> &'a mut W {
97 self.variant(PAD49FNCSEL_A::GPIO49)
98 }
99 #[doc = r"Writes raw bits to the field"]
100 #[inline(always)]
101 pub fn bits(self, value: u8) -> &'a mut W {
102 self.w.bits = (self.w.bits & !(0x03 << 11)) | (((value as u32) & 0x03) << 11);
103 self.w
104 }
105}
106#[doc = "Pad 49 drive strength\n\nValue on reset: 0"]
107#[derive(Clone, Copy, Debug, PartialEq)]
108pub enum PAD49STRNG_A {
109 #[doc = "0: Low drive strength"]
110 LOW = 0,
111 #[doc = "1: High drive strength"]
112 HIGH = 1,
113}
114impl From<PAD49STRNG_A> for bool {
115 #[inline(always)]
116 fn from(variant: PAD49STRNG_A) -> Self {
117 variant as u8 != 0
118 }
119}
120#[doc = "Reader of field `PAD49STRNG`"]
121pub type PAD49STRNG_R = crate::R<bool, PAD49STRNG_A>;
122impl PAD49STRNG_R {
123 #[doc = r"Get enumerated values variant"]
124 #[inline(always)]
125 pub fn variant(&self) -> PAD49STRNG_A {
126 match self.bits {
127 false => PAD49STRNG_A::LOW,
128 true => PAD49STRNG_A::HIGH,
129 }
130 }
131 #[doc = "Checks if the value of the field is `LOW`"]
132 #[inline(always)]
133 pub fn is_low(&self) -> bool {
134 *self == PAD49STRNG_A::LOW
135 }
136 #[doc = "Checks if the value of the field is `HIGH`"]
137 #[inline(always)]
138 pub fn is_high(&self) -> bool {
139 *self == PAD49STRNG_A::HIGH
140 }
141}
142#[doc = "Write proxy for field `PAD49STRNG`"]
143pub struct PAD49STRNG_W<'a> {
144 w: &'a mut W,
145}
146impl<'a> PAD49STRNG_W<'a> {
147 #[doc = r"Writes `variant` to the field"]
148 #[inline(always)]
149 pub fn variant(self, variant: PAD49STRNG_A) -> &'a mut W {
150 {
151 self.bit(variant.into())
152 }
153 }
154 #[doc = "Low drive strength"]
155 #[inline(always)]
156 pub fn low(self) -> &'a mut W {
157 self.variant(PAD49STRNG_A::LOW)
158 }
159 #[doc = "High drive strength"]
160 #[inline(always)]
161 pub fn high(self) -> &'a mut W {
162 self.variant(PAD49STRNG_A::HIGH)
163 }
164 #[doc = r"Sets the field bit"]
165 #[inline(always)]
166 pub fn set_bit(self) -> &'a mut W {
167 self.bit(true)
168 }
169 #[doc = r"Clears the field bit"]
170 #[inline(always)]
171 pub fn clear_bit(self) -> &'a mut W {
172 self.bit(false)
173 }
174 #[doc = r"Writes raw bits to the field"]
175 #[inline(always)]
176 pub fn bit(self, value: bool) -> &'a mut W {
177 self.w.bits = (self.w.bits & !(0x01 << 10)) | (((value as u32) & 0x01) << 10);
178 self.w
179 }
180}
181#[doc = "Pad 49 input enable\n\nValue on reset: 0"]
182#[derive(Clone, Copy, Debug, PartialEq)]
183pub enum PAD49INPEN_A {
184 #[doc = "0: Pad input disabled"]
185 DIS = 0,
186 #[doc = "1: Pad input enabled"]
187 EN = 1,
188}
189impl From<PAD49INPEN_A> for bool {
190 #[inline(always)]
191 fn from(variant: PAD49INPEN_A) -> Self {
192 variant as u8 != 0
193 }
194}
195#[doc = "Reader of field `PAD49INPEN`"]
196pub type PAD49INPEN_R = crate::R<bool, PAD49INPEN_A>;
197impl PAD49INPEN_R {
198 #[doc = r"Get enumerated values variant"]
199 #[inline(always)]
200 pub fn variant(&self) -> PAD49INPEN_A {
201 match self.bits {
202 false => PAD49INPEN_A::DIS,
203 true => PAD49INPEN_A::EN,
204 }
205 }
206 #[doc = "Checks if the value of the field is `DIS`"]
207 #[inline(always)]
208 pub fn is_dis(&self) -> bool {
209 *self == PAD49INPEN_A::DIS
210 }
211 #[doc = "Checks if the value of the field is `EN`"]
212 #[inline(always)]
213 pub fn is_en(&self) -> bool {
214 *self == PAD49INPEN_A::EN
215 }
216}
217#[doc = "Write proxy for field `PAD49INPEN`"]
218pub struct PAD49INPEN_W<'a> {
219 w: &'a mut W,
220}
221impl<'a> PAD49INPEN_W<'a> {
222 #[doc = r"Writes `variant` to the field"]
223 #[inline(always)]
224 pub fn variant(self, variant: PAD49INPEN_A) -> &'a mut W {
225 {
226 self.bit(variant.into())
227 }
228 }
229 #[doc = "Pad input disabled"]
230 #[inline(always)]
231 pub fn dis(self) -> &'a mut W {
232 self.variant(PAD49INPEN_A::DIS)
233 }
234 #[doc = "Pad input enabled"]
235 #[inline(always)]
236 pub fn en(self) -> &'a mut W {
237 self.variant(PAD49INPEN_A::EN)
238 }
239 #[doc = r"Sets the field bit"]
240 #[inline(always)]
241 pub fn set_bit(self) -> &'a mut W {
242 self.bit(true)
243 }
244 #[doc = r"Clears the field bit"]
245 #[inline(always)]
246 pub fn clear_bit(self) -> &'a mut W {
247 self.bit(false)
248 }
249 #[doc = r"Writes raw bits to the field"]
250 #[inline(always)]
251 pub fn bit(self, value: bool) -> &'a mut W {
252 self.w.bits = (self.w.bits & !(0x01 << 9)) | (((value as u32) & 0x01) << 9);
253 self.w
254 }
255}
256#[doc = "Pad 49 pullup enable\n\nValue on reset: 0"]
257#[derive(Clone, Copy, Debug, PartialEq)]
258pub enum PAD49PULL_A {
259 #[doc = "0: Pullup disabled"]
260 DIS = 0,
261 #[doc = "1: Pullup enabled"]
262 EN = 1,
263}
264impl From<PAD49PULL_A> for bool {
265 #[inline(always)]
266 fn from(variant: PAD49PULL_A) -> Self {
267 variant as u8 != 0
268 }
269}
270#[doc = "Reader of field `PAD49PULL`"]
271pub type PAD49PULL_R = crate::R<bool, PAD49PULL_A>;
272impl PAD49PULL_R {
273 #[doc = r"Get enumerated values variant"]
274 #[inline(always)]
275 pub fn variant(&self) -> PAD49PULL_A {
276 match self.bits {
277 false => PAD49PULL_A::DIS,
278 true => PAD49PULL_A::EN,
279 }
280 }
281 #[doc = "Checks if the value of the field is `DIS`"]
282 #[inline(always)]
283 pub fn is_dis(&self) -> bool {
284 *self == PAD49PULL_A::DIS
285 }
286 #[doc = "Checks if the value of the field is `EN`"]
287 #[inline(always)]
288 pub fn is_en(&self) -> bool {
289 *self == PAD49PULL_A::EN
290 }
291}
292#[doc = "Write proxy for field `PAD49PULL`"]
293pub struct PAD49PULL_W<'a> {
294 w: &'a mut W,
295}
296impl<'a> PAD49PULL_W<'a> {
297 #[doc = r"Writes `variant` to the field"]
298 #[inline(always)]
299 pub fn variant(self, variant: PAD49PULL_A) -> &'a mut W {
300 {
301 self.bit(variant.into())
302 }
303 }
304 #[doc = "Pullup disabled"]
305 #[inline(always)]
306 pub fn dis(self) -> &'a mut W {
307 self.variant(PAD49PULL_A::DIS)
308 }
309 #[doc = "Pullup enabled"]
310 #[inline(always)]
311 pub fn en(self) -> &'a mut W {
312 self.variant(PAD49PULL_A::EN)
313 }
314 #[doc = r"Sets the field bit"]
315 #[inline(always)]
316 pub fn set_bit(self) -> &'a mut W {
317 self.bit(true)
318 }
319 #[doc = r"Clears the field bit"]
320 #[inline(always)]
321 pub fn clear_bit(self) -> &'a mut W {
322 self.bit(false)
323 }
324 #[doc = r"Writes raw bits to the field"]
325 #[inline(always)]
326 pub fn bit(self, value: bool) -> &'a mut W {
327 self.w.bits = (self.w.bits & !(0x01 << 8)) | (((value as u32) & 0x01) << 8);
328 self.w
329 }
330}
331#[doc = "Pad 48 function select\n\nValue on reset: 3"]
332#[derive(Clone, Copy, Debug, PartialEq)]
333#[repr(u8)]
334pub enum PAD48FNCSEL_A {
335 #[doc = "0: Pad disabled"]
336 DIS = 0,
337 #[doc = "1: Configure as the SPI channel 6 nCE signal from IOMSTR0"]
338 M0NCE6 = 1,
339 #[doc = "2: Configure as the input/output signal from CTIMER A3"]
340 TCTA3 = 2,
341 #[doc = "3: Configure as GPIO48"]
342 GPIO48 = 3,
343}
344impl From<PAD48FNCSEL_A> for u8 {
345 #[inline(always)]
346 fn from(variant: PAD48FNCSEL_A) -> Self {
347 variant as _
348 }
349}
350#[doc = "Reader of field `PAD48FNCSEL`"]
351pub type PAD48FNCSEL_R = crate::R<u8, PAD48FNCSEL_A>;
352impl PAD48FNCSEL_R {
353 #[doc = r"Get enumerated values variant"]
354 #[inline(always)]
355 pub fn variant(&self) -> PAD48FNCSEL_A {
356 match self.bits {
357 0 => PAD48FNCSEL_A::DIS,
358 1 => PAD48FNCSEL_A::M0NCE6,
359 2 => PAD48FNCSEL_A::TCTA3,
360 3 => PAD48FNCSEL_A::GPIO48,
361 _ => unreachable!(),
362 }
363 }
364 #[doc = "Checks if the value of the field is `DIS`"]
365 #[inline(always)]
366 pub fn is_dis(&self) -> bool {
367 *self == PAD48FNCSEL_A::DIS
368 }
369 #[doc = "Checks if the value of the field is `M0NCE6`"]
370 #[inline(always)]
371 pub fn is_m0n_ce6(&self) -> bool {
372 *self == PAD48FNCSEL_A::M0NCE6
373 }
374 #[doc = "Checks if the value of the field is `TCTA3`"]
375 #[inline(always)]
376 pub fn is_tcta3(&self) -> bool {
377 *self == PAD48FNCSEL_A::TCTA3
378 }
379 #[doc = "Checks if the value of the field is `GPIO48`"]
380 #[inline(always)]
381 pub fn is_gpio48(&self) -> bool {
382 *self == PAD48FNCSEL_A::GPIO48
383 }
384}
385#[doc = "Write proxy for field `PAD48FNCSEL`"]
386pub struct PAD48FNCSEL_W<'a> {
387 w: &'a mut W,
388}
389impl<'a> PAD48FNCSEL_W<'a> {
390 #[doc = r"Writes `variant` to the field"]
391 #[inline(always)]
392 pub fn variant(self, variant: PAD48FNCSEL_A) -> &'a mut W {
393 {
394 self.bits(variant.into())
395 }
396 }
397 #[doc = "Pad disabled"]
398 #[inline(always)]
399 pub fn dis(self) -> &'a mut W {
400 self.variant(PAD48FNCSEL_A::DIS)
401 }
402 #[doc = "Configure as the SPI channel 6 nCE signal from IOMSTR0"]
403 #[inline(always)]
404 pub fn m0n_ce6(self) -> &'a mut W {
405 self.variant(PAD48FNCSEL_A::M0NCE6)
406 }
407 #[doc = "Configure as the input/output signal from CTIMER A3"]
408 #[inline(always)]
409 pub fn tcta3(self) -> &'a mut W {
410 self.variant(PAD48FNCSEL_A::TCTA3)
411 }
412 #[doc = "Configure as GPIO48"]
413 #[inline(always)]
414 pub fn gpio48(self) -> &'a mut W {
415 self.variant(PAD48FNCSEL_A::GPIO48)
416 }
417 #[doc = r"Writes raw bits to the field"]
418 #[inline(always)]
419 pub fn bits(self, value: u8) -> &'a mut W {
420 self.w.bits = (self.w.bits & !(0x03 << 3)) | (((value as u32) & 0x03) << 3);
421 self.w
422 }
423}
424#[doc = "Pad 48 drive strength\n\nValue on reset: 0"]
425#[derive(Clone, Copy, Debug, PartialEq)]
426pub enum PAD48STRNG_A {
427 #[doc = "0: Low drive strength"]
428 LOW = 0,
429 #[doc = "1: High drive strength"]
430 HIGH = 1,
431}
432impl From<PAD48STRNG_A> for bool {
433 #[inline(always)]
434 fn from(variant: PAD48STRNG_A) -> Self {
435 variant as u8 != 0
436 }
437}
438#[doc = "Reader of field `PAD48STRNG`"]
439pub type PAD48STRNG_R = crate::R<bool, PAD48STRNG_A>;
440impl PAD48STRNG_R {
441 #[doc = r"Get enumerated values variant"]
442 #[inline(always)]
443 pub fn variant(&self) -> PAD48STRNG_A {
444 match self.bits {
445 false => PAD48STRNG_A::LOW,
446 true => PAD48STRNG_A::HIGH,
447 }
448 }
449 #[doc = "Checks if the value of the field is `LOW`"]
450 #[inline(always)]
451 pub fn is_low(&self) -> bool {
452 *self == PAD48STRNG_A::LOW
453 }
454 #[doc = "Checks if the value of the field is `HIGH`"]
455 #[inline(always)]
456 pub fn is_high(&self) -> bool {
457 *self == PAD48STRNG_A::HIGH
458 }
459}
460#[doc = "Write proxy for field `PAD48STRNG`"]
461pub struct PAD48STRNG_W<'a> {
462 w: &'a mut W,
463}
464impl<'a> PAD48STRNG_W<'a> {
465 #[doc = r"Writes `variant` to the field"]
466 #[inline(always)]
467 pub fn variant(self, variant: PAD48STRNG_A) -> &'a mut W {
468 {
469 self.bit(variant.into())
470 }
471 }
472 #[doc = "Low drive strength"]
473 #[inline(always)]
474 pub fn low(self) -> &'a mut W {
475 self.variant(PAD48STRNG_A::LOW)
476 }
477 #[doc = "High drive strength"]
478 #[inline(always)]
479 pub fn high(self) -> &'a mut W {
480 self.variant(PAD48STRNG_A::HIGH)
481 }
482 #[doc = r"Sets the field bit"]
483 #[inline(always)]
484 pub fn set_bit(self) -> &'a mut W {
485 self.bit(true)
486 }
487 #[doc = r"Clears the field bit"]
488 #[inline(always)]
489 pub fn clear_bit(self) -> &'a mut W {
490 self.bit(false)
491 }
492 #[doc = r"Writes raw bits to the field"]
493 #[inline(always)]
494 pub fn bit(self, value: bool) -> &'a mut W {
495 self.w.bits = (self.w.bits & !(0x01 << 2)) | (((value as u32) & 0x01) << 2);
496 self.w
497 }
498}
499#[doc = "Pad 48 input enable\n\nValue on reset: 0"]
500#[derive(Clone, Copy, Debug, PartialEq)]
501pub enum PAD48INPEN_A {
502 #[doc = "0: Pad input disabled"]
503 DIS = 0,
504 #[doc = "1: Pad input enabled"]
505 EN = 1,
506}
507impl From<PAD48INPEN_A> for bool {
508 #[inline(always)]
509 fn from(variant: PAD48INPEN_A) -> Self {
510 variant as u8 != 0
511 }
512}
513#[doc = "Reader of field `PAD48INPEN`"]
514pub type PAD48INPEN_R = crate::R<bool, PAD48INPEN_A>;
515impl PAD48INPEN_R {
516 #[doc = r"Get enumerated values variant"]
517 #[inline(always)]
518 pub fn variant(&self) -> PAD48INPEN_A {
519 match self.bits {
520 false => PAD48INPEN_A::DIS,
521 true => PAD48INPEN_A::EN,
522 }
523 }
524 #[doc = "Checks if the value of the field is `DIS`"]
525 #[inline(always)]
526 pub fn is_dis(&self) -> bool {
527 *self == PAD48INPEN_A::DIS
528 }
529 #[doc = "Checks if the value of the field is `EN`"]
530 #[inline(always)]
531 pub fn is_en(&self) -> bool {
532 *self == PAD48INPEN_A::EN
533 }
534}
535#[doc = "Write proxy for field `PAD48INPEN`"]
536pub struct PAD48INPEN_W<'a> {
537 w: &'a mut W,
538}
539impl<'a> PAD48INPEN_W<'a> {
540 #[doc = r"Writes `variant` to the field"]
541 #[inline(always)]
542 pub fn variant(self, variant: PAD48INPEN_A) -> &'a mut W {
543 {
544 self.bit(variant.into())
545 }
546 }
547 #[doc = "Pad input disabled"]
548 #[inline(always)]
549 pub fn dis(self) -> &'a mut W {
550 self.variant(PAD48INPEN_A::DIS)
551 }
552 #[doc = "Pad input enabled"]
553 #[inline(always)]
554 pub fn en(self) -> &'a mut W {
555 self.variant(PAD48INPEN_A::EN)
556 }
557 #[doc = r"Sets the field bit"]
558 #[inline(always)]
559 pub fn set_bit(self) -> &'a mut W {
560 self.bit(true)
561 }
562 #[doc = r"Clears the field bit"]
563 #[inline(always)]
564 pub fn clear_bit(self) -> &'a mut W {
565 self.bit(false)
566 }
567 #[doc = r"Writes raw bits to the field"]
568 #[inline(always)]
569 pub fn bit(self, value: bool) -> &'a mut W {
570 self.w.bits = (self.w.bits & !(0x01 << 1)) | (((value as u32) & 0x01) << 1);
571 self.w
572 }
573}
574#[doc = "Pad 48 pullup enable\n\nValue on reset: 0"]
575#[derive(Clone, Copy, Debug, PartialEq)]
576pub enum PAD48PULL_A {
577 #[doc = "0: Pullup disabled"]
578 DIS = 0,
579 #[doc = "1: Pullup enabled"]
580 EN = 1,
581}
582impl From<PAD48PULL_A> for bool {
583 #[inline(always)]
584 fn from(variant: PAD48PULL_A) -> Self {
585 variant as u8 != 0
586 }
587}
588#[doc = "Reader of field `PAD48PULL`"]
589pub type PAD48PULL_R = crate::R<bool, PAD48PULL_A>;
590impl PAD48PULL_R {
591 #[doc = r"Get enumerated values variant"]
592 #[inline(always)]
593 pub fn variant(&self) -> PAD48PULL_A {
594 match self.bits {
595 false => PAD48PULL_A::DIS,
596 true => PAD48PULL_A::EN,
597 }
598 }
599 #[doc = "Checks if the value of the field is `DIS`"]
600 #[inline(always)]
601 pub fn is_dis(&self) -> bool {
602 *self == PAD48PULL_A::DIS
603 }
604 #[doc = "Checks if the value of the field is `EN`"]
605 #[inline(always)]
606 pub fn is_en(&self) -> bool {
607 *self == PAD48PULL_A::EN
608 }
609}
610#[doc = "Write proxy for field `PAD48PULL`"]
611pub struct PAD48PULL_W<'a> {
612 w: &'a mut W,
613}
614impl<'a> PAD48PULL_W<'a> {
615 #[doc = r"Writes `variant` to the field"]
616 #[inline(always)]
617 pub fn variant(self, variant: PAD48PULL_A) -> &'a mut W {
618 {
619 self.bit(variant.into())
620 }
621 }
622 #[doc = "Pullup disabled"]
623 #[inline(always)]
624 pub fn dis(self) -> &'a mut W {
625 self.variant(PAD48PULL_A::DIS)
626 }
627 #[doc = "Pullup enabled"]
628 #[inline(always)]
629 pub fn en(self) -> &'a mut W {
630 self.variant(PAD48PULL_A::EN)
631 }
632 #[doc = r"Sets the field bit"]
633 #[inline(always)]
634 pub fn set_bit(self) -> &'a mut W {
635 self.bit(true)
636 }
637 #[doc = r"Clears the field bit"]
638 #[inline(always)]
639 pub fn clear_bit(self) -> &'a mut W {
640 self.bit(false)
641 }
642 #[doc = r"Writes raw bits to the field"]
643 #[inline(always)]
644 pub fn bit(self, value: bool) -> &'a mut W {
645 self.w.bits = (self.w.bits & !0x01) | ((value as u32) & 0x01);
646 self.w
647 }
648}
649impl R {
650 #[doc = "Bits 11:12 - Pad 49 function select"]
651 #[inline(always)]
652 pub fn pad49fncsel(&self) -> PAD49FNCSEL_R {
653 PAD49FNCSEL_R::new(((self.bits >> 11) & 0x03) as u8)
654 }
655 #[doc = "Bit 10 - Pad 49 drive strength"]
656 #[inline(always)]
657 pub fn pad49strng(&self) -> PAD49STRNG_R {
658 PAD49STRNG_R::new(((self.bits >> 10) & 0x01) != 0)
659 }
660 #[doc = "Bit 9 - Pad 49 input enable"]
661 #[inline(always)]
662 pub fn pad49inpen(&self) -> PAD49INPEN_R {
663 PAD49INPEN_R::new(((self.bits >> 9) & 0x01) != 0)
664 }
665 #[doc = "Bit 8 - Pad 49 pullup enable"]
666 #[inline(always)]
667 pub fn pad49pull(&self) -> PAD49PULL_R {
668 PAD49PULL_R::new(((self.bits >> 8) & 0x01) != 0)
669 }
670 #[doc = "Bits 3:4 - Pad 48 function select"]
671 #[inline(always)]
672 pub fn pad48fncsel(&self) -> PAD48FNCSEL_R {
673 PAD48FNCSEL_R::new(((self.bits >> 3) & 0x03) as u8)
674 }
675 #[doc = "Bit 2 - Pad 48 drive strength"]
676 #[inline(always)]
677 pub fn pad48strng(&self) -> PAD48STRNG_R {
678 PAD48STRNG_R::new(((self.bits >> 2) & 0x01) != 0)
679 }
680 #[doc = "Bit 1 - Pad 48 input enable"]
681 #[inline(always)]
682 pub fn pad48inpen(&self) -> PAD48INPEN_R {
683 PAD48INPEN_R::new(((self.bits >> 1) & 0x01) != 0)
684 }
685 #[doc = "Bit 0 - Pad 48 pullup enable"]
686 #[inline(always)]
687 pub fn pad48pull(&self) -> PAD48PULL_R {
688 PAD48PULL_R::new((self.bits & 0x01) != 0)
689 }
690}
691impl W {
692 #[doc = "Bits 11:12 - Pad 49 function select"]
693 #[inline(always)]
694 pub fn pad49fncsel(&mut self) -> PAD49FNCSEL_W {
695 PAD49FNCSEL_W { w: self }
696 }
697 #[doc = "Bit 10 - Pad 49 drive strength"]
698 #[inline(always)]
699 pub fn pad49strng(&mut self) -> PAD49STRNG_W {
700 PAD49STRNG_W { w: self }
701 }
702 #[doc = "Bit 9 - Pad 49 input enable"]
703 #[inline(always)]
704 pub fn pad49inpen(&mut self) -> PAD49INPEN_W {
705 PAD49INPEN_W { w: self }
706 }
707 #[doc = "Bit 8 - Pad 49 pullup enable"]
708 #[inline(always)]
709 pub fn pad49pull(&mut self) -> PAD49PULL_W {
710 PAD49PULL_W { w: self }
711 }
712 #[doc = "Bits 3:4 - Pad 48 function select"]
713 #[inline(always)]
714 pub fn pad48fncsel(&mut self) -> PAD48FNCSEL_W {
715 PAD48FNCSEL_W { w: self }
716 }
717 #[doc = "Bit 2 - Pad 48 drive strength"]
718 #[inline(always)]
719 pub fn pad48strng(&mut self) -> PAD48STRNG_W {
720 PAD48STRNG_W { w: self }
721 }
722 #[doc = "Bit 1 - Pad 48 input enable"]
723 #[inline(always)]
724 pub fn pad48inpen(&mut self) -> PAD48INPEN_W {
725 PAD48INPEN_W { w: self }
726 }
727 #[doc = "Bit 0 - Pad 48 pullup enable"]
728 #[inline(always)]
729 pub fn pad48pull(&mut self) -> PAD48PULL_W {
730 PAD48PULL_W { w: self }
731 }
732}