1#[doc = "Reader of register S2"]
2pub type R = crate::R<u8, super::S2>;
3#[doc = "Writer for register S2"]
4pub type W = crate::W<u8, super::S2>;
5#[doc = "Register S2 `reset()`'s with value 0"]
6impl crate::ResetValue for super::S2 {
7 type Type = u8;
8 #[inline(always)]
9 fn reset_value() -> Self::Type {
10 0
11 }
12}
13#[doc = "Receiver Active Flag\n\nValue on reset: 0"]
14#[derive(Clone, Copy, Debug, PartialEq)]
15pub enum RAF_A {
16 #[doc = "0: UART receiver idle/inactive waiting for a start bit."]
17 _0,
18 #[doc = "1: UART receiver active, RxD input not idle."]
19 _1,
20}
21impl From<RAF_A> for bool {
22 #[inline(always)]
23 fn from(variant: RAF_A) -> Self {
24 match variant {
25 RAF_A::_0 => false,
26 RAF_A::_1 => true,
27 }
28 }
29}
30#[doc = "Reader of field `RAF`"]
31pub type RAF_R = crate::R<bool, RAF_A>;
32impl RAF_R {
33 #[doc = r"Get enumerated values variant"]
34 #[inline(always)]
35 pub fn variant(&self) -> RAF_A {
36 match self.bits {
37 false => RAF_A::_0,
38 true => RAF_A::_1,
39 }
40 }
41 #[doc = "Checks if the value of the field is `_0`"]
42 #[inline(always)]
43 pub fn is_0(&self) -> bool {
44 *self == RAF_A::_0
45 }
46 #[doc = "Checks if the value of the field is `_1`"]
47 #[inline(always)]
48 pub fn is_1(&self) -> bool {
49 *self == RAF_A::_1
50 }
51}
52#[doc = "LIN Break Detection Enable\n\nValue on reset: 0"]
53#[derive(Clone, Copy, Debug, PartialEq)]
54pub enum LBKDE_A {
55 #[doc = "0: Break character detection is disabled."]
56 _0,
57 #[doc = "1: Break character is detected at length of 11 bit times if C1\\[M\\] = 0 or 12 bits time if C1\\[M\\] = 1."]
58 _1,
59}
60impl From<LBKDE_A> for bool {
61 #[inline(always)]
62 fn from(variant: LBKDE_A) -> Self {
63 match variant {
64 LBKDE_A::_0 => false,
65 LBKDE_A::_1 => true,
66 }
67 }
68}
69#[doc = "Reader of field `LBKDE`"]
70pub type LBKDE_R = crate::R<bool, LBKDE_A>;
71impl LBKDE_R {
72 #[doc = r"Get enumerated values variant"]
73 #[inline(always)]
74 pub fn variant(&self) -> LBKDE_A {
75 match self.bits {
76 false => LBKDE_A::_0,
77 true => LBKDE_A::_1,
78 }
79 }
80 #[doc = "Checks if the value of the field is `_0`"]
81 #[inline(always)]
82 pub fn is_0(&self) -> bool {
83 *self == LBKDE_A::_0
84 }
85 #[doc = "Checks if the value of the field is `_1`"]
86 #[inline(always)]
87 pub fn is_1(&self) -> bool {
88 *self == LBKDE_A::_1
89 }
90}
91#[doc = "Write proxy for field `LBKDE`"]
92pub struct LBKDE_W<'a> {
93 w: &'a mut W,
94}
95impl<'a> LBKDE_W<'a> {
96 #[doc = r"Writes `variant` to the field"]
97 #[inline(always)]
98 pub fn variant(self, variant: LBKDE_A) -> &'a mut W {
99 {
100 self.bit(variant.into())
101 }
102 }
103 #[doc = "Break character detection is disabled."]
104 #[inline(always)]
105 pub fn _0(self) -> &'a mut W {
106 self.variant(LBKDE_A::_0)
107 }
108 #[doc = "Break character is detected at length of 11 bit times if C1\\[M\\] = 0 or 12 bits time if C1\\[M\\] = 1."]
109 #[inline(always)]
110 pub fn _1(self) -> &'a mut W {
111 self.variant(LBKDE_A::_1)
112 }
113 #[doc = r"Sets the field bit"]
114 #[inline(always)]
115 pub fn set_bit(self) -> &'a mut W {
116 self.bit(true)
117 }
118 #[doc = r"Clears the field bit"]
119 #[inline(always)]
120 pub fn clear_bit(self) -> &'a mut W {
121 self.bit(false)
122 }
123 #[doc = r"Writes raw bits to the field"]
124 #[inline(always)]
125 pub fn bit(self, value: bool) -> &'a mut W {
126 self.w.bits = (self.w.bits & !(0x01 << 1)) | (((value as u8) & 0x01) << 1);
127 self.w
128 }
129}
130#[doc = "Break Transmit Character Length\n\nValue on reset: 0"]
131#[derive(Clone, Copy, Debug, PartialEq)]
132pub enum BRK13_A {
133 #[doc = "0: Break character is 10, 11, or 12 bits long."]
134 _0,
135 #[doc = "1: Break character is 13 or 14 bits long."]
136 _1,
137}
138impl From<BRK13_A> for bool {
139 #[inline(always)]
140 fn from(variant: BRK13_A) -> Self {
141 match variant {
142 BRK13_A::_0 => false,
143 BRK13_A::_1 => true,
144 }
145 }
146}
147#[doc = "Reader of field `BRK13`"]
148pub type BRK13_R = crate::R<bool, BRK13_A>;
149impl BRK13_R {
150 #[doc = r"Get enumerated values variant"]
151 #[inline(always)]
152 pub fn variant(&self) -> BRK13_A {
153 match self.bits {
154 false => BRK13_A::_0,
155 true => BRK13_A::_1,
156 }
157 }
158 #[doc = "Checks if the value of the field is `_0`"]
159 #[inline(always)]
160 pub fn is_0(&self) -> bool {
161 *self == BRK13_A::_0
162 }
163 #[doc = "Checks if the value of the field is `_1`"]
164 #[inline(always)]
165 pub fn is_1(&self) -> bool {
166 *self == BRK13_A::_1
167 }
168}
169#[doc = "Write proxy for field `BRK13`"]
170pub struct BRK13_W<'a> {
171 w: &'a mut W,
172}
173impl<'a> BRK13_W<'a> {
174 #[doc = r"Writes `variant` to the field"]
175 #[inline(always)]
176 pub fn variant(self, variant: BRK13_A) -> &'a mut W {
177 {
178 self.bit(variant.into())
179 }
180 }
181 #[doc = "Break character is 10, 11, or 12 bits long."]
182 #[inline(always)]
183 pub fn _0(self) -> &'a mut W {
184 self.variant(BRK13_A::_0)
185 }
186 #[doc = "Break character is 13 or 14 bits long."]
187 #[inline(always)]
188 pub fn _1(self) -> &'a mut W {
189 self.variant(BRK13_A::_1)
190 }
191 #[doc = r"Sets the field bit"]
192 #[inline(always)]
193 pub fn set_bit(self) -> &'a mut W {
194 self.bit(true)
195 }
196 #[doc = r"Clears the field bit"]
197 #[inline(always)]
198 pub fn clear_bit(self) -> &'a mut W {
199 self.bit(false)
200 }
201 #[doc = r"Writes raw bits to the field"]
202 #[inline(always)]
203 pub fn bit(self, value: bool) -> &'a mut W {
204 self.w.bits = (self.w.bits & !(0x01 << 2)) | (((value as u8) & 0x01) << 2);
205 self.w
206 }
207}
208#[doc = "Receive Wakeup Idle Detect\n\nValue on reset: 0"]
209#[derive(Clone, Copy, Debug, PartialEq)]
210pub enum RWUID_A {
211 #[doc = "0: S1\\[IDLE\\] is not set upon detection of an idle character."]
212 _0,
213 #[doc = "1: S1\\[IDLE\\] is set upon detection of an idle character."]
214 _1,
215}
216impl From<RWUID_A> for bool {
217 #[inline(always)]
218 fn from(variant: RWUID_A) -> Self {
219 match variant {
220 RWUID_A::_0 => false,
221 RWUID_A::_1 => true,
222 }
223 }
224}
225#[doc = "Reader of field `RWUID`"]
226pub type RWUID_R = crate::R<bool, RWUID_A>;
227impl RWUID_R {
228 #[doc = r"Get enumerated values variant"]
229 #[inline(always)]
230 pub fn variant(&self) -> RWUID_A {
231 match self.bits {
232 false => RWUID_A::_0,
233 true => RWUID_A::_1,
234 }
235 }
236 #[doc = "Checks if the value of the field is `_0`"]
237 #[inline(always)]
238 pub fn is_0(&self) -> bool {
239 *self == RWUID_A::_0
240 }
241 #[doc = "Checks if the value of the field is `_1`"]
242 #[inline(always)]
243 pub fn is_1(&self) -> bool {
244 *self == RWUID_A::_1
245 }
246}
247#[doc = "Write proxy for field `RWUID`"]
248pub struct RWUID_W<'a> {
249 w: &'a mut W,
250}
251impl<'a> RWUID_W<'a> {
252 #[doc = r"Writes `variant` to the field"]
253 #[inline(always)]
254 pub fn variant(self, variant: RWUID_A) -> &'a mut W {
255 {
256 self.bit(variant.into())
257 }
258 }
259 #[doc = "S1\\[IDLE\\] is not set upon detection of an idle character."]
260 #[inline(always)]
261 pub fn _0(self) -> &'a mut W {
262 self.variant(RWUID_A::_0)
263 }
264 #[doc = "S1\\[IDLE\\] is set upon detection of an idle character."]
265 #[inline(always)]
266 pub fn _1(self) -> &'a mut W {
267 self.variant(RWUID_A::_1)
268 }
269 #[doc = r"Sets the field bit"]
270 #[inline(always)]
271 pub fn set_bit(self) -> &'a mut W {
272 self.bit(true)
273 }
274 #[doc = r"Clears the field bit"]
275 #[inline(always)]
276 pub fn clear_bit(self) -> &'a mut W {
277 self.bit(false)
278 }
279 #[doc = r"Writes raw bits to the field"]
280 #[inline(always)]
281 pub fn bit(self, value: bool) -> &'a mut W {
282 self.w.bits = (self.w.bits & !(0x01 << 3)) | (((value as u8) & 0x01) << 3);
283 self.w
284 }
285}
286#[doc = "Receive Data Inversion\n\nValue on reset: 0"]
287#[derive(Clone, Copy, Debug, PartialEq)]
288pub enum RXINV_A {
289 #[doc = "0: Receive data is not inverted."]
290 _0,
291 #[doc = "1: Receive data is inverted."]
292 _1,
293}
294impl From<RXINV_A> for bool {
295 #[inline(always)]
296 fn from(variant: RXINV_A) -> Self {
297 match variant {
298 RXINV_A::_0 => false,
299 RXINV_A::_1 => true,
300 }
301 }
302}
303#[doc = "Reader of field `RXINV`"]
304pub type RXINV_R = crate::R<bool, RXINV_A>;
305impl RXINV_R {
306 #[doc = r"Get enumerated values variant"]
307 #[inline(always)]
308 pub fn variant(&self) -> RXINV_A {
309 match self.bits {
310 false => RXINV_A::_0,
311 true => RXINV_A::_1,
312 }
313 }
314 #[doc = "Checks if the value of the field is `_0`"]
315 #[inline(always)]
316 pub fn is_0(&self) -> bool {
317 *self == RXINV_A::_0
318 }
319 #[doc = "Checks if the value of the field is `_1`"]
320 #[inline(always)]
321 pub fn is_1(&self) -> bool {
322 *self == RXINV_A::_1
323 }
324}
325#[doc = "Write proxy for field `RXINV`"]
326pub struct RXINV_W<'a> {
327 w: &'a mut W,
328}
329impl<'a> RXINV_W<'a> {
330 #[doc = r"Writes `variant` to the field"]
331 #[inline(always)]
332 pub fn variant(self, variant: RXINV_A) -> &'a mut W {
333 {
334 self.bit(variant.into())
335 }
336 }
337 #[doc = "Receive data is not inverted."]
338 #[inline(always)]
339 pub fn _0(self) -> &'a mut W {
340 self.variant(RXINV_A::_0)
341 }
342 #[doc = "Receive data is inverted."]
343 #[inline(always)]
344 pub fn _1(self) -> &'a mut W {
345 self.variant(RXINV_A::_1)
346 }
347 #[doc = r"Sets the field bit"]
348 #[inline(always)]
349 pub fn set_bit(self) -> &'a mut W {
350 self.bit(true)
351 }
352 #[doc = r"Clears the field bit"]
353 #[inline(always)]
354 pub fn clear_bit(self) -> &'a mut W {
355 self.bit(false)
356 }
357 #[doc = r"Writes raw bits to the field"]
358 #[inline(always)]
359 pub fn bit(self, value: bool) -> &'a mut W {
360 self.w.bits = (self.w.bits & !(0x01 << 4)) | (((value as u8) & 0x01) << 4);
361 self.w
362 }
363}
364#[doc = "Most Significant Bit First\n\nValue on reset: 0"]
365#[derive(Clone, Copy, Debug, PartialEq)]
366pub enum MSBF_A {
367 #[doc = "0: LSB (bit0) is the first bit that is transmitted following the start bit. Further, the first bit received after the start bit is identified as bit0."]
368 _0,
369 #[doc = "1: MSB (bit8, bit7 or bit6) is the first bit that is transmitted following the start bit, depending on the setting of C1\\[M\\] and C1\\[PE\\]. Further, the first bit received after the start bit is identified as bit8, bit7, or bit6, depending on the setting of C1\\[M\\] and C1\\[PE\\]."]
370 _1,
371}
372impl From<MSBF_A> for bool {
373 #[inline(always)]
374 fn from(variant: MSBF_A) -> Self {
375 match variant {
376 MSBF_A::_0 => false,
377 MSBF_A::_1 => true,
378 }
379 }
380}
381#[doc = "Reader of field `MSBF`"]
382pub type MSBF_R = crate::R<bool, MSBF_A>;
383impl MSBF_R {
384 #[doc = r"Get enumerated values variant"]
385 #[inline(always)]
386 pub fn variant(&self) -> MSBF_A {
387 match self.bits {
388 false => MSBF_A::_0,
389 true => MSBF_A::_1,
390 }
391 }
392 #[doc = "Checks if the value of the field is `_0`"]
393 #[inline(always)]
394 pub fn is_0(&self) -> bool {
395 *self == MSBF_A::_0
396 }
397 #[doc = "Checks if the value of the field is `_1`"]
398 #[inline(always)]
399 pub fn is_1(&self) -> bool {
400 *self == MSBF_A::_1
401 }
402}
403#[doc = "Write proxy for field `MSBF`"]
404pub struct MSBF_W<'a> {
405 w: &'a mut W,
406}
407impl<'a> MSBF_W<'a> {
408 #[doc = r"Writes `variant` to the field"]
409 #[inline(always)]
410 pub fn variant(self, variant: MSBF_A) -> &'a mut W {
411 {
412 self.bit(variant.into())
413 }
414 }
415 #[doc = "LSB (bit0) is the first bit that is transmitted following the start bit. Further, the first bit received after the start bit is identified as bit0."]
416 #[inline(always)]
417 pub fn _0(self) -> &'a mut W {
418 self.variant(MSBF_A::_0)
419 }
420 #[doc = "MSB (bit8, bit7 or bit6) is the first bit that is transmitted following the start bit, depending on the setting of C1\\[M\\] and C1\\[PE\\]. Further, the first bit received after the start bit is identified as bit8, bit7, or bit6, depending on the setting of C1\\[M\\] and C1\\[PE\\]."]
421 #[inline(always)]
422 pub fn _1(self) -> &'a mut W {
423 self.variant(MSBF_A::_1)
424 }
425 #[doc = r"Sets the field bit"]
426 #[inline(always)]
427 pub fn set_bit(self) -> &'a mut W {
428 self.bit(true)
429 }
430 #[doc = r"Clears the field bit"]
431 #[inline(always)]
432 pub fn clear_bit(self) -> &'a mut W {
433 self.bit(false)
434 }
435 #[doc = r"Writes raw bits to the field"]
436 #[inline(always)]
437 pub fn bit(self, value: bool) -> &'a mut W {
438 self.w.bits = (self.w.bits & !(0x01 << 5)) | (((value as u8) & 0x01) << 5);
439 self.w
440 }
441}
442#[doc = "RxD Pin Active Edge Interrupt Flag\n\nValue on reset: 0"]
443#[derive(Clone, Copy, Debug, PartialEq)]
444pub enum RXEDGIF_A {
445 #[doc = "0: No active edge on the receive pin has occurred."]
446 _0,
447 #[doc = "1: An active edge on the receive pin has occurred."]
448 _1,
449}
450impl From<RXEDGIF_A> for bool {
451 #[inline(always)]
452 fn from(variant: RXEDGIF_A) -> Self {
453 match variant {
454 RXEDGIF_A::_0 => false,
455 RXEDGIF_A::_1 => true,
456 }
457 }
458}
459#[doc = "Reader of field `RXEDGIF`"]
460pub type RXEDGIF_R = crate::R<bool, RXEDGIF_A>;
461impl RXEDGIF_R {
462 #[doc = r"Get enumerated values variant"]
463 #[inline(always)]
464 pub fn variant(&self) -> RXEDGIF_A {
465 match self.bits {
466 false => RXEDGIF_A::_0,
467 true => RXEDGIF_A::_1,
468 }
469 }
470 #[doc = "Checks if the value of the field is `_0`"]
471 #[inline(always)]
472 pub fn is_0(&self) -> bool {
473 *self == RXEDGIF_A::_0
474 }
475 #[doc = "Checks if the value of the field is `_1`"]
476 #[inline(always)]
477 pub fn is_1(&self) -> bool {
478 *self == RXEDGIF_A::_1
479 }
480}
481#[doc = "Write proxy for field `RXEDGIF`"]
482pub struct RXEDGIF_W<'a> {
483 w: &'a mut W,
484}
485impl<'a> RXEDGIF_W<'a> {
486 #[doc = r"Writes `variant` to the field"]
487 #[inline(always)]
488 pub fn variant(self, variant: RXEDGIF_A) -> &'a mut W {
489 {
490 self.bit(variant.into())
491 }
492 }
493 #[doc = "No active edge on the receive pin has occurred."]
494 #[inline(always)]
495 pub fn _0(self) -> &'a mut W {
496 self.variant(RXEDGIF_A::_0)
497 }
498 #[doc = "An active edge on the receive pin has occurred."]
499 #[inline(always)]
500 pub fn _1(self) -> &'a mut W {
501 self.variant(RXEDGIF_A::_1)
502 }
503 #[doc = r"Sets the field bit"]
504 #[inline(always)]
505 pub fn set_bit(self) -> &'a mut W {
506 self.bit(true)
507 }
508 #[doc = r"Clears the field bit"]
509 #[inline(always)]
510 pub fn clear_bit(self) -> &'a mut W {
511 self.bit(false)
512 }
513 #[doc = r"Writes raw bits to the field"]
514 #[inline(always)]
515 pub fn bit(self, value: bool) -> &'a mut W {
516 self.w.bits = (self.w.bits & !(0x01 << 6)) | (((value as u8) & 0x01) << 6);
517 self.w
518 }
519}
520#[doc = "LIN Break Detect Interrupt Flag\n\nValue on reset: 0"]
521#[derive(Clone, Copy, Debug, PartialEq)]
522pub enum LBKDIF_A {
523 #[doc = "0: No LIN break character detected."]
524 _0,
525 #[doc = "1: LIN break character detected."]
526 _1,
527}
528impl From<LBKDIF_A> for bool {
529 #[inline(always)]
530 fn from(variant: LBKDIF_A) -> Self {
531 match variant {
532 LBKDIF_A::_0 => false,
533 LBKDIF_A::_1 => true,
534 }
535 }
536}
537#[doc = "Reader of field `LBKDIF`"]
538pub type LBKDIF_R = crate::R<bool, LBKDIF_A>;
539impl LBKDIF_R {
540 #[doc = r"Get enumerated values variant"]
541 #[inline(always)]
542 pub fn variant(&self) -> LBKDIF_A {
543 match self.bits {
544 false => LBKDIF_A::_0,
545 true => LBKDIF_A::_1,
546 }
547 }
548 #[doc = "Checks if the value of the field is `_0`"]
549 #[inline(always)]
550 pub fn is_0(&self) -> bool {
551 *self == LBKDIF_A::_0
552 }
553 #[doc = "Checks if the value of the field is `_1`"]
554 #[inline(always)]
555 pub fn is_1(&self) -> bool {
556 *self == LBKDIF_A::_1
557 }
558}
559#[doc = "Write proxy for field `LBKDIF`"]
560pub struct LBKDIF_W<'a> {
561 w: &'a mut W,
562}
563impl<'a> LBKDIF_W<'a> {
564 #[doc = r"Writes `variant` to the field"]
565 #[inline(always)]
566 pub fn variant(self, variant: LBKDIF_A) -> &'a mut W {
567 {
568 self.bit(variant.into())
569 }
570 }
571 #[doc = "No LIN break character detected."]
572 #[inline(always)]
573 pub fn _0(self) -> &'a mut W {
574 self.variant(LBKDIF_A::_0)
575 }
576 #[doc = "LIN break character detected."]
577 #[inline(always)]
578 pub fn _1(self) -> &'a mut W {
579 self.variant(LBKDIF_A::_1)
580 }
581 #[doc = r"Sets the field bit"]
582 #[inline(always)]
583 pub fn set_bit(self) -> &'a mut W {
584 self.bit(true)
585 }
586 #[doc = r"Clears the field bit"]
587 #[inline(always)]
588 pub fn clear_bit(self) -> &'a mut W {
589 self.bit(false)
590 }
591 #[doc = r"Writes raw bits to the field"]
592 #[inline(always)]
593 pub fn bit(self, value: bool) -> &'a mut W {
594 self.w.bits = (self.w.bits & !(0x01 << 7)) | (((value as u8) & 0x01) << 7);
595 self.w
596 }
597}
598impl R {
599 #[doc = "Bit 0 - Receiver Active Flag"]
600 #[inline(always)]
601 pub fn raf(&self) -> RAF_R {
602 RAF_R::new((self.bits & 0x01) != 0)
603 }
604 #[doc = "Bit 1 - LIN Break Detection Enable"]
605 #[inline(always)]
606 pub fn lbkde(&self) -> LBKDE_R {
607 LBKDE_R::new(((self.bits >> 1) & 0x01) != 0)
608 }
609 #[doc = "Bit 2 - Break Transmit Character Length"]
610 #[inline(always)]
611 pub fn brk13(&self) -> BRK13_R {
612 BRK13_R::new(((self.bits >> 2) & 0x01) != 0)
613 }
614 #[doc = "Bit 3 - Receive Wakeup Idle Detect"]
615 #[inline(always)]
616 pub fn rwuid(&self) -> RWUID_R {
617 RWUID_R::new(((self.bits >> 3) & 0x01) != 0)
618 }
619 #[doc = "Bit 4 - Receive Data Inversion"]
620 #[inline(always)]
621 pub fn rxinv(&self) -> RXINV_R {
622 RXINV_R::new(((self.bits >> 4) & 0x01) != 0)
623 }
624 #[doc = "Bit 5 - Most Significant Bit First"]
625 #[inline(always)]
626 pub fn msbf(&self) -> MSBF_R {
627 MSBF_R::new(((self.bits >> 5) & 0x01) != 0)
628 }
629 #[doc = "Bit 6 - RxD Pin Active Edge Interrupt Flag"]
630 #[inline(always)]
631 pub fn rxedgif(&self) -> RXEDGIF_R {
632 RXEDGIF_R::new(((self.bits >> 6) & 0x01) != 0)
633 }
634 #[doc = "Bit 7 - LIN Break Detect Interrupt Flag"]
635 #[inline(always)]
636 pub fn lbkdif(&self) -> LBKDIF_R {
637 LBKDIF_R::new(((self.bits >> 7) & 0x01) != 0)
638 }
639}
640impl W {
641 #[doc = "Bit 1 - LIN Break Detection Enable"]
642 #[inline(always)]
643 pub fn lbkde(&mut self) -> LBKDE_W {
644 LBKDE_W { w: self }
645 }
646 #[doc = "Bit 2 - Break Transmit Character Length"]
647 #[inline(always)]
648 pub fn brk13(&mut self) -> BRK13_W {
649 BRK13_W { w: self }
650 }
651 #[doc = "Bit 3 - Receive Wakeup Idle Detect"]
652 #[inline(always)]
653 pub fn rwuid(&mut self) -> RWUID_W {
654 RWUID_W { w: self }
655 }
656 #[doc = "Bit 4 - Receive Data Inversion"]
657 #[inline(always)]
658 pub fn rxinv(&mut self) -> RXINV_W {
659 RXINV_W { w: self }
660 }
661 #[doc = "Bit 5 - Most Significant Bit First"]
662 #[inline(always)]
663 pub fn msbf(&mut self) -> MSBF_W {
664 MSBF_W { w: self }
665 }
666 #[doc = "Bit 6 - RxD Pin Active Edge Interrupt Flag"]
667 #[inline(always)]
668 pub fn rxedgif(&mut self) -> RXEDGIF_W {
669 RXEDGIF_W { w: self }
670 }
671 #[doc = "Bit 7 - LIN Break Detect Interrupt Flag"]
672 #[inline(always)]
673 pub fn lbkdif(&mut self) -> LBKDIF_W {
674 LBKDIF_W { w: self }
675 }
676}