Skip to content

Commit

Permalink
raw_read_write
Browse files Browse the repository at this point in the history
  • Loading branch information
@burrbull
burrbull committed May 18, 2024
1 parent 9608246 commit a816243
Show file tree
Hide file tree
Showing 7 changed files with 584 additions and 247 deletions.
1 change: 1 addition & 0 deletions CHANGELOG.md
View file
Original file line number Diff line number Diff line change
Expand Up @@ -7,6 +7,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/).

## [Unreleased]

- Add `raw-access` options
- Refactor `Accessor`

## [v0.33.3] - 2024-05-10
Expand Down
19 changes: 14 additions & 5 deletions src/generate/device.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -63,8 +63,12 @@ pub fn render(d: &Device, config: &Config, device_x: &mut String) -> Result<Toke

out.extend(quote! {
use core::ops::Deref;
use core::marker::PhantomData;
});
if !config.raw_access {
out.extend(quote! {
use core::marker::PhantomData;
});
}

// Retaining the previous assumption
let mut fpu_present = true;
Expand Down Expand Up @@ -140,6 +144,11 @@ pub fn render(d: &Device, config: &Config, device_x: &mut String) -> Result<Toke
}

let generic_file = include_str!("generic.rs");
let generic_reg_file = if config.raw_access {
include_str!("generic_reg_raw.rs")
} else {
include_str!("generic_reg_vcell.rs")
};
let generic_atomic_file = include_str!("generic_atomic.rs");
if config.generic_mod {
let mut file = File::create(
Expand All @@ -150,6 +159,7 @@ pub fn render(d: &Device, config: &Config, device_x: &mut String) -> Result<Toke
.join("generic.rs"),
)?;
writeln!(file, "{generic_file}")?;
writeln!(file, "{generic_reg_file}")?;
if config.atomics {
if let Some(atomics_feature) = config.atomics_feature.as_ref() {
writeln!(file, "#[cfg(feature = \"{atomics_feature}\")]")?;
Expand All @@ -167,6 +177,7 @@ pub fn render(d: &Device, config: &Config, device_x: &mut String) -> Result<Toke
}
} else {
let mut tokens = syn::parse_file(generic_file)?.into_token_stream();
syn::parse_file(generic_reg_file)?.to_tokens(&mut tokens);
if config.atomics {
if let Some(atomics_feature) = config.atomics_feature.as_ref() {
quote!(#[cfg(feature = #atomics_feature)]).to_tokens(&mut tokens);
Expand Down Expand Up @@ -246,9 +257,7 @@ pub fn render(d: &Device, config: &Config, device_x: &mut String) -> Result<Toke
#feature_attribute
pub #p_singleton: #p_ty,
});
exprs.extend(
quote!(#feature_attribute #p_singleton: #p_ty { _marker: PhantomData },),
);
exprs.extend(quote!(#feature_attribute #p_singleton: unsafe { #p_ty::steal() },));
}
Peripheral::Array(p, dim_element) => {
for p_name in names(p, dim_element) {
Expand All @@ -264,7 +273,7 @@ pub fn render(d: &Device, config: &Config, device_x: &mut String) -> Result<Toke
pub #p_singleton: #p_ty,
});
exprs.extend(
quote!(#feature_attribute #p_singleton: #p_ty { _marker: PhantomData },),
quote!(#feature_attribute #p_singleton: unsafe { #p_ty::steal() },),
);
}
}
Expand Down
172 changes: 0 additions & 172 deletions src/generate/generic.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -95,178 +95,6 @@ pub trait Resettable: RegisterSpec {
}
}

/// This structure provides volatile access to registers.
#[repr(transparent)]
pub struct Reg<REG: RegisterSpec> {
register: vcell::VolatileCell<REG::Ux>,
_marker: marker::PhantomData<REG>,
}

unsafe impl<REG: RegisterSpec> Send for Reg<REG> where REG::Ux: Send {}

impl<REG: RegisterSpec> Reg<REG> {
/// Returns the underlying memory address of register.
///
/// ```ignore
/// let reg_ptr = periph.reg.as_ptr();
/// ```
#[inline(always)]
pub fn as_ptr(&self) -> *mut REG::Ux {
self.register.as_ptr()
}
}

impl<REG: Readable> Reg<REG> {
/// Reads the contents of a `Readable` register.
///
/// You can read the raw contents of a register by using `bits`:
/// ```ignore
/// let bits = periph.reg.read().bits();
/// ```
/// or get the content of a particular field of a register:
/// ```ignore
/// let reader = periph.reg.read();
/// let bits = reader.field1().bits();
/// let flag = reader.field2().bit_is_set();
/// ```
#[inline(always)]
pub fn read(&self) -> R<REG> {
R {
bits: self.register.get(),
_reg: marker::PhantomData,
}
}
}

impl<REG: Resettable + Writable> Reg<REG> {
/// Writes the reset value to `Writable` register.
///
/// Resets the register to its initial state.
#[inline(always)]
pub fn reset(&self) {
self.register.set(REG::RESET_VALUE)
}

/// Writes bits to a `Writable` register.
///
/// You can write raw bits into a register:
/// ```ignore
/// periph.reg.write(|w| unsafe { w.bits(rawbits) });
/// ```
/// or write only the fields you need:
/// ```ignore
/// periph.reg.write(|w| w
/// .field1().bits(newfield1bits)
/// .field2().set_bit()
/// .field3().variant(VARIANT)
/// );
/// ```
/// or an alternative way of saying the same:
/// ```ignore
/// periph.reg.write(|w| {
/// w.field1().bits(newfield1bits);
/// w.field2().set_bit();
/// w.field3().variant(VARIANT)
/// });
/// ```
/// In the latter case, other fields will be set to their reset value.
#[inline(always)]
pub fn write<F>(&self, f: F)
where
F: FnOnce(&mut W<REG>) -> &mut W<REG>,
{
self.register.set(
f(&mut W {
bits: REG::RESET_VALUE & !REG::ONE_TO_MODIFY_FIELDS_BITMAP
| REG::ZERO_TO_MODIFY_FIELDS_BITMAP,
_reg: marker::PhantomData,
})
.bits,
);
}
}

impl<REG: Writable> Reg<REG> {
/// Writes 0 to a `Writable` register.
///
/// Similar to `write`, but unused bits will contain 0.
///
/// # Safety
///
/// Unsafe to use with registers which don't allow to write 0.
#[inline(always)]
pub unsafe fn write_with_zero<F>(&self, f: F)
where
F: FnOnce(&mut W<REG>) -> &mut W<REG>,
{
self.register.set(
f(&mut W {
bits: REG::Ux::default(),
_reg: marker::PhantomData,
})
.bits,
);
}
}

impl<REG: Readable + Writable> Reg<REG> {
/// Modifies the contents of the register by reading and then writing it.
///
/// E.g. to do a read-modify-write sequence to change parts of a register:
/// ```ignore
/// periph.reg.modify(|r, w| unsafe { w.bits(
/// r.bits() | 3
/// ) });
/// ```
/// or
/// ```ignore
/// periph.reg.modify(|_, w| w
/// .field1().bits(newfield1bits)
/// .field2().set_bit()
/// .field3().variant(VARIANT)
/// );
/// ```
/// or an alternative way of saying the same:
/// ```ignore
/// periph.reg.modify(|_, w| {
/// w.field1().bits(newfield1bits);
/// w.field2().set_bit();
/// w.field3().variant(VARIANT)
/// });
/// ```
/// Other fields will have the value they had before the call to `modify`.
#[inline(always)]
pub fn modify<F>(&self, f: F)
where
for<'w> F: FnOnce(&R<REG>, &'w mut W<REG>) -> &'w mut W<REG>,
{
let bits = self.register.get();
self.register.set(
f(
&R {
bits,
_reg: marker::PhantomData,
},
&mut W {
bits: bits & !REG::ONE_TO_MODIFY_FIELDS_BITMAP
| REG::ZERO_TO_MODIFY_FIELDS_BITMAP,
_reg: marker::PhantomData,
},
)
.bits,
);
}
}

impl<REG: Readable> core::fmt::Debug for crate::generic::Reg<REG>
where
R<REG>: core::fmt::Debug
{
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
core::fmt::Debug::fmt(&self.read(), f)
}
}

#[doc(hidden)]
pub mod raw {
use super::{marker, BitM, FieldSpec, RegisterSpec, Unsafe, Writable};
Expand Down
Loading

0 comments on commit a816243

Please sign in to comment.