1#[doc = "Reader of register IEN"]
2pub type R = crate::R<u32, super::IEN>;
3#[doc = "Writer for register IEN"]
4pub type W = crate::W<u32, super::IEN>;
5#[doc = "Register IEN `reset()`'s with value 0"]
6impl crate::ResetValue for super::IEN {
7 type Type = u32;
8 #[inline(always)]
9 fn reset_value() -> Self::Type { 0 }
10}
11#[doc = "Reader of field `HFRCORDY`"]
12pub type HFRCORDY_R = crate::R<bool, bool>;
13#[doc = "Write proxy for field `HFRCORDY`"]
14pub struct HFRCORDY_W<'a> {
15 w: &'a mut W,
16}
17impl<'a> HFRCORDY_W<'a> {
18 #[doc = r"Sets the field bit"]
19 #[inline(always)]
20 pub fn set_bit(self) -> &'a mut W { self.bit(true) }
21 #[doc = r"Clears the field bit"]
22 #[inline(always)]
23 pub fn clear_bit(self) -> &'a mut W { self.bit(false) }
24 #[doc = r"Writes raw bits to the field"]
25 #[inline(always)]
26 pub fn bit(self, value: bool) -> &'a mut W {
27 self.w.bits = (self.w.bits & !0x01) | ((value as u32) & 0x01);
28 self.w
29 }
30}
31#[doc = "Reader of field `HFXORDY`"]
32pub type HFXORDY_R = crate::R<bool, bool>;
33#[doc = "Write proxy for field `HFXORDY`"]
34pub struct HFXORDY_W<'a> {
35 w: &'a mut W,
36}
37impl<'a> HFXORDY_W<'a> {
38 #[doc = r"Sets the field bit"]
39 #[inline(always)]
40 pub fn set_bit(self) -> &'a mut W { self.bit(true) }
41 #[doc = r"Clears the field bit"]
42 #[inline(always)]
43 pub fn clear_bit(self) -> &'a mut W { self.bit(false) }
44 #[doc = r"Writes raw bits to the field"]
45 #[inline(always)]
46 pub fn bit(self, value: bool) -> &'a mut W {
47 self.w.bits = (self.w.bits & !(0x01 << 1)) | (((value as u32) & 0x01) << 1);
48 self.w
49 }
50}
51#[doc = "Reader of field `LFRCORDY`"]
52pub type LFRCORDY_R = crate::R<bool, bool>;
53#[doc = "Write proxy for field `LFRCORDY`"]
54pub struct LFRCORDY_W<'a> {
55 w: &'a mut W,
56}
57impl<'a> LFRCORDY_W<'a> {
58 #[doc = r"Sets the field bit"]
59 #[inline(always)]
60 pub fn set_bit(self) -> &'a mut W { self.bit(true) }
61 #[doc = r"Clears the field bit"]
62 #[inline(always)]
63 pub fn clear_bit(self) -> &'a mut W { self.bit(false) }
64 #[doc = r"Writes raw bits to the field"]
65 #[inline(always)]
66 pub fn bit(self, value: bool) -> &'a mut W {
67 self.w.bits = (self.w.bits & !(0x01 << 2)) | (((value as u32) & 0x01) << 2);
68 self.w
69 }
70}
71#[doc = "Reader of field `LFXORDY`"]
72pub type LFXORDY_R = crate::R<bool, bool>;
73#[doc = "Write proxy for field `LFXORDY`"]
74pub struct LFXORDY_W<'a> {
75 w: &'a mut W,
76}
77impl<'a> LFXORDY_W<'a> {
78 #[doc = r"Sets the field bit"]
79 #[inline(always)]
80 pub fn set_bit(self) -> &'a mut W { self.bit(true) }
81 #[doc = r"Clears the field bit"]
82 #[inline(always)]
83 pub fn clear_bit(self) -> &'a mut W { self.bit(false) }
84 #[doc = r"Writes raw bits to the field"]
85 #[inline(always)]
86 pub fn bit(self, value: bool) -> &'a mut W {
87 self.w.bits = (self.w.bits & !(0x01 << 3)) | (((value as u32) & 0x01) << 3);
88 self.w
89 }
90}
91#[doc = "Reader of field `AUXHFRCORDY`"]
92pub type AUXHFRCORDY_R = crate::R<bool, bool>;
93#[doc = "Write proxy for field `AUXHFRCORDY`"]
94pub struct AUXHFRCORDY_W<'a> {
95 w: &'a mut W,
96}
97impl<'a> AUXHFRCORDY_W<'a> {
98 #[doc = r"Sets the field bit"]
99 #[inline(always)]
100 pub fn set_bit(self) -> &'a mut W { self.bit(true) }
101 #[doc = r"Clears the field bit"]
102 #[inline(always)]
103 pub fn clear_bit(self) -> &'a mut W { self.bit(false) }
104 #[doc = r"Writes raw bits to the field"]
105 #[inline(always)]
106 pub fn bit(self, value: bool) -> &'a mut W {
107 self.w.bits = (self.w.bits & !(0x01 << 4)) | (((value as u32) & 0x01) << 4);
108 self.w
109 }
110}
111#[doc = "Reader of field `CALRDY`"]
112pub type CALRDY_R = crate::R<bool, bool>;
113#[doc = "Write proxy for field `CALRDY`"]
114pub struct CALRDY_W<'a> {
115 w: &'a mut W,
116}
117impl<'a> CALRDY_W<'a> {
118 #[doc = r"Sets the field bit"]
119 #[inline(always)]
120 pub fn set_bit(self) -> &'a mut W { self.bit(true) }
121 #[doc = r"Clears the field bit"]
122 #[inline(always)]
123 pub fn clear_bit(self) -> &'a mut W { self.bit(false) }
124 #[doc = r"Writes raw bits to the field"]
125 #[inline(always)]
126 pub fn bit(self, value: bool) -> &'a mut W {
127 self.w.bits = (self.w.bits & !(0x01 << 5)) | (((value as u32) & 0x01) << 5);
128 self.w
129 }
130}
131#[doc = "Reader of field `CALOF`"]
132pub type CALOF_R = crate::R<bool, bool>;
133#[doc = "Write proxy for field `CALOF`"]
134pub struct CALOF_W<'a> {
135 w: &'a mut W,
136}
137impl<'a> CALOF_W<'a> {
138 #[doc = r"Sets the field bit"]
139 #[inline(always)]
140 pub fn set_bit(self) -> &'a mut W { self.bit(true) }
141 #[doc = r"Clears the field bit"]
142 #[inline(always)]
143 pub fn clear_bit(self) -> &'a mut W { self.bit(false) }
144 #[doc = r"Writes raw bits to the field"]
145 #[inline(always)]
146 pub fn bit(self, value: bool) -> &'a mut W {
147 self.w.bits = (self.w.bits & !(0x01 << 6)) | (((value as u32) & 0x01) << 6);
148 self.w
149 }
150}
151#[doc = "Reader of field `USHFRCORDY`"]
152pub type USHFRCORDY_R = crate::R<bool, bool>;
153#[doc = "Write proxy for field `USHFRCORDY`"]
154pub struct USHFRCORDY_W<'a> {
155 w: &'a mut W,
156}
157impl<'a> USHFRCORDY_W<'a> {
158 #[doc = r"Sets the field bit"]
159 #[inline(always)]
160 pub fn set_bit(self) -> &'a mut W { self.bit(true) }
161 #[doc = r"Clears the field bit"]
162 #[inline(always)]
163 pub fn clear_bit(self) -> &'a mut W { self.bit(false) }
164 #[doc = r"Writes raw bits to the field"]
165 #[inline(always)]
166 pub fn bit(self, value: bool) -> &'a mut W {
167 self.w.bits = (self.w.bits & !(0x01 << 7)) | (((value as u32) & 0x01) << 7);
168 self.w
169 }
170}
171#[doc = "Reader of field `HFXODISERR`"]
172pub type HFXODISERR_R = crate::R<bool, bool>;
173#[doc = "Write proxy for field `HFXODISERR`"]
174pub struct HFXODISERR_W<'a> {
175 w: &'a mut W,
176}
177impl<'a> HFXODISERR_W<'a> {
178 #[doc = r"Sets the field bit"]
179 #[inline(always)]
180 pub fn set_bit(self) -> &'a mut W { self.bit(true) }
181 #[doc = r"Clears the field bit"]
182 #[inline(always)]
183 pub fn clear_bit(self) -> &'a mut W { self.bit(false) }
184 #[doc = r"Writes raw bits to the field"]
185 #[inline(always)]
186 pub fn bit(self, value: bool) -> &'a mut W {
187 self.w.bits = (self.w.bits & !(0x01 << 8)) | (((value as u32) & 0x01) << 8);
188 self.w
189 }
190}
191#[doc = "Reader of field `HFXOAUTOSW`"]
192pub type HFXOAUTOSW_R = crate::R<bool, bool>;
193#[doc = "Write proxy for field `HFXOAUTOSW`"]
194pub struct HFXOAUTOSW_W<'a> {
195 w: &'a mut W,
196}
197impl<'a> HFXOAUTOSW_W<'a> {
198 #[doc = r"Sets the field bit"]
199 #[inline(always)]
200 pub fn set_bit(self) -> &'a mut W { self.bit(true) }
201 #[doc = r"Clears the field bit"]
202 #[inline(always)]
203 pub fn clear_bit(self) -> &'a mut W { self.bit(false) }
204 #[doc = r"Writes raw bits to the field"]
205 #[inline(always)]
206 pub fn bit(self, value: bool) -> &'a mut W {
207 self.w.bits = (self.w.bits & !(0x01 << 9)) | (((value as u32) & 0x01) << 9);
208 self.w
209 }
210}
211#[doc = "Reader of field `HFXOPEAKDETRDY`"]
212pub type HFXOPEAKDETRDY_R = crate::R<bool, bool>;
213#[doc = "Write proxy for field `HFXOPEAKDETRDY`"]
214pub struct HFXOPEAKDETRDY_W<'a> {
215 w: &'a mut W,
216}
217impl<'a> HFXOPEAKDETRDY_W<'a> {
218 #[doc = r"Sets the field bit"]
219 #[inline(always)]
220 pub fn set_bit(self) -> &'a mut W { self.bit(true) }
221 #[doc = r"Clears the field bit"]
222 #[inline(always)]
223 pub fn clear_bit(self) -> &'a mut W { self.bit(false) }
224 #[doc = r"Writes raw bits to the field"]
225 #[inline(always)]
226 pub fn bit(self, value: bool) -> &'a mut W {
227 self.w.bits = (self.w.bits & !(0x01 << 11)) | (((value as u32) & 0x01) << 11);
228 self.w
229 }
230}
231#[doc = "Reader of field `HFRCODIS`"]
232pub type HFRCODIS_R = crate::R<bool, bool>;
233#[doc = "Write proxy for field `HFRCODIS`"]
234pub struct HFRCODIS_W<'a> {
235 w: &'a mut W,
236}
237impl<'a> HFRCODIS_W<'a> {
238 #[doc = r"Sets the field bit"]
239 #[inline(always)]
240 pub fn set_bit(self) -> &'a mut W { self.bit(true) }
241 #[doc = r"Clears the field bit"]
242 #[inline(always)]
243 pub fn clear_bit(self) -> &'a mut W { self.bit(false) }
244 #[doc = r"Writes raw bits to the field"]
245 #[inline(always)]
246 pub fn bit(self, value: bool) -> &'a mut W {
247 self.w.bits = (self.w.bits & !(0x01 << 13)) | (((value as u32) & 0x01) << 13);
248 self.w
249 }
250}
251#[doc = "Reader of field `LFTIMEOUTERR`"]
252pub type LFTIMEOUTERR_R = crate::R<bool, bool>;
253#[doc = "Write proxy for field `LFTIMEOUTERR`"]
254pub struct LFTIMEOUTERR_W<'a> {
255 w: &'a mut W,
256}
257impl<'a> LFTIMEOUTERR_W<'a> {
258 #[doc = r"Sets the field bit"]
259 #[inline(always)]
260 pub fn set_bit(self) -> &'a mut W { self.bit(true) }
261 #[doc = r"Clears the field bit"]
262 #[inline(always)]
263 pub fn clear_bit(self) -> &'a mut W { self.bit(false) }
264 #[doc = r"Writes raw bits to the field"]
265 #[inline(always)]
266 pub fn bit(self, value: bool) -> &'a mut W {
267 self.w.bits = (self.w.bits & !(0x01 << 14)) | (((value as u32) & 0x01) << 14);
268 self.w
269 }
270}
271#[doc = "Reader of field `DPLLRDY`"]
272pub type DPLLRDY_R = crate::R<bool, bool>;
273#[doc = "Write proxy for field `DPLLRDY`"]
274pub struct DPLLRDY_W<'a> {
275 w: &'a mut W,
276}
277impl<'a> DPLLRDY_W<'a> {
278 #[doc = r"Sets the field bit"]
279 #[inline(always)]
280 pub fn set_bit(self) -> &'a mut W { self.bit(true) }
281 #[doc = r"Clears the field bit"]
282 #[inline(always)]
283 pub fn clear_bit(self) -> &'a mut W { self.bit(false) }
284 #[doc = r"Writes raw bits to the field"]
285 #[inline(always)]
286 pub fn bit(self, value: bool) -> &'a mut W {
287 self.w.bits = (self.w.bits & !(0x01 << 15)) | (((value as u32) & 0x01) << 15);
288 self.w
289 }
290}
291#[doc = "Reader of field `DPLLLOCKFAILLOW`"]
292pub type DPLLLOCKFAILLOW_R = crate::R<bool, bool>;
293#[doc = "Write proxy for field `DPLLLOCKFAILLOW`"]
294pub struct DPLLLOCKFAILLOW_W<'a> {
295 w: &'a mut W,
296}
297impl<'a> DPLLLOCKFAILLOW_W<'a> {
298 #[doc = r"Sets the field bit"]
299 #[inline(always)]
300 pub fn set_bit(self) -> &'a mut W { self.bit(true) }
301 #[doc = r"Clears the field bit"]
302 #[inline(always)]
303 pub fn clear_bit(self) -> &'a mut W { self.bit(false) }
304 #[doc = r"Writes raw bits to the field"]
305 #[inline(always)]
306 pub fn bit(self, value: bool) -> &'a mut W {
307 self.w.bits = (self.w.bits & !(0x01 << 16)) | (((value as u32) & 0x01) << 16);
308 self.w
309 }
310}
311#[doc = "Reader of field `DPLLLOCKFAILHIGH`"]
312pub type DPLLLOCKFAILHIGH_R = crate::R<bool, bool>;
313#[doc = "Write proxy for field `DPLLLOCKFAILHIGH`"]
314pub struct DPLLLOCKFAILHIGH_W<'a> {
315 w: &'a mut W,
316}
317impl<'a> DPLLLOCKFAILHIGH_W<'a> {
318 #[doc = r"Sets the field bit"]
319 #[inline(always)]
320 pub fn set_bit(self) -> &'a mut W { self.bit(true) }
321 #[doc = r"Clears the field bit"]
322 #[inline(always)]
323 pub fn clear_bit(self) -> &'a mut W { self.bit(false) }
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 << 17)) | (((value as u32) & 0x01) << 17);
328 self.w
329 }
330}
331#[doc = "Reader of field `LFXOEDGE`"]
332pub type LFXOEDGE_R = crate::R<bool, bool>;
333#[doc = "Write proxy for field `LFXOEDGE`"]
334pub struct LFXOEDGE_W<'a> {
335 w: &'a mut W,
336}
337impl<'a> LFXOEDGE_W<'a> {
338 #[doc = r"Sets the field bit"]
339 #[inline(always)]
340 pub fn set_bit(self) -> &'a mut W { self.bit(true) }
341 #[doc = r"Clears the field bit"]
342 #[inline(always)]
343 pub fn clear_bit(self) -> &'a mut W { self.bit(false) }
344 #[doc = r"Writes raw bits to the field"]
345 #[inline(always)]
346 pub fn bit(self, value: bool) -> &'a mut W {
347 self.w.bits = (self.w.bits & !(0x01 << 27)) | (((value as u32) & 0x01) << 27);
348 self.w
349 }
350}
351#[doc = "Reader of field `LFRCOEDGE`"]
352pub type LFRCOEDGE_R = crate::R<bool, bool>;
353#[doc = "Write proxy for field `LFRCOEDGE`"]
354pub struct LFRCOEDGE_W<'a> {
355 w: &'a mut W,
356}
357impl<'a> LFRCOEDGE_W<'a> {
358 #[doc = r"Sets the field bit"]
359 #[inline(always)]
360 pub fn set_bit(self) -> &'a mut W { self.bit(true) }
361 #[doc = r"Clears the field bit"]
362 #[inline(always)]
363 pub fn clear_bit(self) -> &'a mut W { self.bit(false) }
364 #[doc = r"Writes raw bits to the field"]
365 #[inline(always)]
366 pub fn bit(self, value: bool) -> &'a mut W {
367 self.w.bits = (self.w.bits & !(0x01 << 28)) | (((value as u32) & 0x01) << 28);
368 self.w
369 }
370}
371#[doc = "Reader of field `ULFRCOEDGE`"]
372pub type ULFRCOEDGE_R = crate::R<bool, bool>;
373#[doc = "Write proxy for field `ULFRCOEDGE`"]
374pub struct ULFRCOEDGE_W<'a> {
375 w: &'a mut W,
376}
377impl<'a> ULFRCOEDGE_W<'a> {
378 #[doc = r"Sets the field bit"]
379 #[inline(always)]
380 pub fn set_bit(self) -> &'a mut W { self.bit(true) }
381 #[doc = r"Clears the field bit"]
382 #[inline(always)]
383 pub fn clear_bit(self) -> &'a mut W { self.bit(false) }
384 #[doc = r"Writes raw bits to the field"]
385 #[inline(always)]
386 pub fn bit(self, value: bool) -> &'a mut W {
387 self.w.bits = (self.w.bits & !(0x01 << 29)) | (((value as u32) & 0x01) << 29);
388 self.w
389 }
390}
391#[doc = "Reader of field `CMUERR`"]
392pub type CMUERR_R = crate::R<bool, bool>;
393#[doc = "Write proxy for field `CMUERR`"]
394pub struct CMUERR_W<'a> {
395 w: &'a mut W,
396}
397impl<'a> CMUERR_W<'a> {
398 #[doc = r"Sets the field bit"]
399 #[inline(always)]
400 pub fn set_bit(self) -> &'a mut W { self.bit(true) }
401 #[doc = r"Clears the field bit"]
402 #[inline(always)]
403 pub fn clear_bit(self) -> &'a mut W { self.bit(false) }
404 #[doc = r"Writes raw bits to the field"]
405 #[inline(always)]
406 pub fn bit(self, value: bool) -> &'a mut W {
407 self.w.bits = (self.w.bits & !(0x01 << 31)) | (((value as u32) & 0x01) << 31);
408 self.w
409 }
410}
411impl R {
412 #[doc = "Bit 0 - HFRCORDY Interrupt Enable"]
413 #[inline(always)]
414 pub fn hfrcordy(&self) -> HFRCORDY_R { HFRCORDY_R::new((self.bits & 0x01) != 0) }
415 #[doc = "Bit 1 - HFXORDY Interrupt Enable"]
416 #[inline(always)]
417 pub fn hfxordy(&self) -> HFXORDY_R { HFXORDY_R::new(((self.bits >> 1) & 0x01) != 0) }
418 #[doc = "Bit 2 - LFRCORDY Interrupt Enable"]
419 #[inline(always)]
420 pub fn lfrcordy(&self) -> LFRCORDY_R { LFRCORDY_R::new(((self.bits >> 2) & 0x01) != 0) }
421 #[doc = "Bit 3 - LFXORDY Interrupt Enable"]
422 #[inline(always)]
423 pub fn lfxordy(&self) -> LFXORDY_R { LFXORDY_R::new(((self.bits >> 3) & 0x01) != 0) }
424 #[doc = "Bit 4 - AUXHFRCORDY Interrupt Enable"]
425 #[inline(always)]
426 pub fn auxhfrcordy(&self) -> AUXHFRCORDY_R {
427 AUXHFRCORDY_R::new(((self.bits >> 4) & 0x01) != 0)
428 }
429 #[doc = "Bit 5 - CALRDY Interrupt Enable"]
430 #[inline(always)]
431 pub fn calrdy(&self) -> CALRDY_R { CALRDY_R::new(((self.bits >> 5) & 0x01) != 0) }
432 #[doc = "Bit 6 - CALOF Interrupt Enable"]
433 #[inline(always)]
434 pub fn calof(&self) -> CALOF_R { CALOF_R::new(((self.bits >> 6) & 0x01) != 0) }
435 #[doc = "Bit 7 - USHFRCORDY Interrupt Enable"]
436 #[inline(always)]
437 pub fn ushfrcordy(&self) -> USHFRCORDY_R { USHFRCORDY_R::new(((self.bits >> 7) & 0x01) != 0) }
438 #[doc = "Bit 8 - HFXODISERR Interrupt Enable"]
439 #[inline(always)]
440 pub fn hfxodiserr(&self) -> HFXODISERR_R { HFXODISERR_R::new(((self.bits >> 8) & 0x01) != 0) }
441 #[doc = "Bit 9 - HFXOAUTOSW Interrupt Enable"]
442 #[inline(always)]
443 pub fn hfxoautosw(&self) -> HFXOAUTOSW_R { HFXOAUTOSW_R::new(((self.bits >> 9) & 0x01) != 0) }
444 #[doc = "Bit 11 - HFXOPEAKDETRDY Interrupt Enable"]
445 #[inline(always)]
446 pub fn hfxopeakdetrdy(&self) -> HFXOPEAKDETRDY_R {
447 HFXOPEAKDETRDY_R::new(((self.bits >> 11) & 0x01) != 0)
448 }
449 #[doc = "Bit 13 - HFRCODIS Interrupt Enable"]
450 #[inline(always)]
451 pub fn hfrcodis(&self) -> HFRCODIS_R { HFRCODIS_R::new(((self.bits >> 13) & 0x01) != 0) }
452 #[doc = "Bit 14 - LFTIMEOUTERR Interrupt Enable"]
453 #[inline(always)]
454 pub fn lftimeouterr(&self) -> LFTIMEOUTERR_R {
455 LFTIMEOUTERR_R::new(((self.bits >> 14) & 0x01) != 0)
456 }
457 #[doc = "Bit 15 - DPLLRDY Interrupt Enable"]
458 #[inline(always)]
459 pub fn dpllrdy(&self) -> DPLLRDY_R { DPLLRDY_R::new(((self.bits >> 15) & 0x01) != 0) }
460 #[doc = "Bit 16 - DPLLLOCKFAILLOW Interrupt Enable"]
461 #[inline(always)]
462 pub fn dplllockfaillow(&self) -> DPLLLOCKFAILLOW_R {
463 DPLLLOCKFAILLOW_R::new(((self.bits >> 16) & 0x01) != 0)
464 }
465 #[doc = "Bit 17 - DPLLLOCKFAILHIGH Interrupt Enable"]
466 #[inline(always)]
467 pub fn dplllockfailhigh(&self) -> DPLLLOCKFAILHIGH_R {
468 DPLLLOCKFAILHIGH_R::new(((self.bits >> 17) & 0x01) != 0)
469 }
470 #[doc = "Bit 27 - LFXOEDGE Interrupt Enable"]
471 #[inline(always)]
472 pub fn lfxoedge(&self) -> LFXOEDGE_R { LFXOEDGE_R::new(((self.bits >> 27) & 0x01) != 0) }
473 #[doc = "Bit 28 - LFRCOEDGE Interrupt Enable"]
474 #[inline(always)]
475 pub fn lfrcoedge(&self) -> LFRCOEDGE_R { LFRCOEDGE_R::new(((self.bits >> 28) & 0x01) != 0) }
476 #[doc = "Bit 29 - ULFRCOEDGE Interrupt Enable"]
477 #[inline(always)]
478 pub fn ulfrcoedge(&self) -> ULFRCOEDGE_R { ULFRCOEDGE_R::new(((self.bits >> 29) & 0x01) != 0) }
479 #[doc = "Bit 31 - CMUERR Interrupt Enable"]
480 #[inline(always)]
481 pub fn cmuerr(&self) -> CMUERR_R { CMUERR_R::new(((self.bits >> 31) & 0x01) != 0) }
482}
483impl W {
484 #[doc = "Bit 0 - HFRCORDY Interrupt Enable"]
485 #[inline(always)]
486 pub fn hfrcordy(&mut self) -> HFRCORDY_W { HFRCORDY_W { w: self } }
487 #[doc = "Bit 1 - HFXORDY Interrupt Enable"]
488 #[inline(always)]
489 pub fn hfxordy(&mut self) -> HFXORDY_W { HFXORDY_W { w: self } }
490 #[doc = "Bit 2 - LFRCORDY Interrupt Enable"]
491 #[inline(always)]
492 pub fn lfrcordy(&mut self) -> LFRCORDY_W { LFRCORDY_W { w: self } }
493 #[doc = "Bit 3 - LFXORDY Interrupt Enable"]
494 #[inline(always)]
495 pub fn lfxordy(&mut self) -> LFXORDY_W { LFXORDY_W { w: self } }
496 #[doc = "Bit 4 - AUXHFRCORDY Interrupt Enable"]
497 #[inline(always)]
498 pub fn auxhfrcordy(&mut self) -> AUXHFRCORDY_W { AUXHFRCORDY_W { w: self } }
499 #[doc = "Bit 5 - CALRDY Interrupt Enable"]
500 #[inline(always)]
501 pub fn calrdy(&mut self) -> CALRDY_W { CALRDY_W { w: self } }
502 #[doc = "Bit 6 - CALOF Interrupt Enable"]
503 #[inline(always)]
504 pub fn calof(&mut self) -> CALOF_W { CALOF_W { w: self } }
505 #[doc = "Bit 7 - USHFRCORDY Interrupt Enable"]
506 #[inline(always)]
507 pub fn ushfrcordy(&mut self) -> USHFRCORDY_W { USHFRCORDY_W { w: self } }
508 #[doc = "Bit 8 - HFXODISERR Interrupt Enable"]
509 #[inline(always)]
510 pub fn hfxodiserr(&mut self) -> HFXODISERR_W { HFXODISERR_W { w: self } }
511 #[doc = "Bit 9 - HFXOAUTOSW Interrupt Enable"]
512 #[inline(always)]
513 pub fn hfxoautosw(&mut self) -> HFXOAUTOSW_W { HFXOAUTOSW_W { w: self } }
514 #[doc = "Bit 11 - HFXOPEAKDETRDY Interrupt Enable"]
515 #[inline(always)]
516 pub fn hfxopeakdetrdy(&mut self) -> HFXOPEAKDETRDY_W { HFXOPEAKDETRDY_W { w: self } }
517 #[doc = "Bit 13 - HFRCODIS Interrupt Enable"]
518 #[inline(always)]
519 pub fn hfrcodis(&mut self) -> HFRCODIS_W { HFRCODIS_W { w: self } }
520 #[doc = "Bit 14 - LFTIMEOUTERR Interrupt Enable"]
521 #[inline(always)]
522 pub fn lftimeouterr(&mut self) -> LFTIMEOUTERR_W { LFTIMEOUTERR_W { w: self } }
523 #[doc = "Bit 15 - DPLLRDY Interrupt Enable"]
524 #[inline(always)]
525 pub fn dpllrdy(&mut self) -> DPLLRDY_W { DPLLRDY_W { w: self } }
526 #[doc = "Bit 16 - DPLLLOCKFAILLOW Interrupt Enable"]
527 #[inline(always)]
528 pub fn dplllockfaillow(&mut self) -> DPLLLOCKFAILLOW_W { DPLLLOCKFAILLOW_W { w: self } }
529 #[doc = "Bit 17 - DPLLLOCKFAILHIGH Interrupt Enable"]
530 #[inline(always)]
531 pub fn dplllockfailhigh(&mut self) -> DPLLLOCKFAILHIGH_W { DPLLLOCKFAILHIGH_W { w: self } }
532 #[doc = "Bit 27 - LFXOEDGE Interrupt Enable"]
533 #[inline(always)]
534 pub fn lfxoedge(&mut self) -> LFXOEDGE_W { LFXOEDGE_W { w: self } }
535 #[doc = "Bit 28 - LFRCOEDGE Interrupt Enable"]
536 #[inline(always)]
537 pub fn lfrcoedge(&mut self) -> LFRCOEDGE_W { LFRCOEDGE_W { w: self } }
538 #[doc = "Bit 29 - ULFRCOEDGE Interrupt Enable"]
539 #[inline(always)]
540 pub fn ulfrcoedge(&mut self) -> ULFRCOEDGE_W { ULFRCOEDGE_W { w: self } }
541 #[doc = "Bit 31 - CMUERR Interrupt Enable"]
542 #[inline(always)]
543 pub fn cmuerr(&mut self) -> CMUERR_W { CMUERR_W { w: self } }
544}