Commit f7fbf309 authored by Daniel Almeida's avatar Daniel Almeida Committed by Mark Brown
Browse files

rust: regulator: remove needless &mut from member functions 



Regulator functions like "regulator_enable()" and "regulator_disable()"
already provide their own locking through "regulator_lock_dependent()", so
we can safely call the Rust API with a shared reference.

This was already the case with Regulator::set_voltage() on the Rust side,
but it was forgotten for Regulator::enable() and Regulator::disable().

Signed-off-by: default avatarDaniel Almeida <daniel.almeida@collabora.com>
Link: https://patch.msgid.link/20250729-regulator-send-sync-v1-1-8bcbd546b940@collabora.com


Reviewed-by: default avatarAlexandre Courbot <acourbot@nvidia.com>
Reviewed-by: default avatarAlice Ryhl <aliceryhl@google.com>
Signed-off-by: default avatarMark Brown <broonie@kernel.org>
parent 8f5ae30d

rust/kernel/regulator.rs

+9 −9
Original line number Diff line number Diff line
@@ -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()

    }

}