d1_pac/tve/
tve_notch_dac_delay.rs

1#[doc = "Register `tve_notch_dac_delay` reader"]
2pub type R = crate::R<TVE_NOTCH_DAC_DELAY_SPEC>;
3#[doc = "Register `tve_notch_dac_delay` writer"]
4pub type W = crate::W<TVE_NOTCH_DAC_DELAY_SPEC>;
5#[doc = "Field `c_delay_before_dither` reader - "]
6pub type C_DELAY_BEFORE_DITHER_R = crate::FieldReader;
7#[doc = "Field `c_delay_before_dither` writer - "]
8pub type C_DELAY_BEFORE_DITHER_W<'a, REG> = crate::FieldWriter<'a, REG, 4>;
9#[doc = "Field `notch_en` reader - Luma notch filter on/off selection\n\nNote: This bit selects if the luma notch filter is operating or bypassed."]
10pub type NOTCH_EN_R = crate::BitReader<NOTCH_EN_A>;
11#[doc = "Luma notch filter on/off selection\n\nNote: This bit selects if the luma notch filter is operating or bypassed.\n\nValue on reset: 1"]
12#[derive(Clone, Copy, Debug, PartialEq, Eq)]
13pub enum NOTCH_EN_A {
14    #[doc = "0: The luma notch filter is bypassed"]
15    BYPASSED = 0,
16    #[doc = "1: The luma notch filter is operating"]
17    OPERATING = 1,
18}
19impl From<NOTCH_EN_A> for bool {
20    #[inline(always)]
21    fn from(variant: NOTCH_EN_A) -> Self {
22        variant as u8 != 0
23    }
24}
25impl NOTCH_EN_R {
26    #[doc = "Get enumerated values variant"]
27    #[inline(always)]
28    pub const fn variant(&self) -> NOTCH_EN_A {
29        match self.bits {
30            false => NOTCH_EN_A::BYPASSED,
31            true => NOTCH_EN_A::OPERATING,
32        }
33    }
34    #[doc = "The luma notch filter is bypassed"]
35    #[inline(always)]
36    pub fn is_bypassed(&self) -> bool {
37        *self == NOTCH_EN_A::BYPASSED
38    }
39    #[doc = "The luma notch filter is operating"]
40    #[inline(always)]
41    pub fn is_operating(&self) -> bool {
42        *self == NOTCH_EN_A::OPERATING
43    }
44}
45#[doc = "Field `notch_en` writer - Luma notch filter on/off selection\n\nNote: This bit selects if the luma notch filter is operating or bypassed."]
46pub type NOTCH_EN_W<'a, REG> = crate::BitWriter<'a, REG, NOTCH_EN_A>;
47impl<'a, REG> NOTCH_EN_W<'a, REG>
48where
49    REG: crate::Writable + crate::RegisterSpec,
50{
51    #[doc = "The luma notch filter is bypassed"]
52    #[inline(always)]
53    pub fn bypassed(self) -> &'a mut crate::W<REG> {
54        self.variant(NOTCH_EN_A::BYPASSED)
55    }
56    #[doc = "The luma notch filter is operating"]
57    #[inline(always)]
58    pub fn operating(self) -> &'a mut crate::W<REG> {
59        self.variant(NOTCH_EN_A::OPERATING)
60    }
61}
62#[doc = "Field `luma_filter_bypass` reader - "]
63pub type LUMA_FILTER_BYPASS_R = crate::BitReader<LUMA_FILTER_BYPASS_A>;
64#[doc = "\n\nValue on reset: 0"]
65#[derive(Clone, Copy, Debug, PartialEq, Eq)]
66pub enum LUMA_FILTER_BYPASS_A {
67    #[doc = "0: Luma Filter Enable"]
68    ENABLE = 0,
69    #[doc = "1: Luma Filter bypass"]
70    BYPASS = 1,
71}
72impl From<LUMA_FILTER_BYPASS_A> for bool {
73    #[inline(always)]
74    fn from(variant: LUMA_FILTER_BYPASS_A) -> Self {
75        variant as u8 != 0
76    }
77}
78impl LUMA_FILTER_BYPASS_R {
79    #[doc = "Get enumerated values variant"]
80    #[inline(always)]
81    pub const fn variant(&self) -> LUMA_FILTER_BYPASS_A {
82        match self.bits {
83            false => LUMA_FILTER_BYPASS_A::ENABLE,
84            true => LUMA_FILTER_BYPASS_A::BYPASS,
85        }
86    }
87    #[doc = "Luma Filter Enable"]
88    #[inline(always)]
89    pub fn is_enable(&self) -> bool {
90        *self == LUMA_FILTER_BYPASS_A::ENABLE
91    }
92    #[doc = "Luma Filter bypass"]
93    #[inline(always)]
94    pub fn is_bypass(&self) -> bool {
95        *self == LUMA_FILTER_BYPASS_A::BYPASS
96    }
97}
98#[doc = "Field `luma_filter_bypass` writer - "]
99pub type LUMA_FILTER_BYPASS_W<'a, REG> = crate::BitWriter<'a, REG, LUMA_FILTER_BYPASS_A>;
100impl<'a, REG> LUMA_FILTER_BYPASS_W<'a, REG>
101where
102    REG: crate::Writable + crate::RegisterSpec,
103{
104    #[doc = "Luma Filter Enable"]
105    #[inline(always)]
106    pub fn enable(self) -> &'a mut crate::W<REG> {
107        self.variant(LUMA_FILTER_BYPASS_A::ENABLE)
108    }
109    #[doc = "Luma Filter bypass"]
110    #[inline(always)]
111    pub fn bypass(self) -> &'a mut crate::W<REG> {
112        self.variant(LUMA_FILTER_BYPASS_A::BYPASS)
113    }
114}
115#[doc = "Field `chroma_filter_stage__bypass[3,2,1]` reader - "]
116pub type CHROMA_FILTER_STAGE__BYPASS_R = crate::BitReader<CHROMA_FILTER_STAGE__BYPASS_A>;
117#[doc = "\n\nValue on reset: 0"]
118#[derive(Clone, Copy, Debug, PartialEq, Eq)]
119pub enum CHROMA_FILTER_STAGE__BYPASS_A {
120    #[doc = "0: Chroma Filter Stage \\[i\\] Enable"]
121    ENABLE = 0,
122    #[doc = "1: Chroma Filter Stage \\[i\\] bypass"]
123    BYPASS = 1,
124}
125impl From<CHROMA_FILTER_STAGE__BYPASS_A> for bool {
126    #[inline(always)]
127    fn from(variant: CHROMA_FILTER_STAGE__BYPASS_A) -> Self {
128        variant as u8 != 0
129    }
130}
131impl CHROMA_FILTER_STAGE__BYPASS_R {
132    #[doc = "Get enumerated values variant"]
133    #[inline(always)]
134    pub const fn variant(&self) -> CHROMA_FILTER_STAGE__BYPASS_A {
135        match self.bits {
136            false => CHROMA_FILTER_STAGE__BYPASS_A::ENABLE,
137            true => CHROMA_FILTER_STAGE__BYPASS_A::BYPASS,
138        }
139    }
140    #[doc = "Chroma Filter Stage \\[i\\] Enable"]
141    #[inline(always)]
142    pub fn is_enable(&self) -> bool {
143        *self == CHROMA_FILTER_STAGE__BYPASS_A::ENABLE
144    }
145    #[doc = "Chroma Filter Stage \\[i\\] bypass"]
146    #[inline(always)]
147    pub fn is_bypass(&self) -> bool {
148        *self == CHROMA_FILTER_STAGE__BYPASS_A::BYPASS
149    }
150}
151#[doc = "Field `chroma_filter_stage__bypass[3,2,1]` writer - "]
152pub type CHROMA_FILTER_STAGE__BYPASS_W<'a, REG> =
153    crate::BitWriter<'a, REG, CHROMA_FILTER_STAGE__BYPASS_A>;
154impl<'a, REG> CHROMA_FILTER_STAGE__BYPASS_W<'a, REG>
155where
156    REG: crate::Writable + crate::RegisterSpec,
157{
158    #[doc = "Chroma Filter Stage \\[i\\] Enable"]
159    #[inline(always)]
160    pub fn enable(self) -> &'a mut crate::W<REG> {
161        self.variant(CHROMA_FILTER_STAGE__BYPASS_A::ENABLE)
162    }
163    #[doc = "Chroma Filter Stage \\[i\\] bypass"]
164    #[inline(always)]
165    pub fn bypass(self) -> &'a mut crate::W<REG> {
166        self.variant(CHROMA_FILTER_STAGE__BYPASS_A::BYPASS)
167    }
168}
169#[doc = "Field `chroma_hd_mode_filter_en` reader - "]
170pub type CHROMA_HD_MODE_FILTER_EN_R = crate::BitReader<CHROMA_HD_MODE_FILTER_EN_A>;
171#[doc = "\n\nValue on reset: 0"]
172#[derive(Clone, Copy, Debug, PartialEq, Eq)]
173pub enum CHROMA_HD_MODE_FILTER_EN_A {
174    #[doc = "0: Chroma HD Filter Disable"]
175    DISABLE = 0,
176    #[doc = "1: Chroma HD Filter Enable"]
177    ENABLE = 1,
178}
179impl From<CHROMA_HD_MODE_FILTER_EN_A> for bool {
180    #[inline(always)]
181    fn from(variant: CHROMA_HD_MODE_FILTER_EN_A) -> Self {
182        variant as u8 != 0
183    }
184}
185impl CHROMA_HD_MODE_FILTER_EN_R {
186    #[doc = "Get enumerated values variant"]
187    #[inline(always)]
188    pub const fn variant(&self) -> CHROMA_HD_MODE_FILTER_EN_A {
189        match self.bits {
190            false => CHROMA_HD_MODE_FILTER_EN_A::DISABLE,
191            true => CHROMA_HD_MODE_FILTER_EN_A::ENABLE,
192        }
193    }
194    #[doc = "Chroma HD Filter Disable"]
195    #[inline(always)]
196    pub fn is_disable(&self) -> bool {
197        *self == CHROMA_HD_MODE_FILTER_EN_A::DISABLE
198    }
199    #[doc = "Chroma HD Filter Enable"]
200    #[inline(always)]
201    pub fn is_enable(&self) -> bool {
202        *self == CHROMA_HD_MODE_FILTER_EN_A::ENABLE
203    }
204}
205#[doc = "Field `chroma_hd_mode_filter_en` writer - "]
206pub type CHROMA_HD_MODE_FILTER_EN_W<'a, REG> =
207    crate::BitWriter<'a, REG, CHROMA_HD_MODE_FILTER_EN_A>;
208impl<'a, REG> CHROMA_HD_MODE_FILTER_EN_W<'a, REG>
209where
210    REG: crate::Writable + crate::RegisterSpec,
211{
212    #[doc = "Chroma HD Filter Disable"]
213    #[inline(always)]
214    pub fn disable(self) -> &'a mut crate::W<REG> {
215        self.variant(CHROMA_HD_MODE_FILTER_EN_A::DISABLE)
216    }
217    #[doc = "Chroma HD Filter Enable"]
218    #[inline(always)]
219    pub fn enable(self) -> &'a mut crate::W<REG> {
220        self.variant(CHROMA_HD_MODE_FILTER_EN_A::ENABLE)
221    }
222}
223#[doc = "Field `chroma_filter_1_444_en` reader - "]
224pub type CHROMA_FILTER_1_444_EN_R = crate::BitReader<CHROMA_FILTER_1_444_EN_A>;
225#[doc = "\n\nValue on reset: 0"]
226#[derive(Clone, Copy, Debug, PartialEq, Eq)]
227pub enum CHROMA_FILTER_1_444_EN_A {
228    #[doc = "0: Chroma Filter 1 444 Disable"]
229    DISABLE = 0,
230    #[doc = "1: Chroma Filter 1 444 Enable"]
231    ENABLE = 1,
232}
233impl From<CHROMA_FILTER_1_444_EN_A> for bool {
234    #[inline(always)]
235    fn from(variant: CHROMA_FILTER_1_444_EN_A) -> Self {
236        variant as u8 != 0
237    }
238}
239impl CHROMA_FILTER_1_444_EN_R {
240    #[doc = "Get enumerated values variant"]
241    #[inline(always)]
242    pub const fn variant(&self) -> CHROMA_FILTER_1_444_EN_A {
243        match self.bits {
244            false => CHROMA_FILTER_1_444_EN_A::DISABLE,
245            true => CHROMA_FILTER_1_444_EN_A::ENABLE,
246        }
247    }
248    #[doc = "Chroma Filter 1 444 Disable"]
249    #[inline(always)]
250    pub fn is_disable(&self) -> bool {
251        *self == CHROMA_FILTER_1_444_EN_A::DISABLE
252    }
253    #[doc = "Chroma Filter 1 444 Enable"]
254    #[inline(always)]
255    pub fn is_enable(&self) -> bool {
256        *self == CHROMA_FILTER_1_444_EN_A::ENABLE
257    }
258}
259#[doc = "Field `chroma_filter_1_444_en` writer - "]
260pub type CHROMA_FILTER_1_444_EN_W<'a, REG> = crate::BitWriter<'a, REG, CHROMA_FILTER_1_444_EN_A>;
261impl<'a, REG> CHROMA_FILTER_1_444_EN_W<'a, REG>
262where
263    REG: crate::Writable + crate::RegisterSpec,
264{
265    #[doc = "Chroma Filter 1 444 Disable"]
266    #[inline(always)]
267    pub fn disable(self) -> &'a mut crate::W<REG> {
268        self.variant(CHROMA_FILTER_1_444_EN_A::DISABLE)
269    }
270    #[doc = "Chroma Filter 1 444 Enable"]
271    #[inline(always)]
272    pub fn enable(self) -> &'a mut crate::W<REG> {
273        self.variant(CHROMA_FILTER_1_444_EN_A::ENABLE)
274    }
275}
276#[doc = "Field `hd_mode_cr_filter_bypass` reader - "]
277pub type HD_MODE_CR_FILTER_BYPASS_R = crate::BitReader<HD_MODE_CR_FILTER_BYPASS_A>;
278#[doc = "\n\nValue on reset: 0"]
279#[derive(Clone, Copy, Debug, PartialEq, Eq)]
280pub enum HD_MODE_CR_FILTER_BYPASS_A {
281    #[doc = "0: Bypass Enable"]
282    ENABLE = 0,
283    #[doc = "1: Bypass Disable"]
284    DISABLE = 1,
285}
286impl From<HD_MODE_CR_FILTER_BYPASS_A> for bool {
287    #[inline(always)]
288    fn from(variant: HD_MODE_CR_FILTER_BYPASS_A) -> Self {
289        variant as u8 != 0
290    }
291}
292impl HD_MODE_CR_FILTER_BYPASS_R {
293    #[doc = "Get enumerated values variant"]
294    #[inline(always)]
295    pub const fn variant(&self) -> HD_MODE_CR_FILTER_BYPASS_A {
296        match self.bits {
297            false => HD_MODE_CR_FILTER_BYPASS_A::ENABLE,
298            true => HD_MODE_CR_FILTER_BYPASS_A::DISABLE,
299        }
300    }
301    #[doc = "Bypass Enable"]
302    #[inline(always)]
303    pub fn is_enable(&self) -> bool {
304        *self == HD_MODE_CR_FILTER_BYPASS_A::ENABLE
305    }
306    #[doc = "Bypass Disable"]
307    #[inline(always)]
308    pub fn is_disable(&self) -> bool {
309        *self == HD_MODE_CR_FILTER_BYPASS_A::DISABLE
310    }
311}
312#[doc = "Field `hd_mode_cr_filter_bypass` writer - "]
313pub type HD_MODE_CR_FILTER_BYPASS_W<'a, REG> =
314    crate::BitWriter<'a, REG, HD_MODE_CR_FILTER_BYPASS_A>;
315impl<'a, REG> HD_MODE_CR_FILTER_BYPASS_W<'a, REG>
316where
317    REG: crate::Writable + crate::RegisterSpec,
318{
319    #[doc = "Bypass Enable"]
320    #[inline(always)]
321    pub fn enable(self) -> &'a mut crate::W<REG> {
322        self.variant(HD_MODE_CR_FILTER_BYPASS_A::ENABLE)
323    }
324    #[doc = "Bypass Disable"]
325    #[inline(always)]
326    pub fn disable(self) -> &'a mut crate::W<REG> {
327        self.variant(HD_MODE_CR_FILTER_BYPASS_A::DISABLE)
328    }
329}
330#[doc = "Field `hd_mode_cb_filter_bypass` reader - "]
331pub type HD_MODE_CB_FILTER_BYPASS_R = crate::BitReader<HD_MODE_CB_FILTER_BYPASS_A>;
332#[doc = "\n\nValue on reset: 0"]
333#[derive(Clone, Copy, Debug, PartialEq, Eq)]
334pub enum HD_MODE_CB_FILTER_BYPASS_A {
335    #[doc = "0: Bypass Enable"]
336    ENABLE = 0,
337    #[doc = "1: Bypass Disable"]
338    DISABLE = 1,
339}
340impl From<HD_MODE_CB_FILTER_BYPASS_A> for bool {
341    #[inline(always)]
342    fn from(variant: HD_MODE_CB_FILTER_BYPASS_A) -> Self {
343        variant as u8 != 0
344    }
345}
346impl HD_MODE_CB_FILTER_BYPASS_R {
347    #[doc = "Get enumerated values variant"]
348    #[inline(always)]
349    pub const fn variant(&self) -> HD_MODE_CB_FILTER_BYPASS_A {
350        match self.bits {
351            false => HD_MODE_CB_FILTER_BYPASS_A::ENABLE,
352            true => HD_MODE_CB_FILTER_BYPASS_A::DISABLE,
353        }
354    }
355    #[doc = "Bypass Enable"]
356    #[inline(always)]
357    pub fn is_enable(&self) -> bool {
358        *self == HD_MODE_CB_FILTER_BYPASS_A::ENABLE
359    }
360    #[doc = "Bypass Disable"]
361    #[inline(always)]
362    pub fn is_disable(&self) -> bool {
363        *self == HD_MODE_CB_FILTER_BYPASS_A::DISABLE
364    }
365}
366#[doc = "Field `hd_mode_cb_filter_bypass` writer - "]
367pub type HD_MODE_CB_FILTER_BYPASS_W<'a, REG> =
368    crate::BitWriter<'a, REG, HD_MODE_CB_FILTER_BYPASS_A>;
369impl<'a, REG> HD_MODE_CB_FILTER_BYPASS_W<'a, REG>
370where
371    REG: crate::Writable + crate::RegisterSpec,
372{
373    #[doc = "Bypass Enable"]
374    #[inline(always)]
375    pub fn enable(self) -> &'a mut crate::W<REG> {
376        self.variant(HD_MODE_CB_FILTER_BYPASS_A::ENABLE)
377    }
378    #[doc = "Bypass Disable"]
379    #[inline(always)]
380    pub fn disable(self) -> &'a mut crate::W<REG> {
381        self.variant(HD_MODE_CB_FILTER_BYPASS_A::DISABLE)
382    }
383}
384#[doc = "Field `y_delay_before_dither` reader - "]
385pub type Y_DELAY_BEFORE_DITHER_R = crate::FieldReader;
386#[doc = "Field `y_delay_before_dither` writer - "]
387pub type Y_DELAY_BEFORE_DITHER_W<'a, REG> = crate::FieldWriter<'a, REG, 3>;
388#[doc = "Field `luma_filter_lti_enable` reader - "]
389pub type LUMA_FILTER_LTI_ENABLE_R = crate::BitReader<LUMA_FILTER_LTI_ENABLE_A>;
390#[doc = "\n\nValue on reset: 0"]
391#[derive(Clone, Copy, Debug, PartialEq, Eq)]
392pub enum LUMA_FILTER_LTI_ENABLE_A {
393    #[doc = "0: Disable Luma filter lti"]
394    DISABLE = 0,
395    #[doc = "1: Enable Luma filter lti"]
396    ENABLE = 1,
397}
398impl From<LUMA_FILTER_LTI_ENABLE_A> for bool {
399    #[inline(always)]
400    fn from(variant: LUMA_FILTER_LTI_ENABLE_A) -> Self {
401        variant as u8 != 0
402    }
403}
404impl LUMA_FILTER_LTI_ENABLE_R {
405    #[doc = "Get enumerated values variant"]
406    #[inline(always)]
407    pub const fn variant(&self) -> LUMA_FILTER_LTI_ENABLE_A {
408        match self.bits {
409            false => LUMA_FILTER_LTI_ENABLE_A::DISABLE,
410            true => LUMA_FILTER_LTI_ENABLE_A::ENABLE,
411        }
412    }
413    #[doc = "Disable Luma filter lti"]
414    #[inline(always)]
415    pub fn is_disable(&self) -> bool {
416        *self == LUMA_FILTER_LTI_ENABLE_A::DISABLE
417    }
418    #[doc = "Enable Luma filter lti"]
419    #[inline(always)]
420    pub fn is_enable(&self) -> bool {
421        *self == LUMA_FILTER_LTI_ENABLE_A::ENABLE
422    }
423}
424#[doc = "Field `luma_filter_lti_enable` writer - "]
425pub type LUMA_FILTER_LTI_ENABLE_W<'a, REG> = crate::BitWriter<'a, REG, LUMA_FILTER_LTI_ENABLE_A>;
426impl<'a, REG> LUMA_FILTER_LTI_ENABLE_W<'a, REG>
427where
428    REG: crate::Writable + crate::RegisterSpec,
429{
430    #[doc = "Disable Luma filter lti"]
431    #[inline(always)]
432    pub fn disable(self) -> &'a mut crate::W<REG> {
433        self.variant(LUMA_FILTER_LTI_ENABLE_A::DISABLE)
434    }
435    #[doc = "Enable Luma filter lti"]
436    #[inline(always)]
437    pub fn enable(self) -> &'a mut crate::W<REG> {
438        self.variant(LUMA_FILTER_LTI_ENABLE_A::ENABLE)
439    }
440}
441#[doc = "Field `chroma_filter_active_valid` reader - "]
442pub type CHROMA_FILTER_ACTIVE_VALID_R = crate::BitReader<CHROMA_FILTER_ACTIVE_VALID_A>;
443#[doc = "\n\nValue on reset: 0"]
444#[derive(Clone, Copy, Debug, PartialEq, Eq)]
445pub enum CHROMA_FILTER_ACTIVE_VALID_A {
446    #[doc = "0: Disable"]
447    DISABLE = 0,
448    #[doc = "1: Enable"]
449    ENABLE = 1,
450}
451impl From<CHROMA_FILTER_ACTIVE_VALID_A> for bool {
452    #[inline(always)]
453    fn from(variant: CHROMA_FILTER_ACTIVE_VALID_A) -> Self {
454        variant as u8 != 0
455    }
456}
457impl CHROMA_FILTER_ACTIVE_VALID_R {
458    #[doc = "Get enumerated values variant"]
459    #[inline(always)]
460    pub const fn variant(&self) -> CHROMA_FILTER_ACTIVE_VALID_A {
461        match self.bits {
462            false => CHROMA_FILTER_ACTIVE_VALID_A::DISABLE,
463            true => CHROMA_FILTER_ACTIVE_VALID_A::ENABLE,
464        }
465    }
466    #[doc = "Disable"]
467    #[inline(always)]
468    pub fn is_disable(&self) -> bool {
469        *self == CHROMA_FILTER_ACTIVE_VALID_A::DISABLE
470    }
471    #[doc = "Enable"]
472    #[inline(always)]
473    pub fn is_enable(&self) -> bool {
474        *self == CHROMA_FILTER_ACTIVE_VALID_A::ENABLE
475    }
476}
477#[doc = "Field `chroma_filter_active_valid` writer - "]
478pub type CHROMA_FILTER_ACTIVE_VALID_W<'a, REG> =
479    crate::BitWriter<'a, REG, CHROMA_FILTER_ACTIVE_VALID_A>;
480impl<'a, REG> CHROMA_FILTER_ACTIVE_VALID_W<'a, REG>
481where
482    REG: crate::Writable + crate::RegisterSpec,
483{
484    #[doc = "Disable"]
485    #[inline(always)]
486    pub fn disable(self) -> &'a mut crate::W<REG> {
487        self.variant(CHROMA_FILTER_ACTIVE_VALID_A::DISABLE)
488    }
489    #[doc = "Enable"]
490    #[inline(always)]
491    pub fn enable(self) -> &'a mut crate::W<REG> {
492        self.variant(CHROMA_FILTER_ACTIVE_VALID_A::ENABLE)
493    }
494}
495impl R {
496    #[doc = "Bits 12:15"]
497    #[inline(always)]
498    pub fn c_delay_before_dither(&self) -> C_DELAY_BEFORE_DITHER_R {
499        C_DELAY_BEFORE_DITHER_R::new(((self.bits >> 12) & 0x0f) as u8)
500    }
501    #[doc = "Bit 16 - Luma notch filter on/off selection\n\nNote: This bit selects if the luma notch filter is operating or bypassed."]
502    #[inline(always)]
503    pub fn notch_en(&self) -> NOTCH_EN_R {
504        NOTCH_EN_R::new(((self.bits >> 16) & 1) != 0)
505    }
506    #[doc = "Bit 17"]
507    #[inline(always)]
508    pub fn luma_filter_bypass(&self) -> LUMA_FILTER_BYPASS_R {
509        LUMA_FILTER_BYPASS_R::new(((self.bits >> 17) & 1) != 0)
510    }
511    #[doc = "\n\nNOTE: `n` is number of field in register. `n == 0` corresponds to `chroma_filter_stage_3_bypass` field"]
512    #[inline(always)]
513    pub fn chroma_filter_stage__bypass(&self, n: u8) -> CHROMA_FILTER_STAGE__BYPASS_R {
514        #[allow(clippy::no_effect)]
515        [(); 3][n as usize];
516        CHROMA_FILTER_STAGE__BYPASS_R::new(((self.bits >> (n + 18)) & 1) != 0)
517    }
518    #[doc = "Bit 18 - chroma_filter_stage_3_bypass"]
519    #[inline(always)]
520    pub fn chroma_filter_stage_3_bypass(&self) -> CHROMA_FILTER_STAGE__BYPASS_R {
521        CHROMA_FILTER_STAGE__BYPASS_R::new(((self.bits >> 18) & 1) != 0)
522    }
523    #[doc = "Bit 19 - chroma_filter_stage_2_bypass"]
524    #[inline(always)]
525    pub fn chroma_filter_stage_2_bypass(&self) -> CHROMA_FILTER_STAGE__BYPASS_R {
526        CHROMA_FILTER_STAGE__BYPASS_R::new(((self.bits >> 19) & 1) != 0)
527    }
528    #[doc = "Bit 20 - chroma_filter_stage_1_bypass"]
529    #[inline(always)]
530    pub fn chroma_filter_stage_1_bypass(&self) -> CHROMA_FILTER_STAGE__BYPASS_R {
531        CHROMA_FILTER_STAGE__BYPASS_R::new(((self.bits >> 20) & 1) != 0)
532    }
533    #[doc = "Bit 21"]
534    #[inline(always)]
535    pub fn chroma_hd_mode_filter_en(&self) -> CHROMA_HD_MODE_FILTER_EN_R {
536        CHROMA_HD_MODE_FILTER_EN_R::new(((self.bits >> 21) & 1) != 0)
537    }
538    #[doc = "Bit 22"]
539    #[inline(always)]
540    pub fn chroma_filter_1_444_en(&self) -> CHROMA_FILTER_1_444_EN_R {
541        CHROMA_FILTER_1_444_EN_R::new(((self.bits >> 22) & 1) != 0)
542    }
543    #[doc = "Bit 23"]
544    #[inline(always)]
545    pub fn hd_mode_cr_filter_bypass(&self) -> HD_MODE_CR_FILTER_BYPASS_R {
546        HD_MODE_CR_FILTER_BYPASS_R::new(((self.bits >> 23) & 1) != 0)
547    }
548    #[doc = "Bit 24"]
549    #[inline(always)]
550    pub fn hd_mode_cb_filter_bypass(&self) -> HD_MODE_CB_FILTER_BYPASS_R {
551        HD_MODE_CB_FILTER_BYPASS_R::new(((self.bits >> 24) & 1) != 0)
552    }
553    #[doc = "Bits 25:27"]
554    #[inline(always)]
555    pub fn y_delay_before_dither(&self) -> Y_DELAY_BEFORE_DITHER_R {
556        Y_DELAY_BEFORE_DITHER_R::new(((self.bits >> 25) & 7) as u8)
557    }
558    #[doc = "Bit 30"]
559    #[inline(always)]
560    pub fn luma_filter_lti_enable(&self) -> LUMA_FILTER_LTI_ENABLE_R {
561        LUMA_FILTER_LTI_ENABLE_R::new(((self.bits >> 30) & 1) != 0)
562    }
563    #[doc = "Bit 31"]
564    #[inline(always)]
565    pub fn chroma_filter_active_valid(&self) -> CHROMA_FILTER_ACTIVE_VALID_R {
566        CHROMA_FILTER_ACTIVE_VALID_R::new(((self.bits >> 31) & 1) != 0)
567    }
568}
569impl W {
570    #[doc = "Bits 12:15"]
571    #[inline(always)]
572    #[must_use]
573    pub fn c_delay_before_dither(&mut self) -> C_DELAY_BEFORE_DITHER_W<TVE_NOTCH_DAC_DELAY_SPEC> {
574        C_DELAY_BEFORE_DITHER_W::new(self, 12)
575    }
576    #[doc = "Bit 16 - Luma notch filter on/off selection\n\nNote: This bit selects if the luma notch filter is operating or bypassed."]
577    #[inline(always)]
578    #[must_use]
579    pub fn notch_en(&mut self) -> NOTCH_EN_W<TVE_NOTCH_DAC_DELAY_SPEC> {
580        NOTCH_EN_W::new(self, 16)
581    }
582    #[doc = "Bit 17"]
583    #[inline(always)]
584    #[must_use]
585    pub fn luma_filter_bypass(&mut self) -> LUMA_FILTER_BYPASS_W<TVE_NOTCH_DAC_DELAY_SPEC> {
586        LUMA_FILTER_BYPASS_W::new(self, 17)
587    }
588    #[doc = "\n\nNOTE: `n` is number of field in register. `n == 0` corresponds to `chroma_filter_stage_3_bypass` field"]
589    #[inline(always)]
590    #[must_use]
591    pub fn chroma_filter_stage__bypass(
592        &mut self,
593        n: u8,
594    ) -> CHROMA_FILTER_STAGE__BYPASS_W<TVE_NOTCH_DAC_DELAY_SPEC> {
595        #[allow(clippy::no_effect)]
596        [(); 3][n as usize];
597        CHROMA_FILTER_STAGE__BYPASS_W::new(self, n + 18)
598    }
599    #[doc = "Bit 18 - chroma_filter_stage_3_bypass"]
600    #[inline(always)]
601    #[must_use]
602    pub fn chroma_filter_stage_3_bypass(
603        &mut self,
604    ) -> CHROMA_FILTER_STAGE__BYPASS_W<TVE_NOTCH_DAC_DELAY_SPEC> {
605        CHROMA_FILTER_STAGE__BYPASS_W::new(self, 18)
606    }
607    #[doc = "Bit 19 - chroma_filter_stage_2_bypass"]
608    #[inline(always)]
609    #[must_use]
610    pub fn chroma_filter_stage_2_bypass(
611        &mut self,
612    ) -> CHROMA_FILTER_STAGE__BYPASS_W<TVE_NOTCH_DAC_DELAY_SPEC> {
613        CHROMA_FILTER_STAGE__BYPASS_W::new(self, 19)
614    }
615    #[doc = "Bit 20 - chroma_filter_stage_1_bypass"]
616    #[inline(always)]
617    #[must_use]
618    pub fn chroma_filter_stage_1_bypass(
619        &mut self,
620    ) -> CHROMA_FILTER_STAGE__BYPASS_W<TVE_NOTCH_DAC_DELAY_SPEC> {
621        CHROMA_FILTER_STAGE__BYPASS_W::new(self, 20)
622    }
623    #[doc = "Bit 21"]
624    #[inline(always)]
625    #[must_use]
626    pub fn chroma_hd_mode_filter_en(
627        &mut self,
628    ) -> CHROMA_HD_MODE_FILTER_EN_W<TVE_NOTCH_DAC_DELAY_SPEC> {
629        CHROMA_HD_MODE_FILTER_EN_W::new(self, 21)
630    }
631    #[doc = "Bit 22"]
632    #[inline(always)]
633    #[must_use]
634    pub fn chroma_filter_1_444_en(&mut self) -> CHROMA_FILTER_1_444_EN_W<TVE_NOTCH_DAC_DELAY_SPEC> {
635        CHROMA_FILTER_1_444_EN_W::new(self, 22)
636    }
637    #[doc = "Bit 23"]
638    #[inline(always)]
639    #[must_use]
640    pub fn hd_mode_cr_filter_bypass(
641        &mut self,
642    ) -> HD_MODE_CR_FILTER_BYPASS_W<TVE_NOTCH_DAC_DELAY_SPEC> {
643        HD_MODE_CR_FILTER_BYPASS_W::new(self, 23)
644    }
645    #[doc = "Bit 24"]
646    #[inline(always)]
647    #[must_use]
648    pub fn hd_mode_cb_filter_bypass(
649        &mut self,
650    ) -> HD_MODE_CB_FILTER_BYPASS_W<TVE_NOTCH_DAC_DELAY_SPEC> {
651        HD_MODE_CB_FILTER_BYPASS_W::new(self, 24)
652    }
653    #[doc = "Bits 25:27"]
654    #[inline(always)]
655    #[must_use]
656    pub fn y_delay_before_dither(&mut self) -> Y_DELAY_BEFORE_DITHER_W<TVE_NOTCH_DAC_DELAY_SPEC> {
657        Y_DELAY_BEFORE_DITHER_W::new(self, 25)
658    }
659    #[doc = "Bit 30"]
660    #[inline(always)]
661    #[must_use]
662    pub fn luma_filter_lti_enable(&mut self) -> LUMA_FILTER_LTI_ENABLE_W<TVE_NOTCH_DAC_DELAY_SPEC> {
663        LUMA_FILTER_LTI_ENABLE_W::new(self, 30)
664    }
665    #[doc = "Bit 31"]
666    #[inline(always)]
667    #[must_use]
668    pub fn chroma_filter_active_valid(
669        &mut self,
670    ) -> CHROMA_FILTER_ACTIVE_VALID_W<TVE_NOTCH_DAC_DELAY_SPEC> {
671        CHROMA_FILTER_ACTIVE_VALID_W::new(self, 31)
672    }
673    #[doc = r" Writes raw bits to the register."]
674    #[doc = r""]
675    #[doc = r" # Safety"]
676    #[doc = r""]
677    #[doc = r" Passing incorrect value can cause undefined behaviour. See reference manual"]
678    #[inline(always)]
679    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
680        self.bits = bits;
681        self
682    }
683}
684#[doc = "TV Encoder Notch and DAC Delay Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`tve_notch_dac_delay::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`tve_notch_dac_delay::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
685pub struct TVE_NOTCH_DAC_DELAY_SPEC;
686impl crate::RegisterSpec for TVE_NOTCH_DAC_DELAY_SPEC {
687    type Ux = u32;
688}
689#[doc = "`read()` method returns [`tve_notch_dac_delay::R`](R) reader structure"]
690impl crate::Readable for TVE_NOTCH_DAC_DELAY_SPEC {}
691#[doc = "`write(|w| ..)` method takes [`tve_notch_dac_delay::W`](W) writer structure"]
692impl crate::Writable for TVE_NOTCH_DAC_DELAY_SPEC {
693    const ZERO_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
694    const ONE_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
695}
696#[doc = "`reset()` method sets tve_notch_dac_delay to value 0x0201_4924"]
697impl crate::Resettable for TVE_NOTCH_DAC_DELAY_SPEC {
698    const RESET_VALUE: Self::Ux = 0x0201_4924;
699}
d1_pac/tve/tve_notch_dac_delay.rs

d1_pac/tve/
tve_notch_dac_delay.rs
