mimxrt595s/usbphy/
ctrl_clr.rs

1#[doc = "Register `CTRL_CLR` reader"]
2pub struct R(crate::R<CTRL_CLR_SPEC>);
3impl core::ops::Deref for R {
4    type Target = crate::R<CTRL_CLR_SPEC>;
5    #[inline(always)]
6    fn deref(&self) -> &Self::Target {
7        &self.0
8    }
9}
10impl From<crate::R<CTRL_CLR_SPEC>> for R {
11    #[inline(always)]
12    fn from(reader: crate::R<CTRL_CLR_SPEC>) -> Self {
13        R(reader)
14    }
15}
16#[doc = "Register `CTRL_CLR` writer"]
17pub struct W(crate::W<CTRL_CLR_SPEC>);
18impl core::ops::Deref for W {
19    type Target = crate::W<CTRL_CLR_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<CTRL_CLR_SPEC>> for W {
32    #[inline(always)]
33    fn from(writer: crate::W<CTRL_CLR_SPEC>) -> Self {
34        W(writer)
35    }
36}
37#[doc = "Field `ENHOSTDISCONDETECT` reader - Disconnect detect."]
38pub type ENHOSTDISCONDETECT_R = crate::BitReader<ENHOSTDISCONDETECT_A>;
39#[doc = "Disconnect detect.\n\nValue on reset: 0"]
40#[derive(Clone, Copy, Debug, PartialEq, Eq)]
41pub enum ENHOSTDISCONDETECT_A {
42    #[doc = "0: No effect"]
43    DISABLE = 0,
44    #[doc = "1: Clears the corresponding CTRL bit"]
45    ENABLE = 1,
46}
47impl From<ENHOSTDISCONDETECT_A> for bool {
48    #[inline(always)]
49    fn from(variant: ENHOSTDISCONDETECT_A) -> Self {
50        variant as u8 != 0
51    }
52}
53impl ENHOSTDISCONDETECT_R {
54    #[doc = "Get enumerated values variant"]
55    #[inline(always)]
56    pub fn variant(&self) -> ENHOSTDISCONDETECT_A {
57        match self.bits {
58            false => ENHOSTDISCONDETECT_A::DISABLE,
59            true => ENHOSTDISCONDETECT_A::ENABLE,
60        }
61    }
62    #[doc = "Checks if the value of the field is `DISABLE`"]
63    #[inline(always)]
64    pub fn is_disable(&self) -> bool {
65        *self == ENHOSTDISCONDETECT_A::DISABLE
66    }
67    #[doc = "Checks if the value of the field is `ENABLE`"]
68    #[inline(always)]
69    pub fn is_enable(&self) -> bool {
70        *self == ENHOSTDISCONDETECT_A::ENABLE
71    }
72}
73#[doc = "Field `ENHOSTDISCONDETECT` writer - Disconnect detect."]
74pub type ENHOSTDISCONDETECT_W<'a, const O: u8> =
75    crate::BitWriter<'a, u32, CTRL_CLR_SPEC, ENHOSTDISCONDETECT_A, O>;
76impl<'a, const O: u8> ENHOSTDISCONDETECT_W<'a, O> {
77    #[doc = "No effect"]
78    #[inline(always)]
79    pub fn disable(self) -> &'a mut W {
80        self.variant(ENHOSTDISCONDETECT_A::DISABLE)
81    }
82    #[doc = "Clears the corresponding CTRL bit"]
83    #[inline(always)]
84    pub fn enable(self) -> &'a mut W {
85        self.variant(ENHOSTDISCONDETECT_A::ENABLE)
86    }
87}
88#[doc = "Field `HOSTDISCONDETECT_IRQ` reader - Device disconnect indication."]
89pub type HOSTDISCONDETECT_IRQ_R = crate::BitReader<HOSTDISCONDETECT_IRQ_A>;
90#[doc = "Device disconnect indication.\n\nValue on reset: 0"]
91#[derive(Clone, Copy, Debug, PartialEq, Eq)]
92pub enum HOSTDISCONDETECT_IRQ_A {
93    #[doc = "0: No effect"]
94    DISABLE = 0,
95    #[doc = "1: Clears the corresponding CTRL bit"]
96    ENABLE = 1,
97}
98impl From<HOSTDISCONDETECT_IRQ_A> for bool {
99    #[inline(always)]
100    fn from(variant: HOSTDISCONDETECT_IRQ_A) -> Self {
101        variant as u8 != 0
102    }
103}
104impl HOSTDISCONDETECT_IRQ_R {
105    #[doc = "Get enumerated values variant"]
106    #[inline(always)]
107    pub fn variant(&self) -> HOSTDISCONDETECT_IRQ_A {
108        match self.bits {
109            false => HOSTDISCONDETECT_IRQ_A::DISABLE,
110            true => HOSTDISCONDETECT_IRQ_A::ENABLE,
111        }
112    }
113    #[doc = "Checks if the value of the field is `DISABLE`"]
114    #[inline(always)]
115    pub fn is_disable(&self) -> bool {
116        *self == HOSTDISCONDETECT_IRQ_A::DISABLE
117    }
118    #[doc = "Checks if the value of the field is `ENABLE`"]
119    #[inline(always)]
120    pub fn is_enable(&self) -> bool {
121        *self == HOSTDISCONDETECT_IRQ_A::ENABLE
122    }
123}
124#[doc = "Field `HOSTDISCONDETECT_IRQ` writer - Device disconnect indication."]
125pub type HOSTDISCONDETECT_IRQ_W<'a, const O: u8> =
126    crate::BitWriter<'a, u32, CTRL_CLR_SPEC, HOSTDISCONDETECT_IRQ_A, O>;
127impl<'a, const O: u8> HOSTDISCONDETECT_IRQ_W<'a, O> {
128    #[doc = "No effect"]
129    #[inline(always)]
130    pub fn disable(self) -> &'a mut W {
131        self.variant(HOSTDISCONDETECT_IRQ_A::DISABLE)
132    }
133    #[doc = "Clears the corresponding CTRL bit"]
134    #[inline(always)]
135    pub fn enable(self) -> &'a mut W {
136        self.variant(HOSTDISCONDETECT_IRQ_A::ENABLE)
137    }
138}
139#[doc = "Field `ENDEVPLUGINDET` reader - Enables non-standard resistive plugged-in detection."]
140pub type ENDEVPLUGINDET_R = crate::BitReader<ENDEVPLUGINDET_A>;
141#[doc = "Enables non-standard resistive plugged-in detection.\n\nValue on reset: 0"]
142#[derive(Clone, Copy, Debug, PartialEq, Eq)]
143pub enum ENDEVPLUGINDET_A {
144    #[doc = "0: No effect"]
145    DISABLE = 0,
146    #[doc = "1: Clears the corresponding CTRL bit"]
147    ENABLE = 1,
148}
149impl From<ENDEVPLUGINDET_A> for bool {
150    #[inline(always)]
151    fn from(variant: ENDEVPLUGINDET_A) -> Self {
152        variant as u8 != 0
153    }
154}
155impl ENDEVPLUGINDET_R {
156    #[doc = "Get enumerated values variant"]
157    #[inline(always)]
158    pub fn variant(&self) -> ENDEVPLUGINDET_A {
159        match self.bits {
160            false => ENDEVPLUGINDET_A::DISABLE,
161            true => ENDEVPLUGINDET_A::ENABLE,
162        }
163    }
164    #[doc = "Checks if the value of the field is `DISABLE`"]
165    #[inline(always)]
166    pub fn is_disable(&self) -> bool {
167        *self == ENDEVPLUGINDET_A::DISABLE
168    }
169    #[doc = "Checks if the value of the field is `ENABLE`"]
170    #[inline(always)]
171    pub fn is_enable(&self) -> bool {
172        *self == ENDEVPLUGINDET_A::ENABLE
173    }
174}
175#[doc = "Field `ENDEVPLUGINDET` writer - Enables non-standard resistive plugged-in detection."]
176pub type ENDEVPLUGINDET_W<'a, const O: u8> =
177    crate::BitWriter<'a, u32, CTRL_CLR_SPEC, ENDEVPLUGINDET_A, O>;
178impl<'a, const O: u8> ENDEVPLUGINDET_W<'a, O> {
179    #[doc = "No effect"]
180    #[inline(always)]
181    pub fn disable(self) -> &'a mut W {
182        self.variant(ENDEVPLUGINDET_A::DISABLE)
183    }
184    #[doc = "Clears the corresponding CTRL bit"]
185    #[inline(always)]
186    pub fn enable(self) -> &'a mut W {
187        self.variant(ENDEVPLUGINDET_A::ENABLE)
188    }
189}
190#[doc = "Field `DEVPLUGIN_IRQ` reader - Device connected indicator"]
191pub type DEVPLUGIN_IRQ_R = crate::BitReader<DEVPLUGIN_IRQ_A>;
192#[doc = "Device connected indicator\n\nValue on reset: 0"]
193#[derive(Clone, Copy, Debug, PartialEq, Eq)]
194pub enum DEVPLUGIN_IRQ_A {
195    #[doc = "0: No effect"]
196    DISABLE = 0,
197    #[doc = "1: Clears the corresponding CTRL bit"]
198    ENABLE = 1,
199}
200impl From<DEVPLUGIN_IRQ_A> for bool {
201    #[inline(always)]
202    fn from(variant: DEVPLUGIN_IRQ_A) -> Self {
203        variant as u8 != 0
204    }
205}
206impl DEVPLUGIN_IRQ_R {
207    #[doc = "Get enumerated values variant"]
208    #[inline(always)]
209    pub fn variant(&self) -> DEVPLUGIN_IRQ_A {
210        match self.bits {
211            false => DEVPLUGIN_IRQ_A::DISABLE,
212            true => DEVPLUGIN_IRQ_A::ENABLE,
213        }
214    }
215    #[doc = "Checks if the value of the field is `DISABLE`"]
216    #[inline(always)]
217    pub fn is_disable(&self) -> bool {
218        *self == DEVPLUGIN_IRQ_A::DISABLE
219    }
220    #[doc = "Checks if the value of the field is `ENABLE`"]
221    #[inline(always)]
222    pub fn is_enable(&self) -> bool {
223        *self == DEVPLUGIN_IRQ_A::ENABLE
224    }
225}
226#[doc = "Field `DEVPLUGIN_IRQ` writer - Device connected indicator"]
227pub type DEVPLUGIN_IRQ_W<'a, const O: u8> =
228    crate::BitWriter<'a, u32, CTRL_CLR_SPEC, DEVPLUGIN_IRQ_A, O>;
229impl<'a, const O: u8> DEVPLUGIN_IRQ_W<'a, O> {
230    #[doc = "No effect"]
231    #[inline(always)]
232    pub fn disable(self) -> &'a mut W {
233        self.variant(DEVPLUGIN_IRQ_A::DISABLE)
234    }
235    #[doc = "Clears the corresponding CTRL bit"]
236    #[inline(always)]
237    pub fn enable(self) -> &'a mut W {
238        self.variant(DEVPLUGIN_IRQ_A::ENABLE)
239    }
240}
241#[doc = "Field `ENUTMILEVEL2` reader - Enable level 2 operation"]
242pub type ENUTMILEVEL2_R = crate::BitReader<ENUTMILEVEL2_A>;
243#[doc = "Enable level 2 operation\n\nValue on reset: 0"]
244#[derive(Clone, Copy, Debug, PartialEq, Eq)]
245pub enum ENUTMILEVEL2_A {
246    #[doc = "0: No effect"]
247    DISABLE = 0,
248    #[doc = "1: Clears the corresponding CTRL bit"]
249    ENABLE = 1,
250}
251impl From<ENUTMILEVEL2_A> for bool {
252    #[inline(always)]
253    fn from(variant: ENUTMILEVEL2_A) -> Self {
254        variant as u8 != 0
255    }
256}
257impl ENUTMILEVEL2_R {
258    #[doc = "Get enumerated values variant"]
259    #[inline(always)]
260    pub fn variant(&self) -> ENUTMILEVEL2_A {
261        match self.bits {
262            false => ENUTMILEVEL2_A::DISABLE,
263            true => ENUTMILEVEL2_A::ENABLE,
264        }
265    }
266    #[doc = "Checks if the value of the field is `DISABLE`"]
267    #[inline(always)]
268    pub fn is_disable(&self) -> bool {
269        *self == ENUTMILEVEL2_A::DISABLE
270    }
271    #[doc = "Checks if the value of the field is `ENABLE`"]
272    #[inline(always)]
273    pub fn is_enable(&self) -> bool {
274        *self == ENUTMILEVEL2_A::ENABLE
275    }
276}
277#[doc = "Field `ENUTMILEVEL2` writer - Enable level 2 operation"]
278pub type ENUTMILEVEL2_W<'a, const O: u8> =
279    crate::BitWriter<'a, u32, CTRL_CLR_SPEC, ENUTMILEVEL2_A, O>;
280impl<'a, const O: u8> ENUTMILEVEL2_W<'a, O> {
281    #[doc = "No effect"]
282    #[inline(always)]
283    pub fn disable(self) -> &'a mut W {
284        self.variant(ENUTMILEVEL2_A::DISABLE)
285    }
286    #[doc = "Clears the corresponding CTRL bit"]
287    #[inline(always)]
288    pub fn enable(self) -> &'a mut W {
289        self.variant(ENUTMILEVEL2_A::ENABLE)
290    }
291}
292#[doc = "Field `ENUTMILEVEL3` reader - Enable level 2 operation"]
293pub type ENUTMILEVEL3_R = crate::BitReader<ENUTMILEVEL3_A>;
294#[doc = "Enable level 2 operation\n\nValue on reset: 0"]
295#[derive(Clone, Copy, Debug, PartialEq, Eq)]
296pub enum ENUTMILEVEL3_A {
297    #[doc = "0: No effect"]
298    DISABLE = 0,
299    #[doc = "1: Clears the corresponding CTRL bit"]
300    ENABLE = 1,
301}
302impl From<ENUTMILEVEL3_A> for bool {
303    #[inline(always)]
304    fn from(variant: ENUTMILEVEL3_A) -> Self {
305        variant as u8 != 0
306    }
307}
308impl ENUTMILEVEL3_R {
309    #[doc = "Get enumerated values variant"]
310    #[inline(always)]
311    pub fn variant(&self) -> ENUTMILEVEL3_A {
312        match self.bits {
313            false => ENUTMILEVEL3_A::DISABLE,
314            true => ENUTMILEVEL3_A::ENABLE,
315        }
316    }
317    #[doc = "Checks if the value of the field is `DISABLE`"]
318    #[inline(always)]
319    pub fn is_disable(&self) -> bool {
320        *self == ENUTMILEVEL3_A::DISABLE
321    }
322    #[doc = "Checks if the value of the field is `ENABLE`"]
323    #[inline(always)]
324    pub fn is_enable(&self) -> bool {
325        *self == ENUTMILEVEL3_A::ENABLE
326    }
327}
328#[doc = "Field `ENUTMILEVEL3` writer - Enable level 2 operation"]
329pub type ENUTMILEVEL3_W<'a, const O: u8> =
330    crate::BitWriter<'a, u32, CTRL_CLR_SPEC, ENUTMILEVEL3_A, O>;
331impl<'a, const O: u8> ENUTMILEVEL3_W<'a, O> {
332    #[doc = "No effect"]
333    #[inline(always)]
334    pub fn disable(self) -> &'a mut W {
335        self.variant(ENUTMILEVEL3_A::DISABLE)
336    }
337    #[doc = "Clears the corresponding CTRL bit"]
338    #[inline(always)]
339    pub fn enable(self) -> &'a mut W {
340        self.variant(ENUTMILEVEL3_A::ENABLE)
341    }
342}
343#[doc = "Field `AUTORESUME_EN` reader - Enable autoresume"]
344pub type AUTORESUME_EN_R = crate::BitReader<AUTORESUME_EN_A>;
345#[doc = "Enable autoresume\n\nValue on reset: 0"]
346#[derive(Clone, Copy, Debug, PartialEq, Eq)]
347pub enum AUTORESUME_EN_A {
348    #[doc = "0: No effect"]
349    DISABLE = 0,
350    #[doc = "1: Clears the corresponding CTRL bit"]
351    ENABLE = 1,
352}
353impl From<AUTORESUME_EN_A> for bool {
354    #[inline(always)]
355    fn from(variant: AUTORESUME_EN_A) -> Self {
356        variant as u8 != 0
357    }
358}
359impl AUTORESUME_EN_R {
360    #[doc = "Get enumerated values variant"]
361    #[inline(always)]
362    pub fn variant(&self) -> AUTORESUME_EN_A {
363        match self.bits {
364            false => AUTORESUME_EN_A::DISABLE,
365            true => AUTORESUME_EN_A::ENABLE,
366        }
367    }
368    #[doc = "Checks if the value of the field is `DISABLE`"]
369    #[inline(always)]
370    pub fn is_disable(&self) -> bool {
371        *self == AUTORESUME_EN_A::DISABLE
372    }
373    #[doc = "Checks if the value of the field is `ENABLE`"]
374    #[inline(always)]
375    pub fn is_enable(&self) -> bool {
376        *self == AUTORESUME_EN_A::ENABLE
377    }
378}
379#[doc = "Field `AUTORESUME_EN` writer - Enable autoresume"]
380pub type AUTORESUME_EN_W<'a, const O: u8> =
381    crate::BitWriter<'a, u32, CTRL_CLR_SPEC, AUTORESUME_EN_A, O>;
382impl<'a, const O: u8> AUTORESUME_EN_W<'a, O> {
383    #[doc = "No effect"]
384    #[inline(always)]
385    pub fn disable(self) -> &'a mut W {
386        self.variant(AUTORESUME_EN_A::DISABLE)
387    }
388    #[doc = "Clears the corresponding CTRL bit"]
389    #[inline(always)]
390    pub fn enable(self) -> &'a mut W {
391        self.variant(AUTORESUME_EN_A::ENABLE)
392    }
393}
394#[doc = "Field `ENAUTOCLR_CLKGATE` reader - Autoclear clock gate."]
395pub type ENAUTOCLR_CLKGATE_R = crate::BitReader<ENAUTOCLR_CLKGATE_A>;
396#[doc = "Autoclear clock gate.\n\nValue on reset: 0"]
397#[derive(Clone, Copy, Debug, PartialEq, Eq)]
398pub enum ENAUTOCLR_CLKGATE_A {
399    #[doc = "0: No effect"]
400    DISABLE = 0,
401    #[doc = "1: Clears the corresponding CTRL bit"]
402    ENABLE = 1,
403}
404impl From<ENAUTOCLR_CLKGATE_A> for bool {
405    #[inline(always)]
406    fn from(variant: ENAUTOCLR_CLKGATE_A) -> Self {
407        variant as u8 != 0
408    }
409}
410impl ENAUTOCLR_CLKGATE_R {
411    #[doc = "Get enumerated values variant"]
412    #[inline(always)]
413    pub fn variant(&self) -> ENAUTOCLR_CLKGATE_A {
414        match self.bits {
415            false => ENAUTOCLR_CLKGATE_A::DISABLE,
416            true => ENAUTOCLR_CLKGATE_A::ENABLE,
417        }
418    }
419    #[doc = "Checks if the value of the field is `DISABLE`"]
420    #[inline(always)]
421    pub fn is_disable(&self) -> bool {
422        *self == ENAUTOCLR_CLKGATE_A::DISABLE
423    }
424    #[doc = "Checks if the value of the field is `ENABLE`"]
425    #[inline(always)]
426    pub fn is_enable(&self) -> bool {
427        *self == ENAUTOCLR_CLKGATE_A::ENABLE
428    }
429}
430#[doc = "Field `ENAUTOCLR_CLKGATE` writer - Autoclear clock gate."]
431pub type ENAUTOCLR_CLKGATE_W<'a, const O: u8> =
432    crate::BitWriter<'a, u32, CTRL_CLR_SPEC, ENAUTOCLR_CLKGATE_A, O>;
433impl<'a, const O: u8> ENAUTOCLR_CLKGATE_W<'a, O> {
434    #[doc = "No effect"]
435    #[inline(always)]
436    pub fn disable(self) -> &'a mut W {
437        self.variant(ENAUTOCLR_CLKGATE_A::DISABLE)
438    }
439    #[doc = "Clears the corresponding CTRL bit"]
440    #[inline(always)]
441    pub fn enable(self) -> &'a mut W {
442        self.variant(ENAUTOCLR_CLKGATE_A::ENABLE)
443    }
444}
445#[doc = "Field `ENAUTOCLR_PHY_PWD` reader - Autoclear PWD register bits."]
446pub type ENAUTOCLR_PHY_PWD_R = crate::BitReader<ENAUTOCLR_PHY_PWD_A>;
447#[doc = "Autoclear PWD register bits.\n\nValue on reset: 0"]
448#[derive(Clone, Copy, Debug, PartialEq, Eq)]
449pub enum ENAUTOCLR_PHY_PWD_A {
450    #[doc = "0: No effect"]
451    DISABLE = 0,
452    #[doc = "1: Clears the corresponding CTRL bit"]
453    ENABLE = 1,
454}
455impl From<ENAUTOCLR_PHY_PWD_A> for bool {
456    #[inline(always)]
457    fn from(variant: ENAUTOCLR_PHY_PWD_A) -> Self {
458        variant as u8 != 0
459    }
460}
461impl ENAUTOCLR_PHY_PWD_R {
462    #[doc = "Get enumerated values variant"]
463    #[inline(always)]
464    pub fn variant(&self) -> ENAUTOCLR_PHY_PWD_A {
465        match self.bits {
466            false => ENAUTOCLR_PHY_PWD_A::DISABLE,
467            true => ENAUTOCLR_PHY_PWD_A::ENABLE,
468        }
469    }
470    #[doc = "Checks if the value of the field is `DISABLE`"]
471    #[inline(always)]
472    pub fn is_disable(&self) -> bool {
473        *self == ENAUTOCLR_PHY_PWD_A::DISABLE
474    }
475    #[doc = "Checks if the value of the field is `ENABLE`"]
476    #[inline(always)]
477    pub fn is_enable(&self) -> bool {
478        *self == ENAUTOCLR_PHY_PWD_A::ENABLE
479    }
480}
481#[doc = "Field `ENAUTOCLR_PHY_PWD` writer - Autoclear PWD register bits."]
482pub type ENAUTOCLR_PHY_PWD_W<'a, const O: u8> =
483    crate::BitWriter<'a, u32, CTRL_CLR_SPEC, ENAUTOCLR_PHY_PWD_A, O>;
484impl<'a, const O: u8> ENAUTOCLR_PHY_PWD_W<'a, O> {
485    #[doc = "No effect"]
486    #[inline(always)]
487    pub fn disable(self) -> &'a mut W {
488        self.variant(ENAUTOCLR_PHY_PWD_A::DISABLE)
489    }
490    #[doc = "Clears the corresponding CTRL bit"]
491    #[inline(always)]
492    pub fn enable(self) -> &'a mut W {
493        self.variant(ENAUTOCLR_PHY_PWD_A::ENABLE)
494    }
495}
496#[doc = "Field `FSDLL_RST_EN` reader - Reset FSDLL lock"]
497pub type FSDLL_RST_EN_R = crate::BitReader<FSDLL_RST_EN_A>;
498#[doc = "Reset FSDLL lock\n\nValue on reset: 0"]
499#[derive(Clone, Copy, Debug, PartialEq, Eq)]
500pub enum FSDLL_RST_EN_A {
501    #[doc = "0: No effect"]
502    DISABLE = 0,
503    #[doc = "1: Clears the corresponding CTRL bit"]
504    ENABLE = 1,
505}
506impl From<FSDLL_RST_EN_A> for bool {
507    #[inline(always)]
508    fn from(variant: FSDLL_RST_EN_A) -> Self {
509        variant as u8 != 0
510    }
511}
512impl FSDLL_RST_EN_R {
513    #[doc = "Get enumerated values variant"]
514    #[inline(always)]
515    pub fn variant(&self) -> FSDLL_RST_EN_A {
516        match self.bits {
517            false => FSDLL_RST_EN_A::DISABLE,
518            true => FSDLL_RST_EN_A::ENABLE,
519        }
520    }
521    #[doc = "Checks if the value of the field is `DISABLE`"]
522    #[inline(always)]
523    pub fn is_disable(&self) -> bool {
524        *self == FSDLL_RST_EN_A::DISABLE
525    }
526    #[doc = "Checks if the value of the field is `ENABLE`"]
527    #[inline(always)]
528    pub fn is_enable(&self) -> bool {
529        *self == FSDLL_RST_EN_A::ENABLE
530    }
531}
532#[doc = "Field `FSDLL_RST_EN` writer - Reset FSDLL lock"]
533pub type FSDLL_RST_EN_W<'a, const O: u8> =
534    crate::BitWriter<'a, u32, CTRL_CLR_SPEC, FSDLL_RST_EN_A, O>;
535impl<'a, const O: u8> FSDLL_RST_EN_W<'a, O> {
536    #[doc = "No effect"]
537    #[inline(always)]
538    pub fn disable(self) -> &'a mut W {
539        self.variant(FSDLL_RST_EN_A::DISABLE)
540    }
541    #[doc = "Clears the corresponding CTRL bit"]
542    #[inline(always)]
543    pub fn enable(self) -> &'a mut W {
544        self.variant(FSDLL_RST_EN_A::ENABLE)
545    }
546}
547#[doc = "Field `HOST_FORCE_LS_SE0` reader - FS EOP low-speed timing"]
548pub type HOST_FORCE_LS_SE0_R = crate::BitReader<bool>;
549#[doc = "Field `HOST_FORCE_LS_SE0` writer - FS EOP low-speed timing"]
550pub type HOST_FORCE_LS_SE0_W<'a, const O: u8> = crate::BitWriter<'a, u32, CTRL_CLR_SPEC, bool, O>;
551#[doc = "Field `UTMI_SUSPENDM` reader - UTMI suspend"]
552pub type UTMI_SUSPENDM_R = crate::BitReader<UTMI_SUSPENDM_A>;
553#[doc = "UTMI suspend\n\nValue on reset: 0"]
554#[derive(Clone, Copy, Debug, PartialEq, Eq)]
555pub enum UTMI_SUSPENDM_A {
556    #[doc = "0: No effect"]
557    DISABLE = 0,
558    #[doc = "1: Clears the corresponding CTRL bit"]
559    ENABLE = 1,
560}
561impl From<UTMI_SUSPENDM_A> for bool {
562    #[inline(always)]
563    fn from(variant: UTMI_SUSPENDM_A) -> Self {
564        variant as u8 != 0
565    }
566}
567impl UTMI_SUSPENDM_R {
568    #[doc = "Get enumerated values variant"]
569    #[inline(always)]
570    pub fn variant(&self) -> UTMI_SUSPENDM_A {
571        match self.bits {
572            false => UTMI_SUSPENDM_A::DISABLE,
573            true => UTMI_SUSPENDM_A::ENABLE,
574        }
575    }
576    #[doc = "Checks if the value of the field is `DISABLE`"]
577    #[inline(always)]
578    pub fn is_disable(&self) -> bool {
579        *self == UTMI_SUSPENDM_A::DISABLE
580    }
581    #[doc = "Checks if the value of the field is `ENABLE`"]
582    #[inline(always)]
583    pub fn is_enable(&self) -> bool {
584        *self == UTMI_SUSPENDM_A::ENABLE
585    }
586}
587#[doc = "Field `CLKGATE` reader - UTMI clock gate"]
588pub type CLKGATE_R = crate::BitReader<CLKGATE_A>;
589#[doc = "UTMI clock gate\n\nValue on reset: 1"]
590#[derive(Clone, Copy, Debug, PartialEq, Eq)]
591pub enum CLKGATE_A {
592    #[doc = "0: No effect"]
593    DISABLE = 0,
594    #[doc = "1: Clears the corresponding CTRL bit"]
595    ENABLE = 1,
596}
597impl From<CLKGATE_A> for bool {
598    #[inline(always)]
599    fn from(variant: CLKGATE_A) -> Self {
600        variant as u8 != 0
601    }
602}
603impl CLKGATE_R {
604    #[doc = "Get enumerated values variant"]
605    #[inline(always)]
606    pub fn variant(&self) -> CLKGATE_A {
607        match self.bits {
608            false => CLKGATE_A::DISABLE,
609            true => CLKGATE_A::ENABLE,
610        }
611    }
612    #[doc = "Checks if the value of the field is `DISABLE`"]
613    #[inline(always)]
614    pub fn is_disable(&self) -> bool {
615        *self == CLKGATE_A::DISABLE
616    }
617    #[doc = "Checks if the value of the field is `ENABLE`"]
618    #[inline(always)]
619    pub fn is_enable(&self) -> bool {
620        *self == CLKGATE_A::ENABLE
621    }
622}
623#[doc = "Field `CLKGATE` writer - UTMI clock gate"]
624pub type CLKGATE_W<'a, const O: u8> = crate::BitWriter<'a, u32, CTRL_CLR_SPEC, CLKGATE_A, O>;
625impl<'a, const O: u8> CLKGATE_W<'a, O> {
626    #[doc = "No effect"]
627    #[inline(always)]
628    pub fn disable(self) -> &'a mut W {
629        self.variant(CLKGATE_A::DISABLE)
630    }
631    #[doc = "Clears the corresponding CTRL bit"]
632    #[inline(always)]
633    pub fn enable(self) -> &'a mut W {
634        self.variant(CLKGATE_A::ENABLE)
635    }
636}
637#[doc = "Field `SFTRST` reader - Software reset"]
638pub type SFTRST_R = crate::BitReader<SFTRST_A>;
639#[doc = "Software reset\n\nValue on reset: 1"]
640#[derive(Clone, Copy, Debug, PartialEq, Eq)]
641pub enum SFTRST_A {
642    #[doc = "0: No effect"]
643    DISABLE = 0,
644    #[doc = "1: Clears the corresponding CTRL bit"]
645    ENABLE = 1,
646}
647impl From<SFTRST_A> for bool {
648    #[inline(always)]
649    fn from(variant: SFTRST_A) -> Self {
650        variant as u8 != 0
651    }
652}
653impl SFTRST_R {
654    #[doc = "Get enumerated values variant"]
655    #[inline(always)]
656    pub fn variant(&self) -> SFTRST_A {
657        match self.bits {
658            false => SFTRST_A::DISABLE,
659            true => SFTRST_A::ENABLE,
660        }
661    }
662    #[doc = "Checks if the value of the field is `DISABLE`"]
663    #[inline(always)]
664    pub fn is_disable(&self) -> bool {
665        *self == SFTRST_A::DISABLE
666    }
667    #[doc = "Checks if the value of the field is `ENABLE`"]
668    #[inline(always)]
669    pub fn is_enable(&self) -> bool {
670        *self == SFTRST_A::ENABLE
671    }
672}
673#[doc = "Field `SFTRST` writer - Software reset"]
674pub type SFTRST_W<'a, const O: u8> = crate::BitWriter<'a, u32, CTRL_CLR_SPEC, SFTRST_A, O>;
675impl<'a, const O: u8> SFTRST_W<'a, O> {
676    #[doc = "No effect"]
677    #[inline(always)]
678    pub fn disable(self) -> &'a mut W {
679        self.variant(SFTRST_A::DISABLE)
680    }
681    #[doc = "Clears the corresponding CTRL bit"]
682    #[inline(always)]
683    pub fn enable(self) -> &'a mut W {
684        self.variant(SFTRST_A::ENABLE)
685    }
686}
687impl R {
688    #[doc = "Bit 1 - Disconnect detect."]
689    #[inline(always)]
690    pub fn enhostdiscondetect(&self) -> ENHOSTDISCONDETECT_R {
691        ENHOSTDISCONDETECT_R::new(((self.bits >> 1) & 1) != 0)
692    }
693    #[doc = "Bit 3 - Device disconnect indication."]
694    #[inline(always)]
695    pub fn hostdiscondetect_irq(&self) -> HOSTDISCONDETECT_IRQ_R {
696        HOSTDISCONDETECT_IRQ_R::new(((self.bits >> 3) & 1) != 0)
697    }
698    #[doc = "Bit 4 - Enables non-standard resistive plugged-in detection."]
699    #[inline(always)]
700    pub fn endevplugindet(&self) -> ENDEVPLUGINDET_R {
701        ENDEVPLUGINDET_R::new(((self.bits >> 4) & 1) != 0)
702    }
703    #[doc = "Bit 12 - Device connected indicator"]
704    #[inline(always)]
705    pub fn devplugin_irq(&self) -> DEVPLUGIN_IRQ_R {
706        DEVPLUGIN_IRQ_R::new(((self.bits >> 12) & 1) != 0)
707    }
708    #[doc = "Bit 14 - Enable level 2 operation"]
709    #[inline(always)]
710    pub fn enutmilevel2(&self) -> ENUTMILEVEL2_R {
711        ENUTMILEVEL2_R::new(((self.bits >> 14) & 1) != 0)
712    }
713    #[doc = "Bit 15 - Enable level 2 operation"]
714    #[inline(always)]
715    pub fn enutmilevel3(&self) -> ENUTMILEVEL3_R {
716        ENUTMILEVEL3_R::new(((self.bits >> 15) & 1) != 0)
717    }
718    #[doc = "Bit 18 - Enable autoresume"]
719    #[inline(always)]
720    pub fn autoresume_en(&self) -> AUTORESUME_EN_R {
721        AUTORESUME_EN_R::new(((self.bits >> 18) & 1) != 0)
722    }
723    #[doc = "Bit 19 - Autoclear clock gate."]
724    #[inline(always)]
725    pub fn enautoclr_clkgate(&self) -> ENAUTOCLR_CLKGATE_R {
726        ENAUTOCLR_CLKGATE_R::new(((self.bits >> 19) & 1) != 0)
727    }
728    #[doc = "Bit 20 - Autoclear PWD register bits."]
729    #[inline(always)]
730    pub fn enautoclr_phy_pwd(&self) -> ENAUTOCLR_PHY_PWD_R {
731        ENAUTOCLR_PHY_PWD_R::new(((self.bits >> 20) & 1) != 0)
732    }
733    #[doc = "Bit 24 - Reset FSDLL lock"]
734    #[inline(always)]
735    pub fn fsdll_rst_en(&self) -> FSDLL_RST_EN_R {
736        FSDLL_RST_EN_R::new(((self.bits >> 24) & 1) != 0)
737    }
738    #[doc = "Bit 28 - FS EOP low-speed timing"]
739    #[inline(always)]
740    pub fn host_force_ls_se0(&self) -> HOST_FORCE_LS_SE0_R {
741        HOST_FORCE_LS_SE0_R::new(((self.bits >> 28) & 1) != 0)
742    }
743    #[doc = "Bit 29 - UTMI suspend"]
744    #[inline(always)]
745    pub fn utmi_suspendm(&self) -> UTMI_SUSPENDM_R {
746        UTMI_SUSPENDM_R::new(((self.bits >> 29) & 1) != 0)
747    }
748    #[doc = "Bit 30 - UTMI clock gate"]
749    #[inline(always)]
750    pub fn clkgate(&self) -> CLKGATE_R {
751        CLKGATE_R::new(((self.bits >> 30) & 1) != 0)
752    }
753    #[doc = "Bit 31 - Software reset"]
754    #[inline(always)]
755    pub fn sftrst(&self) -> SFTRST_R {
756        SFTRST_R::new(((self.bits >> 31) & 1) != 0)
757    }
758}
759impl W {
760    #[doc = "Bit 1 - Disconnect detect."]
761    #[inline(always)]
762    #[must_use]
763    pub fn enhostdiscondetect(&mut self) -> ENHOSTDISCONDETECT_W<1> {
764        ENHOSTDISCONDETECT_W::new(self)
765    }
766    #[doc = "Bit 3 - Device disconnect indication."]
767    #[inline(always)]
768    #[must_use]
769    pub fn hostdiscondetect_irq(&mut self) -> HOSTDISCONDETECT_IRQ_W<3> {
770        HOSTDISCONDETECT_IRQ_W::new(self)
771    }
772    #[doc = "Bit 4 - Enables non-standard resistive plugged-in detection."]
773    #[inline(always)]
774    #[must_use]
775    pub fn endevplugindet(&mut self) -> ENDEVPLUGINDET_W<4> {
776        ENDEVPLUGINDET_W::new(self)
777    }
778    #[doc = "Bit 12 - Device connected indicator"]
779    #[inline(always)]
780    #[must_use]
781    pub fn devplugin_irq(&mut self) -> DEVPLUGIN_IRQ_W<12> {
782        DEVPLUGIN_IRQ_W::new(self)
783    }
784    #[doc = "Bit 14 - Enable level 2 operation"]
785    #[inline(always)]
786    #[must_use]
787    pub fn enutmilevel2(&mut self) -> ENUTMILEVEL2_W<14> {
788        ENUTMILEVEL2_W::new(self)
789    }
790    #[doc = "Bit 15 - Enable level 2 operation"]
791    #[inline(always)]
792    #[must_use]
793    pub fn enutmilevel3(&mut self) -> ENUTMILEVEL3_W<15> {
794        ENUTMILEVEL3_W::new(self)
795    }
796    #[doc = "Bit 18 - Enable autoresume"]
797    #[inline(always)]
798    #[must_use]
799    pub fn autoresume_en(&mut self) -> AUTORESUME_EN_W<18> {
800        AUTORESUME_EN_W::new(self)
801    }
802    #[doc = "Bit 19 - Autoclear clock gate."]
803    #[inline(always)]
804    #[must_use]
805    pub fn enautoclr_clkgate(&mut self) -> ENAUTOCLR_CLKGATE_W<19> {
806        ENAUTOCLR_CLKGATE_W::new(self)
807    }
808    #[doc = "Bit 20 - Autoclear PWD register bits."]
809    #[inline(always)]
810    #[must_use]
811    pub fn enautoclr_phy_pwd(&mut self) -> ENAUTOCLR_PHY_PWD_W<20> {
812        ENAUTOCLR_PHY_PWD_W::new(self)
813    }
814    #[doc = "Bit 24 - Reset FSDLL lock"]
815    #[inline(always)]
816    #[must_use]
817    pub fn fsdll_rst_en(&mut self) -> FSDLL_RST_EN_W<24> {
818        FSDLL_RST_EN_W::new(self)
819    }
820    #[doc = "Bit 28 - FS EOP low-speed timing"]
821    #[inline(always)]
822    #[must_use]
823    pub fn host_force_ls_se0(&mut self) -> HOST_FORCE_LS_SE0_W<28> {
824        HOST_FORCE_LS_SE0_W::new(self)
825    }
826    #[doc = "Bit 30 - UTMI clock gate"]
827    #[inline(always)]
828    #[must_use]
829    pub fn clkgate(&mut self) -> CLKGATE_W<30> {
830        CLKGATE_W::new(self)
831    }
832    #[doc = "Bit 31 - Software reset"]
833    #[inline(always)]
834    #[must_use]
835    pub fn sftrst(&mut self) -> SFTRST_W<31> {
836        SFTRST_W::new(self)
837    }
838    #[doc = "Writes raw bits to the register."]
839    #[inline(always)]
840    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
841        self.0.bits(bits);
842        self
843    }
844}
845#[doc = "General Purpose Control Clear\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 [ctrl_clr](index.html) module"]
846pub struct CTRL_CLR_SPEC;
847impl crate::RegisterSpec for CTRL_CLR_SPEC {
848    type Ux = u32;
849}
850#[doc = "`read()` method returns [ctrl_clr::R](R) reader structure"]
851impl crate::Readable for CTRL_CLR_SPEC {
852    type Reader = R;
853}
854#[doc = "`write(|w| ..)` method takes [ctrl_clr::W](W) writer structure"]
855impl crate::Writable for CTRL_CLR_SPEC {
856    type Writer = W;
857    const ZERO_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
858    const ONE_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
859}
860#[doc = "`reset()` method sets CTRL_CLR to value 0xc000_0000"]
861impl crate::Resettable for CTRL_CLR_SPEC {
862    const RESET_VALUE: Self::Ux = 0xc000_0000;
863}
mimxrt595s/usbphy/ctrl_clr.rs

mimxrt595s/usbphy/
ctrl_clr.rs
