eos_s3/aud/
voice_status.rs

1#[doc = "Register `VOICE_STATUS` reader"]
2pub struct R(crate::R<VOICE_STATUS_SPEC>);
3impl core::ops::Deref for R {
4    type Target = crate::R<VOICE_STATUS_SPEC>;
5    #[inline(always)]
6    fn deref(&self) -> &Self::Target {
7        &self.0
8    }
9}
10impl From<crate::R<VOICE_STATUS_SPEC>> for R {
11    #[inline(always)]
12    fn from(reader: crate::R<VOICE_STATUS_SPEC>) -> Self {
13        R(reader)
14    }
15}
16#[doc = "Register `VOICE_STATUS` writer"]
17pub struct W(crate::W<VOICE_STATUS_SPEC>);
18impl core::ops::Deref for W {
19    type Target = crate::W<VOICE_STATUS_SPEC>;
20    #[inline(always)]
21    fn deref(&self) -> &Self::Target {
22        &self.0
23    }
24}
25impl core::ops::DerefMut for W {
26    #[inline(always)]
27    fn deref_mut(&mut self) -> &mut Self::Target {
28        &mut self.0
29    }
30}
31impl From<crate::W<VOICE_STATUS_SPEC>> for W {
32    #[inline(always)]
33    fn from(writer: crate::W<VOICE_STATUS_SPEC>) -> Self {
34        W(writer)
35    }
36}
37#[doc = "Field `FIFO_0A_EMPTY` reader - Set if the FIFO is empty"]
38pub struct FIFO_0A_EMPTY_R(crate::FieldReader<bool, bool>);
39impl FIFO_0A_EMPTY_R {
40    #[inline(always)]
41    pub(crate) fn new(bits: bool) -> Self {
42        FIFO_0A_EMPTY_R(crate::FieldReader::new(bits))
43    }
44}
45impl core::ops::Deref for FIFO_0A_EMPTY_R {
46    type Target = crate::FieldReader<bool, bool>;
47    #[inline(always)]
48    fn deref(&self) -> &Self::Target {
49        &self.0
50    }
51}
52#[doc = "Field `FIFO_0A_FULL` reader - Set if the FIFO is full"]
53pub struct FIFO_0A_FULL_R(crate::FieldReader<bool, bool>);
54impl FIFO_0A_FULL_R {
55    #[inline(always)]
56    pub(crate) fn new(bits: bool) -> Self {
57        FIFO_0A_FULL_R(crate::FieldReader::new(bits))
58    }
59}
60impl core::ops::Deref for FIFO_0A_FULL_R {
61    type Target = crate::FieldReader<bool, bool>;
62    #[inline(always)]
63    fn deref(&self) -> &Self::Target {
64        &self.0
65    }
66}
67#[doc = "Field `FIFO_0A_FULL` writer - Set if the FIFO is full"]
68pub struct FIFO_0A_FULL_W<'a> {
69    w: &'a mut W,
70}
71impl<'a> FIFO_0A_FULL_W<'a> {
72    #[doc = r"Sets the field bit"]
73    #[inline(always)]
74    pub fn set_bit(self) -> &'a mut W {
75        self.bit(true)
76    }
77    #[doc = r"Clears the field bit"]
78    #[inline(always)]
79    pub fn clear_bit(self) -> &'a mut W {
80        self.bit(false)
81    }
82    #[doc = r"Writes raw bits to the field"]
83    #[inline(always)]
84    pub fn bit(self, value: bool) -> &'a mut W {
85        self.w.bits =
86            (self.w.bits & !(0x01 << 1)) | ((value as u32 & 0x01) << 1);
87        self.w
88    }
89}
90#[doc = "Field `FIFO_0A_OVERFLOW` reader - Set if there's a FIFO overflow"]
91pub struct FIFO_0A_OVERFLOW_R(crate::FieldReader<bool, bool>);
92impl FIFO_0A_OVERFLOW_R {
93    #[inline(always)]
94    pub(crate) fn new(bits: bool) -> Self {
95        FIFO_0A_OVERFLOW_R(crate::FieldReader::new(bits))
96    }
97}
98impl core::ops::Deref for FIFO_0A_OVERFLOW_R {
99    type Target = crate::FieldReader<bool, bool>;
100    #[inline(always)]
101    fn deref(&self) -> &Self::Target {
102        &self.0
103    }
104}
105#[doc = "Field `FIFO_0A_OVERFLOW` writer - Set if there's a FIFO overflow"]
106pub struct FIFO_0A_OVERFLOW_W<'a> {
107    w: &'a mut W,
108}
109impl<'a> FIFO_0A_OVERFLOW_W<'a> {
110    #[doc = r"Sets the field bit"]
111    #[inline(always)]
112    pub fn set_bit(self) -> &'a mut W {
113        self.bit(true)
114    }
115    #[doc = r"Clears the field bit"]
116    #[inline(always)]
117    pub fn clear_bit(self) -> &'a mut W {
118        self.bit(false)
119    }
120    #[doc = r"Writes raw bits to the field"]
121    #[inline(always)]
122    pub fn bit(self, value: bool) -> &'a mut W {
123        self.w.bits =
124            (self.w.bits & !(0x01 << 2)) | ((value as u32 & 0x01) << 2);
125        self.w
126    }
127}
128#[doc = "Field `FIFO_0B_EMPTY` reader - Set if the FIFO is empty"]
129pub struct FIFO_0B_EMPTY_R(crate::FieldReader<bool, bool>);
130impl FIFO_0B_EMPTY_R {
131    #[inline(always)]
132    pub(crate) fn new(bits: bool) -> Self {
133        FIFO_0B_EMPTY_R(crate::FieldReader::new(bits))
134    }
135}
136impl core::ops::Deref for FIFO_0B_EMPTY_R {
137    type Target = crate::FieldReader<bool, bool>;
138    #[inline(always)]
139    fn deref(&self) -> &Self::Target {
140        &self.0
141    }
142}
143#[doc = "Field `FIFO_0B_FULL` reader - Set if the FIFO is full"]
144pub struct FIFO_0B_FULL_R(crate::FieldReader<bool, bool>);
145impl FIFO_0B_FULL_R {
146    #[inline(always)]
147    pub(crate) fn new(bits: bool) -> Self {
148        FIFO_0B_FULL_R(crate::FieldReader::new(bits))
149    }
150}
151impl core::ops::Deref for FIFO_0B_FULL_R {
152    type Target = crate::FieldReader<bool, bool>;
153    #[inline(always)]
154    fn deref(&self) -> &Self::Target {
155        &self.0
156    }
157}
158#[doc = "Field `FIFO_0B_FULL` writer - Set if the FIFO is full"]
159pub struct FIFO_0B_FULL_W<'a> {
160    w: &'a mut W,
161}
162impl<'a> FIFO_0B_FULL_W<'a> {
163    #[doc = r"Sets the field bit"]
164    #[inline(always)]
165    pub fn set_bit(self) -> &'a mut W {
166        self.bit(true)
167    }
168    #[doc = r"Clears the field bit"]
169    #[inline(always)]
170    pub fn clear_bit(self) -> &'a mut W {
171        self.bit(false)
172    }
173    #[doc = r"Writes raw bits to the field"]
174    #[inline(always)]
175    pub fn bit(self, value: bool) -> &'a mut W {
176        self.w.bits =
177            (self.w.bits & !(0x01 << 5)) | ((value as u32 & 0x01) << 5);
178        self.w
179    }
180}
181#[doc = "Field `FIFO_0B_OVERFLOW` reader - Set if there's a FIFO overflow"]
182pub struct FIFO_0B_OVERFLOW_R(crate::FieldReader<bool, bool>);
183impl FIFO_0B_OVERFLOW_R {
184    #[inline(always)]
185    pub(crate) fn new(bits: bool) -> Self {
186        FIFO_0B_OVERFLOW_R(crate::FieldReader::new(bits))
187    }
188}
189impl core::ops::Deref for FIFO_0B_OVERFLOW_R {
190    type Target = crate::FieldReader<bool, bool>;
191    #[inline(always)]
192    fn deref(&self) -> &Self::Target {
193        &self.0
194    }
195}
196#[doc = "Field `FIFO_0B_OVERFLOW` writer - Set if there's a FIFO overflow"]
197pub struct FIFO_0B_OVERFLOW_W<'a> {
198    w: &'a mut W,
199}
200impl<'a> FIFO_0B_OVERFLOW_W<'a> {
201    #[doc = r"Sets the field bit"]
202    #[inline(always)]
203    pub fn set_bit(self) -> &'a mut W {
204        self.bit(true)
205    }
206    #[doc = r"Clears the field bit"]
207    #[inline(always)]
208    pub fn clear_bit(self) -> &'a mut W {
209        self.bit(false)
210    }
211    #[doc = r"Writes raw bits to the field"]
212    #[inline(always)]
213    pub fn bit(self, value: bool) -> &'a mut W {
214        self.w.bits =
215            (self.w.bits & !(0x01 << 6)) | ((value as u32 & 0x01) << 6);
216        self.w
217    }
218}
219#[doc = "Field `FIFO_1A_EMPTY` reader - Set if the FIFO is empty"]
220pub struct FIFO_1A_EMPTY_R(crate::FieldReader<bool, bool>);
221impl FIFO_1A_EMPTY_R {
222    #[inline(always)]
223    pub(crate) fn new(bits: bool) -> Self {
224        FIFO_1A_EMPTY_R(crate::FieldReader::new(bits))
225    }
226}
227impl core::ops::Deref for FIFO_1A_EMPTY_R {
228    type Target = crate::FieldReader<bool, bool>;
229    #[inline(always)]
230    fn deref(&self) -> &Self::Target {
231        &self.0
232    }
233}
234#[doc = "Field `FIFO_1A_FULL` reader - Set if the FIFO is full"]
235pub struct FIFO_1A_FULL_R(crate::FieldReader<bool, bool>);
236impl FIFO_1A_FULL_R {
237    #[inline(always)]
238    pub(crate) fn new(bits: bool) -> Self {
239        FIFO_1A_FULL_R(crate::FieldReader::new(bits))
240    }
241}
242impl core::ops::Deref for FIFO_1A_FULL_R {
243    type Target = crate::FieldReader<bool, bool>;
244    #[inline(always)]
245    fn deref(&self) -> &Self::Target {
246        &self.0
247    }
248}
249#[doc = "Field `FIFO_1A_FULL` writer - Set if the FIFO is full"]
250pub struct FIFO_1A_FULL_W<'a> {
251    w: &'a mut W,
252}
253impl<'a> FIFO_1A_FULL_W<'a> {
254    #[doc = r"Sets the field bit"]
255    #[inline(always)]
256    pub fn set_bit(self) -> &'a mut W {
257        self.bit(true)
258    }
259    #[doc = r"Clears the field bit"]
260    #[inline(always)]
261    pub fn clear_bit(self) -> &'a mut W {
262        self.bit(false)
263    }
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 =
268            (self.w.bits & !(0x01 << 9)) | ((value as u32 & 0x01) << 9);
269        self.w
270    }
271}
272#[doc = "Field `FIFO_1A_OVERFLOW` reader - Set if there's a FIFO overflow"]
273pub struct FIFO_1A_OVERFLOW_R(crate::FieldReader<bool, bool>);
274impl FIFO_1A_OVERFLOW_R {
275    #[inline(always)]
276    pub(crate) fn new(bits: bool) -> Self {
277        FIFO_1A_OVERFLOW_R(crate::FieldReader::new(bits))
278    }
279}
280impl core::ops::Deref for FIFO_1A_OVERFLOW_R {
281    type Target = crate::FieldReader<bool, bool>;
282    #[inline(always)]
283    fn deref(&self) -> &Self::Target {
284        &self.0
285    }
286}
287#[doc = "Field `FIFO_1A_OVERFLOW` writer - Set if there's a FIFO overflow"]
288pub struct FIFO_1A_OVERFLOW_W<'a> {
289    w: &'a mut W,
290}
291impl<'a> FIFO_1A_OVERFLOW_W<'a> {
292    #[doc = r"Sets the field bit"]
293    #[inline(always)]
294    pub fn set_bit(self) -> &'a mut W {
295        self.bit(true)
296    }
297    #[doc = r"Clears the field bit"]
298    #[inline(always)]
299    pub fn clear_bit(self) -> &'a mut W {
300        self.bit(false)
301    }
302    #[doc = r"Writes raw bits to the field"]
303    #[inline(always)]
304    pub fn bit(self, value: bool) -> &'a mut W {
305        self.w.bits =
306            (self.w.bits & !(0x01 << 10)) | ((value as u32 & 0x01) << 10);
307        self.w
308    }
309}
310#[doc = "Field `FIFO_1B_EMPTY` reader - Set if the FIFO is empty"]
311pub struct FIFO_1B_EMPTY_R(crate::FieldReader<bool, bool>);
312impl FIFO_1B_EMPTY_R {
313    #[inline(always)]
314    pub(crate) fn new(bits: bool) -> Self {
315        FIFO_1B_EMPTY_R(crate::FieldReader::new(bits))
316    }
317}
318impl core::ops::Deref for FIFO_1B_EMPTY_R {
319    type Target = crate::FieldReader<bool, bool>;
320    #[inline(always)]
321    fn deref(&self) -> &Self::Target {
322        &self.0
323    }
324}
325#[doc = "Field `FIFO_1B_FULL` reader - Set if the FIFO is full"]
326pub struct FIFO_1B_FULL_R(crate::FieldReader<bool, bool>);
327impl FIFO_1B_FULL_R {
328    #[inline(always)]
329    pub(crate) fn new(bits: bool) -> Self {
330        FIFO_1B_FULL_R(crate::FieldReader::new(bits))
331    }
332}
333impl core::ops::Deref for FIFO_1B_FULL_R {
334    type Target = crate::FieldReader<bool, bool>;
335    #[inline(always)]
336    fn deref(&self) -> &Self::Target {
337        &self.0
338    }
339}
340#[doc = "Field `FIFO_1B_FULL` writer - Set if the FIFO is full"]
341pub struct FIFO_1B_FULL_W<'a> {
342    w: &'a mut W,
343}
344impl<'a> FIFO_1B_FULL_W<'a> {
345    #[doc = r"Sets the field bit"]
346    #[inline(always)]
347    pub fn set_bit(self) -> &'a mut W {
348        self.bit(true)
349    }
350    #[doc = r"Clears the field bit"]
351    #[inline(always)]
352    pub fn clear_bit(self) -> &'a mut W {
353        self.bit(false)
354    }
355    #[doc = r"Writes raw bits to the field"]
356    #[inline(always)]
357    pub fn bit(self, value: bool) -> &'a mut W {
358        self.w.bits =
359            (self.w.bits & !(0x01 << 13)) | ((value as u32 & 0x01) << 13);
360        self.w
361    }
362}
363#[doc = "Field `FIFO_1B_OVERFLOW` reader - Set if there's a FIFO overflow"]
364pub struct FIFO_1B_OVERFLOW_R(crate::FieldReader<bool, bool>);
365impl FIFO_1B_OVERFLOW_R {
366    #[inline(always)]
367    pub(crate) fn new(bits: bool) -> Self {
368        FIFO_1B_OVERFLOW_R(crate::FieldReader::new(bits))
369    }
370}
371impl core::ops::Deref for FIFO_1B_OVERFLOW_R {
372    type Target = crate::FieldReader<bool, bool>;
373    #[inline(always)]
374    fn deref(&self) -> &Self::Target {
375        &self.0
376    }
377}
378#[doc = "Field `FIFO_1B_OVERFLOW` writer - Set if there's a FIFO overflow"]
379pub struct FIFO_1B_OVERFLOW_W<'a> {
380    w: &'a mut W,
381}
382impl<'a> FIFO_1B_OVERFLOW_W<'a> {
383    #[doc = r"Sets the field bit"]
384    #[inline(always)]
385    pub fn set_bit(self) -> &'a mut W {
386        self.bit(true)
387    }
388    #[doc = r"Clears the field bit"]
389    #[inline(always)]
390    pub fn clear_bit(self) -> &'a mut W {
391        self.bit(false)
392    }
393    #[doc = r"Writes raw bits to the field"]
394    #[inline(always)]
395    pub fn bit(self, value: bool) -> &'a mut W {
396        self.w.bits =
397            (self.w.bits & !(0x01 << 14)) | ((value as u32 & 0x01) << 14);
398        self.w
399    }
400}
401#[doc = "Field `DMIC_VOICE_DETECTED_REG` reader - Set if detected"]
402pub struct DMIC_VOICE_DETECTED_REG_R(crate::FieldReader<bool, bool>);
403impl DMIC_VOICE_DETECTED_REG_R {
404    #[inline(always)]
405    pub(crate) fn new(bits: bool) -> Self {
406        DMIC_VOICE_DETECTED_REG_R(crate::FieldReader::new(bits))
407    }
408}
409impl core::ops::Deref for DMIC_VOICE_DETECTED_REG_R {
410    type Target = crate::FieldReader<bool, bool>;
411    #[inline(always)]
412    fn deref(&self) -> &Self::Target {
413        &self.0
414    }
415}
416#[doc = "Field `LPSD_VOICE_DETECTED_REG` reader - Set if detected"]
417pub struct LPSD_VOICE_DETECTED_REG_R(crate::FieldReader<bool, bool>);
418impl LPSD_VOICE_DETECTED_REG_R {
419    #[inline(always)]
420    pub(crate) fn new(bits: bool) -> Self {
421        LPSD_VOICE_DETECTED_REG_R(crate::FieldReader::new(bits))
422    }
423}
424impl core::ops::Deref for LPSD_VOICE_DETECTED_REG_R {
425    type Target = crate::FieldReader<bool, bool>;
426    #[inline(always)]
427    fn deref(&self) -> &Self::Target {
428        &self.0
429    }
430}
431#[doc = "Field `AP_PDM_CLK_OFF_REG` reader - Set if AP PDM clock is off"]
432pub struct AP_PDM_CLK_OFF_REG_R(crate::FieldReader<bool, bool>);
433impl AP_PDM_CLK_OFF_REG_R {
434    #[inline(always)]
435    pub(crate) fn new(bits: bool) -> Self {
436        AP_PDM_CLK_OFF_REG_R(crate::FieldReader::new(bits))
437    }
438}
439impl core::ops::Deref for AP_PDM_CLK_OFF_REG_R {
440    type Target = crate::FieldReader<bool, bool>;
441    #[inline(always)]
442    fn deref(&self) -> &Self::Target {
443        &self.0
444    }
445}
446#[doc = "Field `AP_PDM_CLK_ON_REG` reader - Set if AP PDM clock is on"]
447pub struct AP_PDM_CLK_ON_REG_R(crate::FieldReader<bool, bool>);
448impl AP_PDM_CLK_ON_REG_R {
449    #[inline(always)]
450    pub(crate) fn new(bits: bool) -> Self {
451        AP_PDM_CLK_ON_REG_R(crate::FieldReader::new(bits))
452    }
453}
454impl core::ops::Deref for AP_PDM_CLK_ON_REG_R {
455    type Target = crate::FieldReader<bool, bool>;
456    #[inline(always)]
457    fn deref(&self) -> &Self::Target {
458        &self.0
459    }
460}
461#[doc = "Field `DMAC1_BUF_DONE_REG` reader - Set if done"]
462pub struct DMAC1_BUF_DONE_REG_R(crate::FieldReader<bool, bool>);
463impl DMAC1_BUF_DONE_REG_R {
464    #[inline(always)]
465    pub(crate) fn new(bits: bool) -> Self {
466        DMAC1_BUF_DONE_REG_R(crate::FieldReader::new(bits))
467    }
468}
469impl core::ops::Deref for DMAC1_BUF_DONE_REG_R {
470    type Target = crate::FieldReader<bool, bool>;
471    #[inline(always)]
472    fn deref(&self) -> &Self::Target {
473        &self.0
474    }
475}
476#[doc = "Field `DMAC1_BUF_DONE_REG` writer - Set if done"]
477pub struct DMAC1_BUF_DONE_REG_W<'a> {
478    w: &'a mut W,
479}
480impl<'a> DMAC1_BUF_DONE_REG_W<'a> {
481    #[doc = r"Sets the field bit"]
482    #[inline(always)]
483    pub fn set_bit(self) -> &'a mut W {
484        self.bit(true)
485    }
486    #[doc = r"Clears the field bit"]
487    #[inline(always)]
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(always)]
493    pub fn bit(self, value: bool) -> &'a mut W {
494        self.w.bits =
495            (self.w.bits & !(0x01 << 20)) | ((value as u32 & 0x01) << 20);
496        self.w
497    }
498}
499#[doc = "Field `DMAC1_BLK_DONE_REG` reader - Set if done"]
500pub struct DMAC1_BLK_DONE_REG_R(crate::FieldReader<bool, bool>);
501impl DMAC1_BLK_DONE_REG_R {
502    #[inline(always)]
503    pub(crate) fn new(bits: bool) -> Self {
504        DMAC1_BLK_DONE_REG_R(crate::FieldReader::new(bits))
505    }
506}
507impl core::ops::Deref for DMAC1_BLK_DONE_REG_R {
508    type Target = crate::FieldReader<bool, bool>;
509    #[inline(always)]
510    fn deref(&self) -> &Self::Target {
511        &self.0
512    }
513}
514#[doc = "Field `DMAC1_BLK_DONE_REG` writer - Set if done"]
515pub struct DMAC1_BLK_DONE_REG_W<'a> {
516    w: &'a mut W,
517}
518impl<'a> DMAC1_BLK_DONE_REG_W<'a> {
519    #[doc = r"Sets the field bit"]
520    #[inline(always)]
521    pub fn set_bit(self) -> &'a mut W {
522        self.bit(true)
523    }
524    #[doc = r"Clears the field bit"]
525    #[inline(always)]
526    pub fn clear_bit(self) -> &'a mut W {
527        self.bit(false)
528    }
529    #[doc = r"Writes raw bits to the field"]
530    #[inline(always)]
531    pub fn bit(self, value: bool) -> &'a mut W {
532        self.w.bits =
533            (self.w.bits & !(0x01 << 21)) | ((value as u32 & 0x01) << 21);
534        self.w
535    }
536}
537#[doc = "Field `DMAC0_BUF_DONE_REG` reader - Set if done"]
538pub struct DMAC0_BUF_DONE_REG_R(crate::FieldReader<bool, bool>);
539impl DMAC0_BUF_DONE_REG_R {
540    #[inline(always)]
541    pub(crate) fn new(bits: bool) -> Self {
542        DMAC0_BUF_DONE_REG_R(crate::FieldReader::new(bits))
543    }
544}
545impl core::ops::Deref for DMAC0_BUF_DONE_REG_R {
546    type Target = crate::FieldReader<bool, bool>;
547    #[inline(always)]
548    fn deref(&self) -> &Self::Target {
549        &self.0
550    }
551}
552#[doc = "Field `DMAC0_BUF_DONE_REG` writer - Set if done"]
553pub struct DMAC0_BUF_DONE_REG_W<'a> {
554    w: &'a mut W,
555}
556impl<'a> DMAC0_BUF_DONE_REG_W<'a> {
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 =
571            (self.w.bits & !(0x01 << 22)) | ((value as u32 & 0x01) << 22);
572        self.w
573    }
574}
575#[doc = "Field `DMAC0_BLK_DONE_REG` reader - Set if done"]
576pub struct DMAC0_BLK_DONE_REG_R(crate::FieldReader<bool, bool>);
577impl DMAC0_BLK_DONE_REG_R {
578    #[inline(always)]
579    pub(crate) fn new(bits: bool) -> Self {
580        DMAC0_BLK_DONE_REG_R(crate::FieldReader::new(bits))
581    }
582}
583impl core::ops::Deref for DMAC0_BLK_DONE_REG_R {
584    type Target = crate::FieldReader<bool, bool>;
585    #[inline(always)]
586    fn deref(&self) -> &Self::Target {
587        &self.0
588    }
589}
590#[doc = "Field `DMAC0_BLK_DONE_REG` writer - Set if done"]
591pub struct DMAC0_BLK_DONE_REG_W<'a> {
592    w: &'a mut W,
593}
594impl<'a> DMAC0_BLK_DONE_REG_W<'a> {
595    #[doc = r"Sets the field bit"]
596    #[inline(always)]
597    pub fn set_bit(self) -> &'a mut W {
598        self.bit(true)
599    }
600    #[doc = r"Clears the field bit"]
601    #[inline(always)]
602    pub fn clear_bit(self) -> &'a mut W {
603        self.bit(false)
604    }
605    #[doc = r"Writes raw bits to the field"]
606    #[inline(always)]
607    pub fn bit(self, value: bool) -> &'a mut W {
608        self.w.bits =
609            (self.w.bits & !(0x01 << 23)) | ((value as u32 & 0x01) << 23);
610        self.w
611    }
612}
613impl R {
614    #[doc = "Bit 0 - Set if the FIFO is empty"]
615    #[inline(always)]
616    pub fn fifo_0a_empty(&self) -> FIFO_0A_EMPTY_R {
617        FIFO_0A_EMPTY_R::new((self.bits & 0x01) != 0)
618    }
619    #[doc = "Bit 1 - Set if the FIFO is full"]
620    #[inline(always)]
621    pub fn fifo_0a_full(&self) -> FIFO_0A_FULL_R {
622        FIFO_0A_FULL_R::new(((self.bits >> 1) & 0x01) != 0)
623    }
624    #[doc = "Bit 2 - Set if there's a FIFO overflow"]
625    #[inline(always)]
626    pub fn fifo_0a_overflow(&self) -> FIFO_0A_OVERFLOW_R {
627        FIFO_0A_OVERFLOW_R::new(((self.bits >> 2) & 0x01) != 0)
628    }
629    #[doc = "Bit 4 - Set if the FIFO is empty"]
630    #[inline(always)]
631    pub fn fifo_0b_empty(&self) -> FIFO_0B_EMPTY_R {
632        FIFO_0B_EMPTY_R::new(((self.bits >> 4) & 0x01) != 0)
633    }
634    #[doc = "Bit 5 - Set if the FIFO is full"]
635    #[inline(always)]
636    pub fn fifo_0b_full(&self) -> FIFO_0B_FULL_R {
637        FIFO_0B_FULL_R::new(((self.bits >> 5) & 0x01) != 0)
638    }
639    #[doc = "Bit 6 - Set if there's a FIFO overflow"]
640    #[inline(always)]
641    pub fn fifo_0b_overflow(&self) -> FIFO_0B_OVERFLOW_R {
642        FIFO_0B_OVERFLOW_R::new(((self.bits >> 6) & 0x01) != 0)
643    }
644    #[doc = "Bit 8 - Set if the FIFO is empty"]
645    #[inline(always)]
646    pub fn fifo_1a_empty(&self) -> FIFO_1A_EMPTY_R {
647        FIFO_1A_EMPTY_R::new(((self.bits >> 8) & 0x01) != 0)
648    }
649    #[doc = "Bit 9 - Set if the FIFO is full"]
650    #[inline(always)]
651    pub fn fifo_1a_full(&self) -> FIFO_1A_FULL_R {
652        FIFO_1A_FULL_R::new(((self.bits >> 9) & 0x01) != 0)
653    }
654    #[doc = "Bit 10 - Set if there's a FIFO overflow"]
655    #[inline(always)]
656    pub fn fifo_1a_overflow(&self) -> FIFO_1A_OVERFLOW_R {
657        FIFO_1A_OVERFLOW_R::new(((self.bits >> 10) & 0x01) != 0)
658    }
659    #[doc = "Bit 12 - Set if the FIFO is empty"]
660    #[inline(always)]
661    pub fn fifo_1b_empty(&self) -> FIFO_1B_EMPTY_R {
662        FIFO_1B_EMPTY_R::new(((self.bits >> 12) & 0x01) != 0)
663    }
664    #[doc = "Bit 13 - Set if the FIFO is full"]
665    #[inline(always)]
666    pub fn fifo_1b_full(&self) -> FIFO_1B_FULL_R {
667        FIFO_1B_FULL_R::new(((self.bits >> 13) & 0x01) != 0)
668    }
669    #[doc = "Bit 14 - Set if there's a FIFO overflow"]
670    #[inline(always)]
671    pub fn fifo_1b_overflow(&self) -> FIFO_1B_OVERFLOW_R {
672        FIFO_1B_OVERFLOW_R::new(((self.bits >> 14) & 0x01) != 0)
673    }
674    #[doc = "Bit 16 - Set if detected"]
675    #[inline(always)]
676    pub fn dmic_voice_detected_reg(&self) -> DMIC_VOICE_DETECTED_REG_R {
677        DMIC_VOICE_DETECTED_REG_R::new(((self.bits >> 16) & 0x01) != 0)
678    }
679    #[doc = "Bit 17 - Set if detected"]
680    #[inline(always)]
681    pub fn lpsd_voice_detected_reg(&self) -> LPSD_VOICE_DETECTED_REG_R {
682        LPSD_VOICE_DETECTED_REG_R::new(((self.bits >> 17) & 0x01) != 0)
683    }
684    #[doc = "Bit 18 - Set if AP PDM clock is off"]
685    #[inline(always)]
686    pub fn ap_pdm_clk_off_reg(&self) -> AP_PDM_CLK_OFF_REG_R {
687        AP_PDM_CLK_OFF_REG_R::new(((self.bits >> 18) & 0x01) != 0)
688    }
689    #[doc = "Bit 19 - Set if AP PDM clock is on"]
690    #[inline(always)]
691    pub fn ap_pdm_clk_on_reg(&self) -> AP_PDM_CLK_ON_REG_R {
692        AP_PDM_CLK_ON_REG_R::new(((self.bits >> 19) & 0x01) != 0)
693    }
694    #[doc = "Bit 20 - Set if done"]
695    #[inline(always)]
696    pub fn dmac1_buf_done_reg(&self) -> DMAC1_BUF_DONE_REG_R {
697        DMAC1_BUF_DONE_REG_R::new(((self.bits >> 20) & 0x01) != 0)
698    }
699    #[doc = "Bit 21 - Set if done"]
700    #[inline(always)]
701    pub fn dmac1_blk_done_reg(&self) -> DMAC1_BLK_DONE_REG_R {
702        DMAC1_BLK_DONE_REG_R::new(((self.bits >> 21) & 0x01) != 0)
703    }
704    #[doc = "Bit 22 - Set if done"]
705    #[inline(always)]
706    pub fn dmac0_buf_done_reg(&self) -> DMAC0_BUF_DONE_REG_R {
707        DMAC0_BUF_DONE_REG_R::new(((self.bits >> 22) & 0x01) != 0)
708    }
709    #[doc = "Bit 23 - Set if done"]
710    #[inline(always)]
711    pub fn dmac0_blk_done_reg(&self) -> DMAC0_BLK_DONE_REG_R {
712        DMAC0_BLK_DONE_REG_R::new(((self.bits >> 23) & 0x01) != 0)
713    }
714}
715impl W {
716    #[doc = "Bit 1 - Set if the FIFO is full"]
717    #[inline(always)]
718    pub fn fifo_0a_full(&mut self) -> FIFO_0A_FULL_W {
719        FIFO_0A_FULL_W { w: self }
720    }
721    #[doc = "Bit 2 - Set if there's a FIFO overflow"]
722    #[inline(always)]
723    pub fn fifo_0a_overflow(&mut self) -> FIFO_0A_OVERFLOW_W {
724        FIFO_0A_OVERFLOW_W { w: self }
725    }
726    #[doc = "Bit 5 - Set if the FIFO is full"]
727    #[inline(always)]
728    pub fn fifo_0b_full(&mut self) -> FIFO_0B_FULL_W {
729        FIFO_0B_FULL_W { w: self }
730    }
731    #[doc = "Bit 6 - Set if there's a FIFO overflow"]
732    #[inline(always)]
733    pub fn fifo_0b_overflow(&mut self) -> FIFO_0B_OVERFLOW_W {
734        FIFO_0B_OVERFLOW_W { w: self }
735    }
736    #[doc = "Bit 9 - Set if the FIFO is full"]
737    #[inline(always)]
738    pub fn fifo_1a_full(&mut self) -> FIFO_1A_FULL_W {
739        FIFO_1A_FULL_W { w: self }
740    }
741    #[doc = "Bit 10 - Set if there's a FIFO overflow"]
742    #[inline(always)]
743    pub fn fifo_1a_overflow(&mut self) -> FIFO_1A_OVERFLOW_W {
744        FIFO_1A_OVERFLOW_W { w: self }
745    }
746    #[doc = "Bit 13 - Set if the FIFO is full"]
747    #[inline(always)]
748    pub fn fifo_1b_full(&mut self) -> FIFO_1B_FULL_W {
749        FIFO_1B_FULL_W { w: self }
750    }
751    #[doc = "Bit 14 - Set if there's a FIFO overflow"]
752    #[inline(always)]
753    pub fn fifo_1b_overflow(&mut self) -> FIFO_1B_OVERFLOW_W {
754        FIFO_1B_OVERFLOW_W { w: self }
755    }
756    #[doc = "Bit 20 - Set if done"]
757    #[inline(always)]
758    pub fn dmac1_buf_done_reg(&mut self) -> DMAC1_BUF_DONE_REG_W {
759        DMAC1_BUF_DONE_REG_W { w: self }
760    }
761    #[doc = "Bit 21 - Set if done"]
762    #[inline(always)]
763    pub fn dmac1_blk_done_reg(&mut self) -> DMAC1_BLK_DONE_REG_W {
764        DMAC1_BLK_DONE_REG_W { w: self }
765    }
766    #[doc = "Bit 22 - Set if done"]
767    #[inline(always)]
768    pub fn dmac0_buf_done_reg(&mut self) -> DMAC0_BUF_DONE_REG_W {
769        DMAC0_BUF_DONE_REG_W { w: self }
770    }
771    #[doc = "Bit 23 - Set if done"]
772    #[inline(always)]
773    pub fn dmac0_blk_done_reg(&mut self) -> DMAC0_BLK_DONE_REG_W {
774        DMAC0_BLK_DONE_REG_W { w: self }
775    }
776    #[doc = "Writes raw bits to the register."]
777    #[inline(always)]
778    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
779        self.0.bits(bits);
780        self
781    }
782}
783#[doc = "Audio Status Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [voice_status](index.html) module"]
784pub struct VOICE_STATUS_SPEC;
785impl crate::RegisterSpec for VOICE_STATUS_SPEC {
786    type Ux = u32;
787}
788#[doc = "`read()` method returns [voice_status::R](R) reader structure"]
789impl crate::Readable for VOICE_STATUS_SPEC {
790    type Reader = R;
791}
792#[doc = "`write(|w| ..)` method takes [voice_status::W](W) writer structure"]
793impl crate::Writable for VOICE_STATUS_SPEC {
794    type Writer = W;
795}
796#[doc = "`reset()` method sets VOICE_STATUS to value 0x0004_1111"]
797impl crate::Resettable for VOICE_STATUS_SPEC {
798    #[inline(always)]
799    fn reset_value() -> Self::Ux {
800        0x0004_1111
801    }
802}
eos_s3/aud/voice_status.rs

eos_s3/aud/
voice_status.rs
