rp2040_pac/
generic.rs

Help
1use core::marker;
2#[doc = " Raw register type (`u8`, `u16`, `u32`, ...)"]
3pub trait RawReg:
4    Copy
5    + Default
6    + From<bool>
7    + core::ops::BitOr<Output = Self>
8    + core::ops::BitAnd<Output = Self>
9    + core::ops::BitOrAssign
10    + core::ops::BitAndAssign
11    + core::ops::Not<Output = Self>
12    + core::ops::Shl<u8, Output = Self>
13{
14    #[doc = " Mask for bits of width `WI`"]
15    fn mask<const WI: u8>() -> Self;
16    #[doc = " Mask for bits of width 1"]
17    fn one() -> Self;
18}
19macro_rules! raw_reg {
20    ($ U : ty , $ size : literal , $ mask : ident) => {
21        impl RawReg for $U {
22            #[inline(always)]
23            fn mask<const WI: u8>() -> Self {
24                $mask::<WI>()
25            }
26            #[inline(always)]
27            fn one() -> Self {
28                1
29            }
30        }
31        const fn $mask<const WI: u8>() -> $U {
32            <$U>::MAX >> ($size - WI)
33        }
34        impl FieldSpec for $U {
35            type Ux = $U;
36        }
37    };
38}
39raw_reg!(u8, 8, mask_u8);
40raw_reg!(u16, 16, mask_u16);
41raw_reg!(u32, 32, mask_u32);
42raw_reg!(u64, 64, mask_u64);
43#[doc = " Raw register type"]
44pub trait RegisterSpec {
45    #[doc = " Raw register type (`u8`, `u16`, `u32`, ...)."]
46    type Ux: RawReg;
47}
48#[doc = " Raw field type"]
49pub trait FieldSpec: Sized {
50    #[doc = " Raw field type (`u8`, `u16`, `u32`, ...)."]
51    type Ux: Copy + PartialEq + From<Self>;
52}
53#[doc = " Trait implemented by readable registers to enable the `read` method."]
54#[doc = ""]
55#[doc = " Registers marked with `Writable` can be also be `modify`'ed."]
56pub trait Readable: RegisterSpec {}
57#[doc = " Trait implemented by writeable registers."]
58#[doc = ""]
59#[doc = " This enables the  `write`, `write_with_zero` and `reset` methods."]
60#[doc = ""]
61#[doc = " Registers marked with `Readable` can be also be `modify`'ed."]
62pub trait Writable: RegisterSpec {
63    #[doc = " Specifies the register bits that are not changed if you pass `1` and are changed if you pass `0`"]
64    const ZERO_TO_MODIFY_FIELDS_BITMAP: Self::Ux;
65    #[doc = " Specifies the register bits that are not changed if you pass `0` and are changed if you pass `1`"]
66    const ONE_TO_MODIFY_FIELDS_BITMAP: Self::Ux;
67}
68#[doc = " Reset value of the register."]
69#[doc = ""]
70#[doc = " This value is the initial value for the `write` method. It can also be directly written to the"]
71#[doc = " register by using the `reset` method."]
72pub trait Resettable: RegisterSpec {
73    #[doc = " Reset value of the register."]
74    const RESET_VALUE: Self::Ux;
75    #[doc = " Reset value of the register."]
76    #[inline(always)]
77    fn reset_value() -> Self::Ux {
78        Self::RESET_VALUE
79    }
80}
81#[doc = " This structure provides volatile access to registers."]
82#[repr(transparent)]
83pub struct Reg<REG: RegisterSpec> {
84    register: vcell::VolatileCell<REG::Ux>,
85    _marker: marker::PhantomData<REG>,
86}
87unsafe impl<REG: RegisterSpec> Send for Reg<REG> where REG::Ux: Send {}
88impl<REG: RegisterSpec> Reg<REG> {
89    #[doc = " Returns the underlying memory address of register."]
90    #[doc = ""]
91    #[doc = " ```ignore"]
92    #[doc = " let reg_ptr = periph.reg.as_ptr();"]
93    #[doc = " ```"]
94    #[inline(always)]
95    pub fn as_ptr(&self) -> *mut REG::Ux {
96        self.register.as_ptr()
97    }
98}
99impl<REG: Readable> Reg<REG> {
100    #[doc = " Reads the contents of a `Readable` register."]
101    #[doc = ""]
102    #[doc = " You can read the raw contents of a register by using `bits`:"]
103    #[doc = " ```ignore"]
104    #[doc = " let bits = periph.reg.read().bits();"]
105    #[doc = " ```"]
106    #[doc = " or get the content of a particular field of a register:"]
107    #[doc = " ```ignore"]
108    #[doc = " let reader = periph.reg.read();"]
109    #[doc = " let bits = reader.field1().bits();"]
110    #[doc = " let flag = reader.field2().bit_is_set();"]
111    #[doc = " ```"]
112    #[inline(always)]
113    pub fn read(&self) -> R<REG> {
114        R {
115            bits: self.register.get(),
116            _reg: marker::PhantomData,
117        }
118    }
119}
120impl<REG: Resettable + Writable> Reg<REG> {
121    #[doc = " Writes the reset value to `Writable` register."]
122    #[doc = ""]
123    #[doc = " Resets the register to its initial state."]
124    #[inline(always)]
125    pub fn reset(&self) {
126        self.register.set(REG::RESET_VALUE)
127    }
128    #[doc = " Writes bits to a `Writable` register."]
129    #[doc = ""]
130    #[doc = " You can write raw bits into a register:"]
131    #[doc = " ```ignore"]
132    #[doc = " periph.reg.write(|w| unsafe { w.bits(rawbits) });"]
133    #[doc = " ```"]
134    #[doc = " or write only the fields you need:"]
135    #[doc = " ```ignore"]
136    #[doc = " periph.reg.write(|w| w"]
137    #[doc = "     .field1().bits(newfield1bits)"]
138    #[doc = "     .field2().set_bit()"]
139    #[doc = "     .field3().variant(VARIANT)"]
140    #[doc = " );"]
141    #[doc = " ```"]
142    #[doc = " or an alternative way of saying the same:"]
143    #[doc = " ```ignore"]
144    #[doc = " periph.reg.write(|w| {"]
145    #[doc = "     w.field1().bits(newfield1bits);"]
146    #[doc = "     w.field2().set_bit();"]
147    #[doc = "     w.field3().variant(VARIANT)"]
148    #[doc = " });"]
149    #[doc = " ```"]
150    #[doc = " In the latter case, other fields will be set to their reset value."]
151    #[inline(always)]
152    pub fn write<F>(&self, f: F)
153    where
154        F: FnOnce(&mut W<REG>) -> &mut W<REG>,
155    {
156        self.register.set(
157            f(&mut W {
158                bits: REG::RESET_VALUE & !REG::ONE_TO_MODIFY_FIELDS_BITMAP
159                    | REG::ZERO_TO_MODIFY_FIELDS_BITMAP,
160                _reg: marker::PhantomData,
161            })
162            .bits,
163        );
164    }
165}
166impl<REG: Writable> Reg<REG> {
167    #[doc = " Writes 0 to a `Writable` register."]
168    #[doc = ""]
169    #[doc = " Similar to `write`, but unused bits will contain 0."]
170    #[doc = ""]
171    #[doc = " # Safety"]
172    #[doc = ""]
173    #[doc = " Unsafe to use with registers which don't allow to write 0."]
174    #[inline(always)]
175    pub unsafe fn write_with_zero<F>(&self, f: F)
176    where
177        F: FnOnce(&mut W<REG>) -> &mut W<REG>,
178    {
179        self.register.set(
180            f(&mut W {
181                bits: REG::Ux::default(),
182                _reg: marker::PhantomData,
183            })
184            .bits,
185        );
186    }
187}
188impl<REG: Readable + Writable> Reg<REG> {
189    #[doc = " Modifies the contents of the register by reading and then writing it."]
190    #[doc = ""]
191    #[doc = " E.g. to do a read-modify-write sequence to change parts of a register:"]
192    #[doc = " ```ignore"]
193    #[doc = " periph.reg.modify(|r, w| unsafe { w.bits("]
194    #[doc = "    r.bits() | 3"]
195    #[doc = " ) });"]
196    #[doc = " ```"]
197    #[doc = " or"]
198    #[doc = " ```ignore"]
199    #[doc = " periph.reg.modify(|_, w| w"]
200    #[doc = "     .field1().bits(newfield1bits)"]
201    #[doc = "     .field2().set_bit()"]
202    #[doc = "     .field3().variant(VARIANT)"]
203    #[doc = " );"]
204    #[doc = " ```"]
205    #[doc = " or an alternative way of saying the same:"]
206    #[doc = " ```ignore"]
207    #[doc = " periph.reg.modify(|_, w| {"]
208    #[doc = "     w.field1().bits(newfield1bits);"]
209    #[doc = "     w.field2().set_bit();"]
210    #[doc = "     w.field3().variant(VARIANT)"]
211    #[doc = " });"]
212    #[doc = " ```"]
213    #[doc = " Other fields will have the value they had before the call to `modify`."]
214    #[inline(always)]
215    pub fn modify<F>(&self, f: F)
216    where
217        for<'w> F: FnOnce(&R<REG>, &'w mut W<REG>) -> &'w mut W<REG>,
218    {
219        let bits = self.register.get();
220        self.register.set(
221            f(
222                &R {
223                    bits,
224                    _reg: marker::PhantomData,
225                },
226                &mut W {
227                    bits: bits & !REG::ONE_TO_MODIFY_FIELDS_BITMAP
228                        | REG::ZERO_TO_MODIFY_FIELDS_BITMAP,
229                    _reg: marker::PhantomData,
230                },
231            )
232            .bits,
233        );
234    }
235}
236#[doc(hidden)]
237pub mod raw;
238#[doc = " Register reader."]
239#[doc = ""]
240#[doc = " Result of the `read` methods of registers. Also used as a closure argument in the `modify`"]
241#[doc = " method."]
242pub type R<REG> = raw::R<REG>;
243impl<REG: RegisterSpec> R<REG> {
244    #[doc = " Reads raw bits from register."]
245    #[inline(always)]
246    pub const fn bits(&self) -> REG::Ux {
247        self.bits
248    }
249}
250impl<REG: RegisterSpec, FI> PartialEq<FI> for R<REG>
251where
252    REG::Ux: PartialEq,
253    FI: Copy,
254    REG::Ux: From<FI>,
255{
256    #[inline(always)]
257    fn eq(&self, other: &FI) -> bool {
258        self.bits.eq(&REG::Ux::from(*other))
259    }
260}
261#[doc = " Register writer."]
262#[doc = ""]
263#[doc = " Used as an argument to the closures in the `write` and `modify` methods of the register."]
264pub type W<REG> = raw::W<REG>;
265#[doc = " Field reader."]
266#[doc = ""]
267#[doc = " Result of the `read` methods of fields."]
268pub type FieldReader<FI = u8> = raw::FieldReader<FI>;
269#[doc = " Bit-wise field reader"]
270pub type BitReader<FI = bool> = raw::BitReader<FI>;
271impl<FI: FieldSpec> FieldReader<FI> {
272    #[doc = " Reads raw bits from field."]
273    #[inline(always)]
274    pub const fn bits(&self) -> FI::Ux {
275        self.bits
276    }
277}
278impl<FI> PartialEq<FI> for FieldReader<FI>
279where
280    FI: FieldSpec + Copy,
281{
282    #[inline(always)]
283    fn eq(&self, other: &FI) -> bool {
284        self.bits.eq(&FI::Ux::from(*other))
285    }
286}
287impl<FI> PartialEq<FI> for BitReader<FI>
288where
289    FI: Copy,
290    bool: From<FI>,
291{
292    #[inline(always)]
293    fn eq(&self, other: &FI) -> bool {
294        self.bits.eq(&bool::from(*other))
295    }
296}
297impl<FI> BitReader<FI> {
298    #[doc = " Value of the field as raw bits."]
299    #[inline(always)]
300    pub const fn bit(&self) -> bool {
301        self.bits
302    }
303    #[doc = " Returns `true` if the bit is clear (0)."]
304    #[inline(always)]
305    pub const fn bit_is_clear(&self) -> bool {
306        !self.bit()
307    }
308    #[doc = " Returns `true` if the bit is set (1)."]
309    #[inline(always)]
310    pub const fn bit_is_set(&self) -> bool {
311        self.bit()
312    }
313}
314#[doc(hidden)]
315pub struct Safe;
316#[doc(hidden)]
317pub struct Unsafe;
318#[doc = " Write field Proxy with unsafe `bits`"]
319pub type FieldWriter<'a, REG, const WI: u8, FI = u8> = raw::FieldWriter<'a, REG, WI, FI, Unsafe>;
320#[doc = " Write field Proxy with safe `bits`"]
321pub type FieldWriterSafe<'a, REG, const WI: u8, FI = u8> = raw::FieldWriter<'a, REG, WI, FI, Safe>;
322impl<'a, REG, const WI: u8, FI> FieldWriter<'a, REG, WI, FI>
323where
324    REG: Writable + RegisterSpec,
325    FI: FieldSpec,
326    REG::Ux: From<FI::Ux>,
327{
328    #[doc = " Field width"]
329    pub const WIDTH: u8 = WI;
330    #[doc = " Field width"]
331    #[inline(always)]
332    pub const fn width(&self) -> u8 {
333        WI
334    }
335    #[doc = " Field offset"]
336    #[inline(always)]
337    pub const fn offset(&self) -> u8 {
338        self.o
339    }
340    #[doc = " Writes raw bits to the field"]
341    #[doc = ""]
342    #[doc = " # Safety"]
343    #[doc = ""]
344    #[doc = " Passing incorrect value can cause undefined behaviour. See reference manual"]
345    #[inline(always)]
346    pub unsafe fn bits(self, value: FI::Ux) -> &'a mut W<REG> {
347        self.w.bits &= !(REG::Ux::mask::<WI>() << self.o);
348        self.w.bits |= (REG::Ux::from(value) & REG::Ux::mask::<WI>()) << self.o;
349        self.w
350    }
351    #[doc = " Writes `variant` to the field"]
352    #[inline(always)]
353    pub fn variant(self, variant: FI) -> &'a mut W<REG> {
354        unsafe { self.bits(FI::Ux::from(variant)) }
355    }
356}
357impl<'a, REG, const WI: u8, FI> FieldWriterSafe<'a, REG, WI, FI>
358where
359    REG: Writable + RegisterSpec,
360    FI: FieldSpec,
361    REG::Ux: From<FI::Ux>,
362{
363    #[doc = " Field width"]
364    pub const WIDTH: u8 = WI;
365    #[doc = " Field width"]
366    #[inline(always)]
367    pub const fn width(&self) -> u8 {
368        WI
369    }
370    #[doc = " Field offset"]
371    #[inline(always)]
372    pub const fn offset(&self) -> u8 {
373        self.o
374    }
375    #[doc = " Writes raw bits to the field"]
376    #[inline(always)]
377    pub fn bits(self, value: FI::Ux) -> &'a mut W<REG> {
378        self.w.bits &= !(REG::Ux::mask::<WI>() << self.o);
379        self.w.bits |= (REG::Ux::from(value) & REG::Ux::mask::<WI>()) << self.o;
380        self.w
381    }
382    #[doc = " Writes `variant` to the field"]
383    #[inline(always)]
384    pub fn variant(self, variant: FI) -> &'a mut W<REG> {
385        self.bits(FI::Ux::from(variant))
386    }
387}
388macro_rules! bit_proxy {
389    ($ writer : ident , $ mwv : ident) => {
390        #[doc(hidden)]
391        pub struct $mwv;
392        #[doc = " Bit-wise write field proxy"]
393        pub type $writer<'a, REG, FI = bool> = raw::BitWriter<'a, REG, FI, $mwv>;
394        impl<'a, REG, FI> $writer<'a, REG, FI>
395        where
396            REG: Writable + RegisterSpec,
397            bool: From<FI>,
398        {
399            #[doc = " Field width"]
400            pub const WIDTH: u8 = 1;
401            #[doc = " Field width"]
402            #[inline(always)]
403            pub const fn width(&self) -> u8 {
404                Self::WIDTH
405            }
406            #[doc = " Field offset"]
407            #[inline(always)]
408            pub const fn offset(&self) -> u8 {
409                self.o
410            }
411            #[doc = " Writes bit to the field"]
412            #[inline(always)]
413            pub fn bit(self, value: bool) -> &'a mut W<REG> {
414                self.w.bits &= !(REG::Ux::one() << self.o);
415                self.w.bits |= (REG::Ux::from(value) & REG::Ux::one()) << self.o;
416                self.w
417            }
418            #[doc = " Writes `variant` to the field"]
419            #[inline(always)]
420            pub fn variant(self, variant: FI) -> &'a mut W<REG> {
421                self.bit(bool::from(variant))
422            }
423        }
424    };
425}
426bit_proxy!(BitWriter, BitM);
427bit_proxy!(BitWriter1S, Bit1S);
428bit_proxy!(BitWriter0C, Bit0C);
429bit_proxy!(BitWriter1C, Bit1C);
430bit_proxy!(BitWriter0S, Bit0S);
431bit_proxy!(BitWriter1T, Bit1T);
432bit_proxy!(BitWriter0T, Bit0T);
433impl<'a, REG, FI> BitWriter<'a, REG, FI>
434where
435    REG: Writable + RegisterSpec,
436    bool: From<FI>,
437{
438    #[doc = " Sets the field bit"]
439    #[inline(always)]
440    pub fn set_bit(self) -> &'a mut W<REG> {
441        self.w.bits |= REG::Ux::one() << self.o;
442        self.w
443    }
444    #[doc = " Clears the field bit"]
445    #[inline(always)]
446    pub fn clear_bit(self) -> &'a mut W<REG> {
447        self.w.bits &= !(REG::Ux::one() << self.o);
448        self.w
449    }
450}
451impl<'a, REG, FI> BitWriter1S<'a, REG, FI>
452where
453    REG: Writable + RegisterSpec,
454    bool: From<FI>,
455{
456    #[doc = " Sets the field bit"]
457    #[inline(always)]
458    pub fn set_bit(self) -> &'a mut W<REG> {
459        self.w.bits |= REG::Ux::one() << self.o;
460        self.w
461    }
462}
463impl<'a, REG, FI> BitWriter0C<'a, REG, FI>
464where
465    REG: Writable + RegisterSpec,
466    bool: From<FI>,
467{
468    #[doc = " Clears the field bit"]
469    #[inline(always)]
470    pub fn clear_bit(self) -> &'a mut W<REG> {
471        self.w.bits &= !(REG::Ux::one() << self.o);
472        self.w
473    }
474}
475impl<'a, REG, FI> BitWriter1C<'a, REG, FI>
476where
477    REG: Writable + RegisterSpec,
478    bool: From<FI>,
479{
480    #[doc = "Clears the field bit by passing one"]
481    #[inline(always)]
482    pub fn clear_bit_by_one(self) -> &'a mut W<REG> {
483        self.w.bits |= REG::Ux::one() << self.o;
484        self.w
485    }
486}
487impl<'a, REG, FI> BitWriter0S<'a, REG, FI>
488where
489    REG: Writable + RegisterSpec,
490    bool: From<FI>,
491{
492    #[doc = "Sets the field bit by passing zero"]
493    #[inline(always)]
494    pub fn set_bit_by_zero(self) -> &'a mut W<REG> {
495        self.w.bits &= !(REG::Ux::one() << self.o);
496        self.w
497    }
498}
499impl<'a, REG, FI> BitWriter1T<'a, REG, FI>
500where
501    REG: Writable + RegisterSpec,
502    bool: From<FI>,
503{
504    #[doc = "Toggle the field bit by passing one"]
505    #[inline(always)]
506    pub fn toggle_bit(self) -> &'a mut W<REG> {
507        self.w.bits |= REG::Ux::one() << self.o;
508        self.w
509    }
510}
511impl<'a, REG, FI> BitWriter0T<'a, REG, FI>
512where
513    REG: Writable + RegisterSpec,
514    bool: From<FI>,
515{
516    #[doc = "Toggle the field bit by passing zero"]
517    #[inline(always)]
518    pub fn toggle_bit(self) -> &'a mut W<REG> {
519        self.w.bits &= !(REG::Ux::one() << self.o);
520        self.w
521    }
522}
rp2040_pac/generic.rs

rp2040_pac/
generic.rs
