Skip to contentSkip to conversation

rust: leds: add led classdev abstractions

PATCH Superseded Markus Probst 4 participants 13 messages Oct 27, 2025 – Nov 17, 2025

Subsystems (7)
USB PCI Driver core LED +3 more subsystems

v7 of 28 Superseded Latest is v28 →

lore
Share & tools
lore
#0 lore raw

v7 cover rust: leds: add led classdev abstractions

This patch series has previously been contained in
https://lore.kernel.org/rust-for-linux/[email protected]/T/#t
which added a rust written led driver for a microcontroller via i2c.

As the reading and writing to the i2c client via the register! macro has not been implemented yet [1], the patch series will only contain the additional abstractions required.

[1] https://lore.kernel.org/rust-for-linux/[email protected]/

The following changes were made:
* add abstraction to convert a device reference to a bus device reference for use in class device callbacks

* add basic led classdev abstractions to register and unregister leds

Changes since v6:
* fixed typos
* improved documentation

Changes since v5:
* rename IntoBusDevice trait into AsBusDevice
* fix documentation about LedOps::BLOCKING
* removed dependency on i2c bindings
* added AsBusDevice implementation for platform::Device
* removed device::Device fallback implementation
* document that AsBusDevice must not be used by drivers and is intended for bus and class device abstractions only.

Changes since v4:
* add abstraction to convert a device reference to a bus device reference
* require the bus device as parent device and provide it in class device callbacks
* remove Pin<Vec<_>> abstraction (as not relevant for the led abstractions)
* fixed formatting in led::Device::new
* fixed LedOps::BLOCKING did the inverse effect

Changes since v3:
* fixed kunit tests failing because of example in documentation

Changes since v2:
* return Devres on led::Device creation
* replace KBox<T> with T in struct definition
* increment and decrement reference-count of fwnode
* make a device parent mandatory for led classdev creation
* rename led::Handler to led::LedOps
* add optional brightness_get function to led::LedOps
* use #[vtable] instead of const BLINK: bool
* use Opaque::cast_from instead of casting a pointer
* improve documentation
* improve support for older rust versions
* use &Device<Bound> for parent

Changes since v1:
* fixed typos noticed by Onur Özkan

Markus Probst (2):
rust: Add trait to convert a device reference to a bus device
reference
rust: leds: add basic led classdev abstractions

Markus Probst (2):
rust: Add trait to convert a device reference to a bus device
reference
rust: leds: add basic led classdev abstractions

 rust/kernel/auxiliary.rs |   7 +
 rust/kernel/device.rs    |  33 ++++
 rust/kernel/led.rs       | 375 +++++++++++++++++++++++++++++++++++++++
 rust/kernel/lib.rs       |   1 +
 rust/kernel/pci.rs       |   7 +
 rust/kernel/platform.rs  |   7 +
 rust/kernel/usb.rs       |   6 +
 7 files changed, 436 insertions(+)
 create mode 100644 rust/kernel/led.rs
Signature · 1 line
2.51.0
#1 lore raw

PATCH v7 1/2 rust: Add trait to convert a device reference to a bus device reference

Implement the AsBusDevice trait for converting a Device reference to a bus device reference for all bus devices.

The AsBusDevice trait allows abstractions to provide the bus device in class device callbacks. It must not be used by drivers and is intended for bus and class device abstractions only.

---
 rust/kernel/auxiliary.rs |  7 +++++++
 rust/kernel/device.rs    | 33 +++++++++++++++++++++++++++++++++
 rust/kernel/pci.rs       |  7 +++++++
 rust/kernel/platform.rs  |  7 +++++++
 rust/kernel/usb.rs       |  6 ++++++
 5 files changed, 60 insertions(+)
rust/kernel/auxiliary.rs +7 -0
index 7a3b0b9c418e..db52062a4355 100644
@@ -15,6 +15,7 @@
 };
 use core::{
     marker::PhantomData,
+    mem::offset_of,
     ptr::{addr_of_mut, NonNull},
 };
 
@@ -233,6 +234,12 @@ extern "C" fn release(dev: *mut bindings::device) {
     }
 }
 
+// SAFETY: `auxiliary::Device` is a transparent wrapper of `struct auxiliary_device`.
+// The offset is guaranteed to point to a valid device field inside `auxiliary::Device`.
+unsafe impl<Ctx: device::DeviceContext> device::AsBusDevice<Ctx> for Device<Ctx> {
+    const OFFSET: usize = offset_of!(bindings::auxiliary_device, dev);
+}
+
 // SAFETY: `Device` is a transparent wrapper of a type that doesn't depend on `Device`'s generic
 // argument.
 kernel::impl_device_context_deref!(unsafe { Device });
rust/kernel/device.rs +33 -0
index a849b7dde2fd..bf09fd0b0199 100644
@@ -511,6 +511,39 @@ impl DeviceContext for Core {}
 impl DeviceContext for CoreInternal {}
 impl DeviceContext for Normal {}
 
