1#[doc = r" Value read from the register"]
2pub struct R {
3 bits: u8,
4}
5#[doc = r" Value to write to the register"]
6pub struct W {
7 bits: u8,
8}
9impl super::CR {
10 #[doc = r" Modifies the contents of the register"]
11 #[inline]
12 pub fn modify<F>(&self, f: F)
13 where
14 for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
15 {
16 let bits = self.register.get();
17 let r = R { bits: bits };
18 let mut w = W { bits: bits };
19 f(&r, &mut w);
20 self.register.set(w.bits);
21 }
22 #[doc = r" Reads the contents of the register"]
23 #[inline]
24 pub fn read(&self) -> R {
25 R {
26 bits: self.register.get(),
27 }
28 }
29 #[doc = r" Writes to the register"]
30 #[inline]
31 pub fn write<F>(&self, f: F)
32 where
33 F: FnOnce(&mut W) -> &mut W,
34 {
35 let mut w = W::reset_value();
36 f(&mut w);
37 self.register.set(w.bits);
38 }
39 #[doc = r" Writes the reset value to the register"]
40 #[inline]
41 pub fn reset(&self) {
42 self.write(|w| w)
43 }
44}
45#[doc = "Possible values of the field `SC16P`"]
46#[derive(Clone, Copy, Debug, PartialEq)]
47pub enum SC16PR {
48 #[doc = "Disable the selection."]
49 _0,
50 #[doc = "Add 16 pF capacitor to the oscillator load."]
51 _1,
52}
53impl SC16PR {
54 #[doc = r" Returns `true` if the bit is clear (0)"]
55 #[inline]
56 pub fn bit_is_clear(&self) -> bool {
57 !self.bit()
58 }
59 #[doc = r" Returns `true` if the bit is set (1)"]
60 #[inline]
61 pub fn bit_is_set(&self) -> bool {
62 self.bit()
63 }
64 #[doc = r" Value of the field as raw bits"]
65 #[inline]
66 pub fn bit(&self) -> bool {
67 match *self {
68 SC16PR::_0 => false,
69 SC16PR::_1 => true,
70 }
71 }
72 #[allow(missing_docs)]
73 #[doc(hidden)]
74 #[inline]
75 pub fn _from(value: bool) -> SC16PR {
76 match value {
77 false => SC16PR::_0,
78 true => SC16PR::_1,
79 }
80 }
81 #[doc = "Checks if the value of the field is `_0`"]
82 #[inline]
83 pub fn is_0(&self) -> bool {
84 *self == SC16PR::_0
85 }
86 #[doc = "Checks if the value of the field is `_1`"]
87 #[inline]
88 pub fn is_1(&self) -> bool {
89 *self == SC16PR::_1
90 }
91}
92#[doc = "Possible values of the field `SC8P`"]
93#[derive(Clone, Copy, Debug, PartialEq)]
94pub enum SC8PR {
95 #[doc = "Disable the selection."]
96 _0,
97 #[doc = "Add 8 pF capacitor to the oscillator load."]
98 _1,
99}
100impl SC8PR {
101 #[doc = r" Returns `true` if the bit is clear (0)"]
102 #[inline]
103 pub fn bit_is_clear(&self) -> bool {
104 !self.bit()
105 }
106 #[doc = r" Returns `true` if the bit is set (1)"]
107 #[inline]
108 pub fn bit_is_set(&self) -> bool {
109 self.bit()
110 }
111 #[doc = r" Value of the field as raw bits"]
112 #[inline]
113 pub fn bit(&self) -> bool {
114 match *self {
115 SC8PR::_0 => false,
116 SC8PR::_1 => true,
117 }
118 }
119 #[allow(missing_docs)]
120 #[doc(hidden)]
121 #[inline]
122 pub fn _from(value: bool) -> SC8PR {
123 match value {
124 false => SC8PR::_0,
125 true => SC8PR::_1,
126 }
127 }
128 #[doc = "Checks if the value of the field is `_0`"]
129 #[inline]
130 pub fn is_0(&self) -> bool {
131 *self == SC8PR::_0
132 }
133 #[doc = "Checks if the value of the field is `_1`"]
134 #[inline]
135 pub fn is_1(&self) -> bool {
136 *self == SC8PR::_1
137 }
138}
139#[doc = "Possible values of the field `SC4P`"]
140#[derive(Clone, Copy, Debug, PartialEq)]
141pub enum SC4PR {
142 #[doc = "Disable the selection."]
143 _0,
144 #[doc = "Add 4 pF capacitor to the oscillator load."]
145 _1,
146}
147impl SC4PR {
148 #[doc = r" Returns `true` if the bit is clear (0)"]
149 #[inline]
150 pub fn bit_is_clear(&self) -> bool {
151 !self.bit()
152 }
153 #[doc = r" Returns `true` if the bit is set (1)"]
154 #[inline]
155 pub fn bit_is_set(&self) -> bool {
156 self.bit()
157 }
158 #[doc = r" Value of the field as raw bits"]
159 #[inline]
160 pub fn bit(&self) -> bool {
161 match *self {
162 SC4PR::_0 => false,
163 SC4PR::_1 => true,
164 }
165 }
166 #[allow(missing_docs)]
167 #[doc(hidden)]
168 #[inline]
169 pub fn _from(value: bool) -> SC4PR {
170 match value {
171 false => SC4PR::_0,
172 true => SC4PR::_1,
173 }
174 }
175 #[doc = "Checks if the value of the field is `_0`"]
176 #[inline]
177 pub fn is_0(&self) -> bool {
178 *self == SC4PR::_0
179 }
180 #[doc = "Checks if the value of the field is `_1`"]
181 #[inline]
182 pub fn is_1(&self) -> bool {
183 *self == SC4PR::_1
184 }
185}
186#[doc = "Possible values of the field `SC2P`"]
187#[derive(Clone, Copy, Debug, PartialEq)]
188pub enum SC2PR {
189 #[doc = "Disable the selection."]
190 _0,
191 #[doc = "Add 2 pF capacitor to the oscillator load."]
192 _1,
193}
194impl SC2PR {
195 #[doc = r" Returns `true` if the bit is clear (0)"]
196 #[inline]
197 pub fn bit_is_clear(&self) -> bool {
198 !self.bit()
199 }
200 #[doc = r" Returns `true` if the bit is set (1)"]
201 #[inline]
202 pub fn bit_is_set(&self) -> bool {
203 self.bit()
204 }
205 #[doc = r" Value of the field as raw bits"]
206 #[inline]
207 pub fn bit(&self) -> bool {
208 match *self {
209 SC2PR::_0 => false,
210 SC2PR::_1 => true,
211 }
212 }
213 #[allow(missing_docs)]
214 #[doc(hidden)]
215 #[inline]
216 pub fn _from(value: bool) -> SC2PR {
217 match value {
218 false => SC2PR::_0,
219 true => SC2PR::_1,
220 }
221 }
222 #[doc = "Checks if the value of the field is `_0`"]
223 #[inline]
224 pub fn is_0(&self) -> bool {
225 *self == SC2PR::_0
226 }
227 #[doc = "Checks if the value of the field is `_1`"]
228 #[inline]
229 pub fn is_1(&self) -> bool {
230 *self == SC2PR::_1
231 }
232}
233#[doc = "Possible values of the field `EREFSTEN`"]
234#[derive(Clone, Copy, Debug, PartialEq)]
235pub enum EREFSTENR {
236 #[doc = "External reference clock is disabled in Stop mode."]
237 _0,
238 #[doc = "External reference clock stays enabled in Stop mode if ERCLKEN is set before entering Stop mode."]
239 _1,
240}
241impl EREFSTENR {
242 #[doc = r" Returns `true` if the bit is clear (0)"]
243 #[inline]
244 pub fn bit_is_clear(&self) -> bool {
245 !self.bit()
246 }
247 #[doc = r" Returns `true` if the bit is set (1)"]
248 #[inline]
249 pub fn bit_is_set(&self) -> bool {
250 self.bit()
251 }
252 #[doc = r" Value of the field as raw bits"]
253 #[inline]
254 pub fn bit(&self) -> bool {
255 match *self {
256 EREFSTENR::_0 => false,
257 EREFSTENR::_1 => true,
258 }
259 }
260 #[allow(missing_docs)]
261 #[doc(hidden)]
262 #[inline]
263 pub fn _from(value: bool) -> EREFSTENR {
264 match value {
265 false => EREFSTENR::_0,
266 true => EREFSTENR::_1,
267 }
268 }
269 #[doc = "Checks if the value of the field is `_0`"]
270 #[inline]
271 pub fn is_0(&self) -> bool {
272 *self == EREFSTENR::_0
273 }
274 #[doc = "Checks if the value of the field is `_1`"]
275 #[inline]
276 pub fn is_1(&self) -> bool {
277 *self == EREFSTENR::_1
278 }
279}
280#[doc = "Possible values of the field `ERCLKEN`"]
281#[derive(Clone, Copy, Debug, PartialEq)]
282pub enum ERCLKENR {
283 #[doc = "External reference clock is inactive."]
284 _0,
285 #[doc = "External reference clock is enabled."]
286 _1,
287}
288impl ERCLKENR {
289 #[doc = r" Returns `true` if the bit is clear (0)"]
290 #[inline]
291 pub fn bit_is_clear(&self) -> bool {
292 !self.bit()
293 }
294 #[doc = r" Returns `true` if the bit is set (1)"]
295 #[inline]
296 pub fn bit_is_set(&self) -> bool {
297 self.bit()
298 }
299 #[doc = r" Value of the field as raw bits"]
300 #[inline]
301 pub fn bit(&self) -> bool {
302 match *self {
303 ERCLKENR::_0 => false,
304 ERCLKENR::_1 => true,
305 }
306 }
307 #[allow(missing_docs)]
308 #[doc(hidden)]
309 #[inline]
310 pub fn _from(value: bool) -> ERCLKENR {
311 match value {
312 false => ERCLKENR::_0,
313 true => ERCLKENR::_1,
314 }
315 }
316 #[doc = "Checks if the value of the field is `_0`"]
317 #[inline]
318 pub fn is_0(&self) -> bool {
319 *self == ERCLKENR::_0
320 }
321 #[doc = "Checks if the value of the field is `_1`"]
322 #[inline]
323 pub fn is_1(&self) -> bool {
324 *self == ERCLKENR::_1
325 }
326}
327#[doc = "Values that can be written to the field `SC16P`"]
328pub enum SC16PW {
329 #[doc = "Disable the selection."]
330 _0,
331 #[doc = "Add 16 pF capacitor to the oscillator load."]
332 _1,
333}
334impl SC16PW {
335 #[allow(missing_docs)]
336 #[doc(hidden)]
337 #[inline]
338 pub fn _bits(&self) -> bool {
339 match *self {
340 SC16PW::_0 => false,
341 SC16PW::_1 => true,
342 }
343 }
344}
345#[doc = r" Proxy"]
346pub struct _SC16PW<'a> {
347 w: &'a mut W,
348}
349impl<'a> _SC16PW<'a> {
350 #[doc = r" Writes `variant` to the field"]
351 #[inline]
352 pub fn variant(self, variant: SC16PW) -> &'a mut W {
353 {
354 self.bit(variant._bits())
355 }
356 }
357 #[doc = "Disable the selection."]
358 #[inline]
359 pub fn _0(self) -> &'a mut W {
360 self.variant(SC16PW::_0)
361 }
362 #[doc = "Add 16 pF capacitor to the oscillator load."]
363 #[inline]
364 pub fn _1(self) -> &'a mut W {
365 self.variant(SC16PW::_1)
366 }
367 #[doc = r" Sets the field bit"]
368 pub fn set_bit(self) -> &'a mut W {
369 self.bit(true)
370 }
371 #[doc = r" Clears the field bit"]
372 pub fn clear_bit(self) -> &'a mut W {
373 self.bit(false)
374 }
375 #[doc = r" Writes raw bits to the field"]
376 #[inline]
377 pub fn bit(self, value: bool) -> &'a mut W {
378 const MASK: bool = true;
379 const OFFSET: u8 = 0;
380 self.w.bits &= !((MASK as u8) << OFFSET);
381 self.w.bits |= ((value & MASK) as u8) << OFFSET;
382 self.w
383 }
384}
385#[doc = "Values that can be written to the field `SC8P`"]
386pub enum SC8PW {
387 #[doc = "Disable the selection."]
388 _0,
389 #[doc = "Add 8 pF capacitor to the oscillator load."]
390 _1,
391}
392impl SC8PW {
393 #[allow(missing_docs)]
394 #[doc(hidden)]
395 #[inline]
396 pub fn _bits(&self) -> bool {
397 match *self {
398 SC8PW::_0 => false,
399 SC8PW::_1 => true,
400 }
401 }
402}
403#[doc = r" Proxy"]
404pub struct _SC8PW<'a> {
405 w: &'a mut W,
406}
407impl<'a> _SC8PW<'a> {
408 #[doc = r" Writes `variant` to the field"]
409 #[inline]
410 pub fn variant(self, variant: SC8PW) -> &'a mut W {
411 {
412 self.bit(variant._bits())
413 }
414 }
415 #[doc = "Disable the selection."]
416 #[inline]
417 pub fn _0(self) -> &'a mut W {
418 self.variant(SC8PW::_0)
419 }
420 #[doc = "Add 8 pF capacitor to the oscillator load."]
421 #[inline]
422 pub fn _1(self) -> &'a mut W {
423 self.variant(SC8PW::_1)
424 }
425 #[doc = r" Sets the field bit"]
426 pub fn set_bit(self) -> &'a mut W {
427 self.bit(true)
428 }
429 #[doc = r" Clears the field bit"]
430 pub fn clear_bit(self) -> &'a mut W {
431 self.bit(false)
432 }
433 #[doc = r" Writes raw bits to the field"]
434 #[inline]
435 pub fn bit(self, value: bool) -> &'a mut W {
436 const MASK: bool = true;
437 const OFFSET: u8 = 1;
438 self.w.bits &= !((MASK as u8) << OFFSET);
439 self.w.bits |= ((value & MASK) as u8) << OFFSET;
440 self.w
441 }
442}
443#[doc = "Values that can be written to the field `SC4P`"]
444pub enum SC4PW {
445 #[doc = "Disable the selection."]
446 _0,
447 #[doc = "Add 4 pF capacitor to the oscillator load."]
448 _1,
449}
450impl SC4PW {
451 #[allow(missing_docs)]
452 #[doc(hidden)]
453 #[inline]
454 pub fn _bits(&self) -> bool {
455 match *self {
456 SC4PW::_0 => false,
457 SC4PW::_1 => true,
458 }
459 }
460}
461#[doc = r" Proxy"]
462pub struct _SC4PW<'a> {
463 w: &'a mut W,
464}
465impl<'a> _SC4PW<'a> {
466 #[doc = r" Writes `variant` to the field"]
467 #[inline]
468 pub fn variant(self, variant: SC4PW) -> &'a mut W {
469 {
470 self.bit(variant._bits())
471 }
472 }
473 #[doc = "Disable the selection."]
474 #[inline]
475 pub fn _0(self) -> &'a mut W {
476 self.variant(SC4PW::_0)
477 }
478 #[doc = "Add 4 pF capacitor to the oscillator load."]
479 #[inline]
480 pub fn _1(self) -> &'a mut W {
481 self.variant(SC4PW::_1)
482 }
483 #[doc = r" Sets the field bit"]
484 pub fn set_bit(self) -> &'a mut W {
485 self.bit(true)
486 }
487 #[doc = r" Clears the field bit"]
488 pub fn clear_bit(self) -> &'a mut W {
489 self.bit(false)
490 }
491 #[doc = r" Writes raw bits to the field"]
492 #[inline]
493 pub fn bit(self, value: bool) -> &'a mut W {
494 const MASK: bool = true;
495 const OFFSET: u8 = 2;
496 self.w.bits &= !((MASK as u8) << OFFSET);
497 self.w.bits |= ((value & MASK) as u8) << OFFSET;
498 self.w
499 }
500}
501#[doc = "Values that can be written to the field `SC2P`"]
502pub enum SC2PW {
503 #[doc = "Disable the selection."]
504 _0,
505 #[doc = "Add 2 pF capacitor to the oscillator load."]
506 _1,
507}
508impl SC2PW {
509 #[allow(missing_docs)]
510 #[doc(hidden)]
511 #[inline]
512 pub fn _bits(&self) -> bool {
513 match *self {
514 SC2PW::_0 => false,
515 SC2PW::_1 => true,
516 }
517 }
518}
519#[doc = r" Proxy"]
520pub struct _SC2PW<'a> {
521 w: &'a mut W,
522}
523impl<'a> _SC2PW<'a> {
524 #[doc = r" Writes `variant` to the field"]
525 #[inline]
526 pub fn variant(self, variant: SC2PW) -> &'a mut W {
527 {
528 self.bit(variant._bits())
529 }
530 }
531 #[doc = "Disable the selection."]
532 #[inline]
533 pub fn _0(self) -> &'a mut W {
534 self.variant(SC2PW::_0)
535 }
536 #[doc = "Add 2 pF capacitor to the oscillator load."]
537 #[inline]
538 pub fn _1(self) -> &'a mut W {
539 self.variant(SC2PW::_1)
540 }
541 #[doc = r" Sets the field bit"]
542 pub fn set_bit(self) -> &'a mut W {
543 self.bit(true)
544 }
545 #[doc = r" Clears the field bit"]
546 pub fn clear_bit(self) -> &'a mut W {
547 self.bit(false)
548 }
549 #[doc = r" Writes raw bits to the field"]
550 #[inline]
551 pub fn bit(self, value: bool) -> &'a mut W {
552 const MASK: bool = true;
553 const OFFSET: u8 = 3;
554 self.w.bits &= !((MASK as u8) << OFFSET);
555 self.w.bits |= ((value & MASK) as u8) << OFFSET;
556 self.w
557 }
558}
559#[doc = "Values that can be written to the field `EREFSTEN`"]
560pub enum EREFSTENW {
561 #[doc = "External reference clock is disabled in Stop mode."]
562 _0,
563 #[doc = "External reference clock stays enabled in Stop mode if ERCLKEN is set before entering Stop mode."]
564 _1,
565}
566impl EREFSTENW {
567 #[allow(missing_docs)]
568 #[doc(hidden)]
569 #[inline]
570 pub fn _bits(&self) -> bool {
571 match *self {
572 EREFSTENW::_0 => false,
573 EREFSTENW::_1 => true,
574 }
575 }
576}
577#[doc = r" Proxy"]
578pub struct _EREFSTENW<'a> {
579 w: &'a mut W,
580}
581impl<'a> _EREFSTENW<'a> {
582 #[doc = r" Writes `variant` to the field"]
583 #[inline]
584 pub fn variant(self, variant: EREFSTENW) -> &'a mut W {
585 {
586 self.bit(variant._bits())
587 }
588 }
589 #[doc = "External reference clock is disabled in Stop mode."]
590 #[inline]
591 pub fn _0(self) -> &'a mut W {
592 self.variant(EREFSTENW::_0)
593 }
594 #[doc = "External reference clock stays enabled in Stop mode if ERCLKEN is set before entering Stop mode."]
595 #[inline]
596 pub fn _1(self) -> &'a mut W {
597 self.variant(EREFSTENW::_1)
598 }
599 #[doc = r" Sets the field bit"]
600 pub fn set_bit(self) -> &'a mut W {
601 self.bit(true)
602 }
603 #[doc = r" Clears the field bit"]
604 pub fn clear_bit(self) -> &'a mut W {
605 self.bit(false)
606 }
607 #[doc = r" Writes raw bits to the field"]
608 #[inline]
609 pub fn bit(self, value: bool) -> &'a mut W {
610 const MASK: bool = true;
611 const OFFSET: u8 = 5;
612 self.w.bits &= !((MASK as u8) << OFFSET);
613 self.w.bits |= ((value & MASK) as u8) << OFFSET;
614 self.w
615 }
616}
617#[doc = "Values that can be written to the field `ERCLKEN`"]
618pub enum ERCLKENW {
619 #[doc = "External reference clock is inactive."]
620 _0,
621 #[doc = "External reference clock is enabled."]
622 _1,
623}
624impl ERCLKENW {
625 #[allow(missing_docs)]
626 #[doc(hidden)]
627 #[inline]
628 pub fn _bits(&self) -> bool {
629 match *self {
630 ERCLKENW::_0 => false,
631 ERCLKENW::_1 => true,
632 }
633 }
634}
635#[doc = r" Proxy"]
636pub struct _ERCLKENW<'a> {
637 w: &'a mut W,
638}
639impl<'a> _ERCLKENW<'a> {
640 #[doc = r" Writes `variant` to the field"]
641 #[inline]
642 pub fn variant(self, variant: ERCLKENW) -> &'a mut W {
643 {
644 self.bit(variant._bits())
645 }
646 }
647 #[doc = "External reference clock is inactive."]
648 #[inline]
649 pub fn _0(self) -> &'a mut W {
650 self.variant(ERCLKENW::_0)
651 }
652 #[doc = "External reference clock is enabled."]
653 #[inline]
654 pub fn _1(self) -> &'a mut W {
655 self.variant(ERCLKENW::_1)
656 }
657 #[doc = r" Sets the field bit"]
658 pub fn set_bit(self) -> &'a mut W {
659 self.bit(true)
660 }
661 #[doc = r" Clears the field bit"]
662 pub fn clear_bit(self) -> &'a mut W {
663 self.bit(false)
664 }
665 #[doc = r" Writes raw bits to the field"]
666 #[inline]
667 pub fn bit(self, value: bool) -> &'a mut W {
668 const MASK: bool = true;
669 const OFFSET: u8 = 7;
670 self.w.bits &= !((MASK as u8) << OFFSET);
671 self.w.bits |= ((value & MASK) as u8) << OFFSET;
672 self.w
673 }
674}
675impl R {
676 #[doc = r" Value of the register as raw bits"]
677 #[inline]
678 pub fn bits(&self) -> u8 {
679 self.bits
680 }
681 #[doc = "Bit 0 - Oscillator 16 pF Capacitor Load Configure"]
682 #[inline]
683 pub fn sc16p(&self) -> SC16PR {
684 SC16PR::_from({
685 const MASK: bool = true;
686 const OFFSET: u8 = 0;
687 ((self.bits >> OFFSET) & MASK as u8) != 0
688 })
689 }
690 #[doc = "Bit 1 - Oscillator 8 pF Capacitor Load Configure"]
691 #[inline]
692 pub fn sc8p(&self) -> SC8PR {
693 SC8PR::_from({
694 const MASK: bool = true;
695 const OFFSET: u8 = 1;
696 ((self.bits >> OFFSET) & MASK as u8) != 0
697 })
698 }
699 #[doc = "Bit 2 - Oscillator 4 pF Capacitor Load Configure"]
700 #[inline]
701 pub fn sc4p(&self) -> SC4PR {
702 SC4PR::_from({
703 const MASK: bool = true;
704 const OFFSET: u8 = 2;
705 ((self.bits >> OFFSET) & MASK as u8) != 0
706 })
707 }
708 #[doc = "Bit 3 - Oscillator 2 pF Capacitor Load Configure"]
709 #[inline]
710 pub fn sc2p(&self) -> SC2PR {
711 SC2PR::_from({
712 const MASK: bool = true;
713 const OFFSET: u8 = 3;
714 ((self.bits >> OFFSET) & MASK as u8) != 0
715 })
716 }
717 #[doc = "Bit 5 - External Reference Stop Enable"]
718 #[inline]
719 pub fn erefsten(&self) -> EREFSTENR {
720 EREFSTENR::_from({
721 const MASK: bool = true;
722 const OFFSET: u8 = 5;
723 ((self.bits >> OFFSET) & MASK as u8) != 0
724 })
725 }
726 #[doc = "Bit 7 - External Reference Enable"]
727 #[inline]
728 pub fn erclken(&self) -> ERCLKENR {
729 ERCLKENR::_from({
730 const MASK: bool = true;
731 const OFFSET: u8 = 7;
732 ((self.bits >> OFFSET) & MASK as u8) != 0
733 })
734 }
735}
736impl W {
737 #[doc = r" Reset value of the register"]
738 #[inline]
739 pub fn reset_value() -> W {
740 W { bits: 0 }
741 }
742 #[doc = r" Writes raw bits to the register"]
743 #[inline]
744 pub unsafe fn bits(&mut self, bits: u8) -> &mut Self {
745 self.bits = bits;
746 self
747 }
748 #[doc = "Bit 0 - Oscillator 16 pF Capacitor Load Configure"]
749 #[inline]
750 pub fn sc16p(&mut self) -> _SC16PW {
751 _SC16PW { w: self }
752 }
753 #[doc = "Bit 1 - Oscillator 8 pF Capacitor Load Configure"]
754 #[inline]
755 pub fn sc8p(&mut self) -> _SC8PW {
756 _SC8PW { w: self }
757 }
758 #[doc = "Bit 2 - Oscillator 4 pF Capacitor Load Configure"]
759 #[inline]
760 pub fn sc4p(&mut self) -> _SC4PW {
761 _SC4PW { w: self }
762 }
763 #[doc = "Bit 3 - Oscillator 2 pF Capacitor Load Configure"]
764 #[inline]
765 pub fn sc2p(&mut self) -> _SC2PW {
766 _SC2PW { w: self }
767 }
768 #[doc = "Bit 5 - External Reference Stop Enable"]
769 #[inline]
770 pub fn erefsten(&mut self) -> _EREFSTENW {
771 _EREFSTENW { w: self }
772 }
773 #[doc = "Bit 7 - External Reference Enable"]
774 #[inline]
775 pub fn erclken(&mut self) -> _ERCLKENW {
776 _ERCLKENW { w: self }
777 }
778}