atsams70j21/ssc/
ssc_tcmr.rs

1#[doc = "Register `SSC_TCMR` reader"]
2pub struct R(crate::R<SSC_TCMR_SPEC>);
3impl core::ops::Deref for R {
4    type Target = crate::R<SSC_TCMR_SPEC>;
5    #[inline(always)]
6    fn deref(&self) -> &Self::Target {
7        &self.0
8    }
9}
10impl From<crate::R<SSC_TCMR_SPEC>> for R {
11    #[inline(always)]
12    fn from(reader: crate::R<SSC_TCMR_SPEC>) -> Self {
13        R(reader)
14    }
15}
16#[doc = "Register `SSC_TCMR` writer"]
17pub struct W(crate::W<SSC_TCMR_SPEC>);
18impl core::ops::Deref for W {
19    type Target = crate::W<SSC_TCMR_SPEC>;
20    #[inline(always)]
21    fn deref(&self) -> &Self::Target {
22        &self.0
23    }
24}
25impl core::ops::DerefMut for W {
26    #[inline(always)]
27    fn deref_mut(&mut self) -> &mut Self::Target {
28        &mut self.0
29    }
30}
31impl From<crate::W<SSC_TCMR_SPEC>> for W {
32    #[inline(always)]
33    fn from(writer: crate::W<SSC_TCMR_SPEC>) -> Self {
34        W(writer)
35    }
36}
37#[doc = "Transmit Clock Selection\n\nValue on reset: 0"]
38#[derive(Clone, Copy, Debug, PartialEq)]
39#[repr(u8)]
40pub enum CKS_A {
41    #[doc = "0: Divided Clock"]
42    MCK = 0,
43    #[doc = "1: RK Clock signal"]
44    RK = 1,
45    #[doc = "2: TK pin"]
46    TK = 2,
47}
48impl From<CKS_A> for u8 {
49    #[inline(always)]
50    fn from(variant: CKS_A) -> Self {
51        variant as _
52    }
53}
54#[doc = "Field `CKS` reader - Transmit Clock Selection"]
55pub struct CKS_R(crate::FieldReader<u8, CKS_A>);
56impl CKS_R {
57    #[inline(always)]
58    pub(crate) fn new(bits: u8) -> Self {
59        CKS_R(crate::FieldReader::new(bits))
60    }
61    #[doc = r"Get enumerated values variant"]
62    #[inline(always)]
63    pub fn variant(&self) -> Option<CKS_A> {
64        match self.bits {
65            0 => Some(CKS_A::MCK),
66            1 => Some(CKS_A::RK),
67            2 => Some(CKS_A::TK),
68            _ => None,
69        }
70    }
71    #[doc = "Checks if the value of the field is `MCK`"]
72    #[inline(always)]
73    pub fn is_mck(&self) -> bool {
74        **self == CKS_A::MCK
75    }
76    #[doc = "Checks if the value of the field is `RK`"]
77    #[inline(always)]
78    pub fn is_rk(&self) -> bool {
79        **self == CKS_A::RK
80    }
81    #[doc = "Checks if the value of the field is `TK`"]
82    #[inline(always)]
83    pub fn is_tk(&self) -> bool {
84        **self == CKS_A::TK
85    }
86}
87impl core::ops::Deref for CKS_R {
88    type Target = crate::FieldReader<u8, CKS_A>;
89    #[inline(always)]
90    fn deref(&self) -> &Self::Target {
91        &self.0
92    }
93}
94#[doc = "Field `CKS` writer - Transmit Clock Selection"]
95pub struct CKS_W<'a> {
96    w: &'a mut W,
97}
98impl<'a> CKS_W<'a> {
99    #[doc = r"Writes `variant` to the field"]
100    #[inline(always)]
101    pub fn variant(self, variant: CKS_A) -> &'a mut W {
102        unsafe { self.bits(variant.into()) }
103    }
104    #[doc = "Divided Clock"]
105    #[inline(always)]
106    pub fn mck(self) -> &'a mut W {
107        self.variant(CKS_A::MCK)
108    }
109    #[doc = "RK Clock signal"]
110    #[inline(always)]
111    pub fn rk(self) -> &'a mut W {
112        self.variant(CKS_A::RK)
113    }
114    #[doc = "TK pin"]
115    #[inline(always)]
116    pub fn tk(self) -> &'a mut W {
117        self.variant(CKS_A::TK)
118    }
119    #[doc = r"Writes raw bits to the field"]
120    #[inline(always)]
121    pub unsafe fn bits(self, value: u8) -> &'a mut W {
122        self.w.bits = (self.w.bits & !0x03) | (value as u32 & 0x03);
123        self.w
124    }
125}
126#[doc = "Transmit Clock Output Mode Selection\n\nValue on reset: 0"]
127#[derive(Clone, Copy, Debug, PartialEq)]
128#[repr(u8)]
129pub enum CKO_A {
130    #[doc = "0: None, TK pin is an input"]
131    NONE = 0,
132    #[doc = "1: Continuous Transmit Clock, TK pin is an output"]
133    CONTINUOUS = 1,
134    #[doc = "2: Transmit Clock only during data transfers, TK pin is an output"]
135    TRANSFER = 2,
136}
137impl From<CKO_A> for u8 {
138    #[inline(always)]
139    fn from(variant: CKO_A) -> Self {
140        variant as _
141    }
142}
143#[doc = "Field `CKO` reader - Transmit Clock Output Mode Selection"]
144pub struct CKO_R(crate::FieldReader<u8, CKO_A>);
145impl CKO_R {
146    #[inline(always)]
147    pub(crate) fn new(bits: u8) -> Self {
148        CKO_R(crate::FieldReader::new(bits))
149    }
150    #[doc = r"Get enumerated values variant"]
151    #[inline(always)]
152    pub fn variant(&self) -> Option<CKO_A> {
153        match self.bits {
154            0 => Some(CKO_A::NONE),
155            1 => Some(CKO_A::CONTINUOUS),
156            2 => Some(CKO_A::TRANSFER),
157            _ => None,
158        }
159    }
160    #[doc = "Checks if the value of the field is `NONE`"]
161    #[inline(always)]
162    pub fn is_none(&self) -> bool {
163        **self == CKO_A::NONE
164    }
165    #[doc = "Checks if the value of the field is `CONTINUOUS`"]
166    #[inline(always)]
167    pub fn is_continuous(&self) -> bool {
168        **self == CKO_A::CONTINUOUS
169    }
170    #[doc = "Checks if the value of the field is `TRANSFER`"]
171    #[inline(always)]
172    pub fn is_transfer(&self) -> bool {
173        **self == CKO_A::TRANSFER
174    }
175}
176impl core::ops::Deref for CKO_R {
177    type Target = crate::FieldReader<u8, CKO_A>;
178    #[inline(always)]
179    fn deref(&self) -> &Self::Target {
180        &self.0
181    }
182}
183#[doc = "Field `CKO` writer - Transmit Clock Output Mode Selection"]
184pub struct CKO_W<'a> {
185    w: &'a mut W,
186}
187impl<'a> CKO_W<'a> {
188    #[doc = r"Writes `variant` to the field"]
189    #[inline(always)]
190    pub fn variant(self, variant: CKO_A) -> &'a mut W {
191        unsafe { self.bits(variant.into()) }
192    }
193    #[doc = "None, TK pin is an input"]
194    #[inline(always)]
195    pub fn none(self) -> &'a mut W {
196        self.variant(CKO_A::NONE)
197    }
198    #[doc = "Continuous Transmit Clock, TK pin is an output"]
199    #[inline(always)]
200    pub fn continuous(self) -> &'a mut W {
201        self.variant(CKO_A::CONTINUOUS)
202    }
203    #[doc = "Transmit Clock only during data transfers, TK pin is an output"]
204    #[inline(always)]
205    pub fn transfer(self) -> &'a mut W {
206        self.variant(CKO_A::TRANSFER)
207    }
208    #[doc = r"Writes raw bits to the field"]
209    #[inline(always)]
210    pub unsafe fn bits(self, value: u8) -> &'a mut W {
211        self.w.bits = (self.w.bits & !(0x07 << 2)) | ((value as u32 & 0x07) << 2);
212        self.w
213    }
214}
215#[doc = "Field `CKI` reader - Transmit Clock Inversion"]
216pub struct CKI_R(crate::FieldReader<bool, bool>);
217impl CKI_R {
218    #[inline(always)]
219    pub(crate) fn new(bits: bool) -> Self {
220        CKI_R(crate::FieldReader::new(bits))
221    }
222}
223impl core::ops::Deref for CKI_R {
224    type Target = crate::FieldReader<bool, bool>;
225    #[inline(always)]
226    fn deref(&self) -> &Self::Target {
227        &self.0
228    }
229}
230#[doc = "Field `CKI` writer - Transmit Clock Inversion"]
231pub struct CKI_W<'a> {
232    w: &'a mut W,
233}
234impl<'a> CKI_W<'a> {
235    #[doc = r"Sets the field bit"]
236    #[inline(always)]
237    pub fn set_bit(self) -> &'a mut W {
238        self.bit(true)
239    }
240    #[doc = r"Clears the field bit"]
241    #[inline(always)]
242    pub fn clear_bit(self) -> &'a mut W {
243        self.bit(false)
244    }
245    #[doc = r"Writes raw bits to the field"]
246    #[inline(always)]
247    pub fn bit(self, value: bool) -> &'a mut W {
248        self.w.bits = (self.w.bits & !(0x01 << 5)) | ((value as u32 & 0x01) << 5);
249        self.w
250    }
251}
252#[doc = "Transmit Clock Gating Selection\n\nValue on reset: 0"]
253#[derive(Clone, Copy, Debug, PartialEq)]
254#[repr(u8)]
255pub enum CKG_A {
256    #[doc = "0: None"]
257    CONTINUOUS = 0,
258    #[doc = "1: Transmit Clock enabled only if TF Low"]
259    EN_TF_LOW = 1,
260    #[doc = "2: Transmit Clock enabled only if TF High"]
261    EN_TF_HIGH = 2,
262}
263impl From<CKG_A> for u8 {
264    #[inline(always)]
265    fn from(variant: CKG_A) -> Self {
266        variant as _
267    }
268}
269#[doc = "Field `CKG` reader - Transmit Clock Gating Selection"]
270pub struct CKG_R(crate::FieldReader<u8, CKG_A>);
271impl CKG_R {
272    #[inline(always)]
273    pub(crate) fn new(bits: u8) -> Self {
274        CKG_R(crate::FieldReader::new(bits))
275    }
276    #[doc = r"Get enumerated values variant"]
277    #[inline(always)]
278    pub fn variant(&self) -> Option<CKG_A> {
279        match self.bits {
280            0 => Some(CKG_A::CONTINUOUS),
281            1 => Some(CKG_A::EN_TF_LOW),
282            2 => Some(CKG_A::EN_TF_HIGH),
283            _ => None,
284        }
285    }
286    #[doc = "Checks if the value of the field is `CONTINUOUS`"]
287    #[inline(always)]
288    pub fn is_continuous(&self) -> bool {
289        **self == CKG_A::CONTINUOUS
290    }
291    #[doc = "Checks if the value of the field is `EN_TF_LOW`"]
292    #[inline(always)]
293    pub fn is_en_tf_low(&self) -> bool {
294        **self == CKG_A::EN_TF_LOW
295    }
296    #[doc = "Checks if the value of the field is `EN_TF_HIGH`"]
297    #[inline(always)]
298    pub fn is_en_tf_high(&self) -> bool {
299        **self == CKG_A::EN_TF_HIGH
300    }
301}
302impl core::ops::Deref for CKG_R {
303    type Target = crate::FieldReader<u8, CKG_A>;
304    #[inline(always)]
305    fn deref(&self) -> &Self::Target {
306        &self.0
307    }
308}
309#[doc = "Field `CKG` writer - Transmit Clock Gating Selection"]
310pub struct CKG_W<'a> {
311    w: &'a mut W,
312}
313impl<'a> CKG_W<'a> {
314    #[doc = r"Writes `variant` to the field"]
315    #[inline(always)]
316    pub fn variant(self, variant: CKG_A) -> &'a mut W {
317        unsafe { self.bits(variant.into()) }
318    }
319    #[doc = "None"]
320    #[inline(always)]
321    pub fn continuous(self) -> &'a mut W {
322        self.variant(CKG_A::CONTINUOUS)
323    }
324    #[doc = "Transmit Clock enabled only if TF Low"]
325    #[inline(always)]
326    pub fn en_tf_low(self) -> &'a mut W {
327        self.variant(CKG_A::EN_TF_LOW)
328    }
329    #[doc = "Transmit Clock enabled only if TF High"]
330    #[inline(always)]
331    pub fn en_tf_high(self) -> &'a mut W {
332        self.variant(CKG_A::EN_TF_HIGH)
333    }
334    #[doc = r"Writes raw bits to the field"]
335    #[inline(always)]
336    pub unsafe fn bits(self, value: u8) -> &'a mut W {
337        self.w.bits = (self.w.bits & !(0x03 << 6)) | ((value as u32 & 0x03) << 6);
338        self.w
339    }
340}
341#[doc = "Transmit Start Selection\n\nValue on reset: 0"]
342#[derive(Clone, Copy, Debug, PartialEq)]
343#[repr(u8)]
344pub enum START_A {
345    #[doc = "0: Continuous, as soon as a word is written in the SSC_THR (if Transmit is enabled), and immediately after the end of transfer of the previous data"]
346    CONTINUOUS = 0,
347    #[doc = "1: Receive start"]
348    RECEIVE = 1,
349    #[doc = "2: Detection of a low level on TF signal"]
350    TF_LOW = 2,
351    #[doc = "3: Detection of a high level on TF signal"]
352    TF_HIGH = 3,
353    #[doc = "4: Detection of a falling edge on TF signal"]
354    TF_FALLING = 4,
355    #[doc = "5: Detection of a rising edge on TF signal"]
356    TF_RISING = 5,
357    #[doc = "6: Detection of any level change on TF signal"]
358    TF_LEVEL = 6,
359    #[doc = "7: Detection of any edge on TF signal"]
360    TF_EDGE = 7,
361}
362impl From<START_A> for u8 {
363    #[inline(always)]
364    fn from(variant: START_A) -> Self {
365        variant as _
366    }
367}
368#[doc = "Field `START` reader - Transmit Start Selection"]
369pub struct START_R(crate::FieldReader<u8, START_A>);
370impl START_R {
371    #[inline(always)]
372    pub(crate) fn new(bits: u8) -> Self {
373        START_R(crate::FieldReader::new(bits))
374    }
375    #[doc = r"Get enumerated values variant"]
376    #[inline(always)]
377    pub fn variant(&self) -> Option<START_A> {
378        match self.bits {
379            0 => Some(START_A::CONTINUOUS),
380            1 => Some(START_A::RECEIVE),
381            2 => Some(START_A::TF_LOW),
382            3 => Some(START_A::TF_HIGH),
383            4 => Some(START_A::TF_FALLING),
384            5 => Some(START_A::TF_RISING),
385            6 => Some(START_A::TF_LEVEL),
386            7 => Some(START_A::TF_EDGE),
387            _ => None,
388        }
389    }
390    #[doc = "Checks if the value of the field is `CONTINUOUS`"]
391    #[inline(always)]
392    pub fn is_continuous(&self) -> bool {
393        **self == START_A::CONTINUOUS
394    }
395    #[doc = "Checks if the value of the field is `RECEIVE`"]
396    #[inline(always)]
397    pub fn is_receive(&self) -> bool {
398        **self == START_A::RECEIVE
399    }
400    #[doc = "Checks if the value of the field is `TF_LOW`"]
401    #[inline(always)]
402    pub fn is_tf_low(&self) -> bool {
403        **self == START_A::TF_LOW
404    }
405    #[doc = "Checks if the value of the field is `TF_HIGH`"]
406    #[inline(always)]
407    pub fn is_tf_high(&self) -> bool {
408        **self == START_A::TF_HIGH
409    }
410    #[doc = "Checks if the value of the field is `TF_FALLING`"]
411    #[inline(always)]
412    pub fn is_tf_falling(&self) -> bool {
413        **self == START_A::TF_FALLING
414    }
415    #[doc = "Checks if the value of the field is `TF_RISING`"]
416    #[inline(always)]
417    pub fn is_tf_rising(&self) -> bool {
418        **self == START_A::TF_RISING
419    }
420    #[doc = "Checks if the value of the field is `TF_LEVEL`"]
421    #[inline(always)]
422    pub fn is_tf_level(&self) -> bool {
423        **self == START_A::TF_LEVEL
424    }
425    #[doc = "Checks if the value of the field is `TF_EDGE`"]
426    #[inline(always)]
427    pub fn is_tf_edge(&self) -> bool {
428        **self == START_A::TF_EDGE
429    }
430}
431impl core::ops::Deref for START_R {
432    type Target = crate::FieldReader<u8, START_A>;
433    #[inline(always)]
434    fn deref(&self) -> &Self::Target {
435        &self.0
436    }
437}
438#[doc = "Field `START` writer - Transmit Start Selection"]
439pub struct START_W<'a> {
440    w: &'a mut W,
441}
442impl<'a> START_W<'a> {
443    #[doc = r"Writes `variant` to the field"]
444    #[inline(always)]
445    pub fn variant(self, variant: START_A) -> &'a mut W {
446        unsafe { self.bits(variant.into()) }
447    }
448    #[doc = "Continuous, as soon as a word is written in the SSC_THR (if Transmit is enabled), and immediately after the end of transfer of the previous data"]
449    #[inline(always)]
450    pub fn continuous(self) -> &'a mut W {
451        self.variant(START_A::CONTINUOUS)
452    }
453    #[doc = "Receive start"]
454    #[inline(always)]
455    pub fn receive(self) -> &'a mut W {
456        self.variant(START_A::RECEIVE)
457    }
458    #[doc = "Detection of a low level on TF signal"]
459    #[inline(always)]
460    pub fn tf_low(self) -> &'a mut W {
461        self.variant(START_A::TF_LOW)
462    }
463    #[doc = "Detection of a high level on TF signal"]
464    #[inline(always)]
465    pub fn tf_high(self) -> &'a mut W {
466        self.variant(START_A::TF_HIGH)
467    }
468    #[doc = "Detection of a falling edge on TF signal"]
469    #[inline(always)]
470    pub fn tf_falling(self) -> &'a mut W {
471        self.variant(START_A::TF_FALLING)
472    }
473    #[doc = "Detection of a rising edge on TF signal"]
474    #[inline(always)]
475    pub fn tf_rising(self) -> &'a mut W {
476        self.variant(START_A::TF_RISING)
477    }
478    #[doc = "Detection of any level change on TF signal"]
479    #[inline(always)]
480    pub fn tf_level(self) -> &'a mut W {
481        self.variant(START_A::TF_LEVEL)
482    }
483    #[doc = "Detection of any edge on TF signal"]
484    #[inline(always)]
485    pub fn tf_edge(self) -> &'a mut W {
486        self.variant(START_A::TF_EDGE)
487    }
488    #[doc = r"Writes raw bits to the field"]
489    #[inline(always)]
490    pub unsafe fn bits(self, value: u8) -> &'a mut W {
491        self.w.bits = (self.w.bits & !(0x0f << 8)) | ((value as u32 & 0x0f) << 8);
492        self.w
493    }
494}
495#[doc = "Field `STTDLY` reader - Transmit Start Delay"]
496pub struct STTDLY_R(crate::FieldReader<u8, u8>);
497impl STTDLY_R {
498    #[inline(always)]
499    pub(crate) fn new(bits: u8) -> Self {
500        STTDLY_R(crate::FieldReader::new(bits))
501    }
502}
503impl core::ops::Deref for STTDLY_R {
504    type Target = crate::FieldReader<u8, u8>;
505    #[inline(always)]
506    fn deref(&self) -> &Self::Target {
507        &self.0
508    }
509}
510#[doc = "Field `STTDLY` writer - Transmit Start Delay"]
511pub struct STTDLY_W<'a> {
512    w: &'a mut W,
513}
514impl<'a> STTDLY_W<'a> {
515    #[doc = r"Writes raw bits to the field"]
516    #[inline(always)]
517    pub unsafe fn bits(self, value: u8) -> &'a mut W {
518        self.w.bits = (self.w.bits & !(0xff << 16)) | ((value as u32 & 0xff) << 16);
519        self.w
520    }
521}
522#[doc = "Field `PERIOD` reader - Transmit Period Divider Selection"]
523pub struct PERIOD_R(crate::FieldReader<u8, u8>);
524impl PERIOD_R {
525    #[inline(always)]
526    pub(crate) fn new(bits: u8) -> Self {
527        PERIOD_R(crate::FieldReader::new(bits))
528    }
529}
530impl core::ops::Deref for PERIOD_R {
531    type Target = crate::FieldReader<u8, u8>;
532    #[inline(always)]
533    fn deref(&self) -> &Self::Target {
534        &self.0
535    }
536}
537#[doc = "Field `PERIOD` writer - Transmit Period Divider Selection"]
538pub struct PERIOD_W<'a> {
539    w: &'a mut W,
540}
541impl<'a> PERIOD_W<'a> {
542    #[doc = r"Writes raw bits to the field"]
543    #[inline(always)]
544    pub unsafe fn bits(self, value: u8) -> &'a mut W {
545        self.w.bits = (self.w.bits & !(0xff << 24)) | ((value as u32 & 0xff) << 24);
546        self.w
547    }
548}
549impl R {
550    #[doc = "Bits 0:1 - Transmit Clock Selection"]
551    #[inline(always)]
552    pub fn cks(&self) -> CKS_R {
553        CKS_R::new((self.bits & 0x03) as u8)
554    }
555    #[doc = "Bits 2:4 - Transmit Clock Output Mode Selection"]
556    #[inline(always)]
557    pub fn cko(&self) -> CKO_R {
558        CKO_R::new(((self.bits >> 2) & 0x07) as u8)
559    }
560    #[doc = "Bit 5 - Transmit Clock Inversion"]
561    #[inline(always)]
562    pub fn cki(&self) -> CKI_R {
563        CKI_R::new(((self.bits >> 5) & 0x01) != 0)
564    }
565    #[doc = "Bits 6:7 - Transmit Clock Gating Selection"]
566    #[inline(always)]
567    pub fn ckg(&self) -> CKG_R {
568        CKG_R::new(((self.bits >> 6) & 0x03) as u8)
569    }
570    #[doc = "Bits 8:11 - Transmit Start Selection"]
571    #[inline(always)]
572    pub fn start(&self) -> START_R {
573        START_R::new(((self.bits >> 8) & 0x0f) as u8)
574    }
575    #[doc = "Bits 16:23 - Transmit Start Delay"]
576    #[inline(always)]
577    pub fn sttdly(&self) -> STTDLY_R {
578        STTDLY_R::new(((self.bits >> 16) & 0xff) as u8)
579    }
580    #[doc = "Bits 24:31 - Transmit Period Divider Selection"]
581    #[inline(always)]
582    pub fn period(&self) -> PERIOD_R {
583        PERIOD_R::new(((self.bits >> 24) & 0xff) as u8)
584    }
585}
586impl W {
587    #[doc = "Bits 0:1 - Transmit Clock Selection"]
588    #[inline(always)]
589    pub fn cks(&mut self) -> CKS_W {
590        CKS_W { w: self }
591    }
592    #[doc = "Bits 2:4 - Transmit Clock Output Mode Selection"]
593    #[inline(always)]
594    pub fn cko(&mut self) -> CKO_W {
595        CKO_W { w: self }
596    }
597    #[doc = "Bit 5 - Transmit Clock Inversion"]
598    #[inline(always)]
599    pub fn cki(&mut self) -> CKI_W {
600        CKI_W { w: self }
601    }
602    #[doc = "Bits 6:7 - Transmit Clock Gating Selection"]
603    #[inline(always)]
604    pub fn ckg(&mut self) -> CKG_W {
605        CKG_W { w: self }
606    }
607    #[doc = "Bits 8:11 - Transmit Start Selection"]
608    #[inline(always)]
609    pub fn start(&mut self) -> START_W {
610        START_W { w: self }
611    }
612    #[doc = "Bits 16:23 - Transmit Start Delay"]
613    #[inline(always)]
614    pub fn sttdly(&mut self) -> STTDLY_W {
615        STTDLY_W { w: self }
616    }
617    #[doc = "Bits 24:31 - Transmit Period Divider Selection"]
618    #[inline(always)]
619    pub fn period(&mut self) -> PERIOD_W {
620        PERIOD_W { w: self }
621    }
622    #[doc = "Writes raw bits to the register."]
623    #[inline(always)]
624    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
625        self.0.bits(bits);
626        self
627    }
628}
629#[doc = "Transmit Clock Mode Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [ssc_tcmr](index.html) module"]
630pub struct SSC_TCMR_SPEC;
631impl crate::RegisterSpec for SSC_TCMR_SPEC {
632    type Ux = u32;
633}
634#[doc = "`read()` method returns [ssc_tcmr::R](R) reader structure"]
635impl crate::Readable for SSC_TCMR_SPEC {
636    type Reader = R;
637}
638#[doc = "`write(|w| ..)` method takes [ssc_tcmr::W](W) writer structure"]
639impl crate::Writable for SSC_TCMR_SPEC {
640    type Writer = W;
641}
642#[doc = "`reset()` method sets SSC_TCMR to value 0"]
643impl crate::Resettable for SSC_TCMR_SPEC {
644    #[inline(always)]
645    fn reset_value() -> Self::Ux {
646        0
647    }
648}
atsams70j21/ssc/ssc_tcmr.rs

atsams70j21/ssc/
ssc_tcmr.rs