+/// Convert device references to bus device references.
+///
+/// Bus devices can implement this trait to allow abstractions to provide the bus device in
+/// class device callbacks.
+///
+/// This must not be used by drivers and is intended for bus and class device abstractions only.
+///
+/// # Safety
+///
+/// `AsBusDevice::OFFSET` must be the offset of the embedded base `struct device` field within a
+/// bus device structure.
+pub(crate) unsafe trait AsBusDevice<Ctx: DeviceContext>: AsRef<Device<Ctx>> {
+    /// The relative offset to the device field.
+    ///
+    /// Use `offset_of!(bindings, field)` macro to avoid breakage.
+    const OFFSET: usize;
+
+    /// Convert a reference to [`Device`] into `Self`.
+    ///
+    /// # Safety
+    ///
+    /// `dev` must be contained in `Self`.
+    unsafe fn from_device(dev: &Device<Ctx>) -> &Self
+    where
+        Self: Sized,
+    {
+        let raw = dev.as_raw();
+        // SAFETY: `raw - Self::OFFSET` is guaranteed by the safety requirements
+        // to be a valid pointer to `Self`.
+        unsafe { &*raw.byte_sub(Self::OFFSET).cast::<Self>() }
+    }
+}
+
 /// # Safety
 ///
 /// The type given as `$device` must be a transparent wrapper of a type that doesn't depend on the
rust/kernel/pci.rs +7 -0
index 7fcc5f6022c1..d78f6feeaae9 100644
@@ -19,6 +19,7 @@
 };
 use core::{
     marker::PhantomData,
+    mem::offset_of,
     ops::Deref,
     ptr::{addr_of_mut, NonNull},
 };
@@ -593,6 +594,12 @@ pub fn set_master(&self) {
     }
 }
 
+// SAFETY: `pci::Device` is a transparent wrapper of `struct pci_dev`.
+// The offset is guaranteed to point to a valid device field inside `pci::Device`.
+unsafe impl<Ctx: device::DeviceContext> device::AsBusDevice<Ctx> for Device<Ctx> {
+    const OFFSET: usize = offset_of!(bindings::pci_dev, dev);
+}
+
 // SAFETY: `Device` is a transparent wrapper of a type that doesn't depend on `Device`'s generic
 // argument.
 kernel::impl_device_context_deref!(unsafe { Device });
rust/kernel/platform.rs +7 -0
index 7205fe3416d3..7197264b5a53 100644
@@ -19,6 +19,7 @@
 
 use core::{
     marker::PhantomData,
+    mem::offset_of,
     ptr::{addr_of_mut, NonNull},
 };
 
@@ -285,6 +286,12 @@ pub fn io_request_by_name(&self, name: &CStr) -> Option<IoRequest<'_>> {
     }
 }
 
