nrf5340_app_pac/usbd_ns/
intenset.rs

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

nrf5340_app_pac/usbd_ns/
intenset.rs
