Commit 6fe9e919 authored by Miguel Ojeda's avatar Miguel Ojeda Committed by Uwe Kleine-König
Browse files

pwm: Fix Rust formatting 

We do our best to keep the repository `rustfmt`-clean [1], thus run the
tool to fix the formatting issue.

A trailing empty comment [2] is added in order to preserve the wanted
style for imports (otherwise the tool will compact the first two items).

Link: https://rust-for-linux.com/contributing#submit-checklist-addendum [1]
Link: https://docs.kernel.org/rust/coding-guidelines.html#style-formatting

 [2]
Fixes: d8046cd5 ("rust: pwm: Add complete abstraction layer")
Fixes: 7b3dce81 ("rust: pwm: Add Kconfig and basic data structures")
Fixes: e03724aa ("pwm: Add Rust driver for T-HEAD TH1520 SoC")
Signed-off-by: default avatarMiguel Ojeda <ojeda@kernel.org>
Link: https://patch.msgid.link/20251029182502.783392-1-ojeda@kernel.org


Signed-off-by: default avatarUwe Kleine-König <ukleinek@kernel.org>
parent a367b64b

drivers/pwm/pwm_th1520.rs

+12 −3
Original line number Diff line number Diff line
@@ -200,7 +200,10 @@ fn round_waveform_fromhw( 
        let rate_hz = data.clk.rate().as_hz() as u64;



        if wfhw.period_cycles == 0 {

            dev_dbg!(chip.device(), "HW state has zero period, reporting as disabled.\n");

            dev_dbg!(

                chip.device(),

                "HW state has zero period, reporting as disabled.\n"

            );

            *wf = pwm::Waveform::default();

            return Ok(());

        }
@@ -277,7 +280,10 @@ fn write_waveform( 
            if was_enabled {

                iomap.try_write32(wfhw.ctrl_val, th1520_pwm_ctrl(hwpwm))?;

                iomap.try_write32(0, th1520_pwm_fp(hwpwm))?;

                iomap.try_write32(wfhw.ctrl_val | TH1520_PWM_CFG_UPDATE, th1520_pwm_ctrl(hwpwm))?;

                iomap.try_write32(

                    wfhw.ctrl_val | TH1520_PWM_CFG_UPDATE,

                    th1520_pwm_ctrl(hwpwm),

                )?;

            }

            return Ok(());

        }
@@ -285,7 +291,10 @@ fn write_waveform( 
        iomap.try_write32(wfhw.ctrl_val, th1520_pwm_ctrl(hwpwm))?;

        iomap.try_write32(wfhw.period_cycles, th1520_pwm_per(hwpwm))?;

        iomap.try_write32(wfhw.duty_cycles, th1520_pwm_fp(hwpwm))?;

        iomap.try_write32(wfhw.ctrl_val | TH1520_PWM_CFG_UPDATE, th1520_pwm_ctrl(hwpwm))?;

        iomap.try_write32(

            wfhw.ctrl_val | TH1520_PWM_CFG_UPDATE,

            th1520_pwm_ctrl(hwpwm),

        )?;



        // The `TH1520_PWM_START` bit must be written in a separate, final transaction, and

        // only when enabling the channel from a disabled state.

rust/kernel/lib.rs

+2 −2
Original line number Diff line number Diff line
@@ -121,6 +121,8 @@ 
pub mod print;

pub mod processor;

pub mod ptr;

#[cfg(CONFIG_RUST_PWM_ABSTRACTIONS)]

pub mod pwm;

pub mod rbtree;

pub mod regulator;

pub mod revocable;
@@ -129,8 +131,6 @@ 
pub mod seq_file;

pub mod sizes;

mod static_assert;

#[cfg(CONFIG_RUST_PWM_ABSTRACTIONS)]

pub mod pwm;

#[doc(hidden)]

pub mod std_vendor;

pub mod str;

rust/kernel/pwm.rs

+25 −21
Original line number Diff line number Diff line
@@ -13,7 +13,7 @@ 
    devres,

    error::{self, to_result},

    prelude::*,

    types::{ARef, AlwaysRefCounted, Opaque},

    types::{ARef, AlwaysRefCounted, Opaque}, //

};

use core::{marker::PhantomData, ptr::NonNull};
@@ -109,7 +109,7 @@ pub fn label(&self) -> Option<&CStr> { 
        // SAFETY: self.as_raw() provides a valid pointer.

        let label_ptr = unsafe { (*self.as_raw()).label };

        if label_ptr.is_null() {

            return None

            return None;

        }



        // SAFETY: label_ptr is non-null and points to a C string
@@ -180,11 +180,7 @@ pub trait PwmOps: 'static + Sized { 
    type WfHw: Copy + Default;



    /// Optional hook for when a PWM device is requested.

    fn request(

        _chip: &Chip<Self>,

        _pwm: &Device,

        _parent_dev: &device::Device<Bound>,

    ) -> Result {

    fn request(_chip: &Chip<Self>, _pwm: &Device, _parent_dev: &device::Device<Bound>) -> Result {

        Ok(())

    }
@@ -310,7 +306,9 @@ unsafe fn deserialize_wfhw(wfhw_ptr: *const c_void) -> Result<T::WfHw> { 
        // Now, call the original release function to free the `pwm_chip` itself.

        // SAFETY: `dev` is the valid pointer passed into this callback, which is

        // the expected argument for `pwmchip_release`.

        unsafe { bindings::pwmchip_release(dev); }

        unsafe {

            bindings::pwmchip_release(dev);

        }

    }



    /// # Safety
@@ -593,9 +591,8 @@ pub fn new( 
    ) -> Result<ARef<Self>> {

        let sizeof_priv = core::mem::size_of::<T>();

        // SAFETY: `pwmchip_alloc` allocates memory for the C struct and our private data.

        let c_chip_ptr_raw = unsafe {

            bindings::pwmchip_alloc(parent_dev.as_raw(), num_channels, sizeof_priv)

        };

        let c_chip_ptr_raw =

            unsafe { bindings::pwmchip_alloc(parent_dev.as_raw(), num_channels, sizeof_priv) };



        let c_chip_ptr: *mut bindings::pwm_chip = error::from_err_ptr(c_chip_ptr_raw)?;
@@ -607,12 +604,16 @@ pub fn new( 
        unsafe { data.__pinned_init(drvdata_ptr.cast())? };



        // SAFETY: `c_chip_ptr` points to a valid chip.

        unsafe { (*c_chip_ptr).dev.release = Some(Adapter::<T>::release_callback); }

        unsafe {

            (*c_chip_ptr).dev.release = Some(Adapter::<T>::release_callback);

        }



        // SAFETY: `c_chip_ptr` points to a valid chip.

        // The `Adapter`'s `VTABLE` has a 'static lifetime, so the pointer

        // returned by `as_raw()` is always valid.

        unsafe { (*c_chip_ptr).ops = Adapter::<T>::VTABLE.as_raw(); }

        unsafe {

            (*c_chip_ptr).ops = Adapter::<T>::VTABLE.as_raw();

        }



        // Cast the `*mut bindings::pwm_chip` to `*mut Chip`. This is valid because

        // `Chip` is `repr(transparent)` over `Opaque<bindings::pwm_chip>`, and
@@ -632,7 +633,9 @@ unsafe impl<T: PwmOps> AlwaysRefCounted for Chip<T> { 
    fn inc_ref(&self) {

        // SAFETY: `self.0.get()` points to a valid `pwm_chip` because `self` exists.

        // The embedded `dev` is valid. `get_device` increments its refcount.

        unsafe { bindings::get_device(&raw mut (*self.0.get()).dev); }

        unsafe {

            bindings::get_device(&raw mut (*self.0.get()).dev);

        }

    }



    #[inline]
@@ -641,7 +644,9 @@ unsafe fn dec_ref(obj: NonNull<Chip<T>>) { 


        // SAFETY: `obj` is a valid pointer to a `Chip` (and thus `bindings::pwm_chip`)

        // with a non-zero refcount. `put_device` handles decrement and final release.

        unsafe { bindings::put_device(&raw mut (*c_chip_ptr).dev); }

        unsafe {

            bindings::put_device(&raw mut (*c_chip_ptr).dev);

        }

    }

}
@@ -673,10 +678,7 @@ impl<T: 'static + PwmOps + Send + Sync> Registration<T> { 
    /// to the parent device.

    /// On unbind of the parent device, the `devres` entry will be dropped, automatically

    /// calling `pwmchip_remove`. This function should be called from the driver's `probe`.

    pub fn register(

        dev: &device::Device<Bound>,

        chip: ARef<Chip<T>>,

    ) -> Result {

    pub fn register(dev: &device::Device<Bound>, chip: ARef<Chip<T>>) -> Result {

        let chip_parent = chip.device().parent().ok_or(EINVAL)?;

        if dev.as_raw() != chip_parent.as_raw() {

            return Err(EINVAL);
@@ -703,7 +705,9 @@ fn drop(&mut self) { 
        // SAFETY: `chip_raw` points to a chip that was successfully registered.

        // `bindings::pwmchip_remove` is the correct C function to unregister it.

        // This `drop` implementation is called automatically by `devres` on driver unbind.

        unsafe { bindings::pwmchip_remove(chip_raw); }

        unsafe {

            bindings::pwmchip_remove(chip_raw);

        }

    }

}