eos_s3/pkfb/
pkfb_fifoctrl.rs

1#[doc = "Register `PKFB_FIFOCTRL` reader"]
2pub struct R(crate::R<PKFB_FIFOCTRL_SPEC>);
3impl core::ops::Deref for R {
4    type Target = crate::R<PKFB_FIFOCTRL_SPEC>;
5    #[inline(always)]
6    fn deref(&self) -> &Self::Target {
7        &self.0
8    }
9}
10impl From<crate::R<PKFB_FIFOCTRL_SPEC>> for R {
11    #[inline(always)]
12    fn from(reader: crate::R<PKFB_FIFOCTRL_SPEC>) -> Self {
13        R(reader)
14    }
15}
16#[doc = "Register `PKFB_FIFOCTRL` writer"]
17pub struct W(crate::W<PKFB_FIFOCTRL_SPEC>);
18impl core::ops::Deref for W {
19    type Target = crate::W<PKFB_FIFOCTRL_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<PKFB_FIFOCTRL_SPEC>> for W {
32    #[inline(always)]
33    fn from(writer: crate::W<PKFB_FIFOCTRL_SPEC>) -> Self {
34        W(writer)
35    }
36}
37#[doc = "Set to enable the Packet FIFO\n\nValue on reset: 0"]
38#[derive(Clone, Copy, Debug, PartialEq)]
39pub enum PF0_EN_A {
40    #[doc = "0: Disable the packet FIFO"]
41    DISABLE = 0,
42    #[doc = "1: Enable the packet FIFO"]
43    ENABLE = 1,
44}
45impl From<PF0_EN_A> for bool {
46    #[inline(always)]
47    fn from(variant: PF0_EN_A) -> Self {
48        variant as u8 != 0
49    }
50}
51#[doc = "Field `pf0_en` reader - Set to enable the Packet FIFO"]
52pub struct PF0_EN_R(crate::FieldReader<bool, PF0_EN_A>);
53impl PF0_EN_R {
54    #[inline(always)]
55    pub(crate) fn new(bits: bool) -> Self {
56        PF0_EN_R(crate::FieldReader::new(bits))
57    }
58    #[doc = r"Get enumerated values variant"]
59    #[inline(always)]
60    pub fn variant(&self) -> PF0_EN_A {
61        match self.bits {
62            false => PF0_EN_A::DISABLE,
63            true => PF0_EN_A::ENABLE,
64        }
65    }
66    #[doc = "Checks if the value of the field is `DISABLE`"]
67    #[inline(always)]
68    pub fn is_disable(&self) -> bool {
69        **self == PF0_EN_A::DISABLE
70    }
71    #[doc = "Checks if the value of the field is `ENABLE`"]
72    #[inline(always)]
73    pub fn is_enable(&self) -> bool {
74        **self == PF0_EN_A::ENABLE
75    }
76}
77impl core::ops::Deref for PF0_EN_R {
78    type Target = crate::FieldReader<bool, PF0_EN_A>;
79    #[inline(always)]
80    fn deref(&self) -> &Self::Target {
81        &self.0
82    }
83}
84#[doc = "Field `pf0_en` writer - Set to enable the Packet FIFO"]
85pub struct PF0_EN_W<'a> {
86    w: &'a mut W,
87}
88impl<'a> PF0_EN_W<'a> {
89    #[doc = r"Writes `variant` to the field"]
90    #[inline(always)]
91    pub fn variant(self, variant: PF0_EN_A) -> &'a mut W {
92        self.bit(variant.into())
93    }
94    #[doc = "Disable the packet FIFO"]
95    #[inline(always)]
96    pub fn disable(self) -> &'a mut W {
97        self.variant(PF0_EN_A::DISABLE)
98    }
99    #[doc = "Enable the packet FIFO"]
100    #[inline(always)]
101    pub fn enable(self) -> &'a mut W {
102        self.variant(PF0_EN_A::ENABLE)
103    }
104    #[doc = r"Sets the field bit"]
105    #[inline(always)]
106    pub fn set_bit(self) -> &'a mut W {
107        self.bit(true)
108    }
109    #[doc = r"Clears the field bit"]
110    #[inline(always)]
111    pub fn clear_bit(self) -> &'a mut W {
112        self.bit(false)
113    }
114    #[doc = r"Writes raw bits to the field"]
115    #[inline(always)]
116    pub fn bit(self, value: bool) -> &'a mut W {
117        self.w.bits = (self.w.bits & !0x01) | (value as u32 & 0x01);
118        self.w
119    }
120}
121#[doc = "Select which subsystem controls the push operation\n\nValue on reset: 0"]
122#[derive(Clone, Copy, Debug, PartialEq)]
123pub enum PF0_PUSH_MUX_A {
124    #[doc = "0: Select the M4 subsystem to control the FIFO"]
125    M4 = 0,
126    #[doc = "1: Select the FFE subsystem to control the FIFO"]
127    FFE = 1,
128}
129impl From<PF0_PUSH_MUX_A> for bool {
130    #[inline(always)]
131    fn from(variant: PF0_PUSH_MUX_A) -> Self {
132        variant as u8 != 0
133    }
134}
135#[doc = "Field `pf0_push_mux` reader - Select which subsystem controls the push operation"]
136pub struct PF0_PUSH_MUX_R(crate::FieldReader<bool, PF0_PUSH_MUX_A>);
137impl PF0_PUSH_MUX_R {
138    #[inline(always)]
139    pub(crate) fn new(bits: bool) -> Self {
140        PF0_PUSH_MUX_R(crate::FieldReader::new(bits))
141    }
142    #[doc = r"Get enumerated values variant"]
143    #[inline(always)]
144    pub fn variant(&self) -> PF0_PUSH_MUX_A {
145        match self.bits {
146            false => PF0_PUSH_MUX_A::M4,
147            true => PF0_PUSH_MUX_A::FFE,
148        }
149    }
150    #[doc = "Checks if the value of the field is `M4`"]
151    #[inline(always)]
152    pub fn is_m4(&self) -> bool {
153        **self == PF0_PUSH_MUX_A::M4
154    }
155    #[doc = "Checks if the value of the field is `FFE`"]
156    #[inline(always)]
157    pub fn is_ffe(&self) -> bool {
158        **self == PF0_PUSH_MUX_A::FFE
159    }
160}
161impl core::ops::Deref for PF0_PUSH_MUX_R {
162    type Target = crate::FieldReader<bool, PF0_PUSH_MUX_A>;
163    #[inline(always)]
164    fn deref(&self) -> &Self::Target {
165        &self.0
166    }
167}
168#[doc = "Field `pf0_push_mux` writer - Select which subsystem controls the push operation"]
169pub struct PF0_PUSH_MUX_W<'a> {
170    w: &'a mut W,
171}
172impl<'a> PF0_PUSH_MUX_W<'a> {
173    #[doc = r"Writes `variant` to the field"]
174    #[inline(always)]
175    pub fn variant(self, variant: PF0_PUSH_MUX_A) -> &'a mut W {
176        self.bit(variant.into())
177    }
178    #[doc = "Select the M4 subsystem to control the FIFO"]
179    #[inline(always)]
180    pub fn m4(self) -> &'a mut W {
181        self.variant(PF0_PUSH_MUX_A::M4)
182    }
183    #[doc = "Select the FFE subsystem to control the FIFO"]
184    #[inline(always)]
185    pub fn ffe(self) -> &'a mut W {
186        self.variant(PF0_PUSH_MUX_A::FFE)
187    }
188    #[doc = r"Sets the field bit"]
189    #[inline(always)]
190    pub fn set_bit(self) -> &'a mut W {
191        self.bit(true)
192    }
193    #[doc = r"Clears the field bit"]
194    #[inline(always)]
195    pub fn clear_bit(self) -> &'a mut W {
196        self.bit(false)
197    }
198    #[doc = r"Writes raw bits to the field"]
199    #[inline(always)]
200    pub fn bit(self, value: bool) -> &'a mut W {
201        self.w.bits =
202            (self.w.bits & !(0x01 << 1)) | ((value as u32 & 0x01) << 1);
203        self.w
204    }
205}
206#[doc = "Select which subsystem controls the pop operation\n\nValue on reset: 0"]
207#[derive(Clone, Copy, Debug, PartialEq)]
208pub enum PF0_POP_MUX_A {
209    #[doc = "0: Select the M4 subsystem to control the FIFO"]
210    M4 = 0,
211    #[doc = "1: Select the AP subsystem to control the FIFO"]
212    AP = 1,
213}
214impl From<PF0_POP_MUX_A> for bool {
215    #[inline(always)]
216    fn from(variant: PF0_POP_MUX_A) -> Self {
217        variant as u8 != 0
218    }
219}
220#[doc = "Field `pf0_pop_mux` reader - Select which subsystem controls the pop operation"]
221pub struct PF0_POP_MUX_R(crate::FieldReader<bool, PF0_POP_MUX_A>);
222impl PF0_POP_MUX_R {
223    #[inline(always)]
224    pub(crate) fn new(bits: bool) -> Self {
225        PF0_POP_MUX_R(crate::FieldReader::new(bits))
226    }
227    #[doc = r"Get enumerated values variant"]
228    #[inline(always)]
229    pub fn variant(&self) -> PF0_POP_MUX_A {
230        match self.bits {
231            false => PF0_POP_MUX_A::M4,
232            true => PF0_POP_MUX_A::AP,
233        }
234    }
235    #[doc = "Checks if the value of the field is `M4`"]
236    #[inline(always)]
237    pub fn is_m4(&self) -> bool {
238        **self == PF0_POP_MUX_A::M4
239    }
240    #[doc = "Checks if the value of the field is `AP`"]
241    #[inline(always)]
242    pub fn is_ap(&self) -> bool {
243        **self == PF0_POP_MUX_A::AP
244    }
245}
246impl core::ops::Deref for PF0_POP_MUX_R {
247    type Target = crate::FieldReader<bool, PF0_POP_MUX_A>;
248    #[inline(always)]
249    fn deref(&self) -> &Self::Target {
250        &self.0
251    }
252}
253#[doc = "Field `pf0_pop_mux` writer - Select which subsystem controls the pop operation"]
254pub struct PF0_POP_MUX_W<'a> {
255    w: &'a mut W,
256}
257impl<'a> PF0_POP_MUX_W<'a> {
258    #[doc = r"Writes `variant` to the field"]
259    #[inline(always)]
260    pub fn variant(self, variant: PF0_POP_MUX_A) -> &'a mut W {
261        self.bit(variant.into())
262    }
263    #[doc = "Select the M4 subsystem to control the FIFO"]
264    #[inline(always)]
265    pub fn m4(self) -> &'a mut W {
266        self.variant(PF0_POP_MUX_A::M4)
267    }
268    #[doc = "Select the AP subsystem to control the FIFO"]
269    #[inline(always)]
270    pub fn ap(self) -> &'a mut W {
271        self.variant(PF0_POP_MUX_A::AP)
272    }
273    #[doc = r"Sets the field bit"]
274    #[inline(always)]
275    pub fn set_bit(self) -> &'a mut W {
276        self.bit(true)
277    }
278    #[doc = r"Clears the field bit"]
279    #[inline(always)]
280    pub fn clear_bit(self) -> &'a mut W {
281        self.bit(false)
282    }
283    #[doc = r"Writes raw bits to the field"]
284    #[inline(always)]
285    pub fn bit(self, value: bool) -> &'a mut W {
286        self.w.bits =
287            (self.w.bits & !(0x01 << 2)) | ((value as u32 & 0x01) << 2);
288        self.w
289    }
290}
291#[doc = "Select which subsystem manages the push interrupt\n\nValue on reset: 0"]
292#[derive(Clone, Copy, Debug, PartialEq)]
293pub enum PF0_PUSH_INT_MUX_A {
294    #[doc = "0: Select the M4 subsystem to control the FIFO"]
295    M4 = 0,
296    #[doc = "1: Select the AP subsystem to control the FIFO"]
297    AP = 1,
298}
299impl From<PF0_PUSH_INT_MUX_A> for bool {
300    #[inline(always)]
301    fn from(variant: PF0_PUSH_INT_MUX_A) -> Self {
302        variant as u8 != 0
303    }
304}
305#[doc = "Field `pf0_push_int_mux` reader - Select which subsystem manages the push interrupt"]
306pub struct PF0_PUSH_INT_MUX_R(crate::FieldReader<bool, PF0_PUSH_INT_MUX_A>);
307impl PF0_PUSH_INT_MUX_R {
308    #[inline(always)]
309    pub(crate) fn new(bits: bool) -> Self {
310        PF0_PUSH_INT_MUX_R(crate::FieldReader::new(bits))
311    }
312    #[doc = r"Get enumerated values variant"]
313    #[inline(always)]
314    pub fn variant(&self) -> PF0_PUSH_INT_MUX_A {
315        match self.bits {
316            false => PF0_PUSH_INT_MUX_A::M4,
317            true => PF0_PUSH_INT_MUX_A::AP,
318        }
319    }
320    #[doc = "Checks if the value of the field is `M4`"]
321    #[inline(always)]
322    pub fn is_m4(&self) -> bool {
323        **self == PF0_PUSH_INT_MUX_A::M4
324    }
325    #[doc = "Checks if the value of the field is `AP`"]
326    #[inline(always)]
327    pub fn is_ap(&self) -> bool {
328        **self == PF0_PUSH_INT_MUX_A::AP
329    }
330}
331impl core::ops::Deref for PF0_PUSH_INT_MUX_R {
332    type Target = crate::FieldReader<bool, PF0_PUSH_INT_MUX_A>;
333    #[inline(always)]
334    fn deref(&self) -> &Self::Target {
335        &self.0
336    }
337}
338#[doc = "Field `pf0_push_int_mux` writer - Select which subsystem manages the push interrupt"]
339pub struct PF0_PUSH_INT_MUX_W<'a> {
340    w: &'a mut W,
341}
342impl<'a> PF0_PUSH_INT_MUX_W<'a> {
343    #[doc = r"Writes `variant` to the field"]
344    #[inline(always)]
345    pub fn variant(self, variant: PF0_PUSH_INT_MUX_A) -> &'a mut W {
346        self.bit(variant.into())
347    }
348    #[doc = "Select the M4 subsystem to control the FIFO"]
349    #[inline(always)]
350    pub fn m4(self) -> &'a mut W {
351        self.variant(PF0_PUSH_INT_MUX_A::M4)
352    }
353    #[doc = "Select the AP subsystem to control the FIFO"]
354    #[inline(always)]
355    pub fn ap(self) -> &'a mut W {
356        self.variant(PF0_PUSH_INT_MUX_A::AP)
357    }
358    #[doc = r"Sets the field bit"]
359    #[inline(always)]
360    pub fn set_bit(self) -> &'a mut W {
361        self.bit(true)
362    }
363    #[doc = r"Clears the field bit"]
364    #[inline(always)]
365    pub fn clear_bit(self) -> &'a mut W {
366        self.bit(false)
367    }
368    #[doc = r"Writes raw bits to the field"]
369    #[inline(always)]
370    pub fn bit(self, value: bool) -> &'a mut W {
371        self.w.bits =
372            (self.w.bits & !(0x01 << 3)) | ((value as u32 & 0x01) << 3);
373        self.w
374    }
375}
376#[doc = "Select which subsystem manages the pop interrupt\n\nValue on reset: 0"]
377#[derive(Clone, Copy, Debug, PartialEq)]
378pub enum PF0_POP_INT_MUX_A {
379    #[doc = "0: Select the M4 subsystem to control the FIFO"]
380    M4 = 0,
381    #[doc = "1: Select the AP subsystem to control the FIFO"]
382    AP = 1,
383}
384impl From<PF0_POP_INT_MUX_A> for bool {
385    #[inline(always)]
386    fn from(variant: PF0_POP_INT_MUX_A) -> Self {
387        variant as u8 != 0
388    }
389}
390#[doc = "Field `pf0_pop_int_mux` reader - Select which subsystem manages the pop interrupt"]
391pub struct PF0_POP_INT_MUX_R(crate::FieldReader<bool, PF0_POP_INT_MUX_A>);
392impl PF0_POP_INT_MUX_R {
393    #[inline(always)]
394    pub(crate) fn new(bits: bool) -> Self {
395        PF0_POP_INT_MUX_R(crate::FieldReader::new(bits))
396    }
397    #[doc = r"Get enumerated values variant"]
398    #[inline(always)]
399    pub fn variant(&self) -> PF0_POP_INT_MUX_A {
400        match self.bits {
401            false => PF0_POP_INT_MUX_A::M4,
402            true => PF0_POP_INT_MUX_A::AP,
403        }
404    }
405    #[doc = "Checks if the value of the field is `M4`"]
406    #[inline(always)]
407    pub fn is_m4(&self) -> bool {
408        **self == PF0_POP_INT_MUX_A::M4
409    }
410    #[doc = "Checks if the value of the field is `AP`"]
411    #[inline(always)]
412    pub fn is_ap(&self) -> bool {
413        **self == PF0_POP_INT_MUX_A::AP
414    }
415}
416impl core::ops::Deref for PF0_POP_INT_MUX_R {
417    type Target = crate::FieldReader<bool, PF0_POP_INT_MUX_A>;
418    #[inline(always)]
419    fn deref(&self) -> &Self::Target {
420        &self.0
421    }
422}
423#[doc = "Field `pf0_pop_int_mux` writer - Select which subsystem manages the pop interrupt"]
424pub struct PF0_POP_INT_MUX_W<'a> {
425    w: &'a mut W,
426}
427impl<'a> PF0_POP_INT_MUX_W<'a> {
428    #[doc = r"Writes `variant` to the field"]
429    #[inline(always)]
430    pub fn variant(self, variant: PF0_POP_INT_MUX_A) -> &'a mut W {
431        self.bit(variant.into())
432    }
433    #[doc = "Select the M4 subsystem to control the FIFO"]
434    #[inline(always)]
435    pub fn m4(self) -> &'a mut W {
436        self.variant(PF0_POP_INT_MUX_A::M4)
437    }
438    #[doc = "Select the AP subsystem to control the FIFO"]
439    #[inline(always)]
440    pub fn ap(self) -> &'a mut W {
441        self.variant(PF0_POP_INT_MUX_A::AP)
442    }
443    #[doc = r"Sets the field bit"]
444    #[inline(always)]
445    pub fn set_bit(self) -> &'a mut W {
446        self.bit(true)
447    }
448    #[doc = r"Clears the field bit"]
449    #[inline(always)]
450    pub fn clear_bit(self) -> &'a mut W {
451        self.bit(false)
452    }
453    #[doc = r"Writes raw bits to the field"]
454    #[inline(always)]
455    pub fn bit(self, value: bool) -> &'a mut W {
456        self.w.bits =
457            (self.w.bits & !(0x01 << 4)) | ((value as u32 & 0x01) << 4);
458        self.w
459    }
460}
461#[doc = "If FFE is the controller, select which instance of FFE will be used for control\n\nValue on reset: 0"]
462#[derive(Clone, Copy, Debug, PartialEq)]
463pub enum PF0_FFE_SEL_A {
464    #[doc = "0: when FFE is the controller of the FIFO, select FFE0 as the controller"]
465    FFE0 = 0,
466    #[doc = "1: when FFE is the controller of the FIFO, select FFE1 as the controller"]
467    FFE1 = 1,
468}
469impl From<PF0_FFE_SEL_A> for bool {
470    #[inline(always)]
471    fn from(variant: PF0_FFE_SEL_A) -> Self {
472        variant as u8 != 0
473    }
474}
475#[doc = "Field `pf0_ffe_sel` reader - If FFE is the controller, select which instance of FFE will be used for control"]
476pub struct PF0_FFE_SEL_R(crate::FieldReader<bool, PF0_FFE_SEL_A>);
477impl PF0_FFE_SEL_R {
478    #[inline(always)]
479    pub(crate) fn new(bits: bool) -> Self {
480        PF0_FFE_SEL_R(crate::FieldReader::new(bits))
481    }
482    #[doc = r"Get enumerated values variant"]
483    #[inline(always)]
484    pub fn variant(&self) -> PF0_FFE_SEL_A {
485        match self.bits {
486            false => PF0_FFE_SEL_A::FFE0,
487            true => PF0_FFE_SEL_A::FFE1,
488        }
489    }
490    #[doc = "Checks if the value of the field is `FFE0`"]
491    #[inline(always)]
492    pub fn is_ffe0(&self) -> bool {
493        **self == PF0_FFE_SEL_A::FFE0
494    }
495    #[doc = "Checks if the value of the field is `FFE1`"]
496    #[inline(always)]
497    pub fn is_ffe1(&self) -> bool {
498        **self == PF0_FFE_SEL_A::FFE1
499    }
500}
501impl core::ops::Deref for PF0_FFE_SEL_R {
502    type Target = crate::FieldReader<bool, PF0_FFE_SEL_A>;
503    #[inline(always)]
504    fn deref(&self) -> &Self::Target {
505        &self.0
506    }
507}
508#[doc = "Field `pf0_ffe_sel` writer - If FFE is the controller, select which instance of FFE will be used for control"]
509pub struct PF0_FFE_SEL_W<'a> {
510    w: &'a mut W,
511}
512impl<'a> PF0_FFE_SEL_W<'a> {
513    #[doc = r"Writes `variant` to the field"]
514    #[inline(always)]
515    pub fn variant(self, variant: PF0_FFE_SEL_A) -> &'a mut W {
516        self.bit(variant.into())
517    }
518    #[doc = "when FFE is the controller of the FIFO, select FFE0 as the controller"]
519    #[inline(always)]
520    pub fn ffe0(self) -> &'a mut W {
521        self.variant(PF0_FFE_SEL_A::FFE0)
522    }
523    #[doc = "when FFE is the controller of the FIFO, select FFE1 as the controller"]
524    #[inline(always)]
525    pub fn ffe1(self) -> &'a mut W {
526        self.variant(PF0_FFE_SEL_A::FFE1)
527    }
528    #[doc = r"Sets the field bit"]
529    #[inline(always)]
530    pub fn set_bit(self) -> &'a mut W {
531        self.bit(true)
532    }
533    #[doc = r"Clears the field bit"]
534    #[inline(always)]
535    pub fn clear_bit(self) -> &'a mut W {
536        self.bit(false)
537    }
538    #[doc = r"Writes raw bits to the field"]
539    #[inline(always)]
540    pub fn bit(self, value: bool) -> &'a mut W {
541        self.w.bits =
542            (self.w.bits & !(0x01 << 5)) | ((value as u32 & 0x01) << 5);
543        self.w
544    }
545}
546#[doc = "Set to enable the Packet FIFO"]
547pub type PF1_EN_A = PF0_EN_A;
548#[doc = "Field `pf1_en` reader - Set to enable the Packet FIFO"]
549pub type PF1_EN_R = PF0_EN_R;
550#[doc = "Field `pf1_en` writer - Set to enable the Packet FIFO"]
551pub struct PF1_EN_W<'a> {
552    w: &'a mut W,
553}
554impl<'a> PF1_EN_W<'a> {
555    #[doc = r"Writes `variant` to the field"]
556    #[inline(always)]
557    pub fn variant(self, variant: PF1_EN_A) -> &'a mut W {
558        self.bit(variant.into())
559    }
560    #[doc = "Disable the packet FIFO"]
561    #[inline(always)]
562    pub fn disable(self) -> &'a mut W {
563        self.variant(PF1_EN_A::DISABLE)
564    }
565    #[doc = "Enable the packet FIFO"]
566    #[inline(always)]
567    pub fn enable(self) -> &'a mut W {
568        self.variant(PF1_EN_A::ENABLE)
569    }
570    #[doc = r"Sets the field bit"]
571    #[inline(always)]
572    pub fn set_bit(self) -> &'a mut W {
573        self.bit(true)
574    }
575    #[doc = r"Clears the field bit"]
576    #[inline(always)]
577    pub fn clear_bit(self) -> &'a mut W {
578        self.bit(false)
579    }
580    #[doc = r"Writes raw bits to the field"]
581    #[inline(always)]
582    pub fn bit(self, value: bool) -> &'a mut W {
583        self.w.bits =
584            (self.w.bits & !(0x01 << 8)) | ((value as u32 & 0x01) << 8);
585        self.w
586    }
587}
588#[doc = "Select which subsystem controls the push operation"]
589pub type PF1_PUSH_MUX_A = PF0_PUSH_MUX_A;
590#[doc = "Field `pf1_push_mux` reader - Select which subsystem controls the push operation"]
591pub type PF1_PUSH_MUX_R = PF0_PUSH_MUX_R;
592#[doc = "Field `pf1_push_mux` writer - Select which subsystem controls the push operation"]
593pub struct PF1_PUSH_MUX_W<'a> {
594    w: &'a mut W,
595}
596impl<'a> PF1_PUSH_MUX_W<'a> {
597    #[doc = r"Writes `variant` to the field"]
598    #[inline(always)]
599    pub fn variant(self, variant: PF1_PUSH_MUX_A) -> &'a mut W {
600        self.bit(variant.into())
601    }
602    #[doc = "Select the M4 subsystem to control the FIFO"]
603    #[inline(always)]
604    pub fn m4(self) -> &'a mut W {
605        self.variant(PF1_PUSH_MUX_A::M4)
606    }
607    #[doc = "Select the FFE subsystem to control the FIFO"]
608    #[inline(always)]
609    pub fn ffe(self) -> &'a mut W {
610        self.variant(PF1_PUSH_MUX_A::FFE)
611    }
612    #[doc = r"Sets the field bit"]
613    #[inline(always)]
614    pub fn set_bit(self) -> &'a mut W {
615        self.bit(true)
616    }
617    #[doc = r"Clears the field bit"]
618    #[inline(always)]
619    pub fn clear_bit(self) -> &'a mut W {
620        self.bit(false)
621    }
622    #[doc = r"Writes raw bits to the field"]
623    #[inline(always)]
624    pub fn bit(self, value: bool) -> &'a mut W {
625        self.w.bits =
626            (self.w.bits & !(0x01 << 9)) | ((value as u32 & 0x01) << 9);
627        self.w
628    }
629}
630#[doc = "Select which subsystem controls the pop operation"]
631pub type PF1_POP_MUX_A = PF0_POP_MUX_A;
632#[doc = "Field `pf1_pop_mux` reader - Select which subsystem controls the pop operation"]
633pub type PF1_POP_MUX_R = PF0_POP_MUX_R;
634#[doc = "Field `pf1_pop_mux` writer - Select which subsystem controls the pop operation"]
635pub struct PF1_POP_MUX_W<'a> {
636    w: &'a mut W,
637}
638impl<'a> PF1_POP_MUX_W<'a> {
639    #[doc = r"Writes `variant` to the field"]
640    #[inline(always)]
641    pub fn variant(self, variant: PF1_POP_MUX_A) -> &'a mut W {
642        self.bit(variant.into())
643    }
644    #[doc = "Select the M4 subsystem to control the FIFO"]
645    #[inline(always)]
646    pub fn m4(self) -> &'a mut W {
647        self.variant(PF1_POP_MUX_A::M4)
648    }
649    #[doc = "Select the AP subsystem to control the FIFO"]
650    #[inline(always)]
651    pub fn ap(self) -> &'a mut W {
652        self.variant(PF1_POP_MUX_A::AP)
653    }
654    #[doc = r"Sets the field bit"]
655    #[inline(always)]
656    pub fn set_bit(self) -> &'a mut W {
657        self.bit(true)
658    }
659    #[doc = r"Clears the field bit"]
660    #[inline(always)]
661    pub fn clear_bit(self) -> &'a mut W {
662        self.bit(false)
663    }
664    #[doc = r"Writes raw bits to the field"]
665    #[inline(always)]
666    pub fn bit(self, value: bool) -> &'a mut W {
667        self.w.bits =
668            (self.w.bits & !(0x01 << 10)) | ((value as u32 & 0x01) << 10);
669        self.w
670    }
671}
672#[doc = "Select which subsystem manages the push interrupt"]
673pub type PF1_PUSH_INT_MUX_A = PF0_PUSH_INT_MUX_A;
674#[doc = "Field `pf1_push_int_mux` reader - Select which subsystem manages the push interrupt"]
675pub type PF1_PUSH_INT_MUX_R = PF0_PUSH_INT_MUX_R;
676#[doc = "Field `pf1_push_int_mux` writer - Select which subsystem manages the push interrupt"]
677pub struct PF1_PUSH_INT_MUX_W<'a> {
678    w: &'a mut W,
679}
680impl<'a> PF1_PUSH_INT_MUX_W<'a> {
681    #[doc = r"Writes `variant` to the field"]
682    #[inline(always)]
683    pub fn variant(self, variant: PF1_PUSH_INT_MUX_A) -> &'a mut W {
684        self.bit(variant.into())
685    }
686    #[doc = "Select the M4 subsystem to control the FIFO"]
687    #[inline(always)]
688    pub fn m4(self) -> &'a mut W {
689        self.variant(PF1_PUSH_INT_MUX_A::M4)
690    }
691    #[doc = "Select the AP subsystem to control the FIFO"]
692    #[inline(always)]
693    pub fn ap(self) -> &'a mut W {
694        self.variant(PF1_PUSH_INT_MUX_A::AP)
695    }
696    #[doc = r"Sets the field bit"]
697    #[inline(always)]
698    pub fn set_bit(self) -> &'a mut W {
699        self.bit(true)
700    }
701    #[doc = r"Clears the field bit"]
702    #[inline(always)]
703    pub fn clear_bit(self) -> &'a mut W {
704        self.bit(false)
705    }
706    #[doc = r"Writes raw bits to the field"]
707    #[inline(always)]
708    pub fn bit(self, value: bool) -> &'a mut W {
709        self.w.bits =
710            (self.w.bits & !(0x01 << 11)) | ((value as u32 & 0x01) << 11);
711        self.w
712    }
713}
714#[doc = "Select which subsystem manages the pop interrupt"]
715pub type PF1_POP_INT_MUX_A = PF0_POP_INT_MUX_A;
716#[doc = "Field `pf1_pop_int_mux` reader - Select which subsystem manages the pop interrupt"]
717pub type PF1_POP_INT_MUX_R = PF0_POP_INT_MUX_R;
718#[doc = "Field `pf1_pop_int_mux` writer - Select which subsystem manages the pop interrupt"]
719pub struct PF1_POP_INT_MUX_W<'a> {
720    w: &'a mut W,
721}
722impl<'a> PF1_POP_INT_MUX_W<'a> {
723    #[doc = r"Writes `variant` to the field"]
724    #[inline(always)]
725    pub fn variant(self, variant: PF1_POP_INT_MUX_A) -> &'a mut W {
726        self.bit(variant.into())
727    }
728    #[doc = "Select the M4 subsystem to control the FIFO"]
729    #[inline(always)]
730    pub fn m4(self) -> &'a mut W {
731        self.variant(PF1_POP_INT_MUX_A::M4)
732    }
733    #[doc = "Select the AP subsystem to control the FIFO"]
734    #[inline(always)]
735    pub fn ap(self) -> &'a mut W {
736        self.variant(PF1_POP_INT_MUX_A::AP)
737    }
738    #[doc = r"Sets the field bit"]
739    #[inline(always)]
740    pub fn set_bit(self) -> &'a mut W {
741        self.bit(true)
742    }
743    #[doc = r"Clears the field bit"]
744    #[inline(always)]
745    pub fn clear_bit(self) -> &'a mut W {
746        self.bit(false)
747    }
748    #[doc = r"Writes raw bits to the field"]
749    #[inline(always)]
750    pub fn bit(self, value: bool) -> &'a mut W {
751        self.w.bits =
752            (self.w.bits & !(0x01 << 12)) | ((value as u32 & 0x01) << 12);
753        self.w
754    }
755}
756#[doc = "If FFE is the controller, select which instance of FFE will be used for control"]
757pub type PF1_FFE_SEL_A = PF0_FFE_SEL_A;
758#[doc = "Field `pf1_ffe_sel` reader - If FFE is the controller, select which instance of FFE will be used for control"]
759pub type PF1_FFE_SEL_R = PF0_FFE_SEL_R;
760#[doc = "Field `pf1_ffe_sel` writer - If FFE is the controller, select which instance of FFE will be used for control"]
761pub struct PF1_FFE_SEL_W<'a> {
762    w: &'a mut W,
763}
764impl<'a> PF1_FFE_SEL_W<'a> {
765    #[doc = r"Writes `variant` to the field"]
766    #[inline(always)]
767    pub fn variant(self, variant: PF1_FFE_SEL_A) -> &'a mut W {
768        self.bit(variant.into())
769    }
770    #[doc = "when FFE is the controller of the FIFO, select FFE0 as the controller"]
771    #[inline(always)]
772    pub fn ffe0(self) -> &'a mut W {
773        self.variant(PF1_FFE_SEL_A::FFE0)
774    }
775    #[doc = "when FFE is the controller of the FIFO, select FFE1 as the controller"]
776    #[inline(always)]
777    pub fn ffe1(self) -> &'a mut W {
778        self.variant(PF1_FFE_SEL_A::FFE1)
779    }
780    #[doc = r"Sets the field bit"]
781    #[inline(always)]
782    pub fn set_bit(self) -> &'a mut W {
783        self.bit(true)
784    }
785    #[doc = r"Clears the field bit"]
786    #[inline(always)]
787    pub fn clear_bit(self) -> &'a mut W {
788        self.bit(false)
789    }
790    #[doc = r"Writes raw bits to the field"]
791    #[inline(always)]
792    pub fn bit(self, value: bool) -> &'a mut W {
793        self.w.bits =
794            (self.w.bits & !(0x01 << 13)) | ((value as u32 & 0x01) << 13);
795        self.w
796    }
797}
798#[doc = "Set to enable the Packet FIFO"]
799pub type PF2_EN_A = PF0_EN_A;
800#[doc = "Field `pf2_en` reader - Set to enable the Packet FIFO"]
801pub type PF2_EN_R = PF0_EN_R;
802#[doc = "Field `pf2_en` writer - Set to enable the Packet FIFO"]
803pub struct PF2_EN_W<'a> {
804    w: &'a mut W,
805}
806impl<'a> PF2_EN_W<'a> {
807    #[doc = r"Writes `variant` to the field"]
808    #[inline(always)]
809    pub fn variant(self, variant: PF2_EN_A) -> &'a mut W {
810        self.bit(variant.into())
811    }
812    #[doc = "Disable the packet FIFO"]
813    #[inline(always)]
814    pub fn disable(self) -> &'a mut W {
815        self.variant(PF2_EN_A::DISABLE)
816    }
817    #[doc = "Enable the packet FIFO"]
818    #[inline(always)]
819    pub fn enable(self) -> &'a mut W {
820        self.variant(PF2_EN_A::ENABLE)
821    }
822    #[doc = r"Sets the field bit"]
823    #[inline(always)]
824    pub fn set_bit(self) -> &'a mut W {
825        self.bit(true)
826    }
827    #[doc = r"Clears the field bit"]
828    #[inline(always)]
829    pub fn clear_bit(self) -> &'a mut W {
830        self.bit(false)
831    }
832    #[doc = r"Writes raw bits to the field"]
833    #[inline(always)]
834    pub fn bit(self, value: bool) -> &'a mut W {
835        self.w.bits =
836            (self.w.bits & !(0x01 << 16)) | ((value as u32 & 0x01) << 16);
837        self.w
838    }
839}
840#[doc = "Select which subsystem controls the push operation"]
841pub type PF2_PUSH_MUX_A = PF0_PUSH_MUX_A;
842#[doc = "Field `pf2_push_mux` reader - Select which subsystem controls the push operation"]
843pub type PF2_PUSH_MUX_R = PF0_PUSH_MUX_R;
844#[doc = "Field `pf2_push_mux` writer - Select which subsystem controls the push operation"]
845pub struct PF2_PUSH_MUX_W<'a> {
846    w: &'a mut W,
847}
848impl<'a> PF2_PUSH_MUX_W<'a> {
849    #[doc = r"Writes `variant` to the field"]
850    #[inline(always)]
851    pub fn variant(self, variant: PF2_PUSH_MUX_A) -> &'a mut W {
852        self.bit(variant.into())
853    }
854    #[doc = "Select the M4 subsystem to control the FIFO"]
855    #[inline(always)]
856    pub fn m4(self) -> &'a mut W {
857        self.variant(PF2_PUSH_MUX_A::M4)
858    }
859    #[doc = "Select the FFE subsystem to control the FIFO"]
860    #[inline(always)]
861    pub fn ffe(self) -> &'a mut W {
862        self.variant(PF2_PUSH_MUX_A::FFE)
863    }
864    #[doc = r"Sets the field bit"]
865    #[inline(always)]
866    pub fn set_bit(self) -> &'a mut W {
867        self.bit(true)
868    }
869    #[doc = r"Clears the field bit"]
870    #[inline(always)]
871    pub fn clear_bit(self) -> &'a mut W {
872        self.bit(false)
873    }
874    #[doc = r"Writes raw bits to the field"]
875    #[inline(always)]
876    pub fn bit(self, value: bool) -> &'a mut W {
877        self.w.bits =
878            (self.w.bits & !(0x01 << 17)) | ((value as u32 & 0x01) << 17);
879        self.w
880    }
881}
882#[doc = "Select which subsystem controls the pop operation"]
883pub type PF2_POP_MUX_A = PF0_POP_MUX_A;
884#[doc = "Field `pf2_pop_mux` reader - Select which subsystem controls the pop operation"]
885pub type PF2_POP_MUX_R = PF0_POP_MUX_R;
886#[doc = "Field `pf2_pop_mux` writer - Select which subsystem controls the pop operation"]
887pub struct PF2_POP_MUX_W<'a> {
888    w: &'a mut W,
889}
890impl<'a> PF2_POP_MUX_W<'a> {
891    #[doc = r"Writes `variant` to the field"]
892    #[inline(always)]
893    pub fn variant(self, variant: PF2_POP_MUX_A) -> &'a mut W {
894        self.bit(variant.into())
895    }
896    #[doc = "Select the M4 subsystem to control the FIFO"]
897    #[inline(always)]
898    pub fn m4(self) -> &'a mut W {
899        self.variant(PF2_POP_MUX_A::M4)
900    }
901    #[doc = "Select the AP subsystem to control the FIFO"]
902    #[inline(always)]
903    pub fn ap(self) -> &'a mut W {
904        self.variant(PF2_POP_MUX_A::AP)
905    }
906    #[doc = r"Sets the field bit"]
907    #[inline(always)]
908    pub fn set_bit(self) -> &'a mut W {
909        self.bit(true)
910    }
911    #[doc = r"Clears the field bit"]
912    #[inline(always)]
913    pub fn clear_bit(self) -> &'a mut W {
914        self.bit(false)
915    }
916    #[doc = r"Writes raw bits to the field"]
917    #[inline(always)]
918    pub fn bit(self, value: bool) -> &'a mut W {
919        self.w.bits =
920            (self.w.bits & !(0x01 << 18)) | ((value as u32 & 0x01) << 18);
921        self.w
922    }
923}
924#[doc = "Select which subsystem manages the push interrupt"]
925pub type PF2_PUSH_INT_MUX_A = PF0_PUSH_INT_MUX_A;
926#[doc = "Field `pf2_push_int_mux` reader - Select which subsystem manages the push interrupt"]
927pub type PF2_PUSH_INT_MUX_R = PF0_PUSH_INT_MUX_R;
928#[doc = "Field `pf2_push_int_mux` writer - Select which subsystem manages the push interrupt"]
929pub struct PF2_PUSH_INT_MUX_W<'a> {
930    w: &'a mut W,
931}
932impl<'a> PF2_PUSH_INT_MUX_W<'a> {
933    #[doc = r"Writes `variant` to the field"]
934    #[inline(always)]
935    pub fn variant(self, variant: PF2_PUSH_INT_MUX_A) -> &'a mut W {
936        self.bit(variant.into())
937    }
938    #[doc = "Select the M4 subsystem to control the FIFO"]
939    #[inline(always)]
940    pub fn m4(self) -> &'a mut W {
941        self.variant(PF2_PUSH_INT_MUX_A::M4)
942    }
943    #[doc = "Select the AP subsystem to control the FIFO"]
944    #[inline(always)]
945    pub fn ap(self) -> &'a mut W {
946        self.variant(PF2_PUSH_INT_MUX_A::AP)
947    }
948    #[doc = r"Sets the field bit"]
949    #[inline(always)]
950    pub fn set_bit(self) -> &'a mut W {
951        self.bit(true)
952    }
953    #[doc = r"Clears the field bit"]
954    #[inline(always)]
955    pub fn clear_bit(self) -> &'a mut W {
956        self.bit(false)
957    }
958    #[doc = r"Writes raw bits to the field"]
959    #[inline(always)]
960    pub fn bit(self, value: bool) -> &'a mut W {
961        self.w.bits =
962            (self.w.bits & !(0x01 << 19)) | ((value as u32 & 0x01) << 19);
963        self.w
964    }
965}
966#[doc = "Select which subsystem manages the pop interrupt"]
967pub type PF2_POP_INT_MUX_A = PF0_POP_INT_MUX_A;
968#[doc = "Field `pf2_pop_int_mux` reader - Select which subsystem manages the pop interrupt"]
969pub type PF2_POP_INT_MUX_R = PF0_POP_INT_MUX_R;
970#[doc = "Field `pf2_pop_int_mux` writer - Select which subsystem manages the pop interrupt"]
971pub struct PF2_POP_INT_MUX_W<'a> {
972    w: &'a mut W,
973}
974impl<'a> PF2_POP_INT_MUX_W<'a> {
975    #[doc = r"Writes `variant` to the field"]
976    #[inline(always)]
977    pub fn variant(self, variant: PF2_POP_INT_MUX_A) -> &'a mut W {
978        self.bit(variant.into())
979    }
980    #[doc = "Select the M4 subsystem to control the FIFO"]
981    #[inline(always)]
982    pub fn m4(self) -> &'a mut W {
983        self.variant(PF2_POP_INT_MUX_A::M4)
984    }
985    #[doc = "Select the AP subsystem to control the FIFO"]
986    #[inline(always)]
987    pub fn ap(self) -> &'a mut W {
988        self.variant(PF2_POP_INT_MUX_A::AP)
989    }
990    #[doc = r"Sets the field bit"]
991    #[inline(always)]
992    pub fn set_bit(self) -> &'a mut W {
993        self.bit(true)
994    }
995    #[doc = r"Clears the field bit"]
996    #[inline(always)]
997    pub fn clear_bit(self) -> &'a mut W {
998        self.bit(false)
999    }
1000    #[doc = r"Writes raw bits to the field"]
1001    #[inline(always)]
1002    pub fn bit(self, value: bool) -> &'a mut W {
1003        self.w.bits =
1004            (self.w.bits & !(0x01 << 20)) | ((value as u32 & 0x01) << 20);
1005        self.w
1006    }
1007}
1008#[doc = "If FFE is the controller, select which instance of FFE will be used for control"]
1009pub type PF2_FFE_SEL_A = PF0_FFE_SEL_A;
1010#[doc = "Field `pf2_ffe_sel` reader - If FFE is the controller, select which instance of FFE will be used for control"]
1011pub type PF2_FFE_SEL_R = PF0_FFE_SEL_R;
1012#[doc = "Field `pf2_ffe_sel` writer - If FFE is the controller, select which instance of FFE will be used for control"]
1013pub struct PF2_FFE_SEL_W<'a> {
1014    w: &'a mut W,
1015}
1016impl<'a> PF2_FFE_SEL_W<'a> {
1017    #[doc = r"Writes `variant` to the field"]
1018    #[inline(always)]
1019    pub fn variant(self, variant: PF2_FFE_SEL_A) -> &'a mut W {
1020        self.bit(variant.into())
1021    }
1022    #[doc = "when FFE is the controller of the FIFO, select FFE0 as the controller"]
1023    #[inline(always)]
1024    pub fn ffe0(self) -> &'a mut W {
1025        self.variant(PF2_FFE_SEL_A::FFE0)
1026    }
1027    #[doc = "when FFE is the controller of the FIFO, select FFE1 as the controller"]
1028    #[inline(always)]
1029    pub fn ffe1(self) -> &'a mut W {
1030        self.variant(PF2_FFE_SEL_A::FFE1)
1031    }
1032    #[doc = r"Sets the field bit"]
1033    #[inline(always)]
1034    pub fn set_bit(self) -> &'a mut W {
1035        self.bit(true)
1036    }
1037    #[doc = r"Clears the field bit"]
1038    #[inline(always)]
1039    pub fn clear_bit(self) -> &'a mut W {
1040        self.bit(false)
1041    }
1042    #[doc = r"Writes raw bits to the field"]
1043    #[inline(always)]
1044    pub fn bit(self, value: bool) -> &'a mut W {
1045        self.w.bits =
1046            (self.w.bits & !(0x01 << 21)) | ((value as u32 & 0x01) << 21);
1047        self.w
1048    }
1049}
1050#[doc = "Set to enable the Packet FIFO"]
1051pub type PF8K_EN_A = PF0_EN_A;
1052#[doc = "Field `pf8k_en` reader - Set to enable the Packet FIFO"]
1053pub type PF8K_EN_R = PF0_EN_R;
1054#[doc = "Field `pf8k_en` writer - Set to enable the Packet FIFO"]
1055pub struct PF8K_EN_W<'a> {
1056    w: &'a mut W,
1057}
1058impl<'a> PF8K_EN_W<'a> {
1059    #[doc = r"Writes `variant` to the field"]
1060    #[inline(always)]
1061    pub fn variant(self, variant: PF8K_EN_A) -> &'a mut W {
1062        self.bit(variant.into())
1063    }
1064    #[doc = "Disable the packet FIFO"]
1065    #[inline(always)]
1066    pub fn disable(self) -> &'a mut W {
1067        self.variant(PF8K_EN_A::DISABLE)
1068    }
1069    #[doc = "Enable the packet FIFO"]
1070    #[inline(always)]
1071    pub fn enable(self) -> &'a mut W {
1072        self.variant(PF8K_EN_A::ENABLE)
1073    }
1074    #[doc = r"Sets the field bit"]
1075    #[inline(always)]
1076    pub fn set_bit(self) -> &'a mut W {
1077        self.bit(true)
1078    }
1079    #[doc = r"Clears the field bit"]
1080    #[inline(always)]
1081    pub fn clear_bit(self) -> &'a mut W {
1082        self.bit(false)
1083    }
1084    #[doc = r"Writes raw bits to the field"]
1085    #[inline(always)]
1086    pub fn bit(self, value: bool) -> &'a mut W {
1087        self.w.bits =
1088            (self.w.bits & !(0x01 << 24)) | ((value as u32 & 0x01) << 24);
1089        self.w
1090    }
1091}
1092#[doc = "Select which subsystem controls the push operation"]
1093pub type PF8K_PUSH_MUX_A = PF0_PUSH_MUX_A;
1094#[doc = "Field `pf8k_push_mux` reader - Select which subsystem controls the push operation"]
1095pub type PF8K_PUSH_MUX_R = PF0_PUSH_MUX_R;
1096#[doc = "Field `pf8k_push_mux` writer - Select which subsystem controls the push operation"]
1097pub struct PF8K_PUSH_MUX_W<'a> {
1098    w: &'a mut W,
1099}
1100impl<'a> PF8K_PUSH_MUX_W<'a> {
1101    #[doc = r"Writes `variant` to the field"]
1102    #[inline(always)]
1103    pub fn variant(self, variant: PF8K_PUSH_MUX_A) -> &'a mut W {
1104        self.bit(variant.into())
1105    }
1106    #[doc = "Select the M4 subsystem to control the FIFO"]
1107    #[inline(always)]
1108    pub fn m4(self) -> &'a mut W {
1109        self.variant(PF8K_PUSH_MUX_A::M4)
1110    }
1111    #[doc = "Select the FFE subsystem to control the FIFO"]
1112    #[inline(always)]
1113    pub fn ffe(self) -> &'a mut W {
1114        self.variant(PF8K_PUSH_MUX_A::FFE)
1115    }
1116    #[doc = r"Sets the field bit"]
1117    #[inline(always)]
1118    pub fn set_bit(self) -> &'a mut W {
1119        self.bit(true)
1120    }
1121    #[doc = r"Clears the field bit"]
1122    #[inline(always)]
1123    pub fn clear_bit(self) -> &'a mut W {
1124        self.bit(false)
1125    }
1126    #[doc = r"Writes raw bits to the field"]
1127    #[inline(always)]
1128    pub fn bit(self, value: bool) -> &'a mut W {
1129        self.w.bits =
1130            (self.w.bits & !(0x01 << 25)) | ((value as u32 & 0x01) << 25);
1131        self.w
1132    }
1133}
1134#[doc = "Select which subsystem controls the pop operation"]
1135pub type PF8K_POP_MUX_A = PF0_POP_MUX_A;
1136#[doc = "Field `pf8k_pop_mux` reader - Select which subsystem controls the pop operation"]
1137pub type PF8K_POP_MUX_R = PF0_POP_MUX_R;
1138#[doc = "Field `pf8k_pop_mux` writer - Select which subsystem controls the pop operation"]
1139pub struct PF8K_POP_MUX_W<'a> {
1140    w: &'a mut W,
1141}
1142impl<'a> PF8K_POP_MUX_W<'a> {
1143    #[doc = r"Writes `variant` to the field"]
1144    #[inline(always)]
1145    pub fn variant(self, variant: PF8K_POP_MUX_A) -> &'a mut W {
1146        self.bit(variant.into())
1147    }
1148    #[doc = "Select the M4 subsystem to control the FIFO"]
1149    #[inline(always)]
1150    pub fn m4(self) -> &'a mut W {
1151        self.variant(PF8K_POP_MUX_A::M4)
1152    }
1153    #[doc = "Select the AP subsystem to control the FIFO"]
1154    #[inline(always)]
1155    pub fn ap(self) -> &'a mut W {
1156        self.variant(PF8K_POP_MUX_A::AP)
1157    }
1158    #[doc = r"Sets the field bit"]
1159    #[inline(always)]
1160    pub fn set_bit(self) -> &'a mut W {
1161        self.bit(true)
1162    }
1163    #[doc = r"Clears the field bit"]
1164    #[inline(always)]
1165    pub fn clear_bit(self) -> &'a mut W {
1166        self.bit(false)
1167    }
1168    #[doc = r"Writes raw bits to the field"]
1169    #[inline(always)]
1170    pub fn bit(self, value: bool) -> &'a mut W {
1171        self.w.bits =
1172            (self.w.bits & !(0x01 << 26)) | ((value as u32 & 0x01) << 26);
1173        self.w
1174    }
1175}
1176#[doc = "Select which subsystem manages the push interrupt"]
1177pub type PF8K_PUSH_INT_MUX_A = PF0_PUSH_INT_MUX_A;
1178#[doc = "Field `pf8k_push_int_mux` reader - Select which subsystem manages the push interrupt"]
1179pub type PF8K_PUSH_INT_MUX_R = PF0_PUSH_INT_MUX_R;
1180#[doc = "Field `pf8k_push_int_mux` writer - Select which subsystem manages the push interrupt"]
1181pub struct PF8K_PUSH_INT_MUX_W<'a> {
1182    w: &'a mut W,
1183}
1184impl<'a> PF8K_PUSH_INT_MUX_W<'a> {
1185    #[doc = r"Writes `variant` to the field"]
1186    #[inline(always)]
1187    pub fn variant(self, variant: PF8K_PUSH_INT_MUX_A) -> &'a mut W {
1188        self.bit(variant.into())
1189    }
1190    #[doc = "Select the M4 subsystem to control the FIFO"]
1191    #[inline(always)]
1192    pub fn m4(self) -> &'a mut W {
1193        self.variant(PF8K_PUSH_INT_MUX_A::M4)
1194    }
1195    #[doc = "Select the AP subsystem to control the FIFO"]
1196    #[inline(always)]
1197    pub fn ap(self) -> &'a mut W {
1198        self.variant(PF8K_PUSH_INT_MUX_A::AP)
1199    }
1200    #[doc = r"Sets the field bit"]
1201    #[inline(always)]
1202    pub fn set_bit(self) -> &'a mut W {
1203        self.bit(true)
1204    }
1205    #[doc = r"Clears the field bit"]
1206    #[inline(always)]
1207    pub fn clear_bit(self) -> &'a mut W {
1208        self.bit(false)
1209    }
1210    #[doc = r"Writes raw bits to the field"]
1211    #[inline(always)]
1212    pub fn bit(self, value: bool) -> &'a mut W {
1213        self.w.bits =
1214            (self.w.bits & !(0x01 << 27)) | ((value as u32 & 0x01) << 27);
1215        self.w
1216    }
1217}
1218#[doc = "Select which subsystem manages the pop interrupt"]
1219pub type PF8K_POP_INT_MUX_A = PF0_POP_INT_MUX_A;
1220#[doc = "Field `pf8k_pop_int_mux` reader - Select which subsystem manages the pop interrupt"]
1221pub type PF8K_POP_INT_MUX_R = PF0_POP_INT_MUX_R;
1222#[doc = "Field `pf8k_pop_int_mux` writer - Select which subsystem manages the pop interrupt"]
1223pub struct PF8K_POP_INT_MUX_W<'a> {
1224    w: &'a mut W,
1225}
1226impl<'a> PF8K_POP_INT_MUX_W<'a> {
1227    #[doc = r"Writes `variant` to the field"]
1228    #[inline(always)]
1229    pub fn variant(self, variant: PF8K_POP_INT_MUX_A) -> &'a mut W {
1230        self.bit(variant.into())
1231    }
1232    #[doc = "Select the M4 subsystem to control the FIFO"]
1233    #[inline(always)]
1234    pub fn m4(self) -> &'a mut W {
1235        self.variant(PF8K_POP_INT_MUX_A::M4)
1236    }
1237    #[doc = "Select the AP subsystem to control the FIFO"]
1238    #[inline(always)]
1239    pub fn ap(self) -> &'a mut W {
1240        self.variant(PF8K_POP_INT_MUX_A::AP)
1241    }
1242    #[doc = r"Sets the field bit"]
1243    #[inline(always)]
1244    pub fn set_bit(self) -> &'a mut W {
1245        self.bit(true)
1246    }
1247    #[doc = r"Clears the field bit"]
1248    #[inline(always)]
1249    pub fn clear_bit(self) -> &'a mut W {
1250        self.bit(false)
1251    }
1252    #[doc = r"Writes raw bits to the field"]
1253    #[inline(always)]
1254    pub fn bit(self, value: bool) -> &'a mut W {
1255        self.w.bits =
1256            (self.w.bits & !(0x01 << 28)) | ((value as u32 & 0x01) << 28);
1257        self.w
1258    }
1259}
1260#[doc = "If FFE is the controller, select which instance of FFE will be used for control"]
1261pub type PF8K_FFE_SEL_A = PF0_FFE_SEL_A;
1262#[doc = "Field `pf8k_ffe_sel` reader - If FFE is the controller, select which instance of FFE will be used for control"]
1263pub type PF8K_FFE_SEL_R = PF0_FFE_SEL_R;
1264#[doc = "Field `pf8k_ffe_sel` writer - If FFE is the controller, select which instance of FFE will be used for control"]
1265pub struct PF8K_FFE_SEL_W<'a> {
1266    w: &'a mut W,
1267}
1268impl<'a> PF8K_FFE_SEL_W<'a> {
1269    #[doc = r"Writes `variant` to the field"]
1270    #[inline(always)]
1271    pub fn variant(self, variant: PF8K_FFE_SEL_A) -> &'a mut W {
1272        self.bit(variant.into())
1273    }
1274    #[doc = "when FFE is the controller of the FIFO, select FFE0 as the controller"]
1275    #[inline(always)]
1276    pub fn ffe0(self) -> &'a mut W {
1277        self.variant(PF8K_FFE_SEL_A::FFE0)
1278    }
1279    #[doc = "when FFE is the controller of the FIFO, select FFE1 as the controller"]
1280    #[inline(always)]
1281    pub fn ffe1(self) -> &'a mut W {
1282        self.variant(PF8K_FFE_SEL_A::FFE1)
1283    }
1284    #[doc = r"Sets the field bit"]
1285    #[inline(always)]
1286    pub fn set_bit(self) -> &'a mut W {
1287        self.bit(true)
1288    }
1289    #[doc = r"Clears the field bit"]
1290    #[inline(always)]
1291    pub fn clear_bit(self) -> &'a mut W {
1292        self.bit(false)
1293    }
1294    #[doc = r"Writes raw bits to the field"]
1295    #[inline(always)]
1296    pub fn bit(self, value: bool) -> &'a mut W {
1297        self.w.bits =
1298            (self.w.bits & !(0x01 << 29)) | ((value as u32 & 0x01) << 29);
1299        self.w
1300    }
1301}
1302impl R {
1303    #[doc = "Bit 0 - Set to enable the Packet FIFO"]
1304    #[inline(always)]
1305    pub fn pf0_en(&self) -> PF0_EN_R {
1306        PF0_EN_R::new((self.bits & 0x01) != 0)
1307    }
1308    #[doc = "Bit 1 - Select which subsystem controls the push operation"]
1309    #[inline(always)]
1310    pub fn pf0_push_mux(&self) -> PF0_PUSH_MUX_R {
1311        PF0_PUSH_MUX_R::new(((self.bits >> 1) & 0x01) != 0)
1312    }
1313    #[doc = "Bit 2 - Select which subsystem controls the pop operation"]
1314    #[inline(always)]
1315    pub fn pf0_pop_mux(&self) -> PF0_POP_MUX_R {
1316        PF0_POP_MUX_R::new(((self.bits >> 2) & 0x01) != 0)
1317    }
1318    #[doc = "Bit 3 - Select which subsystem manages the push interrupt"]
1319    #[inline(always)]
1320    pub fn pf0_push_int_mux(&self) -> PF0_PUSH_INT_MUX_R {
1321        PF0_PUSH_INT_MUX_R::new(((self.bits >> 3) & 0x01) != 0)
1322    }
1323    #[doc = "Bit 4 - Select which subsystem manages the pop interrupt"]
1324    #[inline(always)]
1325    pub fn pf0_pop_int_mux(&self) -> PF0_POP_INT_MUX_R {
1326        PF0_POP_INT_MUX_R::new(((self.bits >> 4) & 0x01) != 0)
1327    }
1328    #[doc = "Bit 5 - If FFE is the controller, select which instance of FFE will be used for control"]
1329    #[inline(always)]
1330    pub fn pf0_ffe_sel(&self) -> PF0_FFE_SEL_R {
1331        PF0_FFE_SEL_R::new(((self.bits >> 5) & 0x01) != 0)
1332    }
1333    #[doc = "Bit 8 - Set to enable the Packet FIFO"]
1334    #[inline(always)]
1335    pub fn pf1_en(&self) -> PF1_EN_R {
1336        PF1_EN_R::new(((self.bits >> 8) & 0x01) != 0)
1337    }
1338    #[doc = "Bit 9 - Select which subsystem controls the push operation"]
1339    #[inline(always)]
1340    pub fn pf1_push_mux(&self) -> PF1_PUSH_MUX_R {
1341        PF1_PUSH_MUX_R::new(((self.bits >> 9) & 0x01) != 0)
1342    }
1343    #[doc = "Bit 10 - Select which subsystem controls the pop operation"]
1344    #[inline(always)]
1345    pub fn pf1_pop_mux(&self) -> PF1_POP_MUX_R {
1346        PF1_POP_MUX_R::new(((self.bits >> 10) & 0x01) != 0)
1347    }
1348    #[doc = "Bit 11 - Select which subsystem manages the push interrupt"]
1349    #[inline(always)]
1350    pub fn pf1_push_int_mux(&self) -> PF1_PUSH_INT_MUX_R {
1351        PF1_PUSH_INT_MUX_R::new(((self.bits >> 11) & 0x01) != 0)
1352    }
1353    #[doc = "Bit 12 - Select which subsystem manages the pop interrupt"]
1354    #[inline(always)]
1355    pub fn pf1_pop_int_mux(&self) -> PF1_POP_INT_MUX_R {
1356        PF1_POP_INT_MUX_R::new(((self.bits >> 12) & 0x01) != 0)
1357    }
1358    #[doc = "Bit 13 - If FFE is the controller, select which instance of FFE will be used for control"]
1359    #[inline(always)]
1360    pub fn pf1_ffe_sel(&self) -> PF1_FFE_SEL_R {
1361        PF1_FFE_SEL_R::new(((self.bits >> 13) & 0x01) != 0)
1362    }
1363    #[doc = "Bit 16 - Set to enable the Packet FIFO"]
1364    #[inline(always)]
1365    pub fn pf2_en(&self) -> PF2_EN_R {
1366        PF2_EN_R::new(((self.bits >> 16) & 0x01) != 0)
1367    }
1368    #[doc = "Bit 17 - Select which subsystem controls the push operation"]
1369    #[inline(always)]
1370    pub fn pf2_push_mux(&self) -> PF2_PUSH_MUX_R {
1371        PF2_PUSH_MUX_R::new(((self.bits >> 17) & 0x01) != 0)
1372    }
1373    #[doc = "Bit 18 - Select which subsystem controls the pop operation"]
1374    #[inline(always)]
1375    pub fn pf2_pop_mux(&self) -> PF2_POP_MUX_R {
1376        PF2_POP_MUX_R::new(((self.bits >> 18) & 0x01) != 0)
1377    }
1378    #[doc = "Bit 19 - Select which subsystem manages the push interrupt"]
1379    #[inline(always)]
1380    pub fn pf2_push_int_mux(&self) -> PF2_PUSH_INT_MUX_R {
1381        PF2_PUSH_INT_MUX_R::new(((self.bits >> 19) & 0x01) != 0)
1382    }
1383    #[doc = "Bit 20 - Select which subsystem manages the pop interrupt"]
1384    #[inline(always)]
1385    pub fn pf2_pop_int_mux(&self) -> PF2_POP_INT_MUX_R {
1386        PF2_POP_INT_MUX_R::new(((self.bits >> 20) & 0x01) != 0)
1387    }
1388    #[doc = "Bit 21 - If FFE is the controller, select which instance of FFE will be used for control"]
1389    #[inline(always)]
1390    pub fn pf2_ffe_sel(&self) -> PF2_FFE_SEL_R {
1391        PF2_FFE_SEL_R::new(((self.bits >> 21) & 0x01) != 0)
1392    }
1393    #[doc = "Bit 24 - Set to enable the Packet FIFO"]
1394    #[inline(always)]
1395    pub fn pf8k_en(&self) -> PF8K_EN_R {
1396        PF8K_EN_R::new(((self.bits >> 24) & 0x01) != 0)
1397    }
1398    #[doc = "Bit 25 - Select which subsystem controls the push operation"]
1399    #[inline(always)]
1400    pub fn pf8k_push_mux(&self) -> PF8K_PUSH_MUX_R {
1401        PF8K_PUSH_MUX_R::new(((self.bits >> 25) & 0x01) != 0)
1402    }
1403    #[doc = "Bit 26 - Select which subsystem controls the pop operation"]
1404    #[inline(always)]
1405    pub fn pf8k_pop_mux(&self) -> PF8K_POP_MUX_R {
1406        PF8K_POP_MUX_R::new(((self.bits >> 26) & 0x01) != 0)
1407    }
1408    #[doc = "Bit 27 - Select which subsystem manages the push interrupt"]
1409    #[inline(always)]
1410    pub fn pf8k_push_int_mux(&self) -> PF8K_PUSH_INT_MUX_R {
1411        PF8K_PUSH_INT_MUX_R::new(((self.bits >> 27) & 0x01) != 0)
1412    }
1413    #[doc = "Bit 28 - Select which subsystem manages the pop interrupt"]
1414    #[inline(always)]
1415    pub fn pf8k_pop_int_mux(&self) -> PF8K_POP_INT_MUX_R {
1416        PF8K_POP_INT_MUX_R::new(((self.bits >> 28) & 0x01) != 0)
1417    }
1418    #[doc = "Bit 29 - If FFE is the controller, select which instance of FFE will be used for control"]
1419    #[inline(always)]
1420    pub fn pf8k_ffe_sel(&self) -> PF8K_FFE_SEL_R {
1421        PF8K_FFE_SEL_R::new(((self.bits >> 29) & 0x01) != 0)
1422    }
1423}
1424impl W {
1425    #[doc = "Bit 0 - Set to enable the Packet FIFO"]
1426    #[inline(always)]
1427    pub fn pf0_en(&mut self) -> PF0_EN_W {
1428        PF0_EN_W { w: self }
1429    }
1430    #[doc = "Bit 1 - Select which subsystem controls the push operation"]
1431    #[inline(always)]
1432    pub fn pf0_push_mux(&mut self) -> PF0_PUSH_MUX_W {
1433        PF0_PUSH_MUX_W { w: self }
1434    }
1435    #[doc = "Bit 2 - Select which subsystem controls the pop operation"]
1436    #[inline(always)]
1437    pub fn pf0_pop_mux(&mut self) -> PF0_POP_MUX_W {
1438        PF0_POP_MUX_W { w: self }
1439    }
1440    #[doc = "Bit 3 - Select which subsystem manages the push interrupt"]
1441    #[inline(always)]
1442    pub fn pf0_push_int_mux(&mut self) -> PF0_PUSH_INT_MUX_W {
1443        PF0_PUSH_INT_MUX_W { w: self }
1444    }
1445    #[doc = "Bit 4 - Select which subsystem manages the pop interrupt"]
1446    #[inline(always)]
1447    pub fn pf0_pop_int_mux(&mut self) -> PF0_POP_INT_MUX_W {
1448        PF0_POP_INT_MUX_W { w: self }
1449    }
1450    #[doc = "Bit 5 - If FFE is the controller, select which instance of FFE will be used for control"]
1451    #[inline(always)]
1452    pub fn pf0_ffe_sel(&mut self) -> PF0_FFE_SEL_W {
1453        PF0_FFE_SEL_W { w: self }
1454    }
1455    #[doc = "Bit 8 - Set to enable the Packet FIFO"]
1456    #[inline(always)]
1457    pub fn pf1_en(&mut self) -> PF1_EN_W {
1458        PF1_EN_W { w: self }
1459    }
1460    #[doc = "Bit 9 - Select which subsystem controls the push operation"]
1461    #[inline(always)]
1462    pub fn pf1_push_mux(&mut self) -> PF1_PUSH_MUX_W {
1463        PF1_PUSH_MUX_W { w: self }
1464    }
1465    #[doc = "Bit 10 - Select which subsystem controls the pop operation"]
1466    #[inline(always)]
1467    pub fn pf1_pop_mux(&mut self) -> PF1_POP_MUX_W {
1468        PF1_POP_MUX_W { w: self }
1469    }
1470    #[doc = "Bit 11 - Select which subsystem manages the push interrupt"]
1471    #[inline(always)]
1472    pub fn pf1_push_int_mux(&mut self) -> PF1_PUSH_INT_MUX_W {
1473        PF1_PUSH_INT_MUX_W { w: self }
1474    }
1475    #[doc = "Bit 12 - Select which subsystem manages the pop interrupt"]
1476    #[inline(always)]
1477    pub fn pf1_pop_int_mux(&mut self) -> PF1_POP_INT_MUX_W {
1478        PF1_POP_INT_MUX_W { w: self }
1479    }
1480    #[doc = "Bit 13 - If FFE is the controller, select which instance of FFE will be used for control"]
1481    #[inline(always)]
1482    pub fn pf1_ffe_sel(&mut self) -> PF1_FFE_SEL_W {
1483        PF1_FFE_SEL_W { w: self }
1484    }
1485    #[doc = "Bit 16 - Set to enable the Packet FIFO"]
1486    #[inline(always)]
1487    pub fn pf2_en(&mut self) -> PF2_EN_W {
1488        PF2_EN_W { w: self }
1489    }
1490    #[doc = "Bit 17 - Select which subsystem controls the push operation"]
1491    #[inline(always)]
1492    pub fn pf2_push_mux(&mut self) -> PF2_PUSH_MUX_W {
1493        PF2_PUSH_MUX_W { w: self }
1494    }
1495    #[doc = "Bit 18 - Select which subsystem controls the pop operation"]
1496    #[inline(always)]
1497    pub fn pf2_pop_mux(&mut self) -> PF2_POP_MUX_W {
1498        PF2_POP_MUX_W { w: self }
1499    }
1500    #[doc = "Bit 19 - Select which subsystem manages the push interrupt"]
1501    #[inline(always)]
1502    pub fn pf2_push_int_mux(&mut self) -> PF2_PUSH_INT_MUX_W {
1503        PF2_PUSH_INT_MUX_W { w: self }
1504    }
1505    #[doc = "Bit 20 - Select which subsystem manages the pop interrupt"]
1506    #[inline(always)]
1507    pub fn pf2_pop_int_mux(&mut self) -> PF2_POP_INT_MUX_W {
1508        PF2_POP_INT_MUX_W { w: self }
1509    }
1510    #[doc = "Bit 21 - If FFE is the controller, select which instance of FFE will be used for control"]
1511    #[inline(always)]
1512    pub fn pf2_ffe_sel(&mut self) -> PF2_FFE_SEL_W {
1513        PF2_FFE_SEL_W { w: self }
1514    }
1515    #[doc = "Bit 24 - Set to enable the Packet FIFO"]
1516    #[inline(always)]
1517    pub fn pf8k_en(&mut self) -> PF8K_EN_W {
1518        PF8K_EN_W { w: self }
1519    }
1520    #[doc = "Bit 25 - Select which subsystem controls the push operation"]
1521    #[inline(always)]
1522    pub fn pf8k_push_mux(&mut self) -> PF8K_PUSH_MUX_W {
1523        PF8K_PUSH_MUX_W { w: self }
1524    }
1525    #[doc = "Bit 26 - Select which subsystem controls the pop operation"]
1526    #[inline(always)]
1527    pub fn pf8k_pop_mux(&mut self) -> PF8K_POP_MUX_W {
1528        PF8K_POP_MUX_W { w: self }
1529    }
1530    #[doc = "Bit 27 - Select which subsystem manages the push interrupt"]
1531    #[inline(always)]
1532    pub fn pf8k_push_int_mux(&mut self) -> PF8K_PUSH_INT_MUX_W {
1533        PF8K_PUSH_INT_MUX_W { w: self }
1534    }
1535    #[doc = "Bit 28 - Select which subsystem manages the pop interrupt"]
1536    #[inline(always)]
1537    pub fn pf8k_pop_int_mux(&mut self) -> PF8K_POP_INT_MUX_W {
1538        PF8K_POP_INT_MUX_W { w: self }
1539    }
1540    #[doc = "Bit 29 - If FFE is the controller, select which instance of FFE will be used for control"]
1541    #[inline(always)]
1542    pub fn pf8k_ffe_sel(&mut self) -> PF8K_FFE_SEL_W {
1543        PF8K_FFE_SEL_W { w: self }
1544    }
1545    #[doc = "Writes raw bits to the register."]
1546    #[inline(always)]
1547    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
1548        self.0.bits(bits);
1549        self
1550    }
1551}
1552#[doc = "Packet FIFO Bank control\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 [pkfb_fifoctrl](index.html) module"]
1553pub struct PKFB_FIFOCTRL_SPEC;
1554impl crate::RegisterSpec for PKFB_FIFOCTRL_SPEC {
1555    type Ux = u32;
1556}
1557#[doc = "`read()` method returns [pkfb_fifoctrl::R](R) reader structure"]
1558impl crate::Readable for PKFB_FIFOCTRL_SPEC {
1559    type Reader = R;
1560}
1561#[doc = "`write(|w| ..)` method takes [pkfb_fifoctrl::W](W) writer structure"]
1562impl crate::Writable for PKFB_FIFOCTRL_SPEC {
1563    type Writer = W;
1564}
1565#[doc = "`reset()` method sets PKFB_FIFOCTRL to value 0"]
1566impl crate::Resettable for PKFB_FIFOCTRL_SPEC {
1567    #[inline(always)]
1568    fn reset_value() -> Self::Ux {
1569        0
1570    }
1571}
eos_s3/pkfb/pkfb_fifoctrl.rs

eos_s3/pkfb/
pkfb_fifoctrl.rs
