bl808_pac/i2c/
config.rs

1#[doc = "Register `config` reader"]
2pub struct R(crate::R<CONFIG_SPEC>);
3impl core::ops::Deref for R {
4    type Target = crate::R<CONFIG_SPEC>;
5    #[inline(always)]
6    fn deref(&self) -> &Self::Target {
7        &self.0
8    }
9}
10impl From<crate::R<CONFIG_SPEC>> for R {
11    #[inline(always)]
12    fn from(reader: crate::R<CONFIG_SPEC>) -> Self {
13        R(reader)
14    }
15}
16#[doc = "Register `config` writer"]
17pub struct W(crate::W<CONFIG_SPEC>);
18impl core::ops::Deref for W {
19    type Target = crate::W<CONFIG_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<CONFIG_SPEC>> for W {
32    #[inline(always)]
33    fn from(writer: crate::W<CONFIG_SPEC>) -> Self {
34        W(writer)
35    }
36}
37#[doc = "Field `master_enable` reader - Enable signal of I2C master function\n\n Asserting this bit will trigger the transaction, and should be de-asserted after finish."]
38pub type MASTER_ENABLE_R = crate::BitReader<MASTER_ENABLE_A>;
39#[doc = "Enable signal of I2C master function\n\n Asserting this bit will trigger the transaction, and should be de-asserted after finish.\n\nValue on reset: 0"]
40#[derive(Clone, Copy, Debug, PartialEq, Eq)]
41pub enum MASTER_ENABLE_A {
42    #[doc = "1: Enable I2C master function"]
43    ENABLE = 1,
44    #[doc = "0: Disable I2C master function"]
45    DISABLE = 0,
46}
47impl From<MASTER_ENABLE_A> for bool {
48    #[inline(always)]
49    fn from(variant: MASTER_ENABLE_A) -> Self {
50        variant as u8 != 0
51    }
52}
53impl MASTER_ENABLE_R {
54    #[doc = "Get enumerated values variant"]
55    #[inline(always)]
56    pub fn variant(&self) -> MASTER_ENABLE_A {
57        match self.bits {
58            true => MASTER_ENABLE_A::ENABLE,
59            false => MASTER_ENABLE_A::DISABLE,
60        }
61    }
62    #[doc = "Checks if the value of the field is `ENABLE`"]
63    #[inline(always)]
64    pub fn is_enable(&self) -> bool {
65        *self == MASTER_ENABLE_A::ENABLE
66    }
67    #[doc = "Checks if the value of the field is `DISABLE`"]
68    #[inline(always)]
69    pub fn is_disable(&self) -> bool {
70        *self == MASTER_ENABLE_A::DISABLE
71    }
72}
73#[doc = "Field `master_enable` writer - Enable signal of I2C master function\n\n Asserting this bit will trigger the transaction, and should be de-asserted after finish."]
74pub type MASTER_ENABLE_W<'a, const O: u8> =
75    crate::BitWriter<'a, u32, CONFIG_SPEC, MASTER_ENABLE_A, O>;
76impl<'a, const O: u8> MASTER_ENABLE_W<'a, O> {
77    #[doc = "Enable I2C master function"]
78    #[inline(always)]
79    pub fn enable(self) -> &'a mut W {
80        self.variant(MASTER_ENABLE_A::ENABLE)
81    }
82    #[doc = "Disable I2C master function"]
83    #[inline(always)]
84    pub fn disable(self) -> &'a mut W {
85        self.variant(MASTER_ENABLE_A::DISABLE)
86    }
87}
88#[doc = "Field `transfer_direction` reader - Packet transfer direction"]
89pub type TRANSFER_DIRECTION_R = crate::BitReader<TRANSFER_DIRECTION_A>;
90#[doc = "Packet transfer direction\n\nValue on reset: 1"]
91#[derive(Clone, Copy, Debug, PartialEq, Eq)]
92pub enum TRANSFER_DIRECTION_A {
93    #[doc = "0: Write from master side"]
94    WRITE = 0,
95    #[doc = "1: Read from master side"]
96    READ = 1,
97}
98impl From<TRANSFER_DIRECTION_A> for bool {
99    #[inline(always)]
100    fn from(variant: TRANSFER_DIRECTION_A) -> Self {
101        variant as u8 != 0
102    }
103}
104impl TRANSFER_DIRECTION_R {
105    #[doc = "Get enumerated values variant"]
106    #[inline(always)]
107    pub fn variant(&self) -> TRANSFER_DIRECTION_A {
108        match self.bits {
109            false => TRANSFER_DIRECTION_A::WRITE,
110            true => TRANSFER_DIRECTION_A::READ,
111        }
112    }
113    #[doc = "Checks if the value of the field is `WRITE`"]
114    #[inline(always)]
115    pub fn is_write(&self) -> bool {
116        *self == TRANSFER_DIRECTION_A::WRITE
117    }
118    #[doc = "Checks if the value of the field is `READ`"]
119    #[inline(always)]
120    pub fn is_read(&self) -> bool {
121        *self == TRANSFER_DIRECTION_A::READ
122    }
123}
124#[doc = "Field `transfer_direction` writer - Packet transfer direction"]
125pub type TRANSFER_DIRECTION_W<'a, const O: u8> =
126    crate::BitWriter<'a, u32, CONFIG_SPEC, TRANSFER_DIRECTION_A, O>;
127impl<'a, const O: u8> TRANSFER_DIRECTION_W<'a, O> {
128    #[doc = "Write from master side"]
129    #[inline(always)]
130    pub fn write(self) -> &'a mut W {
131        self.variant(TRANSFER_DIRECTION_A::WRITE)
132    }
133    #[doc = "Read from master side"]
134    #[inline(always)]
135    pub fn read(self) -> &'a mut W {
136        self.variant(TRANSFER_DIRECTION_A::READ)
137    }
138}
139#[doc = "Field `deglitch_enable` reader - Enable de-glitch function on all input pins"]
140pub type DEGLITCH_ENABLE_R = crate::BitReader<DEGLITCH_ENABLE_A>;
141#[doc = "Enable de-glitch function on all input pins\n\nValue on reset: 0"]
142#[derive(Clone, Copy, Debug, PartialEq, Eq)]
143pub enum DEGLITCH_ENABLE_A {
144    #[doc = "1: Enable de-glitch function on inputs"]
145    ENABLE = 1,
146    #[doc = "0: Disable de-glitch function on inputs"]
147    DISABLE = 0,
148}
149impl From<DEGLITCH_ENABLE_A> for bool {
150    #[inline(always)]
151    fn from(variant: DEGLITCH_ENABLE_A) -> Self {
152        variant as u8 != 0
153    }
154}
155impl DEGLITCH_ENABLE_R {
156    #[doc = "Get enumerated values variant"]
157    #[inline(always)]
158    pub fn variant(&self) -> DEGLITCH_ENABLE_A {
159        match self.bits {
160            true => DEGLITCH_ENABLE_A::ENABLE,
161            false => DEGLITCH_ENABLE_A::DISABLE,
162        }
163    }
164    #[doc = "Checks if the value of the field is `ENABLE`"]
165    #[inline(always)]
166    pub fn is_enable(&self) -> bool {
167        *self == DEGLITCH_ENABLE_A::ENABLE
168    }
169    #[doc = "Checks if the value of the field is `DISABLE`"]
170    #[inline(always)]
171    pub fn is_disable(&self) -> bool {
172        *self == DEGLITCH_ENABLE_A::DISABLE
173    }
174}
175#[doc = "Field `deglitch_enable` writer - Enable de-glitch function on all input pins"]
176pub type DEGLITCH_ENABLE_W<'a, const O: u8> =
177    crate::BitWriter<'a, u32, CONFIG_SPEC, DEGLITCH_ENABLE_A, O>;
178impl<'a, const O: u8> DEGLITCH_ENABLE_W<'a, O> {
179    #[doc = "Enable de-glitch function on inputs"]
180    #[inline(always)]
181    pub fn enable(self) -> &'a mut W {
182        self.variant(DEGLITCH_ENABLE_A::ENABLE)
183    }
184    #[doc = "Disable de-glitch function on inputs"]
185    #[inline(always)]
186    pub fn disable(self) -> &'a mut W {
187        self.variant(DEGLITCH_ENABLE_A::DISABLE)
188    }
189}
190#[doc = "Field `clock_synchronize` reader - Enable I2C clock synchronization\n\n Enable this bit to support multi-master and clock-stretching. It should not be turned-off normally."]
191pub type CLOCK_SYNCHRONIZE_R = crate::BitReader<CLOCK_SYNCHRONIZE_A>;
192#[doc = "Enable I2C clock synchronization\n\n Enable this bit to support multi-master and clock-stretching. It should not be turned-off normally.\n\nValue on reset: 1"]
193#[derive(Clone, Copy, Debug, PartialEq, Eq)]
194pub enum CLOCK_SYNCHRONIZE_A {
195    #[doc = "1: Enable clock synchronization"]
196    ENABLE = 1,
197    #[doc = "0: Disable clock synchronization"]
198    DISABLE = 0,
199}
200impl From<CLOCK_SYNCHRONIZE_A> for bool {
201    #[inline(always)]
202    fn from(variant: CLOCK_SYNCHRONIZE_A) -> Self {
203        variant as u8 != 0
204    }
205}
206impl CLOCK_SYNCHRONIZE_R {
207    #[doc = "Get enumerated values variant"]
208    #[inline(always)]
209    pub fn variant(&self) -> CLOCK_SYNCHRONIZE_A {
210        match self.bits {
211            true => CLOCK_SYNCHRONIZE_A::ENABLE,
212            false => CLOCK_SYNCHRONIZE_A::DISABLE,
213        }
214    }
215    #[doc = "Checks if the value of the field is `ENABLE`"]
216    #[inline(always)]
217    pub fn is_enable(&self) -> bool {
218        *self == CLOCK_SYNCHRONIZE_A::ENABLE
219    }
220    #[doc = "Checks if the value of the field is `DISABLE`"]
221    #[inline(always)]
222    pub fn is_disable(&self) -> bool {
223        *self == CLOCK_SYNCHRONIZE_A::DISABLE
224    }
225}
226#[doc = "Field `clock_synchronize` writer - Enable I2C clock synchronization\n\n Enable this bit to support multi-master and clock-stretching. It should not be turned-off normally."]
227pub type CLOCK_SYNCHRONIZE_W<'a, const O: u8> =
228    crate::BitWriter<'a, u32, CONFIG_SPEC, CLOCK_SYNCHRONIZE_A, O>;
229impl<'a, const O: u8> CLOCK_SYNCHRONIZE_W<'a, O> {
230    #[doc = "Enable clock synchronization"]
231    #[inline(always)]
232    pub fn enable(self) -> &'a mut W {
233        self.variant(CLOCK_SYNCHRONIZE_A::ENABLE)
234    }
235    #[doc = "Disable clock synchronization"]
236    #[inline(always)]
237    pub fn disable(self) -> &'a mut W {
238        self.variant(CLOCK_SYNCHRONIZE_A::DISABLE)
239    }
240}
241#[doc = "Field `sub_address_enable` reader - Enable sub-address fields"]
242pub type SUB_ADDRESS_ENABLE_R = crate::BitReader<SUB_ADDRESS_ENABLE_A>;
243#[doc = "Enable sub-address fields\n\nValue on reset: 0"]
244#[derive(Clone, Copy, Debug, PartialEq, Eq)]
245pub enum SUB_ADDRESS_ENABLE_A {
246    #[doc = "1: Enable sub-address fields"]
247    ENABLE = 1,
248    #[doc = "0: Disable sub-address fields"]
249    DISABLE = 0,
250}
251impl From<SUB_ADDRESS_ENABLE_A> for bool {
252    #[inline(always)]
253    fn from(variant: SUB_ADDRESS_ENABLE_A) -> Self {
254        variant as u8 != 0
255    }
256}
257impl SUB_ADDRESS_ENABLE_R {
258    #[doc = "Get enumerated values variant"]
259    #[inline(always)]
260    pub fn variant(&self) -> SUB_ADDRESS_ENABLE_A {
261        match self.bits {
262            true => SUB_ADDRESS_ENABLE_A::ENABLE,
263            false => SUB_ADDRESS_ENABLE_A::DISABLE,
264        }
265    }
266    #[doc = "Checks if the value of the field is `ENABLE`"]
267    #[inline(always)]
268    pub fn is_enable(&self) -> bool {
269        *self == SUB_ADDRESS_ENABLE_A::ENABLE
270    }
271    #[doc = "Checks if the value of the field is `DISABLE`"]
272    #[inline(always)]
273    pub fn is_disable(&self) -> bool {
274        *self == SUB_ADDRESS_ENABLE_A::DISABLE
275    }
276}
277#[doc = "Field `sub_address_enable` writer - Enable sub-address fields"]
278pub type SUB_ADDRESS_ENABLE_W<'a, const O: u8> =
279    crate::BitWriter<'a, u32, CONFIG_SPEC, SUB_ADDRESS_ENABLE_A, O>;
280impl<'a, const O: u8> SUB_ADDRESS_ENABLE_W<'a, O> {
281    #[doc = "Enable sub-address fields"]
282    #[inline(always)]
283    pub fn enable(self) -> &'a mut W {
284        self.variant(SUB_ADDRESS_ENABLE_A::ENABLE)
285    }
286    #[doc = "Disable sub-address fields"]
287    #[inline(always)]
288    pub fn disable(self) -> &'a mut W {
289        self.variant(SUB_ADDRESS_ENABLE_A::DISABLE)
290    }
291}
292#[doc = "Field `sub_address_length` reader - Byte count for I2C sub-address"]
293pub type SUB_ADDRESS_LENGTH_R = crate::FieldReader<u8, SUB_ADDRESS_LENGTH_A>;
294#[doc = "Byte count for I2C sub-address\n\nValue on reset: 0"]
295#[derive(Clone, Copy, Debug, PartialEq, Eq)]
296#[repr(u8)]
297pub enum SUB_ADDRESS_LENGTH_A {
298    #[doc = "0: Sub-addresses include 1 byte"]
299    ONE = 0,
300    #[doc = "1: Sub-addresses include 2 bytes"]
301    TWO = 1,
302    #[doc = "2: Sub-addresses include 3 bytes"]
303    THREE = 2,
304    #[doc = "3: Sub-addresses include 4 bytes"]
305    FOUR = 3,
306}
307impl From<SUB_ADDRESS_LENGTH_A> for u8 {
308    #[inline(always)]
309    fn from(variant: SUB_ADDRESS_LENGTH_A) -> Self {
310        variant as _
311    }
312}
313impl SUB_ADDRESS_LENGTH_R {
314    #[doc = "Get enumerated values variant"]
315    #[inline(always)]
316    pub fn variant(&self) -> SUB_ADDRESS_LENGTH_A {
317        match self.bits {
318            0 => SUB_ADDRESS_LENGTH_A::ONE,
319            1 => SUB_ADDRESS_LENGTH_A::TWO,
320            2 => SUB_ADDRESS_LENGTH_A::THREE,
321            3 => SUB_ADDRESS_LENGTH_A::FOUR,
322            _ => unreachable!(),
323        }
324    }
325    #[doc = "Checks if the value of the field is `ONE`"]
326    #[inline(always)]
327    pub fn is_one(&self) -> bool {
328        *self == SUB_ADDRESS_LENGTH_A::ONE
329    }
330    #[doc = "Checks if the value of the field is `TWO`"]
331    #[inline(always)]
332    pub fn is_two(&self) -> bool {
333        *self == SUB_ADDRESS_LENGTH_A::TWO
334    }
335    #[doc = "Checks if the value of the field is `THREE`"]
336    #[inline(always)]
337    pub fn is_three(&self) -> bool {
338        *self == SUB_ADDRESS_LENGTH_A::THREE
339    }
340    #[doc = "Checks if the value of the field is `FOUR`"]
341    #[inline(always)]
342    pub fn is_four(&self) -> bool {
343        *self == SUB_ADDRESS_LENGTH_A::FOUR
344    }
345}
346#[doc = "Field `sub_address_length` writer - Byte count for I2C sub-address"]
347pub type SUB_ADDRESS_LENGTH_W<'a, const O: u8> =
348    crate::FieldWriterSafe<'a, u32, CONFIG_SPEC, u8, SUB_ADDRESS_LENGTH_A, 2, O>;
349impl<'a, const O: u8> SUB_ADDRESS_LENGTH_W<'a, O> {
350    #[doc = "Sub-addresses include 1 byte"]
351    #[inline(always)]
352    pub fn one(self) -> &'a mut W {
353        self.variant(SUB_ADDRESS_LENGTH_A::ONE)
354    }
355    #[doc = "Sub-addresses include 2 bytes"]
356    #[inline(always)]
357    pub fn two(self) -> &'a mut W {
358        self.variant(SUB_ADDRESS_LENGTH_A::TWO)
359    }
360    #[doc = "Sub-addresses include 3 bytes"]
361    #[inline(always)]
362    pub fn three(self) -> &'a mut W {
363        self.variant(SUB_ADDRESS_LENGTH_A::THREE)
364    }
365    #[doc = "Sub-addresses include 4 bytes"]
366    #[inline(always)]
367    pub fn four(self) -> &'a mut W {
368        self.variant(SUB_ADDRESS_LENGTH_A::FOUR)
369    }
370}
371#[doc = "Field `slave_address` reader - I2C transaction slave address"]
372pub type SLAVE_ADDRESS_R = crate::FieldReader<u8, u8>;
373#[doc = "Field `slave_address` writer - I2C transaction slave address"]
374pub type SLAVE_ADDRESS_W<'a, const O: u8> = crate::FieldWriter<'a, u32, CONFIG_SPEC, u8, u8, 7, O>;
375#[doc = "Field `packet_length` reader - Byte count for each packet"]
376pub type PACKET_LENGTH_R = crate::FieldReader<u8, u8>;
377#[doc = "Field `packet_length` writer - Byte count for each packet"]
378pub type PACKET_LENGTH_W<'a, const O: u8> = crate::FieldWriter<'a, u32, CONFIG_SPEC, u8, u8, 8, O>;
379#[doc = "Field `deglitch_cycle` reader - De-glitch function cycle count"]
380pub type DEGLITCH_CYCLE_R = crate::FieldReader<u8, u8>;
381#[doc = "Field `deglitch_cycle` writer - De-glitch function cycle count"]
382pub type DEGLITCH_CYCLE_W<'a, const O: u8> = crate::FieldWriter<'a, u32, CONFIG_SPEC, u8, u8, 4, O>;
383impl R {
384    #[doc = "Bit 0 - Enable signal of I2C master function\n\n Asserting this bit will trigger the transaction, and should be de-asserted after finish."]
385    #[inline(always)]
386    pub fn master_enable(&self) -> MASTER_ENABLE_R {
387        MASTER_ENABLE_R::new((self.bits & 1) != 0)
388    }
389    #[doc = "Bit 1 - Packet transfer direction"]
390    #[inline(always)]
391    pub fn transfer_direction(&self) -> TRANSFER_DIRECTION_R {
392        TRANSFER_DIRECTION_R::new(((self.bits >> 1) & 1) != 0)
393    }
394    #[doc = "Bit 2 - Enable de-glitch function on all input pins"]
395    #[inline(always)]
396    pub fn deglitch_enable(&self) -> DEGLITCH_ENABLE_R {
397        DEGLITCH_ENABLE_R::new(((self.bits >> 2) & 1) != 0)
398    }
399    #[doc = "Bit 3 - Enable I2C clock synchronization\n\n Enable this bit to support multi-master and clock-stretching. It should not be turned-off normally."]
400    #[inline(always)]
401    pub fn clock_synchronize(&self) -> CLOCK_SYNCHRONIZE_R {
402        CLOCK_SYNCHRONIZE_R::new(((self.bits >> 3) & 1) != 0)
403    }
404    #[doc = "Bit 4 - Enable sub-address fields"]
405    #[inline(always)]
406    pub fn sub_address_enable(&self) -> SUB_ADDRESS_ENABLE_R {
407        SUB_ADDRESS_ENABLE_R::new(((self.bits >> 4) & 1) != 0)
408    }
409    #[doc = "Bits 5:6 - Byte count for I2C sub-address"]
410    #[inline(always)]
411    pub fn sub_address_length(&self) -> SUB_ADDRESS_LENGTH_R {
412        SUB_ADDRESS_LENGTH_R::new(((self.bits >> 5) & 3) as u8)
413    }
414    #[doc = "Bits 8:14 - I2C transaction slave address"]
415    #[inline(always)]
416    pub fn slave_address(&self) -> SLAVE_ADDRESS_R {
417        SLAVE_ADDRESS_R::new(((self.bits >> 8) & 0x7f) as u8)
418    }
419    #[doc = "Bits 16:23 - Byte count for each packet"]
420    #[inline(always)]
421    pub fn packet_length(&self) -> PACKET_LENGTH_R {
422        PACKET_LENGTH_R::new(((self.bits >> 16) & 0xff) as u8)
423    }
424    #[doc = "Bits 28:31 - De-glitch function cycle count"]
425    #[inline(always)]
426    pub fn deglitch_cycle(&self) -> DEGLITCH_CYCLE_R {
427        DEGLITCH_CYCLE_R::new(((self.bits >> 28) & 0x0f) as u8)
428    }
429}
430impl W {
431    #[doc = "Bit 0 - Enable signal of I2C master function\n\n Asserting this bit will trigger the transaction, and should be de-asserted after finish."]
432    #[inline(always)]
433    pub fn master_enable(&mut self) -> MASTER_ENABLE_W<0> {
434        MASTER_ENABLE_W::new(self)
435    }
436    #[doc = "Bit 1 - Packet transfer direction"]
437    #[inline(always)]
438    pub fn transfer_direction(&mut self) -> TRANSFER_DIRECTION_W<1> {
439        TRANSFER_DIRECTION_W::new(self)
440    }
441    #[doc = "Bit 2 - Enable de-glitch function on all input pins"]
442    #[inline(always)]
443    pub fn deglitch_enable(&mut self) -> DEGLITCH_ENABLE_W<2> {
444        DEGLITCH_ENABLE_W::new(self)
445    }
446    #[doc = "Bit 3 - Enable I2C clock synchronization\n\n Enable this bit to support multi-master and clock-stretching. It should not be turned-off normally."]
447    #[inline(always)]
448    pub fn clock_synchronize(&mut self) -> CLOCK_SYNCHRONIZE_W<3> {
449        CLOCK_SYNCHRONIZE_W::new(self)
450    }
451    #[doc = "Bit 4 - Enable sub-address fields"]
452    #[inline(always)]
453    pub fn sub_address_enable(&mut self) -> SUB_ADDRESS_ENABLE_W<4> {
454        SUB_ADDRESS_ENABLE_W::new(self)
455    }
456    #[doc = "Bits 5:6 - Byte count for I2C sub-address"]
457    #[inline(always)]
458    pub fn sub_address_length(&mut self) -> SUB_ADDRESS_LENGTH_W<5> {
459        SUB_ADDRESS_LENGTH_W::new(self)
460    }
461    #[doc = "Bits 8:14 - I2C transaction slave address"]
462    #[inline(always)]
463    pub fn slave_address(&mut self) -> SLAVE_ADDRESS_W<8> {
464        SLAVE_ADDRESS_W::new(self)
465    }
466    #[doc = "Bits 16:23 - Byte count for each packet"]
467    #[inline(always)]
468    pub fn packet_length(&mut self) -> PACKET_LENGTH_W<16> {
469        PACKET_LENGTH_W::new(self)
470    }
471    #[doc = "Bits 28:31 - De-glitch function cycle count"]
472    #[inline(always)]
473    pub fn deglitch_cycle(&mut self) -> DEGLITCH_CYCLE_W<28> {
474        DEGLITCH_CYCLE_W::new(self)
475    }
476    #[doc = "Writes raw bits to the register."]
477    #[inline(always)]
478    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
479        self.0.bits(bits);
480        self
481    }
482}
483#[doc = "Function configuration 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 [config](index.html) module"]
484pub struct CONFIG_SPEC;
485impl crate::RegisterSpec for CONFIG_SPEC {
486    type Ux = u32;
487}
488#[doc = "`read()` method returns [config::R](R) reader structure"]
489impl crate::Readable for CONFIG_SPEC {
490    type Reader = R;
491}
492#[doc = "`write(|w| ..)` method takes [config::W](W) writer structure"]
493impl crate::Writable for CONFIG_SPEC {
494    type Writer = W;
495}
496#[doc = "`reset()` method sets config to value 0x0a"]
497impl crate::Resettable for CONFIG_SPEC {
498    #[inline(always)]
499    fn reset_value() -> Self::Ux {
500        0x0a
501    }
502}
bl808_pac/i2c/config.rs

bl808_pac/i2c/
config.rs
