1#[doc = "Reader of register STALL_IL_DIS"]
2pub type R = crate::R<u8, super::STALL_IL_DIS>;
3#[doc = "Writer for register STALL_IL_DIS"]
4pub type W = crate::W<u8, super::STALL_IL_DIS>;
5#[doc = "Register STALL_IL_DIS `reset()`'s with value 0"]
6impl crate::ResetValue for super::STALL_IL_DIS {
7 type Type = u8;
8 #[inline(always)]
9 fn reset_value() -> Self::Type {
10 0
11 }
12}
13#[doc = "STALL_I_DIS0\n\nValue on reset: 0"]
14#[derive(Clone, Copy, Debug, PartialEq)]
15pub enum STALL_I_DIS0_A {
16 #[doc = "0: Endpoint 0 IN direction stall is enabled."]
17 STALL_I_DIS0_0,
18 #[doc = "1: Endpoint 0 IN direction stall is disabled."]
19 STALL_I_DIS0_1,
20}
21impl From<STALL_I_DIS0_A> for bool {
22 #[inline(always)]
23 fn from(variant: STALL_I_DIS0_A) -> Self {
24 match variant {
25 STALL_I_DIS0_A::STALL_I_DIS0_0 => false,
26 STALL_I_DIS0_A::STALL_I_DIS0_1 => true,
27 }
28 }
29}
30#[doc = "Reader of field `STALL_I_DIS0`"]
31pub type STALL_I_DIS0_R = crate::R<bool, STALL_I_DIS0_A>;
32impl STALL_I_DIS0_R {
33 #[doc = r"Get enumerated values variant"]
34 #[inline(always)]
35 pub fn variant(&self) -> STALL_I_DIS0_A {
36 match self.bits {
37 false => STALL_I_DIS0_A::STALL_I_DIS0_0,
38 true => STALL_I_DIS0_A::STALL_I_DIS0_1,
39 }
40 }
41 #[doc = "Checks if the value of the field is `STALL_I_DIS0_0`"]
42 #[inline(always)]
43 pub fn is_stall_i_dis0_0(&self) -> bool {
44 *self == STALL_I_DIS0_A::STALL_I_DIS0_0
45 }
46 #[doc = "Checks if the value of the field is `STALL_I_DIS0_1`"]
47 #[inline(always)]
48 pub fn is_stall_i_dis0_1(&self) -> bool {
49 *self == STALL_I_DIS0_A::STALL_I_DIS0_1
50 }
51}
52#[doc = "Write proxy for field `STALL_I_DIS0`"]
53pub struct STALL_I_DIS0_W<'a> {
54 w: &'a mut W,
55}
56impl<'a> STALL_I_DIS0_W<'a> {
57 #[doc = r"Writes `variant` to the field"]
58 #[inline(always)]
59 pub fn variant(self, variant: STALL_I_DIS0_A) -> &'a mut W {
60 {
61 self.bit(variant.into())
62 }
63 }
64 #[doc = "Endpoint 0 IN direction stall is enabled."]
65 #[inline(always)]
66 pub fn stall_i_dis0_0(self) -> &'a mut W {
67 self.variant(STALL_I_DIS0_A::STALL_I_DIS0_0)
68 }
69 #[doc = "Endpoint 0 IN direction stall is disabled."]
70 #[inline(always)]
71 pub fn stall_i_dis0_1(self) -> &'a mut W {
72 self.variant(STALL_I_DIS0_A::STALL_I_DIS0_1)
73 }
74 #[doc = r"Sets the field bit"]
75 #[inline(always)]
76 pub fn set_bit(self) -> &'a mut W {
77 self.bit(true)
78 }
79 #[doc = r"Clears the field bit"]
80 #[inline(always)]
81 pub fn clear_bit(self) -> &'a mut W {
82 self.bit(false)
83 }
84 #[doc = r"Writes raw bits to the field"]
85 #[inline(always)]
86 pub fn bit(self, value: bool) -> &'a mut W {
87 self.w.bits = (self.w.bits & !0x01) | ((value as u8) & 0x01);
88 self.w
89 }
90}
91#[doc = "STALL_I_DIS1\n\nValue on reset: 0"]
92#[derive(Clone, Copy, Debug, PartialEq)]
93pub enum STALL_I_DIS1_A {
94 #[doc = "0: Endpoint 1 IN direction stall is enabled."]
95 STALL_I_DIS1_0,
96 #[doc = "1: Endpoint 1 IN direction stall is disabled."]
97 STALL_I_DIS1_1,
98}
99impl From<STALL_I_DIS1_A> for bool {
100 #[inline(always)]
101 fn from(variant: STALL_I_DIS1_A) -> Self {
102 match variant {
103 STALL_I_DIS1_A::STALL_I_DIS1_0 => false,
104 STALL_I_DIS1_A::STALL_I_DIS1_1 => true,
105 }
106 }
107}
108#[doc = "Reader of field `STALL_I_DIS1`"]
109pub type STALL_I_DIS1_R = crate::R<bool, STALL_I_DIS1_A>;
110impl STALL_I_DIS1_R {
111 #[doc = r"Get enumerated values variant"]
112 #[inline(always)]
113 pub fn variant(&self) -> STALL_I_DIS1_A {
114 match self.bits {
115 false => STALL_I_DIS1_A::STALL_I_DIS1_0,
116 true => STALL_I_DIS1_A::STALL_I_DIS1_1,
117 }
118 }
119 #[doc = "Checks if the value of the field is `STALL_I_DIS1_0`"]
120 #[inline(always)]
121 pub fn is_stall_i_dis1_0(&self) -> bool {
122 *self == STALL_I_DIS1_A::STALL_I_DIS1_0
123 }
124 #[doc = "Checks if the value of the field is `STALL_I_DIS1_1`"]
125 #[inline(always)]
126 pub fn is_stall_i_dis1_1(&self) -> bool {
127 *self == STALL_I_DIS1_A::STALL_I_DIS1_1
128 }
129}
130#[doc = "Write proxy for field `STALL_I_DIS1`"]
131pub struct STALL_I_DIS1_W<'a> {
132 w: &'a mut W,
133}
134impl<'a> STALL_I_DIS1_W<'a> {
135 #[doc = r"Writes `variant` to the field"]
136 #[inline(always)]
137 pub fn variant(self, variant: STALL_I_DIS1_A) -> &'a mut W {
138 {
139 self.bit(variant.into())
140 }
141 }
142 #[doc = "Endpoint 1 IN direction stall is enabled."]
143 #[inline(always)]
144 pub fn stall_i_dis1_0(self) -> &'a mut W {
145 self.variant(STALL_I_DIS1_A::STALL_I_DIS1_0)
146 }
147 #[doc = "Endpoint 1 IN direction stall is disabled."]
148 #[inline(always)]
149 pub fn stall_i_dis1_1(self) -> &'a mut W {
150 self.variant(STALL_I_DIS1_A::STALL_I_DIS1_1)
151 }
152 #[doc = r"Sets the field bit"]
153 #[inline(always)]
154 pub fn set_bit(self) -> &'a mut W {
155 self.bit(true)
156 }
157 #[doc = r"Clears the field bit"]
158 #[inline(always)]
159 pub fn clear_bit(self) -> &'a mut W {
160 self.bit(false)
161 }
162 #[doc = r"Writes raw bits to the field"]
163 #[inline(always)]
164 pub fn bit(self, value: bool) -> &'a mut W {
165 self.w.bits = (self.w.bits & !(0x01 << 1)) | (((value as u8) & 0x01) << 1);
166 self.w
167 }
168}
169#[doc = "STALL_I_DIS2\n\nValue on reset: 0"]
170#[derive(Clone, Copy, Debug, PartialEq)]
171pub enum STALL_I_DIS2_A {
172 #[doc = "0: Endpoint 2 IN direction stall is enabled."]
173 STALL_I_DIS2_0,
174 #[doc = "1: Endpoint 2 IN direction stall is disabled."]
175 STALL_I_DIS2_1,
176}
177impl From<STALL_I_DIS2_A> for bool {
178 #[inline(always)]
179 fn from(variant: STALL_I_DIS2_A) -> Self {
180 match variant {
181 STALL_I_DIS2_A::STALL_I_DIS2_0 => false,
182 STALL_I_DIS2_A::STALL_I_DIS2_1 => true,
183 }
184 }
185}
186#[doc = "Reader of field `STALL_I_DIS2`"]
187pub type STALL_I_DIS2_R = crate::R<bool, STALL_I_DIS2_A>;
188impl STALL_I_DIS2_R {
189 #[doc = r"Get enumerated values variant"]
190 #[inline(always)]
191 pub fn variant(&self) -> STALL_I_DIS2_A {
192 match self.bits {
193 false => STALL_I_DIS2_A::STALL_I_DIS2_0,
194 true => STALL_I_DIS2_A::STALL_I_DIS2_1,
195 }
196 }
197 #[doc = "Checks if the value of the field is `STALL_I_DIS2_0`"]
198 #[inline(always)]
199 pub fn is_stall_i_dis2_0(&self) -> bool {
200 *self == STALL_I_DIS2_A::STALL_I_DIS2_0
201 }
202 #[doc = "Checks if the value of the field is `STALL_I_DIS2_1`"]
203 #[inline(always)]
204 pub fn is_stall_i_dis2_1(&self) -> bool {
205 *self == STALL_I_DIS2_A::STALL_I_DIS2_1
206 }
207}
208#[doc = "Write proxy for field `STALL_I_DIS2`"]
209pub struct STALL_I_DIS2_W<'a> {
210 w: &'a mut W,
211}
212impl<'a> STALL_I_DIS2_W<'a> {
213 #[doc = r"Writes `variant` to the field"]
214 #[inline(always)]
215 pub fn variant(self, variant: STALL_I_DIS2_A) -> &'a mut W {
216 {
217 self.bit(variant.into())
218 }
219 }
220 #[doc = "Endpoint 2 IN direction stall is enabled."]
221 #[inline(always)]
222 pub fn stall_i_dis2_0(self) -> &'a mut W {
223 self.variant(STALL_I_DIS2_A::STALL_I_DIS2_0)
224 }
225 #[doc = "Endpoint 2 IN direction stall is disabled."]
226 #[inline(always)]
227 pub fn stall_i_dis2_1(self) -> &'a mut W {
228 self.variant(STALL_I_DIS2_A::STALL_I_DIS2_1)
229 }
230 #[doc = r"Sets the field bit"]
231 #[inline(always)]
232 pub fn set_bit(self) -> &'a mut W {
233 self.bit(true)
234 }
235 #[doc = r"Clears the field bit"]
236 #[inline(always)]
237 pub fn clear_bit(self) -> &'a mut W {
238 self.bit(false)
239 }
240 #[doc = r"Writes raw bits to the field"]
241 #[inline(always)]
242 pub fn bit(self, value: bool) -> &'a mut W {
243 self.w.bits = (self.w.bits & !(0x01 << 2)) | (((value as u8) & 0x01) << 2);
244 self.w
245 }
246}
247#[doc = "STALL_I_DIS3\n\nValue on reset: 0"]
248#[derive(Clone, Copy, Debug, PartialEq)]
249pub enum STALL_I_DIS3_A {
250 #[doc = "0: Endpoint 3 IN direction stall is enabled."]
251 STALL_I_DIS3_0,
252 #[doc = "1: Endpoint 3 IN direction stall is disabled."]
253 STALL_I_DIS3_1,
254}
255impl From<STALL_I_DIS3_A> for bool {
256 #[inline(always)]
257 fn from(variant: STALL_I_DIS3_A) -> Self {
258 match variant {
259 STALL_I_DIS3_A::STALL_I_DIS3_0 => false,
260 STALL_I_DIS3_A::STALL_I_DIS3_1 => true,
261 }
262 }
263}
264#[doc = "Reader of field `STALL_I_DIS3`"]
265pub type STALL_I_DIS3_R = crate::R<bool, STALL_I_DIS3_A>;
266impl STALL_I_DIS3_R {
267 #[doc = r"Get enumerated values variant"]
268 #[inline(always)]
269 pub fn variant(&self) -> STALL_I_DIS3_A {
270 match self.bits {
271 false => STALL_I_DIS3_A::STALL_I_DIS3_0,
272 true => STALL_I_DIS3_A::STALL_I_DIS3_1,
273 }
274 }
275 #[doc = "Checks if the value of the field is `STALL_I_DIS3_0`"]
276 #[inline(always)]
277 pub fn is_stall_i_dis3_0(&self) -> bool {
278 *self == STALL_I_DIS3_A::STALL_I_DIS3_0
279 }
280 #[doc = "Checks if the value of the field is `STALL_I_DIS3_1`"]
281 #[inline(always)]
282 pub fn is_stall_i_dis3_1(&self) -> bool {
283 *self == STALL_I_DIS3_A::STALL_I_DIS3_1
284 }
285}
286#[doc = "Write proxy for field `STALL_I_DIS3`"]
287pub struct STALL_I_DIS3_W<'a> {
288 w: &'a mut W,
289}
290impl<'a> STALL_I_DIS3_W<'a> {
291 #[doc = r"Writes `variant` to the field"]
292 #[inline(always)]
293 pub fn variant(self, variant: STALL_I_DIS3_A) -> &'a mut W {
294 {
295 self.bit(variant.into())
296 }
297 }
298 #[doc = "Endpoint 3 IN direction stall is enabled."]
299 #[inline(always)]
300 pub fn stall_i_dis3_0(self) -> &'a mut W {
301 self.variant(STALL_I_DIS3_A::STALL_I_DIS3_0)
302 }
303 #[doc = "Endpoint 3 IN direction stall is disabled."]
304 #[inline(always)]
305 pub fn stall_i_dis3_1(self) -> &'a mut W {
306 self.variant(STALL_I_DIS3_A::STALL_I_DIS3_1)
307 }
308 #[doc = r"Sets the field bit"]
309 #[inline(always)]
310 pub fn set_bit(self) -> &'a mut W {
311 self.bit(true)
312 }
313 #[doc = r"Clears the field bit"]
314 #[inline(always)]
315 pub fn clear_bit(self) -> &'a mut W {
316 self.bit(false)
317 }
318 #[doc = r"Writes raw bits to the field"]
319 #[inline(always)]
320 pub fn bit(self, value: bool) -> &'a mut W {
321 self.w.bits = (self.w.bits & !(0x01 << 3)) | (((value as u8) & 0x01) << 3);
322 self.w
323 }
324}
325#[doc = "STALL_I_DIS4\n\nValue on reset: 0"]
326#[derive(Clone, Copy, Debug, PartialEq)]
327pub enum STALL_I_DIS4_A {
328 #[doc = "0: Endpoint 4 IN direction stall is enabled."]
329 STALL_I_DIS4_0,
330 #[doc = "1: Endpoint 4 IN direction stall is disabled."]
331 STALL_I_DIS4_1,
332}
333impl From<STALL_I_DIS4_A> for bool {
334 #[inline(always)]
335 fn from(variant: STALL_I_DIS4_A) -> Self {
336 match variant {
337 STALL_I_DIS4_A::STALL_I_DIS4_0 => false,
338 STALL_I_DIS4_A::STALL_I_DIS4_1 => true,
339 }
340 }
341}
342#[doc = "Reader of field `STALL_I_DIS4`"]
343pub type STALL_I_DIS4_R = crate::R<bool, STALL_I_DIS4_A>;
344impl STALL_I_DIS4_R {
345 #[doc = r"Get enumerated values variant"]
346 #[inline(always)]
347 pub fn variant(&self) -> STALL_I_DIS4_A {
348 match self.bits {
349 false => STALL_I_DIS4_A::STALL_I_DIS4_0,
350 true => STALL_I_DIS4_A::STALL_I_DIS4_1,
351 }
352 }
353 #[doc = "Checks if the value of the field is `STALL_I_DIS4_0`"]
354 #[inline(always)]
355 pub fn is_stall_i_dis4_0(&self) -> bool {
356 *self == STALL_I_DIS4_A::STALL_I_DIS4_0
357 }
358 #[doc = "Checks if the value of the field is `STALL_I_DIS4_1`"]
359 #[inline(always)]
360 pub fn is_stall_i_dis4_1(&self) -> bool {
361 *self == STALL_I_DIS4_A::STALL_I_DIS4_1
362 }
363}
364#[doc = "Write proxy for field `STALL_I_DIS4`"]
365pub struct STALL_I_DIS4_W<'a> {
366 w: &'a mut W,
367}
368impl<'a> STALL_I_DIS4_W<'a> {
369 #[doc = r"Writes `variant` to the field"]
370 #[inline(always)]
371 pub fn variant(self, variant: STALL_I_DIS4_A) -> &'a mut W {
372 {
373 self.bit(variant.into())
374 }
375 }
376 #[doc = "Endpoint 4 IN direction stall is enabled."]
377 #[inline(always)]
378 pub fn stall_i_dis4_0(self) -> &'a mut W {
379 self.variant(STALL_I_DIS4_A::STALL_I_DIS4_0)
380 }
381 #[doc = "Endpoint 4 IN direction stall is disabled."]
382 #[inline(always)]
383 pub fn stall_i_dis4_1(self) -> &'a mut W {
384 self.variant(STALL_I_DIS4_A::STALL_I_DIS4_1)
385 }
386 #[doc = r"Sets the field bit"]
387 #[inline(always)]
388 pub fn set_bit(self) -> &'a mut W {
389 self.bit(true)
390 }
391 #[doc = r"Clears the field bit"]
392 #[inline(always)]
393 pub fn clear_bit(self) -> &'a mut W {
394 self.bit(false)
395 }
396 #[doc = r"Writes raw bits to the field"]
397 #[inline(always)]
398 pub fn bit(self, value: bool) -> &'a mut W {
399 self.w.bits = (self.w.bits & !(0x01 << 4)) | (((value as u8) & 0x01) << 4);
400 self.w
401 }
402}
403#[doc = "STALL_I_DIS5\n\nValue on reset: 0"]
404#[derive(Clone, Copy, Debug, PartialEq)]
405pub enum STALL_I_DIS5_A {
406 #[doc = "0: Endpoint 5 IN direction stall is enabled."]
407 STALL_I_DIS5_0,
408 #[doc = "1: Endpoint 5 IN direction stall is disabled."]
409 STALL_I_DIS5_1,
410}
411impl From<STALL_I_DIS5_A> for bool {
412 #[inline(always)]
413 fn from(variant: STALL_I_DIS5_A) -> Self {
414 match variant {
415 STALL_I_DIS5_A::STALL_I_DIS5_0 => false,
416 STALL_I_DIS5_A::STALL_I_DIS5_1 => true,
417 }
418 }
419}
420#[doc = "Reader of field `STALL_I_DIS5`"]
421pub type STALL_I_DIS5_R = crate::R<bool, STALL_I_DIS5_A>;
422impl STALL_I_DIS5_R {
423 #[doc = r"Get enumerated values variant"]
424 #[inline(always)]
425 pub fn variant(&self) -> STALL_I_DIS5_A {
426 match self.bits {
427 false => STALL_I_DIS5_A::STALL_I_DIS5_0,
428 true => STALL_I_DIS5_A::STALL_I_DIS5_1,
429 }
430 }
431 #[doc = "Checks if the value of the field is `STALL_I_DIS5_0`"]
432 #[inline(always)]
433 pub fn is_stall_i_dis5_0(&self) -> bool {
434 *self == STALL_I_DIS5_A::STALL_I_DIS5_0
435 }
436 #[doc = "Checks if the value of the field is `STALL_I_DIS5_1`"]
437 #[inline(always)]
438 pub fn is_stall_i_dis5_1(&self) -> bool {
439 *self == STALL_I_DIS5_A::STALL_I_DIS5_1
440 }
441}
442#[doc = "Write proxy for field `STALL_I_DIS5`"]
443pub struct STALL_I_DIS5_W<'a> {
444 w: &'a mut W,
445}
446impl<'a> STALL_I_DIS5_W<'a> {
447 #[doc = r"Writes `variant` to the field"]
448 #[inline(always)]
449 pub fn variant(self, variant: STALL_I_DIS5_A) -> &'a mut W {
450 {
451 self.bit(variant.into())
452 }
453 }
454 #[doc = "Endpoint 5 IN direction stall is enabled."]
455 #[inline(always)]
456 pub fn stall_i_dis5_0(self) -> &'a mut W {
457 self.variant(STALL_I_DIS5_A::STALL_I_DIS5_0)
458 }
459 #[doc = "Endpoint 5 IN direction stall is disabled."]
460 #[inline(always)]
461 pub fn stall_i_dis5_1(self) -> &'a mut W {
462 self.variant(STALL_I_DIS5_A::STALL_I_DIS5_1)
463 }
464 #[doc = r"Sets the field bit"]
465 #[inline(always)]
466 pub fn set_bit(self) -> &'a mut W {
467 self.bit(true)
468 }
469 #[doc = r"Clears the field bit"]
470 #[inline(always)]
471 pub fn clear_bit(self) -> &'a mut W {
472 self.bit(false)
473 }
474 #[doc = r"Writes raw bits to the field"]
475 #[inline(always)]
476 pub fn bit(self, value: bool) -> &'a mut W {
477 self.w.bits = (self.w.bits & !(0x01 << 5)) | (((value as u8) & 0x01) << 5);
478 self.w
479 }
480}
481#[doc = "STALL_I_DIS6\n\nValue on reset: 0"]
482#[derive(Clone, Copy, Debug, PartialEq)]
483pub enum STALL_I_DIS6_A {
484 #[doc = "0: Endpoint 6 IN direction stall is enabled."]
485 STALL_I_DIS6_0,
486 #[doc = "1: Endpoint 6 IN direction stall is disabled."]
487 STALL_I_DIS6_1,
488}
489impl From<STALL_I_DIS6_A> for bool {
490 #[inline(always)]
491 fn from(variant: STALL_I_DIS6_A) -> Self {
492 match variant {
493 STALL_I_DIS6_A::STALL_I_DIS6_0 => false,
494 STALL_I_DIS6_A::STALL_I_DIS6_1 => true,
495 }
496 }
497}
498#[doc = "Reader of field `STALL_I_DIS6`"]
499pub type STALL_I_DIS6_R = crate::R<bool, STALL_I_DIS6_A>;
500impl STALL_I_DIS6_R {
501 #[doc = r"Get enumerated values variant"]
502 #[inline(always)]
503 pub fn variant(&self) -> STALL_I_DIS6_A {
504 match self.bits {
505 false => STALL_I_DIS6_A::STALL_I_DIS6_0,
506 true => STALL_I_DIS6_A::STALL_I_DIS6_1,
507 }
508 }
509 #[doc = "Checks if the value of the field is `STALL_I_DIS6_0`"]
510 #[inline(always)]
511 pub fn is_stall_i_dis6_0(&self) -> bool {
512 *self == STALL_I_DIS6_A::STALL_I_DIS6_0
513 }
514 #[doc = "Checks if the value of the field is `STALL_I_DIS6_1`"]
515 #[inline(always)]
516 pub fn is_stall_i_dis6_1(&self) -> bool {
517 *self == STALL_I_DIS6_A::STALL_I_DIS6_1
518 }
519}
520#[doc = "Write proxy for field `STALL_I_DIS6`"]
521pub struct STALL_I_DIS6_W<'a> {
522 w: &'a mut W,
523}
524impl<'a> STALL_I_DIS6_W<'a> {
525 #[doc = r"Writes `variant` to the field"]
526 #[inline(always)]
527 pub fn variant(self, variant: STALL_I_DIS6_A) -> &'a mut W {
528 {
529 self.bit(variant.into())
530 }
531 }
532 #[doc = "Endpoint 6 IN direction stall is enabled."]
533 #[inline(always)]
534 pub fn stall_i_dis6_0(self) -> &'a mut W {
535 self.variant(STALL_I_DIS6_A::STALL_I_DIS6_0)
536 }
537 #[doc = "Endpoint 6 IN direction stall is disabled."]
538 #[inline(always)]
539 pub fn stall_i_dis6_1(self) -> &'a mut W {
540 self.variant(STALL_I_DIS6_A::STALL_I_DIS6_1)
541 }
542 #[doc = r"Sets the field bit"]
543 #[inline(always)]
544 pub fn set_bit(self) -> &'a mut W {
545 self.bit(true)
546 }
547 #[doc = r"Clears the field bit"]
548 #[inline(always)]
549 pub fn clear_bit(self) -> &'a mut W {
550 self.bit(false)
551 }
552 #[doc = r"Writes raw bits to the field"]
553 #[inline(always)]
554 pub fn bit(self, value: bool) -> &'a mut W {
555 self.w.bits = (self.w.bits & !(0x01 << 6)) | (((value as u8) & 0x01) << 6);
556 self.w
557 }
558}
559#[doc = "STALL_I_DIS7\n\nValue on reset: 0"]
560#[derive(Clone, Copy, Debug, PartialEq)]
561pub enum STALL_I_DIS7_A {
562 #[doc = "0: Endpoint 7 IN direction stall is enabled."]
563 STALL_I_DIS7_0,
564 #[doc = "1: Endpoint 7 IN direction stall is disabled."]
565 STALL_I_DIS7_1,
566}
567impl From<STALL_I_DIS7_A> for bool {
568 #[inline(always)]
569 fn from(variant: STALL_I_DIS7_A) -> Self {
570 match variant {
571 STALL_I_DIS7_A::STALL_I_DIS7_0 => false,
572 STALL_I_DIS7_A::STALL_I_DIS7_1 => true,
573 }
574 }
575}
576#[doc = "Reader of field `STALL_I_DIS7`"]
577pub type STALL_I_DIS7_R = crate::R<bool, STALL_I_DIS7_A>;
578impl STALL_I_DIS7_R {
579 #[doc = r"Get enumerated values variant"]
580 #[inline(always)]
581 pub fn variant(&self) -> STALL_I_DIS7_A {
582 match self.bits {
583 false => STALL_I_DIS7_A::STALL_I_DIS7_0,
584 true => STALL_I_DIS7_A::STALL_I_DIS7_1,
585 }
586 }
587 #[doc = "Checks if the value of the field is `STALL_I_DIS7_0`"]
588 #[inline(always)]
589 pub fn is_stall_i_dis7_0(&self) -> bool {
590 *self == STALL_I_DIS7_A::STALL_I_DIS7_0
591 }
592 #[doc = "Checks if the value of the field is `STALL_I_DIS7_1`"]
593 #[inline(always)]
594 pub fn is_stall_i_dis7_1(&self) -> bool {
595 *self == STALL_I_DIS7_A::STALL_I_DIS7_1
596 }
597}
598#[doc = "Write proxy for field `STALL_I_DIS7`"]
599pub struct STALL_I_DIS7_W<'a> {
600 w: &'a mut W,
601}
602impl<'a> STALL_I_DIS7_W<'a> {
603 #[doc = r"Writes `variant` to the field"]
604 #[inline(always)]
605 pub fn variant(self, variant: STALL_I_DIS7_A) -> &'a mut W {
606 {
607 self.bit(variant.into())
608 }
609 }
610 #[doc = "Endpoint 7 IN direction stall is enabled."]
611 #[inline(always)]
612 pub fn stall_i_dis7_0(self) -> &'a mut W {
613 self.variant(STALL_I_DIS7_A::STALL_I_DIS7_0)
614 }
615 #[doc = "Endpoint 7 IN direction stall is disabled."]
616 #[inline(always)]
617 pub fn stall_i_dis7_1(self) -> &'a mut W {
618 self.variant(STALL_I_DIS7_A::STALL_I_DIS7_1)
619 }
620 #[doc = r"Sets the field bit"]
621 #[inline(always)]
622 pub fn set_bit(self) -> &'a mut W {
623 self.bit(true)
624 }
625 #[doc = r"Clears the field bit"]
626 #[inline(always)]
627 pub fn clear_bit(self) -> &'a mut W {
628 self.bit(false)
629 }
630 #[doc = r"Writes raw bits to the field"]
631 #[inline(always)]
632 pub fn bit(self, value: bool) -> &'a mut W {
633 self.w.bits = (self.w.bits & !(0x01 << 7)) | (((value as u8) & 0x01) << 7);
634 self.w
635 }
636}
637impl R {
638 #[doc = "Bit 0 - STALL_I_DIS0"]
639 #[inline(always)]
640 pub fn stall_i_dis0(&self) -> STALL_I_DIS0_R {
641 STALL_I_DIS0_R::new((self.bits & 0x01) != 0)
642 }
643 #[doc = "Bit 1 - STALL_I_DIS1"]
644 #[inline(always)]
645 pub fn stall_i_dis1(&self) -> STALL_I_DIS1_R {
646 STALL_I_DIS1_R::new(((self.bits >> 1) & 0x01) != 0)
647 }
648 #[doc = "Bit 2 - STALL_I_DIS2"]
649 #[inline(always)]
650 pub fn stall_i_dis2(&self) -> STALL_I_DIS2_R {
651 STALL_I_DIS2_R::new(((self.bits >> 2) & 0x01) != 0)
652 }
653 #[doc = "Bit 3 - STALL_I_DIS3"]
654 #[inline(always)]
655 pub fn stall_i_dis3(&self) -> STALL_I_DIS3_R {
656 STALL_I_DIS3_R::new(((self.bits >> 3) & 0x01) != 0)
657 }
658 #[doc = "Bit 4 - STALL_I_DIS4"]
659 #[inline(always)]
660 pub fn stall_i_dis4(&self) -> STALL_I_DIS4_R {
661 STALL_I_DIS4_R::new(((self.bits >> 4) & 0x01) != 0)
662 }
663 #[doc = "Bit 5 - STALL_I_DIS5"]
664 #[inline(always)]
665 pub fn stall_i_dis5(&self) -> STALL_I_DIS5_R {
666 STALL_I_DIS5_R::new(((self.bits >> 5) & 0x01) != 0)
667 }
668 #[doc = "Bit 6 - STALL_I_DIS6"]
669 #[inline(always)]
670 pub fn stall_i_dis6(&self) -> STALL_I_DIS6_R {
671 STALL_I_DIS6_R::new(((self.bits >> 6) & 0x01) != 0)
672 }
673 #[doc = "Bit 7 - STALL_I_DIS7"]
674 #[inline(always)]
675 pub fn stall_i_dis7(&self) -> STALL_I_DIS7_R {
676 STALL_I_DIS7_R::new(((self.bits >> 7) & 0x01) != 0)
677 }
678}
679impl W {
680 #[doc = "Bit 0 - STALL_I_DIS0"]
681 #[inline(always)]
682 pub fn stall_i_dis0(&mut self) -> STALL_I_DIS0_W {
683 STALL_I_DIS0_W { w: self }
684 }
685 #[doc = "Bit 1 - STALL_I_DIS1"]
686 #[inline(always)]
687 pub fn stall_i_dis1(&mut self) -> STALL_I_DIS1_W {
688 STALL_I_DIS1_W { w: self }
689 }
690 #[doc = "Bit 2 - STALL_I_DIS2"]
691 #[inline(always)]
692 pub fn stall_i_dis2(&mut self) -> STALL_I_DIS2_W {
693 STALL_I_DIS2_W { w: self }
694 }
695 #[doc = "Bit 3 - STALL_I_DIS3"]
696 #[inline(always)]
697 pub fn stall_i_dis3(&mut self) -> STALL_I_DIS3_W {
698 STALL_I_DIS3_W { w: self }
699 }
700 #[doc = "Bit 4 - STALL_I_DIS4"]
701 #[inline(always)]
702 pub fn stall_i_dis4(&mut self) -> STALL_I_DIS4_W {
703 STALL_I_DIS4_W { w: self }
704 }
705 #[doc = "Bit 5 - STALL_I_DIS5"]
706 #[inline(always)]
707 pub fn stall_i_dis5(&mut self) -> STALL_I_DIS5_W {
708 STALL_I_DIS5_W { w: self }
709 }
710 #[doc = "Bit 6 - STALL_I_DIS6"]
711 #[inline(always)]
712 pub fn stall_i_dis6(&mut self) -> STALL_I_DIS6_W {
713 STALL_I_DIS6_W { w: self }
714 }
715 #[doc = "Bit 7 - STALL_I_DIS7"]
716 #[inline(always)]
717 pub fn stall_i_dis7(&mut self) -> STALL_I_DIS7_W {
718 STALL_I_DIS7_W { w: self }
719 }
720}