rust: leds: add led classdev abstractions
Subsystems (7)
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
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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
Danilo Krummrich
maintainerRe: [PATCH v7 1/2] rust: Add trait to convert a device reference to a bus device reference
Quoted 8 lines · Markus Probst
Implement the
AsBusDevicetrait for converting aDevicereference to a bus device reference for all bus devices.The
AsBusDevicetrait 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.Signed-off-by Markus Probst <[email protected]>
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
PATCH v7 2/2 rust: leds: add basic led classdev abstractions
In reply to Markus ProbstImplement 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
@@ -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 <&'aFwNode >, + default_label:Option <&'aCStr >, + devicename:Option <&'aCStr >, + 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: &'bFwNode ) ->InitData <'c> +where + 'a: 'c, + 'b: 'c, + { +InitData { + fwnode:Some (fwnode), + ..self + } + } + +/// Sets a default label +pub fn default_label <'b, 'c>(self, label: &'bCStr ) ->InitData <'c> +where + 'a: 'c, + 'b: 'c, + { +InitData { + default_label:Some (label), + ..self + } + } + +/// Sets the device name +pub fn devicename <'b, 'c>(self, devicename: &'bCStr ) ->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: &'aT ::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 ) -> &'aSelf { +// 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
@@ -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
Danilo Krummrich
maintainerHi 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]/
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 abstractionsI don't see an entry in the
MAINTAINERSfile 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
Quoted 5 lines · Markus Probst
No there is no
MAINTAINERSentry 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
Quoted 23 lines · Miguel Ojeda
Quoted 7 lines · Markus Probst
No there is no
MAINTAINERSentry 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,
MiguelQuoted 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
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
Lee Jones
maintainerQuoted 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
MAINTAINERSfile 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 [李琼斯]
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 documentationChanges since v5:
* renameIntoBusDevicetrait intoAsBusDevice
* fix documentation aboutLedOps::BLOCKING
* removed dependency on i2c bindings
* addedAsBusDeviceimplementation forplatform::Device
* removeddevice::Devicefallback implementation
* document thatAsBusDevicemust 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 inled::Device::new
* fixedLedOps::BLOCKINGdid the inverse effectChanges since v3:
* fixed kunit tests failing because of example in documentationChanges since v2:
* returnDevresonled::Devicecreation
* replace KBox<T> with T in struct definition
* increment and decrement reference-count of fwnode
* make a device parent mandatory for led classdev creation
* renameled::Handlertoled::LedOps
* add optionalbrightness_getfunction toled::LedOps
* use#[vtable]instead ofconst BLINK: bool
* useOpaque::cast_frominstead of casting a pointer
* improve documentation
* improve support for older rust versions
* use&Device<Bound>for parentChanges since v1:
* fixed typos noticed by Onur ÖzkanMarkus 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
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 documentationChanges since v5:
* renameIntoBusDevicetrait intoAsBusDevice
* fix documentation aboutLedOps::BLOCKING
* removed dependency on i2c bindings
* addedAsBusDeviceimplementation forplatform::Device
* removeddevice::Devicefallback implementation
* document thatAsBusDevicemust 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 inled::Device::new
* fixedLedOps::BLOCKINGdid the inverse effectChanges since v3:
* fixed kunit tests failing because of example in documentationChanges since v2:
* returnDevresonled::Devicecreation
* replace KBox<T> with T in struct definition
* increment and decrement reference-count of fwnode
* make a device parent mandatory for led classdev creation
* renameled::Handlertoled::LedOps
* add optionalbrightness_getfunction toled::LedOps
* use#[vtable]instead ofconst BLINK: bool
* useOpaque::cast_frominstead of casting a pointer
* improve documentation
* improve support for older rust versions
* use&Device<Bound>for parentChanges since v1:
* fixed typos noticed by Onur ÖzkanMarkus Probst (2):
rust: Add trait to convert a device reference to a bus device
reference
rust: leds: add basic led classdev abstractionsQuoted 4 lines
Markus Probst (2):
rust: Add trait to convert a device reference to a bus device
reference
rust: leds: add basic led classdev abstractionsHi,
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
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 documentationChanges since v5:
* renameIntoBusDevicetrait intoAsBusDevice
* fix documentation aboutLedOps::BLOCKING
* removed dependency on i2c bindings
* addedAsBusDeviceimplementation forplatform::Device
* removeddevice::Devicefallback implementation
* document thatAsBusDevicemust 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 inled::Device::new
* fixedLedOps::BLOCKINGdid the inverse effectChanges since v3:
* fixed kunit tests failing because of example in documentationChanges since v2:
* returnDevresonled::Devicecreation
* replace KBox<T> with T in struct definition
* increment and decrement reference-count of fwnode
* make a device parent mandatory for led classdev creation
* renameled::Handlertoled::LedOps
* add optionalbrightness_getfunction toled::LedOps
* use#[vtable]instead ofconst BLINK: bool
* useOpaque::cast_frominstead of casting a pointer
* improve documentation
* improve support for older rust versions
* use&Device<Bound>for parentChanges since v1:
* fixed typos noticed by Onur ÖzkanMarkus 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