+// SAFETY: `platform::Device` is a transparent wrapper of `struct platform_device`.
+// The offset is guaranteed to point to a valid device field inside `platform::Device`.
+unsafe impl<Ctx: device::DeviceContext> device::AsBusDevice<Ctx> for Device<Ctx> {
+    const OFFSET: usize = offset_of!(bindings::platform_device, dev);
+}
+
 macro_rules! define_irq_accessor_by_index {
     (
         $(#[$meta:meta])* $fn_name:ident,
rust/kernel/usb.rs +6 -0
index 14ddb711bab3..ec21261baf6a 100644
@@ -324,6 +324,12 @@ fn as_raw(&self) -> *mut bindings::usb_interface {
     }
 }
 
+// SAFETY: `usb::Interface` is a transparent wrapper of `struct usb_interface`.
+// The offset is guaranteed to point to a valid device field inside `usb::Interface`.
+unsafe impl<Ctx: device::DeviceContext> device::AsBusDevice<Ctx> for Interface<Ctx> {
+    const OFFSET: usize = offset_of!(bindings::usb_interface, dev);
+}
+
 // SAFETY: `Interface` is a transparent wrapper of a type that doesn't depend on
 // `Interface`'s generic argument.
 kernel::impl_device_context_deref!(unsafe { Interface });
Signature · 1 line
2.51.0
maintainer
#2 lore raw

Re: [PATCH v7 1/2] rust: Add trait to convert a device reference to a bus device reference

Quoted 8 lines · Markus Probst

Implement the AsBusDevice trait for converting a Device reference to a bus device reference for all bus devices.

The AsBusDevice trait allows abstractions to provide the bus device in class device callbacks. It must not be used by drivers and is intended for bus and class device abstractions only.

Applied to driver-core-testing, thanks!

[ * Remove unused import.
* Change visibility of AsBusDevice to public.
* Fix build for USB.
* Add impl for I2cClient.
- Danilo ]

--

Given that it's already quite late in the cycle, I expect the LED stuff to land in the next cycle, hence I picked this one up in the driver-core tree.

- Danilo

#3 lore raw

PATCH v7 2/2 rust: leds: add basic led classdev abstractions

In reply to Markus Probst

Implement the core abstractions needed for led class devices, including:

* led::LedOps - the trait for handling leds, including brightness_set, brightness_get and blink_set

* led::InitData - data set for the led class device

* led::Device - a safe wrapper around led_classdev

---
 rust/kernel/led.rs | 375 +++++++++++++++++++++++++++++++++++++++++++++
 rust/kernel/lib.rs |   1 +
 2 files changed, 376 insertions(+)
 create mode 100644 rust/kernel/led.rs
rust/kernel/led.rs new file +375 -0
new file mode 100644
index 000000000000..1c1e23a0414c
@@ -0,0 +1,375 @@
+// SPDX-License-Identifier: GPL-2.0
+
+//! Abstractions for the leds driver model.
+//!
+//! C header: [`include/linux/leds.h`](srctree/include/linux/leds.h)
+
+use core::{marker::PhantomData, pin::Pin, ptr::NonNull};
+
+use pin_init::{pin_data, pinned_drop, PinInit};
+
+use crate::{
+    build_error, container_of,
+    device::{self, property::FwNode, Bound, AsBusDevice},
+    devres::Devres,
+    error::{from_result, to_result, Error, Result, VTABLE_DEFAULT_ERROR},
+    macros::vtable,
+    str::CStr,
+    try_pin_init,
+    types::{ARef, Opaque},
+};
+
+/// The led class device representation.
+///
+/// This structure represents the Rust abstraction for a C `struct led_classdev`.
+#[pin_data(PinnedDrop)]
+pub struct Device<T: LedOps> {
+    ops: T,
+    #[pin]
+    classdev: Opaque<bindings::led_classdev>,
+}
+
+/// The led init data representation.
+///
+/// This structure represents the Rust abstraction for a C `struct led_init_data`.
+#[derive(Default)]
+pub struct InitData<'a> {
+    fwnode: Option<&'a FwNode>,
+    default_label: Option<&'a CStr>,
+    devicename: Option<&'a CStr>,
+    devname_mandatory: bool,
+}
+
+impl InitData<'static> {
+    /// Creates a new [`InitData`]
+    pub fn new() -> Self {
+        Self::default()
+    }
+}
+
+impl<'a> InitData<'a> {
+    /// Sets the firmware node
+    pub fn fwnode<'b, 'c>(self, fwnode: &'b FwNode) -> InitData<'c>
+    where
+        'a: 'c,
+        'b: 'c,
+    {
+        InitData {
+            fwnode: Some(fwnode),
+            ..self
+        }
+    }
+
+    /// Sets a default label
+    pub fn default_label<'b, 'c>(self, label: &'b CStr) -> InitData<'c>
+    where
+        'a: 'c,
+        'b: 'c,
+    {
+        InitData {
+            default_label: Some(label),
+            ..self
+        }
+    }
+
+    /// Sets the device name
+    pub fn devicename<'b, 'c>(self, devicename: &'b CStr) -> InitData<'c>
+    where
+        'a: 'c,
+        'b: 'c,
+    {
+        InitData {
+            devicename: Some(devicename),
+            ..self
+        }
+    }
+
+    /// Sets if a device name is mandatory
+    pub fn devicename_mandatory(self, mandatory: bool) -> Self {
+        Self {
+            devname_mandatory: mandatory,
+
+            ..self
+        }
+    }
+}
+
+/// Trait defining the operations for a LED driver.
+///
+/// # Examples
+///
+///```
+/// # use kernel::{
+/// #     c_str, device, devres::Devres,
+/// #     error::Result, led,
+/// #     macros::vtable, platform, prelude::*,
+/// # };
+/// # use core::pin::Pin;
+///
+/// struct MyLedOps;
+///
+///
+/// #[vtable]
+/// impl led::LedOps for MyLedOps {
+///     type Bus = platform::Device<device::Bound>;
+///     const BLOCKING: bool = false;
+///     const MAX_BRIGHTNESS: u32 = 255;
+///
+///     fn brightness_set(
+///         &self,
+///         _dev: &platform::Device<device::Bound>,
+///         _brightness: u32
+///     ) -> Result<()> {
+///         // Set the brightness for the led here
+///         Ok(())
+///     }
+/// }
+///
+/// fn register_my_led(
+///     parent: &platform::Device<device::Bound>,
+/// ) -> Result<Pin<KBox<Devres<led::Device<MyLedOps>>>>> {
+///     KBox::pin_init(led::Device::new(
+///         parent,
+///         led::InitData::new()
+///             .default_label(c_str!("my_led")),
+///         MyLedOps,
+///     ), GFP_KERNEL)
+/// }
+///```
+/// Led drivers must implement this trait in order to register and handle a [`Device`].
+#[vtable]
+pub trait LedOps: Send + 'static + Sized {
+    /// The bus device required by the implementation.
+    #[allow(private_bounds)]
+    type Bus: AsBusDevice<Bound>;
+    /// If set true, [`LedOps::brightness_set`] and [`LedOps::blink_set`] must perform the
+    /// operation immediately. If set false, they must not sleep.
+    const BLOCKING: bool;
+    /// The max brightness level
+    const MAX_BRIGHTNESS: u32;
+
+    /// Sets the brightness level.
+    ///
+    /// See also [`LedOps::BLOCKING`]
+    fn brightness_set(&self, dev: &Self::Bus, brightness: u32) -> Result<()>;
+
+    /// Gets the current brightness level.
+    fn brightness_get(&self, _dev: &Self::Bus) -> u32 {
+        build_error!(VTABLE_DEFAULT_ERROR)
+    }
+
+    /// Activates hardware accelerated blinking.
+    ///
+    /// delays are in milliseconds. If both are zero, a sensible default should be chosen.
+    /// The caller should adjust the timings in that case and if it can't match the values
+    /// specified exactly. Setting the brightness to 0 will disable the hardware accelerated
+    /// blinking.
+    ///
+    /// See also [`LedOps::BLOCKING`]
+    fn blink_set(
+        &self,
+        _dev: &Self::Bus,
+        _delay_on: &mut usize,
+        _delay_off: &mut usize,
+    ) -> Result<()> {
+        build_error!(VTABLE_DEFAULT_ERROR)
+    }
+}
+
+// SAFETY: A `led::Device` can be unregistered from any thread.
+unsafe impl<T: LedOps + Send> Send for Device<T> {}
+
+// SAFETY: `led::Device` can be shared among threads because all methods of `led::Device`
+// are thread safe.
+unsafe impl<T: LedOps + Sync> Sync for Device<T> {}
+
+impl<T: LedOps> Device<T> {
+    /// Registers a new led classdev.
+    ///
+    /// The [`Device`] will be unregistered on drop.
+    pub fn new<'a>(
+        parent: &'a T::Bus,
+        init_data: InitData<'a>,
+        ops: T,
+    ) -> impl PinInit<Devres<Self>, Error> + 'a {
+        Devres::new(
+            parent.as_ref(),
+            try_pin_init!(Self {
+                ops,
+                classdev <- Opaque::try_ffi_init(|ptr: *mut bindings::led_classdev| {
+                    // SAFETY: `try_ffi_init` guarantees that `ptr` is valid for write.
+                    // `led_classdev` gets fully initialized in-place by
+                    // `led_classdev_register_ext` including `mutex` and `list_head`.
+                    unsafe {
+                        ptr.write(bindings::led_classdev {
+                            max_brightness: T::MAX_BRIGHTNESS,
+                            brightness_set: (!T::BLOCKING)
+                                .then_some(Adapter::<T>::brightness_set_callback),
+                            brightness_set_blocking: T::BLOCKING
+                                .then_some(Adapter::<T>::brightness_set_blocking_callback),
+                            brightness_get: T::HAS_BRIGHTNESS_GET
+                                .then_some(Adapter::<T>::brightness_get_callback),
+                            blink_set: T::HAS_BLINK_SET.then_some(Adapter::<T>::blink_set_callback),
+                            ..bindings::led_classdev::default()
+                        })
+                    };
+
+                    let fwnode = init_data.fwnode.map(ARef::from);
+
+                    let mut init_data = bindings::led_init_data {
+                        fwnode: fwnode
+                            .as_ref()
+                            .map_or(core::ptr::null_mut(), |fwnode| fwnode.as_raw()),
+                        default_label: init_data
+                            .default_label
+                            .map_or(core::ptr::null(), CStr::as_char_ptr),
+                        devicename: init_data
+                            .devicename
+                            .map_or(core::ptr::null(), CStr::as_char_ptr),
+                        devname_mandatory: init_data.devname_mandatory,
+                    };
+
+                    // SAFETY:
+                    // - `parent.as_raw()` is guaranteed to be a pointer to a valid `device`
+                    //    or a null pointer.
+                    // - `ptr` is guaranteed to be a pointer to an initialized `led_classdev`.
+                    to_result(unsafe {
+                        bindings::led_classdev_register_ext(
+                            parent.as_ref().as_raw(),
+                            ptr,
+                            &mut init_data,
+                        )
+                    })?;
+
+                    core::mem::forget(fwnode); // keep the reference count incremented
+
+                    Ok::<_, Error>(())
+                }),
+            }),
+        )
+    }
+
+    /// # Safety
+    /// `led_cdev` must be a valid pointer to a `led_classdev` embedded within a
+    /// `led::Device`.
+    unsafe fn from_raw<'a>(led_cdev: *mut bindings::led_classdev) -> &'a Self {
+        // SAFETY: The function's contract guarantees that `led_cdev` points to a `led_classdev`
+        // field embedded within a valid `led::Device`. `container_of!` can therefore
+        // safely calculate the address of the containing struct.
+        unsafe { &*container_of!(Opaque::cast_from(led_cdev), Self, classdev) }
+    }
+
+    fn parent(&self) -> &device::Device<Bound> {
+        // SAFETY:
+        // - `self.classdev.get()` is guaranteed to be a valid pointer to `led_classdev`.
+        unsafe { device::Device::from_raw((*(*self.classdev.get()).dev).parent) }
+    }
+}
+
+struct Adapter<T: LedOps> {
+    _p: PhantomData<T>,
+}
+
+impl<T: LedOps> Adapter<T> {
+    /// # Safety
+    /// `led_cdev` must be a valid pointer to a `led_classdev` embedded within a
+    /// `led::Device`.
+    /// This function is called on setting the brightness of a led.
+    unsafe extern "C" fn brightness_set_callback(
+        led_cdev: *mut bindings::led_classdev,
+        brightness: u32,
+    ) {
+        // SAFETY: The function's contract guarantees that `led_cdev` is a valid pointer to a
+        // `led_classdev` embedded within a `led::Device`.
+        let classdev = unsafe { Device::<T>::from_raw(led_cdev) };
+        // SAFETY: `classdev.parent()` is guaranteed to be contained in `T::Bus`.
+        let parent = unsafe { T::Bus::from_device(classdev.parent()) };
+
+        let _ = classdev.ops.brightness_set(parent, brightness);
+    }
+
+    /// # Safety
+    /// `led_cdev` must be a valid pointer to a `led_classdev` embedded within a
+    /// `led::Device`.
+    /// This function is called on setting the brightness of a led immediately.
+    unsafe extern "C" fn brightness_set_blocking_callback(
+        led_cdev: *mut bindings::led_classdev,
+        brightness: u32,
+    ) -> i32 {
+        from_result(|| {
+            // SAFETY: The function's contract guarantees that `led_cdev` is a valid pointer to a
+            // `led_classdev` embedded within a `led::Device`.
+            let classdev = unsafe { Device::<T>::from_raw(led_cdev) };
+            // SAFETY: `classdev.parent()` is guaranteed to be contained in `T::Bus`.
+            let parent = unsafe { T::Bus::from_device(classdev.parent()) };
+
+            classdev.ops.brightness_set(parent, brightness)?;
+            Ok(0)
+        })
+    }
+
+    /// # Safety
+    /// `led_cdev` must be a valid pointer to a `led_classdev` embedded within a
+    /// `led::Device`.
+    /// This function is called on getting the brightness of a led.
+    unsafe extern "C" fn brightness_get_callback(led_cdev: *mut bindings::led_classdev) -> u32 {
+        // SAFETY: The function's contract guarantees that `led_cdev` is a valid pointer to a
+        // `led_classdev` embedded within a `led::Device`.
+        let classdev = unsafe { Device::<T>::from_raw(led_cdev) };
+        // SAFETY: `classdev.parent()` is guaranteed to be contained in `T::Bus`.
+        let parent = unsafe { T::Bus::from_device(classdev.parent()) };
+
+        classdev.ops.brightness_get(parent)
+    }
+
+    /// # Safety
+    /// `led_cdev` must be a valid pointer to a `led_classdev` embedded within a
+    /// `led::Device`.
+    /// `delay_on` and `delay_off` must be valid pointers to `usize` and have
+    /// exclusive access for the period of this function.
+    /// This function is called on enabling hardware accelerated blinking.
+    unsafe extern "C" fn blink_set_callback(
+        led_cdev: *mut bindings::led_classdev,
+        delay_on: *mut usize,
+        delay_off: *mut usize,
+    ) -> i32 {
+        from_result(|| {
+            // SAFETY: The function's contract guarantees that `led_cdev` is a valid pointer to a
+            // `led_classdev` embedded within a `led::Device`.
+            let classdev = unsafe { Device::<T>::from_raw(led_cdev) };
+            // SAFETY: `classdev.parent()` is guaranteed to be contained in `T::Bus`.
+            let parent = unsafe { T::Bus::from_device(classdev.parent()) };
+
+            classdev.ops.blink_set(
+                parent,
+                // SAFETY: The function's contract guarantees that `delay_on` points to a `usize`
+                // and is exclusive for the period of this function.
+                unsafe { &mut *delay_on },
+                // SAFETY: The function's contract guarantees that `delay_off` points to a `usize`
+                // and is exclusive for the period of this function.
+                unsafe { &mut *delay_off },
+            )?;
+            Ok(0)
+        })
+    }
+}
+
+#[pinned_drop]
+impl<T: LedOps> PinnedDrop for Device<T> {
+    fn drop(self: Pin<&mut Self>) {
+        let raw = self.classdev.get();
+        // SAFETY: The existence of `self` guarantees that `self.classdev.get()` is a pointer to a
+        // valid `struct led_classdev`.
+        let dev: &device::Device = unsafe { device::Device::from_raw((*raw).dev) };
+
+        let _fwnode = dev
+            .fwnode()
+            // SAFETY: the reference count of `fwnode` has previously been
+            // incremented in `led::Device::new`.
+            .map(|fwnode| unsafe { ARef::from_raw(NonNull::from(fwnode)) });
+
+        // SAFETY: The existence of `self` guarantees that `self.classdev` has previously been
+        // successfully registered with `led_classdev_register_ext`.
+        unsafe { bindings::led_classdev_unregister(self.classdev.get()) };
+    }
+}
rust/kernel/lib.rs +1 -0
index 3dd7bebe7888..c03b7b242a2b 100644
@@ -103,6 +103,7 @@
 pub mod jump_label;
 #[cfg(CONFIG_KUNIT)]
 pub mod kunit;
