mcxa_pac/i3c0/
sstatus.rs

1#[doc = "Register `SSTATUS` reader"]
2pub type R = crate::R<SstatusSpec>;
3#[doc = "Register `SSTATUS` writer"]
4pub type W = crate::W<SstatusSpec>;
5#[doc = "Status not Stop\n\nValue on reset: 0"]
6#[cfg_attr(feature = "defmt", derive(defmt::Format))]
7#[derive(Clone, Copy, Debug, PartialEq, Eq)]
8pub enum Stnotstop {
9    #[doc = "0: In STOP condition"]
10    Stopped = 0,
11    #[doc = "1: Busy"]
12    Busy = 1,
13}
14impl From<Stnotstop> for bool {
15    #[inline(always)]
16    fn from(variant: Stnotstop) -> Self {
17        variant as u8 != 0
18    }
19}
20#[doc = "Field `STNOTSTOP` reader - Status not Stop"]
21pub type StnotstopR = crate::BitReader<Stnotstop>;
22impl StnotstopR {
23    #[doc = "Get enumerated values variant"]
24    #[inline(always)]
25    pub const fn variant(&self) -> Stnotstop {
26        match self.bits {
27            false => Stnotstop::Stopped,
28            true => Stnotstop::Busy,
29        }
30    }
31    #[doc = "In STOP condition"]
32    #[inline(always)]
33    pub fn is_stopped(&self) -> bool {
34        *self == Stnotstop::Stopped
35    }
36    #[doc = "Busy"]
37    #[inline(always)]
38    pub fn is_busy(&self) -> bool {
39        *self == Stnotstop::Busy
40    }
41}
42#[doc = "Status Message\n\nValue on reset: 0"]
43#[cfg_attr(feature = "defmt", derive(defmt::Format))]
44#[derive(Clone, Copy, Debug, PartialEq, Eq)]
45pub enum Stmsg {
46    #[doc = "0: Idle"]
47    Idle = 0,
48    #[doc = "1: Busy"]
49    Busy = 1,
50}
51impl From<Stmsg> for bool {
52    #[inline(always)]
53    fn from(variant: Stmsg) -> Self {
54        variant as u8 != 0
55    }
56}
57#[doc = "Field `STMSG` reader - Status Message"]
58pub type StmsgR = crate::BitReader<Stmsg>;
59impl StmsgR {
60    #[doc = "Get enumerated values variant"]
61    #[inline(always)]
62    pub const fn variant(&self) -> Stmsg {
63        match self.bits {
64            false => Stmsg::Idle,
65            true => Stmsg::Busy,
66        }
67    }
68    #[doc = "Idle"]
69    #[inline(always)]
70    pub fn is_idle(&self) -> bool {
71        *self == Stmsg::Idle
72    }
73    #[doc = "Busy"]
74    #[inline(always)]
75    pub fn is_busy(&self) -> bool {
76        *self == Stmsg::Busy
77    }
78}
79#[doc = "Status Common Command Code Handler\n\nValue on reset: 0"]
80#[cfg_attr(feature = "defmt", derive(defmt::Format))]
81#[derive(Clone, Copy, Debug, PartialEq, Eq)]
82pub enum Stccch {
83    #[doc = "0: No CCC message handled"]
84    Idle = 0,
85    #[doc = "1: Handled automatically"]
86    Busy = 1,
87}
88impl From<Stccch> for bool {
89    #[inline(always)]
90    fn from(variant: Stccch) -> Self {
91        variant as u8 != 0
92    }
93}
94#[doc = "Field `STCCCH` reader - Status Common Command Code Handler"]
95pub type StccchR = crate::BitReader<Stccch>;
96impl StccchR {
97    #[doc = "Get enumerated values variant"]
98    #[inline(always)]
99    pub const fn variant(&self) -> Stccch {
100        match self.bits {
101            false => Stccch::Idle,
102            true => Stccch::Busy,
103        }
104    }
105    #[doc = "No CCC message handled"]
106    #[inline(always)]
107    pub fn is_idle(&self) -> bool {
108        *self == Stccch::Idle
109    }
110    #[doc = "Handled automatically"]
111    #[inline(always)]
112    pub fn is_busy(&self) -> bool {
113        *self == Stccch::Busy
114    }
115}
116#[doc = "Status Request Read\n\nValue on reset: 0"]
117#[cfg_attr(feature = "defmt", derive(defmt::Format))]
118#[derive(Clone, Copy, Debug, PartialEq, Eq)]
119pub enum Streqrd {
120    #[doc = "0: Not an SDR read"]
121    Idle = 0,
122    #[doc = "1: SDR read from this target or an IBI is being pushed out"]
123    Busy = 1,
124}
125impl From<Streqrd> for bool {
126    #[inline(always)]
127    fn from(variant: Streqrd) -> Self {
128        variant as u8 != 0
129    }
130}
131#[doc = "Field `STREQRD` reader - Status Request Read"]
132pub type StreqrdR = crate::BitReader<Streqrd>;
133impl StreqrdR {
134    #[doc = "Get enumerated values variant"]
135    #[inline(always)]
136    pub const fn variant(&self) -> Streqrd {
137        match self.bits {
138            false => Streqrd::Idle,
139            true => Streqrd::Busy,
140        }
141    }
142    #[doc = "Not an SDR read"]
143    #[inline(always)]
144    pub fn is_idle(&self) -> bool {
145        *self == Streqrd::Idle
146    }
147    #[doc = "SDR read from this target or an IBI is being pushed out"]
148    #[inline(always)]
149    pub fn is_busy(&self) -> bool {
150        *self == Streqrd::Busy
151    }
152}
153#[doc = "Status Request Write\n\nValue on reset: 0"]
154#[cfg_attr(feature = "defmt", derive(defmt::Format))]
155#[derive(Clone, Copy, Debug, PartialEq, Eq)]
156pub enum Streqwr {
157    #[doc = "0: Not an SDR write"]
158    Idle = 0,
159    #[doc = "1: SDR write data from the controller, but not in ENTDAA mode"]
160    Busy = 1,
161}
162impl From<Streqwr> for bool {
163    #[inline(always)]
164    fn from(variant: Streqwr) -> Self {
165        variant as u8 != 0
166    }
167}
168#[doc = "Field `STREQWR` reader - Status Request Write"]
169pub type StreqwrR = crate::BitReader<Streqwr>;
170impl StreqwrR {
171    #[doc = "Get enumerated values variant"]
172    #[inline(always)]
173    pub const fn variant(&self) -> Streqwr {
174        match self.bits {
175            false => Streqwr::Idle,
176            true => Streqwr::Busy,
177        }
178    }
179    #[doc = "Not an SDR write"]
180    #[inline(always)]
181    pub fn is_idle(&self) -> bool {
182        *self == Streqwr::Idle
183    }
184    #[doc = "SDR write data from the controller, but not in ENTDAA mode"]
185    #[inline(always)]
186    pub fn is_busy(&self) -> bool {
187        *self == Streqwr::Busy
188    }
189}
190#[doc = "Status Dynamic Address Assignment\n\nValue on reset: 0"]
191#[cfg_attr(feature = "defmt", derive(defmt::Format))]
192#[derive(Clone, Copy, Debug, PartialEq, Eq)]
193pub enum Stdaa {
194    #[doc = "0: Not in ENTDAA mode"]
195    NotInEntdaa = 0,
196    #[doc = "1: In ENTDAA mode"]
197    InEntdaa = 1,
198}
199impl From<Stdaa> for bool {
200    #[inline(always)]
201    fn from(variant: Stdaa) -> Self {
202        variant as u8 != 0
203    }
204}
205#[doc = "Field `STDAA` reader - Status Dynamic Address Assignment"]
206pub type StdaaR = crate::BitReader<Stdaa>;
207impl StdaaR {
208    #[doc = "Get enumerated values variant"]
209    #[inline(always)]
210    pub const fn variant(&self) -> Stdaa {
211        match self.bits {
212            false => Stdaa::NotInEntdaa,
213            true => Stdaa::InEntdaa,
214        }
215    }
216    #[doc = "Not in ENTDAA mode"]
217    #[inline(always)]
218    pub fn is_not_in_entdaa(&self) -> bool {
219        *self == Stdaa::NotInEntdaa
220    }
221    #[doc = "In ENTDAA mode"]
222    #[inline(always)]
223    pub fn is_in_entdaa(&self) -> bool {
224        *self == Stdaa::InEntdaa
225    }
226}
227#[doc = "Status High Data Rate\n\nValue on reset: 0"]
228#[cfg_attr(feature = "defmt", derive(defmt::Format))]
229#[derive(Clone, Copy, Debug, PartialEq, Eq)]
230pub enum Sthdr {
231    #[doc = "0: I3C bus not in HDR-DDR mode"]
232    NotInHdrDdr = 0,
233    #[doc = "1: I3C bus in HDR-DDR mode"]
234    InHdrDdr = 1,
235}
236impl From<Sthdr> for bool {
237    #[inline(always)]
238    fn from(variant: Sthdr) -> Self {
239        variant as u8 != 0
240    }
241}
242#[doc = "Field `STHDR` reader - Status High Data Rate"]
243pub type SthdrR = crate::BitReader<Sthdr>;
244impl SthdrR {
245    #[doc = "Get enumerated values variant"]
246    #[inline(always)]
247    pub const fn variant(&self) -> Sthdr {
248        match self.bits {
249            false => Sthdr::NotInHdrDdr,
250            true => Sthdr::InHdrDdr,
251        }
252    }
253    #[doc = "I3C bus not in HDR-DDR mode"]
254    #[inline(always)]
255    pub fn is_not_in_hdr_ddr(&self) -> bool {
256        *self == Sthdr::NotInHdrDdr
257    }
258    #[doc = "I3C bus in HDR-DDR mode"]
259    #[inline(always)]
260    pub fn is_in_hdr_ddr(&self) -> bool {
261        *self == Sthdr::InHdrDdr
262    }
263}
264#[doc = "Start Flag\n\nValue on reset: 0"]
265#[cfg_attr(feature = "defmt", derive(defmt::Format))]
266#[derive(Clone, Copy, Debug, PartialEq, Eq)]
267pub enum Start {
268    #[doc = "0: Not detected"]
269    StartNotDetected = 0,
270    #[doc = "1: Detected"]
271    StartDetected = 1,
272}
273impl From<Start> for bool {
274    #[inline(always)]
275    fn from(variant: Start) -> Self {
276        variant as u8 != 0
277    }
278}
279#[doc = "Field `START` reader - Start Flag"]
280pub type StartR = crate::BitReader<Start>;
281impl StartR {
282    #[doc = "Get enumerated values variant"]
283    #[inline(always)]
284    pub const fn variant(&self) -> Start {
285        match self.bits {
286            false => Start::StartNotDetected,
287            true => Start::StartDetected,
288        }
289    }
290    #[doc = "Not detected"]
291    #[inline(always)]
292    pub fn is_start_not_detected(&self) -> bool {
293        *self == Start::StartNotDetected
294    }
295    #[doc = "Detected"]
296    #[inline(always)]
297    pub fn is_start_detected(&self) -> bool {
298        *self == Start::StartDetected
299    }
300}
301#[doc = "Field `START` writer - Start Flag"]
302pub type StartW<'a, REG> = crate::BitWriter1C<'a, REG, Start>;
303impl<'a, REG> StartW<'a, REG>
304where
305    REG: crate::Writable + crate::RegisterSpec,
306{
307    #[doc = "Not detected"]
308    #[inline(always)]
309    pub fn start_not_detected(self) -> &'a mut crate::W<REG> {
310        self.variant(Start::StartNotDetected)
311    }
312    #[doc = "Detected"]
313    #[inline(always)]
314    pub fn start_detected(self) -> &'a mut crate::W<REG> {
315        self.variant(Start::StartDetected)
316    }
317}
318#[doc = "Matched Flag\n\nValue on reset: 0"]
319#[cfg_attr(feature = "defmt", derive(defmt::Format))]
320#[derive(Clone, Copy, Debug, PartialEq, Eq)]
321pub enum Matched {
322    #[doc = "0: Header not matched"]
323    NotMatched = 0,
324    #[doc = "1: Header matched"]
325    Matched = 1,
326}
327impl From<Matched> for bool {
328    #[inline(always)]
329    fn from(variant: Matched) -> Self {
330        variant as u8 != 0
331    }
332}
333#[doc = "Field `MATCHED` reader - Matched Flag"]
334pub type MatchedR = crate::BitReader<Matched>;
335impl MatchedR {
336    #[doc = "Get enumerated values variant"]
337    #[inline(always)]
338    pub const fn variant(&self) -> Matched {
339        match self.bits {
340            false => Matched::NotMatched,
341            true => Matched::Matched,
342        }
343    }
344    #[doc = "Header not matched"]
345    #[inline(always)]
346    pub fn is_not_matched(&self) -> bool {
347        *self == Matched::NotMatched
348    }
349    #[doc = "Header matched"]
350    #[inline(always)]
351    pub fn is_matched(&self) -> bool {
352        *self == Matched::Matched
353    }
354}
355#[doc = "Field `MATCHED` writer - Matched Flag"]
356pub type MatchedW<'a, REG> = crate::BitWriter1C<'a, REG, Matched>;
357impl<'a, REG> MatchedW<'a, REG>
358where
359    REG: crate::Writable + crate::RegisterSpec,
360{
361    #[doc = "Header not matched"]
362    #[inline(always)]
363    pub fn not_matched(self) -> &'a mut crate::W<REG> {
364        self.variant(Matched::NotMatched)
365    }
366    #[doc = "Header matched"]
367    #[inline(always)]
368    pub fn matched(self) -> &'a mut crate::W<REG> {
369        self.variant(Matched::Matched)
370    }
371}
372#[doc = "Stop Flag\n\nValue on reset: 1"]
373#[cfg_attr(feature = "defmt", derive(defmt::Format))]
374#[derive(Clone, Copy, Debug, PartialEq, Eq)]
375pub enum Stop {
376    #[doc = "0: No Stopped state detected"]
377    NoStopDetected = 0,
378    #[doc = "1: Stopped state detected"]
379    StopDetected = 1,
380}
381impl From<Stop> for bool {
382    #[inline(always)]
383    fn from(variant: Stop) -> Self {
384        variant as u8 != 0
385    }
386}
387#[doc = "Field `STOP` reader - Stop Flag"]
388pub type StopR = crate::BitReader<Stop>;
389impl StopR {
390    #[doc = "Get enumerated values variant"]
391    #[inline(always)]
392    pub const fn variant(&self) -> Stop {
393        match self.bits {
394            false => Stop::NoStopDetected,
395            true => Stop::StopDetected,
396        }
397    }
398    #[doc = "No Stopped state detected"]
399    #[inline(always)]
400    pub fn is_no_stop_detected(&self) -> bool {
401        *self == Stop::NoStopDetected
402    }
403    #[doc = "Stopped state detected"]
404    #[inline(always)]
405    pub fn is_stop_detected(&self) -> bool {
406        *self == Stop::StopDetected
407    }
408}
409#[doc = "Field `STOP` writer - Stop Flag"]
410pub type StopW<'a, REG> = crate::BitWriter1C<'a, REG, Stop>;
411impl<'a, REG> StopW<'a, REG>
412where
413    REG: crate::Writable + crate::RegisterSpec,
414{
415    #[doc = "No Stopped state detected"]
416    #[inline(always)]
417    pub fn no_stop_detected(self) -> &'a mut crate::W<REG> {
418        self.variant(Stop::NoStopDetected)
419    }
420    #[doc = "Stopped state detected"]
421    #[inline(always)]
422    pub fn stop_detected(self) -> &'a mut crate::W<REG> {
423        self.variant(Stop::StopDetected)
424    }
425}
426#[doc = "Received Message Pending\n\nValue on reset: 0"]
427#[cfg_attr(feature = "defmt", derive(defmt::Format))]
428#[derive(Clone, Copy, Debug, PartialEq, Eq)]
429pub enum RxPend {
430    #[doc = "0: No received message pending"]
431    NoMsgPending = 0,
432    #[doc = "1: Received message pending"]
433    MsgPending = 1,
434}
435impl From<RxPend> for bool {
436    #[inline(always)]
437    fn from(variant: RxPend) -> Self {
438        variant as u8 != 0
439    }
440}
441#[doc = "Field `RX_PEND` reader - Received Message Pending"]
442pub type RxPendR = crate::BitReader<RxPend>;
443impl RxPendR {
444    #[doc = "Get enumerated values variant"]
445    #[inline(always)]
446    pub const fn variant(&self) -> RxPend {
447        match self.bits {
448            false => RxPend::NoMsgPending,
449            true => RxPend::MsgPending,
450        }
451    }
452    #[doc = "No received message pending"]
453    #[inline(always)]
454    pub fn is_no_msg_pending(&self) -> bool {
455        *self == RxPend::NoMsgPending
456    }
457    #[doc = "Received message pending"]
458    #[inline(always)]
459    pub fn is_msg_pending(&self) -> bool {
460        *self == RxPend::MsgPending
461    }
462}
463#[doc = "Transmit Buffer Not Full\n\nValue on reset: 1"]
464#[cfg_attr(feature = "defmt", derive(defmt::Format))]
465#[derive(Clone, Copy, Debug, PartialEq, Eq)]
466pub enum Txnotfull {
467    #[doc = "0: Transmit buffer full"]
468    Full = 0,
469    #[doc = "1: Transmit buffer not full"]
470    NotFull = 1,
471}
472impl From<Txnotfull> for bool {
473    #[inline(always)]
474    fn from(variant: Txnotfull) -> Self {
475        variant as u8 != 0
476    }
477}
478#[doc = "Field `TXNOTFULL` reader - Transmit Buffer Not Full"]
479pub type TxnotfullR = crate::BitReader<Txnotfull>;
480impl TxnotfullR {
481    #[doc = "Get enumerated values variant"]
482    #[inline(always)]
483    pub const fn variant(&self) -> Txnotfull {
484        match self.bits {
485            false => Txnotfull::Full,
486            true => Txnotfull::NotFull,
487        }
488    }
489    #[doc = "Transmit buffer full"]
490    #[inline(always)]
491    pub fn is_full(&self) -> bool {
492        *self == Txnotfull::Full
493    }
494    #[doc = "Transmit buffer not full"]
495    #[inline(always)]
496    pub fn is_not_full(&self) -> bool {
497        *self == Txnotfull::NotFull
498    }
499}
500#[doc = "Dynamic Address Change Flag\n\nValue on reset: 0"]
501#[cfg_attr(feature = "defmt", derive(defmt::Format))]
502#[derive(Clone, Copy, Debug, PartialEq, Eq)]
503pub enum Dachg {
504    #[doc = "0: No DA change detected"]
505    NoChangeDetected = 0,
506    #[doc = "1: DA change detected"]
507    ChangeDetected = 1,
508}
509impl From<Dachg> for bool {
510    #[inline(always)]
511    fn from(variant: Dachg) -> Self {
512        variant as u8 != 0
513    }
514}
515#[doc = "Field `DACHG` reader - Dynamic Address Change Flag"]
516pub type DachgR = crate::BitReader<Dachg>;
517impl DachgR {
518    #[doc = "Get enumerated values variant"]
519    #[inline(always)]
520    pub const fn variant(&self) -> Dachg {
521        match self.bits {
522            false => Dachg::NoChangeDetected,
523            true => Dachg::ChangeDetected,
524        }
525    }
526    #[doc = "No DA change detected"]
527    #[inline(always)]
528    pub fn is_no_change_detected(&self) -> bool {
529        *self == Dachg::NoChangeDetected
530    }
531    #[doc = "DA change detected"]
532    #[inline(always)]
533    pub fn is_change_detected(&self) -> bool {
534        *self == Dachg::ChangeDetected
535    }
536}
537#[doc = "Field `DACHG` writer - Dynamic Address Change Flag"]
538pub type DachgW<'a, REG> = crate::BitWriter1C<'a, REG, Dachg>;
539impl<'a, REG> DachgW<'a, REG>
540where
541    REG: crate::Writable + crate::RegisterSpec,
542{
543    #[doc = "No DA change detected"]
544    #[inline(always)]
545    pub fn no_change_detected(self) -> &'a mut crate::W<REG> {
546        self.variant(Dachg::NoChangeDetected)
547    }
548    #[doc = "DA change detected"]
549    #[inline(always)]
550    pub fn change_detected(self) -> &'a mut crate::W<REG> {
551        self.variant(Dachg::ChangeDetected)
552    }
553}
554#[doc = "Common Command Code Flag\n\nValue on reset: 0"]
555#[cfg_attr(feature = "defmt", derive(defmt::Format))]
556#[derive(Clone, Copy, Debug, PartialEq, Eq)]
557pub enum Ccc {
558    #[doc = "0: CCC not received"]
559    NoCccReceived = 0,
560    #[doc = "1: CCC received"]
561    CccReceived = 1,
562}
563impl From<Ccc> for bool {
564    #[inline(always)]
565    fn from(variant: Ccc) -> Self {
566        variant as u8 != 0
567    }
568}
569#[doc = "Field `CCC` reader - Common Command Code Flag"]
570pub type CccR = crate::BitReader<Ccc>;
571impl CccR {
572    #[doc = "Get enumerated values variant"]
573    #[inline(always)]
574    pub const fn variant(&self) -> Ccc {
575        match self.bits {
576            false => Ccc::NoCccReceived,
577            true => Ccc::CccReceived,
578        }
579    }
580    #[doc = "CCC not received"]
581    #[inline(always)]
582    pub fn is_no_ccc_received(&self) -> bool {
583        *self == Ccc::NoCccReceived
584    }
585    #[doc = "CCC received"]
586    #[inline(always)]
587    pub fn is_ccc_received(&self) -> bool {
588        *self == Ccc::CccReceived
589    }
590}
591#[doc = "Field `CCC` writer - Common Command Code Flag"]
592pub type CccW<'a, REG> = crate::BitWriter1C<'a, REG, Ccc>;
593impl<'a, REG> CccW<'a, REG>
594where
595    REG: crate::Writable + crate::RegisterSpec,
596{
597    #[doc = "CCC not received"]
598    #[inline(always)]
599    pub fn no_ccc_received(self) -> &'a mut crate::W<REG> {
600        self.variant(Ccc::NoCccReceived)
601    }
602    #[doc = "CCC received"]
603    #[inline(always)]
604    pub fn ccc_received(self) -> &'a mut crate::W<REG> {
605        self.variant(Ccc::CccReceived)
606    }
607}
608#[doc = "Field `ERRWARN` reader - Error Warning"]
609pub type ErrwarnR = crate::BitReader;
610#[doc = "High Data Rate Command Match Flag\n\nValue on reset: 0"]
611#[cfg_attr(feature = "defmt", derive(defmt::Format))]
612#[derive(Clone, Copy, Debug, PartialEq, Eq)]
613pub enum Hdrmatch {
614    #[doc = "0: Did not match"]
615    NoMatch = 0,
616    #[doc = "1: Matched the I3C dynamic address"]
617    Match = 1,
618}
619impl From<Hdrmatch> for bool {
620    #[inline(always)]
621    fn from(variant: Hdrmatch) -> Self {
622        variant as u8 != 0
623    }
624}
625#[doc = "Field `HDRMATCH` reader - High Data Rate Command Match Flag"]
626pub type HdrmatchR = crate::BitReader<Hdrmatch>;
627impl HdrmatchR {
628    #[doc = "Get enumerated values variant"]
629    #[inline(always)]
630    pub const fn variant(&self) -> Hdrmatch {
631        match self.bits {
632            false => Hdrmatch::NoMatch,
633            true => Hdrmatch::Match,
634        }
635    }
636    #[doc = "Did not match"]
637    #[inline(always)]
638    pub fn is_no_match(&self) -> bool {
639        *self == Hdrmatch::NoMatch
640    }
641    #[doc = "Matched the I3C dynamic address"]
642    #[inline(always)]
643    pub fn is_match(&self) -> bool {
644        *self == Hdrmatch::Match
645    }
646}
647#[doc = "Field `HDRMATCH` writer - High Data Rate Command Match Flag"]
648pub type HdrmatchW<'a, REG> = crate::BitWriter1C<'a, REG, Hdrmatch>;
649impl<'a, REG> HdrmatchW<'a, REG>
650where
651    REG: crate::Writable + crate::RegisterSpec,
652{
653    #[doc = "Did not match"]
654    #[inline(always)]
655    pub fn no_match(self) -> &'a mut crate::W<REG> {
656        self.variant(Hdrmatch::NoMatch)
657    }
658    #[doc = "Matched the I3C dynamic address"]
659    #[inline(always)]
660    pub fn match_(self) -> &'a mut crate::W<REG> {
661        self.variant(Hdrmatch::Match)
662    }
663}
664#[doc = "Common Command Code Handled Flag\n\nValue on reset: 0"]
665#[cfg_attr(feature = "defmt", derive(defmt::Format))]
666#[derive(Clone, Copy, Debug, PartialEq, Eq)]
667pub enum Chandled {
668    #[doc = "0: CCC handling not in progress"]
669    NotHandled = 0,
670    #[doc = "1: CCC handling in progress"]
671    Handled = 1,
672}
673impl From<Chandled> for bool {
674    #[inline(always)]
675    fn from(variant: Chandled) -> Self {
676        variant as u8 != 0
677    }
678}
679#[doc = "Field `CHANDLED` reader - Common Command Code Handled Flag"]
680pub type ChandledR = crate::BitReader<Chandled>;
681impl ChandledR {
682    #[doc = "Get enumerated values variant"]
683    #[inline(always)]
684    pub const fn variant(&self) -> Chandled {
685        match self.bits {
686            false => Chandled::NotHandled,
687            true => Chandled::Handled,
688        }
689    }
690    #[doc = "CCC handling not in progress"]
691    #[inline(always)]
692    pub fn is_not_handled(&self) -> bool {
693        *self == Chandled::NotHandled
694    }
695    #[doc = "CCC handling in progress"]
696    #[inline(always)]
697    pub fn is_handled(&self) -> bool {
698        *self == Chandled::Handled
699    }
700}
701#[doc = "Field `CHANDLED` writer - Common Command Code Handled Flag"]
702pub type ChandledW<'a, REG> = crate::BitWriter1C<'a, REG, Chandled>;
703impl<'a, REG> ChandledW<'a, REG>
704where
705    REG: crate::Writable + crate::RegisterSpec,
706{
707    #[doc = "CCC handling not in progress"]
708    #[inline(always)]
709    pub fn not_handled(self) -> &'a mut crate::W<REG> {
710        self.variant(Chandled::NotHandled)
711    }
712    #[doc = "CCC handling in progress"]
713    #[inline(always)]
714    pub fn handled(self) -> &'a mut crate::W<REG> {
715        self.variant(Chandled::Handled)
716    }
717}
718#[doc = "Event Flag\n\nValue on reset: 0"]
719#[cfg_attr(feature = "defmt", derive(defmt::Format))]
720#[derive(Clone, Copy, Debug, PartialEq, Eq)]
721pub enum Event {
722    #[doc = "0: No event occurred"]
723    NoEvent = 0,
724    #[doc = "1: IBI, CR, or HJ occurred"]
725    Event = 1,
726}
727impl From<Event> for bool {
728    #[inline(always)]
729    fn from(variant: Event) -> Self {
730        variant as u8 != 0
731    }
732}
733#[doc = "Field `EVENT` reader - Event Flag"]
734pub type EventR = crate::BitReader<Event>;
735impl EventR {
736    #[doc = "Get enumerated values variant"]
737    #[inline(always)]
738    pub const fn variant(&self) -> Event {
739        match self.bits {
740            false => Event::NoEvent,
741            true => Event::Event,
742        }
743    }
744    #[doc = "No event occurred"]
745    #[inline(always)]
746    pub fn is_no_event(&self) -> bool {
747        *self == Event::NoEvent
748    }
749    #[doc = "IBI, CR, or HJ occurred"]
750    #[inline(always)]
751    pub fn is_event(&self) -> bool {
752        *self == Event::Event
753    }
754}
755#[doc = "Field `EVENT` writer - Event Flag"]
756pub type EventW<'a, REG> = crate::BitWriter1C<'a, REG, Event>;
757impl<'a, REG> EventW<'a, REG>
758where
759    REG: crate::Writable + crate::RegisterSpec,
760{
761    #[doc = "No event occurred"]
762    #[inline(always)]
763    pub fn no_event(self) -> &'a mut crate::W<REG> {
764        self.variant(Event::NoEvent)
765    }
766    #[doc = "IBI, CR, or HJ occurred"]
767    #[inline(always)]
768    pub fn event(self) -> &'a mut crate::W<REG> {
769        self.variant(Event::Event)
770    }
771}
772#[doc = "Event Details\n\nValue on reset: 0"]
773#[cfg_attr(feature = "defmt", derive(defmt::Format))]
774#[derive(Clone, Copy, Debug, PartialEq, Eq)]
775#[repr(u8)]
776pub enum Evdet {
777    #[doc = "0: NONE (no event or no pending event)"]
778    None = 0,
779    #[doc = "1: NO_REQUEST (request is not sent yet; either there is no START condition yet, or is waiting for Bus-Available or Bus-Idle (HJ))"]
780    NoRequest = 1,
781    #[doc = "2: NACKed (not acknowledged, request sent and rejected); I3C tries again"]
782    Nacked = 2,
783    #[doc = "3: ACKed (acknowledged; request sent and accepted), so done (unless the time control data is still being sent)"]
784    Acked = 3,
785}
786impl From<Evdet> for u8 {
787    #[inline(always)]
788    fn from(variant: Evdet) -> Self {
789        variant as _
790    }
791}
792impl crate::FieldSpec for Evdet {
793    type Ux = u8;
794}
795impl crate::IsEnum for Evdet {}
796#[doc = "Field `EVDET` reader - Event Details"]
797pub type EvdetR = crate::FieldReader<Evdet>;
798impl EvdetR {
799    #[doc = "Get enumerated values variant"]
800    #[inline(always)]
801    pub const fn variant(&self) -> Evdet {
802        match self.bits {
803            0 => Evdet::None,
804            1 => Evdet::NoRequest,
805            2 => Evdet::Nacked,
806            3 => Evdet::Acked,
807            _ => unreachable!(),
808        }
809    }
810    #[doc = "NONE (no event or no pending event)"]
811    #[inline(always)]
812    pub fn is_none(&self) -> bool {
813        *self == Evdet::None
814    }
815    #[doc = "NO_REQUEST (request is not sent yet; either there is no START condition yet, or is waiting for Bus-Available or Bus-Idle (HJ))"]
816    #[inline(always)]
817    pub fn is_no_request(&self) -> bool {
818        *self == Evdet::NoRequest
819    }
820    #[doc = "NACKed (not acknowledged, request sent and rejected); I3C tries again"]
821    #[inline(always)]
822    pub fn is_nacked(&self) -> bool {
823        *self == Evdet::Nacked
824    }
825    #[doc = "ACKed (acknowledged; request sent and accepted), so done (unless the time control data is still being sent)"]
826    #[inline(always)]
827    pub fn is_acked(&self) -> bool {
828        *self == Evdet::Acked
829    }
830}
831#[doc = "In-Band Interrupts Disable\n\nValue on reset: 0"]
832#[cfg_attr(feature = "defmt", derive(defmt::Format))]
833#[derive(Clone, Copy, Debug, PartialEq, Eq)]
834pub enum Ibidis {
835    #[doc = "0: Enabled"]
836    InterruptsEnabled = 0,
837    #[doc = "1: Disabled"]
838    InterruptsDisabled = 1,
839}
840impl From<Ibidis> for bool {
841    #[inline(always)]
842    fn from(variant: Ibidis) -> Self {
843        variant as u8 != 0
844    }
845}
846#[doc = "Field `IBIDIS` reader - In-Band Interrupts Disable"]
847pub type IbidisR = crate::BitReader<Ibidis>;
848impl IbidisR {
849    #[doc = "Get enumerated values variant"]
850    #[inline(always)]
851    pub const fn variant(&self) -> Ibidis {
852        match self.bits {
853            false => Ibidis::InterruptsEnabled,
854            true => Ibidis::InterruptsDisabled,
855        }
856    }
857    #[doc = "Enabled"]
858    #[inline(always)]
859    pub fn is_interrupts_enabled(&self) -> bool {
860        *self == Ibidis::InterruptsEnabled
861    }
862    #[doc = "Disabled"]
863    #[inline(always)]
864    pub fn is_interrupts_disabled(&self) -> bool {
865        *self == Ibidis::InterruptsDisabled
866    }
867}
868#[doc = "Controller Requests Disable\n\nValue on reset: 0"]
869#[cfg_attr(feature = "defmt", derive(defmt::Format))]
870#[derive(Clone, Copy, Debug, PartialEq, Eq)]
871pub enum Mrdis {
872    #[doc = "0: Enabled"]
873    MrEnabled = 0,
874    #[doc = "1: Disabled"]
875    MrDisabled = 1,
876}
877impl From<Mrdis> for bool {
878    #[inline(always)]
879    fn from(variant: Mrdis) -> Self {
880        variant as u8 != 0
881    }
882}
883#[doc = "Field `MRDIS` reader - Controller Requests Disable"]
884pub type MrdisR = crate::BitReader<Mrdis>;
885impl MrdisR {
886    #[doc = "Get enumerated values variant"]
887    #[inline(always)]
888    pub const fn variant(&self) -> Mrdis {
889        match self.bits {
890            false => Mrdis::MrEnabled,
891            true => Mrdis::MrDisabled,
892        }
893    }
894    #[doc = "Enabled"]
895    #[inline(always)]
896    pub fn is_mr_enabled(&self) -> bool {
897        *self == Mrdis::MrEnabled
898    }
899    #[doc = "Disabled"]
900    #[inline(always)]
901    pub fn is_mr_disabled(&self) -> bool {
902        *self == Mrdis::MrDisabled
903    }
904}
905#[doc = "Hot-Join Disabled\n\nValue on reset: 0"]
906#[cfg_attr(feature = "defmt", derive(defmt::Format))]
907#[derive(Clone, Copy, Debug, PartialEq, Eq)]
908pub enum Hjdis {
909    #[doc = "0: Enabled"]
910    MrEnabled = 0,
911    #[doc = "1: Disabled"]
912    MrDisabled = 1,
913}
914impl From<Hjdis> for bool {
915    #[inline(always)]
916    fn from(variant: Hjdis) -> Self {
917        variant as u8 != 0
918    }
919}
920#[doc = "Field `HJDIS` reader - Hot-Join Disabled"]
921pub type HjdisR = crate::BitReader<Hjdis>;
922impl HjdisR {
923    #[doc = "Get enumerated values variant"]
924    #[inline(always)]
925    pub const fn variant(&self) -> Hjdis {
926        match self.bits {
927            false => Hjdis::MrEnabled,
928            true => Hjdis::MrDisabled,
929        }
930    }
931    #[doc = "Enabled"]
932    #[inline(always)]
933    pub fn is_mr_enabled(&self) -> bool {
934        *self == Hjdis::MrEnabled
935    }
936    #[doc = "Disabled"]
937    #[inline(always)]
938    pub fn is_mr_disabled(&self) -> bool {
939        *self == Hjdis::MrDisabled
940    }
941}
942#[doc = "Activity State from Common Command Codes (CCC)\n\nValue on reset: 0"]
943#[cfg_attr(feature = "defmt", derive(defmt::Format))]
944#[derive(Clone, Copy, Debug, PartialEq, Eq)]
945#[repr(u8)]
946pub enum Actstate {
947    #[doc = "0: NO_LATENCY (normal bus operations)"]
948    NoLatency = 0,
949    #[doc = "1: LATENCY_1MS (1 ms of latency)"]
950    Latency1ms = 1,
951    #[doc = "2: LATENCY_100MS (100 ms of latency)"]
952    Latency100ms = 2,
953    #[doc = "3: LATENCY_10S (10 seconds of latency)"]
954    Latency10s = 3,
955}
956impl From<Actstate> for u8 {
957    #[inline(always)]
958    fn from(variant: Actstate) -> Self {
959        variant as _
960    }
961}
962impl crate::FieldSpec for Actstate {
963    type Ux = u8;
964}
965impl crate::IsEnum for Actstate {}
966#[doc = "Field `ACTSTATE` reader - Activity State from Common Command Codes (CCC)"]
967pub type ActstateR = crate::FieldReader<Actstate>;
968impl ActstateR {
969    #[doc = "Get enumerated values variant"]
970    #[inline(always)]
971    pub const fn variant(&self) -> Actstate {
972        match self.bits {
973            0 => Actstate::NoLatency,
974            1 => Actstate::Latency1ms,
975            2 => Actstate::Latency100ms,
976            3 => Actstate::Latency10s,
977            _ => unreachable!(),
978        }
979    }
980    #[doc = "NO_LATENCY (normal bus operations)"]
981    #[inline(always)]
982    pub fn is_no_latency(&self) -> bool {
983        *self == Actstate::NoLatency
984    }
985    #[doc = "LATENCY_1MS (1 ms of latency)"]
986    #[inline(always)]
987    pub fn is_latency_1ms(&self) -> bool {
988        *self == Actstate::Latency1ms
989    }
990    #[doc = "LATENCY_100MS (100 ms of latency)"]
991    #[inline(always)]
992    pub fn is_latency_100ms(&self) -> bool {
993        *self == Actstate::Latency100ms
994    }
995    #[doc = "LATENCY_10S (10 seconds of latency)"]
996    #[inline(always)]
997    pub fn is_latency_10s(&self) -> bool {
998        *self == Actstate::Latency10s
999    }
1000}
1001#[doc = "Time Control\n\nValue on reset: 0"]
1002#[cfg_attr(feature = "defmt", derive(defmt::Format))]
1003#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1004#[repr(u8)]
1005pub enum Timectrl {
1006    #[doc = "0: NO_TIME_CONTROL (no time control is enabled)"]
1007    NoTimeControl = 0,
1008    #[doc = "1: SYNC_MODE (Synchronous mode is enabled)"]
1009    Sync = 1,
1010    #[doc = "2: ASYNC_MODE (Asynchronous standard mode (0 or 1) is enabled)"]
1011    AsyncMode = 2,
1012    #[doc = "3: BOTHSYNCASYNC (both Synchronous and Asynchronous modes are enabled)"]
1013    Bothsyncasync = 3,
1014}
1015impl From<Timectrl> for u8 {
1016    #[inline(always)]
1017    fn from(variant: Timectrl) -> Self {
1018        variant as _
1019    }
1020}
1021impl crate::FieldSpec for Timectrl {
1022    type Ux = u8;
1023}
1024impl crate::IsEnum for Timectrl {}
1025#[doc = "Field `TIMECTRL` reader - Time Control"]
1026pub type TimectrlR = crate::FieldReader<Timectrl>;
1027impl TimectrlR {
1028    #[doc = "Get enumerated values variant"]
1029    #[inline(always)]
1030    pub const fn variant(&self) -> Timectrl {
1031        match self.bits {
1032            0 => Timectrl::NoTimeControl,
1033            1 => Timectrl::Sync,
1034            2 => Timectrl::AsyncMode,
1035            3 => Timectrl::Bothsyncasync,
1036            _ => unreachable!(),
1037        }
1038    }
1039    #[doc = "NO_TIME_CONTROL (no time control is enabled)"]
1040    #[inline(always)]
1041    pub fn is_no_time_control(&self) -> bool {
1042        *self == Timectrl::NoTimeControl
1043    }
1044    #[doc = "SYNC_MODE (Synchronous mode is enabled)"]
1045    #[inline(always)]
1046    pub fn is_sync(&self) -> bool {
1047        *self == Timectrl::Sync
1048    }
1049    #[doc = "ASYNC_MODE (Asynchronous standard mode (0 or 1) is enabled)"]
1050    #[inline(always)]
1051    pub fn is_async_mode(&self) -> bool {
1052        *self == Timectrl::AsyncMode
1053    }
1054    #[doc = "BOTHSYNCASYNC (both Synchronous and Asynchronous modes are enabled)"]
1055    #[inline(always)]
1056    pub fn is_bothsyncasync(&self) -> bool {
1057        *self == Timectrl::Bothsyncasync
1058    }
1059}
1060impl R {
1061    #[doc = "Bit 0 - Status not Stop"]
1062    #[inline(always)]
1063    pub fn stnotstop(&self) -> StnotstopR {
1064        StnotstopR::new((self.bits & 1) != 0)
1065    }
1066    #[doc = "Bit 1 - Status Message"]
1067    #[inline(always)]
1068    pub fn stmsg(&self) -> StmsgR {
1069        StmsgR::new(((self.bits >> 1) & 1) != 0)
1070    }
1071    #[doc = "Bit 2 - Status Common Command Code Handler"]
1072    #[inline(always)]
1073    pub fn stccch(&self) -> StccchR {
1074        StccchR::new(((self.bits >> 2) & 1) != 0)
1075    }
1076    #[doc = "Bit 3 - Status Request Read"]
1077    #[inline(always)]
1078    pub fn streqrd(&self) -> StreqrdR {
1079        StreqrdR::new(((self.bits >> 3) & 1) != 0)
1080    }
1081    #[doc = "Bit 4 - Status Request Write"]
1082    #[inline(always)]
1083    pub fn streqwr(&self) -> StreqwrR {
1084        StreqwrR::new(((self.bits >> 4) & 1) != 0)
1085    }
1086    #[doc = "Bit 5 - Status Dynamic Address Assignment"]
1087    #[inline(always)]
1088    pub fn stdaa(&self) -> StdaaR {
1089        StdaaR::new(((self.bits >> 5) & 1) != 0)
1090    }
1091    #[doc = "Bit 6 - Status High Data Rate"]
1092    #[inline(always)]
1093    pub fn sthdr(&self) -> SthdrR {
1094        SthdrR::new(((self.bits >> 6) & 1) != 0)
1095    }
1096    #[doc = "Bit 8 - Start Flag"]
1097    #[inline(always)]
1098    pub fn start(&self) -> StartR {
1099        StartR::new(((self.bits >> 8) & 1) != 0)
1100    }
1101    #[doc = "Bit 9 - Matched Flag"]
1102    #[inline(always)]
1103    pub fn matched(&self) -> MatchedR {
1104        MatchedR::new(((self.bits >> 9) & 1) != 0)
1105    }
1106    #[doc = "Bit 10 - Stop Flag"]
1107    #[inline(always)]
1108    pub fn stop(&self) -> StopR {
1109        StopR::new(((self.bits >> 10) & 1) != 0)
1110    }
1111    #[doc = "Bit 11 - Received Message Pending"]
1112    #[inline(always)]
1113    pub fn rx_pend(&self) -> RxPendR {
1114        RxPendR::new(((self.bits >> 11) & 1) != 0)
1115    }
1116    #[doc = "Bit 12 - Transmit Buffer Not Full"]
1117    #[inline(always)]
1118    pub fn txnotfull(&self) -> TxnotfullR {
1119        TxnotfullR::new(((self.bits >> 12) & 1) != 0)
1120    }
1121    #[doc = "Bit 13 - Dynamic Address Change Flag"]
1122    #[inline(always)]
1123    pub fn dachg(&self) -> DachgR {
1124        DachgR::new(((self.bits >> 13) & 1) != 0)
1125    }
1126    #[doc = "Bit 14 - Common Command Code Flag"]
1127    #[inline(always)]
1128    pub fn ccc(&self) -> CccR {
1129        CccR::new(((self.bits >> 14) & 1) != 0)
1130    }
1131    #[doc = "Bit 15 - Error Warning"]
1132    #[inline(always)]
1133    pub fn errwarn(&self) -> ErrwarnR {
1134        ErrwarnR::new(((self.bits >> 15) & 1) != 0)
1135    }
1136    #[doc = "Bit 16 - High Data Rate Command Match Flag"]
1137    #[inline(always)]
1138    pub fn hdrmatch(&self) -> HdrmatchR {
1139        HdrmatchR::new(((self.bits >> 16) & 1) != 0)
1140    }
1141    #[doc = "Bit 17 - Common Command Code Handled Flag"]
1142    #[inline(always)]
1143    pub fn chandled(&self) -> ChandledR {
1144        ChandledR::new(((self.bits >> 17) & 1) != 0)
1145    }
1146    #[doc = "Bit 18 - Event Flag"]
1147    #[inline(always)]
1148    pub fn event(&self) -> EventR {
1149        EventR::new(((self.bits >> 18) & 1) != 0)
1150    }
1151    #[doc = "Bits 20:21 - Event Details"]
1152    #[inline(always)]
1153    pub fn evdet(&self) -> EvdetR {
1154        EvdetR::new(((self.bits >> 20) & 3) as u8)
1155    }
1156    #[doc = "Bit 24 - In-Band Interrupts Disable"]
1157    #[inline(always)]
1158    pub fn ibidis(&self) -> IbidisR {
1159        IbidisR::new(((self.bits >> 24) & 1) != 0)
1160    }
1161    #[doc = "Bit 25 - Controller Requests Disable"]
1162    #[inline(always)]
1163    pub fn mrdis(&self) -> MrdisR {
1164        MrdisR::new(((self.bits >> 25) & 1) != 0)
1165    }
1166    #[doc = "Bit 27 - Hot-Join Disabled"]
1167    #[inline(always)]
1168    pub fn hjdis(&self) -> HjdisR {
1169        HjdisR::new(((self.bits >> 27) & 1) != 0)
1170    }
1171    #[doc = "Bits 28:29 - Activity State from Common Command Codes (CCC)"]
1172    #[inline(always)]
1173    pub fn actstate(&self) -> ActstateR {
1174        ActstateR::new(((self.bits >> 28) & 3) as u8)
1175    }
1176    #[doc = "Bits 30:31 - Time Control"]
1177    #[inline(always)]
1178    pub fn timectrl(&self) -> TimectrlR {
1179        TimectrlR::new(((self.bits >> 30) & 3) as u8)
1180    }
1181}
1182#[cfg(feature = "debug")]
1183impl core::fmt::Debug for R {
1184    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1185        f.debug_struct("SSTATUS")
1186            .field("stnotstop", &self.stnotstop())
1187            .field("stmsg", &self.stmsg())
1188            .field("stccch", &self.stccch())
1189            .field("streqrd", &self.streqrd())
1190            .field("streqwr", &self.streqwr())
1191            .field("stdaa", &self.stdaa())
1192            .field("sthdr", &self.sthdr())
1193            .field("start", &self.start())
1194            .field("matched", &self.matched())
1195            .field("stop", &self.stop())
1196            .field("rx_pend", &self.rx_pend())
1197            .field("txnotfull", &self.txnotfull())
1198            .field("dachg", &self.dachg())
1199            .field("ccc", &self.ccc())
1200            .field("errwarn", &self.errwarn())
1201            .field("hdrmatch", &self.hdrmatch())
1202            .field("chandled", &self.chandled())
1203            .field("event", &self.event())
1204            .field("evdet", &self.evdet())
1205            .field("ibidis", &self.ibidis())
1206            .field("mrdis", &self.mrdis())
1207            .field("hjdis", &self.hjdis())
1208            .field("actstate", &self.actstate())
1209            .field("timectrl", &self.timectrl())
1210            .finish()
1211    }
1212}
1213impl W {
1214    #[doc = "Bit 8 - Start Flag"]
1215    #[inline(always)]
1216    pub fn start(&mut self) -> StartW<'_, SstatusSpec> {
1217        StartW::new(self, 8)
1218    }
1219    #[doc = "Bit 9 - Matched Flag"]
1220    #[inline(always)]
1221    pub fn matched(&mut self) -> MatchedW<'_, SstatusSpec> {
1222        MatchedW::new(self, 9)
1223    }
1224    #[doc = "Bit 10 - Stop Flag"]
1225    #[inline(always)]
1226    pub fn stop(&mut self) -> StopW<'_, SstatusSpec> {
1227        StopW::new(self, 10)
1228    }
1229    #[doc = "Bit 13 - Dynamic Address Change Flag"]
1230    #[inline(always)]
1231    pub fn dachg(&mut self) -> DachgW<'_, SstatusSpec> {
1232        DachgW::new(self, 13)
1233    }
1234    #[doc = "Bit 14 - Common Command Code Flag"]
1235    #[inline(always)]
1236    pub fn ccc(&mut self) -> CccW<'_, SstatusSpec> {
1237        CccW::new(self, 14)
1238    }
1239    #[doc = "Bit 16 - High Data Rate Command Match Flag"]
1240    #[inline(always)]
1241    pub fn hdrmatch(&mut self) -> HdrmatchW<'_, SstatusSpec> {
1242        HdrmatchW::new(self, 16)
1243    }
1244    #[doc = "Bit 17 - Common Command Code Handled Flag"]
1245    #[inline(always)]
1246    pub fn chandled(&mut self) -> ChandledW<'_, SstatusSpec> {
1247        ChandledW::new(self, 17)
1248    }
1249    #[doc = "Bit 18 - Event Flag"]
1250    #[inline(always)]
1251    pub fn event(&mut self) -> EventW<'_, SstatusSpec> {
1252        EventW::new(self, 18)
1253    }
1254}
1255#[doc = "Target Status\n\nYou can [`read`](crate::Reg::read) this register and get [`sstatus::R`](R). You can [`reset`](crate::Reg::reset), [`write`](crate::Reg::write), [`write_with_zero`](crate::Reg::write_with_zero) this register using [`sstatus::W`](W). You can also [`modify`](crate::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
1256pub struct SstatusSpec;
1257impl crate::RegisterSpec for SstatusSpec {
1258    type Ux = u32;
1259}
1260#[doc = "`read()` method returns [`sstatus::R`](R) reader structure"]
1261impl crate::Readable for SstatusSpec {}
1262#[doc = "`write(|w| ..)` method takes [`sstatus::W`](W) writer structure"]
1263impl crate::Writable for SstatusSpec {
1264    type Safety = crate::Unsafe;
1265    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0x0007_6700;
1266}
1267#[doc = "`reset()` method sets SSTATUS to value 0x1400"]
1268impl crate::Resettable for SstatusSpec {
1269    const RESET_VALUE: u32 = 0x1400;
1270}
mcxa_pac/i3c0/sstatus.rs

mcxa_pac/i3c0/
sstatus.rs
