github-mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-05-25 07:33:19 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity Graph

rust: regulator: relax a few constraints on

Browse Source 
Merge series from Daniel Almeida <daniel.almeida@collabora.com>:

This series implement two related changes to address a bit of an oversight
on my end on the initial patch for the Regulator abstraction. Note that
this is not a fix, as it just relaxes the constraints on the previous code
as it is safe to do so.

Patch 1 removes some needless &mut self for functions that already provide
their own locking on the C side.

Patch 2 implements Send and Sync. In particular, there is no reason for
Regulator<T> not to be Send, and as discussed above, it is naturally Sync.
This commit is contained in:
Mark Brown 2025-08-12 12:06:23 +01:00
commit eb9bb4c5b5
No known key found for this signature in database
GPG Key ID: 24D68B725D5487D0
1 changed files with 17 additions and 9 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
rust/kernel/regulator.rs
View File

@ -203,20 +203,20 @@ pub struct Error<State: RegulatorState> {
/// // A fictictious probe function that obtains a regulator and sets it up.
/// fn probe(dev: &Device) -> Result<PrivateData> {
/// // Obtain a reference to a (fictitious) regulator.
/// let mut regulator = Regulator::<Dynamic>::get(dev, c_str!("vcc"))?;
/// let regulator = Regulator::<Dynamic>::get(dev, c_str!("vcc"))?;
///
/// Ok(PrivateData { regulator })
/// }
///
/// // A fictictious function that indicates that the device is going to be used.
/// fn open(dev: &Device, data: &mut PrivateData) -> Result {
/// fn open(dev: &Device, data: &PrivateData) -> Result {
/// // Increase the `enabled` reference count.
/// data.regulator.enable()?;
///
/// Ok(())
/// }
///
/// fn close(dev: &Device, data: &mut PrivateData) -> Result {
/// fn close(dev: &Device, data: &PrivateData) -> Result {
/// // Decrease the `enabled` reference count.
/// data.regulator.disable()?;
///
@ -289,12 +289,12 @@ fn get_internal(dev: &Device, name: &CStr) -> Result<Regulator<T>> {
})
}
fn enable_internal(&mut self) -> Result {
fn enable_internal(&self) -> Result {
// SAFETY: Safe as per the type invariants of `Regulator`.
to_result(unsafe { bindings::regulator_enable(self.inner.as_ptr()) })
}
fn disable_internal(&mut self) -> Result {
fn disable_internal(&self) -> Result {
// SAFETY: Safe as per the type invariants of `Regulator`.
to_result(unsafe { bindings::regulator_disable(self.inner.as_ptr()) })
}
@ -310,7 +310,7 @@ pub fn get(dev: &Device, name: &CStr) -> Result<Self> {
pub fn try_into_enabled(self) -> Result<Regulator<Enabled>, Error<Disabled>> {
// We will be transferring the ownership of our `regulator_get()` count to
// `Regulator<Enabled>`.
let mut regulator = ManuallyDrop::new(self);
let regulator = ManuallyDrop::new(self);
regulator
.enable_internal()
@ -339,7 +339,7 @@ pub fn get(dev: &Device, name: &CStr) -> Result<Self> {
pub fn try_into_disabled(self) -> Result<Regulator<Disabled>, Error<Enabled>> {
// We will be transferring the ownership of our `regulator_get()` count
// to `Regulator<Disabled>`.
let mut regulator = ManuallyDrop::new(self);
let regulator = ManuallyDrop::new(self);
regulator
.disable_internal()
@ -366,12 +366,12 @@ pub fn get(dev: &Device, name: &CStr) -> Result<Self> {
}
/// Increases the `enabled` reference count.
pub fn enable(&mut self) -> Result {
pub fn enable(&self) -> Result {
self.enable_internal()
}
/// Decreases the `enabled` reference count.
pub fn disable(&mut self) -> Result {
pub fn disable(&self) -> Result {
self.disable_internal()
}
}
@ -398,6 +398,14 @@ fn drop(&mut self) {
}
}
// SAFETY: It is safe to send a `Regulator<T>` across threads. In particular, a
// Regulator<T> can be dropped from any thread.
unsafe impl<T: RegulatorState> Send for Regulator<T> {}
// SAFETY: It is safe to send a &Regulator<T> across threads because the C side
// handles its own locking.
unsafe impl<T: RegulatorState> Sync for Regulator<T> {}
/// A voltage.
///
/// This type represents a voltage value in microvolts.