+pub mod led;
 pub mod list;
 pub mod maple_tree;
 pub mod miscdevice;
Signature · 1 line
2.51.0
maintainer
#4 lore raw
In reply to Markus Probst

Hi Markus,

Quoted 4 lines · Markus Probst

Markus Probst (2):
rust: Add trait to convert a device reference to a bus device
reference
rust: leds: add basic led classdev abstractions

I don't see an entry in the MAINTAINERS file for the added LED code.

Did you hear back from the LED maintainers already?

@Lee, Pavel: What's your take on this?

Depending on whether it is likely for the LED work to land in this cycle, I'd otherwise pick the first patch into the driver-core tree for now, since it can already be used in the PCI and platform code.

(I'd assume you want to wait for the driver from [1] before picking the Rust LED code, which has to wait for the next cycle since it depends on the Rust I2C code.)

[1] https://lore.kernel.org/rust-for-linux/[email protected]/

#5 lore raw
Quoted 11 lines · Danilo Krummrich

Hi Markus,

Quoted 4 lines · Markus Probst

Markus Probst (2):
  rust: Add trait to convert a device reference to a bus device reference
  rust: leds: add basic led classdev abstractions

I don't see an entry in the MAINTAINERS file for the added LED code.

Did you hear back from the LED maintainers already?

No there is no MAINTAINERS entry for it, therefore it will covered by the "RUST" entry in the file. I have added the led maintainers and the "linux-leds" mailing list to every patch sent regarding the led bindings and none of the maintainers have commented on it so far.

Thanks
- Markus

Quoted 671 lines

@Lee, Pavel: What's your take on this?

Depending on whether it is likely for the LED work to land in this cycle, I'd
otherwise pick the first patch into the driver-core tree for now, since it can
already be used in the PCI and platform code.

(I'd assume you want to wait for the driver from [1] before picking the Rust LED
code, which has to wait for the next cycle since it depends on the Rust I2C
code.)

[1]
https://lore.kernel.org/rust-for-linux/[email protected]/

Quoted 654 lines
Quoted 654 lines
Quoted 654 lines
Quoted 654 lines
Quoted 654 lines
Quoted 654 lines
Quoted 654 lines
Quoted 654 lines
Quoted 654 lines
Quoted 654 lines
Quoted 654 lines
Quoted 654 lines
#6 lore raw
Quoted 5 lines · Markus Probst

No there is no MAINTAINERS entry for it, therefore it will covered by the "RUST" entry in the file. I have added the led maintainers and the "linux-leds" mailing list to every patch sent regarding the led bindings and none of the maintainers have commented on it so far.

The global "RUST" entry is generally meant for core abstractions and infrastructure. The best way forward is to get the C side maintainers involved, since they are the experts on the subsystem.

Depending on what they want to do (e.g. they may want to maintain the Rust side themselves, or they may be looking for a co-maintainer, or they may not want Rust code for the time being, or they may prefer to leave this to another entry, etc.), we can see what to do.

The first version was posted, I think, earlier this month (please correct me if I am wrong), so let's give them one kernel cycle at least to think about it.

Of course, it also depends on what you want to do. For instance, would you be willing to maintain this code if the maintainers want to have a "LED SUBSYSTEM [RUST]" subentry?

Thanks!

Cheers,
Miguel

#7 lore raw
Quoted 23 lines · Miguel Ojeda
Quoted 7 lines · Markus Probst

No there is no MAINTAINERS entry for it, therefore it will covered by
the "RUST" entry in the file. I have added the led maintainers and the
"linux-leds" mailing list to every patch sent regarding the led bindings and none of the maintainers have commented on it so far.

The global "RUST" entry is generally meant for core abstractions and infrastructure. The best way forward is to get the C side maintainers involved, since they are the experts on the subsystem.

Depending on what they want to do (e.g. they may want to maintain the Rust side themselves, or they may be looking for a co-maintainer, or they may not want Rust code for the time being, or they may prefer to leave this to another entry, etc.), we can see what to do.

The first version was posted, I think, earlier this month (please correct me if I am wrong), so let's give them one kernel cycle at least to think about it.

Quoted 5 lines

Of course, it also depends on what you want to do. For instance, would
you be willing to maintain this code if the maintainers want to have a
"LED SUBSYSTEM [RUST]" subentry?

Yes.

Could you please clarify if there would be other responsibilities to it than code reviews and adapting the code to breaking changes from the LED Subsystem (I assume I will be notified in that event).

Thanks
- Markus Probst

Quoted 322 lines

Thanks!

Cheers,
Miguel

Quoted 316 lines
Quoted 316 lines
Quoted 316 lines
Quoted 316 lines
Quoted 316 lines
Quoted 316 lines
Quoted 316 lines
Quoted 316 lines
Quoted 316 lines
Quoted 316 lines
Quoted 316 lines
Quoted 316 lines
#8 lore raw
Quoted 4 lines · Markus Probst

Could you please clarify if there would be other responsibilities to it than code reviews and adapting the code to breaking changes from the LED Subsystem (I assume I will be notified in that event).

It depends on the case, e.g. if the LED maintainers prefer that you manage your own tree and send PRs to them.

But, generally speaking, a kernel maintainer takes care of a few more things, e.g. triaging bugs, fixing issues, tracking patches, deciding which releases a patch should go into (backporting), etc. Some details at:

https://docs.kernel.org/maintainer/feature-and-driver-maintainers.html#responsibilities

This is not meant to discourage you, of course -- being a kernel maintainer is a fairly unique experience. Now, how much it is wildly varies depending on what code it is, e.g. how many changes go through the C side, how many users/callers you have etc.

I hope that helps!

Cheers,
Miguel

maintainer
#9 lore raw
In reply to Danilo Krummrich
Quoted 8 lines · Danilo Krummrich

Hi Markus,

Quoted 4 lines · Markus Probst

Markus Probst (2):
rust: Add trait to convert a device reference to a bus device
reference
rust: leds: add basic led classdev abstractions

Quoted 5 lines

I don't see an entry in the MAINTAINERS file for the added LED code.

Did you hear back from the LED maintainers already?

@Lee, Pavel: What's your take on this?

I'd be happy to take LED Rust patches at face value so long as they come with a quality Rust-specific Reviewed-by. Reviewing professional level Rust code is presently beyond my capabilities.

Signature · 1 line
Lee Jones [李琼斯]
#10 lore raw
In reply to Markus Probst
Quoted 63 lines · Markus Probst

This patch series has previously been contained in
https://lore.kernel.org/rust-for-linux/[email protected]/T/#t
which added a rust written led driver for a microcontroller via i2c.

As the reading and writing to the i2c client via the register! macro has not been implemented yet [1], the patch series will only contain the additional abstractions required.

[1] https://lore.kernel.org/rust-for-linux/[email protected]/

The following changes were made:
* add abstraction to convert a device reference to a bus device reference for use in class device callbacks

* add basic led classdev abstractions to register and unregister leds

Changes since v6:
* fixed typos
* improved documentation

Changes since v5:
* rename IntoBusDevice trait into AsBusDevice
* fix documentation about LedOps::BLOCKING
* removed dependency on i2c bindings
* added AsBusDevice implementation for platform::Device
* removed device::Device fallback implementation
* document that AsBusDevice must not be used by drivers and is intended for bus and class device abstractions only.

Changes since v4:
* add abstraction to convert a device reference to a bus device reference
* require the bus device as parent device and provide it in class device callbacks
* remove Pin<Vec<_>> abstraction (as not relevant for the led abstractions)
* fixed formatting in led::Device::new
* fixed LedOps::BLOCKING did the inverse effect

Changes since v3:
* fixed kunit tests failing because of example in documentation

Changes since v2:
* return Devres on led::Device creation
* replace KBox<T> with T in struct definition
* increment and decrement reference-count of fwnode
* make a device parent mandatory for led classdev creation
* rename led::Handler to led::LedOps
* add optional brightness_get function to led::LedOps
* use #[vtable] instead of const BLINK: bool
* use Opaque::cast_from instead of casting a pointer
* improve documentation
* improve support for older rust versions
* use &Device<Bound> for parent

Changes since v1:
* fixed typos noticed by Onur Özkan

Markus Probst (2):
rust: Add trait to convert a device reference to a bus device
reference
rust: leds: add basic led classdev abstractions

Quoted 4 lines

Markus Probst (2):
rust: Add trait to convert a device reference to a bus device
reference
rust: leds: add basic led classdev abstractions

Hi,

So you know in advance, I will add a 3. patch for multicolor led classdev abstractions (drivers/leds/led-class-multicolor.c, include/linux/led-class-multicolor.h) to this patch series.

In the atmega1608 led driver (the user of these abstractions) there are leds with different colors that share the same slot. Technically "drivers/leds/rgb/leds-group-multicolor.c" could be used in combination with single color leds instead, but then hardware accelerated blinking wouldn't be supported. I think it would make more sense to directly implement it in the driver.

The existing 2 patches shouldn't change, so feel free to review them.

Thanks
- Markus Probst

Quoted 10 lines
 rust/kernel/auxiliary.rs |   7 +
 rust/kernel/device.rs    |  33 ++++
 rust/kernel/led.rs       | 375 +++++++++++++++++++++++++++++++++++++++
 rust/kernel/lib.rs       |   1 +
 rust/kernel/pci.rs       |   7 +
 rust/kernel/platform.rs  |   7 +
 rust/kernel/usb.rs       |   6 +
 7 files changed, 436 insertions(+)
 create mode 100644 rust/kernel/led.rs
#11 lore raw
Quoted 82 lines · Markus Probst
Quoted 63 lines · Markus Probst

This patch series has previously been contained in
https://lore.kernel.org/rust-for-linux/[email protected]/T/#t
which added a rust written led driver for a microcontroller via i2c.

As the reading and writing to the i2c client via the register! macro has not been implemented yet [1], the patch series will only contain the additional abstractions required.

[1] https://lore.kernel.org/rust-for-linux/[email protected]/

The following changes were made:
* add abstraction to convert a device reference to a bus device reference for use in class device callbacks

* add basic led classdev abstractions to register and unregister leds

Changes since v6:
* fixed typos
* improved documentation

Changes since v5:
* rename IntoBusDevice trait into AsBusDevice
* fix documentation about LedOps::BLOCKING
* removed dependency on i2c bindings
* added AsBusDevice implementation for platform::Device
* removed device::Device fallback implementation
* document that AsBusDevice must not be used by drivers and is intended for bus and class device abstractions only.

Changes since v4:
* add abstraction to convert a device reference to a bus device reference
* require the bus device as parent device and provide it in class device callbacks
* remove Pin<Vec<_>> abstraction (as not relevant for the led abstractions)
* fixed formatting in led::Device::new
* fixed LedOps::BLOCKING did the inverse effect

Changes since v3:
* fixed kunit tests failing because of example in documentation

Changes since v2:
* return Devres on led::Device creation
* replace KBox<T> with T in struct definition
* increment and decrement reference-count of fwnode
* make a device parent mandatory for led classdev creation
* rename led::Handler to led::LedOps
* add optional brightness_get function to led::LedOps
* use #[vtable] instead of const BLINK: bool
* use Opaque::cast_from instead of casting a pointer
* improve documentation
* improve support for older rust versions
* use &Device<Bound> for parent

Changes since v1:
* fixed typos noticed by Onur Özkan

Markus Probst (2):
rust: Add trait to convert a device reference to a bus device
reference
rust: leds: add basic led classdev abstractions

Quoted 4 lines

Markus Probst (2):
rust: Add trait to convert a device reference to a bus device
reference
rust: leds: add basic led classdev abstractions

Hi,

So you know in advance, I will add a 3. patch for multicolor led classdev abstractions (drivers/leds/led-class-multicolor.c, include/linux/led-class-multicolor.h) to this patch series.

In the atmega1608 led driver (the user of these abstractions) there are leds with different colors that share the same slot. Technically "drivers/leds/rgb/leds-group-multicolor.c" could be used in combination with single color leds instead, but then hardware accelerated blinking wouldn't be supported. I think it would make more sense to directly implement it in the driver.

Quoted 4 lines

The existing 2 patches shouldn't change, so feel free to review them.

Thanks
- Markus Probst

ignore the duplicate email. Sending the email gave an error, retrying resulted in the email being sent twice.

Thanks
- Markus Probst

Quoted 11 lines
Quoted 11 lines

 rust/kernel/auxiliary.rs |   7 +
 rust/kernel/device.rs    |  33 ++++
 rust/kernel/led.rs       | 375 +++++++++++++++++++++++++++++++++++++++
 rust/kernel/lib.rs       |   1 +
 rust/kernel/pci.rs       |   7 +
 rust/kernel/platform.rs  |   7 +
 rust/kernel/usb.rs       |   6 +
 7 files changed, 436 insertions(+)
 create mode 100644 rust/kernel/led.rs
#12 lore raw
In reply to Markus Probst
Quoted 63 lines · Markus Probst

This patch series has previously been contained in
https://lore.kernel.org/rust-for-linux/[email protected]/T/#t
which added a rust written led driver for a microcontroller via i2c.

As the reading and writing to the i2c client via the register! macro has not been implemented yet [1], the patch series will only contain the additional abstractions required.

[1] https://lore.kernel.org/rust-for-linux/[email protected]/

The following changes were made:
* add abstraction to convert a device reference to a bus device reference for use in class device callbacks

* add basic led classdev abstractions to register and unregister leds

Changes since v6:
* fixed typos
* improved documentation

Changes since v5:
* rename IntoBusDevice trait into AsBusDevice
* fix documentation about LedOps::BLOCKING
* removed dependency on i2c bindings
* added AsBusDevice implementation for platform::Device
* removed device::Device fallback implementation
* document that AsBusDevice must not be used by drivers and is intended for bus and class device abstractions only.

Changes since v4:
* add abstraction to convert a device reference to a bus device reference
* require the bus device as parent device and provide it in class device callbacks
* remove Pin<Vec<_>> abstraction (as not relevant for the led abstractions)
* fixed formatting in led::Device::new
* fixed LedOps::BLOCKING did the inverse effect

Changes since v3:
* fixed kunit tests failing because of example in documentation

Changes since v2:
* return Devres on led::Device creation
* replace KBox<T> with T in struct definition
* increment and decrement reference-count of fwnode
* make a device parent mandatory for led classdev creation
* rename led::Handler to led::LedOps
* add optional brightness_get function to led::LedOps
* use #[vtable] instead of const BLINK: bool
* use Opaque::cast_from instead of casting a pointer
* improve documentation
* improve support for older rust versions
* use &Device<Bound> for parent

Changes since v1:
* fixed typos noticed by Onur Özkan

Markus Probst (2):
rust: Add trait to convert a device reference to a bus device
reference
rust: leds: add basic led classdev abstractions

Quoted 4 lines

Markus Probst (2):
rust: Add trait to convert a device reference to a bus device
reference
rust: leds: add basic led classdev abstractions

Hi,

So you know in advance, I will add a 3. patch for multicolor led classdev abstractions (drivers/leds/led-class-multicolor.c, include/linux/led-class-multicolor.h) to this patch series.

In the atmega1608 led driver (the user of these abstractions) there are leds with different colors that share the same slot. Technically "drivers/leds/rgb/leds-group-multicolor.c" could be used in combination with single color leds instead, but then hardware accelerated blinking wouldn't be supported. I think it would make more sense to directly implement it in the driver.

The existing 2 patches shouldn't change, so feel free to review them.

Thanks
- Markus Probst

Quoted 10 lines
 rust/kernel/auxiliary.rs |   7 +
 rust/kernel/device.rs    |  33 ++++
 rust/kernel/led.rs       | 375 +++++++++++++++++++++++++++++++++++++++
 rust/kernel/lib.rs       |   1 +
 rust/kernel/pci.rs       |   7 +
 rust/kernel/platform.rs  |   7 +
 rust/kernel/usb.rs       |   6 +
 7 files changed, 436 insertions(+)
 create mode 100644 rust/kernel/led.rs