1#[doc = r" Value read from the register"]
2pub struct R {
3 bits: u32,
4}
5#[doc = r" Value to write to the register"]
6pub struct W {
7 bits: u32,
8}
9impl super::DEVPWREVENTEN {
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 `BURSTEVEN`"]
46#[derive(Clone, Copy, Debug, PartialEq)]
47pub enum BURSTEVENR {
48 #[doc = "Enable BURST status event value."]
49 EN,
50 #[doc = "Disable BURST status event value."]
51 DIS,
52}
53impl BURSTEVENR {
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 BURSTEVENR::EN => true,
69 BURSTEVENR::DIS => false,
70 }
71 }
72 #[allow(missing_docs)]
73 #[doc(hidden)]
74 #[inline]
75 pub fn _from(value: bool) -> BURSTEVENR {
76 match value {
77 true => BURSTEVENR::EN,
78 false => BURSTEVENR::DIS,
79 }
80 }
81 #[doc = "Checks if the value of the field is `EN`"]
82 #[inline]
83 pub fn is_en(&self) -> bool {
84 *self == BURSTEVENR::EN
85 }
86 #[doc = "Checks if the value of the field is `DIS`"]
87 #[inline]
88 pub fn is_dis(&self) -> bool {
89 *self == BURSTEVENR::DIS
90 }
91}
92#[doc = "Possible values of the field `BURSTFEATUREEVEN`"]
93#[derive(Clone, Copy, Debug, PartialEq)]
94pub enum BURSTFEATUREEVENR {
95 #[doc = "Enable BURSTFEATURE status event value."]
96 EN,
97 #[doc = "Disable BURSTFEATURE status event value."]
98 DIS,
99}
100impl BURSTFEATUREEVENR {
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 BURSTFEATUREEVENR::EN => true,
116 BURSTFEATUREEVENR::DIS => false,
117 }
118 }
119 #[allow(missing_docs)]
120 #[doc(hidden)]
121 #[inline]
122 pub fn _from(value: bool) -> BURSTFEATUREEVENR {
123 match value {
124 true => BURSTFEATUREEVENR::EN,
125 false => BURSTFEATUREEVENR::DIS,
126 }
127 }
128 #[doc = "Checks if the value of the field is `EN`"]
129 #[inline]
130 pub fn is_en(&self) -> bool {
131 *self == BURSTFEATUREEVENR::EN
132 }
133 #[doc = "Checks if the value of the field is `DIS`"]
134 #[inline]
135 pub fn is_dis(&self) -> bool {
136 *self == BURSTFEATUREEVENR::DIS
137 }
138}
139#[doc = "Possible values of the field `BLEFEATUREEVEN`"]
140#[derive(Clone, Copy, Debug, PartialEq)]
141pub enum BLEFEATUREEVENR {
142 #[doc = "Enable BLEFEATURE status event value."]
143 EN,
144 #[doc = "Disable BLEFEATURE status event value."]
145 DIS,
146}
147impl BLEFEATUREEVENR {
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 BLEFEATUREEVENR::EN => true,
163 BLEFEATUREEVENR::DIS => false,
164 }
165 }
166 #[allow(missing_docs)]
167 #[doc(hidden)]
168 #[inline]
169 pub fn _from(value: bool) -> BLEFEATUREEVENR {
170 match value {
171 true => BLEFEATUREEVENR::EN,
172 false => BLEFEATUREEVENR::DIS,
173 }
174 }
175 #[doc = "Checks if the value of the field is `EN`"]
176 #[inline]
177 pub fn is_en(&self) -> bool {
178 *self == BLEFEATUREEVENR::EN
179 }
180 #[doc = "Checks if the value of the field is `DIS`"]
181 #[inline]
182 pub fn is_dis(&self) -> bool {
183 *self == BLEFEATUREEVENR::DIS
184 }
185}
186#[doc = "Possible values of the field `BLELEVEN`"]
187#[derive(Clone, Copy, Debug, PartialEq)]
188pub enum BLELEVENR {
189 #[doc = "Enable BLE power-on status event value."]
190 EN,
191 #[doc = "Disable BLE power-on status event value."]
192 DIS,
193}
194impl BLELEVENR {
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 BLELEVENR::EN => true,
210 BLELEVENR::DIS => false,
211 }
212 }
213 #[allow(missing_docs)]
214 #[doc(hidden)]
215 #[inline]
216 pub fn _from(value: bool) -> BLELEVENR {
217 match value {
218 true => BLELEVENR::EN,
219 false => BLELEVENR::DIS,
220 }
221 }
222 #[doc = "Checks if the value of the field is `EN`"]
223 #[inline]
224 pub fn is_en(&self) -> bool {
225 *self == BLELEVENR::EN
226 }
227 #[doc = "Checks if the value of the field is `DIS`"]
228 #[inline]
229 pub fn is_dis(&self) -> bool {
230 *self == BLELEVENR::DIS
231 }
232}
233#[doc = "Possible values of the field `PDMEVEN`"]
234#[derive(Clone, Copy, Debug, PartialEq)]
235pub enum PDMEVENR {
236 #[doc = "Enable PDM power-on status event value."]
237 EN,
238 #[doc = "Disable PDM power-on status event value."]
239 DIS,
240}
241impl PDMEVENR {
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 PDMEVENR::EN => true,
257 PDMEVENR::DIS => false,
258 }
259 }
260 #[allow(missing_docs)]
261 #[doc(hidden)]
262 #[inline]
263 pub fn _from(value: bool) -> PDMEVENR {
264 match value {
265 true => PDMEVENR::EN,
266 false => PDMEVENR::DIS,
267 }
268 }
269 #[doc = "Checks if the value of the field is `EN`"]
270 #[inline]
271 pub fn is_en(&self) -> bool {
272 *self == PDMEVENR::EN
273 }
274 #[doc = "Checks if the value of the field is `DIS`"]
275 #[inline]
276 pub fn is_dis(&self) -> bool {
277 *self == PDMEVENR::DIS
278 }
279}
280#[doc = "Possible values of the field `MSPIEVEN`"]
281#[derive(Clone, Copy, Debug, PartialEq)]
282pub enum MSPIEVENR {
283 #[doc = "Enable MSPI power-on status event value."]
284 EN,
285 #[doc = "Disable MSPI power-on status event value."]
286 DIS,
287}
288impl MSPIEVENR {
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 MSPIEVENR::EN => true,
304 MSPIEVENR::DIS => false,
305 }
306 }
307 #[allow(missing_docs)]
308 #[doc(hidden)]
309 #[inline]
310 pub fn _from(value: bool) -> MSPIEVENR {
311 match value {
312 true => MSPIEVENR::EN,
313 false => MSPIEVENR::DIS,
314 }
315 }
316 #[doc = "Checks if the value of the field is `EN`"]
317 #[inline]
318 pub fn is_en(&self) -> bool {
319 *self == MSPIEVENR::EN
320 }
321 #[doc = "Checks if the value of the field is `DIS`"]
322 #[inline]
323 pub fn is_dis(&self) -> bool {
324 *self == MSPIEVENR::DIS
325 }
326}
327#[doc = "Possible values of the field `ADCEVEN`"]
328#[derive(Clone, Copy, Debug, PartialEq)]
329pub enum ADCEVENR {
330 #[doc = "Enable ADC power-on status event value."]
331 EN,
332 #[doc = "Disable ADC power-on status event value."]
333 DIS,
334}
335impl ADCEVENR {
336 #[doc = r" Returns `true` if the bit is clear (0)"]
337 #[inline]
338 pub fn bit_is_clear(&self) -> bool {
339 !self.bit()
340 }
341 #[doc = r" Returns `true` if the bit is set (1)"]
342 #[inline]
343 pub fn bit_is_set(&self) -> bool {
344 self.bit()
345 }
346 #[doc = r" Value of the field as raw bits"]
347 #[inline]
348 pub fn bit(&self) -> bool {
349 match *self {
350 ADCEVENR::EN => true,
351 ADCEVENR::DIS => false,
352 }
353 }
354 #[allow(missing_docs)]
355 #[doc(hidden)]
356 #[inline]
357 pub fn _from(value: bool) -> ADCEVENR {
358 match value {
359 true => ADCEVENR::EN,
360 false => ADCEVENR::DIS,
361 }
362 }
363 #[doc = "Checks if the value of the field is `EN`"]
364 #[inline]
365 pub fn is_en(&self) -> bool {
366 *self == ADCEVENR::EN
367 }
368 #[doc = "Checks if the value of the field is `DIS`"]
369 #[inline]
370 pub fn is_dis(&self) -> bool {
371 *self == ADCEVENR::DIS
372 }
373}
374#[doc = "Possible values of the field `HCPCEVEN`"]
375#[derive(Clone, Copy, Debug, PartialEq)]
376pub enum HCPCEVENR {
377 #[doc = "Enable HCPC power-on status event value."]
378 EN,
379 #[doc = "Disable HCPC power-on status event value."]
380 DIS,
381}
382impl HCPCEVENR {
383 #[doc = r" Returns `true` if the bit is clear (0)"]
384 #[inline]
385 pub fn bit_is_clear(&self) -> bool {
386 !self.bit()
387 }
388 #[doc = r" Returns `true` if the bit is set (1)"]
389 #[inline]
390 pub fn bit_is_set(&self) -> bool {
391 self.bit()
392 }
393 #[doc = r" Value of the field as raw bits"]
394 #[inline]
395 pub fn bit(&self) -> bool {
396 match *self {
397 HCPCEVENR::EN => true,
398 HCPCEVENR::DIS => false,
399 }
400 }
401 #[allow(missing_docs)]
402 #[doc(hidden)]
403 #[inline]
404 pub fn _from(value: bool) -> HCPCEVENR {
405 match value {
406 true => HCPCEVENR::EN,
407 false => HCPCEVENR::DIS,
408 }
409 }
410 #[doc = "Checks if the value of the field is `EN`"]
411 #[inline]
412 pub fn is_en(&self) -> bool {
413 *self == HCPCEVENR::EN
414 }
415 #[doc = "Checks if the value of the field is `DIS`"]
416 #[inline]
417 pub fn is_dis(&self) -> bool {
418 *self == HCPCEVENR::DIS
419 }
420}
421#[doc = "Possible values of the field `HCPBEVEN`"]
422#[derive(Clone, Copy, Debug, PartialEq)]
423pub enum HCPBEVENR {
424 #[doc = "Enable HCPB power-on status event value."]
425 EN,
426 #[doc = "Disable HCPB power-on status event value."]
427 DIS,
428}
429impl HCPBEVENR {
430 #[doc = r" Returns `true` if the bit is clear (0)"]
431 #[inline]
432 pub fn bit_is_clear(&self) -> bool {
433 !self.bit()
434 }
435 #[doc = r" Returns `true` if the bit is set (1)"]
436 #[inline]
437 pub fn bit_is_set(&self) -> bool {
438 self.bit()
439 }
440 #[doc = r" Value of the field as raw bits"]
441 #[inline]
442 pub fn bit(&self) -> bool {
443 match *self {
444 HCPBEVENR::EN => true,
445 HCPBEVENR::DIS => false,
446 }
447 }
448 #[allow(missing_docs)]
449 #[doc(hidden)]
450 #[inline]
451 pub fn _from(value: bool) -> HCPBEVENR {
452 match value {
453 true => HCPBEVENR::EN,
454 false => HCPBEVENR::DIS,
455 }
456 }
457 #[doc = "Checks if the value of the field is `EN`"]
458 #[inline]
459 pub fn is_en(&self) -> bool {
460 *self == HCPBEVENR::EN
461 }
462 #[doc = "Checks if the value of the field is `DIS`"]
463 #[inline]
464 pub fn is_dis(&self) -> bool {
465 *self == HCPBEVENR::DIS
466 }
467}
468#[doc = "Possible values of the field `HCPAEVEN`"]
469#[derive(Clone, Copy, Debug, PartialEq)]
470pub enum HCPAEVENR {
471 #[doc = "Enable HCPA power-on status event value."]
472 EN,
473 #[doc = "Disable HCPA power-on status event value."]
474 DIS,
475}
476impl HCPAEVENR {
477 #[doc = r" Returns `true` if the bit is clear (0)"]
478 #[inline]
479 pub fn bit_is_clear(&self) -> bool {
480 !self.bit()
481 }
482 #[doc = r" Returns `true` if the bit is set (1)"]
483 #[inline]
484 pub fn bit_is_set(&self) -> bool {
485 self.bit()
486 }
487 #[doc = r" Value of the field as raw bits"]
488 #[inline]
489 pub fn bit(&self) -> bool {
490 match *self {
491 HCPAEVENR::EN => true,
492 HCPAEVENR::DIS => false,
493 }
494 }
495 #[allow(missing_docs)]
496 #[doc(hidden)]
497 #[inline]
498 pub fn _from(value: bool) -> HCPAEVENR {
499 match value {
500 true => HCPAEVENR::EN,
501 false => HCPAEVENR::DIS,
502 }
503 }
504 #[doc = "Checks if the value of the field is `EN`"]
505 #[inline]
506 pub fn is_en(&self) -> bool {
507 *self == HCPAEVENR::EN
508 }
509 #[doc = "Checks if the value of the field is `DIS`"]
510 #[inline]
511 pub fn is_dis(&self) -> bool {
512 *self == HCPAEVENR::DIS
513 }
514}
515#[doc = "Possible values of the field `MCUHEVEN`"]
516#[derive(Clone, Copy, Debug, PartialEq)]
517pub enum MCUHEVENR {
518 #[doc = "Enable MCHU power-on status event value."]
519 EN,
520 #[doc = "Disable MCUH power-on status event value."]
521 DIS,
522}
523impl MCUHEVENR {
524 #[doc = r" Returns `true` if the bit is clear (0)"]
525 #[inline]
526 pub fn bit_is_clear(&self) -> bool {
527 !self.bit()
528 }
529 #[doc = r" Returns `true` if the bit is set (1)"]
530 #[inline]
531 pub fn bit_is_set(&self) -> bool {
532 self.bit()
533 }
534 #[doc = r" Value of the field as raw bits"]
535 #[inline]
536 pub fn bit(&self) -> bool {
537 match *self {
538 MCUHEVENR::EN => true,
539 MCUHEVENR::DIS => false,
540 }
541 }
542 #[allow(missing_docs)]
543 #[doc(hidden)]
544 #[inline]
545 pub fn _from(value: bool) -> MCUHEVENR {
546 match value {
547 true => MCUHEVENR::EN,
548 false => MCUHEVENR::DIS,
549 }
550 }
551 #[doc = "Checks if the value of the field is `EN`"]
552 #[inline]
553 pub fn is_en(&self) -> bool {
554 *self == MCUHEVENR::EN
555 }
556 #[doc = "Checks if the value of the field is `DIS`"]
557 #[inline]
558 pub fn is_dis(&self) -> bool {
559 *self == MCUHEVENR::DIS
560 }
561}
562#[doc = "Possible values of the field `MCULEVEN`"]
563#[derive(Clone, Copy, Debug, PartialEq)]
564pub enum MCULEVENR {
565 #[doc = "Enable MCUL power-on status event value."]
566 EN,
567 #[doc = "Disable MCUL power-on status event value."]
568 DIS,
569}
570impl MCULEVENR {
571 #[doc = r" Returns `true` if the bit is clear (0)"]
572 #[inline]
573 pub fn bit_is_clear(&self) -> bool {
574 !self.bit()
575 }
576 #[doc = r" Returns `true` if the bit is set (1)"]
577 #[inline]
578 pub fn bit_is_set(&self) -> bool {
579 self.bit()
580 }
581 #[doc = r" Value of the field as raw bits"]
582 #[inline]
583 pub fn bit(&self) -> bool {
584 match *self {
585 MCULEVENR::EN => true,
586 MCULEVENR::DIS => false,
587 }
588 }
589 #[allow(missing_docs)]
590 #[doc(hidden)]
591 #[inline]
592 pub fn _from(value: bool) -> MCULEVENR {
593 match value {
594 true => MCULEVENR::EN,
595 false => MCULEVENR::DIS,
596 }
597 }
598 #[doc = "Checks if the value of the field is `EN`"]
599 #[inline]
600 pub fn is_en(&self) -> bool {
601 *self == MCULEVENR::EN
602 }
603 #[doc = "Checks if the value of the field is `DIS`"]
604 #[inline]
605 pub fn is_dis(&self) -> bool {
606 *self == MCULEVENR::DIS
607 }
608}
609#[doc = "Values that can be written to the field `BURSTEVEN`"]
610pub enum BURSTEVENW {
611 #[doc = "Enable BURST status event value."]
612 EN,
613 #[doc = "Disable BURST status event value."]
614 DIS,
615}
616impl BURSTEVENW {
617 #[allow(missing_docs)]
618 #[doc(hidden)]
619 #[inline]
620 pub fn _bits(&self) -> bool {
621 match *self {
622 BURSTEVENW::EN => true,
623 BURSTEVENW::DIS => false,
624 }
625 }
626}
627#[doc = r" Proxy"]
628pub struct _BURSTEVENW<'a> {
629 w: &'a mut W,
630}
631impl<'a> _BURSTEVENW<'a> {
632 #[doc = r" Writes `variant` to the field"]
633 #[inline]
634 pub fn variant(self, variant: BURSTEVENW) -> &'a mut W {
635 {
636 self.bit(variant._bits())
637 }
638 }
639 #[doc = "Enable BURST status event value."]
640 #[inline]
641 pub fn en(self) -> &'a mut W {
642 self.variant(BURSTEVENW::EN)
643 }
644 #[doc = "Disable BURST status event value."]
645 #[inline]
646 pub fn dis(self) -> &'a mut W {
647 self.variant(BURSTEVENW::DIS)
648 }
649 #[doc = r" Sets the field bit"]
650 pub fn set_bit(self) -> &'a mut W {
651 self.bit(true)
652 }
653 #[doc = r" Clears the field bit"]
654 pub fn clear_bit(self) -> &'a mut W {
655 self.bit(false)
656 }
657 #[doc = r" Writes raw bits to the field"]
658 #[inline]
659 pub fn bit(self, value: bool) -> &'a mut W {
660 const MASK: bool = true;
661 const OFFSET: u8 = 31;
662 self.w.bits &= !((MASK as u32) << OFFSET);
663 self.w.bits |= ((value & MASK) as u32) << OFFSET;
664 self.w
665 }
666}
667#[doc = "Values that can be written to the field `BURSTFEATUREEVEN`"]
668pub enum BURSTFEATUREEVENW {
669 #[doc = "Enable BURSTFEATURE status event value."]
670 EN,
671 #[doc = "Disable BURSTFEATURE status event value."]
672 DIS,
673}
674impl BURSTFEATUREEVENW {
675 #[allow(missing_docs)]
676 #[doc(hidden)]
677 #[inline]
678 pub fn _bits(&self) -> bool {
679 match *self {
680 BURSTFEATUREEVENW::EN => true,
681 BURSTFEATUREEVENW::DIS => false,
682 }
683 }
684}
685#[doc = r" Proxy"]
686pub struct _BURSTFEATUREEVENW<'a> {
687 w: &'a mut W,
688}
689impl<'a> _BURSTFEATUREEVENW<'a> {
690 #[doc = r" Writes `variant` to the field"]
691 #[inline]
692 pub fn variant(self, variant: BURSTFEATUREEVENW) -> &'a mut W {
693 {
694 self.bit(variant._bits())
695 }
696 }
697 #[doc = "Enable BURSTFEATURE status event value."]
698 #[inline]
699 pub fn en(self) -> &'a mut W {
700 self.variant(BURSTFEATUREEVENW::EN)
701 }
702 #[doc = "Disable BURSTFEATURE status event value."]
703 #[inline]
704 pub fn dis(self) -> &'a mut W {
705 self.variant(BURSTFEATUREEVENW::DIS)
706 }
707 #[doc = r" Sets the field bit"]
708 pub fn set_bit(self) -> &'a mut W {
709 self.bit(true)
710 }
711 #[doc = r" Clears the field bit"]
712 pub fn clear_bit(self) -> &'a mut W {
713 self.bit(false)
714 }
715 #[doc = r" Writes raw bits to the field"]
716 #[inline]
717 pub fn bit(self, value: bool) -> &'a mut W {
718 const MASK: bool = true;
719 const OFFSET: u8 = 30;
720 self.w.bits &= !((MASK as u32) << OFFSET);
721 self.w.bits |= ((value & MASK) as u32) << OFFSET;
722 self.w
723 }
724}
725#[doc = "Values that can be written to the field `BLEFEATUREEVEN`"]
726pub enum BLEFEATUREEVENW {
727 #[doc = "Enable BLEFEATURE status event value."]
728 EN,
729 #[doc = "Disable BLEFEATURE status event value."]
730 DIS,
731}
732impl BLEFEATUREEVENW {
733 #[allow(missing_docs)]
734 #[doc(hidden)]
735 #[inline]
736 pub fn _bits(&self) -> bool {
737 match *self {
738 BLEFEATUREEVENW::EN => true,
739 BLEFEATUREEVENW::DIS => false,
740 }
741 }
742}
743#[doc = r" Proxy"]
744pub struct _BLEFEATUREEVENW<'a> {
745 w: &'a mut W,
746}
747impl<'a> _BLEFEATUREEVENW<'a> {
748 #[doc = r" Writes `variant` to the field"]
749 #[inline]
750 pub fn variant(self, variant: BLEFEATUREEVENW) -> &'a mut W {
751 {
752 self.bit(variant._bits())
753 }
754 }
755 #[doc = "Enable BLEFEATURE status event value."]
756 #[inline]
757 pub fn en(self) -> &'a mut W {
758 self.variant(BLEFEATUREEVENW::EN)
759 }
760 #[doc = "Disable BLEFEATURE status event value."]
761 #[inline]
762 pub fn dis(self) -> &'a mut W {
763 self.variant(BLEFEATUREEVENW::DIS)
764 }
765 #[doc = r" Sets the field bit"]
766 pub fn set_bit(self) -> &'a mut W {
767 self.bit(true)
768 }
769 #[doc = r" Clears the field bit"]
770 pub fn clear_bit(self) -> &'a mut W {
771 self.bit(false)
772 }
773 #[doc = r" Writes raw bits to the field"]
774 #[inline]
775 pub fn bit(self, value: bool) -> &'a mut W {
776 const MASK: bool = true;
777 const OFFSET: u8 = 29;
778 self.w.bits &= !((MASK as u32) << OFFSET);
779 self.w.bits |= ((value & MASK) as u32) << OFFSET;
780 self.w
781 }
782}
783#[doc = "Values that can be written to the field `BLELEVEN`"]
784pub enum BLELEVENW {
785 #[doc = "Enable BLE power-on status event value."]
786 EN,
787 #[doc = "Disable BLE power-on status event value."]
788 DIS,
789}
790impl BLELEVENW {
791 #[allow(missing_docs)]
792 #[doc(hidden)]
793 #[inline]
794 pub fn _bits(&self) -> bool {
795 match *self {
796 BLELEVENW::EN => true,
797 BLELEVENW::DIS => false,
798 }
799 }
800}
801#[doc = r" Proxy"]
802pub struct _BLELEVENW<'a> {
803 w: &'a mut W,
804}
805impl<'a> _BLELEVENW<'a> {
806 #[doc = r" Writes `variant` to the field"]
807 #[inline]
808 pub fn variant(self, variant: BLELEVENW) -> &'a mut W {
809 {
810 self.bit(variant._bits())
811 }
812 }
813 #[doc = "Enable BLE power-on status event value."]
814 #[inline]
815 pub fn en(self) -> &'a mut W {
816 self.variant(BLELEVENW::EN)
817 }
818 #[doc = "Disable BLE power-on status event value."]
819 #[inline]
820 pub fn dis(self) -> &'a mut W {
821 self.variant(BLELEVENW::DIS)
822 }
823 #[doc = r" Sets the field bit"]
824 pub fn set_bit(self) -> &'a mut W {
825 self.bit(true)
826 }
827 #[doc = r" Clears the field bit"]
828 pub fn clear_bit(self) -> &'a mut W {
829 self.bit(false)
830 }
831 #[doc = r" Writes raw bits to the field"]
832 #[inline]
833 pub fn bit(self, value: bool) -> &'a mut W {
834 const MASK: bool = true;
835 const OFFSET: u8 = 8;
836 self.w.bits &= !((MASK as u32) << OFFSET);
837 self.w.bits |= ((value & MASK) as u32) << OFFSET;
838 self.w
839 }
840}
841#[doc = "Values that can be written to the field `PDMEVEN`"]
842pub enum PDMEVENW {
843 #[doc = "Enable PDM power-on status event value."]
844 EN,
845 #[doc = "Disable PDM power-on status event value."]
846 DIS,
847}
848impl PDMEVENW {
849 #[allow(missing_docs)]
850 #[doc(hidden)]
851 #[inline]
852 pub fn _bits(&self) -> bool {
853 match *self {
854 PDMEVENW::EN => true,
855 PDMEVENW::DIS => false,
856 }
857 }
858}
859#[doc = r" Proxy"]
860pub struct _PDMEVENW<'a> {
861 w: &'a mut W,
862}
863impl<'a> _PDMEVENW<'a> {
864 #[doc = r" Writes `variant` to the field"]
865 #[inline]
866 pub fn variant(self, variant: PDMEVENW) -> &'a mut W {
867 {
868 self.bit(variant._bits())
869 }
870 }
871 #[doc = "Enable PDM power-on status event value."]
872 #[inline]
873 pub fn en(self) -> &'a mut W {
874 self.variant(PDMEVENW::EN)
875 }
876 #[doc = "Disable PDM power-on status event value."]
877 #[inline]
878 pub fn dis(self) -> &'a mut W {
879 self.variant(PDMEVENW::DIS)
880 }
881 #[doc = r" Sets the field bit"]
882 pub fn set_bit(self) -> &'a mut W {
883 self.bit(true)
884 }
885 #[doc = r" Clears the field bit"]
886 pub fn clear_bit(self) -> &'a mut W {
887 self.bit(false)
888 }
889 #[doc = r" Writes raw bits to the field"]
890 #[inline]
891 pub fn bit(self, value: bool) -> &'a mut W {
892 const MASK: bool = true;
893 const OFFSET: u8 = 7;
894 self.w.bits &= !((MASK as u32) << OFFSET);
895 self.w.bits |= ((value & MASK) as u32) << OFFSET;
896 self.w
897 }
898}
899#[doc = "Values that can be written to the field `MSPIEVEN`"]
900pub enum MSPIEVENW {
901 #[doc = "Enable MSPI power-on status event value."]
902 EN,
903 #[doc = "Disable MSPI power-on status event value."]
904 DIS,
905}
906impl MSPIEVENW {
907 #[allow(missing_docs)]
908 #[doc(hidden)]
909 #[inline]
910 pub fn _bits(&self) -> bool {
911 match *self {
912 MSPIEVENW::EN => true,
913 MSPIEVENW::DIS => false,
914 }
915 }
916}
917#[doc = r" Proxy"]
918pub struct _MSPIEVENW<'a> {
919 w: &'a mut W,
920}
921impl<'a> _MSPIEVENW<'a> {
922 #[doc = r" Writes `variant` to the field"]
923 #[inline]
924 pub fn variant(self, variant: MSPIEVENW) -> &'a mut W {
925 {
926 self.bit(variant._bits())
927 }
928 }
929 #[doc = "Enable MSPI power-on status event value."]
930 #[inline]
931 pub fn en(self) -> &'a mut W {
932 self.variant(MSPIEVENW::EN)
933 }
934 #[doc = "Disable MSPI power-on status event value."]
935 #[inline]
936 pub fn dis(self) -> &'a mut W {
937 self.variant(MSPIEVENW::DIS)
938 }
939 #[doc = r" Sets the field bit"]
940 pub fn set_bit(self) -> &'a mut W {
941 self.bit(true)
942 }
943 #[doc = r" Clears the field bit"]
944 pub fn clear_bit(self) -> &'a mut W {
945 self.bit(false)
946 }
947 #[doc = r" Writes raw bits to the field"]
948 #[inline]
949 pub fn bit(self, value: bool) -> &'a mut W {
950 const MASK: bool = true;
951 const OFFSET: u8 = 6;
952 self.w.bits &= !((MASK as u32) << OFFSET);
953 self.w.bits |= ((value & MASK) as u32) << OFFSET;
954 self.w
955 }
956}
957#[doc = "Values that can be written to the field `ADCEVEN`"]
958pub enum ADCEVENW {
959 #[doc = "Enable ADC power-on status event value."]
960 EN,
961 #[doc = "Disable ADC power-on status event value."]
962 DIS,
963}
964impl ADCEVENW {
965 #[allow(missing_docs)]
966 #[doc(hidden)]
967 #[inline]
968 pub fn _bits(&self) -> bool {
969 match *self {
970 ADCEVENW::EN => true,
971 ADCEVENW::DIS => false,
972 }
973 }
974}
975#[doc = r" Proxy"]
976pub struct _ADCEVENW<'a> {
977 w: &'a mut W,
978}
979impl<'a> _ADCEVENW<'a> {
980 #[doc = r" Writes `variant` to the field"]
981 #[inline]
982 pub fn variant(self, variant: ADCEVENW) -> &'a mut W {
983 {
984 self.bit(variant._bits())
985 }
986 }
987 #[doc = "Enable ADC power-on status event value."]
988 #[inline]
989 pub fn en(self) -> &'a mut W {
990 self.variant(ADCEVENW::EN)
991 }
992 #[doc = "Disable ADC power-on status event value."]
993 #[inline]
994 pub fn dis(self) -> &'a mut W {
995 self.variant(ADCEVENW::DIS)
996 }
997 #[doc = r" Sets the field bit"]
998 pub fn set_bit(self) -> &'a mut W {
999 self.bit(true)
1000 }
1001 #[doc = r" Clears the field bit"]
1002 pub fn clear_bit(self) -> &'a mut W {
1003 self.bit(false)
1004 }
1005 #[doc = r" Writes raw bits to the field"]
1006 #[inline]
1007 pub fn bit(self, value: bool) -> &'a mut W {
1008 const MASK: bool = true;
1009 const OFFSET: u8 = 5;
1010 self.w.bits &= !((MASK as u32) << OFFSET);
1011 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1012 self.w
1013 }
1014}
1015#[doc = "Values that can be written to the field `HCPCEVEN`"]
1016pub enum HCPCEVENW {
1017 #[doc = "Enable HCPC power-on status event value."]
1018 EN,
1019 #[doc = "Disable HCPC power-on status event value."]
1020 DIS,
1021}
1022impl HCPCEVENW {
1023 #[allow(missing_docs)]
1024 #[doc(hidden)]
1025 #[inline]
1026 pub fn _bits(&self) -> bool {
1027 match *self {
1028 HCPCEVENW::EN => true,
1029 HCPCEVENW::DIS => false,
1030 }
1031 }
1032}
1033#[doc = r" Proxy"]
1034pub struct _HCPCEVENW<'a> {
1035 w: &'a mut W,
1036}
1037impl<'a> _HCPCEVENW<'a> {
1038 #[doc = r" Writes `variant` to the field"]
1039 #[inline]
1040 pub fn variant(self, variant: HCPCEVENW) -> &'a mut W {
1041 {
1042 self.bit(variant._bits())
1043 }
1044 }
1045 #[doc = "Enable HCPC power-on status event value."]
1046 #[inline]
1047 pub fn en(self) -> &'a mut W {
1048 self.variant(HCPCEVENW::EN)
1049 }
1050 #[doc = "Disable HCPC power-on status event value."]
1051 #[inline]
1052 pub fn dis(self) -> &'a mut W {
1053 self.variant(HCPCEVENW::DIS)
1054 }
1055 #[doc = r" Sets the field bit"]
1056 pub fn set_bit(self) -> &'a mut W {
1057 self.bit(true)
1058 }
1059 #[doc = r" Clears the field bit"]
1060 pub fn clear_bit(self) -> &'a mut W {
1061 self.bit(false)
1062 }
1063 #[doc = r" Writes raw bits to the field"]
1064 #[inline]
1065 pub fn bit(self, value: bool) -> &'a mut W {
1066 const MASK: bool = true;
1067 const OFFSET: u8 = 4;
1068 self.w.bits &= !((MASK as u32) << OFFSET);
1069 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1070 self.w
1071 }
1072}
1073#[doc = "Values that can be written to the field `HCPBEVEN`"]
1074pub enum HCPBEVENW {
1075 #[doc = "Enable HCPB power-on status event value."]
1076 EN,
1077 #[doc = "Disable HCPB power-on status event value."]
1078 DIS,
1079}
1080impl HCPBEVENW {
1081 #[allow(missing_docs)]
1082 #[doc(hidden)]
1083 #[inline]
1084 pub fn _bits(&self) -> bool {
1085 match *self {
1086 HCPBEVENW::EN => true,
1087 HCPBEVENW::DIS => false,
1088 }
1089 }
1090}
1091#[doc = r" Proxy"]
1092pub struct _HCPBEVENW<'a> {
1093 w: &'a mut W,
1094}
1095impl<'a> _HCPBEVENW<'a> {
1096 #[doc = r" Writes `variant` to the field"]
1097 #[inline]
1098 pub fn variant(self, variant: HCPBEVENW) -> &'a mut W {
1099 {
1100 self.bit(variant._bits())
1101 }
1102 }
1103 #[doc = "Enable HCPB power-on status event value."]
1104 #[inline]
1105 pub fn en(self) -> &'a mut W {
1106 self.variant(HCPBEVENW::EN)
1107 }
1108 #[doc = "Disable HCPB power-on status event value."]
1109 #[inline]
1110 pub fn dis(self) -> &'a mut W {
1111 self.variant(HCPBEVENW::DIS)
1112 }
1113 #[doc = r" Sets the field bit"]
1114 pub fn set_bit(self) -> &'a mut W {
1115 self.bit(true)
1116 }
1117 #[doc = r" Clears the field bit"]
1118 pub fn clear_bit(self) -> &'a mut W {
1119 self.bit(false)
1120 }
1121 #[doc = r" Writes raw bits to the field"]
1122 #[inline]
1123 pub fn bit(self, value: bool) -> &'a mut W {
1124 const MASK: bool = true;
1125 const OFFSET: u8 = 3;
1126 self.w.bits &= !((MASK as u32) << OFFSET);
1127 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1128 self.w
1129 }
1130}
1131#[doc = "Values that can be written to the field `HCPAEVEN`"]
1132pub enum HCPAEVENW {
1133 #[doc = "Enable HCPA power-on status event value."]
1134 EN,
1135 #[doc = "Disable HCPA power-on status event value."]
1136 DIS,
1137}
1138impl HCPAEVENW {
1139 #[allow(missing_docs)]
1140 #[doc(hidden)]
1141 #[inline]
1142 pub fn _bits(&self) -> bool {
1143 match *self {
1144 HCPAEVENW::EN => true,
1145 HCPAEVENW::DIS => false,
1146 }
1147 }
1148}
1149#[doc = r" Proxy"]
1150pub struct _HCPAEVENW<'a> {
1151 w: &'a mut W,
1152}
1153impl<'a> _HCPAEVENW<'a> {
1154 #[doc = r" Writes `variant` to the field"]
1155 #[inline]
1156 pub fn variant(self, variant: HCPAEVENW) -> &'a mut W {
1157 {
1158 self.bit(variant._bits())
1159 }
1160 }
1161 #[doc = "Enable HCPA power-on status event value."]
1162 #[inline]
1163 pub fn en(self) -> &'a mut W {
1164 self.variant(HCPAEVENW::EN)
1165 }
1166 #[doc = "Disable HCPA power-on status event value."]
1167 #[inline]
1168 pub fn dis(self) -> &'a mut W {
1169 self.variant(HCPAEVENW::DIS)
1170 }
1171 #[doc = r" Sets the field bit"]
1172 pub fn set_bit(self) -> &'a mut W {
1173 self.bit(true)
1174 }
1175 #[doc = r" Clears the field bit"]
1176 pub fn clear_bit(self) -> &'a mut W {
1177 self.bit(false)
1178 }
1179 #[doc = r" Writes raw bits to the field"]
1180 #[inline]
1181 pub fn bit(self, value: bool) -> &'a mut W {
1182 const MASK: bool = true;
1183 const OFFSET: u8 = 2;
1184 self.w.bits &= !((MASK as u32) << OFFSET);
1185 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1186 self.w
1187 }
1188}
1189#[doc = "Values that can be written to the field `MCUHEVEN`"]
1190pub enum MCUHEVENW {
1191 #[doc = "Enable MCHU power-on status event value."]
1192 EN,
1193 #[doc = "Disable MCUH power-on status event value."]
1194 DIS,
1195}
1196impl MCUHEVENW {
1197 #[allow(missing_docs)]
1198 #[doc(hidden)]
1199 #[inline]
1200 pub fn _bits(&self) -> bool {
1201 match *self {
1202 MCUHEVENW::EN => true,
1203 MCUHEVENW::DIS => false,
1204 }
1205 }
1206}
1207#[doc = r" Proxy"]
1208pub struct _MCUHEVENW<'a> {
1209 w: &'a mut W,
1210}
1211impl<'a> _MCUHEVENW<'a> {
1212 #[doc = r" Writes `variant` to the field"]
1213 #[inline]
1214 pub fn variant(self, variant: MCUHEVENW) -> &'a mut W {
1215 {
1216 self.bit(variant._bits())
1217 }
1218 }
1219 #[doc = "Enable MCHU power-on status event value."]
1220 #[inline]
1221 pub fn en(self) -> &'a mut W {
1222 self.variant(MCUHEVENW::EN)
1223 }
1224 #[doc = "Disable MCUH power-on status event value."]
1225 #[inline]
1226 pub fn dis(self) -> &'a mut W {
1227 self.variant(MCUHEVENW::DIS)
1228 }
1229 #[doc = r" Sets the field bit"]
1230 pub fn set_bit(self) -> &'a mut W {
1231 self.bit(true)
1232 }
1233 #[doc = r" Clears the field bit"]
1234 pub fn clear_bit(self) -> &'a mut W {
1235 self.bit(false)
1236 }
1237 #[doc = r" Writes raw bits to the field"]
1238 #[inline]
1239 pub fn bit(self, value: bool) -> &'a mut W {
1240 const MASK: bool = true;
1241 const OFFSET: u8 = 1;
1242 self.w.bits &= !((MASK as u32) << OFFSET);
1243 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1244 self.w
1245 }
1246}
1247#[doc = "Values that can be written to the field `MCULEVEN`"]
1248pub enum MCULEVENW {
1249 #[doc = "Enable MCUL power-on status event value."]
1250 EN,
1251 #[doc = "Disable MCUL power-on status event value."]
1252 DIS,
1253}
1254impl MCULEVENW {
1255 #[allow(missing_docs)]
1256 #[doc(hidden)]
1257 #[inline]
1258 pub fn _bits(&self) -> bool {
1259 match *self {
1260 MCULEVENW::EN => true,
1261 MCULEVENW::DIS => false,
1262 }
1263 }
1264}
1265#[doc = r" Proxy"]
1266pub struct _MCULEVENW<'a> {
1267 w: &'a mut W,
1268}
1269impl<'a> _MCULEVENW<'a> {
1270 #[doc = r" Writes `variant` to the field"]
1271 #[inline]
1272 pub fn variant(self, variant: MCULEVENW) -> &'a mut W {
1273 {
1274 self.bit(variant._bits())
1275 }
1276 }
1277 #[doc = "Enable MCUL power-on status event value."]
1278 #[inline]
1279 pub fn en(self) -> &'a mut W {
1280 self.variant(MCULEVENW::EN)
1281 }
1282 #[doc = "Disable MCUL power-on status event value."]
1283 #[inline]
1284 pub fn dis(self) -> &'a mut W {
1285 self.variant(MCULEVENW::DIS)
1286 }
1287 #[doc = r" Sets the field bit"]
1288 pub fn set_bit(self) -> &'a mut W {
1289 self.bit(true)
1290 }
1291 #[doc = r" Clears the field bit"]
1292 pub fn clear_bit(self) -> &'a mut W {
1293 self.bit(false)
1294 }
1295 #[doc = r" Writes raw bits to the field"]
1296 #[inline]
1297 pub fn bit(self, value: bool) -> &'a mut W {
1298 const MASK: bool = true;
1299 const OFFSET: u8 = 0;
1300 self.w.bits &= !((MASK as u32) << OFFSET);
1301 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1302 self.w
1303 }
1304}
1305impl R {
1306 #[doc = r" Value of the register as raw bits"]
1307 #[inline]
1308 pub fn bits(&self) -> u32 {
1309 self.bits
1310 }
1311 #[doc = "Bit 31 - Control BURST status event"]
1312 #[inline]
1313 pub fn bursteven(&self) -> BURSTEVENR {
1314 BURSTEVENR::_from({
1315 const MASK: bool = true;
1316 const OFFSET: u8 = 31;
1317 ((self.bits >> OFFSET) & MASK as u32) != 0
1318 })
1319 }
1320 #[doc = "Bit 30 - Control BURSTFEATURE status event"]
1321 #[inline]
1322 pub fn burstfeatureeven(&self) -> BURSTFEATUREEVENR {
1323 BURSTFEATUREEVENR::_from({
1324 const MASK: bool = true;
1325 const OFFSET: u8 = 30;
1326 ((self.bits >> OFFSET) & MASK as u32) != 0
1327 })
1328 }
1329 #[doc = "Bit 29 - Control BLEFEATURE status event"]
1330 #[inline]
1331 pub fn blefeatureeven(&self) -> BLEFEATUREEVENR {
1332 BLEFEATUREEVENR::_from({
1333 const MASK: bool = true;
1334 const OFFSET: u8 = 29;
1335 ((self.bits >> OFFSET) & MASK as u32) != 0
1336 })
1337 }
1338 #[doc = "Bit 8 - Control BLE power-on status event"]
1339 #[inline]
1340 pub fn bleleven(&self) -> BLELEVENR {
1341 BLELEVENR::_from({
1342 const MASK: bool = true;
1343 const OFFSET: u8 = 8;
1344 ((self.bits >> OFFSET) & MASK as u32) != 0
1345 })
1346 }
1347 #[doc = "Bit 7 - Control PDM power-on status event"]
1348 #[inline]
1349 pub fn pdmeven(&self) -> PDMEVENR {
1350 PDMEVENR::_from({
1351 const MASK: bool = true;
1352 const OFFSET: u8 = 7;
1353 ((self.bits >> OFFSET) & MASK as u32) != 0
1354 })
1355 }
1356 #[doc = "Bit 6 - Control MSPI power-on status event"]
1357 #[inline]
1358 pub fn mspieven(&self) -> MSPIEVENR {
1359 MSPIEVENR::_from({
1360 const MASK: bool = true;
1361 const OFFSET: u8 = 6;
1362 ((self.bits >> OFFSET) & MASK as u32) != 0
1363 })
1364 }
1365 #[doc = "Bit 5 - Control ADC power-on status event"]
1366 #[inline]
1367 pub fn adceven(&self) -> ADCEVENR {
1368 ADCEVENR::_from({
1369 const MASK: bool = true;
1370 const OFFSET: u8 = 5;
1371 ((self.bits >> OFFSET) & MASK as u32) != 0
1372 })
1373 }
1374 #[doc = "Bit 4 - Control HCPC power-on status event"]
1375 #[inline]
1376 pub fn hcpceven(&self) -> HCPCEVENR {
1377 HCPCEVENR::_from({
1378 const MASK: bool = true;
1379 const OFFSET: u8 = 4;
1380 ((self.bits >> OFFSET) & MASK as u32) != 0
1381 })
1382 }
1383 #[doc = "Bit 3 - Control HCPB power-on status event"]
1384 #[inline]
1385 pub fn hcpbeven(&self) -> HCPBEVENR {
1386 HCPBEVENR::_from({
1387 const MASK: bool = true;
1388 const OFFSET: u8 = 3;
1389 ((self.bits >> OFFSET) & MASK as u32) != 0
1390 })
1391 }
1392 #[doc = "Bit 2 - Control HCPA power-on status event"]
1393 #[inline]
1394 pub fn hcpaeven(&self) -> HCPAEVENR {
1395 HCPAEVENR::_from({
1396 const MASK: bool = true;
1397 const OFFSET: u8 = 2;
1398 ((self.bits >> OFFSET) & MASK as u32) != 0
1399 })
1400 }
1401 #[doc = "Bit 1 - Control MCUH power-on status event"]
1402 #[inline]
1403 pub fn mcuheven(&self) -> MCUHEVENR {
1404 MCUHEVENR::_from({
1405 const MASK: bool = true;
1406 const OFFSET: u8 = 1;
1407 ((self.bits >> OFFSET) & MASK as u32) != 0
1408 })
1409 }
1410 #[doc = "Bit 0 - Control MCUL power-on status event"]
1411 #[inline]
1412 pub fn mculeven(&self) -> MCULEVENR {
1413 MCULEVENR::_from({
1414 const MASK: bool = true;
1415 const OFFSET: u8 = 0;
1416 ((self.bits >> OFFSET) & MASK as u32) != 0
1417 })
1418 }
1419}
1420impl W {
1421 #[doc = r" Reset value of the register"]
1422 #[inline]
1423 pub fn reset_value() -> W {
1424 W { bits: 0 }
1425 }
1426 #[doc = r" Writes raw bits to the register"]
1427 #[inline]
1428 pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
1429 self.bits = bits;
1430 self
1431 }
1432 #[doc = "Bit 31 - Control BURST status event"]
1433 #[inline]
1434 pub fn bursteven(&mut self) -> _BURSTEVENW {
1435 _BURSTEVENW { w: self }
1436 }
1437 #[doc = "Bit 30 - Control BURSTFEATURE status event"]
1438 #[inline]
1439 pub fn burstfeatureeven(&mut self) -> _BURSTFEATUREEVENW {
1440 _BURSTFEATUREEVENW { w: self }
1441 }
1442 #[doc = "Bit 29 - Control BLEFEATURE status event"]
1443 #[inline]
1444 pub fn blefeatureeven(&mut self) -> _BLEFEATUREEVENW {
1445 _BLEFEATUREEVENW { w: self }
1446 }
1447 #[doc = "Bit 8 - Control BLE power-on status event"]
1448 #[inline]
1449 pub fn bleleven(&mut self) -> _BLELEVENW {
1450 _BLELEVENW { w: self }
1451 }
1452 #[doc = "Bit 7 - Control PDM power-on status event"]
1453 #[inline]
1454 pub fn pdmeven(&mut self) -> _PDMEVENW {
1455 _PDMEVENW { w: self }
1456 }
1457 #[doc = "Bit 6 - Control MSPI power-on status event"]
1458 #[inline]
1459 pub fn mspieven(&mut self) -> _MSPIEVENW {
1460 _MSPIEVENW { w: self }
1461 }
1462 #[doc = "Bit 5 - Control ADC power-on status event"]
1463 #[inline]
1464 pub fn adceven(&mut self) -> _ADCEVENW {
1465 _ADCEVENW { w: self }
1466 }
1467 #[doc = "Bit 4 - Control HCPC power-on status event"]
1468 #[inline]
1469 pub fn hcpceven(&mut self) -> _HCPCEVENW {
1470 _HCPCEVENW { w: self }
1471 }
1472 #[doc = "Bit 3 - Control HCPB power-on status event"]
1473 #[inline]
1474 pub fn hcpbeven(&mut self) -> _HCPBEVENW {
1475 _HCPBEVENW { w: self }
1476 }
1477 #[doc = "Bit 2 - Control HCPA power-on status event"]
1478 #[inline]
1479 pub fn hcpaeven(&mut self) -> _HCPAEVENW {
1480 _HCPAEVENW { w: self }
1481 }
1482 #[doc = "Bit 1 - Control MCUH power-on status event"]
1483 #[inline]
1484 pub fn mcuheven(&mut self) -> _MCUHEVENW {
1485 _MCUHEVENW { w: self }
1486 }
1487 #[doc = "Bit 0 - Control MCUL power-on status event"]
1488 #[inline]
1489 pub fn mculeven(&mut self) -> _MCULEVENW {
1490 _MCULEVENW { w: self }
1491 }
1492}