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
Link: https://docs.kernel.org/rust/coding-guidelines.html#style-formatting
Fixes: d8046cd50879 ("rust: pwm: Add complete abstraction layer")
Fixes: 7b3dce814a15 ("rust: pwm: Add Kconfig and basic data structures")
Fixes: e03724aac758 ("pwm: Add Rust driver for T-HEAD TH1520 SoC")
Signed-off-by: Miguel Ojeda <ojeda@kernel.org>
Link: https://patch.msgid.link/20251029182502.783392-1-ojeda@kernel.org
Signed-off-by: Uwe Kleine-König <ukleinek@kernel.org>

diff --git a/drivers/pwm/pwm_th1520.rs b/drivers/pwm/pwm_th1520.rs
index 0ad38b78be854ab3c10268fb20763d9962f59c0f..ee2a6d573bc23dd0d18c0dde9ef8513160948bc6 100644 (file)
--- a/drivers/pwm/pwm_th1520.rs
+++ b/drivers/pwm/pwm_th1520.rs
@@ -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.

diff --git a/rust/kernel/lib.rs b/rust/kernel/lib.rs
index 68c71d888fdb84183569120f0673c0f983d0ec9b..584aa3282029c55e18a84295624de97515c6d682 100644 (file)
--- a/rust/kernel/lib.rs
+++ b/rust/kernel/lib.rs
@@ -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;

diff --git a/rust/kernel/pwm.rs b/rust/kernel/pwm.rs
index e6d1278d83169336bf86dd662f049c353928888b..cb00f8a8765c8ec58ed78a73275b022b02bf7aa3 100644 (file)
--- a/rust/kernel/pwm.rs
+++ b/rust/kernel/pwm.rs
@@ -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,11 +678,8 @@ 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 {
-       let chip_parent = chip.device().parent().ok_or(EINVAL)?;
+    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);
+        }
     }
 }