1#[doc = "Register `SSR` reader"]
2pub type R = crate::R<SsrSpec>;
3#[doc = "Register `SSR` writer"]
4pub type W = crate::W<SsrSpec>;
5#[doc = "Transmit Data Flag\n\nValue on reset: 0"]
6#[cfg_attr(feature = "defmt", derive(defmt::Format))]
7#[derive(Clone, Copy, Debug, PartialEq, Eq)]
8pub enum Tdf {
9 #[doc = "0: Transmit data not requested"]
10 NoFlag = 0,
11 #[doc = "1: Transmit data is requested"]
12 Flag = 1,
13}
14impl From<Tdf> for bool {
15 #[inline(always)]
16 fn from(variant: Tdf) -> Self {
17 variant as u8 != 0
18 }
19}
20#[doc = "Field `TDF` reader - Transmit Data Flag"]
21pub type TdfR = crate::BitReader<Tdf>;
22impl TdfR {
23 #[doc = "Get enumerated values variant"]
24 #[inline(always)]
25 pub const fn variant(&self) -> Tdf {
26 match self.bits {
27 false => Tdf::NoFlag,
28 true => Tdf::Flag,
29 }
30 }
31 #[doc = "Transmit data not requested"]
32 #[inline(always)]
33 pub fn is_no_flag(&self) -> bool {
34 *self == Tdf::NoFlag
35 }
36 #[doc = "Transmit data is requested"]
37 #[inline(always)]
38 pub fn is_flag(&self) -> bool {
39 *self == Tdf::Flag
40 }
41}
42#[doc = "Receive Data Flag\n\nValue on reset: 0"]
43#[cfg_attr(feature = "defmt", derive(defmt::Format))]
44#[derive(Clone, Copy, Debug, PartialEq, Eq)]
45pub enum Rdf {
46 #[doc = "0: Not ready"]
47 NotReady = 0,
48 #[doc = "1: Ready"]
49 Ready = 1,
50}
51impl From<Rdf> for bool {
52 #[inline(always)]
53 fn from(variant: Rdf) -> Self {
54 variant as u8 != 0
55 }
56}
57#[doc = "Field `RDF` reader - Receive Data Flag"]
58pub type RdfR = crate::BitReader<Rdf>;
59impl RdfR {
60 #[doc = "Get enumerated values variant"]
61 #[inline(always)]
62 pub const fn variant(&self) -> Rdf {
63 match self.bits {
64 false => Rdf::NotReady,
65 true => Rdf::Ready,
66 }
67 }
68 #[doc = "Not ready"]
69 #[inline(always)]
70 pub fn is_not_ready(&self) -> bool {
71 *self == Rdf::NotReady
72 }
73 #[doc = "Ready"]
74 #[inline(always)]
75 pub fn is_ready(&self) -> bool {
76 *self == Rdf::Ready
77 }
78}
79#[doc = "Address Valid Flag\n\nValue on reset: 0"]
80#[cfg_attr(feature = "defmt", derive(defmt::Format))]
81#[derive(Clone, Copy, Debug, PartialEq, Eq)]
82pub enum Avf {
83 #[doc = "0: Not valid"]
84 NotValid = 0,
85 #[doc = "1: Valid"]
86 Valid = 1,
87}
88impl From<Avf> for bool {
89 #[inline(always)]
90 fn from(variant: Avf) -> Self {
91 variant as u8 != 0
92 }
93}
94#[doc = "Field `AVF` reader - Address Valid Flag"]
95pub type AvfR = crate::BitReader<Avf>;
96impl AvfR {
97 #[doc = "Get enumerated values variant"]
98 #[inline(always)]
99 pub const fn variant(&self) -> Avf {
100 match self.bits {
101 false => Avf::NotValid,
102 true => Avf::Valid,
103 }
104 }
105 #[doc = "Not valid"]
106 #[inline(always)]
107 pub fn is_not_valid(&self) -> bool {
108 *self == Avf::NotValid
109 }
110 #[doc = "Valid"]
111 #[inline(always)]
112 pub fn is_valid(&self) -> bool {
113 *self == Avf::Valid
114 }
115}
116#[doc = "Transmit ACK Flag\n\nValue on reset: 0"]
117#[cfg_attr(feature = "defmt", derive(defmt::Format))]
118#[derive(Clone, Copy, Debug, PartialEq, Eq)]
119pub enum Taf {
120 #[doc = "0: Not required"]
121 NotRequired = 0,
122 #[doc = "1: Required"]
123 Required = 1,
124}
125impl From<Taf> for bool {
126 #[inline(always)]
127 fn from(variant: Taf) -> Self {
128 variant as u8 != 0
129 }
130}
131#[doc = "Field `TAF` reader - Transmit ACK Flag"]
132pub type TafR = crate::BitReader<Taf>;
133impl TafR {
134 #[doc = "Get enumerated values variant"]
135 #[inline(always)]
136 pub const fn variant(&self) -> Taf {
137 match self.bits {
138 false => Taf::NotRequired,
139 true => Taf::Required,
140 }
141 }
142 #[doc = "Not required"]
143 #[inline(always)]
144 pub fn is_not_required(&self) -> bool {
145 *self == Taf::NotRequired
146 }
147 #[doc = "Required"]
148 #[inline(always)]
149 pub fn is_required(&self) -> bool {
150 *self == Taf::Required
151 }
152}
153#[doc = "Repeated Start Flag\n\nValue on reset: 0"]
154#[cfg_attr(feature = "defmt", derive(defmt::Format))]
155#[derive(Clone, Copy, Debug, PartialEq, Eq)]
156pub enum Rsf {
157 #[doc = "0: No repeated Start detected"]
158 IntNo = 0,
159 #[doc = "1: Repeated Start detected"]
160 IntYes = 1,
161}
162impl From<Rsf> for bool {
163 #[inline(always)]
164 fn from(variant: Rsf) -> Self {
165 variant as u8 != 0
166 }
167}
168#[doc = "Field `RSF` reader - Repeated Start Flag"]
169pub type RsfR = crate::BitReader<Rsf>;
170impl RsfR {
171 #[doc = "Get enumerated values variant"]
172 #[inline(always)]
173 pub const fn variant(&self) -> Rsf {
174 match self.bits {
175 false => Rsf::IntNo,
176 true => Rsf::IntYes,
177 }
178 }
179 #[doc = "No repeated Start detected"]
180 #[inline(always)]
181 pub fn is_int_no(&self) -> bool {
182 *self == Rsf::IntNo
183 }
184 #[doc = "Repeated Start detected"]
185 #[inline(always)]
186 pub fn is_int_yes(&self) -> bool {
187 *self == Rsf::IntYes
188 }
189}
190#[doc = "Field `RSF` writer - Repeated Start Flag"]
191pub type RsfW<'a, REG> = crate::BitWriter1C<'a, REG, Rsf>;
192impl<'a, REG> RsfW<'a, REG>
193where
194 REG: crate::Writable + crate::RegisterSpec,
195{
196 #[doc = "No repeated Start detected"]
197 #[inline(always)]
198 pub fn int_no(self) -> &'a mut crate::W<REG> {
199 self.variant(Rsf::IntNo)
200 }
201 #[doc = "Repeated Start detected"]
202 #[inline(always)]
203 pub fn int_yes(self) -> &'a mut crate::W<REG> {
204 self.variant(Rsf::IntYes)
205 }
206}
207#[doc = "Stop Detect Flag\n\nValue on reset: 0"]
208#[cfg_attr(feature = "defmt", derive(defmt::Format))]
209#[derive(Clone, Copy, Debug, PartialEq, Eq)]
210pub enum Sdf {
211 #[doc = "0: No Stop detected"]
212 IntNo = 0,
213 #[doc = "1: Stop detected"]
214 IntYes = 1,
215}
216impl From<Sdf> for bool {
217 #[inline(always)]
218 fn from(variant: Sdf) -> Self {
219 variant as u8 != 0
220 }
221}
222#[doc = "Field `SDF` reader - Stop Detect Flag"]
223pub type SdfR = crate::BitReader<Sdf>;
224impl SdfR {
225 #[doc = "Get enumerated values variant"]
226 #[inline(always)]
227 pub const fn variant(&self) -> Sdf {
228 match self.bits {
229 false => Sdf::IntNo,
230 true => Sdf::IntYes,
231 }
232 }
233 #[doc = "No Stop detected"]
234 #[inline(always)]
235 pub fn is_int_no(&self) -> bool {
236 *self == Sdf::IntNo
237 }
238 #[doc = "Stop detected"]
239 #[inline(always)]
240 pub fn is_int_yes(&self) -> bool {
241 *self == Sdf::IntYes
242 }
243}
244#[doc = "Field `SDF` writer - Stop Detect Flag"]
245pub type SdfW<'a, REG> = crate::BitWriter1C<'a, REG, Sdf>;
246impl<'a, REG> SdfW<'a, REG>
247where
248 REG: crate::Writable + crate::RegisterSpec,
249{
250 #[doc = "No Stop detected"]
251 #[inline(always)]
252 pub fn int_no(self) -> &'a mut crate::W<REG> {
253 self.variant(Sdf::IntNo)
254 }
255 #[doc = "Stop detected"]
256 #[inline(always)]
257 pub fn int_yes(self) -> &'a mut crate::W<REG> {
258 self.variant(Sdf::IntYes)
259 }
260}
261#[doc = "Bit Error Flag\n\nValue on reset: 0"]
262#[cfg_attr(feature = "defmt", derive(defmt::Format))]
263#[derive(Clone, Copy, Debug, PartialEq, Eq)]
264pub enum Bef {
265 #[doc = "0: No bit error occurred"]
266 IntNo = 0,
267 #[doc = "1: Bit error occurred"]
268 IntYes = 1,
269}
270impl From<Bef> for bool {
271 #[inline(always)]
272 fn from(variant: Bef) -> Self {
273 variant as u8 != 0
274 }
275}
276#[doc = "Field `BEF` reader - Bit Error Flag"]
277pub type BefR = crate::BitReader<Bef>;
278impl BefR {
279 #[doc = "Get enumerated values variant"]
280 #[inline(always)]
281 pub const fn variant(&self) -> Bef {
282 match self.bits {
283 false => Bef::IntNo,
284 true => Bef::IntYes,
285 }
286 }
287 #[doc = "No bit error occurred"]
288 #[inline(always)]
289 pub fn is_int_no(&self) -> bool {
290 *self == Bef::IntNo
291 }
292 #[doc = "Bit error occurred"]
293 #[inline(always)]
294 pub fn is_int_yes(&self) -> bool {
295 *self == Bef::IntYes
296 }
297}
298#[doc = "Field `BEF` writer - Bit Error Flag"]
299pub type BefW<'a, REG> = crate::BitWriter1C<'a, REG, Bef>;
300impl<'a, REG> BefW<'a, REG>
301where
302 REG: crate::Writable + crate::RegisterSpec,
303{
304 #[doc = "No bit error occurred"]
305 #[inline(always)]
306 pub fn int_no(self) -> &'a mut crate::W<REG> {
307 self.variant(Bef::IntNo)
308 }
309 #[doc = "Bit error occurred"]
310 #[inline(always)]
311 pub fn int_yes(self) -> &'a mut crate::W<REG> {
312 self.variant(Bef::IntYes)
313 }
314}
315#[doc = "FIFO Error Flag\n\nValue on reset: 0"]
316#[cfg_attr(feature = "defmt", derive(defmt::Format))]
317#[derive(Clone, Copy, Debug, PartialEq, Eq)]
318pub enum Fef {
319 #[doc = "0: No FIFO error"]
320 IntNo = 0,
321 #[doc = "1: FIFO error"]
322 IntYes = 1,
323}
324impl From<Fef> for bool {
325 #[inline(always)]
326 fn from(variant: Fef) -> Self {
327 variant as u8 != 0
328 }
329}
330#[doc = "Field `FEF` reader - FIFO Error Flag"]
331pub type FefR = crate::BitReader<Fef>;
332impl FefR {
333 #[doc = "Get enumerated values variant"]
334 #[inline(always)]
335 pub const fn variant(&self) -> Fef {
336 match self.bits {
337 false => Fef::IntNo,
338 true => Fef::IntYes,
339 }
340 }
341 #[doc = "No FIFO error"]
342 #[inline(always)]
343 pub fn is_int_no(&self) -> bool {
344 *self == Fef::IntNo
345 }
346 #[doc = "FIFO error"]
347 #[inline(always)]
348 pub fn is_int_yes(&self) -> bool {
349 *self == Fef::IntYes
350 }
351}
352#[doc = "Field `FEF` writer - FIFO Error Flag"]
353pub type FefW<'a, REG> = crate::BitWriter1C<'a, REG, Fef>;
354impl<'a, REG> FefW<'a, REG>
355where
356 REG: crate::Writable + crate::RegisterSpec,
357{
358 #[doc = "No FIFO error"]
359 #[inline(always)]
360 pub fn int_no(self) -> &'a mut crate::W<REG> {
361 self.variant(Fef::IntNo)
362 }
363 #[doc = "FIFO error"]
364 #[inline(always)]
365 pub fn int_yes(self) -> &'a mut crate::W<REG> {
366 self.variant(Fef::IntYes)
367 }
368}
369#[doc = "Address Match 0 Flag\n\nValue on reset: 0"]
370#[cfg_attr(feature = "defmt", derive(defmt::Format))]
371#[derive(Clone, Copy, Debug, PartialEq, Eq)]
372pub enum Am0f {
373 #[doc = "0: ADDR0 matching address not received"]
374 NoFlag = 0,
375 #[doc = "1: ADDR0 matching address received"]
376 Flag = 1,
377}
378impl From<Am0f> for bool {
379 #[inline(always)]
380 fn from(variant: Am0f) -> Self {
381 variant as u8 != 0
382 }
383}
384#[doc = "Field `AM0F` reader - Address Match 0 Flag"]
385pub type Am0fR = crate::BitReader<Am0f>;
386impl Am0fR {
387 #[doc = "Get enumerated values variant"]
388 #[inline(always)]
389 pub const fn variant(&self) -> Am0f {
390 match self.bits {
391 false => Am0f::NoFlag,
392 true => Am0f::Flag,
393 }
394 }
395 #[doc = "ADDR0 matching address not received"]
396 #[inline(always)]
397 pub fn is_no_flag(&self) -> bool {
398 *self == Am0f::NoFlag
399 }
400 #[doc = "ADDR0 matching address received"]
401 #[inline(always)]
402 pub fn is_flag(&self) -> bool {
403 *self == Am0f::Flag
404 }
405}
406#[doc = "Address Match 1 Flag\n\nValue on reset: 0"]
407#[cfg_attr(feature = "defmt", derive(defmt::Format))]
408#[derive(Clone, Copy, Debug, PartialEq, Eq)]
409pub enum Am1f {
410 #[doc = "0: Matching address not received"]
411 NoFlag = 0,
412 #[doc = "1: Matching address received"]
413 Flag = 1,
414}
415impl From<Am1f> for bool {
416 #[inline(always)]
417 fn from(variant: Am1f) -> Self {
418 variant as u8 != 0
419 }
420}
421#[doc = "Field `AM1F` reader - Address Match 1 Flag"]
422pub type Am1fR = crate::BitReader<Am1f>;
423impl Am1fR {
424 #[doc = "Get enumerated values variant"]
425 #[inline(always)]
426 pub const fn variant(&self) -> Am1f {
427 match self.bits {
428 false => Am1f::NoFlag,
429 true => Am1f::Flag,
430 }
431 }
432 #[doc = "Matching address not received"]
433 #[inline(always)]
434 pub fn is_no_flag(&self) -> bool {
435 *self == Am1f::NoFlag
436 }
437 #[doc = "Matching address received"]
438 #[inline(always)]
439 pub fn is_flag(&self) -> bool {
440 *self == Am1f::Flag
441 }
442}
443#[doc = "General Call Flag\n\nValue on reset: 0"]
444#[cfg_attr(feature = "defmt", derive(defmt::Format))]
445#[derive(Clone, Copy, Debug, PartialEq, Eq)]
446pub enum Gcf {
447 #[doc = "0: General call address disabled or not detected"]
448 NoFlag = 0,
449 #[doc = "1: General call address detected"]
450 Flag = 1,
451}
452impl From<Gcf> for bool {
453 #[inline(always)]
454 fn from(variant: Gcf) -> Self {
455 variant as u8 != 0
456 }
457}
458#[doc = "Field `GCF` reader - General Call Flag"]
459pub type GcfR = crate::BitReader<Gcf>;
460impl GcfR {
461 #[doc = "Get enumerated values variant"]
462 #[inline(always)]
463 pub const fn variant(&self) -> Gcf {
464 match self.bits {
465 false => Gcf::NoFlag,
466 true => Gcf::Flag,
467 }
468 }
469 #[doc = "General call address disabled or not detected"]
470 #[inline(always)]
471 pub fn is_no_flag(&self) -> bool {
472 *self == Gcf::NoFlag
473 }
474 #[doc = "General call address detected"]
475 #[inline(always)]
476 pub fn is_flag(&self) -> bool {
477 *self == Gcf::Flag
478 }
479}
480#[doc = "SMBus Alert Response Flag\n\nValue on reset: 0"]
481#[cfg_attr(feature = "defmt", derive(defmt::Format))]
482#[derive(Clone, Copy, Debug, PartialEq, Eq)]
483pub enum Sarf {
484 #[doc = "0: Disabled or not detected"]
485 NoFlag = 0,
486 #[doc = "1: Enabled and detected"]
487 Flag = 1,
488}
489impl From<Sarf> for bool {
490 #[inline(always)]
491 fn from(variant: Sarf) -> Self {
492 variant as u8 != 0
493 }
494}
495#[doc = "Field `SARF` reader - SMBus Alert Response Flag"]
496pub type SarfR = crate::BitReader<Sarf>;
497impl SarfR {
498 #[doc = "Get enumerated values variant"]
499 #[inline(always)]
500 pub const fn variant(&self) -> Sarf {
501 match self.bits {
502 false => Sarf::NoFlag,
503 true => Sarf::Flag,
504 }
505 }
506 #[doc = "Disabled or not detected"]
507 #[inline(always)]
508 pub fn is_no_flag(&self) -> bool {
509 *self == Sarf::NoFlag
510 }
511 #[doc = "Enabled and detected"]
512 #[inline(always)]
513 pub fn is_flag(&self) -> bool {
514 *self == Sarf::Flag
515 }
516}
517#[doc = "Target Busy Flag\n\nValue on reset: 0"]
518#[cfg_attr(feature = "defmt", derive(defmt::Format))]
519#[derive(Clone, Copy, Debug, PartialEq, Eq)]
520pub enum Sbf {
521 #[doc = "0: Idle"]
522 Idle = 0,
523 #[doc = "1: Busy"]
524 Busy = 1,
525}
526impl From<Sbf> for bool {
527 #[inline(always)]
528 fn from(variant: Sbf) -> Self {
529 variant as u8 != 0
530 }
531}
532#[doc = "Field `SBF` reader - Target Busy Flag"]
533pub type SbfR = crate::BitReader<Sbf>;
534impl SbfR {
535 #[doc = "Get enumerated values variant"]
536 #[inline(always)]
537 pub const fn variant(&self) -> Sbf {
538 match self.bits {
539 false => Sbf::Idle,
540 true => Sbf::Busy,
541 }
542 }
543 #[doc = "Idle"]
544 #[inline(always)]
545 pub fn is_idle(&self) -> bool {
546 *self == Sbf::Idle
547 }
548 #[doc = "Busy"]
549 #[inline(always)]
550 pub fn is_busy(&self) -> bool {
551 *self == Sbf::Busy
552 }
553}
554#[doc = "Bus Busy Flag\n\nValue on reset: 0"]
555#[cfg_attr(feature = "defmt", derive(defmt::Format))]
556#[derive(Clone, Copy, Debug, PartialEq, Eq)]
557pub enum Bbf {
558 #[doc = "0: Idle"]
559 Idle = 0,
560 #[doc = "1: Busy"]
561 Busy = 1,
562}
563impl From<Bbf> for bool {
564 #[inline(always)]
565 fn from(variant: Bbf) -> Self {
566 variant as u8 != 0
567 }
568}
569#[doc = "Field `BBF` reader - Bus Busy Flag"]
570pub type BbfR = crate::BitReader<Bbf>;
571impl BbfR {
572 #[doc = "Get enumerated values variant"]
573 #[inline(always)]
574 pub const fn variant(&self) -> Bbf {
575 match self.bits {
576 false => Bbf::Idle,
577 true => Bbf::Busy,
578 }
579 }
580 #[doc = "Idle"]
581 #[inline(always)]
582 pub fn is_idle(&self) -> bool {
583 *self == Bbf::Idle
584 }
585 #[doc = "Busy"]
586 #[inline(always)]
587 pub fn is_busy(&self) -> bool {
588 *self == Bbf::Busy
589 }
590}
591impl R {
592 #[doc = "Bit 0 - Transmit Data Flag"]
593 #[inline(always)]
594 pub fn tdf(&self) -> TdfR {
595 TdfR::new((self.bits & 1) != 0)
596 }
597 #[doc = "Bit 1 - Receive Data Flag"]
598 #[inline(always)]
599 pub fn rdf(&self) -> RdfR {
600 RdfR::new(((self.bits >> 1) & 1) != 0)
601 }
602 #[doc = "Bit 2 - Address Valid Flag"]
603 #[inline(always)]
604 pub fn avf(&self) -> AvfR {
605 AvfR::new(((self.bits >> 2) & 1) != 0)
606 }
607 #[doc = "Bit 3 - Transmit ACK Flag"]
608 #[inline(always)]
609 pub fn taf(&self) -> TafR {
610 TafR::new(((self.bits >> 3) & 1) != 0)
611 }
612 #[doc = "Bit 8 - Repeated Start Flag"]
613 #[inline(always)]
614 pub fn rsf(&self) -> RsfR {
615 RsfR::new(((self.bits >> 8) & 1) != 0)
616 }
617 #[doc = "Bit 9 - Stop Detect Flag"]
618 #[inline(always)]
619 pub fn sdf(&self) -> SdfR {
620 SdfR::new(((self.bits >> 9) & 1) != 0)
621 }
622 #[doc = "Bit 10 - Bit Error Flag"]
623 #[inline(always)]
624 pub fn bef(&self) -> BefR {
625 BefR::new(((self.bits >> 10) & 1) != 0)
626 }
627 #[doc = "Bit 11 - FIFO Error Flag"]
628 #[inline(always)]
629 pub fn fef(&self) -> FefR {
630 FefR::new(((self.bits >> 11) & 1) != 0)
631 }
632 #[doc = "Bit 12 - Address Match 0 Flag"]
633 #[inline(always)]
634 pub fn am0f(&self) -> Am0fR {
635 Am0fR::new(((self.bits >> 12) & 1) != 0)
636 }
637 #[doc = "Bit 13 - Address Match 1 Flag"]
638 #[inline(always)]
639 pub fn am1f(&self) -> Am1fR {
640 Am1fR::new(((self.bits >> 13) & 1) != 0)
641 }
642 #[doc = "Bit 14 - General Call Flag"]
643 #[inline(always)]
644 pub fn gcf(&self) -> GcfR {
645 GcfR::new(((self.bits >> 14) & 1) != 0)
646 }
647 #[doc = "Bit 15 - SMBus Alert Response Flag"]
648 #[inline(always)]
649 pub fn sarf(&self) -> SarfR {
650 SarfR::new(((self.bits >> 15) & 1) != 0)
651 }
652 #[doc = "Bit 24 - Target Busy Flag"]
653 #[inline(always)]
654 pub fn sbf(&self) -> SbfR {
655 SbfR::new(((self.bits >> 24) & 1) != 0)
656 }
657 #[doc = "Bit 25 - Bus Busy Flag"]
658 #[inline(always)]
659 pub fn bbf(&self) -> BbfR {
660 BbfR::new(((self.bits >> 25) & 1) != 0)
661 }
662}
663#[cfg(feature = "debug")]
664impl core::fmt::Debug for R {
665 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
666 f.debug_struct("SSR")
667 .field("tdf", &self.tdf())
668 .field("rdf", &self.rdf())
669 .field("avf", &self.avf())
670 .field("taf", &self.taf())
671 .field("rsf", &self.rsf())
672 .field("sdf", &self.sdf())
673 .field("bef", &self.bef())
674 .field("fef", &self.fef())
675 .field("am0f", &self.am0f())
676 .field("am1f", &self.am1f())
677 .field("gcf", &self.gcf())
678 .field("sarf", &self.sarf())
679 .field("sbf", &self.sbf())
680 .field("bbf", &self.bbf())
681 .finish()
682 }
683}
684impl W {
685 #[doc = "Bit 8 - Repeated Start Flag"]
686 #[inline(always)]
687 pub fn rsf(&mut self) -> RsfW<'_, SsrSpec> {
688 RsfW::new(self, 8)
689 }
690 #[doc = "Bit 9 - Stop Detect Flag"]
691 #[inline(always)]
692 pub fn sdf(&mut self) -> SdfW<'_, SsrSpec> {
693 SdfW::new(self, 9)
694 }
695 #[doc = "Bit 10 - Bit Error Flag"]
696 #[inline(always)]
697 pub fn bef(&mut self) -> BefW<'_, SsrSpec> {
698 BefW::new(self, 10)
699 }
700 #[doc = "Bit 11 - FIFO Error Flag"]
701 #[inline(always)]
702 pub fn fef(&mut self) -> FefW<'_, SsrSpec> {
703 FefW::new(self, 11)
704 }
705}
706#[doc = "Target Status\n\nYou can [`read`](crate::Reg::read) this register and get [`ssr::R`](R). You can [`reset`](crate::Reg::reset), [`write`](crate::Reg::write), [`write_with_zero`](crate::Reg::write_with_zero) this register using [`ssr::W`](W). You can also [`modify`](crate::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
707pub struct SsrSpec;
708impl crate::RegisterSpec for SsrSpec {
709 type Ux = u32;
710}
711#[doc = "`read()` method returns [`ssr::R`](R) reader structure"]
712impl crate::Readable for SsrSpec {}
713#[doc = "`write(|w| ..)` method takes [`ssr::W`](W) writer structure"]
714impl crate::Writable for SsrSpec {
715 type Safety = crate::Unsafe;
716 const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0x0f00;
717}
718#[doc = "`reset()` method sets SSR to value 0"]
719impl crate::Resettable for SsrSpec {}