nrf52840_pac/usbd/
intenset.rs

Help
1#[doc = "Register `INTENSET` reader"]
2pub struct R(crate::R<INTENSET_SPEC>);
3impl core::ops::Deref for R {
4    type Target = crate::R<INTENSET_SPEC>;
5    #[inline(always)]
6    fn deref(&self) -> &Self::Target {
7        &self.0
8    }
9}
10impl From<crate::R<INTENSET_SPEC>> for R {
11    #[inline(always)]
12    fn from(reader: crate::R<INTENSET_SPEC>) -> Self {
13        R(reader)
14    }
15}
16#[doc = "Register `INTENSET` writer"]
17pub struct W(crate::W<INTENSET_SPEC>);
18impl core::ops::Deref for W {
19    type Target = crate::W<INTENSET_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<INTENSET_SPEC>> for W {
32    #[inline(always)]
33    fn from(writer: crate::W<INTENSET_SPEC>) -> Self {
34        W(writer)
35    }
36}
37#[doc = "Field `USBRESET` reader - Write '1' to enable interrupt for USBRESET event"]
38pub type USBRESET_R = crate::BitReader<USBRESET_A>;
39#[doc = "Write '1' to enable interrupt for USBRESET event\n\nValue on reset: 0"]
40#[derive(Clone, Copy, Debug, PartialEq)]
41pub enum USBRESET_A {
42    #[doc = "0: Read: Disabled"]
43    DISABLED = 0,
44    #[doc = "1: Read: Enabled"]
45    ENABLED = 1,
46}
47impl From<USBRESET_A> for bool {
48    #[inline(always)]
49    fn from(variant: USBRESET_A) -> Self {
50        variant as u8 != 0
51    }
52}
53impl USBRESET_R {
54    #[doc = "Get enumerated values variant"]
55    #[inline(always)]
56    pub fn variant(&self) -> USBRESET_A {
57        match self.bits {
58            false => USBRESET_A::DISABLED,
59            true => USBRESET_A::ENABLED,
60        }
61    }
62    #[doc = "Checks if the value of the field is `DISABLED`"]
63    #[inline(always)]
64    pub fn is_disabled(&self) -> bool {
65        *self == USBRESET_A::DISABLED
66    }
67    #[doc = "Checks if the value of the field is `ENABLED`"]
68    #[inline(always)]
69    pub fn is_enabled(&self) -> bool {
70        *self == USBRESET_A::ENABLED
71    }
72}
73#[doc = "Write '1' to enable interrupt for USBRESET event\n\nValue on reset: 0"]
74#[derive(Clone, Copy, Debug, PartialEq)]
75pub enum USBRESET_AW {
76    #[doc = "1: Enable"]
77    SET = 1,
78}
79impl From<USBRESET_AW> for bool {
80    #[inline(always)]
81    fn from(variant: USBRESET_AW) -> Self {
82        variant as u8 != 0
83    }
84}
85#[doc = "Field `USBRESET` writer - Write '1' to enable interrupt for USBRESET event"]
86pub type USBRESET_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, USBRESET_AW, O>;
87impl<'a, const O: u8> USBRESET_W<'a, O> {
88    #[doc = "Enable"]
89    #[inline(always)]
90    pub fn set(self) -> &'a mut W {
91        self.variant(USBRESET_AW::SET)
92    }
93}
94#[doc = "Field `STARTED` reader - Write '1' to enable interrupt for STARTED event"]
95pub type STARTED_R = crate::BitReader<STARTED_A>;
96#[doc = "Write '1' to enable interrupt for STARTED event\n\nValue on reset: 0"]
97#[derive(Clone, Copy, Debug, PartialEq)]
98pub enum STARTED_A {
99    #[doc = "0: Read: Disabled"]
100    DISABLED = 0,
101    #[doc = "1: Read: Enabled"]
102    ENABLED = 1,
103}
104impl From<STARTED_A> for bool {
105    #[inline(always)]
106    fn from(variant: STARTED_A) -> Self {
107        variant as u8 != 0
108    }
109}
110impl STARTED_R {
111    #[doc = "Get enumerated values variant"]
112    #[inline(always)]
113    pub fn variant(&self) -> STARTED_A {
114        match self.bits {
115            false => STARTED_A::DISABLED,
116            true => STARTED_A::ENABLED,
117        }
118    }
119    #[doc = "Checks if the value of the field is `DISABLED`"]
120    #[inline(always)]
121    pub fn is_disabled(&self) -> bool {
122        *self == STARTED_A::DISABLED
123    }
124    #[doc = "Checks if the value of the field is `ENABLED`"]
125    #[inline(always)]
126    pub fn is_enabled(&self) -> bool {
127        *self == STARTED_A::ENABLED
128    }
129}
130#[doc = "Write '1' to enable interrupt for STARTED event\n\nValue on reset: 0"]
131#[derive(Clone, Copy, Debug, PartialEq)]
132pub enum STARTED_AW {
133    #[doc = "1: Enable"]
134    SET = 1,
135}
136impl From<STARTED_AW> for bool {
137    #[inline(always)]
138    fn from(variant: STARTED_AW) -> Self {
139        variant as u8 != 0
140    }
141}
142#[doc = "Field `STARTED` writer - Write '1' to enable interrupt for STARTED event"]
143pub type STARTED_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, STARTED_AW, O>;
144impl<'a, const O: u8> STARTED_W<'a, O> {
145    #[doc = "Enable"]
146    #[inline(always)]
147    pub fn set(self) -> &'a mut W {
148        self.variant(STARTED_AW::SET)
149    }
150}
151#[doc = "Field `ENDEPIN0` reader - Write '1' to enable interrupt for ENDEPIN\\[0\\]
152event"]
153pub type ENDEPIN0_R = crate::BitReader<ENDEPIN0_A>;
154#[doc = "Write '1' to enable interrupt for ENDEPIN\\[0\\]
155event\n\nValue on reset: 0"]
156#[derive(Clone, Copy, Debug, PartialEq)]
157pub enum ENDEPIN0_A {
158    #[doc = "0: Read: Disabled"]
159    DISABLED = 0,
160    #[doc = "1: Read: Enabled"]
161    ENABLED = 1,
162}
163impl From<ENDEPIN0_A> for bool {
164    #[inline(always)]
165    fn from(variant: ENDEPIN0_A) -> Self {
166        variant as u8 != 0
167    }
168}
169impl ENDEPIN0_R {
170    #[doc = "Get enumerated values variant"]
171    #[inline(always)]
172    pub fn variant(&self) -> ENDEPIN0_A {
173        match self.bits {
174            false => ENDEPIN0_A::DISABLED,
175            true => ENDEPIN0_A::ENABLED,
176        }
177    }
178    #[doc = "Checks if the value of the field is `DISABLED`"]
179    #[inline(always)]
180    pub fn is_disabled(&self) -> bool {
181        *self == ENDEPIN0_A::DISABLED
182    }
183    #[doc = "Checks if the value of the field is `ENABLED`"]
184    #[inline(always)]
185    pub fn is_enabled(&self) -> bool {
186        *self == ENDEPIN0_A::ENABLED
187    }
188}
189#[doc = "Write '1' to enable interrupt for ENDEPIN\\[0\\]
190event\n\nValue on reset: 0"]
191#[derive(Clone, Copy, Debug, PartialEq)]
192pub enum ENDEPIN0_AW {
193    #[doc = "1: Enable"]
194    SET = 1,
195}
196impl From<ENDEPIN0_AW> for bool {
197    #[inline(always)]
198    fn from(variant: ENDEPIN0_AW) -> Self {
199        variant as u8 != 0
200    }
201}
202#[doc = "Field `ENDEPIN0` writer - Write '1' to enable interrupt for ENDEPIN\\[0\\]
203event"]
204pub type ENDEPIN0_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, ENDEPIN0_AW, O>;
205impl<'a, const O: u8> ENDEPIN0_W<'a, O> {
206    #[doc = "Enable"]
207    #[inline(always)]
208    pub fn set(self) -> &'a mut W {
209        self.variant(ENDEPIN0_AW::SET)
210    }
211}
212#[doc = "Field `ENDEPIN1` reader - Write '1' to enable interrupt for ENDEPIN\\[1\\]
213event"]
214pub type ENDEPIN1_R = crate::BitReader<ENDEPIN1_A>;
215#[doc = "Write '1' to enable interrupt for ENDEPIN\\[1\\]
216event\n\nValue on reset: 0"]
217#[derive(Clone, Copy, Debug, PartialEq)]
218pub enum ENDEPIN1_A {
219    #[doc = "0: Read: Disabled"]
220    DISABLED = 0,
221    #[doc = "1: Read: Enabled"]
222    ENABLED = 1,
223}
224impl From<ENDEPIN1_A> for bool {
225    #[inline(always)]
226    fn from(variant: ENDEPIN1_A) -> Self {
227        variant as u8 != 0
228    }
229}
230impl ENDEPIN1_R {
231    #[doc = "Get enumerated values variant"]
232    #[inline(always)]
233    pub fn variant(&self) -> ENDEPIN1_A {
234        match self.bits {
235            false => ENDEPIN1_A::DISABLED,
236            true => ENDEPIN1_A::ENABLED,
237        }
238    }
239    #[doc = "Checks if the value of the field is `DISABLED`"]
240    #[inline(always)]
241    pub fn is_disabled(&self) -> bool {
242        *self == ENDEPIN1_A::DISABLED
243    }
244    #[doc = "Checks if the value of the field is `ENABLED`"]
245    #[inline(always)]
246    pub fn is_enabled(&self) -> bool {
247        *self == ENDEPIN1_A::ENABLED
248    }
249}
250#[doc = "Write '1' to enable interrupt for ENDEPIN\\[1\\]
251event\n\nValue on reset: 0"]
252#[derive(Clone, Copy, Debug, PartialEq)]
253pub enum ENDEPIN1_AW {
254    #[doc = "1: Enable"]
255    SET = 1,
256}
257impl From<ENDEPIN1_AW> for bool {
258    #[inline(always)]
259    fn from(variant: ENDEPIN1_AW) -> Self {
260        variant as u8 != 0
261    }
262}
263#[doc = "Field `ENDEPIN1` writer - Write '1' to enable interrupt for ENDEPIN\\[1\\]
264event"]
265pub type ENDEPIN1_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, ENDEPIN1_AW, O>;
266impl<'a, const O: u8> ENDEPIN1_W<'a, O> {
267    #[doc = "Enable"]
268    #[inline(always)]
269    pub fn set(self) -> &'a mut W {
270        self.variant(ENDEPIN1_AW::SET)
271    }
272}
273#[doc = "Field `ENDEPIN2` reader - Write '1' to enable interrupt for ENDEPIN\\[2\\]
274event"]
275pub type ENDEPIN2_R = crate::BitReader<ENDEPIN2_A>;
276#[doc = "Write '1' to enable interrupt for ENDEPIN\\[2\\]
277event\n\nValue on reset: 0"]
278#[derive(Clone, Copy, Debug, PartialEq)]
279pub enum ENDEPIN2_A {
280    #[doc = "0: Read: Disabled"]
281    DISABLED = 0,
282    #[doc = "1: Read: Enabled"]
283    ENABLED = 1,
284}
285impl From<ENDEPIN2_A> for bool {
286    #[inline(always)]
287    fn from(variant: ENDEPIN2_A) -> Self {
288        variant as u8 != 0
289    }
290}
291impl ENDEPIN2_R {
292    #[doc = "Get enumerated values variant"]
293    #[inline(always)]
294    pub fn variant(&self) -> ENDEPIN2_A {
295        match self.bits {
296            false => ENDEPIN2_A::DISABLED,
297            true => ENDEPIN2_A::ENABLED,
298        }
299    }
300    #[doc = "Checks if the value of the field is `DISABLED`"]
301    #[inline(always)]
302    pub fn is_disabled(&self) -> bool {
303        *self == ENDEPIN2_A::DISABLED
304    }
305    #[doc = "Checks if the value of the field is `ENABLED`"]
306    #[inline(always)]
307    pub fn is_enabled(&self) -> bool {
308        *self == ENDEPIN2_A::ENABLED
309    }
310}
311#[doc = "Write '1' to enable interrupt for ENDEPIN\\[2\\]
312event\n\nValue on reset: 0"]
313#[derive(Clone, Copy, Debug, PartialEq)]
314pub enum ENDEPIN2_AW {
315    #[doc = "1: Enable"]
316    SET = 1,
317}
318impl From<ENDEPIN2_AW> for bool {
319    #[inline(always)]
320    fn from(variant: ENDEPIN2_AW) -> Self {
321        variant as u8 != 0
322    }
323}
324#[doc = "Field `ENDEPIN2` writer - Write '1' to enable interrupt for ENDEPIN\\[2\\]
325event"]
326pub type ENDEPIN2_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, ENDEPIN2_AW, O>;
327impl<'a, const O: u8> ENDEPIN2_W<'a, O> {
328    #[doc = "Enable"]
329    #[inline(always)]
330    pub fn set(self) -> &'a mut W {
331        self.variant(ENDEPIN2_AW::SET)
332    }
333}
334#[doc = "Field `ENDEPIN3` reader - Write '1' to enable interrupt for ENDEPIN\\[3\\]
335event"]
336pub type ENDEPIN3_R = crate::BitReader<ENDEPIN3_A>;
337#[doc = "Write '1' to enable interrupt for ENDEPIN\\[3\\]
338event\n\nValue on reset: 0"]
339#[derive(Clone, Copy, Debug, PartialEq)]
340pub enum ENDEPIN3_A {
341    #[doc = "0: Read: Disabled"]
342    DISABLED = 0,
343    #[doc = "1: Read: Enabled"]
344    ENABLED = 1,
345}
346impl From<ENDEPIN3_A> for bool {
347    #[inline(always)]
348    fn from(variant: ENDEPIN3_A) -> Self {
349        variant as u8 != 0
350    }
351}
352impl ENDEPIN3_R {
353    #[doc = "Get enumerated values variant"]
354    #[inline(always)]
355    pub fn variant(&self) -> ENDEPIN3_A {
356        match self.bits {
357            false => ENDEPIN3_A::DISABLED,
358            true => ENDEPIN3_A::ENABLED,
359        }
360    }
361    #[doc = "Checks if the value of the field is `DISABLED`"]
362    #[inline(always)]
363    pub fn is_disabled(&self) -> bool {
364        *self == ENDEPIN3_A::DISABLED
365    }
366    #[doc = "Checks if the value of the field is `ENABLED`"]
367    #[inline(always)]
368    pub fn is_enabled(&self) -> bool {
369        *self == ENDEPIN3_A::ENABLED
370    }
371}
372#[doc = "Write '1' to enable interrupt for ENDEPIN\\[3\\]
373event\n\nValue on reset: 0"]
374#[derive(Clone, Copy, Debug, PartialEq)]
375pub enum ENDEPIN3_AW {
376    #[doc = "1: Enable"]
377    SET = 1,
378}
379impl From<ENDEPIN3_AW> for bool {
380    #[inline(always)]
381    fn from(variant: ENDEPIN3_AW) -> Self {
382        variant as u8 != 0
383    }
384}
385#[doc = "Field `ENDEPIN3` writer - Write '1' to enable interrupt for ENDEPIN\\[3\\]
386event"]
387pub type ENDEPIN3_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, ENDEPIN3_AW, O>;
388impl<'a, const O: u8> ENDEPIN3_W<'a, O> {
389    #[doc = "Enable"]
390    #[inline(always)]
391    pub fn set(self) -> &'a mut W {
392        self.variant(ENDEPIN3_AW::SET)
393    }
394}
395#[doc = "Field `ENDEPIN4` reader - Write '1' to enable interrupt for ENDEPIN\\[4\\]
396event"]
397pub type ENDEPIN4_R = crate::BitReader<ENDEPIN4_A>;
398#[doc = "Write '1' to enable interrupt for ENDEPIN\\[4\\]
399event\n\nValue on reset: 0"]
400#[derive(Clone, Copy, Debug, PartialEq)]
401pub enum ENDEPIN4_A {
402    #[doc = "0: Read: Disabled"]
403    DISABLED = 0,
404    #[doc = "1: Read: Enabled"]
405    ENABLED = 1,
406}
407impl From<ENDEPIN4_A> for bool {
408    #[inline(always)]
409    fn from(variant: ENDEPIN4_A) -> Self {
410        variant as u8 != 0
411    }
412}
413impl ENDEPIN4_R {
414    #[doc = "Get enumerated values variant"]
415    #[inline(always)]
416    pub fn variant(&self) -> ENDEPIN4_A {
417        match self.bits {
418            false => ENDEPIN4_A::DISABLED,
419            true => ENDEPIN4_A::ENABLED,
420        }
421    }
422    #[doc = "Checks if the value of the field is `DISABLED`"]
423    #[inline(always)]
424    pub fn is_disabled(&self) -> bool {
425        *self == ENDEPIN4_A::DISABLED
426    }
427    #[doc = "Checks if the value of the field is `ENABLED`"]
428    #[inline(always)]
429    pub fn is_enabled(&self) -> bool {
430        *self == ENDEPIN4_A::ENABLED
431    }
432}
433#[doc = "Write '1' to enable interrupt for ENDEPIN\\[4\\]
434event\n\nValue on reset: 0"]
435#[derive(Clone, Copy, Debug, PartialEq)]
436pub enum ENDEPIN4_AW {
437    #[doc = "1: Enable"]
438    SET = 1,
439}
440impl From<ENDEPIN4_AW> for bool {
441    #[inline(always)]
442    fn from(variant: ENDEPIN4_AW) -> Self {
443        variant as u8 != 0
444    }
445}
446#[doc = "Field `ENDEPIN4` writer - Write '1' to enable interrupt for ENDEPIN\\[4\\]
447event"]
448pub type ENDEPIN4_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, ENDEPIN4_AW, O>;
449impl<'a, const O: u8> ENDEPIN4_W<'a, O> {
450    #[doc = "Enable"]
451    #[inline(always)]
452    pub fn set(self) -> &'a mut W {
453        self.variant(ENDEPIN4_AW::SET)
454    }
455}
456#[doc = "Field `ENDEPIN5` reader - Write '1' to enable interrupt for ENDEPIN\\[5\\]
457event"]
458pub type ENDEPIN5_R = crate::BitReader<ENDEPIN5_A>;
459#[doc = "Write '1' to enable interrupt for ENDEPIN\\[5\\]
460event\n\nValue on reset: 0"]
461#[derive(Clone, Copy, Debug, PartialEq)]
462pub enum ENDEPIN5_A {
463    #[doc = "0: Read: Disabled"]
464    DISABLED = 0,
465    #[doc = "1: Read: Enabled"]
466    ENABLED = 1,
467}
468impl From<ENDEPIN5_A> for bool {
469    #[inline(always)]
470    fn from(variant: ENDEPIN5_A) -> Self {
471        variant as u8 != 0
472    }
473}
474impl ENDEPIN5_R {
475    #[doc = "Get enumerated values variant"]
476    #[inline(always)]
477    pub fn variant(&self) -> ENDEPIN5_A {
478        match self.bits {
479            false => ENDEPIN5_A::DISABLED,
480            true => ENDEPIN5_A::ENABLED,
481        }
482    }
483    #[doc = "Checks if the value of the field is `DISABLED`"]
484    #[inline(always)]
485    pub fn is_disabled(&self) -> bool {
486        *self == ENDEPIN5_A::DISABLED
487    }
488    #[doc = "Checks if the value of the field is `ENABLED`"]
489    #[inline(always)]
490    pub fn is_enabled(&self) -> bool {
491        *self == ENDEPIN5_A::ENABLED
492    }
493}
494#[doc = "Write '1' to enable interrupt for ENDEPIN\\[5\\]
495event\n\nValue on reset: 0"]
496#[derive(Clone, Copy, Debug, PartialEq)]
497pub enum ENDEPIN5_AW {
498    #[doc = "1: Enable"]
499    SET = 1,
500}
501impl From<ENDEPIN5_AW> for bool {
502    #[inline(always)]
503    fn from(variant: ENDEPIN5_AW) -> Self {
504        variant as u8 != 0
505    }
506}
507#[doc = "Field `ENDEPIN5` writer - Write '1' to enable interrupt for ENDEPIN\\[5\\]
508event"]
509pub type ENDEPIN5_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, ENDEPIN5_AW, O>;
510impl<'a, const O: u8> ENDEPIN5_W<'a, O> {
511    #[doc = "Enable"]
512    #[inline(always)]
513    pub fn set(self) -> &'a mut W {
514        self.variant(ENDEPIN5_AW::SET)
515    }
516}
517#[doc = "Field `ENDEPIN6` reader - Write '1' to enable interrupt for ENDEPIN\\[6\\]
518event"]
519pub type ENDEPIN6_R = crate::BitReader<ENDEPIN6_A>;
520#[doc = "Write '1' to enable interrupt for ENDEPIN\\[6\\]
521event\n\nValue on reset: 0"]
522#[derive(Clone, Copy, Debug, PartialEq)]
523pub enum ENDEPIN6_A {
524    #[doc = "0: Read: Disabled"]
525    DISABLED = 0,
526    #[doc = "1: Read: Enabled"]
527    ENABLED = 1,
528}
529impl From<ENDEPIN6_A> for bool {
530    #[inline(always)]
531    fn from(variant: ENDEPIN6_A) -> Self {
532        variant as u8 != 0
533    }
534}
535impl ENDEPIN6_R {
536    #[doc = "Get enumerated values variant"]
537    #[inline(always)]
538    pub fn variant(&self) -> ENDEPIN6_A {
539        match self.bits {
540            false => ENDEPIN6_A::DISABLED,
541            true => ENDEPIN6_A::ENABLED,
542        }
543    }
544    #[doc = "Checks if the value of the field is `DISABLED`"]
545    #[inline(always)]
546    pub fn is_disabled(&self) -> bool {
547        *self == ENDEPIN6_A::DISABLED
548    }
549    #[doc = "Checks if the value of the field is `ENABLED`"]
550    #[inline(always)]
551    pub fn is_enabled(&self) -> bool {
552        *self == ENDEPIN6_A::ENABLED
553    }
554}
555#[doc = "Write '1' to enable interrupt for ENDEPIN\\[6\\]
556event\n\nValue on reset: 0"]
557#[derive(Clone, Copy, Debug, PartialEq)]
558pub enum ENDEPIN6_AW {
559    #[doc = "1: Enable"]
560    SET = 1,
561}
562impl From<ENDEPIN6_AW> for bool {
563    #[inline(always)]
564    fn from(variant: ENDEPIN6_AW) -> Self {
565        variant as u8 != 0
566    }
567}
568#[doc = "Field `ENDEPIN6` writer - Write '1' to enable interrupt for ENDEPIN\\[6\\]
569event"]
570pub type ENDEPIN6_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, ENDEPIN6_AW, O>;
571impl<'a, const O: u8> ENDEPIN6_W<'a, O> {
572    #[doc = "Enable"]
573    #[inline(always)]
574    pub fn set(self) -> &'a mut W {
575        self.variant(ENDEPIN6_AW::SET)
576    }
577}
578#[doc = "Field `ENDEPIN7` reader - Write '1' to enable interrupt for ENDEPIN\\[7\\]
579event"]
580pub type ENDEPIN7_R = crate::BitReader<ENDEPIN7_A>;
581#[doc = "Write '1' to enable interrupt for ENDEPIN\\[7\\]
582event\n\nValue on reset: 0"]
583#[derive(Clone, Copy, Debug, PartialEq)]
584pub enum ENDEPIN7_A {
585    #[doc = "0: Read: Disabled"]
586    DISABLED = 0,
587    #[doc = "1: Read: Enabled"]
588    ENABLED = 1,
589}
590impl From<ENDEPIN7_A> for bool {
591    #[inline(always)]
592    fn from(variant: ENDEPIN7_A) -> Self {
593        variant as u8 != 0
594    }
595}
596impl ENDEPIN7_R {
597    #[doc = "Get enumerated values variant"]
598    #[inline(always)]
599    pub fn variant(&self) -> ENDEPIN7_A {
600        match self.bits {
601            false => ENDEPIN7_A::DISABLED,
602            true => ENDEPIN7_A::ENABLED,
603        }
604    }
605    #[doc = "Checks if the value of the field is `DISABLED`"]
606    #[inline(always)]
607    pub fn is_disabled(&self) -> bool {
608        *self == ENDEPIN7_A::DISABLED
609    }
610    #[doc = "Checks if the value of the field is `ENABLED`"]
611    #[inline(always)]
612    pub fn is_enabled(&self) -> bool {
613        *self == ENDEPIN7_A::ENABLED
614    }
615}
616#[doc = "Write '1' to enable interrupt for ENDEPIN\\[7\\]
617event\n\nValue on reset: 0"]
618#[derive(Clone, Copy, Debug, PartialEq)]
619pub enum ENDEPIN7_AW {
620    #[doc = "1: Enable"]
621    SET = 1,
622}
623impl From<ENDEPIN7_AW> for bool {
624    #[inline(always)]
625    fn from(variant: ENDEPIN7_AW) -> Self {
626        variant as u8 != 0
627    }
628}
629#[doc = "Field `ENDEPIN7` writer - Write '1' to enable interrupt for ENDEPIN\\[7\\]
630event"]
631pub type ENDEPIN7_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, ENDEPIN7_AW, O>;
632impl<'a, const O: u8> ENDEPIN7_W<'a, O> {
633    #[doc = "Enable"]
634    #[inline(always)]
635    pub fn set(self) -> &'a mut W {
636        self.variant(ENDEPIN7_AW::SET)
637    }
638}
639#[doc = "Field `EP0DATADONE` reader - Write '1' to enable interrupt for EP0DATADONE event"]
640pub type EP0DATADONE_R = crate::BitReader<EP0DATADONE_A>;
641#[doc = "Write '1' to enable interrupt for EP0DATADONE event\n\nValue on reset: 0"]
642#[derive(Clone, Copy, Debug, PartialEq)]
643pub enum EP0DATADONE_A {
644    #[doc = "0: Read: Disabled"]
645    DISABLED = 0,
646    #[doc = "1: Read: Enabled"]
647    ENABLED = 1,
648}
649impl From<EP0DATADONE_A> for bool {
650    #[inline(always)]
651    fn from(variant: EP0DATADONE_A) -> Self {
652        variant as u8 != 0
653    }
654}
655impl EP0DATADONE_R {
656    #[doc = "Get enumerated values variant"]
657    #[inline(always)]
658    pub fn variant(&self) -> EP0DATADONE_A {
659        match self.bits {
660            false => EP0DATADONE_A::DISABLED,
661            true => EP0DATADONE_A::ENABLED,
662        }
663    }
664    #[doc = "Checks if the value of the field is `DISABLED`"]
665    #[inline(always)]
666    pub fn is_disabled(&self) -> bool {
667        *self == EP0DATADONE_A::DISABLED
668    }
669    #[doc = "Checks if the value of the field is `ENABLED`"]
670    #[inline(always)]
671    pub fn is_enabled(&self) -> bool {
672        *self == EP0DATADONE_A::ENABLED
673    }
674}
675#[doc = "Write '1' to enable interrupt for EP0DATADONE event\n\nValue on reset: 0"]
676#[derive(Clone, Copy, Debug, PartialEq)]
677pub enum EP0DATADONE_AW {
678    #[doc = "1: Enable"]
679    SET = 1,
680}
681impl From<EP0DATADONE_AW> for bool {
682    #[inline(always)]
683    fn from(variant: EP0DATADONE_AW) -> Self {
684        variant as u8 != 0
685    }
686}
687#[doc = "Field `EP0DATADONE` writer - Write '1' to enable interrupt for EP0DATADONE event"]
688pub type EP0DATADONE_W<'a, const O: u8> =
689    crate::BitWriter<'a, u32, INTENSET_SPEC, EP0DATADONE_AW, O>;
690impl<'a, const O: u8> EP0DATADONE_W<'a, O> {
691    #[doc = "Enable"]
692    #[inline(always)]
693    pub fn set(self) -> &'a mut W {
694        self.variant(EP0DATADONE_AW::SET)
695    }
696}
697#[doc = "Field `ENDISOIN` reader - Write '1' to enable interrupt for ENDISOIN event"]
698pub type ENDISOIN_R = crate::BitReader<ENDISOIN_A>;
699#[doc = "Write '1' to enable interrupt for ENDISOIN event\n\nValue on reset: 0"]
700#[derive(Clone, Copy, Debug, PartialEq)]
701pub enum ENDISOIN_A {
702    #[doc = "0: Read: Disabled"]
703    DISABLED = 0,
704    #[doc = "1: Read: Enabled"]
705    ENABLED = 1,
706}
707impl From<ENDISOIN_A> for bool {
708    #[inline(always)]
709    fn from(variant: ENDISOIN_A) -> Self {
710        variant as u8 != 0
711    }
712}
713impl ENDISOIN_R {
714    #[doc = "Get enumerated values variant"]
715    #[inline(always)]
716    pub fn variant(&self) -> ENDISOIN_A {
717        match self.bits {
718            false => ENDISOIN_A::DISABLED,
719            true => ENDISOIN_A::ENABLED,
720        }
721    }
722    #[doc = "Checks if the value of the field is `DISABLED`"]
723    #[inline(always)]
724    pub fn is_disabled(&self) -> bool {
725        *self == ENDISOIN_A::DISABLED
726    }
727    #[doc = "Checks if the value of the field is `ENABLED`"]
728    #[inline(always)]
729    pub fn is_enabled(&self) -> bool {
730        *self == ENDISOIN_A::ENABLED
731    }
732}
733#[doc = "Write '1' to enable interrupt for ENDISOIN event\n\nValue on reset: 0"]
734#[derive(Clone, Copy, Debug, PartialEq)]
735pub enum ENDISOIN_AW {
736    #[doc = "1: Enable"]
737    SET = 1,
738}
739impl From<ENDISOIN_AW> for bool {
740    #[inline(always)]
741    fn from(variant: ENDISOIN_AW) -> Self {
742        variant as u8 != 0
743    }
744}
745#[doc = "Field `ENDISOIN` writer - Write '1' to enable interrupt for ENDISOIN event"]
746pub type ENDISOIN_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, ENDISOIN_AW, O>;
747impl<'a, const O: u8> ENDISOIN_W<'a, O> {
748    #[doc = "Enable"]
749    #[inline(always)]
750    pub fn set(self) -> &'a mut W {
751        self.variant(ENDISOIN_AW::SET)
752    }
753}
754#[doc = "Field `ENDEPOUT0` reader - Write '1' to enable interrupt for ENDEPOUT\\[0\\]
755event"]
756pub type ENDEPOUT0_R = crate::BitReader<ENDEPOUT0_A>;
757#[doc = "Write '1' to enable interrupt for ENDEPOUT\\[0\\]
758event\n\nValue on reset: 0"]
759#[derive(Clone, Copy, Debug, PartialEq)]
760pub enum ENDEPOUT0_A {
761    #[doc = "0: Read: Disabled"]
762    DISABLED = 0,
763    #[doc = "1: Read: Enabled"]
764    ENABLED = 1,
765}
766impl From<ENDEPOUT0_A> for bool {
767    #[inline(always)]
768    fn from(variant: ENDEPOUT0_A) -> Self {
769        variant as u8 != 0
770    }
771}
772impl ENDEPOUT0_R {
773    #[doc = "Get enumerated values variant"]
774    #[inline(always)]
775    pub fn variant(&self) -> ENDEPOUT0_A {
776        match self.bits {
777            false => ENDEPOUT0_A::DISABLED,
778            true => ENDEPOUT0_A::ENABLED,
779        }
780    }
781    #[doc = "Checks if the value of the field is `DISABLED`"]
782    #[inline(always)]
783    pub fn is_disabled(&self) -> bool {
784        *self == ENDEPOUT0_A::DISABLED
785    }
786    #[doc = "Checks if the value of the field is `ENABLED`"]
787    #[inline(always)]
788    pub fn is_enabled(&self) -> bool {
789        *self == ENDEPOUT0_A::ENABLED
790    }
791}
792#[doc = "Write '1' to enable interrupt for ENDEPOUT\\[0\\]
793event\n\nValue on reset: 0"]
794#[derive(Clone, Copy, Debug, PartialEq)]
795pub enum ENDEPOUT0_AW {
796    #[doc = "1: Enable"]
797    SET = 1,
798}
799impl From<ENDEPOUT0_AW> for bool {
800    #[inline(always)]
801    fn from(variant: ENDEPOUT0_AW) -> Self {
802        variant as u8 != 0
803    }
804}
805#[doc = "Field `ENDEPOUT0` writer - Write '1' to enable interrupt for ENDEPOUT\\[0\\]
806event"]
807pub type ENDEPOUT0_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, ENDEPOUT0_AW, O>;
808impl<'a, const O: u8> ENDEPOUT0_W<'a, O> {
809    #[doc = "Enable"]
810    #[inline(always)]
811    pub fn set(self) -> &'a mut W {
812        self.variant(ENDEPOUT0_AW::SET)
813    }
814}
815#[doc = "Field `ENDEPOUT1` reader - Write '1' to enable interrupt for ENDEPOUT\\[1\\]
816event"]
817pub type ENDEPOUT1_R = crate::BitReader<ENDEPOUT1_A>;
818#[doc = "Write '1' to enable interrupt for ENDEPOUT\\[1\\]
819event\n\nValue on reset: 0"]
820#[derive(Clone, Copy, Debug, PartialEq)]
821pub enum ENDEPOUT1_A {
822    #[doc = "0: Read: Disabled"]
823    DISABLED = 0,
824    #[doc = "1: Read: Enabled"]
825    ENABLED = 1,
826}
827impl From<ENDEPOUT1_A> for bool {
828    #[inline(always)]
829    fn from(variant: ENDEPOUT1_A) -> Self {
830        variant as u8 != 0
831    }
832}
833impl ENDEPOUT1_R {
834    #[doc = "Get enumerated values variant"]
835    #[inline(always)]
836    pub fn variant(&self) -> ENDEPOUT1_A {
837        match self.bits {
838            false => ENDEPOUT1_A::DISABLED,
839            true => ENDEPOUT1_A::ENABLED,
840        }
841    }
842    #[doc = "Checks if the value of the field is `DISABLED`"]
843    #[inline(always)]
844    pub fn is_disabled(&self) -> bool {
845        *self == ENDEPOUT1_A::DISABLED
846    }
847    #[doc = "Checks if the value of the field is `ENABLED`"]
848    #[inline(always)]
849    pub fn is_enabled(&self) -> bool {
850        *self == ENDEPOUT1_A::ENABLED
851    }
852}
853#[doc = "Write '1' to enable interrupt for ENDEPOUT\\[1\\]
854event\n\nValue on reset: 0"]
855#[derive(Clone, Copy, Debug, PartialEq)]
856pub enum ENDEPOUT1_AW {
857    #[doc = "1: Enable"]
858    SET = 1,
859}
860impl From<ENDEPOUT1_AW> for bool {
861    #[inline(always)]
862    fn from(variant: ENDEPOUT1_AW) -> Self {
863        variant as u8 != 0
864    }
865}
866#[doc = "Field `ENDEPOUT1` writer - Write '1' to enable interrupt for ENDEPOUT\\[1\\]
867event"]
868pub type ENDEPOUT1_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, ENDEPOUT1_AW, O>;
869impl<'a, const O: u8> ENDEPOUT1_W<'a, O> {
870    #[doc = "Enable"]
871    #[inline(always)]
872    pub fn set(self) -> &'a mut W {
873        self.variant(ENDEPOUT1_AW::SET)
874    }
875}
876#[doc = "Field `ENDEPOUT2` reader - Write '1' to enable interrupt for ENDEPOUT\\[2\\]
877event"]
878pub type ENDEPOUT2_R = crate::BitReader<ENDEPOUT2_A>;
879#[doc = "Write '1' to enable interrupt for ENDEPOUT\\[2\\]
880event\n\nValue on reset: 0"]
881#[derive(Clone, Copy, Debug, PartialEq)]
882pub enum ENDEPOUT2_A {
883    #[doc = "0: Read: Disabled"]
884    DISABLED = 0,
885    #[doc = "1: Read: Enabled"]
886    ENABLED = 1,
887}
888impl From<ENDEPOUT2_A> for bool {
889    #[inline(always)]
890    fn from(variant: ENDEPOUT2_A) -> Self {
891        variant as u8 != 0
892    }
893}
894impl ENDEPOUT2_R {
895    #[doc = "Get enumerated values variant"]
896    #[inline(always)]
897    pub fn variant(&self) -> ENDEPOUT2_A {
898        match self.bits {
899            false => ENDEPOUT2_A::DISABLED,
900            true => ENDEPOUT2_A::ENABLED,
901        }
902    }
903    #[doc = "Checks if the value of the field is `DISABLED`"]
904    #[inline(always)]
905    pub fn is_disabled(&self) -> bool {
906        *self == ENDEPOUT2_A::DISABLED
907    }
908    #[doc = "Checks if the value of the field is `ENABLED`"]
909    #[inline(always)]
910    pub fn is_enabled(&self) -> bool {
911        *self == ENDEPOUT2_A::ENABLED
912    }
913}
914#[doc = "Write '1' to enable interrupt for ENDEPOUT\\[2\\]
915event\n\nValue on reset: 0"]
916#[derive(Clone, Copy, Debug, PartialEq)]
917pub enum ENDEPOUT2_AW {
918    #[doc = "1: Enable"]
919    SET = 1,
920}
921impl From<ENDEPOUT2_AW> for bool {
922    #[inline(always)]
923    fn from(variant: ENDEPOUT2_AW) -> Self {
924        variant as u8 != 0
925    }
926}
927#[doc = "Field `ENDEPOUT2` writer - Write '1' to enable interrupt for ENDEPOUT\\[2\\]
928event"]
929pub type ENDEPOUT2_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, ENDEPOUT2_AW, O>;
930impl<'a, const O: u8> ENDEPOUT2_W<'a, O> {
931    #[doc = "Enable"]
932    #[inline(always)]
933    pub fn set(self) -> &'a mut W {
934        self.variant(ENDEPOUT2_AW::SET)
935    }
936}
937#[doc = "Field `ENDEPOUT3` reader - Write '1' to enable interrupt for ENDEPOUT\\[3\\]
938event"]
939pub type ENDEPOUT3_R = crate::BitReader<ENDEPOUT3_A>;
940#[doc = "Write '1' to enable interrupt for ENDEPOUT\\[3\\]
941event\n\nValue on reset: 0"]
942#[derive(Clone, Copy, Debug, PartialEq)]
943pub enum ENDEPOUT3_A {
944    #[doc = "0: Read: Disabled"]
945    DISABLED = 0,
946    #[doc = "1: Read: Enabled"]
947    ENABLED = 1,
948}
949impl From<ENDEPOUT3_A> for bool {
950    #[inline(always)]
951    fn from(variant: ENDEPOUT3_A) -> Self {
952        variant as u8 != 0
953    }
954}
955impl ENDEPOUT3_R {
956    #[doc = "Get enumerated values variant"]
957    #[inline(always)]
958    pub fn variant(&self) -> ENDEPOUT3_A {
959        match self.bits {
960            false => ENDEPOUT3_A::DISABLED,
961            true => ENDEPOUT3_A::ENABLED,
962        }
963    }
964    #[doc = "Checks if the value of the field is `DISABLED`"]
965    #[inline(always)]
966    pub fn is_disabled(&self) -> bool {
967        *self == ENDEPOUT3_A::DISABLED
968    }
969    #[doc = "Checks if the value of the field is `ENABLED`"]
970    #[inline(always)]
971    pub fn is_enabled(&self) -> bool {
972        *self == ENDEPOUT3_A::ENABLED
973    }
974}
975#[doc = "Write '1' to enable interrupt for ENDEPOUT\\[3\\]
976event\n\nValue on reset: 0"]
977#[derive(Clone, Copy, Debug, PartialEq)]
978pub enum ENDEPOUT3_AW {
979    #[doc = "1: Enable"]
980    SET = 1,
981}
982impl From<ENDEPOUT3_AW> for bool {
983    #[inline(always)]
984    fn from(variant: ENDEPOUT3_AW) -> Self {
985        variant as u8 != 0
986    }
987}
988#[doc = "Field `ENDEPOUT3` writer - Write '1' to enable interrupt for ENDEPOUT\\[3\\]
989event"]
990pub type ENDEPOUT3_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, ENDEPOUT3_AW, O>;
991impl<'a, const O: u8> ENDEPOUT3_W<'a, O> {
992    #[doc = "Enable"]
993    #[inline(always)]
994    pub fn set(self) -> &'a mut W {
995        self.variant(ENDEPOUT3_AW::SET)
996    }
997}
998#[doc = "Field `ENDEPOUT4` reader - Write '1' to enable interrupt for ENDEPOUT\\[4\\]
999event"]
1000pub type ENDEPOUT4_R = crate::BitReader<ENDEPOUT4_A>;
1001#[doc = "Write '1' to enable interrupt for ENDEPOUT\\[4\\]
1002event\n\nValue on reset: 0"]
1003#[derive(Clone, Copy, Debug, PartialEq)]
1004pub enum ENDEPOUT4_A {
1005    #[doc = "0: Read: Disabled"]
1006    DISABLED = 0,
1007    #[doc = "1: Read: Enabled"]
1008    ENABLED = 1,
1009}
1010impl From<ENDEPOUT4_A> for bool {
1011    #[inline(always)]
1012    fn from(variant: ENDEPOUT4_A) -> Self {
1013        variant as u8 != 0
1014    }
1015}
1016impl ENDEPOUT4_R {
1017    #[doc = "Get enumerated values variant"]
1018    #[inline(always)]
1019    pub fn variant(&self) -> ENDEPOUT4_A {
1020        match self.bits {
1021            false => ENDEPOUT4_A::DISABLED,
1022            true => ENDEPOUT4_A::ENABLED,
1023        }
1024    }
1025    #[doc = "Checks if the value of the field is `DISABLED`"]
1026    #[inline(always)]
1027    pub fn is_disabled(&self) -> bool {
1028        *self == ENDEPOUT4_A::DISABLED
1029    }
1030    #[doc = "Checks if the value of the field is `ENABLED`"]
1031    #[inline(always)]
1032    pub fn is_enabled(&self) -> bool {
1033        *self == ENDEPOUT4_A::ENABLED
1034    }
1035}
1036#[doc = "Write '1' to enable interrupt for ENDEPOUT\\[4\\]
1037event\n\nValue on reset: 0"]
1038#[derive(Clone, Copy, Debug, PartialEq)]
1039pub enum ENDEPOUT4_AW {
1040    #[doc = "1: Enable"]
1041    SET = 1,
1042}
1043impl From<ENDEPOUT4_AW> for bool {
1044    #[inline(always)]
1045    fn from(variant: ENDEPOUT4_AW) -> Self {
1046        variant as u8 != 0
1047    }
1048}
1049#[doc = "Field `ENDEPOUT4` writer - Write '1' to enable interrupt for ENDEPOUT\\[4\\]
1050event"]
1051pub type ENDEPOUT4_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, ENDEPOUT4_AW, O>;
1052impl<'a, const O: u8> ENDEPOUT4_W<'a, O> {
1053    #[doc = "Enable"]
1054    #[inline(always)]
1055    pub fn set(self) -> &'a mut W {
1056        self.variant(ENDEPOUT4_AW::SET)
1057    }
1058}
1059#[doc = "Field `ENDEPOUT5` reader - Write '1' to enable interrupt for ENDEPOUT\\[5\\]
1060event"]
1061pub type ENDEPOUT5_R = crate::BitReader<ENDEPOUT5_A>;
1062#[doc = "Write '1' to enable interrupt for ENDEPOUT\\[5\\]
1063event\n\nValue on reset: 0"]
1064#[derive(Clone, Copy, Debug, PartialEq)]
1065pub enum ENDEPOUT5_A {
1066    #[doc = "0: Read: Disabled"]
1067    DISABLED = 0,
1068    #[doc = "1: Read: Enabled"]
1069    ENABLED = 1,
1070}
1071impl From<ENDEPOUT5_A> for bool {
1072    #[inline(always)]
1073    fn from(variant: ENDEPOUT5_A) -> Self {
1074        variant as u8 != 0
1075    }
1076}
1077impl ENDEPOUT5_R {
1078    #[doc = "Get enumerated values variant"]
1079    #[inline(always)]
1080    pub fn variant(&self) -> ENDEPOUT5_A {
1081        match self.bits {
1082            false => ENDEPOUT5_A::DISABLED,
1083            true => ENDEPOUT5_A::ENABLED,
1084        }
1085    }
1086    #[doc = "Checks if the value of the field is `DISABLED`"]
1087    #[inline(always)]
1088    pub fn is_disabled(&self) -> bool {
1089        *self == ENDEPOUT5_A::DISABLED
1090    }
1091    #[doc = "Checks if the value of the field is `ENABLED`"]
1092    #[inline(always)]
1093    pub fn is_enabled(&self) -> bool {
1094        *self == ENDEPOUT5_A::ENABLED
1095    }
1096}
1097#[doc = "Write '1' to enable interrupt for ENDEPOUT\\[5\\]
1098event\n\nValue on reset: 0"]
1099#[derive(Clone, Copy, Debug, PartialEq)]
1100pub enum ENDEPOUT5_AW {
1101    #[doc = "1: Enable"]
1102    SET = 1,
1103}
1104impl From<ENDEPOUT5_AW> for bool {
1105    #[inline(always)]
1106    fn from(variant: ENDEPOUT5_AW) -> Self {
1107        variant as u8 != 0
1108    }
1109}
1110#[doc = "Field `ENDEPOUT5` writer - Write '1' to enable interrupt for ENDEPOUT\\[5\\]
1111event"]
1112pub type ENDEPOUT5_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, ENDEPOUT5_AW, O>;
1113impl<'a, const O: u8> ENDEPOUT5_W<'a, O> {
1114    #[doc = "Enable"]
1115    #[inline(always)]
1116    pub fn set(self) -> &'a mut W {
1117        self.variant(ENDEPOUT5_AW::SET)
1118    }
1119}
1120#[doc = "Field `ENDEPOUT6` reader - Write '1' to enable interrupt for ENDEPOUT\\[6\\]
1121event"]
1122pub type ENDEPOUT6_R = crate::BitReader<ENDEPOUT6_A>;
1123#[doc = "Write '1' to enable interrupt for ENDEPOUT\\[6\\]
1124event\n\nValue on reset: 0"]
1125#[derive(Clone, Copy, Debug, PartialEq)]
1126pub enum ENDEPOUT6_A {
1127    #[doc = "0: Read: Disabled"]
1128    DISABLED = 0,
1129    #[doc = "1: Read: Enabled"]
1130    ENABLED = 1,
1131}
1132impl From<ENDEPOUT6_A> for bool {
1133    #[inline(always)]
1134    fn from(variant: ENDEPOUT6_A) -> Self {
1135        variant as u8 != 0
1136    }
1137}
1138impl ENDEPOUT6_R {
1139    #[doc = "Get enumerated values variant"]
1140    #[inline(always)]
1141    pub fn variant(&self) -> ENDEPOUT6_A {
1142        match self.bits {
1143            false => ENDEPOUT6_A::DISABLED,
1144            true => ENDEPOUT6_A::ENABLED,
1145        }
1146    }
1147    #[doc = "Checks if the value of the field is `DISABLED`"]
1148    #[inline(always)]
1149    pub fn is_disabled(&self) -> bool {
1150        *self == ENDEPOUT6_A::DISABLED
1151    }
1152    #[doc = "Checks if the value of the field is `ENABLED`"]
1153    #[inline(always)]
1154    pub fn is_enabled(&self) -> bool {
1155        *self == ENDEPOUT6_A::ENABLED
1156    }
1157}
1158#[doc = "Write '1' to enable interrupt for ENDEPOUT\\[6\\]
1159event\n\nValue on reset: 0"]
1160#[derive(Clone, Copy, Debug, PartialEq)]
1161pub enum ENDEPOUT6_AW {
1162    #[doc = "1: Enable"]
1163    SET = 1,
1164}
1165impl From<ENDEPOUT6_AW> for bool {
1166    #[inline(always)]
1167    fn from(variant: ENDEPOUT6_AW) -> Self {
1168        variant as u8 != 0
1169    }
1170}
1171#[doc = "Field `ENDEPOUT6` writer - Write '1' to enable interrupt for ENDEPOUT\\[6\\]
1172event"]
1173pub type ENDEPOUT6_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, ENDEPOUT6_AW, O>;
1174impl<'a, const O: u8> ENDEPOUT6_W<'a, O> {
1175    #[doc = "Enable"]
1176    #[inline(always)]
1177    pub fn set(self) -> &'a mut W {
1178        self.variant(ENDEPOUT6_AW::SET)
1179    }
1180}
1181#[doc = "Field `ENDEPOUT7` reader - Write '1' to enable interrupt for ENDEPOUT\\[7\\]
1182event"]
1183pub type ENDEPOUT7_R = crate::BitReader<ENDEPOUT7_A>;
1184#[doc = "Write '1' to enable interrupt for ENDEPOUT\\[7\\]
1185event\n\nValue on reset: 0"]
1186#[derive(Clone, Copy, Debug, PartialEq)]
1187pub enum ENDEPOUT7_A {
1188    #[doc = "0: Read: Disabled"]
1189    DISABLED = 0,
1190    #[doc = "1: Read: Enabled"]
1191    ENABLED = 1,
1192}
1193impl From<ENDEPOUT7_A> for bool {
1194    #[inline(always)]
1195    fn from(variant: ENDEPOUT7_A) -> Self {
1196        variant as u8 != 0
1197    }
1198}
1199impl ENDEPOUT7_R {
1200    #[doc = "Get enumerated values variant"]
1201    #[inline(always)]
1202    pub fn variant(&self) -> ENDEPOUT7_A {
1203        match self.bits {
1204            false => ENDEPOUT7_A::DISABLED,
1205            true => ENDEPOUT7_A::ENABLED,
1206        }
1207    }
1208    #[doc = "Checks if the value of the field is `DISABLED`"]
1209    #[inline(always)]
1210    pub fn is_disabled(&self) -> bool {
1211        *self == ENDEPOUT7_A::DISABLED
1212    }
1213    #[doc = "Checks if the value of the field is `ENABLED`"]
1214    #[inline(always)]
1215    pub fn is_enabled(&self) -> bool {
1216        *self == ENDEPOUT7_A::ENABLED
1217    }
1218}
1219#[doc = "Write '1' to enable interrupt for ENDEPOUT\\[7\\]
1220event\n\nValue on reset: 0"]
1221#[derive(Clone, Copy, Debug, PartialEq)]
1222pub enum ENDEPOUT7_AW {
1223    #[doc = "1: Enable"]
1224    SET = 1,
1225}
1226impl From<ENDEPOUT7_AW> for bool {
1227    #[inline(always)]
1228    fn from(variant: ENDEPOUT7_AW) -> Self {
1229        variant as u8 != 0
1230    }
1231}
1232#[doc = "Field `ENDEPOUT7` writer - Write '1' to enable interrupt for ENDEPOUT\\[7\\]
1233event"]
1234pub type ENDEPOUT7_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, ENDEPOUT7_AW, O>;
1235impl<'a, const O: u8> ENDEPOUT7_W<'a, O> {
1236    #[doc = "Enable"]
1237    #[inline(always)]
1238    pub fn set(self) -> &'a mut W {
1239        self.variant(ENDEPOUT7_AW::SET)
1240    }
1241}
1242#[doc = "Field `ENDISOOUT` reader - Write '1' to enable interrupt for ENDISOOUT event"]
1243pub type ENDISOOUT_R = crate::BitReader<ENDISOOUT_A>;
1244#[doc = "Write '1' to enable interrupt for ENDISOOUT event\n\nValue on reset: 0"]
1245#[derive(Clone, Copy, Debug, PartialEq)]
1246pub enum ENDISOOUT_A {
1247    #[doc = "0: Read: Disabled"]
1248    DISABLED = 0,
1249    #[doc = "1: Read: Enabled"]
1250    ENABLED = 1,
1251}
1252impl From<ENDISOOUT_A> for bool {
1253    #[inline(always)]
1254    fn from(variant: ENDISOOUT_A) -> Self {
1255        variant as u8 != 0
1256    }
1257}
1258impl ENDISOOUT_R {
1259    #[doc = "Get enumerated values variant"]
1260    #[inline(always)]
1261    pub fn variant(&self) -> ENDISOOUT_A {
1262        match self.bits {
1263            false => ENDISOOUT_A::DISABLED,
1264            true => ENDISOOUT_A::ENABLED,
1265        }
1266    }
1267    #[doc = "Checks if the value of the field is `DISABLED`"]
1268    #[inline(always)]
1269    pub fn is_disabled(&self) -> bool {
1270        *self == ENDISOOUT_A::DISABLED
1271    }
1272    #[doc = "Checks if the value of the field is `ENABLED`"]
1273    #[inline(always)]
1274    pub fn is_enabled(&self) -> bool {
1275        *self == ENDISOOUT_A::ENABLED
1276    }
1277}
1278#[doc = "Write '1' to enable interrupt for ENDISOOUT event\n\nValue on reset: 0"]
1279#[derive(Clone, Copy, Debug, PartialEq)]
1280pub enum ENDISOOUT_AW {
1281    #[doc = "1: Enable"]
1282    SET = 1,
1283}
1284impl From<ENDISOOUT_AW> for bool {
1285    #[inline(always)]
1286    fn from(variant: ENDISOOUT_AW) -> Self {
1287        variant as u8 != 0
1288    }
1289}
1290#[doc = "Field `ENDISOOUT` writer - Write '1' to enable interrupt for ENDISOOUT event"]
1291pub type ENDISOOUT_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, ENDISOOUT_AW, O>;
1292impl<'a, const O: u8> ENDISOOUT_W<'a, O> {
1293    #[doc = "Enable"]
1294    #[inline(always)]
1295    pub fn set(self) -> &'a mut W {
1296        self.variant(ENDISOOUT_AW::SET)
1297    }
1298}
1299#[doc = "Field `SOF` reader - Write '1' to enable interrupt for SOF event"]
1300pub type SOF_R = crate::BitReader<SOF_A>;
1301#[doc = "Write '1' to enable interrupt for SOF event\n\nValue on reset: 0"]
1302#[derive(Clone, Copy, Debug, PartialEq)]
1303pub enum SOF_A {
1304    #[doc = "0: Read: Disabled"]
1305    DISABLED = 0,
1306    #[doc = "1: Read: Enabled"]
1307    ENABLED = 1,
1308}
1309impl From<SOF_A> for bool {
1310    #[inline(always)]
1311    fn from(variant: SOF_A) -> Self {
1312        variant as u8 != 0
1313    }
1314}
1315impl SOF_R {
1316    #[doc = "Get enumerated values variant"]
1317    #[inline(always)]
1318    pub fn variant(&self) -> SOF_A {
1319        match self.bits {
1320            false => SOF_A::DISABLED,
1321            true => SOF_A::ENABLED,
1322        }
1323    }
1324    #[doc = "Checks if the value of the field is `DISABLED`"]
1325    #[inline(always)]
1326    pub fn is_disabled(&self) -> bool {
1327        *self == SOF_A::DISABLED
1328    }
1329    #[doc = "Checks if the value of the field is `ENABLED`"]
1330    #[inline(always)]
1331    pub fn is_enabled(&self) -> bool {
1332        *self == SOF_A::ENABLED
1333    }
1334}
1335#[doc = "Write '1' to enable interrupt for SOF event\n\nValue on reset: 0"]
1336#[derive(Clone, Copy, Debug, PartialEq)]
1337pub enum SOF_AW {
1338    #[doc = "1: Enable"]
1339    SET = 1,
1340}
1341impl From<SOF_AW> for bool {
1342    #[inline(always)]
1343    fn from(variant: SOF_AW) -> Self {
1344        variant as u8 != 0
1345    }
1346}
1347#[doc = "Field `SOF` writer - Write '1' to enable interrupt for SOF event"]
1348pub type SOF_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, SOF_AW, O>;
1349impl<'a, const O: u8> SOF_W<'a, O> {
1350    #[doc = "Enable"]
1351    #[inline(always)]
1352    pub fn set(self) -> &'a mut W {
1353        self.variant(SOF_AW::SET)
1354    }
1355}
1356#[doc = "Field `USBEVENT` reader - Write '1' to enable interrupt for USBEVENT event"]
1357pub type USBEVENT_R = crate::BitReader<USBEVENT_A>;
1358#[doc = "Write '1' to enable interrupt for USBEVENT event\n\nValue on reset: 0"]
1359#[derive(Clone, Copy, Debug, PartialEq)]
1360pub enum USBEVENT_A {
1361    #[doc = "0: Read: Disabled"]
1362    DISABLED = 0,
1363    #[doc = "1: Read: Enabled"]
1364    ENABLED = 1,
1365}
1366impl From<USBEVENT_A> for bool {
1367    #[inline(always)]
1368    fn from(variant: USBEVENT_A) -> Self {
1369        variant as u8 != 0
1370    }
1371}
1372impl USBEVENT_R {
1373    #[doc = "Get enumerated values variant"]
1374    #[inline(always)]
1375    pub fn variant(&self) -> USBEVENT_A {
1376        match self.bits {
1377            false => USBEVENT_A::DISABLED,
1378            true => USBEVENT_A::ENABLED,
1379        }
1380    }
1381    #[doc = "Checks if the value of the field is `DISABLED`"]
1382    #[inline(always)]
1383    pub fn is_disabled(&self) -> bool {
1384        *self == USBEVENT_A::DISABLED
1385    }
1386    #[doc = "Checks if the value of the field is `ENABLED`"]
1387    #[inline(always)]
1388    pub fn is_enabled(&self) -> bool {
1389        *self == USBEVENT_A::ENABLED
1390    }
1391}
1392#[doc = "Write '1' to enable interrupt for USBEVENT event\n\nValue on reset: 0"]
1393#[derive(Clone, Copy, Debug, PartialEq)]
1394pub enum USBEVENT_AW {
1395    #[doc = "1: Enable"]
1396    SET = 1,
1397}
1398impl From<USBEVENT_AW> for bool {
1399    #[inline(always)]
1400    fn from(variant: USBEVENT_AW) -> Self {
1401        variant as u8 != 0
1402    }
1403}
1404#[doc = "Field `USBEVENT` writer - Write '1' to enable interrupt for USBEVENT event"]
1405pub type USBEVENT_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, USBEVENT_AW, O>;
1406impl<'a, const O: u8> USBEVENT_W<'a, O> {
1407    #[doc = "Enable"]
1408    #[inline(always)]
1409    pub fn set(self) -> &'a mut W {
1410        self.variant(USBEVENT_AW::SET)
1411    }
1412}
1413#[doc = "Field `EP0SETUP` reader - Write '1' to enable interrupt for EP0SETUP event"]
1414pub type EP0SETUP_R = crate::BitReader<EP0SETUP_A>;
1415#[doc = "Write '1' to enable interrupt for EP0SETUP event\n\nValue on reset: 0"]
1416#[derive(Clone, Copy, Debug, PartialEq)]
1417pub enum EP0SETUP_A {
1418    #[doc = "0: Read: Disabled"]
1419    DISABLED = 0,
1420    #[doc = "1: Read: Enabled"]
1421    ENABLED = 1,
1422}
1423impl From<EP0SETUP_A> for bool {
1424    #[inline(always)]
1425    fn from(variant: EP0SETUP_A) -> Self {
1426        variant as u8 != 0
1427    }
1428}
1429impl EP0SETUP_R {
1430    #[doc = "Get enumerated values variant"]
1431    #[inline(always)]
1432    pub fn variant(&self) -> EP0SETUP_A {
1433        match self.bits {
1434            false => EP0SETUP_A::DISABLED,
1435            true => EP0SETUP_A::ENABLED,
1436        }
1437    }
1438    #[doc = "Checks if the value of the field is `DISABLED`"]
1439    #[inline(always)]
1440    pub fn is_disabled(&self) -> bool {
1441        *self == EP0SETUP_A::DISABLED
1442    }
1443    #[doc = "Checks if the value of the field is `ENABLED`"]
1444    #[inline(always)]
1445    pub fn is_enabled(&self) -> bool {
1446        *self == EP0SETUP_A::ENABLED
1447    }
1448}
1449#[doc = "Write '1' to enable interrupt for EP0SETUP event\n\nValue on reset: 0"]
1450#[derive(Clone, Copy, Debug, PartialEq)]
1451pub enum EP0SETUP_AW {
1452    #[doc = "1: Enable"]
1453    SET = 1,
1454}
1455impl From<EP0SETUP_AW> for bool {
1456    #[inline(always)]
1457    fn from(variant: EP0SETUP_AW) -> Self {
1458        variant as u8 != 0
1459    }
1460}
1461#[doc = "Field `EP0SETUP` writer - Write '1' to enable interrupt for EP0SETUP event"]
1462pub type EP0SETUP_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, EP0SETUP_AW, O>;
1463impl<'a, const O: u8> EP0SETUP_W<'a, O> {
1464    #[doc = "Enable"]
1465    #[inline(always)]
1466    pub fn set(self) -> &'a mut W {
1467        self.variant(EP0SETUP_AW::SET)
1468    }
1469}
1470#[doc = "Field `EPDATA` reader - Write '1' to enable interrupt for EPDATA event"]
1471pub type EPDATA_R = crate::BitReader<EPDATA_A>;
1472#[doc = "Write '1' to enable interrupt for EPDATA event\n\nValue on reset: 0"]
1473#[derive(Clone, Copy, Debug, PartialEq)]
1474pub enum EPDATA_A {
1475    #[doc = "0: Read: Disabled"]
1476    DISABLED = 0,
1477    #[doc = "1: Read: Enabled"]
1478    ENABLED = 1,
1479}
1480impl From<EPDATA_A> for bool {
1481    #[inline(always)]
1482    fn from(variant: EPDATA_A) -> Self {
1483        variant as u8 != 0
1484    }
1485}
1486impl EPDATA_R {
1487    #[doc = "Get enumerated values variant"]
1488    #[inline(always)]
1489    pub fn variant(&self) -> EPDATA_A {
1490        match self.bits {
1491            false => EPDATA_A::DISABLED,
1492            true => EPDATA_A::ENABLED,
1493        }
1494    }
1495    #[doc = "Checks if the value of the field is `DISABLED`"]
1496    #[inline(always)]
1497    pub fn is_disabled(&self) -> bool {
1498        *self == EPDATA_A::DISABLED
1499    }
1500    #[doc = "Checks if the value of the field is `ENABLED`"]
1501    #[inline(always)]
1502    pub fn is_enabled(&self) -> bool {
1503        *self == EPDATA_A::ENABLED
1504    }
1505}
1506#[doc = "Write '1' to enable interrupt for EPDATA event\n\nValue on reset: 0"]
1507#[derive(Clone, Copy, Debug, PartialEq)]
1508pub enum EPDATA_AW {
1509    #[doc = "1: Enable"]
1510    SET = 1,
1511}
1512impl From<EPDATA_AW> for bool {
1513    #[inline(always)]
1514    fn from(variant: EPDATA_AW) -> Self {
1515        variant as u8 != 0
1516    }
1517}
1518#[doc = "Field `EPDATA` writer - Write '1' to enable interrupt for EPDATA event"]
1519pub type EPDATA_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, EPDATA_AW, O>;
1520impl<'a, const O: u8> EPDATA_W<'a, O> {
1521    #[doc = "Enable"]
1522    #[inline(always)]
1523    pub fn set(self) -> &'a mut W {
1524        self.variant(EPDATA_AW::SET)
1525    }
1526}
1527impl R {
1528    #[doc = "Bit 0 - Write '1' to enable interrupt for USBRESET event"]
1529    #[inline(always)]
1530    pub fn usbreset(&self) -> USBRESET_R {
1531        USBRESET_R::new((self.bits & 1) != 0)
1532    }
1533    #[doc = "Bit 1 - Write '1' to enable interrupt for STARTED event"]
1534    #[inline(always)]
1535    pub fn started(&self) -> STARTED_R {
1536        STARTED_R::new(((self.bits >> 1) & 1) != 0)
1537    }
1538    #[doc = "Bit 2 - Write '1' to enable interrupt for ENDEPIN\\[0\\]
1539event"]
1540    #[inline(always)]
1541    pub fn endepin0(&self) -> ENDEPIN0_R {
1542        ENDEPIN0_R::new(((self.bits >> 2) & 1) != 0)
1543    }
1544    #[doc = "Bit 3 - Write '1' to enable interrupt for ENDEPIN\\[1\\]
1545event"]
1546    #[inline(always)]
1547    pub fn endepin1(&self) -> ENDEPIN1_R {
1548        ENDEPIN1_R::new(((self.bits >> 3) & 1) != 0)
1549    }
1550    #[doc = "Bit 4 - Write '1' to enable interrupt for ENDEPIN\\[2\\]
1551event"]
1552    #[inline(always)]
1553    pub fn endepin2(&self) -> ENDEPIN2_R {
1554        ENDEPIN2_R::new(((self.bits >> 4) & 1) != 0)
1555    }
1556    #[doc = "Bit 5 - Write '1' to enable interrupt for ENDEPIN\\[3\\]
1557event"]
1558    #[inline(always)]
1559    pub fn endepin3(&self) -> ENDEPIN3_R {
1560        ENDEPIN3_R::new(((self.bits >> 5) & 1) != 0)
1561    }
1562    #[doc = "Bit 6 - Write '1' to enable interrupt for ENDEPIN\\[4\\]
1563event"]
1564    #[inline(always)]
1565    pub fn endepin4(&self) -> ENDEPIN4_R {
1566        ENDEPIN4_R::new(((self.bits >> 6) & 1) != 0)
1567    }
1568    #[doc = "Bit 7 - Write '1' to enable interrupt for ENDEPIN\\[5\\]
1569event"]
1570    #[inline(always)]
1571    pub fn endepin5(&self) -> ENDEPIN5_R {
1572        ENDEPIN5_R::new(((self.bits >> 7) & 1) != 0)
1573    }
1574    #[doc = "Bit 8 - Write '1' to enable interrupt for ENDEPIN\\[6\\]
1575event"]
1576    #[inline(always)]
1577    pub fn endepin6(&self) -> ENDEPIN6_R {
1578        ENDEPIN6_R::new(((self.bits >> 8) & 1) != 0)
1579    }
1580    #[doc = "Bit 9 - Write '1' to enable interrupt for ENDEPIN\\[7\\]
1581event"]
1582    #[inline(always)]
1583    pub fn endepin7(&self) -> ENDEPIN7_R {
1584        ENDEPIN7_R::new(((self.bits >> 9) & 1) != 0)
1585    }
1586    #[doc = "Bit 10 - Write '1' to enable interrupt for EP0DATADONE event"]
1587    #[inline(always)]
1588    pub fn ep0datadone(&self) -> EP0DATADONE_R {
1589        EP0DATADONE_R::new(((self.bits >> 10) & 1) != 0)
1590    }
1591    #[doc = "Bit 11 - Write '1' to enable interrupt for ENDISOIN event"]
1592    #[inline(always)]
1593    pub fn endisoin(&self) -> ENDISOIN_R {
1594        ENDISOIN_R::new(((self.bits >> 11) & 1) != 0)
1595    }
1596    #[doc = "Bit 12 - Write '1' to enable interrupt for ENDEPOUT\\[0\\]
1597event"]
1598    #[inline(always)]
1599    pub fn endepout0(&self) -> ENDEPOUT0_R {
1600        ENDEPOUT0_R::new(((self.bits >> 12) & 1) != 0)
1601    }
1602    #[doc = "Bit 13 - Write '1' to enable interrupt for ENDEPOUT\\[1\\]
1603event"]
1604    #[inline(always)]
1605    pub fn endepout1(&self) -> ENDEPOUT1_R {
1606        ENDEPOUT1_R::new(((self.bits >> 13) & 1) != 0)
1607    }
1608    #[doc = "Bit 14 - Write '1' to enable interrupt for ENDEPOUT\\[2\\]
1609event"]
1610    #[inline(always)]
1611    pub fn endepout2(&self) -> ENDEPOUT2_R {
1612        ENDEPOUT2_R::new(((self.bits >> 14) & 1) != 0)
1613    }
1614    #[doc = "Bit 15 - Write '1' to enable interrupt for ENDEPOUT\\[3\\]
1615event"]
1616    #[inline(always)]
1617    pub fn endepout3(&self) -> ENDEPOUT3_R {
1618        ENDEPOUT3_R::new(((self.bits >> 15) & 1) != 0)
1619    }
1620    #[doc = "Bit 16 - Write '1' to enable interrupt for ENDEPOUT\\[4\\]
1621event"]
1622    #[inline(always)]
1623    pub fn endepout4(&self) -> ENDEPOUT4_R {
1624        ENDEPOUT4_R::new(((self.bits >> 16) & 1) != 0)
1625    }
1626    #[doc = "Bit 17 - Write '1' to enable interrupt for ENDEPOUT\\[5\\]
1627event"]
1628    #[inline(always)]
1629    pub fn endepout5(&self) -> ENDEPOUT5_R {
1630        ENDEPOUT5_R::new(((self.bits >> 17) & 1) != 0)
1631    }
1632    #[doc = "Bit 18 - Write '1' to enable interrupt for ENDEPOUT\\[6\\]
1633event"]
1634    #[inline(always)]
1635    pub fn endepout6(&self) -> ENDEPOUT6_R {
1636        ENDEPOUT6_R::new(((self.bits >> 18) & 1) != 0)
1637    }
1638    #[doc = "Bit 19 - Write '1' to enable interrupt for ENDEPOUT\\[7\\]
1639event"]
1640    #[inline(always)]
1641    pub fn endepout7(&self) -> ENDEPOUT7_R {
1642        ENDEPOUT7_R::new(((self.bits >> 19) & 1) != 0)
1643    }
1644    #[doc = "Bit 20 - Write '1' to enable interrupt for ENDISOOUT event"]
1645    #[inline(always)]
1646    pub fn endisoout(&self) -> ENDISOOUT_R {
1647        ENDISOOUT_R::new(((self.bits >> 20) & 1) != 0)
1648    }
1649    #[doc = "Bit 21 - Write '1' to enable interrupt for SOF event"]
1650    #[inline(always)]
1651    pub fn sof(&self) -> SOF_R {
1652        SOF_R::new(((self.bits >> 21) & 1) != 0)
1653    }
1654    #[doc = "Bit 22 - Write '1' to enable interrupt for USBEVENT event"]
1655    #[inline(always)]
1656    pub fn usbevent(&self) -> USBEVENT_R {
1657        USBEVENT_R::new(((self.bits >> 22) & 1) != 0)
1658    }
1659    #[doc = "Bit 23 - Write '1' to enable interrupt for EP0SETUP event"]
1660    #[inline(always)]
1661    pub fn ep0setup(&self) -> EP0SETUP_R {
1662        EP0SETUP_R::new(((self.bits >> 23) & 1) != 0)
1663    }
1664    #[doc = "Bit 24 - Write '1' to enable interrupt for EPDATA event"]
1665    #[inline(always)]
1666    pub fn epdata(&self) -> EPDATA_R {
1667        EPDATA_R::new(((self.bits >> 24) & 1) != 0)
1668    }
1669}
1670impl W {
1671    #[doc = "Bit 0 - Write '1' to enable interrupt for USBRESET event"]
1672    #[inline(always)]
1673    pub fn usbreset(&mut self) -> USBRESET_W<0> {
1674        USBRESET_W::new(self)
1675    }
1676    #[doc = "Bit 1 - Write '1' to enable interrupt for STARTED event"]
1677    #[inline(always)]
1678    pub fn started(&mut self) -> STARTED_W<1> {
1679        STARTED_W::new(self)
1680    }
1681    #[doc = "Bit 2 - Write '1' to enable interrupt for ENDEPIN\\[0\\]
1682event"]
1683    #[inline(always)]
1684    pub fn endepin0(&mut self) -> ENDEPIN0_W<2> {
1685        ENDEPIN0_W::new(self)
1686    }
1687    #[doc = "Bit 3 - Write '1' to enable interrupt for ENDEPIN\\[1\\]
1688event"]
1689    #[inline(always)]
1690    pub fn endepin1(&mut self) -> ENDEPIN1_W<3> {
1691        ENDEPIN1_W::new(self)
1692    }
1693    #[doc = "Bit 4 - Write '1' to enable interrupt for ENDEPIN\\[2\\]
1694event"]
1695    #[inline(always)]
1696    pub fn endepin2(&mut self) -> ENDEPIN2_W<4> {
1697        ENDEPIN2_W::new(self)
1698    }
1699    #[doc = "Bit 5 - Write '1' to enable interrupt for ENDEPIN\\[3\\]
1700event"]
1701    #[inline(always)]
1702    pub fn endepin3(&mut self) -> ENDEPIN3_W<5> {
1703        ENDEPIN3_W::new(self)
1704    }
1705    #[doc = "Bit 6 - Write '1' to enable interrupt for ENDEPIN\\[4\\]
1706event"]
1707    #[inline(always)]
1708    pub fn endepin4(&mut self) -> ENDEPIN4_W<6> {
1709        ENDEPIN4_W::new(self)
1710    }
1711    #[doc = "Bit 7 - Write '1' to enable interrupt for ENDEPIN\\[5\\]
1712event"]
1713    #[inline(always)]
1714    pub fn endepin5(&mut self) -> ENDEPIN5_W<7> {
1715        ENDEPIN5_W::new(self)
1716    }
1717    #[doc = "Bit 8 - Write '1' to enable interrupt for ENDEPIN\\[6\\]
1718event"]
1719    #[inline(always)]
1720    pub fn endepin6(&mut self) -> ENDEPIN6_W<8> {
1721        ENDEPIN6_W::new(self)
1722    }
1723    #[doc = "Bit 9 - Write '1' to enable interrupt for ENDEPIN\\[7\\]
1724event"]
1725    #[inline(always)]
1726    pub fn endepin7(&mut self) -> ENDEPIN7_W<9> {
1727        ENDEPIN7_W::new(self)
1728    }
1729    #[doc = "Bit 10 - Write '1' to enable interrupt for EP0DATADONE event"]
1730    #[inline(always)]
1731    pub fn ep0datadone(&mut self) -> EP0DATADONE_W<10> {
1732        EP0DATADONE_W::new(self)
1733    }
1734    #[doc = "Bit 11 - Write '1' to enable interrupt for ENDISOIN event"]
1735    #[inline(always)]
1736    pub fn endisoin(&mut self) -> ENDISOIN_W<11> {
1737        ENDISOIN_W::new(self)
1738    }
1739    #[doc = "Bit 12 - Write '1' to enable interrupt for ENDEPOUT\\[0\\]
1740event"]
1741    #[inline(always)]
1742    pub fn endepout0(&mut self) -> ENDEPOUT0_W<12> {
1743        ENDEPOUT0_W::new(self)
1744    }
1745    #[doc = "Bit 13 - Write '1' to enable interrupt for ENDEPOUT\\[1\\]
1746event"]
1747    #[inline(always)]
1748    pub fn endepout1(&mut self) -> ENDEPOUT1_W<13> {
1749        ENDEPOUT1_W::new(self)
1750    }
1751    #[doc = "Bit 14 - Write '1' to enable interrupt for ENDEPOUT\\[2\\]
1752event"]
1753    #[inline(always)]
1754    pub fn endepout2(&mut self) -> ENDEPOUT2_W<14> {
1755        ENDEPOUT2_W::new(self)
1756    }
1757    #[doc = "Bit 15 - Write '1' to enable interrupt for ENDEPOUT\\[3\\]
1758event"]
1759    #[inline(always)]
1760    pub fn endepout3(&mut self) -> ENDEPOUT3_W<15> {
1761        ENDEPOUT3_W::new(self)
1762    }
1763    #[doc = "Bit 16 - Write '1' to enable interrupt for ENDEPOUT\\[4\\]
1764event"]
1765    #[inline(always)]
1766    pub fn endepout4(&mut self) -> ENDEPOUT4_W<16> {
1767        ENDEPOUT4_W::new(self)
1768    }
1769    #[doc = "Bit 17 - Write '1' to enable interrupt for ENDEPOUT\\[5\\]
1770event"]
1771    #[inline(always)]
1772    pub fn endepout5(&mut self) -> ENDEPOUT5_W<17> {
1773        ENDEPOUT5_W::new(self)
1774    }
1775    #[doc = "Bit 18 - Write '1' to enable interrupt for ENDEPOUT\\[6\\]
1776event"]
1777    #[inline(always)]
1778    pub fn endepout6(&mut self) -> ENDEPOUT6_W<18> {
1779        ENDEPOUT6_W::new(self)
1780    }
1781    #[doc = "Bit 19 - Write '1' to enable interrupt for ENDEPOUT\\[7\\]
1782event"]
1783    #[inline(always)]
1784    pub fn endepout7(&mut self) -> ENDEPOUT7_W<19> {
1785        ENDEPOUT7_W::new(self)
1786    }
1787    #[doc = "Bit 20 - Write '1' to enable interrupt for ENDISOOUT event"]
1788    #[inline(always)]
1789    pub fn endisoout(&mut self) -> ENDISOOUT_W<20> {
1790        ENDISOOUT_W::new(self)
1791    }
1792    #[doc = "Bit 21 - Write '1' to enable interrupt for SOF event"]
1793    #[inline(always)]
1794    pub fn sof(&mut self) -> SOF_W<21> {
1795        SOF_W::new(self)
1796    }
1797    #[doc = "Bit 22 - Write '1' to enable interrupt for USBEVENT event"]
1798    #[inline(always)]
1799    pub fn usbevent(&mut self) -> USBEVENT_W<22> {
1800        USBEVENT_W::new(self)
1801    }
1802    #[doc = "Bit 23 - Write '1' to enable interrupt for EP0SETUP event"]
1803    #[inline(always)]
1804    pub fn ep0setup(&mut self) -> EP0SETUP_W<23> {
1805        EP0SETUP_W::new(self)
1806    }
1807    #[doc = "Bit 24 - Write '1' to enable interrupt for EPDATA event"]
1808    #[inline(always)]
1809    pub fn epdata(&mut self) -> EPDATA_W<24> {
1810        EPDATA_W::new(self)
1811    }
1812    #[doc = "Writes raw bits to the register."]
1813    #[inline(always)]
1814    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
1815        self.0.bits(bits);
1816        self
1817    }
1818}
1819#[doc = "Enable interrupt\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 [intenset](index.html) module"]
1820pub struct INTENSET_SPEC;
1821impl crate::RegisterSpec for INTENSET_SPEC {
1822    type Ux = u32;
1823}
1824#[doc = "`read()` method returns [intenset::R](R) reader structure"]
1825impl crate::Readable for INTENSET_SPEC {
1826    type Reader = R;
1827}
1828#[doc = "`write(|w| ..)` method takes [intenset::W](W) writer structure"]
1829impl crate::Writable for INTENSET_SPEC {
1830    type Writer = W;
1831}
1832#[doc = "`reset()` method sets INTENSET to value 0"]
1833impl crate::Resettable for INTENSET_SPEC {
1834    #[inline(always)]
1835    fn reset_value() -> Self::Ux {
1836        0
1837    }
1838}
nrf52840_pac/usbd/intenset.rs

nrf52840_pac/usbd/
intenset.rs
