* Re: [PATCH v3 RESEND RESEND 2/3] rust: core abstractions for HID drivers
From: Benjamin Tissoires @ 2025-09-17 10:04 UTC (permalink / raw)
To: Rahul Rameshbabu
Cc: linux-input, linux-kernel, rust-for-linux, Jiri Kosina,
a.hindborg, alex.gaynor, aliceryhl, benno.lossin,
Benjamin Tissoires, bjorn3_gh, boqun.feng, dakr, db48x, gary,
ojeda, tmgross, peter.hutterer
In-Reply-To: <20250913161222.3889-3-sergeantsagara@protonmail.com>
On Sep 13 2025, Rahul Rameshbabu wrote:
> These abstractions enable the development of HID drivers in Rust by binding
> with the HID core C API. They provide Rust types that map to the
> equivalents in C. In this initial draft, only hid_device and hid_device_id
> are provided direct Rust type equivalents. hid_driver is specially wrapped
> with a custom Driver type. The module_hid_driver! macro provides analogous
> functionality to its C equivalent. Only the .report_fixup callback is
> binded to Rust so far.
>
> Future work for these abstractions would include more bindings for common
> HID-related types, such as hid_field, hid_report_enum, and hid_report as
> well as more bus callbacks. Providing Rust equivalents to useful core HID
> functions will also be necessary for HID driver development in Rust.
>
> Signed-off-by: Rahul Rameshbabu <sergeantsagara@protonmail.com>
> ---
>
> Notes:
> Some points I did not address from the last review cycle:
>
> * I did not look into autogenerating all the getter functions for various
> fields exported from the binded C structures.
> - I would be interested in hearing opinions from folks actively involved
> with Rust for Linux on this topic.
>
> Changelog:
>
> v2->v3:
> * Implemented AlwaysRefCounted trait using embedded struct device's
> reference counts instead of the separate reference counter in struct
> hid_device
> * Used &raw mut as appropriate
> * Binded include/linux/device.h for get_device and put_device
> * Cleaned up various comment related formatting
> * Minified dev_err! format string
> * Updated Group enum to be repr(u16)
> * Implemented From<u16> trait for Group
> * Added TODO comment when const_trait_impl stabilizes
> * Made group getter functions return a Group variant instead of a raw
> number
> * Made sure example code builds
> v1->v2:
> * Binded drivers/hid/hid-ids.h for use in Rust drivers
> * Remove pre-emptive referencing of a C HID driver instance before
> it is fully initialized in the driver registration path
> * Moved static getters to generic Device trait implementation, so
> they can be used by all device::DeviceContext
> * Use core macros for supporting DeviceContext transitions
> * Implemented the AlwaysRefCounted and AsRef traits
> * Make use for dev_err! as appropriate
> RFC->v1:
> * Use Danilo's core infrastructure
> * Account for HID device groups
> * Remove probe and remove callbacks
> * Implement report_fixup support
> * Properly comment code including SAFETY comments
>
> MAINTAINERS | 9 +
> drivers/hid/Kconfig | 8 +
> rust/bindings/bindings_helper.h | 3 +
> rust/kernel/hid.rs | 503 ++++++++++++++++++++++++++++++++
> rust/kernel/lib.rs | 2 +
> 5 files changed, 525 insertions(+)
> create mode 100644 rust/kernel/hid.rs
>
> diff --git a/MAINTAINERS b/MAINTAINERS
> index dd810da5261b..6c60765f2aaa 100644
> --- a/MAINTAINERS
> +++ b/MAINTAINERS
> @@ -10686,6 +10686,15 @@ F: include/uapi/linux/hid*
> F: samples/hid/
> F: tools/testing/selftests/hid/
>
> +HID CORE LAYER [RUST]
> +M: Rahul Rameshbabu <sergeantsagara@protonmail.com>
> +R: Benjamin Tissoires <bentiss@kernel.org>
> +L: linux-input@vger.kernel.org
> +S: Maintained
> +T: git git://git.kernel.org/pub/scm/linux/kernel/git/hid/hid.git rust
FWIW, we (HID maintainers) are still undecided on how to handle that,
and so it's a little bit postponed for now
> +F: drivers/hid/*.rs
Could you instead make it really independant by relying on
drivers/hid/rust instead?
We already have drivers/hid/bpf for HID-BPF related stuff, so it doesn't
seem to be that much of an issue to have a separate rust dir.
This should allow for a cleaner separation without tinkering in Makefile
or Kconfig if the HID rust tree is handled separately.
Cheers,
Benjamin
> +F: rust/kernel/hid.rs
> +
> HID LOGITECH DRIVERS
> R: Filipe Laíns <lains@riseup.net>
> L: linux-input@vger.kernel.org
> diff --git a/drivers/hid/Kconfig b/drivers/hid/Kconfig
> index 43859fc75747..922e76e18af2 100644
> --- a/drivers/hid/Kconfig
> +++ b/drivers/hid/Kconfig
> @@ -744,6 +744,14 @@ config HID_MEGAWORLD_FF
> Say Y here if you have a Mega World based game controller and want
> to have force feedback support for it.
>
> +config RUST_HID_ABSTRACTIONS
> + bool "Rust HID abstractions support"
> + depends on RUST
> + depends on HID=y
> + help
> + Adds support needed for HID drivers written in Rust. It provides a
> + wrapper around the C hid core.
> +
> config HID_REDRAGON
> tristate "Redragon keyboards"
> default !EXPERT
> diff --git a/rust/bindings/bindings_helper.h b/rust/bindings/bindings_helper.h
> index 8cbb660e2ec2..7145fb1cdff1 100644
> --- a/rust/bindings/bindings_helper.h
> +++ b/rust/bindings/bindings_helper.h
> @@ -45,6 +45,7 @@
> #include <linux/cpufreq.h>
> #include <linux/cpumask.h>
> #include <linux/cred.h>
> +#include <linux/device.h>
> #include <linux/device/faux.h>
> #include <linux/dma-mapping.h>
> #include <linux/errname.h>
> @@ -52,6 +53,8 @@
> #include <linux/file.h>
> #include <linux/firmware.h>
> #include <linux/fs.h>
> +#include <linux/hid.h>
> +#include "../../drivers/hid/hid-ids.h"
> #include <linux/jiffies.h>
> #include <linux/jump_label.h>
> #include <linux/mdio.h>
> diff --git a/rust/kernel/hid.rs b/rust/kernel/hid.rs
> new file mode 100644
> index 000000000000..a93804af8b78
> --- /dev/null
> +++ b/rust/kernel/hid.rs
> @@ -0,0 +1,503 @@
> +// SPDX-License-Identifier: GPL-2.0
> +
> +// Copyright (C) 2025 Rahul Rameshbabu <sergeantsagara@protonmail.com>
> +
> +//! Abstractions for the HID interface.
> +//!
> +//! C header: [`include/linux/hid.h`](srctree/include/linux/hid.h)
> +
> +use crate::{device, device_id::RawDeviceId, driver, error::*, prelude::*, types::Opaque};
> +use core::{
> + marker::PhantomData,
> + ptr::{addr_of_mut, NonNull},
> +};
> +
> +/// Indicates the item is static read-only.
> +///
> +/// Refer to [Device Class Definition for HID 1.11]
> +/// Section 6.2.2.5 Input, Output, and Feature Items.
> +///
> +/// [Device Class Definition for HID 1.11]: https://www.usb.org/sites/default/files/hid1_11.pdf
> +pub const MAIN_ITEM_CONSTANT: u8 = bindings::HID_MAIN_ITEM_CONSTANT as u8;
> +
> +/// Indicates the item represents data from a physical control.
> +///
> +/// Refer to [Device Class Definition for HID 1.11]
> +/// Section 6.2.2.5 Input, Output, and Feature Items.
> +///
> +/// [Device Class Definition for HID 1.11]: https://www.usb.org/sites/default/files/hid1_11.pdf
> +pub const MAIN_ITEM_VARIABLE: u8 = bindings::HID_MAIN_ITEM_VARIABLE as u8;
> +
> +/// Indicates the item should be treated as a relative change from the previous
> +/// report.
> +///
> +/// Refer to [Device Class Definition for HID 1.11]
> +/// Section 6.2.2.5 Input, Output, and Feature Items.
> +///
> +/// [Device Class Definition for HID 1.11]: https://www.usb.org/sites/default/files/hid1_11.pdf
> +pub const MAIN_ITEM_RELATIVE: u8 = bindings::HID_MAIN_ITEM_RELATIVE as u8;
> +
> +/// Indicates the item should wrap around when reaching the extreme high or
> +/// extreme low values.
> +///
> +/// Refer to [Device Class Definition for HID 1.11]
> +/// Section 6.2.2.5 Input, Output, and Feature Items.
> +///
> +/// [Device Class Definition for HID 1.11]: https://www.usb.org/sites/default/files/hid1_11.pdf
> +pub const MAIN_ITEM_WRAP: u8 = bindings::HID_MAIN_ITEM_WRAP as u8;
> +
> +/// Indicates the item should wrap around when reaching the extreme high or
> +/// extreme low values.
> +///
> +/// Refer to [Device Class Definition for HID 1.11]
> +/// Section 6.2.2.5 Input, Output, and Feature Items.
> +///
> +/// [Device Class Definition for HID 1.11]: https://www.usb.org/sites/default/files/hid1_11.pdf
> +pub const MAIN_ITEM_NONLINEAR: u8 = bindings::HID_MAIN_ITEM_NONLINEAR as u8;
> +
> +/// Indicates whether the control has a preferred state it will physically
> +/// return to without user intervention.
> +///
> +/// Refer to [Device Class Definition for HID 1.11]
> +/// Section 6.2.2.5 Input, Output, and Feature Items.
> +///
> +/// [Device Class Definition for HID 1.11]: https://www.usb.org/sites/default/files/hid1_11.pdf
> +pub const MAIN_ITEM_NO_PREFERRED: u8 = bindings::HID_MAIN_ITEM_NO_PREFERRED as u8;
> +
> +/// Indicates whether the control has a physical state where it will not send
> +/// any reports.
> +///
> +/// Refer to [Device Class Definition for HID 1.11]
> +/// Section 6.2.2.5 Input, Output, and Feature Items.
> +///
> +/// [Device Class Definition for HID 1.11]: https://www.usb.org/sites/default/files/hid1_11.pdf
> +pub const MAIN_ITEM_NULL_STATE: u8 = bindings::HID_MAIN_ITEM_NULL_STATE as u8;
> +
> +/// Indicates whether the control requires host system logic to change state.
> +///
> +/// Refer to [Device Class Definition for HID 1.11]
> +/// Section 6.2.2.5 Input, Output, and Feature Items.
> +///
> +/// [Device Class Definition for HID 1.11]: https://www.usb.org/sites/default/files/hid1_11.pdf
> +pub const MAIN_ITEM_VOLATILE: u8 = bindings::HID_MAIN_ITEM_VOLATILE as u8;
> +
> +/// Indicates whether the item is fixed size or a variable buffer of bytes.
> +///
> +/// Refer to [Device Class Definition for HID 1.11]
> +/// Section 6.2.2.5 Input, Output, and Feature Items.
> +///
> +/// [Device Class Definition for HID 1.11]: https://www.usb.org/sites/default/files/hid1_11.pdf
> +pub const MAIN_ITEM_BUFFERED_BYTE: u8 = bindings::HID_MAIN_ITEM_BUFFERED_BYTE as u8;
> +
> +/// HID device groups are intended to help categories HID devices based on a set
> +/// of common quirks and logic that they will require to function correctly.
> +#[repr(u16)]
> +pub enum Group {
> + /// Used to match a device against any group when probing.
> + Any = bindings::HID_GROUP_ANY as u16,
> +
> + /// Indicates a generic device that should need no custom logic from the
> + /// core HID stack.
> + Generic = bindings::HID_GROUP_GENERIC as u16,
> +
> + /// Maps multitouch devices to hid-multitouch instead of hid-generic.
> + Multitouch = bindings::HID_GROUP_MULTITOUCH as u16,
> +
> + /// Used for autodetecing and mapping of HID sensor hubs to
> + /// hid-sensor-hub.
> + SensorHub = bindings::HID_GROUP_SENSOR_HUB as u16,
> +
> + /// Used for autodetecing and mapping Win 8 multitouch devices to set the
> + /// needed quirks.
> + MultitouchWin8 = bindings::HID_GROUP_MULTITOUCH_WIN_8 as u16,
> +
> + // Vendor-specific device groups.
> + /// Used to distinguish Synpatics touchscreens from other products. The
> + /// touchscreens will be handled by hid-multitouch instead, while everything
> + /// else will be managed by hid-rmi.
> + RMI = bindings::HID_GROUP_RMI as u16,
> +
> + /// Used for hid-core handling to automatically identify Wacom devices and
> + /// have them probed by hid-wacom.
> + Wacom = bindings::HID_GROUP_WACOM as u16,
> +
> + /// Used by logitech-djreceiver and logitech-djdevice to autodetect if
> + /// devices paied to the DJ receivers are DJ devices and handle them with
> + /// the device driver.
> + LogitechDJDevice = bindings::HID_GROUP_LOGITECH_DJ_DEVICE as u16,
> +
> + /// Since the Valve Steam Controller only has vendor-specific usages,
> + /// prevent hid-generic from parsing its reports since there would be
> + /// nothing hid-generic could do for the device.
> + Steam = bindings::HID_GROUP_STEAM as u16,
> +
> + /// Used to differentiate 27 Mhz frequency Logitech DJ devices from other
> + /// Logitech DJ devices.
> + Logitech27MHzDevice = bindings::HID_GROUP_LOGITECH_27MHZ_DEVICE as u16,
> +
> + /// Used for autodetecting and mapping Vivaldi devices to hid-vivaldi.
> + Vivaldi = bindings::HID_GROUP_VIVALDI as u16,
> +}
> +
> +// TODO: use `const_trait_impl` once stabilized:
> +//
> +// ```
> +// impl const From<Group> for u16 {
> +// /// [`Group`] variants are represented by [`u16`] values.
> +// fn from(value: Group) -> Self {
> +// value as Self
> +// }
> +// }
> +// ```
> +impl Group {
> + /// Internal function used to convert [`Group`] variants into [`u16`].
> + const fn into(self) -> u16 {
> + self as u16
> + }
> +}
> +
> +impl From<u16> for Group {
> + /// [`u16`] values can be safely converted to [`Group`] variants.
> + fn from(value: u16) -> Self {
> + match value.into() {
> + bindings::HID_GROUP_GENERIC => Group::Generic,
> + bindings::HID_GROUP_MULTITOUCH => Group::Multitouch,
> + bindings::HID_GROUP_SENSOR_HUB => Group::SensorHub,
> + bindings::HID_GROUP_MULTITOUCH_WIN_8 => Group::MultitouchWin8,
> + bindings::HID_GROUP_RMI => Group::RMI,
> + bindings::HID_GROUP_WACOM => Group::Wacom,
> + bindings::HID_GROUP_LOGITECH_DJ_DEVICE => Group::LogitechDJDevice,
> + bindings::HID_GROUP_STEAM => Group::Steam,
> + bindings::HID_GROUP_LOGITECH_27MHZ_DEVICE => Group::Logitech27MHzDevice,
> + bindings::HID_GROUP_VIVALDI => Group::Vivaldi,
> + _ => Group::Any,
> + }
> + }
> +}
> +
> +/// The HID device representation.
> +///
> +/// This structure represents the Rust abstraction for a C `struct hid_device`.
> +/// The implementation abstracts the usage of an already existing C `struct
> +/// hid_device` within Rust code that we get passed from the C side.
> +///
> +/// # Invariants
> +///
> +/// A [`Device`] instance represents a valid `struct hid_device` created by the
> +/// C portion of the kernel.
> +#[repr(transparent)]
> +pub struct Device<Ctx: device::DeviceContext = device::Normal>(
> + Opaque<bindings::hid_device>,
> + PhantomData<Ctx>,
> +);
> +
> +impl<Ctx: device::DeviceContext> Device<Ctx> {
> + fn as_raw(&self) -> *mut bindings::hid_device {
> + self.0.get()
> + }
> +
> + /// Returns the HID transport bus ID.
> + pub fn bus(&self) -> u16 {
> + // SAFETY: `self.as_raw` is a valid pointer to a `struct hid_device`
> + unsafe { *self.as_raw() }.bus
> + }
> +
> + /// Returns the HID report group.
> + pub fn group(&self) -> Group {
> + // SAFETY: `self.as_raw` is a valid pointer to a `struct hid_device`
> + unsafe { *self.as_raw() }.group.into()
> + }
> +
> + /// Returns the HID vendor ID.
> + pub fn vendor(&self) -> u32 {
> + // SAFETY: `self.as_raw` is a valid pointer to a `struct hid_device`
> + unsafe { *self.as_raw() }.vendor
> + }
> +
> + /// Returns the HID product ID.
> + pub fn product(&self) -> u32 {
> + // SAFETY: `self.as_raw` is a valid pointer to a `struct hid_device`
> + unsafe { *self.as_raw() }.product
> + }
> +}
> +
> +// 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 });
> +kernel::impl_device_context_into_aref!(Device);
> +
> +// SAFETY: Instances of `Device` are always reference-counted.
> +unsafe impl crate::types::AlwaysRefCounted for Device {
> + fn inc_ref(&self) {
> + // SAFETY: The existence of a shared reference guarantees that the refcount is non-zero.
> + unsafe { bindings::get_device(&raw mut (*self.as_raw()).dev) };
> + }
> +
> + unsafe fn dec_ref(obj: NonNull<Self>) {
> + // SAFETY: The safety requirements guarantee that the refcount is non-zero.
> + unsafe { bindings::put_device(&raw mut (*obj.cast::<bindings::hid_device>().as_ptr()).dev) }
> + }
> +}
> +
> +impl<Ctx: device::DeviceContext> AsRef<device::Device<Ctx>> for Device<Ctx> {
> + fn as_ref(&self) -> &device::Device<Ctx> {
> + // SAFETY: By the type invariant of `Self`, `self.as_raw()` is a pointer to a valid
> + // `struct hid_device`.
> + let dev = unsafe { addr_of_mut!((*self.as_raw()).dev) };
> +
> + // SAFETY: `dev` points to a valid `struct device`.
> + unsafe { device::Device::as_ref(dev) }
> + }
> +}
> +
> +/// Abstraction for the HID device ID structure `struct hid_device_id`.
> +#[repr(transparent)]
> +#[derive(Clone, Copy)]
> +pub struct DeviceId(bindings::hid_device_id);
> +
> +impl DeviceId {
> + /// Equivalent to C's `HID_USB_DEVICE` macro.
> + ///
> + /// Create a new `hid::DeviceId` from a group, vendor ID, and device ID
> + /// number.
> + pub const fn new_usb(group: Group, vendor: u32, product: u32) -> Self {
> + Self(bindings::hid_device_id {
> + bus: 0x3, // BUS_USB
> + group: group.into(),
> + vendor,
> + product,
> + driver_data: 0,
> + })
> + }
> +
> + /// Returns the HID transport bus ID.
> + pub fn bus(&self) -> u16 {
> + self.0.bus
> + }
> +
> + /// Returns the HID report group.
> + pub fn group(&self) -> Group {
> + self.0.group.into()
> + }
> +
> + /// Returns the HID vendor ID.
> + pub fn vendor(&self) -> u32 {
> + self.0.vendor
> + }
> +
> + /// Returns the HID product ID.
> + pub fn product(&self) -> u32 {
> + self.0.product
> + }
> +}
> +
> +// SAFETY:
> +// * `DeviceId` is a `#[repr(transparent)` wrapper of `hid_device_id` and does not add
> +// additional invariants, so it's safe to transmute to `RawType`.
> +// * `DRIVER_DATA_OFFSET` is the offset to the `driver_data` field.
> +unsafe impl RawDeviceId for DeviceId {
> + type RawType = bindings::hid_device_id;
> +
> + const DRIVER_DATA_OFFSET: usize = core::mem::offset_of!(bindings::hid_device_id, driver_data);
> +
> + fn index(&self) -> usize {
> + self.0.driver_data
> + }
> +}
> +
> +/// [`IdTable`] type for HID.
> +pub type IdTable<T> = &'static dyn kernel::device_id::IdTable<DeviceId, T>;
> +
> +/// Create a HID [`IdTable`] with its alias for modpost.
> +#[macro_export]
> +macro_rules! hid_device_table {
> + ($table_name:ident, $module_table_name:ident, $id_info_type: ty, $table_data: expr) => {
> + const $table_name: $crate::device_id::IdArray<
> + $crate::hid::DeviceId,
> + $id_info_type,
> + { $table_data.len() },
> + > = $crate::device_id::IdArray::new($table_data);
> +
> + $crate::module_device_table!("hid", $module_table_name, $table_name);
> + };
> +}
> +
> +/// The HID driver trait.
> +///
> +/// # Examples
> +///
> +/// ```
> +/// use kernel::{bindings, device, hid};
> +///
> +/// struct MyDriver;
> +///
> +/// kernel::hid_device_table!(
> +/// HID_TABLE,
> +/// MODULE_HID_TABLE,
> +/// <MyDriver as hid::Driver>::IdInfo,
> +/// [(
> +/// hid::DeviceId::new_usb(
> +/// hid::Group::Steam,
> +/// bindings::USB_VENDOR_ID_VALVE,
> +/// bindings::USB_DEVICE_ID_STEAM_DECK,
> +/// ),
> +/// (),
> +/// )]
> +/// );
> +///
> +/// #[vtable]
> +/// impl hid::Driver for MyDriver {
> +/// type IdInfo = ();
> +/// const ID_TABLE: hid::IdTable<Self::IdInfo> = &HID_TABLE;
> +///
> +/// /// This function is optional to implement.
> +/// fn report_fixup<'a, 'b: 'a>(_hdev: &hid::Device<device::Core>, rdesc: &'b mut [u8]) -> &'a [u8] {
> +/// // Perform some report descriptor fixup.
> +/// rdesc
> +/// }
> +/// }
> +/// ```
> +/// Drivers must implement this trait in order to get a HID driver registered.
> +/// Please refer to the `Adapter` documentation for an example.
> +#[vtable]
> +pub trait Driver: Send {
> + /// The type holding information about each device id supported by the driver.
> + // TODO: Use `associated_type_defaults` once stabilized:
> + //
> + // ```
> + // type IdInfo: 'static = ();
> + // ```
> + type IdInfo: 'static;
> +
> + /// The table of device ids supported by the driver.
> + const ID_TABLE: IdTable<Self::IdInfo>;
> +
> + /// Called before report descriptor parsing. Can be used to mutate the
> + /// report descriptor before the core HID logic processes the descriptor.
> + /// Useful for problematic report descriptors that prevent HID devices from
> + /// functioning correctly.
> + ///
> + /// Optional to implement.
> + fn report_fixup<'a, 'b: 'a>(_hdev: &Device<device::Core>, _rdesc: &'b mut [u8]) -> &'a [u8] {
> + build_error!(VTABLE_DEFAULT_ERROR)
> + }
> +}
> +
> +/// An adapter for the registration of HID drivers.
> +pub struct Adapter<T: Driver>(T);
> +
> +// SAFETY: A call to `unregister` for a given instance of `RegType` is guaranteed to be valid if
> +// a preceding call to `register` has been successful.
> +unsafe impl<T: Driver + 'static> driver::RegistrationOps for Adapter<T> {
> + type RegType = bindings::hid_driver;
> +
> + unsafe fn register(
> + hdrv: &Opaque<Self::RegType>,
> + name: &'static CStr,
> + module: &'static ThisModule,
> + ) -> Result {
> + // SAFETY: It's safe to set the fields of `struct hid_driver` on initialization.
> + unsafe {
> + (*hdrv.get()).name = name.as_char_ptr();
> + (*hdrv.get()).id_table = T::ID_TABLE.as_ptr();
> + (*hdrv.get()).report_fixup = if T::HAS_REPORT_FIXUP {
> + Some(Self::report_fixup_callback)
> + } else {
> + None
> + };
> + }
> +
> + // SAFETY: `hdrv` is guaranteed to be a valid `RegType`
> + to_result(unsafe {
> + bindings::__hid_register_driver(hdrv.get(), module.0, name.as_char_ptr())
> + })
> + }
> +
> + unsafe fn unregister(hdrv: &Opaque<Self::RegType>) {
> + // SAFETY: `hdrv` is guaranteed to be a valid `RegType`
> + unsafe { bindings::hid_unregister_driver(hdrv.get()) }
> + }
> +}
> +
> +impl<T: Driver + 'static> Adapter<T> {
> + extern "C" fn report_fixup_callback(
> + hdev: *mut bindings::hid_device,
> + buf: *mut u8,
> + size: *mut kernel::ffi::c_uint,
> + ) -> *const u8 {
> + // SAFETY: The HID subsystem only ever calls the report_fixup callback
> + // with a valid pointer to a `struct hid_device`.
> + //
> + // INVARIANT: `hdev` is valid for the duration of
> + // `report_fixup_callback()`.
> + let hdev = unsafe { &*hdev.cast::<Device<device::Core>>() };
> +
> + // SAFETY: The HID subsystem only ever calls the report_fixup callback
> + // with a valid pointer to a `kernel::ffi::c_uint`.
> + //
> + // INVARIANT: `size` is valid for the duration of
> + // `report_fixup_callback()`.
> + let buf_len: usize = match unsafe { *size }.try_into() {
> + Ok(len) => len,
> + Err(e) => {
> + dev_err!(
> + hdev.as_ref(),
> + "Cannot fix report description due to {}!\n",
> + e
> + );
> +
> + return buf;
> + }
> + };
> +
> + // Build a mutable Rust slice from `buf` and `size`.
> + //
> + // SAFETY: The HID subsystem only ever calls the `report_fixup callback`
> + // with a valid pointer to a `u8` buffer.
> + //
> + // INVARIANT: `buf` is valid for the duration of
> + // `report_fixup_callback()`.
> + let rdesc_slice = unsafe { core::slice::from_raw_parts_mut(buf, buf_len) };
> + let rdesc_slice = T::report_fixup(hdev, rdesc_slice);
> +
> + match rdesc_slice.len().try_into() {
> + // SAFETY: The HID subsystem only ever calls the report_fixup
> + // callback with a valid pointer to a `kernel::ffi::c_uint`.
> + //
> + // INVARIANT: `size` is valid for the duration of
> + // `report_fixup_callback()`.
> + Ok(len) => unsafe { *size = len },
> + Err(e) => {
> + dev_err!(
> + hdev.as_ref(),
> + "Fixed report description will not be used due to {}!\n",
> + e
> + );
> +
> + return buf;
> + }
> + }
> +
> + rdesc_slice.as_ptr()
> + }
> +}
> +
> +/// Declares a kernel module that exposes a single HID driver.
> +///
> +/// # Examples
> +///
> +/// ```ignore
> +/// kernel::module_hid_driver! {
> +/// type: MyDriver,
> +/// name: "Module name",
> +/// authors: ["Author name"],
> +/// description: "Description",
> +/// license: "GPL",
> +/// }
> +/// ```
> +#[macro_export]
> +macro_rules! module_hid_driver {
> + ($($f:tt)*) => {
> + $crate::module_driver!(<T>, $crate::hid::Adapter<T>, { $($f)* });
> + };
> +}
> diff --git a/rust/kernel/lib.rs b/rust/kernel/lib.rs
> index e88bc4b27d6e..44c107f20174 100644
> --- a/rust/kernel/lib.rs
> +++ b/rust/kernel/lib.rs
> @@ -80,6 +80,8 @@
> pub mod firmware;
> pub mod fmt;
> pub mod fs;
> +#[cfg(CONFIG_RUST_HID_ABSTRACTIONS)]
> +pub mod hid;
> pub mod init;
> pub mod io;
> pub mod ioctl;
> --
> 2.47.2
>
>
^ permalink raw reply
* [GIT PULL] Immutable branch between MFD, GPIO, Input, Pinctrl and PWM due for the v6.18 merge window
From: Lee Jones @ 2025-09-17 10:16 UTC (permalink / raw)
To: Mathieu Dubois-Briand
Cc: Rob Herring, Krzysztof Kozlowski, Conor Dooley, Kamel Bouhara,
Linus Walleij, Bartosz Golaszewski, Dmitry Torokhov,
Uwe Kleine-König, Michael Walle, Mark Brown,
Greg Kroah-Hartman, Rafael J. Wysocki, Danilo Krummrich,
devicetree, linux-kernel, linux-gpio, linux-input, linux-pwm,
andriy.shevchenko, Grégory Clement, Thomas Petazzoni,
Krzysztof Kozlowski, Andy Shevchenko, Bartosz Golaszewski
In-Reply-To: <20250824-mdb-max7360-support-v14-0-435cfda2b1ea@bootlin.com>
Enjoy!
The following changes since commit 8f5ae30d69d7543eee0d70083daf4de8fe15d585:
Linux 6.17-rc1 (2025-08-10 19:41:16 +0300)
are available in the Git repository at:
git://git.kernel.org/pub/scm/linux/kernel/git/lee/mfd.git ib-mfd-gpio-input-pinctrl-pwm-v6.18
for you to fetch changes up to 32d4cedd24ed346edbe063323ed495d685e033df:
MAINTAINERS: Add entry on MAX7360 driver (2025-09-16 15:24:48 +0100)
----------------------------------------------------------------
Immutable branch between MFD, GPIO, Input, Pinctrl and PWM due for the v6.18 merge window
----------------------------------------------------------------
Kamel Bouhara (2):
mfd: Add max7360 support
pwm: max7360: Add MAX7360 PWM support
Mathieu Dubois-Briand (8):
dt-bindings: mfd: gpio: Add MAX7360
pinctrl: Add MAX7360 pinctrl driver
gpio: regmap: Allow to allocate regmap-irq device
gpio: regmap: Allow to provide init_valid_mask callback
gpio: max7360: Add MAX7360 gpio support
input: keyboard: Add support for MAX7360 keypad
input: misc: Add support for MAX7360 rotary
MAINTAINERS: Add entry on MAX7360 driver
.../bindings/gpio/maxim,max7360-gpio.yaml | 83 ++++++
.../devicetree/bindings/mfd/maxim,max7360.yaml | 191 +++++++++++++
MAINTAINERS | 13 +
drivers/gpio/Kconfig | 12 +
drivers/gpio/Makefile | 1 +
drivers/gpio/gpio-max7360.c | 257 +++++++++++++++++
drivers/gpio/gpio-regmap.c | 30 +-
drivers/input/keyboard/Kconfig | 12 +
drivers/input/keyboard/Makefile | 1 +
drivers/input/keyboard/max7360-keypad.c | 308 +++++++++++++++++++++
drivers/input/misc/Kconfig | 10 +
drivers/input/misc/Makefile | 1 +
drivers/input/misc/max7360-rotary.c | 192 +++++++++++++
drivers/mfd/Kconfig | 14 +
drivers/mfd/Makefile | 1 +
drivers/mfd/max7360.c | 171 ++++++++++++
drivers/pinctrl/Kconfig | 11 +
drivers/pinctrl/Makefile | 1 +
drivers/pinctrl/pinctrl-max7360.c | 215 ++++++++++++++
drivers/pwm/Kconfig | 10 +
drivers/pwm/Makefile | 1 +
drivers/pwm/pwm-max7360.c | 209 ++++++++++++++
include/linux/gpio/regmap.h | 18 ++
include/linux/mfd/max7360.h | 109 ++++++++
24 files changed, 1869 insertions(+), 2 deletions(-)
create mode 100644 Documentation/devicetree/bindings/gpio/maxim,max7360-gpio.yaml
create mode 100644 Documentation/devicetree/bindings/mfd/maxim,max7360.yaml
create mode 100644 drivers/gpio/gpio-max7360.c
create mode 100644 drivers/input/keyboard/max7360-keypad.c
create mode 100644 drivers/input/misc/max7360-rotary.c
create mode 100644 drivers/mfd/max7360.c
create mode 100644 drivers/pinctrl/pinctrl-max7360.c
create mode 100644 drivers/pwm/pwm-max7360.c
create mode 100644 include/linux/mfd/max7360.h
--
Lee Jones [李琼斯]
^ permalink raw reply
* Re: (subset) [PATCH v3 RESEND RESEND 0/3] Initial work for Rust abstraction for HID device driver development
From: Benjamin Tissoires @ 2025-09-17 10:25 UTC (permalink / raw)
To: linux-input, linux-kernel, rust-for-linux, Rahul Rameshbabu
Cc: Jiri Kosina, a.hindborg, alex.gaynor, aliceryhl, bjorn3_gh,
boqun.feng, dakr, db48x, gary, ojeda, tmgross, peter.hutterer,
Benno Lossin, Benjamin Tissoires
In-Reply-To: <20250913161222.3889-1-sergeantsagara@protonmail.com>
On Sat, 13 Sep 2025 16:12:43 +0000, Rahul Rameshbabu wrote:
> I am doing another resend. Let me know if it makes sense to start sending out
> work I have on top of these changes. I wanted to wait till these changes got
> merged first but maybe that is not the right strategy?
>
> https://lore.kernel.org/rust-for-linux/20250721020211.196394-2-sergeantsagara@protonmail.com/
>
> I incorporated Danilo's and Miguel's feedback from my v2. Additionally, I
> noticed I had basic formatting issues when running scripts/checkpatch.pl.
> I made sure to check the generated rustdocs and that the Rust examples
> compile as part of the kunit infrastructure. I dropped the kref bindings
> as they are no longer needed for this series.
>
> [...]
Applied to hid/hid.git (for-6.18/core), thanks!
[1/3] HID: core: Change hid_driver to use a const char* for name
https://git.kernel.org/hid/hid/c/d1dd75c6500c
Cheers,
--
Benjamin Tissoires <bentiss@kernel.org>
^ permalink raw reply
* Re: [PATCH v3] HID: lg-g15 - Add support for Logitech G13.
From: Hans de Goede @ 2025-09-17 10:33 UTC (permalink / raw)
To: Leo L. Schwab
Cc: Kate Hsuan, Jiri Kosina, Benjamin Tissoires, linux-input,
linux-kernel
In-Reply-To: <aMiQsMtyX9POrXof@ewhac.org>
Hi Leo,
On 16-Sep-25 00:18, Leo L. Schwab wrote:
> On Wed, Sep 10, 2025 at 09:16:45PM +0200, Hans de Goede wrote:
>> Since the driver writes any new values to the G13 and the G13 accepts
>> those and remembers them even when the backlight is off,
>> the notify() should be passed g15_led->brightness when an
>> off -> on transition happens (and 0 or LED_OFF for the on -> off
>> transition).
>>
>> Since g15_led->brightness gets initialized by reading the actual
>> setting from the G13 at probe time and then gets updated on
>> any successful completion if writing a new brightness value
>> to the G13, it should always reflect the value which the backlight
>> will be set at by the G13 after an off -> on transition.
>>
>> Or am I missing something ?
>>
> If I'm understanding you correctly:
> You want `brightness` to be copied to `brightness_hw_changed` on
> probe, and on every backlight off->on transition (cool so far).
Just to clarify, there are 2 things here
1: brightness as in the actual rgb/brightness values the backlight will
be lit with when it is on
2. A backlight_disabled flag to indicate if the backlight is disabled
in hw by the button on the G13
I would suggest to track those separately by adding a backlight_disabled
(or backlight_enabled) flag to struct lg_g15_data like I do in the
g510 patch I send earlier in the thread.
So wrt copying things on probe() I would copy both the brightness
to g15_led->brightness which is already done in v3 as well as
use something like:
ret = hid_hw_raw_request(g15->hdev, LG_G510_INPUT_KBD_BACKLIGHT,
g15->transfer_buf, 2,
HID_INPUT_REPORT, HID_REQ_GET_REPORT);
to get the input-report with the backlight_enabled/disabled flag and
initialize backlight_disabled based on that.
I would not touch mcled.cdev.brightness_hw_changed directly,
not touching this will also avoid the build issues when
support for it is disabled.
Ack to on detecting a backlight off->on transition based on comparing
the input-report bit to the cached backlight_disabled flag pass
the cached g15_led->brightness to notify()
> What do you want to happen to `brightness_hw_changed` when
> `brightness` is changed in sysfs while the backlight is on? As it stands,
> the current behavior is:
> * Driver loads and probes; `brightness` and `brightness_hw_changed`
> both set to 255.
Ack, except that as mentioned above I would not touch brightness_hw_changed
and just leave it at -1.
> * sysfs `brightness` changed to 128. `brightness_hw_changed`
> remains at 255.
> * Toggle backilght off. `brightness_hw_changed` changed to 0.
> `brightness` remains at 128.
> * Toggle backlight back on. `brightness_hw_changed` gets a copy of
> `brightness`, and both are now 128.
Ack this is all correct.
> This seems inconsistent to me.
This is working as intended / how the API was designed as
Documentation/ABI/testing/sysfs-class-led says:
Reading this file will return the last brightness level set
by the hardware, this may be different from the current
brightness. Reading this file when no hw brightness change
event has happened will return an ENODATA error.
> Hence my earlier suggestion that
> `brightness_hw_changed` should track all changes to `brightness`, except
> when the backlight is toggled off.
Then it also would be reporting values coming from sysfs writes,
which it explicitly should not do.
Summarizing in my view the following changes are necessary on v4:
1. Add backlight_disabled (or backlight_enabled) flag to struct lg_g15_data
2. Init that flag from prope()
3. Use that flag on receiving input reports to see if notify()
should be called
4. Replace the LED_FULL passed to notify() (for off->on)
with g15_led->brightness
and that is it, with those changes I believe that we should be
good to go.
Regards,
Hans
^ permalink raw reply
* Re: (subset) [PATCH v3 RESEND RESEND 0/3] Initial work for Rust abstraction for HID device driver development
From: Rahul Rameshbabu @ 2025-09-17 11:59 UTC (permalink / raw)
To: Benjamin Tissoires
Cc: linux-input, linux-kernel, rust-for-linux, Jiri Kosina,
a.hindborg, alex.gaynor, aliceryhl, bjorn3_gh, boqun.feng, dakr,
db48x, gary, ojeda, tmgross, peter.hutterer, Benno Lossin
In-Reply-To: <175810473311.3076338.14309101339951114135.b4-ty@kernel.org>
On Wed, 17 Sep, 2025 12:25:33 +0200 "Benjamin Tissoires" <bentiss@kernel.org> wrote:
> On Sat, 13 Sep 2025 16:12:43 +0000, Rahul Rameshbabu wrote:
>> I am doing another resend. Let me know if it makes sense to start sending out
>> work I have on top of these changes. I wanted to wait till these changes got
>> merged first but maybe that is not the right strategy?
>>
>> https://lore.kernel.org/rust-for-linux/20250721020211.196394-2-sergeantsagara@protonmail.com/
>>
>> I incorporated Danilo's and Miguel's feedback from my v2. Additionally, I
>> noticed I had basic formatting issues when running scripts/checkpatch.pl.
>> I made sure to check the generated rustdocs and that the Rust examples
>> compile as part of the kunit infrastructure. I dropped the kref bindings
>> as they are no longer needed for this series.
>>
>> [...]
>
> Applied to hid/hid.git (for-6.18/core), thanks!
>
> [1/3] HID: core: Change hid_driver to use a const char* for name
> https://git.kernel.org/hid/hid/c/d1dd75c6500c
>
Thanks!
It will be nice not having to carry around that small cleanup patch.
-- Rahul Rameshbabu
^ permalink raw reply
* Re: [PATCH v3 RESEND RESEND 2/3] rust: core abstractions for HID drivers
From: Rahul Rameshbabu @ 2025-09-17 12:08 UTC (permalink / raw)
To: Benjamin Tissoires
Cc: linux-input, linux-kernel, rust-for-linux, Jiri Kosina,
a.hindborg, alex.gaynor, aliceryhl, benno.lossin,
Benjamin Tissoires, bjorn3_gh, boqun.feng, dakr, db48x, gary,
ojeda, tmgross, peter.hutterer
In-Reply-To: <wjfjzjc626n55zvhksiyldobwubr2imbvfavqej333lvnka2wn@r4zfcjqtanvu>
On Wed, 17 Sep, 2025 12:04:30 +0200 "Benjamin Tissoires" <bentiss@kernel.org> wrote:
> On Sep 13 2025, Rahul Rameshbabu wrote:
>> These abstractions enable the development of HID drivers in Rust by binding
>> with the HID core C API. They provide Rust types that map to the
>> equivalents in C. In this initial draft, only hid_device and hid_device_id
>> are provided direct Rust type equivalents. hid_driver is specially wrapped
>> with a custom Driver type. The module_hid_driver! macro provides analogous
>> functionality to its C equivalent. Only the .report_fixup callback is
>> binded to Rust so far.
>>
>> Future work for these abstractions would include more bindings for common
>> HID-related types, such as hid_field, hid_report_enum, and hid_report as
>> well as more bus callbacks. Providing Rust equivalents to useful core HID
>> functions will also be necessary for HID driver development in Rust.
>>
>> Signed-off-by: Rahul Rameshbabu <sergeantsagara@protonmail.com>
>> ---
>>
>> Notes:
>> Some points I did not address from the last review cycle:
>>
>> * I did not look into autogenerating all the getter functions for various
>> fields exported from the binded C structures.
>> - I would be interested in hearing opinions from folks actively involved
>> with Rust for Linux on this topic.
>>
>> Changelog:
>>
>> v2->v3:
>> * Implemented AlwaysRefCounted trait using embedded struct device's
>> reference counts instead of the separate reference counter in struct
>> hid_device
>> * Used &raw mut as appropriate
>> * Binded include/linux/device.h for get_device and put_device
>> * Cleaned up various comment related formatting
>> * Minified dev_err! format string
>> * Updated Group enum to be repr(u16)
>> * Implemented From<u16> trait for Group
>> * Added TODO comment when const_trait_impl stabilizes
>> * Made group getter functions return a Group variant instead of a raw
>> number
>> * Made sure example code builds
>> v1->v2:
>> * Binded drivers/hid/hid-ids.h for use in Rust drivers
>> * Remove pre-emptive referencing of a C HID driver instance before
>> it is fully initialized in the driver registration path
>> * Moved static getters to generic Device trait implementation, so
>> they can be used by all device::DeviceContext
>> * Use core macros for supporting DeviceContext transitions
>> * Implemented the AlwaysRefCounted and AsRef traits
>> * Make use for dev_err! as appropriate
>> RFC->v1:
>> * Use Danilo's core infrastructure
>> * Account for HID device groups
>> * Remove probe and remove callbacks
>> * Implement report_fixup support
>> * Properly comment code including SAFETY comments
>>
>> MAINTAINERS | 9 +
>> drivers/hid/Kconfig | 8 +
>> rust/bindings/bindings_helper.h | 3 +
>> rust/kernel/hid.rs | 503 ++++++++++++++++++++++++++++++++
>> rust/kernel/lib.rs | 2 +
>> 5 files changed, 525 insertions(+)
>> create mode 100644 rust/kernel/hid.rs
>>
>> diff --git a/MAINTAINERS b/MAINTAINERS
>> index dd810da5261b..6c60765f2aaa 100644
>> --- a/MAINTAINERS
>> +++ b/MAINTAINERS
>> @@ -10686,6 +10686,15 @@ F: include/uapi/linux/hid*
>> F: samples/hid/
>> F: tools/testing/selftests/hid/
>>
>> +HID CORE LAYER [RUST]
>> +M: Rahul Rameshbabu <sergeantsagara@protonmail.com>
>> +R: Benjamin Tissoires <bentiss@kernel.org>
>> +L: linux-input@vger.kernel.org
>> +S: Maintained
>> +T: git git://git.kernel.org/pub/scm/linux/kernel/git/hid/hid.git rust
>
> FWIW, we (HID maintainers) are still undecided on how to handle that,
> and so it's a little bit postponed for now
Sure, understandable. I am going to send v4 without updating the
MAINTAINERS file, so we are aligned that this is still up for
discussion. My only concern is that I have been holding off patches for
a more complex HID driver in Rust. I am wondering if it would be good to
send out those changes as a separate series that builds on top of this
one while this discussion occurs. Ideally, I do not want to end up in
the situation where I'll have to maintain too many patches out of tree
long term (6+ months). I think starting out of tree and documenting this
on the rust-for-linux project page might be viable. Maybe some input on
the rust-for-linux side would help.
>
>> +F: drivers/hid/*.rs
>
> Could you instead make it really independant by relying on
> drivers/hid/rust instead?
> We already have drivers/hid/bpf for HID-BPF related stuff, so it doesn't
> seem to be that much of an issue to have a separate rust dir.
>
> This should allow for a cleaner separation without tinkering in Makefile
> or Kconfig if the HID rust tree is handled separately.
Yeah, having the drivers live in drivers/hid/rust should not be a
problem. Let me send out a v4 to handle this as well as another minor
cleanup in the reference driver I implemented (using hex integer
constants instead of decimal).
>
> Cheers,
> Benjamin
>
>> +F: rust/kernel/hid.rs
>> +
>> HID LOGITECH DRIVERS
>> R: Filipe Laíns <lains@riseup.net>
>> L: linux-input@vger.kernel.org
>> diff --git a/drivers/hid/Kconfig b/drivers/hid/Kconfig
>> index 43859fc75747..922e76e18af2 100644
>> --- a/drivers/hid/Kconfig
>> +++ b/drivers/hid/Kconfig
>> @@ -744,6 +744,14 @@ config HID_MEGAWORLD_FF
>> Say Y here if you have a Mega World based game controller and want
>> to have force feedback support for it.
>>
>> +config RUST_HID_ABSTRACTIONS
>> + bool "Rust HID abstractions support"
>> + depends on RUST
>> + depends on HID=y
>> + help
>> + Adds support needed for HID drivers written in Rust. It provides a
>> + wrapper around the C hid core.
>> +
>> config HID_REDRAGON
>> tristate "Redragon keyboards"
>> default !EXPERT
>> diff --git a/rust/bindings/bindings_helper.h b/rust/bindings/bindings_helper.h
>> index 8cbb660e2ec2..7145fb1cdff1 100644
>> --- a/rust/bindings/bindings_helper.h
>> +++ b/rust/bindings/bindings_helper.h
>> @@ -45,6 +45,7 @@
>> #include <linux/cpufreq.h>
>> #include <linux/cpumask.h>
>> #include <linux/cred.h>
>> +#include <linux/device.h>
>> #include <linux/device/faux.h>
>> #include <linux/dma-mapping.h>
>> #include <linux/errname.h>
>> @@ -52,6 +53,8 @@
>> #include <linux/file.h>
>> #include <linux/firmware.h>
>> #include <linux/fs.h>
>> +#include <linux/hid.h>
>> +#include "../../drivers/hid/hid-ids.h"
>> #include <linux/jiffies.h>
>> #include <linux/jump_label.h>
>> #include <linux/mdio.h>
>> diff --git a/rust/kernel/hid.rs b/rust/kernel/hid.rs
>> new file mode 100644
>> index 000000000000..a93804af8b78
>> --- /dev/null
>> +++ b/rust/kernel/hid.rs
>> @@ -0,0 +1,503 @@
>> +// SPDX-License-Identifier: GPL-2.0
>> +
>> +// Copyright (C) 2025 Rahul Rameshbabu <sergeantsagara@protonmail.com>
>> +
>> +//! Abstractions for the HID interface.
>> +//!
>> +//! C header: [`include/linux/hid.h`](srctree/include/linux/hid.h)
>> +
>> +use crate::{device, device_id::RawDeviceId, driver, error::*, prelude::*, types::Opaque};
>> +use core::{
>> + marker::PhantomData,
>> + ptr::{addr_of_mut, NonNull},
>> +};
>> +
>> +/// Indicates the item is static read-only.
>> +///
>> +/// Refer to [Device Class Definition for HID 1.11]
>> +/// Section 6.2.2.5 Input, Output, and Feature Items.
>> +///
>> +/// [Device Class Definition for HID 1.11]: https://www.usb.org/sites/default/files/hid1_11.pdf
>> +pub const MAIN_ITEM_CONSTANT: u8 = bindings::HID_MAIN_ITEM_CONSTANT as u8;
>> +
>> +/// Indicates the item represents data from a physical control.
>> +///
>> +/// Refer to [Device Class Definition for HID 1.11]
>> +/// Section 6.2.2.5 Input, Output, and Feature Items.
>> +///
>> +/// [Device Class Definition for HID 1.11]: https://www.usb.org/sites/default/files/hid1_11.pdf
>> +pub const MAIN_ITEM_VARIABLE: u8 = bindings::HID_MAIN_ITEM_VARIABLE as u8;
>> +
>> +/// Indicates the item should be treated as a relative change from the previous
>> +/// report.
>> +///
>> +/// Refer to [Device Class Definition for HID 1.11]
>> +/// Section 6.2.2.5 Input, Output, and Feature Items.
>> +///
>> +/// [Device Class Definition for HID 1.11]: https://www.usb.org/sites/default/files/hid1_11.pdf
>> +pub const MAIN_ITEM_RELATIVE: u8 = bindings::HID_MAIN_ITEM_RELATIVE as u8;
>> +
>> +/// Indicates the item should wrap around when reaching the extreme high or
>> +/// extreme low values.
>> +///
>> +/// Refer to [Device Class Definition for HID 1.11]
>> +/// Section 6.2.2.5 Input, Output, and Feature Items.
>> +///
>> +/// [Device Class Definition for HID 1.11]: https://www.usb.org/sites/default/files/hid1_11.pdf
>> +pub const MAIN_ITEM_WRAP: u8 = bindings::HID_MAIN_ITEM_WRAP as u8;
>> +
>> +/// Indicates the item should wrap around when reaching the extreme high or
>> +/// extreme low values.
>> +///
>> +/// Refer to [Device Class Definition for HID 1.11]
>> +/// Section 6.2.2.5 Input, Output, and Feature Items.
>> +///
>> +/// [Device Class Definition for HID 1.11]: https://www.usb.org/sites/default/files/hid1_11.pdf
>> +pub const MAIN_ITEM_NONLINEAR: u8 = bindings::HID_MAIN_ITEM_NONLINEAR as u8;
>> +
>> +/// Indicates whether the control has a preferred state it will physically
>> +/// return to without user intervention.
>> +///
>> +/// Refer to [Device Class Definition for HID 1.11]
>> +/// Section 6.2.2.5 Input, Output, and Feature Items.
>> +///
>> +/// [Device Class Definition for HID 1.11]: https://www.usb.org/sites/default/files/hid1_11.pdf
>> +pub const MAIN_ITEM_NO_PREFERRED: u8 = bindings::HID_MAIN_ITEM_NO_PREFERRED as u8;
>> +
>> +/// Indicates whether the control has a physical state where it will not send
>> +/// any reports.
>> +///
>> +/// Refer to [Device Class Definition for HID 1.11]
>> +/// Section 6.2.2.5 Input, Output, and Feature Items.
>> +///
>> +/// [Device Class Definition for HID 1.11]: https://www.usb.org/sites/default/files/hid1_11.pdf
>> +pub const MAIN_ITEM_NULL_STATE: u8 = bindings::HID_MAIN_ITEM_NULL_STATE as u8;
>> +
>> +/// Indicates whether the control requires host system logic to change state.
>> +///
>> +/// Refer to [Device Class Definition for HID 1.11]
>> +/// Section 6.2.2.5 Input, Output, and Feature Items.
>> +///
>> +/// [Device Class Definition for HID 1.11]: https://www.usb.org/sites/default/files/hid1_11.pdf
>> +pub const MAIN_ITEM_VOLATILE: u8 = bindings::HID_MAIN_ITEM_VOLATILE as u8;
>> +
>> +/// Indicates whether the item is fixed size or a variable buffer of bytes.
>> +///
>> +/// Refer to [Device Class Definition for HID 1.11]
>> +/// Section 6.2.2.5 Input, Output, and Feature Items.
>> +///
>> +/// [Device Class Definition for HID 1.11]: https://www.usb.org/sites/default/files/hid1_11.pdf
>> +pub const MAIN_ITEM_BUFFERED_BYTE: u8 = bindings::HID_MAIN_ITEM_BUFFERED_BYTE as u8;
>> +
>> +/// HID device groups are intended to help categories HID devices based on a set
>> +/// of common quirks and logic that they will require to function correctly.
>> +#[repr(u16)]
>> +pub enum Group {
>> + /// Used to match a device against any group when probing.
>> + Any = bindings::HID_GROUP_ANY as u16,
>> +
>> + /// Indicates a generic device that should need no custom logic from the
>> + /// core HID stack.
>> + Generic = bindings::HID_GROUP_GENERIC as u16,
>> +
>> + /// Maps multitouch devices to hid-multitouch instead of hid-generic.
>> + Multitouch = bindings::HID_GROUP_MULTITOUCH as u16,
>> +
>> + /// Used for autodetecing and mapping of HID sensor hubs to
>> + /// hid-sensor-hub.
>> + SensorHub = bindings::HID_GROUP_SENSOR_HUB as u16,
>> +
>> + /// Used for autodetecing and mapping Win 8 multitouch devices to set the
>> + /// needed quirks.
>> + MultitouchWin8 = bindings::HID_GROUP_MULTITOUCH_WIN_8 as u16,
>> +
>> + // Vendor-specific device groups.
>> + /// Used to distinguish Synpatics touchscreens from other products. The
>> + /// touchscreens will be handled by hid-multitouch instead, while everything
>> + /// else will be managed by hid-rmi.
>> + RMI = bindings::HID_GROUP_RMI as u16,
>> +
>> + /// Used for hid-core handling to automatically identify Wacom devices and
>> + /// have them probed by hid-wacom.
>> + Wacom = bindings::HID_GROUP_WACOM as u16,
>> +
>> + /// Used by logitech-djreceiver and logitech-djdevice to autodetect if
>> + /// devices paied to the DJ receivers are DJ devices and handle them with
>> + /// the device driver.
>> + LogitechDJDevice = bindings::HID_GROUP_LOGITECH_DJ_DEVICE as u16,
>> +
>> + /// Since the Valve Steam Controller only has vendor-specific usages,
>> + /// prevent hid-generic from parsing its reports since there would be
>> + /// nothing hid-generic could do for the device.
>> + Steam = bindings::HID_GROUP_STEAM as u16,
>> +
>> + /// Used to differentiate 27 Mhz frequency Logitech DJ devices from other
>> + /// Logitech DJ devices.
>> + Logitech27MHzDevice = bindings::HID_GROUP_LOGITECH_27MHZ_DEVICE as u16,
>> +
>> + /// Used for autodetecting and mapping Vivaldi devices to hid-vivaldi.
>> + Vivaldi = bindings::HID_GROUP_VIVALDI as u16,
>> +}
>> +
>> +// TODO: use `const_trait_impl` once stabilized:
>> +//
>> +// ```
>> +// impl const From<Group> for u16 {
>> +// /// [`Group`] variants are represented by [`u16`] values.
>> +// fn from(value: Group) -> Self {
>> +// value as Self
>> +// }
>> +// }
>> +// ```
>> +impl Group {
>> + /// Internal function used to convert [`Group`] variants into [`u16`].
>> + const fn into(self) -> u16 {
>> + self as u16
>> + }
>> +}
>> +
>> +impl From<u16> for Group {
>> + /// [`u16`] values can be safely converted to [`Group`] variants.
>> + fn from(value: u16) -> Self {
>> + match value.into() {
>> + bindings::HID_GROUP_GENERIC => Group::Generic,
>> + bindings::HID_GROUP_MULTITOUCH => Group::Multitouch,
>> + bindings::HID_GROUP_SENSOR_HUB => Group::SensorHub,
>> + bindings::HID_GROUP_MULTITOUCH_WIN_8 => Group::MultitouchWin8,
>> + bindings::HID_GROUP_RMI => Group::RMI,
>> + bindings::HID_GROUP_WACOM => Group::Wacom,
>> + bindings::HID_GROUP_LOGITECH_DJ_DEVICE => Group::LogitechDJDevice,
>> + bindings::HID_GROUP_STEAM => Group::Steam,
>> + bindings::HID_GROUP_LOGITECH_27MHZ_DEVICE => Group::Logitech27MHzDevice,
>> + bindings::HID_GROUP_VIVALDI => Group::Vivaldi,
>> + _ => Group::Any,
>> + }
>> + }
>> +}
>> +
>> +/// The HID device representation.
>> +///
>> +/// This structure represents the Rust abstraction for a C `struct hid_device`.
>> +/// The implementation abstracts the usage of an already existing C `struct
>> +/// hid_device` within Rust code that we get passed from the C side.
>> +///
>> +/// # Invariants
>> +///
>> +/// A [`Device`] instance represents a valid `struct hid_device` created by the
>> +/// C portion of the kernel.
>> +#[repr(transparent)]
>> +pub struct Device<Ctx: device::DeviceContext = device::Normal>(
>> + Opaque<bindings::hid_device>,
>> + PhantomData<Ctx>,
>> +);
>> +
>> +impl<Ctx: device::DeviceContext> Device<Ctx> {
>> + fn as_raw(&self) -> *mut bindings::hid_device {
>> + self.0.get()
>> + }
>> +
>> + /// Returns the HID transport bus ID.
>> + pub fn bus(&self) -> u16 {
>> + // SAFETY: `self.as_raw` is a valid pointer to a `struct hid_device`
>> + unsafe { *self.as_raw() }.bus
>> + }
>> +
>> + /// Returns the HID report group.
>> + pub fn group(&self) -> Group {
>> + // SAFETY: `self.as_raw` is a valid pointer to a `struct hid_device`
>> + unsafe { *self.as_raw() }.group.into()
>> + }
>> +
>> + /// Returns the HID vendor ID.
>> + pub fn vendor(&self) -> u32 {
>> + // SAFETY: `self.as_raw` is a valid pointer to a `struct hid_device`
>> + unsafe { *self.as_raw() }.vendor
>> + }
>> +
>> + /// Returns the HID product ID.
>> + pub fn product(&self) -> u32 {
>> + // SAFETY: `self.as_raw` is a valid pointer to a `struct hid_device`
>> + unsafe { *self.as_raw() }.product
>> + }
>> +}
>> +
>> +// 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 });
>> +kernel::impl_device_context_into_aref!(Device);
>> +
>> +// SAFETY: Instances of `Device` are always reference-counted.
>> +unsafe impl crate::types::AlwaysRefCounted for Device {
>> + fn inc_ref(&self) {
>> + // SAFETY: The existence of a shared reference guarantees that the refcount is non-zero.
>> + unsafe { bindings::get_device(&raw mut (*self.as_raw()).dev) };
>> + }
>> +
>> + unsafe fn dec_ref(obj: NonNull<Self>) {
>> + // SAFETY: The safety requirements guarantee that the refcount is non-zero.
>> + unsafe { bindings::put_device(&raw mut (*obj.cast::<bindings::hid_device>().as_ptr()).dev) }
>> + }
>> +}
>> +
>> +impl<Ctx: device::DeviceContext> AsRef<device::Device<Ctx>> for Device<Ctx> {
>> + fn as_ref(&self) -> &device::Device<Ctx> {
>> + // SAFETY: By the type invariant of `Self`, `self.as_raw()` is a pointer to a valid
>> + // `struct hid_device`.
>> + let dev = unsafe { addr_of_mut!((*self.as_raw()).dev) };
>> +
>> + // SAFETY: `dev` points to a valid `struct device`.
>> + unsafe { device::Device::as_ref(dev) }
>> + }
>> +}
>> +
>> +/// Abstraction for the HID device ID structure `struct hid_device_id`.
>> +#[repr(transparent)]
>> +#[derive(Clone, Copy)]
>> +pub struct DeviceId(bindings::hid_device_id);
>> +
>> +impl DeviceId {
>> + /// Equivalent to C's `HID_USB_DEVICE` macro.
>> + ///
>> + /// Create a new `hid::DeviceId` from a group, vendor ID, and device ID
>> + /// number.
>> + pub const fn new_usb(group: Group, vendor: u32, product: u32) -> Self {
>> + Self(bindings::hid_device_id {
>> + bus: 0x3, // BUS_USB
>> + group: group.into(),
>> + vendor,
>> + product,
>> + driver_data: 0,
>> + })
>> + }
>> +
>> + /// Returns the HID transport bus ID.
>> + pub fn bus(&self) -> u16 {
>> + self.0.bus
>> + }
>> +
>> + /// Returns the HID report group.
>> + pub fn group(&self) -> Group {
>> + self.0.group.into()
>> + }
>> +
>> + /// Returns the HID vendor ID.
>> + pub fn vendor(&self) -> u32 {
>> + self.0.vendor
>> + }
>> +
>> + /// Returns the HID product ID.
>> + pub fn product(&self) -> u32 {
>> + self.0.product
>> + }
>> +}
>> +
>> +// SAFETY:
>> +// * `DeviceId` is a `#[repr(transparent)` wrapper of `hid_device_id` and does not add
>> +// additional invariants, so it's safe to transmute to `RawType`.
>> +// * `DRIVER_DATA_OFFSET` is the offset to the `driver_data` field.
>> +unsafe impl RawDeviceId for DeviceId {
>> + type RawType = bindings::hid_device_id;
>> +
>> + const DRIVER_DATA_OFFSET: usize = core::mem::offset_of!(bindings::hid_device_id, driver_data);
>> +
>> + fn index(&self) -> usize {
>> + self.0.driver_data
>> + }
>> +}
>> +
>> +/// [`IdTable`] type for HID.
>> +pub type IdTable<T> = &'static dyn kernel::device_id::IdTable<DeviceId, T>;
>> +
>> +/// Create a HID [`IdTable`] with its alias for modpost.
>> +#[macro_export]
>> +macro_rules! hid_device_table {
>> + ($table_name:ident, $module_table_name:ident, $id_info_type: ty, $table_data: expr) => {
>> + const $table_name: $crate::device_id::IdArray<
>> + $crate::hid::DeviceId,
>> + $id_info_type,
>> + { $table_data.len() },
>> + > = $crate::device_id::IdArray::new($table_data);
>> +
>> + $crate::module_device_table!("hid", $module_table_name, $table_name);
>> + };
>> +}
>> +
>> +/// The HID driver trait.
>> +///
>> +/// # Examples
>> +///
>> +/// ```
>> +/// use kernel::{bindings, device, hid};
>> +///
>> +/// struct MyDriver;
>> +///
>> +/// kernel::hid_device_table!(
>> +/// HID_TABLE,
>> +/// MODULE_HID_TABLE,
>> +/// <MyDriver as hid::Driver>::IdInfo,
>> +/// [(
>> +/// hid::DeviceId::new_usb(
>> +/// hid::Group::Steam,
>> +/// bindings::USB_VENDOR_ID_VALVE,
>> +/// bindings::USB_DEVICE_ID_STEAM_DECK,
>> +/// ),
>> +/// (),
>> +/// )]
>> +/// );
>> +///
>> +/// #[vtable]
>> +/// impl hid::Driver for MyDriver {
>> +/// type IdInfo = ();
>> +/// const ID_TABLE: hid::IdTable<Self::IdInfo> = &HID_TABLE;
>> +///
>> +/// /// This function is optional to implement.
>> +/// fn report_fixup<'a, 'b: 'a>(_hdev: &hid::Device<device::Core>, rdesc: &'b mut [u8]) -> &'a [u8] {
>> +/// // Perform some report descriptor fixup.
>> +/// rdesc
>> +/// }
>> +/// }
>> +/// ```
>> +/// Drivers must implement this trait in order to get a HID driver registered.
>> +/// Please refer to the `Adapter` documentation for an example.
>> +#[vtable]
>> +pub trait Driver: Send {
>> + /// The type holding information about each device id supported by the driver.
>> + // TODO: Use `associated_type_defaults` once stabilized:
>> + //
>> + // ```
>> + // type IdInfo: 'static = ();
>> + // ```
>> + type IdInfo: 'static;
>> +
>> + /// The table of device ids supported by the driver.
>> + const ID_TABLE: IdTable<Self::IdInfo>;
>> +
>> + /// Called before report descriptor parsing. Can be used to mutate the
>> + /// report descriptor before the core HID logic processes the descriptor.
>> + /// Useful for problematic report descriptors that prevent HID devices from
>> + /// functioning correctly.
>> + ///
>> + /// Optional to implement.
>> + fn report_fixup<'a, 'b: 'a>(_hdev: &Device<device::Core>, _rdesc: &'b mut [u8]) -> &'a [u8] {
>> + build_error!(VTABLE_DEFAULT_ERROR)
>> + }
>> +}
>> +
>> +/// An adapter for the registration of HID drivers.
>> +pub struct Adapter<T: Driver>(T);
>> +
>> +// SAFETY: A call to `unregister` for a given instance of `RegType` is guaranteed to be valid if
>> +// a preceding call to `register` has been successful.
>> +unsafe impl<T: Driver + 'static> driver::RegistrationOps for Adapter<T> {
>> + type RegType = bindings::hid_driver;
>> +
>> + unsafe fn register(
>> + hdrv: &Opaque<Self::RegType>,
>> + name: &'static CStr,
>> + module: &'static ThisModule,
>> + ) -> Result {
>> + // SAFETY: It's safe to set the fields of `struct hid_driver` on initialization.
>> + unsafe {
>> + (*hdrv.get()).name = name.as_char_ptr();
>> + (*hdrv.get()).id_table = T::ID_TABLE.as_ptr();
>> + (*hdrv.get()).report_fixup = if T::HAS_REPORT_FIXUP {
>> + Some(Self::report_fixup_callback)
>> + } else {
>> + None
>> + };
>> + }
>> +
>> + // SAFETY: `hdrv` is guaranteed to be a valid `RegType`
>> + to_result(unsafe {
>> + bindings::__hid_register_driver(hdrv.get(), module.0, name.as_char_ptr())
>> + })
>> + }
>> +
>> + unsafe fn unregister(hdrv: &Opaque<Self::RegType>) {
>> + // SAFETY: `hdrv` is guaranteed to be a valid `RegType`
>> + unsafe { bindings::hid_unregister_driver(hdrv.get()) }
>> + }
>> +}
>> +
>> +impl<T: Driver + 'static> Adapter<T> {
>> + extern "C" fn report_fixup_callback(
>> + hdev: *mut bindings::hid_device,
>> + buf: *mut u8,
>> + size: *mut kernel::ffi::c_uint,
>> + ) -> *const u8 {
>> + // SAFETY: The HID subsystem only ever calls the report_fixup callback
>> + // with a valid pointer to a `struct hid_device`.
>> + //
>> + // INVARIANT: `hdev` is valid for the duration of
>> + // `report_fixup_callback()`.
>> + let hdev = unsafe { &*hdev.cast::<Device<device::Core>>() };
>> +
>> + // SAFETY: The HID subsystem only ever calls the report_fixup callback
>> + // with a valid pointer to a `kernel::ffi::c_uint`.
>> + //
>> + // INVARIANT: `size` is valid for the duration of
>> + // `report_fixup_callback()`.
>> + let buf_len: usize = match unsafe { *size }.try_into() {
>> + Ok(len) => len,
>> + Err(e) => {
>> + dev_err!(
>> + hdev.as_ref(),
>> + "Cannot fix report description due to {}!\n",
>> + e
>> + );
>> +
>> + return buf;
>> + }
>> + };
>> +
>> + // Build a mutable Rust slice from `buf` and `size`.
>> + //
>> + // SAFETY: The HID subsystem only ever calls the `report_fixup callback`
>> + // with a valid pointer to a `u8` buffer.
>> + //
>> + // INVARIANT: `buf` is valid for the duration of
>> + // `report_fixup_callback()`.
>> + let rdesc_slice = unsafe { core::slice::from_raw_parts_mut(buf, buf_len) };
>> + let rdesc_slice = T::report_fixup(hdev, rdesc_slice);
>> +
>> + match rdesc_slice.len().try_into() {
>> + // SAFETY: The HID subsystem only ever calls the report_fixup
>> + // callback with a valid pointer to a `kernel::ffi::c_uint`.
>> + //
>> + // INVARIANT: `size` is valid for the duration of
>> + // `report_fixup_callback()`.
>> + Ok(len) => unsafe { *size = len },
>> + Err(e) => {
>> + dev_err!(
>> + hdev.as_ref(),
>> + "Fixed report description will not be used due to {}!\n",
>> + e
>> + );
>> +
>> + return buf;
>> + }
>> + }
>> +
>> + rdesc_slice.as_ptr()
>> + }
>> +}
>> +
>> +/// Declares a kernel module that exposes a single HID driver.
>> +///
>> +/// # Examples
>> +///
>> +/// ```ignore
>> +/// kernel::module_hid_driver! {
>> +/// type: MyDriver,
>> +/// name: "Module name",
>> +/// authors: ["Author name"],
>> +/// description: "Description",
>> +/// license: "GPL",
>> +/// }
>> +/// ```
>> +#[macro_export]
>> +macro_rules! module_hid_driver {
>> + ($($f:tt)*) => {
>> + $crate::module_driver!(<T>, $crate::hid::Adapter<T>, { $($f)* });
>> + };
>> +}
>> diff --git a/rust/kernel/lib.rs b/rust/kernel/lib.rs
>> index e88bc4b27d6e..44c107f20174 100644
>> --- a/rust/kernel/lib.rs
>> +++ b/rust/kernel/lib.rs
>> @@ -80,6 +80,8 @@
>> pub mod firmware;
>> pub mod fmt;
>> pub mod fs;
>> +#[cfg(CONFIG_RUST_HID_ABSTRACTIONS)]
>> +pub mod hid;
>> pub mod init;
>> pub mod io;
>> pub mod ioctl;
>> --
>> 2.47.2
>>
>>
^ permalink raw reply
* Re: [PATCH v2 03/11] HID: playstation: Simplify locking with guard() and scoped_guard()
From: Benjamin Tissoires @ 2025-09-17 13:50 UTC (permalink / raw)
To: Cristian Ciocaltea
Cc: Roderick Colenbrander, Jiri Kosina, Henrik Rydberg, kernel,
linux-input, linux-kernel
In-Reply-To: <20250625-dualsense-hid-jack-v2-3-596c0db14128@collabora.com>
On Jun 25 2025, Cristian Ciocaltea wrote:
> Use guard() and scoped_guard() infrastructure instead of explicitly
> acquiring and releasing spinlocks and mutexes to simplify the code and
> ensure that all locks are released properly.
>
> Signed-off-by: Cristian Ciocaltea <cristian.ciocaltea@collabora.com>
It looks like the patch is now creating sparse errors:
https://gitlab.freedesktop.org/bentiss/hid/-/jobs/84636162
with:
drivers/hid/hid-playstation.c:1187:32: warning: context imbalance in 'dualsense_player_led_set_brightness' - wrong count at exit
drivers/hid/hid-playstation.c:1403:9: warning: context imbalance in 'dualsense_parse_report' - different lock contexts for basic block
drivers/hid/hid-playstation.c:1499:12: warning: context imbalance in 'dualsense_play_effect' - different lock contexts for basic block
drivers/hid/hid-playstation.c:1552:13: warning: context imbalance in 'dualsense_set_lightbar' - wrong count at exit
drivers/hid/hid-playstation.c:1564:13: warning: context imbalance in 'dualsense_set_player_leds' - wrong count at exit
drivers/hid/hid-playstation.c:2054:33: warning: context imbalance in 'dualshock4_led_set_blink' - wrong count at exit
drivers/hid/hid-playstation.c:2095:33: warning: context imbalance in 'dualshock4_led_set_brightness' - wrong count at exit
drivers/hid/hid-playstation.c:2463:12: warning: context imbalance in 'dualshock4_play_effect' - different lock contexts for basic block
drivers/hid/hid-playstation.c:2501:13: warning: context imbalance in 'dualshock4_set_bt_poll_interval' - wrong count at exit
drivers/hid/hid-playstation.c:2509:13: warning: context imbalance in 'dualshock4_set_default_lightbar_colors' - wrong count at exit
(the artifacts are going to be removed in 4 hours, so better document
the line numbers here).
I am under the impression that it's because the 2 *_output_worker
functions are not using scoped guarding, but it could very well be
something entirely different. Do you mind taking a look as well?
Cheers,
Benjamin
> ---
> drivers/hid/hid-playstation.c | 216 ++++++++++++++++++------------------------
> 1 file changed, 93 insertions(+), 123 deletions(-)
>
> diff --git a/drivers/hid/hid-playstation.c b/drivers/hid/hid-playstation.c
> index 799b47cdfe034c2b78ec589ac19e3c7a764dc784..ab3a0c505c4db9110ae4d528ba70b32d9f90b81b 100644
> --- a/drivers/hid/hid-playstation.c
> +++ b/drivers/hid/hid-playstation.c
> @@ -7,6 +7,7 @@
>
> #include <linux/bitfield.h>
> #include <linux/bits.h>
> +#include <linux/cleanup.h>
> #include <linux/crc32.h>
> #include <linux/device.h>
> #include <linux/hid.h>
> @@ -566,26 +567,25 @@ static int ps_devices_list_add(struct ps_device *dev)
> {
> struct ps_device *entry;
>
> - mutex_lock(&ps_devices_lock);
> + guard(mutex)(&ps_devices_lock);
> +
> list_for_each_entry(entry, &ps_devices_list, list) {
> if (!memcmp(entry->mac_address, dev->mac_address, sizeof(dev->mac_address))) {
> hid_err(dev->hdev, "Duplicate device found for MAC address %pMR.\n",
> dev->mac_address);
> - mutex_unlock(&ps_devices_lock);
> return -EEXIST;
> }
> }
>
> list_add_tail(&dev->list, &ps_devices_list);
> - mutex_unlock(&ps_devices_lock);
> return 0;
> }
>
> static int ps_devices_list_remove(struct ps_device *dev)
> {
> - mutex_lock(&ps_devices_lock);
> + guard(mutex)(&ps_devices_lock);
> +
> list_del(&dev->list);
> - mutex_unlock(&ps_devices_lock);
> return 0;
> }
>
> @@ -649,13 +649,12 @@ static int ps_battery_get_property(struct power_supply *psy,
> struct ps_device *dev = power_supply_get_drvdata(psy);
> uint8_t battery_capacity;
> int battery_status;
> - unsigned long flags;
> int ret = 0;
>
> - spin_lock_irqsave(&dev->lock, flags);
> - battery_capacity = dev->battery_capacity;
> - battery_status = dev->battery_status;
> - spin_unlock_irqrestore(&dev->lock, flags);
> + scoped_guard(spinlock_irqsave, &dev->lock) {
> + battery_capacity = dev->battery_capacity;
> + battery_status = dev->battery_status;
> + }
>
> switch (psp) {
> case POWER_SUPPLY_PROP_STATUS:
> @@ -1173,19 +1172,17 @@ static int dualsense_player_led_set_brightness(struct led_classdev *led, enum le
> {
> struct hid_device *hdev = to_hid_device(led->dev->parent);
> struct dualsense *ds = hid_get_drvdata(hdev);
> - unsigned long flags;
> unsigned int led_index;
>
> - spin_lock_irqsave(&ds->base.lock, flags);
> -
> - led_index = led - ds->player_leds;
> - if (value == LED_OFF)
> - ds->player_leds_state &= ~BIT(led_index);
> - else
> - ds->player_leds_state |= BIT(led_index);
> + scoped_guard(spinlock_irqsave, &ds->base.lock) {
> + led_index = led - ds->player_leds;
> + if (value == LED_OFF)
> + ds->player_leds_state &= ~BIT(led_index);
> + else
> + ds->player_leds_state |= BIT(led_index);
>
> - ds->update_player_leds = true;
> - spin_unlock_irqrestore(&ds->base.lock, flags);
> + ds->update_player_leds = true;
> + }
>
> dualsense_schedule_work(ds);
>
> @@ -1234,12 +1231,9 @@ static void dualsense_init_output_report(struct dualsense *ds, struct dualsense_
>
> static inline void dualsense_schedule_work(struct dualsense *ds)
> {
> - unsigned long flags;
> -
> - spin_lock_irqsave(&ds->base.lock, flags);
> + guard(spinlock_irqsave)(&ds->base.lock);
> if (ds->output_worker_initialized)
> schedule_work(&ds->output_worker);
> - spin_unlock_irqrestore(&ds->base.lock, flags);
> }
>
> /*
> @@ -1337,7 +1331,6 @@ static int dualsense_parse_report(struct ps_device *ps_dev, struct hid_report *r
> int battery_status;
> uint32_t sensor_timestamp;
> bool btn_mic_state;
> - unsigned long flags;
> int i;
>
> /*
> @@ -1399,10 +1392,10 @@ static int dualsense_parse_report(struct ps_device *ps_dev, struct hid_report *r
> */
> btn_mic_state = !!(ds_report->buttons[2] & DS_BUTTONS2_MIC_MUTE);
> if (btn_mic_state && !ds->last_btn_mic_state) {
> - spin_lock_irqsave(&ps_dev->lock, flags);
> - ds->update_mic_mute = true;
> - ds->mic_muted = !ds->mic_muted; /* toggle */
> - spin_unlock_irqrestore(&ps_dev->lock, flags);
> + scoped_guard(spinlock_irqsave, &ps_dev->lock) {
> + ds->update_mic_mute = true;
> + ds->mic_muted = !ds->mic_muted; /* toggle */
> + }
>
> /* Schedule updating of microphone state at hardware level. */
> dualsense_schedule_work(ds);
> @@ -1495,10 +1488,10 @@ static int dualsense_parse_report(struct ps_device *ps_dev, struct hid_report *r
> battery_status = POWER_SUPPLY_STATUS_UNKNOWN;
> }
>
> - spin_lock_irqsave(&ps_dev->lock, flags);
> - ps_dev->battery_capacity = battery_capacity;
> - ps_dev->battery_status = battery_status;
> - spin_unlock_irqrestore(&ps_dev->lock, flags);
> + scoped_guard(spinlock_irqsave, &ps_dev->lock) {
> + ps_dev->battery_capacity = battery_capacity;
> + ps_dev->battery_status = battery_status;
> + }
>
> return 0;
> }
> @@ -1507,16 +1500,15 @@ static int dualsense_play_effect(struct input_dev *dev, void *data, struct ff_ef
> {
> struct hid_device *hdev = input_get_drvdata(dev);
> struct dualsense *ds = hid_get_drvdata(hdev);
> - unsigned long flags;
>
> if (effect->type != FF_RUMBLE)
> return 0;
>
> - spin_lock_irqsave(&ds->base.lock, flags);
> - ds->update_rumble = true;
> - ds->motor_left = effect->u.rumble.strong_magnitude / 256;
> - ds->motor_right = effect->u.rumble.weak_magnitude / 256;
> - spin_unlock_irqrestore(&ds->base.lock, flags);
> + scoped_guard(spinlock_irqsave, &ds->base.lock) {
> + ds->update_rumble = true;
> + ds->motor_left = effect->u.rumble.strong_magnitude / 256;
> + ds->motor_right = effect->u.rumble.weak_magnitude / 256;
> + }
>
> dualsense_schedule_work(ds);
> return 0;
> @@ -1525,11 +1517,9 @@ static int dualsense_play_effect(struct input_dev *dev, void *data, struct ff_ef
> static void dualsense_remove(struct ps_device *ps_dev)
> {
> struct dualsense *ds = container_of(ps_dev, struct dualsense, base);
> - unsigned long flags;
>
> - spin_lock_irqsave(&ds->base.lock, flags);
> - ds->output_worker_initialized = false;
> - spin_unlock_irqrestore(&ds->base.lock, flags);
> + scoped_guard(spinlock_irqsave, &ds->base.lock)
> + ds->output_worker_initialized = false;
>
> cancel_work_sync(&ds->output_worker);
> }
> @@ -1561,14 +1551,12 @@ static int dualsense_reset_leds(struct dualsense *ds)
>
> static void dualsense_set_lightbar(struct dualsense *ds, uint8_t red, uint8_t green, uint8_t blue)
> {
> - unsigned long flags;
> -
> - spin_lock_irqsave(&ds->base.lock, flags);
> - ds->update_lightbar = true;
> - ds->lightbar_red = red;
> - ds->lightbar_green = green;
> - ds->lightbar_blue = blue;
> - spin_unlock_irqrestore(&ds->base.lock, flags);
> + scoped_guard(spinlock_irqsave, &ds->base.lock) {
> + ds->update_lightbar = true;
> + ds->lightbar_red = red;
> + ds->lightbar_green = green;
> + ds->lightbar_blue = blue;
> + }
>
> dualsense_schedule_work(ds);
> }
> @@ -1755,7 +1743,6 @@ static struct ps_device *dualsense_create(struct hid_device *hdev)
> static void dualshock4_dongle_calibration_work(struct work_struct *work)
> {
> struct dualshock4 *ds4 = container_of(work, struct dualshock4, dongle_hotplug_worker);
> - unsigned long flags;
> enum dualshock4_dongle_state dongle_state;
> int ret;
>
> @@ -1774,9 +1761,8 @@ static void dualshock4_dongle_calibration_work(struct work_struct *work)
> dongle_state = DONGLE_CONNECTED;
> }
>
> - spin_lock_irqsave(&ds4->base.lock, flags);
> - ds4->dongle_state = dongle_state;
> - spin_unlock_irqrestore(&ds4->base.lock, flags);
> + scoped_guard(spinlock_irqsave, &ds4->base.lock)
> + ds4->dongle_state = dongle_state;
> }
>
> static int dualshock4_get_calibration_data(struct dualshock4 *ds4)
> @@ -2048,26 +2034,23 @@ static int dualshock4_led_set_blink(struct led_classdev *led, unsigned long *del
> {
> struct hid_device *hdev = to_hid_device(led->dev->parent);
> struct dualshock4 *ds4 = hid_get_drvdata(hdev);
> - unsigned long flags;
>
> - spin_lock_irqsave(&ds4->base.lock, flags);
> + scoped_guard(spinlock_irqsave, &ds4->base.lock) {
> + if (!*delay_on && !*delay_off) {
> + /* Default to 1 Hz (50 centiseconds on, 50 centiseconds off). */
> + ds4->lightbar_blink_on = 50;
> + ds4->lightbar_blink_off = 50;
> + } else {
> + /* Blink delays in centiseconds. */
> + ds4->lightbar_blink_on = min_t(unsigned long, *delay_on / 10,
> + DS4_LIGHTBAR_MAX_BLINK);
> + ds4->lightbar_blink_off = min_t(unsigned long, *delay_off / 10,
> + DS4_LIGHTBAR_MAX_BLINK);
> + }
>
> - if (!*delay_on && !*delay_off) {
> - /* Default to 1 Hz (50 centiseconds on, 50 centiseconds off). */
> - ds4->lightbar_blink_on = 50;
> - ds4->lightbar_blink_off = 50;
> - } else {
> - /* Blink delays in centiseconds. */
> - ds4->lightbar_blink_on = min_t(unsigned long, *delay_on / 10,
> - DS4_LIGHTBAR_MAX_BLINK);
> - ds4->lightbar_blink_off = min_t(unsigned long, *delay_off / 10,
> - DS4_LIGHTBAR_MAX_BLINK);
> + ds4->update_lightbar_blink = true;
> }
>
> - ds4->update_lightbar_blink = true;
> -
> - spin_unlock_irqrestore(&ds4->base.lock, flags);
> -
> dualshock4_schedule_work(ds4);
>
> /* Report scaled values back to LED subsystem */
> @@ -2081,36 +2064,33 @@ static int dualshock4_led_set_brightness(struct led_classdev *led, enum led_brig
> {
> struct hid_device *hdev = to_hid_device(led->dev->parent);
> struct dualshock4 *ds4 = hid_get_drvdata(hdev);
> - unsigned long flags;
> unsigned int led_index;
>
> - spin_lock_irqsave(&ds4->base.lock, flags);
> -
> - led_index = led - ds4->lightbar_leds;
> - switch (led_index) {
> - case 0:
> - ds4->lightbar_red = value;
> - break;
> - case 1:
> - ds4->lightbar_green = value;
> - break;
> - case 2:
> - ds4->lightbar_blue = value;
> - break;
> - case 3:
> - ds4->lightbar_enabled = !!value;
> -
> - /* brightness = 0 also cancels blinking in Linux. */
> - if (!ds4->lightbar_enabled) {
> - ds4->lightbar_blink_off = 0;
> - ds4->lightbar_blink_on = 0;
> - ds4->update_lightbar_blink = true;
> + scoped_guard(spinlock_irqsave, &ds4->base.lock) {
> + led_index = led - ds4->lightbar_leds;
> + switch (led_index) {
> + case 0:
> + ds4->lightbar_red = value;
> + break;
> + case 1:
> + ds4->lightbar_green = value;
> + break;
> + case 2:
> + ds4->lightbar_blue = value;
> + break;
> + case 3:
> + ds4->lightbar_enabled = !!value;
> +
> + /* brightness = 0 also cancels blinking in Linux. */
> + if (!ds4->lightbar_enabled) {
> + ds4->lightbar_blink_off = 0;
> + ds4->lightbar_blink_on = 0;
> + ds4->update_lightbar_blink = true;
> + }
> }
> - }
> -
> - ds4->update_lightbar = true;
>
> - spin_unlock_irqrestore(&ds4->base.lock, flags);
> + ds4->update_lightbar = true;
> + }
>
> dualshock4_schedule_work(ds4);
>
> @@ -2242,7 +2222,6 @@ static int dualshock4_parse_report(struct ps_device *ps_dev, struct hid_report *
> uint8_t battery_capacity, num_touch_reports, value;
> int battery_status, i, j;
> uint16_t sensor_timestamp;
> - unsigned long flags;
> bool is_minimal = false;
>
> /*
> @@ -2420,10 +2399,10 @@ static int dualshock4_parse_report(struct ps_device *ps_dev, struct hid_report *
> battery_status = POWER_SUPPLY_STATUS_DISCHARGING;
> }
>
> - spin_lock_irqsave(&ps_dev->lock, flags);
> - ps_dev->battery_capacity = battery_capacity;
> - ps_dev->battery_status = battery_status;
> - spin_unlock_irqrestore(&ps_dev->lock, flags);
> + scoped_guard(spinlock_irqsave, &ps_dev->lock) {
> + ps_dev->battery_capacity = battery_capacity;
> + ps_dev->battery_status = battery_status;
> + }
>
> return 0;
> }
> @@ -2441,7 +2420,6 @@ static int dualshock4_dongle_parse_report(struct ps_device *ps_dev, struct hid_r
> */
> if (data[0] == DS4_INPUT_REPORT_USB && size == DS4_INPUT_REPORT_USB_SIZE) {
> struct dualshock4_input_report_common *ds4_report = (struct dualshock4_input_report_common *)&data[1];
> - unsigned long flags;
>
> connected = ds4_report->status[1] & DS4_STATUS1_DONGLE_STATE ? false : true;
>
> @@ -2450,9 +2428,8 @@ static int dualshock4_dongle_parse_report(struct ps_device *ps_dev, struct hid_r
>
> dualshock4_set_default_lightbar_colors(ds4);
>
> - spin_lock_irqsave(&ps_dev->lock, flags);
> - ds4->dongle_state = DONGLE_CALIBRATING;
> - spin_unlock_irqrestore(&ps_dev->lock, flags);
> + scoped_guard(spinlock_irqsave, &ps_dev->lock)
> + ds4->dongle_state = DONGLE_CALIBRATING;
>
> schedule_work(&ds4->dongle_hotplug_worker);
>
> @@ -2464,9 +2441,8 @@ static int dualshock4_dongle_parse_report(struct ps_device *ps_dev, struct hid_r
> ds4->dongle_state == DONGLE_DISABLED) && !connected) {
> hid_info(ps_dev->hdev, "DualShock 4 USB dongle: controller disconnected\n");
>
> - spin_lock_irqsave(&ps_dev->lock, flags);
> - ds4->dongle_state = DONGLE_DISCONNECTED;
> - spin_unlock_irqrestore(&ps_dev->lock, flags);
> + scoped_guard(spinlock_irqsave, &ps_dev->lock)
> + ds4->dongle_state = DONGLE_DISCONNECTED;
>
> /* Return 0, so hidraw can get the report. */
> return 0;
> @@ -2488,16 +2464,15 @@ static int dualshock4_play_effect(struct input_dev *dev, void *data, struct ff_e
> {
> struct hid_device *hdev = input_get_drvdata(dev);
> struct dualshock4 *ds4 = hid_get_drvdata(hdev);
> - unsigned long flags;
>
> if (effect->type != FF_RUMBLE)
> return 0;
>
> - spin_lock_irqsave(&ds4->base.lock, flags);
> - ds4->update_rumble = true;
> - ds4->motor_left = effect->u.rumble.strong_magnitude / 256;
> - ds4->motor_right = effect->u.rumble.weak_magnitude / 256;
> - spin_unlock_irqrestore(&ds4->base.lock, flags);
> + scoped_guard(spinlock_irqsave, &ds4->base.lock) {
> + ds4->update_rumble = true;
> + ds4->motor_left = effect->u.rumble.strong_magnitude / 256;
> + ds4->motor_right = effect->u.rumble.weak_magnitude / 256;
> + }
>
> dualshock4_schedule_work(ds4);
> return 0;
> @@ -2506,11 +2481,9 @@ static int dualshock4_play_effect(struct input_dev *dev, void *data, struct ff_e
> static void dualshock4_remove(struct ps_device *ps_dev)
> {
> struct dualshock4 *ds4 = container_of(ps_dev, struct dualshock4, base);
> - unsigned long flags;
>
> - spin_lock_irqsave(&ds4->base.lock, flags);
> - ds4->output_worker_initialized = false;
> - spin_unlock_irqrestore(&ds4->base.lock, flags);
> + scoped_guard(spinlock_irqsave, &ds4->base.lock)
> + ds4->output_worker_initialized = false;
>
> cancel_work_sync(&ds4->output_worker);
>
> @@ -2520,12 +2493,9 @@ static void dualshock4_remove(struct ps_device *ps_dev)
>
> static inline void dualshock4_schedule_work(struct dualshock4 *ds4)
> {
> - unsigned long flags;
> -
> - spin_lock_irqsave(&ds4->base.lock, flags);
> + guard(spinlock_irqsave)(&ds4->base.lock);
> if (ds4->output_worker_initialized)
> schedule_work(&ds4->output_worker);
> - spin_unlock_irqrestore(&ds4->base.lock, flags);
> }
>
> static void dualshock4_set_bt_poll_interval(struct dualshock4 *ds4, uint8_t interval)
>
> --
> 2.49.0
>
^ permalink raw reply
* Re: [PATCH v2 03/11] HID: playstation: Simplify locking with guard() and scoped_guard()
From: Benjamin Tissoires @ 2025-09-17 14:21 UTC (permalink / raw)
To: Cristian Ciocaltea
Cc: Roderick Colenbrander, Jiri Kosina, Henrik Rydberg, kernel,
linux-input, linux-kernel
In-Reply-To: <dor5e2ugnp4k5iava3uwxltttrfopkqoo23uex6xdu5rcz6rqt@7ett6gqco32m>
On Sep 17 2025, Benjamin Tissoires wrote:
> On Jun 25 2025, Cristian Ciocaltea wrote:
> > Use guard() and scoped_guard() infrastructure instead of explicitly
> > acquiring and releasing spinlocks and mutexes to simplify the code and
> > ensure that all locks are released properly.
> >
> > Signed-off-by: Cristian Ciocaltea <cristian.ciocaltea@collabora.com>
>
> It looks like the patch is now creating sparse errors:
>
> https://gitlab.freedesktop.org/bentiss/hid/-/jobs/84636162
>
> with:
>
> drivers/hid/hid-playstation.c:1187:32: warning: context imbalance in 'dualsense_player_led_set_brightness' - wrong count at exit
> drivers/hid/hid-playstation.c:1403:9: warning: context imbalance in 'dualsense_parse_report' - different lock contexts for basic block
> drivers/hid/hid-playstation.c:1499:12: warning: context imbalance in 'dualsense_play_effect' - different lock contexts for basic block
> drivers/hid/hid-playstation.c:1552:13: warning: context imbalance in 'dualsense_set_lightbar' - wrong count at exit
> drivers/hid/hid-playstation.c:1564:13: warning: context imbalance in 'dualsense_set_player_leds' - wrong count at exit
> drivers/hid/hid-playstation.c:2054:33: warning: context imbalance in 'dualshock4_led_set_blink' - wrong count at exit
> drivers/hid/hid-playstation.c:2095:33: warning: context imbalance in 'dualshock4_led_set_brightness' - wrong count at exit
> drivers/hid/hid-playstation.c:2463:12: warning: context imbalance in 'dualshock4_play_effect' - different lock contexts for basic block
> drivers/hid/hid-playstation.c:2501:13: warning: context imbalance in 'dualshock4_set_bt_poll_interval' - wrong count at exit
> drivers/hid/hid-playstation.c:2509:13: warning: context imbalance in 'dualshock4_set_default_lightbar_colors' - wrong count at exit
>
> (the artifacts are going to be removed in 4 hours, so better document
> the line numbers here).
>
> I am under the impression that it's because the 2 *_output_worker
> functions are not using scoped guarding, but it could very well be
> something entirely different. Do you mind taking a look as well?
Turns out it's the mix of guard and scoped_guard that confuses spare:
https://lkml.org/lkml/2025/6/8/74
the following shuts down all of the warnings:
---
diff --git a/drivers/hid/hid-playstation.c b/drivers/hid/hid-playstation.c
index d2bee1a314b1..36f3ac044fdc 100644
--- a/drivers/hid/hid-playstation.c
+++ b/drivers/hid/hid-playstation.c
@@ -1274,9 +1274,9 @@ static void dualsense_init_output_report(struct dualsense *ds,
static inline void dualsense_schedule_work(struct dualsense *ds)
{
- guard(spinlock_irqsave)(&ds->base.lock);
- if (ds->output_worker_initialized)
- schedule_work(&ds->output_worker);
+ scoped_guard(spinlock_irqsave, &ds->base.lock)
+ if (ds->output_worker_initialized)
+ schedule_work(&ds->output_worker);
}
/*
@@ -2626,9 +2626,9 @@ static void dualshock4_remove(struct ps_device *ps_dev)
static inline void dualshock4_schedule_work(struct dualshock4 *ds4)
{
- guard(spinlock_irqsave)(&ds4->base.lock);
- if (ds4->output_worker_initialized)
- schedule_work(&ds4->output_worker);
+ scoped_guard(spinlock_irqsave, &ds4->base.lock)
+ if (ds4->output_worker_initialized)
+ schedule_work(&ds4->output_worker);
}
static void dualshock4_set_bt_poll_interval(struct dualshock4 *ds4, u8 interval)
---
There are also a couple more of manual spin_unlock_irqrestore which
would benefit from the scoped guard mechanism.
Cheers,
Benjamin
> > ---
> > drivers/hid/hid-playstation.c | 216 ++++++++++++++++++------------------------
> > 1 file changed, 93 insertions(+), 123 deletions(-)
> >
> > diff --git a/drivers/hid/hid-playstation.c b/drivers/hid/hid-playstation.c
> > index 799b47cdfe034c2b78ec589ac19e3c7a764dc784..ab3a0c505c4db9110ae4d528ba70b32d9f90b81b 100644
> > --- a/drivers/hid/hid-playstation.c
> > +++ b/drivers/hid/hid-playstation.c
> > @@ -7,6 +7,7 @@
> >
> > #include <linux/bitfield.h>
> > #include <linux/bits.h>
> > +#include <linux/cleanup.h>
> > #include <linux/crc32.h>
> > #include <linux/device.h>
> > #include <linux/hid.h>
> > @@ -566,26 +567,25 @@ static int ps_devices_list_add(struct ps_device *dev)
> > {
> > struct ps_device *entry;
> >
> > - mutex_lock(&ps_devices_lock);
> > + guard(mutex)(&ps_devices_lock);
> > +
> > list_for_each_entry(entry, &ps_devices_list, list) {
> > if (!memcmp(entry->mac_address, dev->mac_address, sizeof(dev->mac_address))) {
> > hid_err(dev->hdev, "Duplicate device found for MAC address %pMR.\n",
> > dev->mac_address);
> > - mutex_unlock(&ps_devices_lock);
> > return -EEXIST;
> > }
> > }
> >
> > list_add_tail(&dev->list, &ps_devices_list);
> > - mutex_unlock(&ps_devices_lock);
> > return 0;
> > }
> >
> > static int ps_devices_list_remove(struct ps_device *dev)
> > {
> > - mutex_lock(&ps_devices_lock);
> > + guard(mutex)(&ps_devices_lock);
> > +
> > list_del(&dev->list);
> > - mutex_unlock(&ps_devices_lock);
> > return 0;
> > }
> >
> > @@ -649,13 +649,12 @@ static int ps_battery_get_property(struct power_supply *psy,
> > struct ps_device *dev = power_supply_get_drvdata(psy);
> > uint8_t battery_capacity;
> > int battery_status;
> > - unsigned long flags;
> > int ret = 0;
> >
> > - spin_lock_irqsave(&dev->lock, flags);
> > - battery_capacity = dev->battery_capacity;
> > - battery_status = dev->battery_status;
> > - spin_unlock_irqrestore(&dev->lock, flags);
> > + scoped_guard(spinlock_irqsave, &dev->lock) {
> > + battery_capacity = dev->battery_capacity;
> > + battery_status = dev->battery_status;
> > + }
> >
> > switch (psp) {
> > case POWER_SUPPLY_PROP_STATUS:
> > @@ -1173,19 +1172,17 @@ static int dualsense_player_led_set_brightness(struct led_classdev *led, enum le
> > {
> > struct hid_device *hdev = to_hid_device(led->dev->parent);
> > struct dualsense *ds = hid_get_drvdata(hdev);
> > - unsigned long flags;
> > unsigned int led_index;
> >
> > - spin_lock_irqsave(&ds->base.lock, flags);
> > -
> > - led_index = led - ds->player_leds;
> > - if (value == LED_OFF)
> > - ds->player_leds_state &= ~BIT(led_index);
> > - else
> > - ds->player_leds_state |= BIT(led_index);
> > + scoped_guard(spinlock_irqsave, &ds->base.lock) {
> > + led_index = led - ds->player_leds;
> > + if (value == LED_OFF)
> > + ds->player_leds_state &= ~BIT(led_index);
> > + else
> > + ds->player_leds_state |= BIT(led_index);
> >
> > - ds->update_player_leds = true;
> > - spin_unlock_irqrestore(&ds->base.lock, flags);
> > + ds->update_player_leds = true;
> > + }
> >
> > dualsense_schedule_work(ds);
> >
> > @@ -1234,12 +1231,9 @@ static void dualsense_init_output_report(struct dualsense *ds, struct dualsense_
> >
> > static inline void dualsense_schedule_work(struct dualsense *ds)
> > {
> > - unsigned long flags;
> > -
> > - spin_lock_irqsave(&ds->base.lock, flags);
> > + guard(spinlock_irqsave)(&ds->base.lock);
> > if (ds->output_worker_initialized)
> > schedule_work(&ds->output_worker);
> > - spin_unlock_irqrestore(&ds->base.lock, flags);
> > }
> >
> > /*
> > @@ -1337,7 +1331,6 @@ static int dualsense_parse_report(struct ps_device *ps_dev, struct hid_report *r
> > int battery_status;
> > uint32_t sensor_timestamp;
> > bool btn_mic_state;
> > - unsigned long flags;
> > int i;
> >
> > /*
> > @@ -1399,10 +1392,10 @@ static int dualsense_parse_report(struct ps_device *ps_dev, struct hid_report *r
> > */
> > btn_mic_state = !!(ds_report->buttons[2] & DS_BUTTONS2_MIC_MUTE);
> > if (btn_mic_state && !ds->last_btn_mic_state) {
> > - spin_lock_irqsave(&ps_dev->lock, flags);
> > - ds->update_mic_mute = true;
> > - ds->mic_muted = !ds->mic_muted; /* toggle */
> > - spin_unlock_irqrestore(&ps_dev->lock, flags);
> > + scoped_guard(spinlock_irqsave, &ps_dev->lock) {
> > + ds->update_mic_mute = true;
> > + ds->mic_muted = !ds->mic_muted; /* toggle */
> > + }
> >
> > /* Schedule updating of microphone state at hardware level. */
> > dualsense_schedule_work(ds);
> > @@ -1495,10 +1488,10 @@ static int dualsense_parse_report(struct ps_device *ps_dev, struct hid_report *r
> > battery_status = POWER_SUPPLY_STATUS_UNKNOWN;
> > }
> >
> > - spin_lock_irqsave(&ps_dev->lock, flags);
> > - ps_dev->battery_capacity = battery_capacity;
> > - ps_dev->battery_status = battery_status;
> > - spin_unlock_irqrestore(&ps_dev->lock, flags);
> > + scoped_guard(spinlock_irqsave, &ps_dev->lock) {
> > + ps_dev->battery_capacity = battery_capacity;
> > + ps_dev->battery_status = battery_status;
> > + }
> >
> > return 0;
> > }
> > @@ -1507,16 +1500,15 @@ static int dualsense_play_effect(struct input_dev *dev, void *data, struct ff_ef
> > {
> > struct hid_device *hdev = input_get_drvdata(dev);
> > struct dualsense *ds = hid_get_drvdata(hdev);
> > - unsigned long flags;
> >
> > if (effect->type != FF_RUMBLE)
> > return 0;
> >
> > - spin_lock_irqsave(&ds->base.lock, flags);
> > - ds->update_rumble = true;
> > - ds->motor_left = effect->u.rumble.strong_magnitude / 256;
> > - ds->motor_right = effect->u.rumble.weak_magnitude / 256;
> > - spin_unlock_irqrestore(&ds->base.lock, flags);
> > + scoped_guard(spinlock_irqsave, &ds->base.lock) {
> > + ds->update_rumble = true;
> > + ds->motor_left = effect->u.rumble.strong_magnitude / 256;
> > + ds->motor_right = effect->u.rumble.weak_magnitude / 256;
> > + }
> >
> > dualsense_schedule_work(ds);
> > return 0;
> > @@ -1525,11 +1517,9 @@ static int dualsense_play_effect(struct input_dev *dev, void *data, struct ff_ef
> > static void dualsense_remove(struct ps_device *ps_dev)
> > {
> > struct dualsense *ds = container_of(ps_dev, struct dualsense, base);
> > - unsigned long flags;
> >
> > - spin_lock_irqsave(&ds->base.lock, flags);
> > - ds->output_worker_initialized = false;
> > - spin_unlock_irqrestore(&ds->base.lock, flags);
> > + scoped_guard(spinlock_irqsave, &ds->base.lock)
> > + ds->output_worker_initialized = false;
> >
> > cancel_work_sync(&ds->output_worker);
> > }
> > @@ -1561,14 +1551,12 @@ static int dualsense_reset_leds(struct dualsense *ds)
> >
> > static void dualsense_set_lightbar(struct dualsense *ds, uint8_t red, uint8_t green, uint8_t blue)
> > {
> > - unsigned long flags;
> > -
> > - spin_lock_irqsave(&ds->base.lock, flags);
> > - ds->update_lightbar = true;
> > - ds->lightbar_red = red;
> > - ds->lightbar_green = green;
> > - ds->lightbar_blue = blue;
> > - spin_unlock_irqrestore(&ds->base.lock, flags);
> > + scoped_guard(spinlock_irqsave, &ds->base.lock) {
> > + ds->update_lightbar = true;
> > + ds->lightbar_red = red;
> > + ds->lightbar_green = green;
> > + ds->lightbar_blue = blue;
> > + }
> >
> > dualsense_schedule_work(ds);
> > }
> > @@ -1755,7 +1743,6 @@ static struct ps_device *dualsense_create(struct hid_device *hdev)
> > static void dualshock4_dongle_calibration_work(struct work_struct *work)
> > {
> > struct dualshock4 *ds4 = container_of(work, struct dualshock4, dongle_hotplug_worker);
> > - unsigned long flags;
> > enum dualshock4_dongle_state dongle_state;
> > int ret;
> >
> > @@ -1774,9 +1761,8 @@ static void dualshock4_dongle_calibration_work(struct work_struct *work)
> > dongle_state = DONGLE_CONNECTED;
> > }
> >
> > - spin_lock_irqsave(&ds4->base.lock, flags);
> > - ds4->dongle_state = dongle_state;
> > - spin_unlock_irqrestore(&ds4->base.lock, flags);
> > + scoped_guard(spinlock_irqsave, &ds4->base.lock)
> > + ds4->dongle_state = dongle_state;
> > }
> >
> > static int dualshock4_get_calibration_data(struct dualshock4 *ds4)
> > @@ -2048,26 +2034,23 @@ static int dualshock4_led_set_blink(struct led_classdev *led, unsigned long *del
> > {
> > struct hid_device *hdev = to_hid_device(led->dev->parent);
> > struct dualshock4 *ds4 = hid_get_drvdata(hdev);
> > - unsigned long flags;
> >
> > - spin_lock_irqsave(&ds4->base.lock, flags);
> > + scoped_guard(spinlock_irqsave, &ds4->base.lock) {
> > + if (!*delay_on && !*delay_off) {
> > + /* Default to 1 Hz (50 centiseconds on, 50 centiseconds off). */
> > + ds4->lightbar_blink_on = 50;
> > + ds4->lightbar_blink_off = 50;
> > + } else {
> > + /* Blink delays in centiseconds. */
> > + ds4->lightbar_blink_on = min_t(unsigned long, *delay_on / 10,
> > + DS4_LIGHTBAR_MAX_BLINK);
> > + ds4->lightbar_blink_off = min_t(unsigned long, *delay_off / 10,
> > + DS4_LIGHTBAR_MAX_BLINK);
> > + }
> >
> > - if (!*delay_on && !*delay_off) {
> > - /* Default to 1 Hz (50 centiseconds on, 50 centiseconds off). */
> > - ds4->lightbar_blink_on = 50;
> > - ds4->lightbar_blink_off = 50;
> > - } else {
> > - /* Blink delays in centiseconds. */
> > - ds4->lightbar_blink_on = min_t(unsigned long, *delay_on / 10,
> > - DS4_LIGHTBAR_MAX_BLINK);
> > - ds4->lightbar_blink_off = min_t(unsigned long, *delay_off / 10,
> > - DS4_LIGHTBAR_MAX_BLINK);
> > + ds4->update_lightbar_blink = true;
> > }
> >
> > - ds4->update_lightbar_blink = true;
> > -
> > - spin_unlock_irqrestore(&ds4->base.lock, flags);
> > -
> > dualshock4_schedule_work(ds4);
> >
> > /* Report scaled values back to LED subsystem */
> > @@ -2081,36 +2064,33 @@ static int dualshock4_led_set_brightness(struct led_classdev *led, enum led_brig
> > {
> > struct hid_device *hdev = to_hid_device(led->dev->parent);
> > struct dualshock4 *ds4 = hid_get_drvdata(hdev);
> > - unsigned long flags;
> > unsigned int led_index;
> >
> > - spin_lock_irqsave(&ds4->base.lock, flags);
> > -
> > - led_index = led - ds4->lightbar_leds;
> > - switch (led_index) {
> > - case 0:
> > - ds4->lightbar_red = value;
> > - break;
> > - case 1:
> > - ds4->lightbar_green = value;
> > - break;
> > - case 2:
> > - ds4->lightbar_blue = value;
> > - break;
> > - case 3:
> > - ds4->lightbar_enabled = !!value;
> > -
> > - /* brightness = 0 also cancels blinking in Linux. */
> > - if (!ds4->lightbar_enabled) {
> > - ds4->lightbar_blink_off = 0;
> > - ds4->lightbar_blink_on = 0;
> > - ds4->update_lightbar_blink = true;
> > + scoped_guard(spinlock_irqsave, &ds4->base.lock) {
> > + led_index = led - ds4->lightbar_leds;
> > + switch (led_index) {
> > + case 0:
> > + ds4->lightbar_red = value;
> > + break;
> > + case 1:
> > + ds4->lightbar_green = value;
> > + break;
> > + case 2:
> > + ds4->lightbar_blue = value;
> > + break;
> > + case 3:
> > + ds4->lightbar_enabled = !!value;
> > +
> > + /* brightness = 0 also cancels blinking in Linux. */
> > + if (!ds4->lightbar_enabled) {
> > + ds4->lightbar_blink_off = 0;
> > + ds4->lightbar_blink_on = 0;
> > + ds4->update_lightbar_blink = true;
> > + }
> > }
> > - }
> > -
> > - ds4->update_lightbar = true;
> >
> > - spin_unlock_irqrestore(&ds4->base.lock, flags);
> > + ds4->update_lightbar = true;
> > + }
> >
> > dualshock4_schedule_work(ds4);
> >
> > @@ -2242,7 +2222,6 @@ static int dualshock4_parse_report(struct ps_device *ps_dev, struct hid_report *
> > uint8_t battery_capacity, num_touch_reports, value;
> > int battery_status, i, j;
> > uint16_t sensor_timestamp;
> > - unsigned long flags;
> > bool is_minimal = false;
> >
> > /*
> > @@ -2420,10 +2399,10 @@ static int dualshock4_parse_report(struct ps_device *ps_dev, struct hid_report *
> > battery_status = POWER_SUPPLY_STATUS_DISCHARGING;
> > }
> >
> > - spin_lock_irqsave(&ps_dev->lock, flags);
> > - ps_dev->battery_capacity = battery_capacity;
> > - ps_dev->battery_status = battery_status;
> > - spin_unlock_irqrestore(&ps_dev->lock, flags);
> > + scoped_guard(spinlock_irqsave, &ps_dev->lock) {
> > + ps_dev->battery_capacity = battery_capacity;
> > + ps_dev->battery_status = battery_status;
> > + }
> >
> > return 0;
> > }
> > @@ -2441,7 +2420,6 @@ static int dualshock4_dongle_parse_report(struct ps_device *ps_dev, struct hid_r
> > */
> > if (data[0] == DS4_INPUT_REPORT_USB && size == DS4_INPUT_REPORT_USB_SIZE) {
> > struct dualshock4_input_report_common *ds4_report = (struct dualshock4_input_report_common *)&data[1];
> > - unsigned long flags;
> >
> > connected = ds4_report->status[1] & DS4_STATUS1_DONGLE_STATE ? false : true;
> >
> > @@ -2450,9 +2428,8 @@ static int dualshock4_dongle_parse_report(struct ps_device *ps_dev, struct hid_r
> >
> > dualshock4_set_default_lightbar_colors(ds4);
> >
> > - spin_lock_irqsave(&ps_dev->lock, flags);
> > - ds4->dongle_state = DONGLE_CALIBRATING;
> > - spin_unlock_irqrestore(&ps_dev->lock, flags);
> > + scoped_guard(spinlock_irqsave, &ps_dev->lock)
> > + ds4->dongle_state = DONGLE_CALIBRATING;
> >
> > schedule_work(&ds4->dongle_hotplug_worker);
> >
> > @@ -2464,9 +2441,8 @@ static int dualshock4_dongle_parse_report(struct ps_device *ps_dev, struct hid_r
> > ds4->dongle_state == DONGLE_DISABLED) && !connected) {
> > hid_info(ps_dev->hdev, "DualShock 4 USB dongle: controller disconnected\n");
> >
> > - spin_lock_irqsave(&ps_dev->lock, flags);
> > - ds4->dongle_state = DONGLE_DISCONNECTED;
> > - spin_unlock_irqrestore(&ps_dev->lock, flags);
> > + scoped_guard(spinlock_irqsave, &ps_dev->lock)
> > + ds4->dongle_state = DONGLE_DISCONNECTED;
> >
> > /* Return 0, so hidraw can get the report. */
> > return 0;
> > @@ -2488,16 +2464,15 @@ static int dualshock4_play_effect(struct input_dev *dev, void *data, struct ff_e
> > {
> > struct hid_device *hdev = input_get_drvdata(dev);
> > struct dualshock4 *ds4 = hid_get_drvdata(hdev);
> > - unsigned long flags;
> >
> > if (effect->type != FF_RUMBLE)
> > return 0;
> >
> > - spin_lock_irqsave(&ds4->base.lock, flags);
> > - ds4->update_rumble = true;
> > - ds4->motor_left = effect->u.rumble.strong_magnitude / 256;
> > - ds4->motor_right = effect->u.rumble.weak_magnitude / 256;
> > - spin_unlock_irqrestore(&ds4->base.lock, flags);
> > + scoped_guard(spinlock_irqsave, &ds4->base.lock) {
> > + ds4->update_rumble = true;
> > + ds4->motor_left = effect->u.rumble.strong_magnitude / 256;
> > + ds4->motor_right = effect->u.rumble.weak_magnitude / 256;
> > + }
> >
> > dualshock4_schedule_work(ds4);
> > return 0;
> > @@ -2506,11 +2481,9 @@ static int dualshock4_play_effect(struct input_dev *dev, void *data, struct ff_e
> > static void dualshock4_remove(struct ps_device *ps_dev)
> > {
> > struct dualshock4 *ds4 = container_of(ps_dev, struct dualshock4, base);
> > - unsigned long flags;
> >
> > - spin_lock_irqsave(&ds4->base.lock, flags);
> > - ds4->output_worker_initialized = false;
> > - spin_unlock_irqrestore(&ds4->base.lock, flags);
> > + scoped_guard(spinlock_irqsave, &ds4->base.lock)
> > + ds4->output_worker_initialized = false;
> >
> > cancel_work_sync(&ds4->output_worker);
> >
> > @@ -2520,12 +2493,9 @@ static void dualshock4_remove(struct ps_device *ps_dev)
> >
> > static inline void dualshock4_schedule_work(struct dualshock4 *ds4)
> > {
> > - unsigned long flags;
> > -
> > - spin_lock_irqsave(&ds4->base.lock, flags);
> > + guard(spinlock_irqsave)(&ds4->base.lock);
> > if (ds4->output_worker_initialized)
> > schedule_work(&ds4->output_worker);
> > - spin_unlock_irqrestore(&ds4->base.lock, flags);
> > }
> >
> > static void dualshock4_set_bt_poll_interval(struct dualshock4 *ds4, uint8_t interval)
> >
> > --
> > 2.49.0
> >
^ permalink raw reply related
* Re: [PATCH v2 1/1] dt-bindings: input: convert tca8418_keypad.txt to yaml format
From: Rob Herring @ 2025-09-17 15:51 UTC (permalink / raw)
To: Frank Li
Cc: Dmitry Torokhov, Krzysztof Kozlowski, Conor Dooley,
open list:INPUT (KEYBOARD, MOUSE, JOYSTICK, TOUCHSCREEN)...,
open list:OPEN FIRMWARE AND FLATTENED DEVICE TREE BINDINGS,
open list, imx
In-Reply-To: <20250916171327.3773620-1-Frank.Li@nxp.com>
On Tue, Sep 16, 2025 at 12:13 PM Frank Li <Frank.Li@nxp.com> wrote:
>
> Convert tca8418_keypad.txt to yaml format.
>
> Signed-off-by: Frank Li <Frank.Li@nxp.com>
> ---
> change in v2
> - add TCA8418 to title
> ---
> .../bindings/input/tca8418_keypad.txt | 10 ---
> .../devicetree/bindings/input/ti,tca8418.yaml | 61 +++++++++++++++++++
> 2 files changed, 61 insertions(+), 10 deletions(-)
> delete mode 100644 Documentation/devicetree/bindings/input/tca8418_keypad.txt
> create mode 100644 Documentation/devicetree/bindings/input/ti,tca8418.yaml
Reviewed-by: Rob Herring (Arm) <robh@kernel.org>
^ permalink raw reply
* [PATCH v11 2/6] mfd: pf1550: add core driver
From: Samuel Kayode via B4 Relay @ 2025-09-17 15:52 UTC (permalink / raw)
To: Lee Jones, Rob Herring, Krzysztof Kozlowski, Conor Dooley,
Liam Girdwood, Mark Brown, Dmitry Torokhov, Sebastian Reichel,
Frank Li
Cc: imx, devicetree, linux-kernel, linux-input, linux-pm, Abel Vesa,
Abel Vesa, Robin Gong, Robin Gong, Enric Balletbo i Serra,
Sean Nyekjaer, Christophe JAILLET, Samuel Kayode, Abel Vesa,
Frank Li
In-Reply-To: <20250917-pf1550-v11-0-e0649822fcc9@savoirfairelinux.com>
From: Samuel Kayode <samuel.kayode@savoirfairelinux.com>
Add the core driver for pf1550 PMIC. There are 3 subdevices for which the
drivers will be added in subsequent patches.
Reviewed-by: Frank Li <Frank.Li@nxp.com>
Tested-by: Sean Nyekjaer <sean@geanix.com>
Signed-off-by: Samuel Kayode <samuel.kayode@savoirfairelinux.com>
---
v11:
- Add Tested-by tag from Sean
v10:
- Address Lee's feedback:
- Change dvsX_enb to dvsX_enable
- Add new line where necessary
- Can use 100 chars in a line
- Begin comments with uppercase
- Rearrange members of struct pf1550_ddata
- Add support for disabling onkey shutting down system
v9:
- Requested by Sean:
- Add support for SW1 DVS enable/disable
- Use consistent whitespace
- Adjust commenting and log messages of the read_otp function
v8:
- Address Lee's feedback:
- Drop `mfd` from driver description and comments
- Add module name in Kconfig
- Fix license commenting
- Drop filenames from comments
- Drop unnecessary tabbing
- Alphabetical ordering of includes
- Remove magic numbers
- Add comments for pf1550_read_otp function
- Fix log error message in pf1550_read_otp
- Drop pf1550_add_child_device function
- Start comments with upper case
- Rename pf1550_dev to pf1550_ddata
- Drop i2c member in struct pf1550_ddata/pf1550_dev
- Use more helpful log message when device id not recognized
- Fix dvs_enb: when bit is set the DVS is disabled and when bit is clear the
DVS is enabled
- Verified the PM_OPS suspend and resume do act as expected
v7:
- Address Frank's feedback:
- Ensure reverse christmas tree order for local variable definitions
- Drop unnecessary driver data definition in id table
v6:
- Address Frank's feedback:
- Ensure lowercase when defining register addresses
- Use GENMASK macro for masking
- Hardcode IRQ flags in pf1550_add_child_device
- Add dvs_enb variable for SW2 regulator
- Drop chip type variable
v5:
- Use top level interrupt to manage interrupts for the sub-drivers as
recommended by Mark Brown. The regmap_irq_sub_irq_map would have been used
if not for the irregular charger irq address. For all children, the mask
register is directly after the irq register (i.e., 0x08, 0x09) except
for the charger: 0x80, 0x82. Meaning .mask_base would be applicable
for all but the charger
- Fix bad offset for temperature interrupts of regulator
v4:
- Use struct resource to define irq so platform_get_irq can be used in
children as suggested by Dmitry
- Let mfd_add_devices create the mappings for the interrupts
- ack_base and init_ack_masked defined for charger and regulator irq
chips
- No need to define driver_data in table id
v3:
- Address Dmitry's feedback:
- Place Table IDs next to each other
- Drop of_match_ptr
- Replace dev_err with dev_err_probe in probe method
- Drop useless log in probe
- Map all irqs instead of doing it in the sub-devices as recommended by
Dmitry.
v2:
- Address feedback from Enric Balletbo Serra
---
drivers/mfd/Kconfig | 16 ++
drivers/mfd/Makefile | 2 +
drivers/mfd/pf1550.c | 367 +++++++++++++++++++++++++++++++++++++++++++++
include/linux/mfd/pf1550.h | 273 +++++++++++++++++++++++++++++++++
4 files changed, 658 insertions(+)
diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig
index 6fb3768e3d71cbb5c81f63de36cdb2d27a0a7726..14e21f0e239b4a609b01c59435f39abaa41dce14 100644
--- a/drivers/mfd/Kconfig
+++ b/drivers/mfd/Kconfig
@@ -558,6 +558,22 @@ config MFD_MX25_TSADC
i.MX25 processors. They consist of a conversion queue for general
purpose ADC and a queue for Touchscreens.
+config MFD_PF1550
+ tristate "NXP PF1550 PMIC Support"
+ depends on I2C=y && OF
+ select MFD_CORE
+ select REGMAP_I2C
+ select REGMAP_IRQ
+ help
+ Say yes here to add support for NXP PF1550. This is a companion Power
+ Management IC with regulators, onkey, and charger control on chip.
+ This driver provides common support for accessing the device;
+ additional drivers must be enabled in order to use the functionality
+ of the device.
+
+ This driver can also be built as a module and if so will be called
+ pf1550.
+
config MFD_HI6421_PMIC
tristate "HiSilicon Hi6421 PMU/Codec IC"
depends on OF
diff --git a/drivers/mfd/Makefile b/drivers/mfd/Makefile
index 79495f9f3457b8a666646ec9671861c64d7939e1..8bf712081deaafa554940c1aac0c317a2dcbbfeb 100644
--- a/drivers/mfd/Makefile
+++ b/drivers/mfd/Makefile
@@ -120,6 +120,8 @@ obj-$(CONFIG_MFD_MC13XXX) += mc13xxx-core.o
obj-$(CONFIG_MFD_MC13XXX_SPI) += mc13xxx-spi.o
obj-$(CONFIG_MFD_MC13XXX_I2C) += mc13xxx-i2c.o
+obj-$(CONFIG_MFD_PF1550) += pf1550.o
+
obj-$(CONFIG_MFD_CORE) += mfd-core.o
ocelot-soc-objs := ocelot-core.o ocelot-spi.o
diff --git a/drivers/mfd/pf1550.c b/drivers/mfd/pf1550.c
new file mode 100644
index 0000000000000000000000000000000000000000..c4f567c055640662cc2db742917cc87cf9cabb5f
--- /dev/null
+++ b/drivers/mfd/pf1550.c
@@ -0,0 +1,367 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Core driver for the PF1550
+ *
+ * Copyright (C) 2016 Freescale Semiconductor, Inc.
+ * Robin Gong <yibin.gong@freescale.com>
+ *
+ * Portions Copyright (c) 2025 Savoir-faire Linux Inc.
+ * Samuel Kayode <samuel.kayode@savoirfairelinux.com>
+ */
+
+#include <linux/err.h>
+#include <linux/i2c.h>
+#include <linux/interrupt.h>
+#include <linux/mfd/core.h>
+#include <linux/mfd/pf1550.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/regmap.h>
+
+static const struct regmap_config pf1550_regmap_config = {
+ .reg_bits = 8,
+ .val_bits = 8,
+ .max_register = PF1550_PMIC_REG_END,
+};
+
+static const struct regmap_irq pf1550_irqs[] = {
+ REGMAP_IRQ_REG(PF1550_IRQ_CHG, 0, IRQ_CHG),
+ REGMAP_IRQ_REG(PF1550_IRQ_REGULATOR, 0, IRQ_REGULATOR),
+ REGMAP_IRQ_REG(PF1550_IRQ_ONKEY, 0, IRQ_ONKEY),
+};
+
+static const struct regmap_irq_chip pf1550_irq_chip = {
+ .name = "pf1550",
+ .status_base = PF1550_PMIC_REG_INT_CATEGORY,
+ .init_ack_masked = 1,
+ .num_regs = 1,
+ .irqs = pf1550_irqs,
+ .num_irqs = ARRAY_SIZE(pf1550_irqs),
+};
+
+static const struct regmap_irq pf1550_regulator_irqs[] = {
+ REGMAP_IRQ_REG(PF1550_PMIC_IRQ_SW1_LS, 0, PMIC_IRQ_SW1_LS),
+ REGMAP_IRQ_REG(PF1550_PMIC_IRQ_SW2_LS, 0, PMIC_IRQ_SW2_LS),
+ REGMAP_IRQ_REG(PF1550_PMIC_IRQ_SW3_LS, 0, PMIC_IRQ_SW3_LS),
+ REGMAP_IRQ_REG(PF1550_PMIC_IRQ_SW1_HS, 3, PMIC_IRQ_SW1_HS),
+ REGMAP_IRQ_REG(PF1550_PMIC_IRQ_SW2_HS, 3, PMIC_IRQ_SW2_HS),
+ REGMAP_IRQ_REG(PF1550_PMIC_IRQ_SW3_HS, 3, PMIC_IRQ_SW3_HS),
+ REGMAP_IRQ_REG(PF1550_PMIC_IRQ_LDO1_FAULT, 16, PMIC_IRQ_LDO1_FAULT),
+ REGMAP_IRQ_REG(PF1550_PMIC_IRQ_LDO2_FAULT, 16, PMIC_IRQ_LDO2_FAULT),
+ REGMAP_IRQ_REG(PF1550_PMIC_IRQ_LDO3_FAULT, 16, PMIC_IRQ_LDO3_FAULT),
+ REGMAP_IRQ_REG(PF1550_PMIC_IRQ_TEMP_110, 24, PMIC_IRQ_TEMP_110),
+ REGMAP_IRQ_REG(PF1550_PMIC_IRQ_TEMP_125, 24, PMIC_IRQ_TEMP_125),
+};
+
+static const struct regmap_irq_chip pf1550_regulator_irq_chip = {
+ .name = "pf1550-regulator",
+ .status_base = PF1550_PMIC_REG_SW_INT_STAT0,
+ .ack_base = PF1550_PMIC_REG_SW_INT_STAT0,
+ .mask_base = PF1550_PMIC_REG_SW_INT_MASK0,
+ .use_ack = 1,
+ .init_ack_masked = 1,
+ .num_regs = 25,
+ .irqs = pf1550_regulator_irqs,
+ .num_irqs = ARRAY_SIZE(pf1550_regulator_irqs),
+};
+
+static const struct resource regulator_resources[] = {
+ DEFINE_RES_IRQ(PF1550_PMIC_IRQ_SW1_LS),
+ DEFINE_RES_IRQ(PF1550_PMIC_IRQ_SW2_LS),
+ DEFINE_RES_IRQ(PF1550_PMIC_IRQ_SW3_LS),
+ DEFINE_RES_IRQ(PF1550_PMIC_IRQ_SW1_HS),
+ DEFINE_RES_IRQ(PF1550_PMIC_IRQ_SW2_HS),
+ DEFINE_RES_IRQ(PF1550_PMIC_IRQ_SW3_HS),
+ DEFINE_RES_IRQ(PF1550_PMIC_IRQ_LDO1_FAULT),
+ DEFINE_RES_IRQ(PF1550_PMIC_IRQ_LDO2_FAULT),
+ DEFINE_RES_IRQ(PF1550_PMIC_IRQ_LDO3_FAULT),
+ DEFINE_RES_IRQ(PF1550_PMIC_IRQ_TEMP_110),
+ DEFINE_RES_IRQ(PF1550_PMIC_IRQ_TEMP_125),
+};
+
+static const struct regmap_irq pf1550_onkey_irqs[] = {
+ REGMAP_IRQ_REG(PF1550_ONKEY_IRQ_PUSHI, 0, ONKEY_IRQ_PUSHI),
+ REGMAP_IRQ_REG(PF1550_ONKEY_IRQ_1SI, 0, ONKEY_IRQ_1SI),
+ REGMAP_IRQ_REG(PF1550_ONKEY_IRQ_2SI, 0, ONKEY_IRQ_2SI),
+ REGMAP_IRQ_REG(PF1550_ONKEY_IRQ_3SI, 0, ONKEY_IRQ_3SI),
+ REGMAP_IRQ_REG(PF1550_ONKEY_IRQ_4SI, 0, ONKEY_IRQ_4SI),
+ REGMAP_IRQ_REG(PF1550_ONKEY_IRQ_8SI, 0, ONKEY_IRQ_8SI),
+};
+
+static const struct regmap_irq_chip pf1550_onkey_irq_chip = {
+ .name = "pf1550-onkey",
+ .status_base = PF1550_PMIC_REG_ONKEY_INT_STAT0,
+ .ack_base = PF1550_PMIC_REG_ONKEY_INT_STAT0,
+ .mask_base = PF1550_PMIC_REG_ONKEY_INT_MASK0,
+ .use_ack = 1,
+ .init_ack_masked = 1,
+ .num_regs = 1,
+ .irqs = pf1550_onkey_irqs,
+ .num_irqs = ARRAY_SIZE(pf1550_onkey_irqs),
+};
+
+static const struct resource onkey_resources[] = {
+ DEFINE_RES_IRQ(PF1550_ONKEY_IRQ_PUSHI),
+ DEFINE_RES_IRQ(PF1550_ONKEY_IRQ_1SI),
+ DEFINE_RES_IRQ(PF1550_ONKEY_IRQ_2SI),
+ DEFINE_RES_IRQ(PF1550_ONKEY_IRQ_3SI),
+ DEFINE_RES_IRQ(PF1550_ONKEY_IRQ_4SI),
+ DEFINE_RES_IRQ(PF1550_ONKEY_IRQ_8SI),
+};
+
+static const struct regmap_irq pf1550_charger_irqs[] = {
+ REGMAP_IRQ_REG(PF1550_CHARG_IRQ_BAT2SOCI, 0, CHARG_IRQ_BAT2SOCI),
+ REGMAP_IRQ_REG(PF1550_CHARG_IRQ_BATI, 0, CHARG_IRQ_BATI),
+ REGMAP_IRQ_REG(PF1550_CHARG_IRQ_CHGI, 0, CHARG_IRQ_CHGI),
+ REGMAP_IRQ_REG(PF1550_CHARG_IRQ_VBUSI, 0, CHARG_IRQ_VBUSI),
+ REGMAP_IRQ_REG(PF1550_CHARG_IRQ_THMI, 0, CHARG_IRQ_THMI),
+};
+
+static const struct regmap_irq_chip pf1550_charger_irq_chip = {
+ .name = "pf1550-charger",
+ .status_base = PF1550_CHARG_REG_CHG_INT,
+ .ack_base = PF1550_CHARG_REG_CHG_INT,
+ .mask_base = PF1550_CHARG_REG_CHG_INT_MASK,
+ .use_ack = 1,
+ .init_ack_masked = 1,
+ .num_regs = 1,
+ .irqs = pf1550_charger_irqs,
+ .num_irqs = ARRAY_SIZE(pf1550_charger_irqs),
+};
+
+static const struct resource charger_resources[] = {
+ DEFINE_RES_IRQ(PF1550_CHARG_IRQ_BAT2SOCI),
+ DEFINE_RES_IRQ(PF1550_CHARG_IRQ_BATI),
+ DEFINE_RES_IRQ(PF1550_CHARG_IRQ_CHGI),
+ DEFINE_RES_IRQ(PF1550_CHARG_IRQ_VBUSI),
+ DEFINE_RES_IRQ(PF1550_CHARG_IRQ_THMI),
+};
+
+static const struct mfd_cell pf1550_regulator_cell = {
+ .name = "pf1550-regulator",
+ .num_resources = ARRAY_SIZE(regulator_resources),
+ .resources = regulator_resources,
+};
+
+static const struct mfd_cell pf1550_onkey_cell = {
+ .name = "pf1550-onkey",
+ .num_resources = ARRAY_SIZE(onkey_resources),
+ .resources = onkey_resources,
+};
+
+static const struct mfd_cell pf1550_charger_cell = {
+ .name = "pf1550-charger",
+ .num_resources = ARRAY_SIZE(charger_resources),
+ .resources = charger_resources,
+};
+
+/*
+ * The PF1550 is shipped in variants of A0, A1,...A9. Each variant defines a
+ * configuration of the PMIC in a One-Time Programmable (OTP) memory.
+ * This memory is accessed indirectly by writing valid keys to specific
+ * registers of the PMIC. To read the OTP memory after writing the valid keys,
+ * the OTP register address to be read is written to pf1550 register 0xc4 and
+ * its value read from pf1550 register 0xc5.
+ */
+static int pf1550_read_otp(const struct pf1550_ddata *pf1550, unsigned int index,
+ unsigned int *val)
+{
+ int ret = 0;
+
+ ret = regmap_write(pf1550->regmap, PF1550_PMIC_REG_KEY, PF1550_OTP_PMIC_KEY);
+ if (ret)
+ goto read_err;
+
+ ret = regmap_write(pf1550->regmap, PF1550_CHARG_REG_CHGR_KEY2, PF1550_OTP_CHGR_KEY);
+ if (ret)
+ goto read_err;
+
+ ret = regmap_write(pf1550->regmap, PF1550_TEST_REG_KEY3, PF1550_OTP_TEST_KEY);
+ if (ret)
+ goto read_err;
+
+ ret = regmap_write(pf1550->regmap, PF1550_TEST_REG_FMRADDR, index);
+ if (ret)
+ goto read_err;
+
+ ret = regmap_read(pf1550->regmap, PF1550_TEST_REG_FMRDATA, val);
+ if (ret)
+ goto read_err;
+
+ return 0;
+
+read_err:
+ return dev_err_probe(pf1550->dev, ret, "OTP reg %x not found!\n", index);
+}
+
+static int pf1550_i2c_probe(struct i2c_client *i2c)
+{
+ const struct mfd_cell *regulator = &pf1550_regulator_cell;
+ const struct mfd_cell *charger = &pf1550_charger_cell;
+ const struct mfd_cell *onkey = &pf1550_onkey_cell;
+ unsigned int reg_data = 0, otp_data = 0;
+ struct pf1550_ddata *pf1550;
+ struct irq_domain *domain;
+ int irq, ret = 0;
+
+ pf1550 = devm_kzalloc(&i2c->dev, sizeof(*pf1550), GFP_KERNEL);
+ if (!pf1550)
+ return -ENOMEM;
+
+ i2c_set_clientdata(i2c, pf1550);
+ pf1550->dev = &i2c->dev;
+ pf1550->irq = i2c->irq;
+
+ pf1550->regmap = devm_regmap_init_i2c(i2c, &pf1550_regmap_config);
+ if (IS_ERR(pf1550->regmap))
+ return dev_err_probe(pf1550->dev, PTR_ERR(pf1550->regmap),
+ "failed to allocate register map\n");
+
+ ret = regmap_read(pf1550->regmap, PF1550_PMIC_REG_DEVICE_ID, ®_data);
+ if (ret < 0)
+ return dev_err_probe(pf1550->dev, ret, "cannot read chip ID\n");
+ if (reg_data != PF1550_DEVICE_ID)
+ return dev_err_probe(pf1550->dev, -ENODEV, "invalid device ID: 0x%02x\n", reg_data);
+
+ /* Regulator DVS for SW2 */
+ ret = pf1550_read_otp(pf1550, PF1550_OTP_SW2_SW3, &otp_data);
+ if (ret)
+ return ret;
+
+ /* When clear, DVS should be enabled */
+ if (!(otp_data & OTP_SW2_DVS_ENB))
+ pf1550->dvs2_enable = true;
+
+ /* Regulator DVS for SW1 */
+ ret = pf1550_read_otp(pf1550, PF1550_OTP_SW1_SW2, &otp_data);
+ if (ret)
+ return ret;
+
+ if (!(otp_data & OTP_SW1_DVS_ENB))
+ pf1550->dvs1_enable = true;
+
+ /* Add top level interrupts */
+ ret = devm_regmap_add_irq_chip(pf1550->dev, pf1550->regmap, pf1550->irq,
+ IRQF_ONESHOT | IRQF_SHARED |
+ IRQF_TRIGGER_FALLING,
+ 0, &pf1550_irq_chip,
+ &pf1550->irq_data);
+ if (ret)
+ return ret;
+
+ /* Add regulator */
+ irq = regmap_irq_get_virq(pf1550->irq_data, PF1550_IRQ_REGULATOR);
+ if (irq < 0)
+ return dev_err_probe(pf1550->dev, irq,
+ "Failed to get parent vIRQ(%d) for chip %s\n",
+ PF1550_IRQ_REGULATOR, pf1550_irq_chip.name);
+
+ ret = devm_regmap_add_irq_chip(pf1550->dev, pf1550->regmap, irq,
+ IRQF_ONESHOT | IRQF_SHARED |
+ IRQF_TRIGGER_FALLING, 0,
+ &pf1550_regulator_irq_chip,
+ &pf1550->irq_data_regulator);
+ if (ret)
+ return dev_err_probe(pf1550->dev, ret, "Failed to add %s IRQ chip\n",
+ pf1550_regulator_irq_chip.name);
+
+ domain = regmap_irq_get_domain(pf1550->irq_data_regulator);
+
+ ret = devm_mfd_add_devices(pf1550->dev, PLATFORM_DEVID_NONE, regulator, 1, NULL, 0, domain);
+ if (ret)
+ return ret;
+
+ /* Add onkey */
+ irq = regmap_irq_get_virq(pf1550->irq_data, PF1550_IRQ_ONKEY);
+ if (irq < 0)
+ return dev_err_probe(pf1550->dev, irq,
+ "Failed to get parent vIRQ(%d) for chip %s\n",
+ PF1550_IRQ_ONKEY, pf1550_irq_chip.name);
+
+ ret = devm_regmap_add_irq_chip(pf1550->dev, pf1550->regmap, irq,
+ IRQF_ONESHOT | IRQF_SHARED |
+ IRQF_TRIGGER_FALLING, 0,
+ &pf1550_onkey_irq_chip,
+ &pf1550->irq_data_onkey);
+ if (ret)
+ return dev_err_probe(pf1550->dev, ret, "Failed to add %s IRQ chip\n",
+ pf1550_onkey_irq_chip.name);
+
+ domain = regmap_irq_get_domain(pf1550->irq_data_onkey);
+
+ ret = devm_mfd_add_devices(pf1550->dev, PLATFORM_DEVID_NONE, onkey, 1, NULL, 0, domain);
+ if (ret)
+ return ret;
+
+ /* Add battery charger */
+ irq = regmap_irq_get_virq(pf1550->irq_data, PF1550_IRQ_CHG);
+ if (irq < 0)
+ return dev_err_probe(pf1550->dev, irq,
+ "Failed to get parent vIRQ(%d) for chip %s\n",
+ PF1550_IRQ_CHG, pf1550_irq_chip.name);
+
+ ret = devm_regmap_add_irq_chip(pf1550->dev, pf1550->regmap, irq,
+ IRQF_ONESHOT | IRQF_SHARED |
+ IRQF_TRIGGER_FALLING, 0,
+ &pf1550_charger_irq_chip,
+ &pf1550->irq_data_charger);
+ if (ret)
+ return dev_err_probe(pf1550->dev, ret, "Failed to add %s IRQ chip\n",
+ pf1550_charger_irq_chip.name);
+
+ domain = regmap_irq_get_domain(pf1550->irq_data_charger);
+
+ return devm_mfd_add_devices(pf1550->dev, PLATFORM_DEVID_NONE, charger, 1, NULL, 0, domain);
+}
+
+static int pf1550_suspend(struct device *dev)
+{
+ struct pf1550_ddata *pf1550 = dev_get_drvdata(dev);
+
+ if (device_may_wakeup(dev)) {
+ enable_irq_wake(pf1550->irq);
+ disable_irq(pf1550->irq);
+ }
+
+ return 0;
+}
+
+static int pf1550_resume(struct device *dev)
+{
+ struct pf1550_ddata *pf1550 = dev_get_drvdata(dev);
+
+ if (device_may_wakeup(dev)) {
+ disable_irq_wake(pf1550->irq);
+ enable_irq(pf1550->irq);
+ }
+
+ return 0;
+}
+static DEFINE_SIMPLE_DEV_PM_OPS(pf1550_pm, pf1550_suspend, pf1550_resume);
+
+static const struct i2c_device_id pf1550_i2c_id[] = {
+ { "pf1550" },
+ { /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(i2c, pf1550_i2c_id);
+
+static const struct of_device_id pf1550_dt_match[] = {
+ { .compatible = "nxp,pf1550" },
+ { /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(of, pf1550_dt_match);
+
+static struct i2c_driver pf1550_i2c_driver = {
+ .driver = {
+ .name = "pf1550",
+ .pm = pm_sleep_ptr(&pf1550_pm),
+ .of_match_table = pf1550_dt_match,
+ },
+ .probe = pf1550_i2c_probe,
+ .id_table = pf1550_i2c_id,
+};
+module_i2c_driver(pf1550_i2c_driver);
+
+MODULE_DESCRIPTION("NXP PF1550 core driver");
+MODULE_AUTHOR("Robin Gong <yibin.gong@freescale.com>");
+MODULE_LICENSE("GPL");
diff --git a/include/linux/mfd/pf1550.h b/include/linux/mfd/pf1550.h
new file mode 100644
index 0000000000000000000000000000000000000000..7cb2340ff2bd92883a709806da58601daaf98a88
--- /dev/null
+++ b/include/linux/mfd/pf1550.h
@@ -0,0 +1,273 @@
+/* SPDX-License-Identifier: GPL-2.0
+ *
+ * Declarations for the PF1550 PMIC
+ *
+ * Copyright (C) 2016 Freescale Semiconductor, Inc.
+ * Robin Gong <yibin.gong@freescale.com>
+ *
+ * Portions Copyright (c) 2025 Savoir-faire Linux Inc.
+ * Samuel Kayode <samuel.kayode@savoirfairelinux.com>
+ */
+
+#ifndef __LINUX_MFD_PF1550_H
+#define __LINUX_MFD_PF1550_H
+
+#include <linux/i2c.h>
+#include <linux/regmap.h>
+
+enum pf1550_pmic_reg {
+ /* PMIC regulator part */
+ PF1550_PMIC_REG_DEVICE_ID = 0x00,
+ PF1550_PMIC_REG_OTP_FLAVOR = 0x01,
+ PF1550_PMIC_REG_SILICON_REV = 0x02,
+
+ PF1550_PMIC_REG_INT_CATEGORY = 0x06,
+ PF1550_PMIC_REG_SW_INT_STAT0 = 0x08,
+ PF1550_PMIC_REG_SW_INT_MASK0 = 0x09,
+ PF1550_PMIC_REG_SW_INT_SENSE0 = 0x0a,
+ PF1550_PMIC_REG_SW_INT_STAT1 = 0x0b,
+ PF1550_PMIC_REG_SW_INT_MASK1 = 0x0c,
+ PF1550_PMIC_REG_SW_INT_SENSE1 = 0x0d,
+ PF1550_PMIC_REG_SW_INT_STAT2 = 0x0e,
+ PF1550_PMIC_REG_SW_INT_MASK2 = 0x0f,
+ PF1550_PMIC_REG_SW_INT_SENSE2 = 0x10,
+ PF1550_PMIC_REG_LDO_INT_STAT0 = 0x18,
+ PF1550_PMIC_REG_LDO_INT_MASK0 = 0x19,
+ PF1550_PMIC_REG_LDO_INT_SENSE0 = 0x1a,
+ PF1550_PMIC_REG_TEMP_INT_STAT0 = 0x20,
+ PF1550_PMIC_REG_TEMP_INT_MASK0 = 0x21,
+ PF1550_PMIC_REG_TEMP_INT_SENSE0 = 0x22,
+ PF1550_PMIC_REG_ONKEY_INT_STAT0 = 0x24,
+ PF1550_PMIC_REG_ONKEY_INT_MASK0 = 0x25,
+ PF1550_PMIC_REG_ONKEY_INT_SENSE0 = 0x26,
+ PF1550_PMIC_REG_MISC_INT_STAT0 = 0x28,
+ PF1550_PMIC_REG_MISC_INT_MASK0 = 0x29,
+ PF1550_PMIC_REG_MISC_INT_SENSE0 = 0x2a,
+
+ PF1550_PMIC_REG_COINCELL_CONTROL = 0x30,
+
+ PF1550_PMIC_REG_SW1_VOLT = 0x32,
+ PF1550_PMIC_REG_SW1_STBY_VOLT = 0x33,
+ PF1550_PMIC_REG_SW1_SLP_VOLT = 0x34,
+ PF1550_PMIC_REG_SW1_CTRL = 0x35,
+ PF1550_PMIC_REG_SW1_CTRL1 = 0x36,
+ PF1550_PMIC_REG_SW2_VOLT = 0x38,
+ PF1550_PMIC_REG_SW2_STBY_VOLT = 0x39,
+ PF1550_PMIC_REG_SW2_SLP_VOLT = 0x3a,
+ PF1550_PMIC_REG_SW2_CTRL = 0x3b,
+ PF1550_PMIC_REG_SW2_CTRL1 = 0x3c,
+ PF1550_PMIC_REG_SW3_VOLT = 0x3e,
+ PF1550_PMIC_REG_SW3_STBY_VOLT = 0x3f,
+ PF1550_PMIC_REG_SW3_SLP_VOLT = 0x40,
+ PF1550_PMIC_REG_SW3_CTRL = 0x41,
+ PF1550_PMIC_REG_SW3_CTRL1 = 0x42,
+ PF1550_PMIC_REG_VSNVS_CTRL = 0x48,
+ PF1550_PMIC_REG_VREFDDR_CTRL = 0x4a,
+ PF1550_PMIC_REG_LDO1_VOLT = 0x4c,
+ PF1550_PMIC_REG_LDO1_CTRL = 0x4d,
+ PF1550_PMIC_REG_LDO2_VOLT = 0x4f,
+ PF1550_PMIC_REG_LDO2_CTRL = 0x50,
+ PF1550_PMIC_REG_LDO3_VOLT = 0x52,
+ PF1550_PMIC_REG_LDO3_CTRL = 0x53,
+ PF1550_PMIC_REG_PWRCTRL0 = 0x58,
+ PF1550_PMIC_REG_PWRCTRL1 = 0x59,
+ PF1550_PMIC_REG_PWRCTRL2 = 0x5a,
+ PF1550_PMIC_REG_PWRCTRL3 = 0x5b,
+ PF1550_PMIC_REG_SW1_PWRDN_SEQ = 0x5f,
+ PF1550_PMIC_REG_SW2_PWRDN_SEQ = 0x60,
+ PF1550_PMIC_REG_SW3_PWRDN_SEQ = 0x61,
+ PF1550_PMIC_REG_LDO1_PWRDN_SEQ = 0x62,
+ PF1550_PMIC_REG_LDO2_PWRDN_SEQ = 0x63,
+ PF1550_PMIC_REG_LDO3_PWRDN_SEQ = 0x64,
+ PF1550_PMIC_REG_VREFDDR_PWRDN_SEQ = 0x65,
+
+ PF1550_PMIC_REG_STATE_INFO = 0x67,
+ PF1550_PMIC_REG_I2C_ADDR = 0x68,
+ PF1550_PMIC_REG_IO_DRV0 = 0x69,
+ PF1550_PMIC_REG_IO_DRV1 = 0x6a,
+ PF1550_PMIC_REG_RC_16MHZ = 0x6b,
+ PF1550_PMIC_REG_KEY = 0x6f,
+
+ /* Charger part */
+ PF1550_CHARG_REG_CHG_INT = 0x80,
+ PF1550_CHARG_REG_CHG_INT_MASK = 0x82,
+ PF1550_CHARG_REG_CHG_INT_OK = 0x84,
+ PF1550_CHARG_REG_VBUS_SNS = 0x86,
+ PF1550_CHARG_REG_CHG_SNS = 0x87,
+ PF1550_CHARG_REG_BATT_SNS = 0x88,
+ PF1550_CHARG_REG_CHG_OPER = 0x89,
+ PF1550_CHARG_REG_CHG_TMR = 0x8a,
+ PF1550_CHARG_REG_CHG_EOC_CNFG = 0x8d,
+ PF1550_CHARG_REG_CHG_CURR_CNFG = 0x8e,
+ PF1550_CHARG_REG_BATT_REG = 0x8f,
+ PF1550_CHARG_REG_BATFET_CNFG = 0x91,
+ PF1550_CHARG_REG_THM_REG_CNFG = 0x92,
+ PF1550_CHARG_REG_VBUS_INLIM_CNFG = 0x94,
+ PF1550_CHARG_REG_VBUS_LIN_DPM = 0x95,
+ PF1550_CHARG_REG_USB_PHY_LDO_CNFG = 0x96,
+ PF1550_CHARG_REG_DBNC_DELAY_TIME = 0x98,
+ PF1550_CHARG_REG_CHG_INT_CNFG = 0x99,
+ PF1550_CHARG_REG_THM_ADJ_SETTING = 0x9a,
+ PF1550_CHARG_REG_VBUS2SYS_CNFG = 0x9b,
+ PF1550_CHARG_REG_LED_PWM = 0x9c,
+ PF1550_CHARG_REG_FAULT_BATFET_CNFG = 0x9d,
+ PF1550_CHARG_REG_LED_CNFG = 0x9e,
+ PF1550_CHARG_REG_CHGR_KEY2 = 0x9f,
+
+ PF1550_TEST_REG_FMRADDR = 0xc4,
+ PF1550_TEST_REG_FMRDATA = 0xc5,
+ PF1550_TEST_REG_KEY3 = 0xdf,
+
+ PF1550_PMIC_REG_END = 0xff,
+};
+
+/* One-Time Programmable(OTP) memory */
+enum pf1550_otp_reg {
+ PF1550_OTP_SW1_SW2 = 0x1e,
+ PF1550_OTP_SW2_SW3 = 0x1f,
+};
+
+#define PF1550_DEVICE_ID 0x7c
+
+/* Keys for reading OTP */
+#define PF1550_OTP_PMIC_KEY 0x15
+#define PF1550_OTP_CHGR_KEY 0x50
+#define PF1550_OTP_TEST_KEY 0xab
+
+/* Supported charger modes */
+#define PF1550_CHG_BAT_OFF 1
+#define PF1550_CHG_BAT_ON 2
+
+#define PF1550_CHG_PRECHARGE 0
+#define PF1550_CHG_CONSTANT_CURRENT 1
+#define PF1550_CHG_CONSTANT_VOL 2
+#define PF1550_CHG_EOC 3
+#define PF1550_CHG_DONE 4
+#define PF1550_CHG_TIMER_FAULT 6
+#define PF1550_CHG_SUSPEND 7
+#define PF1550_CHG_OFF_INV 8
+#define PF1550_CHG_BAT_OVER 9
+#define PF1550_CHG_OFF_TEMP 10
+#define PF1550_CHG_LINEAR_ONLY 12
+#define PF1550_CHG_SNS_MASK 0xf
+#define PF1550_CHG_INT_MASK 0x51
+
+#define PF1550_BAT_NO_VBUS 0
+#define PF1550_BAT_LOW_THAN_PRECHARG 1
+#define PF1550_BAT_CHARG_FAIL 2
+#define PF1550_BAT_HIGH_THAN_PRECHARG 4
+#define PF1550_BAT_OVER_VOL 5
+#define PF1550_BAT_NO_DETECT 6
+#define PF1550_BAT_SNS_MASK 0x7
+
+#define PF1550_VBUS_UVLO BIT(2)
+#define PF1550_VBUS_IN2SYS BIT(3)
+#define PF1550_VBUS_OVLO BIT(4)
+#define PF1550_VBUS_VALID BIT(5)
+
+#define PF1550_CHARG_REG_BATT_REG_CHGCV_MASK 0x3f
+#define PF1550_CHARG_REG_BATT_REG_VMINSYS_SHIFT 6
+#define PF1550_CHARG_REG_BATT_REG_VMINSYS_MASK GENMASK(7, 6)
+#define PF1550_CHARG_REG_THM_REG_CNFG_REGTEMP_SHIFT 2
+#define PF1550_CHARG_REG_THM_REG_CNFG_REGTEMP_MASK GENMASK(3, 2)
+
+#define PF1550_ONKEY_RST_EN BIT(7)
+
+/* DVS enable masks */
+#define OTP_SW1_DVS_ENB BIT(1)
+#define OTP_SW2_DVS_ENB BIT(3)
+
+/* Top level interrupt masks */
+#define IRQ_REGULATOR (BIT(1) | BIT(2) | BIT(3) | BIT(4) | BIT(6))
+#define IRQ_ONKEY BIT(5)
+#define IRQ_CHG BIT(0)
+
+/* Regulator interrupt masks */
+#define PMIC_IRQ_SW1_LS BIT(0)
+#define PMIC_IRQ_SW2_LS BIT(1)
+#define PMIC_IRQ_SW3_LS BIT(2)
+#define PMIC_IRQ_SW1_HS BIT(0)
+#define PMIC_IRQ_SW2_HS BIT(1)
+#define PMIC_IRQ_SW3_HS BIT(2)
+#define PMIC_IRQ_LDO1_FAULT BIT(0)
+#define PMIC_IRQ_LDO2_FAULT BIT(1)
+#define PMIC_IRQ_LDO3_FAULT BIT(2)
+#define PMIC_IRQ_TEMP_110 BIT(0)
+#define PMIC_IRQ_TEMP_125 BIT(1)
+
+/* Onkey interrupt masks */
+#define ONKEY_IRQ_PUSHI BIT(0)
+#define ONKEY_IRQ_1SI BIT(1)
+#define ONKEY_IRQ_2SI BIT(2)
+#define ONKEY_IRQ_3SI BIT(3)
+#define ONKEY_IRQ_4SI BIT(4)
+#define ONKEY_IRQ_8SI BIT(5)
+
+/* Charger interrupt masks */
+#define CHARG_IRQ_BAT2SOCI BIT(1)
+#define CHARG_IRQ_BATI BIT(2)
+#define CHARG_IRQ_CHGI BIT(3)
+#define CHARG_IRQ_VBUSI BIT(5)
+#define CHARG_IRQ_DPMI BIT(6)
+#define CHARG_IRQ_THMI BIT(7)
+
+enum pf1550_irq {
+ PF1550_IRQ_CHG,
+ PF1550_IRQ_REGULATOR,
+ PF1550_IRQ_ONKEY,
+};
+
+enum pf1550_pmic_irq {
+ PF1550_PMIC_IRQ_SW1_LS,
+ PF1550_PMIC_IRQ_SW2_LS,
+ PF1550_PMIC_IRQ_SW3_LS,
+ PF1550_PMIC_IRQ_SW1_HS,
+ PF1550_PMIC_IRQ_SW2_HS,
+ PF1550_PMIC_IRQ_SW3_HS,
+ PF1550_PMIC_IRQ_LDO1_FAULT,
+ PF1550_PMIC_IRQ_LDO2_FAULT,
+ PF1550_PMIC_IRQ_LDO3_FAULT,
+ PF1550_PMIC_IRQ_TEMP_110,
+ PF1550_PMIC_IRQ_TEMP_125,
+};
+
+enum pf1550_onkey_irq {
+ PF1550_ONKEY_IRQ_PUSHI,
+ PF1550_ONKEY_IRQ_1SI,
+ PF1550_ONKEY_IRQ_2SI,
+ PF1550_ONKEY_IRQ_3SI,
+ PF1550_ONKEY_IRQ_4SI,
+ PF1550_ONKEY_IRQ_8SI,
+};
+
+enum pf1550_charg_irq {
+ PF1550_CHARG_IRQ_BAT2SOCI,
+ PF1550_CHARG_IRQ_BATI,
+ PF1550_CHARG_IRQ_CHGI,
+ PF1550_CHARG_IRQ_VBUSI,
+ PF1550_CHARG_IRQ_THMI,
+};
+
+enum pf1550_regulators {
+ PF1550_SW1,
+ PF1550_SW2,
+ PF1550_SW3,
+ PF1550_VREFDDR,
+ PF1550_LDO1,
+ PF1550_LDO2,
+ PF1550_LDO3,
+};
+
+struct pf1550_ddata {
+ struct regmap_irq_chip_data *irq_data_regulator;
+ struct regmap_irq_chip_data *irq_data_charger;
+ struct regmap_irq_chip_data *irq_data_onkey;
+ struct regmap_irq_chip_data *irq_data;
+ struct regmap *regmap;
+ struct device *dev;
+ bool dvs1_enable;
+ bool dvs2_enable;
+ int irq;
+};
+
+#endif /* __LINUX_MFD_PF1550_H */
--
2.50.1
^ permalink raw reply related
* [PATCH v11 0/6] add support for pf1550 PMIC MFD-based drivers
From: Samuel Kayode via B4 Relay @ 2025-09-17 15:52 UTC (permalink / raw)
To: Lee Jones, Rob Herring, Krzysztof Kozlowski, Conor Dooley,
Liam Girdwood, Mark Brown, Dmitry Torokhov, Sebastian Reichel,
Frank Li
Cc: imx, devicetree, linux-kernel, linux-input, linux-pm, Abel Vesa,
Abel Vesa, Robin Gong, Robin Gong, Enric Balletbo i Serra,
Sean Nyekjaer, Christophe JAILLET, Samuel Kayode, Abel Vesa,
Krzysztof Kozlowski, Frank Li
This series adds support for pf1550 PMIC. It provides the core driver and
sub-drivers for the regulator, power supply and input subsystems.
Patch 1 adds the DT binding document for the PMIC. Patches 2-5 adds the
pertinent drivers. Last patch adds a MAINTAINERS entry for the drivers.
The patches 3-5 depend on the core driver provided in patch 2.
Changes since v1:
- DT bindings for all devices included
- Add onkey driver
- Add driver for the regulators
- Ensure charger is activated as some variants have it off by default
- Update mfd and charger driver per feedback from eballetbo@gmail.com
- Add myself as maintainer for these drivers
- Link to v1: https://lore.kernel.org/1523974819-8711-1-git-send-email-abel.vesa@nxp.com/
Changes since v2:
- Rebase on recent mainline kernel v6.15
- Single yaml file containing dt bindings for all pf1550 devices
- irq mapping done in MFD driver as suggested by Dmitry Torokhov
- Drop unnecessary includes in drivers
- Replace dev_err with dev_err_probe in probe method of drivers
- Drop compatible string from drivers of the sub-devices
- Remove dependency on OF from drivers of the sub-devices
- onkey: move driver from input/keyboard into input/misc
- onkey: remove dependency on OF
- onkey: use onkey virqs instead of central irq
- onkey: fix integer overflow for regmap_write when unmasking
interrupts during pf1550_onkey_resume
- charger: add support for monitored-battery which is used in setting
a constant voltage for the charger.
- Address other feedback from Dmitry Torokhov and Krzysztof Kozlowski
- Link to v2: https://lore.kernel.org/cover.1747409892.git.samuel.kayode@savoirfairelinux.com/
Changes since v3:
- Update manufacturer from Freescale to NXP in compatible,
dt-binding and Kconfigs
- Use C++ style comments for SPDX license in .c code
- Add portions copyright to source code
- irqs are defined as struct resource in mfd cell such that
platform_get_irq is used in the sub-devices
- Make struct pf1550_dev of type const in sub-device driver
- irq variable dropped from sub-device driver struct
- EXPORT_SYMBOL of global pf1550_read_otp function for use in
regulator driver
- Drop unneeded info in driver_data when defining device table id
- regulator: validate ramp_delay
- regulator: report overcurrent and over temperature events
- onkey: drop unnecessary keycode variable
- onkey: change wakeup variable to type bool
- onkey: replace (error < 0) with error in if statement when possible
- onkey: use pm_sleep_ptr when defining driver.pm
- charger: finish handling of some interrupts in threaded irq handler
- Link to v3: https://lore.kernel.org/20250527-pf1550-v3-0-45f69453cd51@savoirfairelinux.com/
Changes since v4:
- Use top level interrupt to minimize number of registers checked on
each interrupt
- Fix bad offset for temperature interrupts of regulator irq chip
- Address Krzysztof's comments for dt-binding
- regulator: add comments to clarify difference in its interrupts
- regulator: issue warn event for _LS interrupt and error event for
_HS interrupt
- regulator: validate maximum and minimum ramp_delay
- charger: drop lock in battery and charger delayed_work
- charger: more conservative locking for vbus delayed_work
- charger: apply lock when setting power_supply type during register
intialization
- Link to v4: https://lore.kernel.org/r/20250603-pf1550-v4-0-bfdf51ee59cc@savoirfairelinux.com
Changes since v5:
- Ensure lowercase when assigning hex values
- Add imx@lists.linux.dev to relevant mailing list in MAINTAINERS file
- Use GENMASK macro
- Drop unused chips variable
- Read the OTP in the mfd driver probe for new dvs_enb variable
- Hardcode IRQ flags in pf1550_add_child function
- charger: drop the mutex entirely
- charger: reverse christmas tree style local variable definition in
probe
- Link to v5: https://lore.kernel.org/r/20250610-pf1550-v5-0-ed0d9e3aaac7@savoirfairelinux.com
Changes since v6:
- Use reverse christmas tree order
- Drop 0 in table id's driver data
- charger: store virq to avoid reinvoking platform_get_irq in ISR
- Link to v6: https://lore.kernel.org/r/20250611-pf1550-v6-0-34f2ddfe045e@savoirfairelinux.com
Changes since v7:
- Thanks everyone for the reviews
- Use C++ comment only for SPDX license header in core, charger and
onkey drivers
- Drop filenames from comments
- Rename pf1550_dev to pf1550_ddata
- Define OTP register for accessing status of DVS
- core: rename from `mfd driver` to `core driver`
- core: add child devices in a cleaner manner
- charger: define two power supplies: battery and external power
- charger: use devm_delayed_work_autocancel
- Link to v7: https://lore.kernel.org/r/20250612-pf1550-v7-0-0e393b0f45d7@savoirfairelinux.com
Changes since v8:
- Collect Frank's `Reviewed-by` tags
- core: use consistent whitespace
- regulator: add standby support for regulators requested by Sean Nyekjaer
- regulator: add support for SW1 DVS enable/disable
- regulator: fix improper DVS activation
- regulator: add map_voltage for regulators
- regulator: add enable/disable for regulators
- charger: use datasheet thermal regulation temperature ranges
- charger: select charger operation mode based on the application
- onkey: add support for disabling system power down via onkey
- dt-bindings: changed temperature ranges
- dt-bindings: added `disable-key-power`
- Link to v8: https://lore.kernel.org/r/20250707-pf1550-v8-0-6b6eb67c03a0@savoirfairelinux.com
Changes since v9:
- add Sean's Tested-by tag
- core: style changes
- dt-bindings: add regulator-state-mem to examples
- onkey: use regmap_clear_bits to avoid overwriting all bits of the
PWRCTRL register
- Link to v9: https://lore.kernel.org/r/20250716-pf1550-v9-0-502a647f04ef@savoirfairelinux.com
Changes since v10:
- add Sean's Tested-by tag on mfd patch
- charger: separate battery properties from charger properties
- Link to v10: https://lore.kernel.org/r/20250820-pf1550-v10-0-4c0b6e4445e3@savoirfairelinux.com
Signed-off-by: Samuel Kayode <samuel.kayode@savoirfairelinux.com>
---
Samuel Kayode (6):
dt-bindings: mfd: add pf1550
mfd: pf1550: add core driver
regulator: pf1550: add support for regulator
input: pf1550: add onkey support
power: supply: pf1550: add battery charger support
MAINTAINERS: add an entry for pf1550 mfd driver
.../devicetree/bindings/mfd/nxp,pf1550.yaml | 161 ++++++
MAINTAINERS | 11 +
drivers/input/misc/Kconfig | 11 +
drivers/input/misc/Makefile | 1 +
drivers/input/misc/pf1550-onkey.c | 197 +++++++
drivers/mfd/Kconfig | 16 +
drivers/mfd/Makefile | 2 +
drivers/mfd/pf1550.c | 367 ++++++++++++
drivers/power/supply/Kconfig | 11 +
drivers/power/supply/Makefile | 1 +
drivers/power/supply/pf1550-charger.c | 641 +++++++++++++++++++++
drivers/regulator/Kconfig | 9 +
drivers/regulator/Makefile | 1 +
drivers/regulator/pf1550-regulator.c | 429 ++++++++++++++
include/linux/mfd/pf1550.h | 273 +++++++++
15 files changed, 2131 insertions(+)
---
base-commit: 0a4b866d08c6adaea2f4592d31edac6deeb4dcbd
change-id: 20250527-pf1550-d401f0d07b80
Best regards,
--
Samuel Kayode <samuel.kayode@savoirfairelinux.com>
^ permalink raw reply
* [PATCH v11 1/6] dt-bindings: mfd: add pf1550
From: Samuel Kayode via B4 Relay @ 2025-09-17 15:52 UTC (permalink / raw)
To: Lee Jones, Rob Herring, Krzysztof Kozlowski, Conor Dooley,
Liam Girdwood, Mark Brown, Dmitry Torokhov, Sebastian Reichel,
Frank Li
Cc: imx, devicetree, linux-kernel, linux-input, linux-pm, Abel Vesa,
Abel Vesa, Robin Gong, Robin Gong, Enric Balletbo i Serra,
Sean Nyekjaer, Christophe JAILLET, Samuel Kayode, Abel Vesa,
Krzysztof Kozlowski
In-Reply-To: <20250917-pf1550-v11-0-e0649822fcc9@savoirfairelinux.com>
From: Samuel Kayode <samuel.kayode@savoirfairelinux.com>
Add a DT binding document for pf1550 PMIC. This describes the core mfd
device along with its children: regulators, charger and onkey.
Reviewed-by: Krzysztof Kozlowski <krzysztof.kozlowski@linaro.org>
Tested-by: Sean Nyekjaer <sean@geanix.com>
Signed-off-by: Samuel Kayode <samuel.kayode@savoirfairelinux.com>
---
v10:
- Add regulator-state-mem to examples
v9:
- Add regulator suspend bindings in example
- Add binding for disabling onkey power down
- Fix thermal regulation temperature range
v5:
- Address Krzystof's feedback:
- Drop monitored battery ref already included in power supply schema
- Move `additionalProperties` close to `type` for regulator
- Drop unneccessary |
- Change `additionalProperties` to `unevaluatedProperties` for the
PMIC
v4:
- Address Krzystof's feedback:
- Filename changed to nxp,pf1550.yaml
- Replace Freescale with NXP
- Define include before battery-cell
- Drop operating-range-celsius in example since
nxp,thermal-regulation-celsisus already exists
- Not sure if there is similar binding to thermal-regulation...
for regulating temperature on thermal-zones? @Sebastian and @Krzysztof
v3:
- Address Krzysztof's feedback:
- Fold charger and onkey objects
- Drop compatible for sub-devices: onkey, charger and regulator.
- Drop constant voltage property already included in
monitored-battery
- Fix whitespace warnings
- Fix license
v2:
- Add yamls for the PMIC and the sub-devices
---
.../devicetree/bindings/mfd/nxp,pf1550.yaml | 161 +++++++++++++++++++++
1 file changed, 161 insertions(+)
diff --git a/Documentation/devicetree/bindings/mfd/nxp,pf1550.yaml b/Documentation/devicetree/bindings/mfd/nxp,pf1550.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..e50dc44252c60063463295c5ec3e3c90d1592ec2
--- /dev/null
+++ b/Documentation/devicetree/bindings/mfd/nxp,pf1550.yaml
@@ -0,0 +1,161 @@
+# SPDX-License-Identifier: GPL-2.0-only OR BSD-2-Clause
+%YAML 1.2
+---
+$id: http://devicetree.org/schemas/mfd/nxp,pf1550.yaml#
+$schema: http://devicetree.org/meta-schemas/core.yaml#
+
+title: NXP PF1550 Power Management IC
+
+maintainers:
+ - Samuel Kayode <samuel.kayode@savoirfairelinux.com>
+
+description:
+ PF1550 PMIC provides battery charging and power supply for low power IoT and
+ wearable applications. This device consists of an i2c controlled MFD that
+ includes regulators, battery charging and an onkey/power button.
+
+$ref: /schemas/power/supply/power-supply.yaml
+
+properties:
+ compatible:
+ const: nxp,pf1550
+
+ reg:
+ maxItems: 1
+
+ interrupts:
+ maxItems: 1
+
+ wakeup-source: true
+
+ regulators:
+ type: object
+ additionalProperties: false
+
+ patternProperties:
+ "^(ldo[1-3]|sw[1-3]|vrefddr)$":
+ type: object
+ $ref: /schemas/regulator/regulator.yaml
+ description:
+ regulator configuration for ldo1-3, buck converters(sw1-3)
+ and DDR termination reference voltage (vrefddr)
+ unevaluatedProperties: false
+
+ monitored-battery:
+ description: |
+ A phandle to a monitored battery node that contains a valid value
+ for:
+ constant-charge-voltage-max-microvolt.
+
+ nxp,thermal-regulation-celsius:
+ description:
+ Temperature threshold for thermal regulation of charger in celsius.
+ enum: [ 80, 95, 110, 125 ]
+
+ nxp,min-system-microvolt:
+ description:
+ System specific lower limit voltage.
+ enum: [ 3500000, 3700000, 4300000 ]
+
+ nxp,disable-key-power:
+ type: boolean
+ description:
+ Disable power-down using a long key-press. The onkey driver will remove
+ support for the KEY_POWER key press when triggered using a long press of
+ the onkey.
+
+required:
+ - compatible
+ - reg
+ - interrupts
+
+unevaluatedProperties: false
+
+examples:
+ - |
+ #include <dt-bindings/interrupt-controller/irq.h>
+ #include <dt-bindings/input/linux-event-codes.h>
+
+ battery: battery-cell {
+ compatible = "simple-battery";
+ constant-charge-voltage-max-microvolt = <4400000>;
+ };
+
+ i2c {
+ #address-cells = <1>;
+ #size-cells = <0>;
+
+ pmic@8 {
+ compatible = "nxp,pf1550";
+ reg = <0x8>;
+
+ interrupt-parent = <&gpio1>;
+ interrupts = <2 IRQ_TYPE_LEVEL_LOW>;
+ wakeup-source;
+ monitored-battery = <&battery>;
+ nxp,min-system-microvolt = <4300000>;
+ nxp,thermal-regulation-celsius = <80>;
+
+ regulators {
+ sw1_reg: sw1 {
+ regulator-name = "sw1";
+ regulator-min-microvolt = <600000>;
+ regulator-max-microvolt = <1387500>;
+ regulator-always-on;
+ regulator-ramp-delay = <6250>;
+
+ regulator-state-mem {
+ regulator-on-in-suspend;
+ regulator-suspend-min-microvolt = <1270000>;
+ };
+ };
+
+ sw2_reg: sw2 {
+ regulator-name = "sw2";
+ regulator-min-microvolt = <600000>;
+ regulator-max-microvolt = <1387500>;
+ regulator-always-on;
+
+ regulator-state-mem {
+ regulator-on-in-suspend;
+ };
+ };
+
+ sw3_reg: sw3 {
+ regulator-name = "sw3";
+ regulator-min-microvolt = <1800000>;
+ regulator-max-microvolt = <3300000>;
+ regulator-always-on;
+
+ regulator-state-mem {
+ regulator-on-in-suspend;
+ };
+ };
+
+ vldo1_reg: ldo1 {
+ regulator-name = "ldo1";
+ regulator-min-microvolt = <750000>;
+ regulator-max-microvolt = <3300000>;
+ regulator-always-on;
+
+ regulator-state-mem {
+ regulator-off-in-suspend;
+ };
+ };
+
+ vldo2_reg: ldo2 {
+ regulator-name = "ldo2";
+ regulator-min-microvolt = <1800000>;
+ regulator-max-microvolt = <3300000>;
+ regulator-always-on;
+ };
+
+ vldo3_reg: ldo3 {
+ regulator-name = "ldo3";
+ regulator-min-microvolt = <750000>;
+ regulator-max-microvolt = <3300000>;
+ regulator-always-on;
+ };
+ };
+ };
+ };
--
2.50.1
^ permalink raw reply related
* [PATCH v11 4/6] input: pf1550: add onkey support
From: Samuel Kayode via B4 Relay @ 2025-09-17 15:52 UTC (permalink / raw)
To: Lee Jones, Rob Herring, Krzysztof Kozlowski, Conor Dooley,
Liam Girdwood, Mark Brown, Dmitry Torokhov, Sebastian Reichel,
Frank Li
Cc: imx, devicetree, linux-kernel, linux-input, linux-pm, Abel Vesa,
Abel Vesa, Robin Gong, Robin Gong, Enric Balletbo i Serra,
Sean Nyekjaer, Christophe JAILLET, Samuel Kayode, Abel Vesa,
Frank Li
In-Reply-To: <20250917-pf1550-v11-0-e0649822fcc9@savoirfairelinux.com>
From: Samuel Kayode <samuel.kayode@savoirfairelinux.com>
Add support for the onkey of the pf1550 PMIC.
Acked-by: Dmitry Torokhov <dmitry.torokhov@gmail.com>
Reviewed-by: Frank Li <Frank.Li@nxp.com>
Tested-by: Sean Nyekjaer <sean@geanix.com>
Signed-off-by: Samuel Kayode <samuel.kayode@savoirfairelinux.com>
---
v10:
- Use regmap_clear_bits instead of regmap_write
v9:
- Requested by Sean:
- Add support for disabling power down of system by onkey
v8:
- Pick up `Acked-by` tag from Dmitry
- Use C++ for SPDX license header comment and C type for rest of license
comment
v7:
- Use reverese christmas tree style
- Drop unecessary 0 in id table's driver data
v4:
- Address Dmitry's feedback
- Drop irq variable in onkey_drv_data
- Drop keycode variable in onkey_drv_data
- Define wakeup as type bool
- Use platform_get_irq
- Use type const for struct pf1550_dev in onkey_drv_data
- Replace (error < 0) with (error) in if statement when applicable
- No need to define driver_data in table id
- Define driver.pm with pm_sleep_ptr
v3:
- Address Dmitry's feedback
- Drop compatible string
- Remove dependency on OF
- Use generic device properties
- Drop unnecessary includes
- Drop unnecessary initializations in probe
- Always use the KEY_POWER property for onkey->keycode
- Do mapping of irqs in MFD driver
- Define onkey->input before interrupts are active
- Drop unnecessary input_free_device since devm
- Manage onkey irqs instead of the main interrupt line.
- Fix integer overflow when unmasking onkey irqs in onkey_resume.
v2:
- Add driver for onkey
---
drivers/input/misc/Kconfig | 11 +++
drivers/input/misc/Makefile | 1 +
drivers/input/misc/pf1550-onkey.c | 197 ++++++++++++++++++++++++++++++++++++++
3 files changed, 209 insertions(+)
diff --git a/drivers/input/misc/Kconfig b/drivers/input/misc/Kconfig
index f5496ca0c0d2bfcb7968503ccd1844ff43bbc1c0..47b3c43ff0550f14d61990997976366436411adc 100644
--- a/drivers/input/misc/Kconfig
+++ b/drivers/input/misc/Kconfig
@@ -179,6 +179,17 @@ config INPUT_PCSPKR
To compile this driver as a module, choose M here: the
module will be called pcspkr.
+config INPUT_PF1550_ONKEY
+ tristate "NXP PF1550 Onkey support"
+ depends on MFD_PF1550
+ help
+ Say Y here if you want support for PF1550 PMIC. Onkey can trigger
+ release and 1s(push hold), 2s, 3s, 4s, 8s interrupt for long press
+ detect.
+
+ To compile this driver as a module, choose M here. The module will be
+ called pf1550-onkey.
+
config INPUT_PM8941_PWRKEY
tristate "Qualcomm PM8941 power key support"
depends on MFD_SPMI_PMIC
diff --git a/drivers/input/misc/Makefile b/drivers/input/misc/Makefile
index 6d91804d0a6f761a094e6c380f878f74c3054d63..c652337de464c1eeaf1515d0bc84d10de0cb3a74 100644
--- a/drivers/input/misc/Makefile
+++ b/drivers/input/misc/Makefile
@@ -62,6 +62,7 @@ obj-$(CONFIG_INPUT_PCAP) += pcap_keys.o
obj-$(CONFIG_INPUT_PCF50633_PMU) += pcf50633-input.o
obj-$(CONFIG_INPUT_PCF8574) += pcf8574_keypad.o
obj-$(CONFIG_INPUT_PCSPKR) += pcspkr.o
+obj-$(CONFIG_INPUT_PF1550_ONKEY) += pf1550-onkey.o
obj-$(CONFIG_INPUT_PM8941_PWRKEY) += pm8941-pwrkey.o
obj-$(CONFIG_INPUT_PM8XXX_VIBRATOR) += pm8xxx-vibrator.o
obj-$(CONFIG_INPUT_PMIC8XXX_PWRKEY) += pmic8xxx-pwrkey.o
diff --git a/drivers/input/misc/pf1550-onkey.c b/drivers/input/misc/pf1550-onkey.c
new file mode 100644
index 0000000000000000000000000000000000000000..9be6377151cb3be824ab34ff37f983196b909324
--- /dev/null
+++ b/drivers/input/misc/pf1550-onkey.c
@@ -0,0 +1,197 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Driver for the PF1550 ONKEY
+ * Copyright (C) 2016 Freescale Semiconductor, Inc. All Rights Reserved.
+ *
+ * Portions Copyright (c) 2025 Savoir-faire Linux Inc.
+ * Samuel Kayode <samuel.kayode@savoirfairelinux.com>
+ */
+
+#include <linux/err.h>
+#include <linux/input.h>
+#include <linux/interrupt.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/mfd/pf1550.h>
+#include <linux/platform_device.h>
+
+#define PF1550_ONKEY_IRQ_NR 6
+
+struct onkey_drv_data {
+ struct device *dev;
+ const struct pf1550_ddata *pf1550;
+ bool wakeup;
+ struct input_dev *input;
+};
+
+static irqreturn_t pf1550_onkey_irq_handler(int irq, void *data)
+{
+ struct onkey_drv_data *onkey = data;
+ struct platform_device *pdev = to_platform_device(onkey->dev);
+ int i, state, irq_type = -1;
+
+ for (i = 0; i < PF1550_ONKEY_IRQ_NR; i++)
+ if (irq == platform_get_irq(pdev, i))
+ irq_type = i;
+
+ switch (irq_type) {
+ case PF1550_ONKEY_IRQ_PUSHI:
+ state = 0;
+ break;
+ case PF1550_ONKEY_IRQ_1SI:
+ case PF1550_ONKEY_IRQ_2SI:
+ case PF1550_ONKEY_IRQ_3SI:
+ case PF1550_ONKEY_IRQ_4SI:
+ case PF1550_ONKEY_IRQ_8SI:
+ state = 1;
+ break;
+ default:
+ dev_err(onkey->dev, "onkey interrupt: irq %d occurred\n",
+ irq_type);
+ return IRQ_HANDLED;
+ }
+
+ input_event(onkey->input, EV_KEY, KEY_POWER, state);
+ input_sync(onkey->input);
+
+ return IRQ_HANDLED;
+}
+
+static int pf1550_onkey_probe(struct platform_device *pdev)
+{
+ struct onkey_drv_data *onkey;
+ struct input_dev *input;
+ bool key_power = false;
+ int i, irq, error;
+
+ onkey = devm_kzalloc(&pdev->dev, sizeof(*onkey), GFP_KERNEL);
+ if (!onkey)
+ return -ENOMEM;
+
+ onkey->dev = &pdev->dev;
+
+ onkey->pf1550 = dev_get_drvdata(pdev->dev.parent);
+ if (!onkey->pf1550->regmap)
+ return dev_err_probe(&pdev->dev, -ENODEV,
+ "failed to get regmap\n");
+
+ onkey->wakeup = device_property_read_bool(pdev->dev.parent,
+ "wakeup-source");
+
+ if (device_property_read_bool(pdev->dev.parent,
+ "nxp,disable-key-power")) {
+ error = regmap_clear_bits(onkey->pf1550->regmap,
+ PF1550_PMIC_REG_PWRCTRL1,
+ PF1550_ONKEY_RST_EN);
+ if (error)
+ return dev_err_probe(&pdev->dev, error,
+ "failed: disable turn system off");
+ } else {
+ key_power = true;
+ }
+
+ input = devm_input_allocate_device(&pdev->dev);
+ if (!input)
+ return dev_err_probe(&pdev->dev, -ENOMEM,
+ "failed to allocate the input device\n");
+
+ input->name = pdev->name;
+ input->phys = "pf1550-onkey/input0";
+ input->id.bustype = BUS_HOST;
+
+ if (key_power)
+ input_set_capability(input, EV_KEY, KEY_POWER);
+
+ onkey->input = input;
+ platform_set_drvdata(pdev, onkey);
+
+ for (i = 0; i < PF1550_ONKEY_IRQ_NR; i++) {
+ irq = platform_get_irq(pdev, i);
+ if (irq < 0)
+ return irq;
+
+ error = devm_request_threaded_irq(&pdev->dev, irq, NULL,
+ pf1550_onkey_irq_handler,
+ IRQF_NO_SUSPEND,
+ "pf1550-onkey", onkey);
+ if (error)
+ return dev_err_probe(&pdev->dev, error,
+ "failed: irq request (IRQ: %d)\n",
+ i);
+ }
+
+ error = input_register_device(input);
+ if (error)
+ return dev_err_probe(&pdev->dev, error,
+ "failed to register input device\n");
+
+ device_init_wakeup(&pdev->dev, onkey->wakeup);
+
+ return 0;
+}
+
+static int pf1550_onkey_suspend(struct device *dev)
+{
+ struct platform_device *pdev = to_platform_device(dev);
+ struct onkey_drv_data *onkey = platform_get_drvdata(pdev);
+ int i, irq;
+
+ if (!device_may_wakeup(&pdev->dev))
+ regmap_write(onkey->pf1550->regmap,
+ PF1550_PMIC_REG_ONKEY_INT_MASK0,
+ ONKEY_IRQ_PUSHI | ONKEY_IRQ_1SI | ONKEY_IRQ_2SI |
+ ONKEY_IRQ_3SI | ONKEY_IRQ_4SI | ONKEY_IRQ_8SI);
+ else
+ for (i = 0; i < PF1550_ONKEY_IRQ_NR; i++) {
+ irq = platform_get_irq(pdev, i);
+ if (irq > 0)
+ enable_irq_wake(irq);
+ }
+
+ return 0;
+}
+
+static int pf1550_onkey_resume(struct device *dev)
+{
+ struct platform_device *pdev = to_platform_device(dev);
+ struct onkey_drv_data *onkey = platform_get_drvdata(pdev);
+ int i, irq;
+
+ if (!device_may_wakeup(&pdev->dev))
+ regmap_write(onkey->pf1550->regmap,
+ PF1550_PMIC_REG_ONKEY_INT_MASK0,
+ ~((u8)(ONKEY_IRQ_PUSHI | ONKEY_IRQ_1SI |
+ ONKEY_IRQ_2SI | ONKEY_IRQ_3SI | ONKEY_IRQ_4SI |
+ ONKEY_IRQ_8SI)));
+ else
+ for (i = 0; i < PF1550_ONKEY_IRQ_NR; i++) {
+ irq = platform_get_irq(pdev, i);
+ if (irq > 0)
+ disable_irq_wake(irq);
+ }
+
+ return 0;
+}
+
+static SIMPLE_DEV_PM_OPS(pf1550_onkey_pm_ops, pf1550_onkey_suspend,
+ pf1550_onkey_resume);
+
+static const struct platform_device_id pf1550_onkey_id[] = {
+ { "pf1550-onkey", },
+ { /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(platform, pf1550_onkey_id);
+
+static struct platform_driver pf1550_onkey_driver = {
+ .driver = {
+ .name = "pf1550-onkey",
+ .pm = pm_sleep_ptr(&pf1550_onkey_pm_ops),
+ },
+ .probe = pf1550_onkey_probe,
+ .id_table = pf1550_onkey_id,
+};
+module_platform_driver(pf1550_onkey_driver);
+
+MODULE_AUTHOR("Freescale Semiconductor");
+MODULE_DESCRIPTION("PF1550 onkey Driver");
+MODULE_LICENSE("GPL");
--
2.50.1
^ permalink raw reply related
* [PATCH v11 3/6] regulator: pf1550: add support for regulator
From: Samuel Kayode via B4 Relay @ 2025-09-17 15:52 UTC (permalink / raw)
To: Lee Jones, Rob Herring, Krzysztof Kozlowski, Conor Dooley,
Liam Girdwood, Mark Brown, Dmitry Torokhov, Sebastian Reichel,
Frank Li
Cc: imx, devicetree, linux-kernel, linux-input, linux-pm, Abel Vesa,
Abel Vesa, Robin Gong, Robin Gong, Enric Balletbo i Serra,
Sean Nyekjaer, Christophe JAILLET, Samuel Kayode, Abel Vesa,
Frank Li
In-Reply-To: <20250917-pf1550-v11-0-e0649822fcc9@savoirfairelinux.com>
From: Samuel Kayode <samuel.kayode@savoirfairelinux.com>
Add regulator support for the pf1550 PMIC.
Reviewed-by: Frank Li <Frank.Li@nxp.com>
Reviewed-by: Mark Brown <broonie@kernel.org>
Tested-by: Sean Nyekjaer <sean@geanix.com>
Signed-off-by: Samuel Kayode <samuel.kayode@savoirfairelinux.com>
---
v10:
- Change dvsX_enb to dvsX_enable
v9:
- Requested by Sean:
- Add support for SW1 DVS enable/disable
- Add support for standby voltages
- Add map_voltage for all configurable regulators
- Add regulator enable/disable for all regulators
- Fix for DVS activation when meant to be disabled
v7:
- Use reverese christmas tree style
- Drop unecessary 0 in id table's driver data
v6:
- Use dvs_enb variable in pf1550_dev as suggested by Frank Li
v5:
- Address Mark's feedback:
- Add comments to clarify difference in interrupts
- Issue warn event for _LS(low side) interrupt
- Validate maximum ramp_delay
v4:
- Address Mark's feedback:
- Use C++ comments for SPDX license
- Add portions copyright to reflect my update
- Validate ramp_delay
- Report overcurrent and temperature events
- Use platform_get_irq
v3:
- Drop duplicate include
- Drop unnecessary includes
- Accept lower case regulator names from devicetree
- Use virqs mapped in core MFD driver
v2:
- Add driver for regulator
---
drivers/regulator/Kconfig | 9 +
drivers/regulator/Makefile | 1 +
drivers/regulator/pf1550-regulator.c | 429 +++++++++++++++++++++++++++++++++++
3 files changed, 439 insertions(+)
diff --git a/drivers/regulator/Kconfig b/drivers/regulator/Kconfig
index 6d8988387da4599633ca9bde2698b9711e34a245..de455887f9aeeada5546e44b8dc9d7ed041618a6 100644
--- a/drivers/regulator/Kconfig
+++ b/drivers/regulator/Kconfig
@@ -1049,6 +1049,15 @@ config REGULATOR_PV88090
Say y here to support the voltage regulators and convertors
on PV88090
+config REGULATOR_PF1550
+ tristate "NXP PF1550 regulator"
+ depends on MFD_PF1550
+ help
+ Say y here to select this option to enable the regulators on
+ the PF1550 PMICs.
+ This driver controls the PF1550 regulators via I2C bus.
+ The regulators include three bucks and three ldos.
+
config REGULATOR_PWM
tristate "PWM voltage regulator"
depends on PWM
diff --git a/drivers/regulator/Makefile b/drivers/regulator/Makefile
index c0bc7a0f4e67098c50ac3cf887ae95f46b2eac44..891174b511fc0653bac662c71659498122e8441f 100644
--- a/drivers/regulator/Makefile
+++ b/drivers/regulator/Makefile
@@ -125,6 +125,7 @@ obj-$(CONFIG_REGULATOR_QCOM_USB_VBUS) += qcom_usb_vbus-regulator.o
obj-$(CONFIG_REGULATOR_PALMAS) += palmas-regulator.o
obj-$(CONFIG_REGULATOR_PCA9450) += pca9450-regulator.o
obj-$(CONFIG_REGULATOR_PF9453) += pf9453-regulator.o
+obj-$(CONFIG_REGULATOR_PF1550) += pf1550-regulator.o
obj-$(CONFIG_REGULATOR_PF8X00) += pf8x00-regulator.o
obj-$(CONFIG_REGULATOR_PFUZE100) += pfuze100-regulator.o
obj-$(CONFIG_REGULATOR_PV88060) += pv88060-regulator.o
diff --git a/drivers/regulator/pf1550-regulator.c b/drivers/regulator/pf1550-regulator.c
new file mode 100644
index 0000000000000000000000000000000000000000..90492609773886343151c2ba40d2d4bf84c37c5e
--- /dev/null
+++ b/drivers/regulator/pf1550-regulator.c
@@ -0,0 +1,429 @@
+// SPDX-License-Identifier: GPL-2.0
+//
+// regulator driver for the PF1550
+//
+// Copyright (C) 2016 Freescale Semiconductor, Inc.
+// Robin Gong <yibin.gong@freescale.com>
+//
+// Portions Copyright (c) 2025 Savoir-faire Linux Inc.
+// Samuel Kayode <samuel.kayode@savoirfairelinux.com>
+//
+
+#include <linux/err.h>
+#include <linux/interrupt.h>
+#include <linux/mfd/pf1550.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/regulator/driver.h>
+#include <linux/regulator/machine.h>
+
+#define PF1550_REGULATOR_IRQ_NR 11
+#define PF1550_MAX_REGULATOR 7
+
+struct pf1550_desc {
+ struct regulator_desc desc;
+ unsigned char stby_reg;
+ unsigned char stby_mask;
+ unsigned char stby_enable_reg;
+ unsigned char stby_enable_mask;
+};
+
+struct pf1550_regulator_info {
+ struct device *dev;
+ const struct pf1550_ddata *pf1550;
+ struct pf1550_desc regulator_descs[PF1550_MAX_REGULATOR];
+ struct regulator_dev *rdevs[PF1550_MAX_REGULATOR];
+};
+
+static const int pf1550_sw12_volts[] = {
+ 1100000, 1200000, 1350000, 1500000, 1800000, 2500000, 3000000, 3300000,
+};
+
+static const int pf1550_ldo13_volts[] = {
+ 750000, 800000, 850000, 900000, 950000, 1000000, 1050000, 1100000,
+ 1150000, 1200000, 1250000, 1300000, 1350000, 1400000, 1450000, 1500000,
+ 1800000, 1900000, 2000000, 2100000, 2200000, 2300000, 2400000, 2500000,
+ 2600000, 2700000, 2800000, 2900000, 3000000, 3100000, 3200000, 3300000,
+};
+
+static int pf1550_set_ramp_delay(struct regulator_dev *rdev, int ramp_delay)
+{
+ int id = rdev_get_id(rdev);
+ unsigned int ramp_bits = 0;
+ int ret;
+
+ if (id > PF1550_VREFDDR)
+ return -EACCES;
+
+ if (ramp_delay < 0 || ramp_delay > 6250)
+ return -EINVAL;
+
+ ramp_delay = 6250 / ramp_delay;
+ ramp_bits = ramp_delay >> 1;
+
+ ret = regmap_update_bits(rdev->regmap, rdev->desc->vsel_reg + 4, 0x10,
+ ramp_bits << 4);
+ if (ret < 0)
+ dev_err(&rdev->dev, "ramp failed, err %d\n", ret);
+
+ return ret;
+}
+
+static int pf1550_set_suspend_enable(struct regulator_dev *rdev)
+{
+ const struct pf1550_desc *desc = container_of(rdev->desc,
+ struct pf1550_desc,
+ desc);
+ unsigned int val = desc->stby_enable_mask;
+
+ return regmap_update_bits(rdev->regmap, desc->stby_enable_reg,
+ desc->stby_enable_mask, val);
+}
+
+static int pf1550_set_suspend_disable(struct regulator_dev *rdev)
+{
+ const struct pf1550_desc *desc = container_of(rdev->desc,
+ struct pf1550_desc,
+ desc);
+
+ return regmap_update_bits(rdev->regmap, desc->stby_enable_reg,
+ desc->stby_enable_mask, 0);
+}
+
+static int pf1550_buck_set_table_suspend_voltage(struct regulator_dev *rdev,
+ int uV)
+{
+ const struct pf1550_desc *desc = container_of(rdev->desc,
+ struct pf1550_desc,
+ desc);
+ int ret;
+
+ ret = regulator_map_voltage_ascend(rdev, uV, uV);
+ if (ret < 0) {
+ dev_err(rdev_get_dev(rdev), "failed to map %i uV\n", uV);
+ return ret;
+ }
+
+ return regmap_update_bits(rdev->regmap, desc->stby_reg,
+ desc->stby_mask, ret);
+}
+
+static int pf1550_buck_set_linear_suspend_voltage(struct regulator_dev *rdev,
+ int uV)
+{
+ const struct pf1550_desc *desc = container_of(rdev->desc,
+ struct pf1550_desc,
+ desc);
+ int ret;
+
+ ret = regulator_map_voltage_linear(rdev, uV, uV);
+ if (ret < 0) {
+ dev_err(rdev_get_dev(rdev), "failed to map %i uV\n", uV);
+ return ret;
+ }
+
+ return regmap_update_bits(rdev->regmap, desc->stby_reg,
+ desc->stby_mask, ret);
+}
+
+static const struct regulator_ops pf1550_sw1_ops = {
+ .enable = regulator_enable_regmap,
+ .disable = regulator_disable_regmap,
+ .set_suspend_enable = pf1550_set_suspend_enable,
+ .set_suspend_disable = pf1550_set_suspend_disable,
+ .is_enabled = regulator_is_enabled_regmap,
+ .list_voltage = regulator_list_voltage_table,
+ .set_voltage_sel = regulator_set_voltage_sel_regmap,
+ .get_voltage_sel = regulator_get_voltage_sel_regmap,
+ .set_voltage_time_sel = regulator_set_voltage_time_sel,
+ .set_suspend_voltage = pf1550_buck_set_table_suspend_voltage,
+ .map_voltage = regulator_map_voltage_ascend,
+ .set_ramp_delay = pf1550_set_ramp_delay,
+};
+
+static const struct regulator_ops pf1550_sw2_ops = {
+ .enable = regulator_enable_regmap,
+ .disable = regulator_disable_regmap,
+ .set_suspend_enable = pf1550_set_suspend_enable,
+ .set_suspend_disable = pf1550_set_suspend_disable,
+ .is_enabled = regulator_is_enabled_regmap,
+ .list_voltage = regulator_list_voltage_linear,
+ .set_voltage_sel = regulator_set_voltage_sel_regmap,
+ .get_voltage_sel = regulator_get_voltage_sel_regmap,
+ .set_voltage_time_sel = regulator_set_voltage_time_sel,
+ .set_suspend_voltage = pf1550_buck_set_linear_suspend_voltage,
+ .map_voltage = regulator_map_voltage_linear,
+ .set_ramp_delay = pf1550_set_ramp_delay,
+};
+
+static const struct regulator_ops pf1550_ldo1_ops = {
+ .enable = regulator_enable_regmap,
+ .disable = regulator_disable_regmap,
+ .set_suspend_enable = pf1550_set_suspend_enable,
+ .set_suspend_disable = pf1550_set_suspend_disable,
+ .is_enabled = regulator_is_enabled_regmap,
+ .list_voltage = regulator_list_voltage_table,
+ .map_voltage = regulator_map_voltage_ascend,
+ .set_voltage_sel = regulator_set_voltage_sel_regmap,
+ .get_voltage_sel = regulator_get_voltage_sel_regmap,
+};
+
+static const struct regulator_ops pf1550_ldo2_ops = {
+ .enable = regulator_enable_regmap,
+ .disable = regulator_disable_regmap,
+ .set_suspend_enable = pf1550_set_suspend_enable,
+ .set_suspend_disable = pf1550_set_suspend_disable,
+ .is_enabled = regulator_is_enabled_regmap,
+ .list_voltage = regulator_list_voltage_linear,
+ .set_voltage_sel = regulator_set_voltage_sel_regmap,
+ .get_voltage_sel = regulator_get_voltage_sel_regmap,
+ .map_voltage = regulator_map_voltage_linear,
+};
+
+static const struct regulator_ops pf1550_fixed_ops = {
+ .enable = regulator_enable_regmap,
+ .disable = regulator_disable_regmap,
+ .set_suspend_enable = pf1550_set_suspend_enable,
+ .set_suspend_disable = pf1550_set_suspend_disable,
+ .is_enabled = regulator_is_enabled_regmap,
+ .list_voltage = regulator_list_voltage_linear,
+};
+
+#define PF_VREF(_chip, match, _name, voltage) { \
+ .desc = { \
+ .name = #_name, \
+ .of_match = of_match_ptr(match), \
+ .regulators_node = of_match_ptr("regulators"), \
+ .n_voltages = 1, \
+ .ops = &pf1550_fixed_ops, \
+ .type = REGULATOR_VOLTAGE, \
+ .id = _chip ## _ ## _name, \
+ .owner = THIS_MODULE, \
+ .min_uV = (voltage), \
+ .enable_reg = _chip ## _PMIC_REG_ ## _name ## _CTRL, \
+ .enable_mask = 0x1, \
+ }, \
+ .stby_enable_reg = _chip ## _PMIC_REG_ ## _name ## _CTRL, \
+ .stby_enable_mask = 0x2, \
+}
+
+#define PF_SW(_chip, match, _name, min, max, mask, step) { \
+ .desc = { \
+ .name = #_name, \
+ .of_match = of_match_ptr(match), \
+ .regulators_node = of_match_ptr("regulators"), \
+ .n_voltages = ((max) - (min)) / (step) + 1, \
+ .ops = &pf1550_sw2_ops, \
+ .type = REGULATOR_VOLTAGE, \
+ .id = _chip ## _ ## _name, \
+ .owner = THIS_MODULE, \
+ .min_uV = (min), \
+ .uV_step = (step), \
+ .linear_min_sel = 0, \
+ .vsel_reg = _chip ## _PMIC_REG_ ## _name ## _VOLT, \
+ .vsel_mask = (mask), \
+ .enable_reg = _chip ## _PMIC_REG_ ## _name ## _CTRL, \
+ .enable_mask = 0x1, \
+ }, \
+ .stby_reg = _chip ## _PMIC_REG_ ## _name ## _STBY_VOLT, \
+ .stby_mask = (mask), \
+ .stby_enable_reg = _chip ## _PMIC_REG_ ## _name ## _CTRL, \
+ .stby_enable_mask = 0x2, \
+}
+
+#define PF_LDO1(_chip, match, _name, mask, voltages) { \
+ .desc = { \
+ .name = #_name, \
+ .of_match = of_match_ptr(match), \
+ .regulators_node = of_match_ptr("regulators"), \
+ .n_voltages = ARRAY_SIZE(voltages), \
+ .ops = &pf1550_ldo1_ops, \
+ .type = REGULATOR_VOLTAGE, \
+ .id = _chip ## _ ## _name, \
+ .owner = THIS_MODULE, \
+ .volt_table = voltages, \
+ .vsel_reg = _chip ## _PMIC_REG_ ## _name ## _VOLT, \
+ .vsel_mask = (mask), \
+ .enable_reg = _chip ## _PMIC_REG_ ## _name ## _CTRL, \
+ .enable_mask = 0x1, \
+ }, \
+ .stby_enable_reg = _chip ## _PMIC_REG_ ## _name ## _CTRL, \
+ .stby_enable_mask = 0x2, \
+}
+
+#define PF_LDO2(_chip, match, _name, mask, min, max, step) { \
+ .desc = { \
+ .name = #_name, \
+ .of_match = of_match_ptr(match), \
+ .regulators_node = of_match_ptr("regulators"), \
+ .n_voltages = ((max) - (min)) / (step) + 1, \
+ .ops = &pf1550_ldo2_ops, \
+ .type = REGULATOR_VOLTAGE, \
+ .id = _chip ## _ ## _name, \
+ .owner = THIS_MODULE, \
+ .min_uV = (min), \
+ .uV_step = (step), \
+ .linear_min_sel = 0, \
+ .vsel_reg = _chip ## _PMIC_REG_ ## _name ## _VOLT, \
+ .vsel_mask = (mask), \
+ .enable_reg = _chip ## _PMIC_REG_ ## _name ## _CTRL, \
+ .enable_mask = 0x1, \
+ }, \
+ .stby_enable_reg = _chip ## _PMIC_REG_ ## _name ## _CTRL, \
+ .stby_enable_mask = 0x2, \
+}
+
+static struct pf1550_desc pf1550_regulators[] = {
+ PF_SW(PF1550, "sw1", SW1, 600000, 1387500, 0x3f, 12500),
+ PF_SW(PF1550, "sw2", SW2, 600000, 1387500, 0x3f, 12500),
+ PF_SW(PF1550, "sw3", SW3, 1800000, 3300000, 0xf, 100000),
+ PF_VREF(PF1550, "vrefddr", VREFDDR, 1200000),
+ PF_LDO1(PF1550, "ldo1", LDO1, 0x1f, pf1550_ldo13_volts),
+ PF_LDO2(PF1550, "ldo2", LDO2, 0xf, 1800000, 3300000, 100000),
+ PF_LDO1(PF1550, "ldo3", LDO3, 0x1f, pf1550_ldo13_volts),
+};
+
+static irqreturn_t pf1550_regulator_irq_handler(int irq, void *data)
+{
+ struct pf1550_regulator_info *info = data;
+ struct device *dev = info->dev;
+ struct platform_device *pdev = to_platform_device(dev);
+ int i, irq_type = -1;
+ unsigned int event;
+
+ for (i = 0; i < PF1550_REGULATOR_IRQ_NR; i++)
+ if (irq == platform_get_irq(pdev, i))
+ irq_type = i;
+
+ switch (irq_type) {
+ /* The _LS interrupts indicate over-current event. The _HS interrupts
+ * which are more accurate and can detect catastrophic faults, issue
+ * an error event. The current limit FAULT interrupt is similar to the
+ * _HS'
+ */
+ case PF1550_PMIC_IRQ_SW1_LS:
+ case PF1550_PMIC_IRQ_SW2_LS:
+ case PF1550_PMIC_IRQ_SW3_LS:
+ event = REGULATOR_EVENT_OVER_CURRENT_WARN;
+ for (i = 0; i < PF1550_MAX_REGULATOR; i++)
+ if (!strcmp(rdev_get_name(info->rdevs[i]), "SW3"))
+ regulator_notifier_call_chain(info->rdevs[i],
+ event, NULL);
+ break;
+ case PF1550_PMIC_IRQ_SW1_HS:
+ case PF1550_PMIC_IRQ_SW2_HS:
+ case PF1550_PMIC_IRQ_SW3_HS:
+ event = REGULATOR_EVENT_OVER_CURRENT;
+ for (i = 0; i < PF1550_MAX_REGULATOR; i++)
+ if (!strcmp(rdev_get_name(info->rdevs[i]), "SW3"))
+ regulator_notifier_call_chain(info->rdevs[i],
+ event, NULL);
+ break;
+ case PF1550_PMIC_IRQ_LDO1_FAULT:
+ case PF1550_PMIC_IRQ_LDO2_FAULT:
+ case PF1550_PMIC_IRQ_LDO3_FAULT:
+ event = REGULATOR_EVENT_OVER_CURRENT;
+ for (i = 0; i < PF1550_MAX_REGULATOR; i++)
+ if (!strcmp(rdev_get_name(info->rdevs[i]), "LDO3"))
+ regulator_notifier_call_chain(info->rdevs[i],
+ event, NULL);
+ break;
+ case PF1550_PMIC_IRQ_TEMP_110:
+ case PF1550_PMIC_IRQ_TEMP_125:
+ event = REGULATOR_EVENT_OVER_TEMP;
+ for (i = 0; i < PF1550_MAX_REGULATOR; i++)
+ regulator_notifier_call_chain(info->rdevs[i],
+ event, NULL);
+ break;
+ default:
+ dev_err(dev, "regulator interrupt: irq %d occurred\n",
+ irq_type);
+ }
+
+ return IRQ_HANDLED;
+}
+
+static int pf1550_regulator_probe(struct platform_device *pdev)
+{
+ const struct pf1550_ddata *pf1550 = dev_get_drvdata(pdev->dev.parent);
+ struct regulator_config config = { };
+ struct pf1550_regulator_info *info;
+ int i, irq = -1, ret = 0;
+
+ info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
+ if (!info)
+ return -ENOMEM;
+
+ config.regmap = dev_get_regmap(pf1550->dev, NULL);
+ if (!config.regmap)
+ return dev_err_probe(&pdev->dev, -ENODEV,
+ "failed to get parent regmap\n");
+
+ config.dev = pf1550->dev;
+ config.regmap = pf1550->regmap;
+ info->dev = &pdev->dev;
+ info->pf1550 = pf1550;
+
+ memcpy(info->regulator_descs, pf1550_regulators,
+ sizeof(info->regulator_descs));
+
+ for (i = 0; i < ARRAY_SIZE(pf1550_regulators); i++) {
+ struct regulator_desc *desc;
+
+ desc = &info->regulator_descs[i].desc;
+
+ if ((desc->id == PF1550_SW2 && !pf1550->dvs2_enable) ||
+ (desc->id == PF1550_SW1 && !pf1550->dvs1_enable)) {
+ /* OTP_SW2_DVS_ENB == 1? or OTP_SW1_DVS_ENB == 1? */
+ desc->volt_table = pf1550_sw12_volts;
+ desc->n_voltages = ARRAY_SIZE(pf1550_sw12_volts);
+ desc->ops = &pf1550_sw1_ops;
+ }
+
+ info->rdevs[i] = devm_regulator_register(&pdev->dev, desc,
+ &config);
+ if (IS_ERR(info->rdevs[i]))
+ return dev_err_probe(&pdev->dev,
+ PTR_ERR(info->rdevs[i]),
+ "failed to initialize regulator-%d\n",
+ i);
+ }
+
+ platform_set_drvdata(pdev, info);
+
+ for (i = 0; i < PF1550_REGULATOR_IRQ_NR; i++) {
+ irq = platform_get_irq(pdev, i);
+ if (irq < 0)
+ return irq;
+
+ ret = devm_request_threaded_irq(&pdev->dev, irq, NULL,
+ pf1550_regulator_irq_handler,
+ IRQF_NO_SUSPEND,
+ "pf1550-regulator", info);
+ if (ret)
+ return dev_err_probe(&pdev->dev, ret,
+ "failed: irq request (IRQ: %d)\n",
+ i);
+ }
+
+ return 0;
+}
+
+static const struct platform_device_id pf1550_regulator_id[] = {
+ { "pf1550-regulator", },
+ { /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(platform, pf1550_regulator_id);
+
+static struct platform_driver pf1550_regulator_driver = {
+ .driver = {
+ .name = "pf1550-regulator",
+ },
+ .probe = pf1550_regulator_probe,
+ .id_table = pf1550_regulator_id,
+};
+module_platform_driver(pf1550_regulator_driver);
+
+MODULE_DESCRIPTION("NXP PF1550 regulator driver");
+MODULE_AUTHOR("Robin Gong <yibin.gong@freescale.com>");
+MODULE_LICENSE("GPL");
--
2.50.1
^ permalink raw reply related
* [PATCH v11 5/6] power: supply: pf1550: add battery charger support
From: Samuel Kayode via B4 Relay @ 2025-09-17 15:52 UTC (permalink / raw)
To: Lee Jones, Rob Herring, Krzysztof Kozlowski, Conor Dooley,
Liam Girdwood, Mark Brown, Dmitry Torokhov, Sebastian Reichel,
Frank Li
Cc: imx, devicetree, linux-kernel, linux-input, linux-pm, Abel Vesa,
Abel Vesa, Robin Gong, Robin Gong, Enric Balletbo i Serra,
Sean Nyekjaer, Christophe JAILLET, Samuel Kayode, Abel Vesa,
Frank Li
In-Reply-To: <20250917-pf1550-v11-0-e0649822fcc9@savoirfairelinux.com>
From: Samuel Kayode <samuel.kayode@savoirfairelinux.com>
Add support for the battery charger for pf1550 PMIC.
Reviewed-by: Frank Li <Frank.Li@nxp.com>
Tested-by: Sean Nyekjaer <sean@geanix.com>
Signed-off-by: Samuel Kayode <samuel.kayode@savoirfairelinux.com>
---
v11:
- Seperate the battery properties from the charger properties
v9:
- Fix thermal regulation temperature ranges
- Fix default thermal regulation temperature
- Drop unused `data` variable in reg_init
- Select charger operation mode based on application - suggested by Sean
v8:
- Drop PF1550_CHARGER_NAME
- Drop unnecessary POWER_SUPPLY_STATUS_CHARGING s
- Replace POWER_SUPPLY_HEALTH_DEAD with POWER_SUPPLY_HEALTH_NO_BATTERY
- Drop check for charger in delayed_work s
- Use dev_warn when battery is over-voltage
- Define two power supplies: charger and battery
- Use devm_delayed_work_autocancel to automate cleanup and fix race
condition
v7:
- Use reverse christmas tree order
- Drop unecessary 0 in id table's driver data field
- Store virqs to avoid reinvoking platform_get_irq in the interrupt
service routine
- Drop manufacturer and model global variables
v6:
- Drop lock entirely
- Reverse christmas tree order for variables defined in probe as
suggested by Frank
- return pf1550_reg_init
v5:
- Drop lock for battery and charger delayed_work
- More conservative locking in vbus delayed_work
- Apply lock when setting power supply type during register initialization
v4:
- Finish handling of some interrupts in threaded irq handler
- Use platform_get_irq
v3:
- Use struct power_supply_get_battery_info to get constant charge
voltage if specified
- Use virqs mapped in MFD driver
v2:
- Address feedback from Enric Balletbo Serra
---
drivers/power/supply/Kconfig | 11 +
drivers/power/supply/Makefile | 1 +
drivers/power/supply/pf1550-charger.c | 641 ++++++++++++++++++++++++++++++++++
3 files changed, 653 insertions(+)
diff --git a/drivers/power/supply/Kconfig b/drivers/power/supply/Kconfig
index 79ddb006e2dad6bf96b71ed570a37c006b5f9433..6d0c872edac1f45da314632e671af1aeda4c87b8 100644
--- a/drivers/power/supply/Kconfig
+++ b/drivers/power/supply/Kconfig
@@ -471,6 +471,17 @@ config CHARGER_88PM860X
help
Say Y here to enable charger for Marvell 88PM860x chip.
+config CHARGER_PF1550
+ tristate "NXP PF1550 battery charger driver"
+ depends on MFD_PF1550
+ help
+ Say Y to enable support for the NXP PF1550 battery charger.
+ The device is a single cell Li-Ion/Li-Polymer battery charger for
+ portable application.
+
+ This driver can also be built as a module. If so, the module will be
+ called pf1550-charger.
+
config BATTERY_RX51
tristate "Nokia RX-51 (N900) battery driver"
depends on TWL4030_MADC
diff --git a/drivers/power/supply/Makefile b/drivers/power/supply/Makefile
index 4f5f8e3507f80da02812f0d08c2d81ddff0a272f..7f68380099c59dab71b73120150612a23e16a745 100644
--- a/drivers/power/supply/Makefile
+++ b/drivers/power/supply/Makefile
@@ -64,6 +64,7 @@ obj-$(CONFIG_CHARGER_RT9467) += rt9467-charger.o
obj-$(CONFIG_CHARGER_RT9471) += rt9471.o
obj-$(CONFIG_BATTERY_TWL4030_MADC) += twl4030_madc_battery.o
obj-$(CONFIG_CHARGER_88PM860X) += 88pm860x_charger.o
+obj-$(CONFIG_CHARGER_PF1550) += pf1550-charger.o
obj-$(CONFIG_BATTERY_RX51) += rx51_battery.o
obj-$(CONFIG_AB8500_BM) += ab8500_bmdata.o ab8500_charger.o ab8500_fg.o ab8500_btemp.o ab8500_chargalg.o
obj-$(CONFIG_CHARGER_CPCAP) += cpcap-charger.o
diff --git a/drivers/power/supply/pf1550-charger.c b/drivers/power/supply/pf1550-charger.c
new file mode 100644
index 0000000000000000000000000000000000000000..98f1ee8eca3bc8dff2c3a697d157b9e3da204fe2
--- /dev/null
+++ b/drivers/power/supply/pf1550-charger.c
@@ -0,0 +1,641 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * charger driver for the PF1550
+ *
+ * Copyright (C) 2016 Freescale Semiconductor, Inc.
+ * Robin Gong <yibin.gong@freescale.com>
+ *
+ * Portions Copyright (c) 2025 Savoir-faire Linux Inc.
+ * Samuel Kayode <samuel.kayode@savoirfairelinux.com>
+ */
+
+#include <linux/devm-helpers.h>
+#include <linux/interrupt.h>
+#include <linux/mfd/pf1550.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/power_supply.h>
+
+#define PF1550_DEFAULT_CONSTANT_VOLT 4200000
+#define PF1550_DEFAULT_MIN_SYSTEM_VOLT 3500000
+#define PF1550_DEFAULT_THERMAL_TEMP 95
+#define PF1550_CHARGER_IRQ_NR 5
+
+struct pf1550_charger {
+ struct device *dev;
+ const struct pf1550_ddata *pf1550;
+ struct power_supply *charger;
+ struct power_supply *battery;
+ struct delayed_work vbus_sense_work;
+ struct delayed_work chg_sense_work;
+ struct delayed_work bat_sense_work;
+ int virqs[PF1550_CHARGER_IRQ_NR];
+
+ u32 constant_volt;
+ u32 min_system_volt;
+ u32 thermal_regulation_temp;
+};
+
+static int pf1550_get_charger_state(struct regmap *regmap, int *val)
+{
+ unsigned int data;
+ int ret;
+
+ ret = regmap_read(regmap, PF1550_CHARG_REG_CHG_SNS, &data);
+ if (ret < 0)
+ return ret;
+
+ data &= PF1550_CHG_SNS_MASK;
+
+ switch (data) {
+ case PF1550_CHG_PRECHARGE:
+ case PF1550_CHG_CONSTANT_CURRENT:
+ case PF1550_CHG_CONSTANT_VOL:
+ case PF1550_CHG_EOC:
+ *val = POWER_SUPPLY_STATUS_CHARGING;
+ break;
+ case PF1550_CHG_DONE:
+ *val = POWER_SUPPLY_STATUS_FULL;
+ break;
+ case PF1550_CHG_TIMER_FAULT:
+ case PF1550_CHG_SUSPEND:
+ *val = POWER_SUPPLY_STATUS_NOT_CHARGING;
+ break;
+ case PF1550_CHG_OFF_INV:
+ case PF1550_CHG_OFF_TEMP:
+ case PF1550_CHG_LINEAR_ONLY:
+ *val = POWER_SUPPLY_STATUS_DISCHARGING;
+ break;
+ default:
+ *val = POWER_SUPPLY_STATUS_UNKNOWN;
+ }
+
+ return 0;
+}
+
+static int pf1550_get_charge_type(struct regmap *regmap, int *val)
+{
+ unsigned int data;
+ int ret;
+
+ ret = regmap_read(regmap, PF1550_CHARG_REG_CHG_SNS, &data);
+ if (ret < 0)
+ return ret;
+
+ data &= PF1550_CHG_SNS_MASK;
+
+ switch (data) {
+ case PF1550_CHG_SNS_MASK:
+ *val = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
+ break;
+ case PF1550_CHG_CONSTANT_CURRENT:
+ case PF1550_CHG_CONSTANT_VOL:
+ case PF1550_CHG_EOC:
+ *val = POWER_SUPPLY_CHARGE_TYPE_FAST;
+ break;
+ case PF1550_CHG_DONE:
+ case PF1550_CHG_TIMER_FAULT:
+ case PF1550_CHG_SUSPEND:
+ case PF1550_CHG_OFF_INV:
+ case PF1550_CHG_BAT_OVER:
+ case PF1550_CHG_OFF_TEMP:
+ case PF1550_CHG_LINEAR_ONLY:
+ *val = POWER_SUPPLY_CHARGE_TYPE_NONE;
+ break;
+ default:
+ *val = POWER_SUPPLY_CHARGE_TYPE_UNKNOWN;
+ }
+
+ return 0;
+}
+
+/*
+ * Supported health statuses:
+ * - POWER_SUPPLY_HEALTH_DEAD
+ * - POWER_SUPPLY_HEALTH_GOOD
+ * - POWER_SUPPLY_HEALTH_OVERVOLTAGE
+ * - POWER_SUPPLY_HEALTH_UNKNOWN
+ */
+static int pf1550_get_battery_health(struct regmap *regmap, int *val)
+{
+ unsigned int data;
+ int ret;
+
+ ret = regmap_read(regmap, PF1550_CHARG_REG_BATT_SNS, &data);
+ if (ret < 0)
+ return ret;
+
+ data &= PF1550_BAT_SNS_MASK;
+
+ switch (data) {
+ case PF1550_BAT_NO_DETECT:
+ *val = POWER_SUPPLY_HEALTH_NO_BATTERY;
+ break;
+ case PF1550_BAT_NO_VBUS:
+ case PF1550_BAT_LOW_THAN_PRECHARG:
+ case PF1550_BAT_CHARG_FAIL:
+ case PF1550_BAT_HIGH_THAN_PRECHARG:
+ *val = POWER_SUPPLY_HEALTH_GOOD;
+ break;
+ case PF1550_BAT_OVER_VOL:
+ *val = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
+ break;
+ default:
+ *val = POWER_SUPPLY_HEALTH_UNKNOWN;
+ break;
+ }
+
+ return 0;
+}
+
+static int pf1550_get_present(struct regmap *regmap, int *val)
+{
+ unsigned int data;
+ int ret;
+
+ ret = regmap_read(regmap, PF1550_CHARG_REG_BATT_SNS, &data);
+ if (ret < 0)
+ return ret;
+
+ data &= PF1550_BAT_SNS_MASK;
+ *val = (data == PF1550_BAT_NO_DETECT) ? 0 : 1;
+
+ return 0;
+}
+
+static int pf1550_get_online(struct regmap *regmap, int *val)
+{
+ unsigned int data;
+ int ret;
+
+ ret = regmap_read(regmap, PF1550_CHARG_REG_VBUS_SNS, &data);
+ if (ret < 0)
+ return ret;
+
+ *val = (data & PF1550_VBUS_VALID) ? 1 : 0;
+
+ return 0;
+}
+
+static void pf1550_chg_bat_work(struct work_struct *work)
+{
+ struct pf1550_charger *chg = container_of(to_delayed_work(work),
+ struct pf1550_charger,
+ bat_sense_work);
+ unsigned int data;
+
+ if (regmap_read(chg->pf1550->regmap, PF1550_CHARG_REG_BATT_SNS, &data)) {
+ dev_err(chg->dev, "Read BATT_SNS error.\n");
+ return;
+ }
+
+ switch (data & PF1550_BAT_SNS_MASK) {
+ case PF1550_BAT_NO_VBUS:
+ dev_dbg(chg->dev, "No valid VBUS input.\n");
+ break;
+ case PF1550_BAT_LOW_THAN_PRECHARG:
+ dev_dbg(chg->dev, "VBAT < VPRECHG.LB.\n");
+ break;
+ case PF1550_BAT_CHARG_FAIL:
+ dev_dbg(chg->dev, "Battery charging failed.\n");
+ break;
+ case PF1550_BAT_HIGH_THAN_PRECHARG:
+ dev_dbg(chg->dev, "VBAT > VPRECHG.LB.\n");
+ break;
+ case PF1550_BAT_OVER_VOL:
+ dev_dbg(chg->dev, "VBAT > VBATOV.\n");
+ break;
+ case PF1550_BAT_NO_DETECT:
+ dev_dbg(chg->dev, "Battery not detected.\n");
+ break;
+ default:
+ dev_err(chg->dev, "Unknown value read:%x\n",
+ data & PF1550_CHG_SNS_MASK);
+ }
+}
+
+static void pf1550_chg_chg_work(struct work_struct *work)
+{
+ struct pf1550_charger *chg = container_of(to_delayed_work(work),
+ struct pf1550_charger,
+ chg_sense_work);
+ unsigned int data;
+
+ if (regmap_read(chg->pf1550->regmap, PF1550_CHARG_REG_CHG_SNS, &data)) {
+ dev_err(chg->dev, "Read CHG_SNS error.\n");
+ return;
+ }
+
+ switch (data & PF1550_CHG_SNS_MASK) {
+ case PF1550_CHG_PRECHARGE:
+ dev_dbg(chg->dev, "In pre-charger mode.\n");
+ break;
+ case PF1550_CHG_CONSTANT_CURRENT:
+ dev_dbg(chg->dev, "In fast-charge constant current mode.\n");
+ break;
+ case PF1550_CHG_CONSTANT_VOL:
+ dev_dbg(chg->dev, "In fast-charge constant voltage mode.\n");
+ break;
+ case PF1550_CHG_EOC:
+ dev_dbg(chg->dev, "In EOC mode.\n");
+ break;
+ case PF1550_CHG_DONE:
+ dev_dbg(chg->dev, "In DONE mode.\n");
+ break;
+ case PF1550_CHG_TIMER_FAULT:
+ dev_info(chg->dev, "In timer fault mode.\n");
+ break;
+ case PF1550_CHG_SUSPEND:
+ dev_info(chg->dev, "In thermistor suspend mode.\n");
+ break;
+ case PF1550_CHG_OFF_INV:
+ dev_info(chg->dev, "Input invalid, charger off.\n");
+ break;
+ case PF1550_CHG_BAT_OVER:
+ dev_warn(chg->dev, "Battery over-voltage.\n");
+ break;
+ case PF1550_CHG_OFF_TEMP:
+ dev_info(chg->dev, "Temp high, charger off.\n");
+ break;
+ case PF1550_CHG_LINEAR_ONLY:
+ dev_dbg(chg->dev, "In Linear mode, not charging.\n");
+ break;
+ default:
+ dev_err(chg->dev, "Unknown value read:%x\n",
+ data & PF1550_CHG_SNS_MASK);
+ }
+}
+
+static void pf1550_chg_vbus_work(struct work_struct *work)
+{
+ struct pf1550_charger *chg = container_of(to_delayed_work(work),
+ struct pf1550_charger,
+ vbus_sense_work);
+ unsigned int data;
+
+ if (regmap_read(chg->pf1550->regmap, PF1550_CHARG_REG_VBUS_SNS, &data)) {
+ dev_err(chg->dev, "Read VBUS_SNS error.\n");
+ return;
+ }
+
+ if (data & PF1550_VBUS_UVLO) {
+ dev_dbg(chg->dev, "VBUS detached.\n");
+ power_supply_changed(chg->battery);
+ }
+ if (data & PF1550_VBUS_IN2SYS)
+ dev_dbg(chg->dev, "VBUS_IN2SYS_SNS.\n");
+ if (data & PF1550_VBUS_OVLO)
+ dev_dbg(chg->dev, "VBUS_OVLO_SNS.\n");
+ if (data & PF1550_VBUS_VALID) {
+ dev_dbg(chg->dev, "VBUS attached.\n");
+ power_supply_changed(chg->charger);
+ }
+}
+
+static irqreturn_t pf1550_charger_irq_handler(int irq, void *data)
+{
+ struct pf1550_charger *chg = data;
+ struct device *dev = chg->dev;
+ int i, irq_type = -1;
+
+ for (i = 0; i < PF1550_CHARGER_IRQ_NR; i++)
+ if (irq == chg->virqs[i])
+ irq_type = i;
+
+ switch (irq_type) {
+ case PF1550_CHARG_IRQ_BAT2SOCI:
+ dev_info(dev, "BAT to SYS Overcurrent interrupt.\n");
+ break;
+ case PF1550_CHARG_IRQ_BATI:
+ schedule_delayed_work(&chg->bat_sense_work,
+ msecs_to_jiffies(10));
+ break;
+ case PF1550_CHARG_IRQ_CHGI:
+ schedule_delayed_work(&chg->chg_sense_work,
+ msecs_to_jiffies(10));
+ break;
+ case PF1550_CHARG_IRQ_VBUSI:
+ schedule_delayed_work(&chg->vbus_sense_work,
+ msecs_to_jiffies(10));
+ break;
+ case PF1550_CHARG_IRQ_THMI:
+ dev_info(dev, "Thermal interrupt.\n");
+ break;
+ default:
+ dev_err(dev, "unknown interrupt occurred.\n");
+ }
+
+ return IRQ_HANDLED;
+}
+
+static enum power_supply_property pf1550_charger_props[] = {
+ POWER_SUPPLY_PROP_ONLINE,
+ POWER_SUPPLY_PROP_MODEL_NAME,
+ POWER_SUPPLY_PROP_MANUFACTURER,
+};
+
+static enum power_supply_property pf1550_battery_props[] = {
+ POWER_SUPPLY_PROP_STATUS,
+ POWER_SUPPLY_PROP_CHARGE_TYPE,
+ POWER_SUPPLY_PROP_HEALTH,
+ POWER_SUPPLY_PROP_PRESENT,
+ POWER_SUPPLY_PROP_MODEL_NAME,
+ POWER_SUPPLY_PROP_MANUFACTURER,
+};
+
+static int pf1550_charger_get_property(struct power_supply *psy,
+ enum power_supply_property psp,
+ union power_supply_propval *val)
+{
+ struct pf1550_charger *chg = power_supply_get_drvdata(psy);
+ struct regmap *regmap = chg->pf1550->regmap;
+ int ret = 0;
+
+ switch (psp) {
+ case POWER_SUPPLY_PROP_STATUS:
+ ret = pf1550_get_charger_state(regmap, &val->intval);
+ break;
+ case POWER_SUPPLY_PROP_CHARGE_TYPE:
+ ret = pf1550_get_charge_type(regmap, &val->intval);
+ break;
+ case POWER_SUPPLY_PROP_HEALTH:
+ ret = pf1550_get_battery_health(regmap, &val->intval);
+ break;
+ case POWER_SUPPLY_PROP_PRESENT:
+ ret = pf1550_get_present(regmap, &val->intval);
+ break;
+ case POWER_SUPPLY_PROP_ONLINE:
+ ret = pf1550_get_online(regmap, &val->intval);
+ break;
+ case POWER_SUPPLY_PROP_MODEL_NAME:
+ val->strval = "PF1550";
+ break;
+ case POWER_SUPPLY_PROP_MANUFACTURER:
+ val->strval = "NXP";
+ break;
+ default:
+ return -EINVAL;
+ }
+
+ return ret;
+}
+
+static const struct power_supply_desc pf1550_charger_desc = {
+ .name = "pf1550-charger",
+ .type = POWER_SUPPLY_TYPE_MAINS,
+ .properties = pf1550_charger_props,
+ .num_properties = ARRAY_SIZE(pf1550_charger_props),
+ .get_property = pf1550_charger_get_property,
+};
+
+static const struct power_supply_desc pf1550_battery_desc = {
+ .name = "pf1550-battery",
+ .type = POWER_SUPPLY_TYPE_BATTERY,
+ .properties = pf1550_battery_props,
+ .num_properties = ARRAY_SIZE(pf1550_battery_props),
+ .get_property = pf1550_charger_get_property,
+};
+
+static int pf1550_set_constant_volt(struct pf1550_charger *chg,
+ unsigned int uvolt)
+{
+ unsigned int data;
+
+ if (uvolt >= 3500000 && uvolt <= 4440000)
+ data = 8 + (uvolt - 3500000) / 20000;
+ else
+ return dev_err_probe(chg->dev, -EINVAL,
+ "Wrong value for constant voltage\n");
+
+ dev_dbg(chg->dev, "Charging constant voltage: %u (0x%x)\n", uvolt,
+ data);
+
+ return regmap_update_bits(chg->pf1550->regmap,
+ PF1550_CHARG_REG_BATT_REG,
+ PF1550_CHARG_REG_BATT_REG_CHGCV_MASK, data);
+}
+
+static int pf1550_set_min_system_volt(struct pf1550_charger *chg,
+ unsigned int uvolt)
+{
+ unsigned int data;
+
+ switch (uvolt) {
+ case 3500000:
+ data = 0x0;
+ break;
+ case 3700000:
+ data = 0x1;
+ break;
+ case 4300000:
+ data = 0x2;
+ break;
+ default:
+ return dev_err_probe(chg->dev, -EINVAL,
+ "Wrong value for minimum system voltage\n");
+ }
+
+ data <<= PF1550_CHARG_REG_BATT_REG_VMINSYS_SHIFT;
+
+ dev_dbg(chg->dev, "Minimum system regulation voltage: %u (0x%x)\n",
+ uvolt, data);
+
+ return regmap_update_bits(chg->pf1550->regmap,
+ PF1550_CHARG_REG_BATT_REG,
+ PF1550_CHARG_REG_BATT_REG_VMINSYS_MASK, data);
+}
+
+static int pf1550_set_thermal_regulation_temp(struct pf1550_charger *chg,
+ unsigned int cells)
+{
+ unsigned int data;
+
+ switch (cells) {
+ case 80:
+ data = 0x0;
+ break;
+ case 95:
+ data = 0x1;
+ break;
+ case 110:
+ data = 0x2;
+ break;
+ case 125:
+ data = 0x3;
+ break;
+ default:
+ return dev_err_probe(chg->dev, -EINVAL,
+ "Wrong value for thermal temperature\n");
+ }
+
+ data <<= PF1550_CHARG_REG_THM_REG_CNFG_REGTEMP_SHIFT;
+
+ dev_dbg(chg->dev, "Thermal regulation loop temperature: %u (0x%x)\n",
+ cells, data);
+
+ return regmap_update_bits(chg->pf1550->regmap,
+ PF1550_CHARG_REG_THM_REG_CNFG,
+ PF1550_CHARG_REG_THM_REG_CNFG_REGTEMP_MASK,
+ data);
+}
+
+/*
+ * Sets charger registers to proper and safe default values.
+ */
+static int pf1550_reg_init(struct pf1550_charger *chg)
+{
+ struct power_supply_battery_info *info;
+ struct device *dev = chg->dev;
+ int ret;
+
+ /* Unmask charger interrupt, mask DPMI and reserved bit */
+ ret = regmap_write(chg->pf1550->regmap, PF1550_CHARG_REG_CHG_INT_MASK,
+ PF1550_CHG_INT_MASK);
+ if (ret)
+ return dev_err_probe(dev, ret,
+ "Error unmask charger interrupt\n");
+
+ ret = pf1550_set_constant_volt(chg, chg->constant_volt);
+ if (ret)
+ return ret;
+
+ ret = pf1550_set_min_system_volt(chg, chg->min_system_volt);
+ if (ret)
+ return ret;
+
+ ret = pf1550_set_thermal_regulation_temp(chg,
+ chg->thermal_regulation_temp);
+ if (ret)
+ return ret;
+
+ /*
+ * The PF1550 charger has 3 modes of operation. By default, the charger
+ * is in mode 1; it remains off. Appropriate for applications not using
+ * a battery. The other supported mode is mode 2, the charger is turned
+ * on to charge a battery when present.
+ */
+ if (power_supply_get_battery_info(chg->charger, &info)) {
+ ret = regmap_write(chg->pf1550->regmap,
+ PF1550_CHARG_REG_CHG_OPER,
+ PF1550_CHG_BAT_ON);
+ if (ret)
+ return dev_err_probe(dev, ret,
+ "Error turn on charger\n");
+ }
+
+ return 0;
+}
+
+static void pf1550_dt_parse_dev_info(struct pf1550_charger *chg)
+{
+ struct power_supply_battery_info *info;
+ struct device *dev = chg->dev;
+
+ if (device_property_read_u32(dev->parent, "nxp,min-system-microvolt",
+ &chg->min_system_volt))
+ chg->min_system_volt = PF1550_DEFAULT_MIN_SYSTEM_VOLT;
+
+ if (device_property_read_u32(dev->parent,
+ "nxp,thermal-regulation-celsius",
+ &chg->thermal_regulation_temp))
+ chg->thermal_regulation_temp = PF1550_DEFAULT_THERMAL_TEMP;
+
+ if (power_supply_get_battery_info(chg->charger, &info))
+ chg->constant_volt = PF1550_DEFAULT_CONSTANT_VOLT;
+ else
+ chg->constant_volt = info->constant_charge_voltage_max_uv;
+}
+
+static int pf1550_charger_probe(struct platform_device *pdev)
+{
+ const struct pf1550_ddata *pf1550 = dev_get_drvdata(pdev->dev.parent);
+ struct power_supply_config psy_cfg = {};
+ struct pf1550_charger *chg;
+ int i, irq, ret;
+
+ chg = devm_kzalloc(&pdev->dev, sizeof(*chg), GFP_KERNEL);
+ if (!chg)
+ return -ENOMEM;
+
+ chg->dev = &pdev->dev;
+ chg->pf1550 = pf1550;
+
+ if (!chg->pf1550->regmap)
+ return dev_err_probe(&pdev->dev, -ENODEV,
+ "failed to get regmap\n");
+
+ platform_set_drvdata(pdev, chg);
+
+ ret = devm_delayed_work_autocancel(chg->dev, &chg->vbus_sense_work,
+ pf1550_chg_vbus_work);
+ if (ret)
+ return dev_err_probe(chg->dev, ret,
+ "failed to add vbus sense work\n");
+
+ ret = devm_delayed_work_autocancel(chg->dev, &chg->chg_sense_work,
+ pf1550_chg_chg_work);
+ if (ret)
+ return dev_err_probe(chg->dev, ret,
+ "failed to add charger sense work\n");
+
+ ret = devm_delayed_work_autocancel(chg->dev, &chg->bat_sense_work,
+ pf1550_chg_bat_work);
+ if (ret)
+ return dev_err_probe(chg->dev, ret,
+ "failed to add battery sense work\n");
+
+ for (i = 0; i < PF1550_CHARGER_IRQ_NR; i++) {
+ irq = platform_get_irq(pdev, i);
+ if (irq < 0)
+ return irq;
+
+ chg->virqs[i] = irq;
+
+ ret = devm_request_threaded_irq(&pdev->dev, irq, NULL,
+ pf1550_charger_irq_handler,
+ IRQF_NO_SUSPEND,
+ "pf1550-charger", chg);
+ if (ret)
+ return dev_err_probe(&pdev->dev, ret,
+ "failed irq request\n");
+ }
+
+ psy_cfg.drv_data = chg;
+
+ chg->charger = devm_power_supply_register(&pdev->dev,
+ &pf1550_charger_desc,
+ &psy_cfg);
+ if (IS_ERR(chg->charger))
+ return dev_err_probe(&pdev->dev, PTR_ERR(chg->charger),
+ "failed: power supply register\n");
+
+ chg->battery = devm_power_supply_register(&pdev->dev,
+ &pf1550_battery_desc,
+ &psy_cfg);
+ if (IS_ERR(chg->battery))
+ return dev_err_probe(&pdev->dev, PTR_ERR(chg->battery),
+ "failed: power supply register\n");
+
+ pf1550_dt_parse_dev_info(chg);
+
+ return pf1550_reg_init(chg);
+}
+
+static const struct platform_device_id pf1550_charger_id[] = {
+ { "pf1550-charger", },
+ { /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(platform, pf1550_charger_id);
+
+static struct platform_driver pf1550_charger_driver = {
+ .driver = {
+ .name = "pf1550-charger",
+ },
+ .probe = pf1550_charger_probe,
+ .id_table = pf1550_charger_id,
+};
+module_platform_driver(pf1550_charger_driver);
+
+MODULE_AUTHOR("Robin Gong <yibin.gong@freescale.com>");
+MODULE_DESCRIPTION("PF1550 charger driver");
+MODULE_LICENSE("GPL");
--
2.50.1
^ permalink raw reply related
* [PATCH v11 6/6] MAINTAINERS: add an entry for pf1550 mfd driver
From: Samuel Kayode via B4 Relay @ 2025-09-17 15:52 UTC (permalink / raw)
To: Lee Jones, Rob Herring, Krzysztof Kozlowski, Conor Dooley,
Liam Girdwood, Mark Brown, Dmitry Torokhov, Sebastian Reichel,
Frank Li
Cc: imx, devicetree, linux-kernel, linux-input, linux-pm, Abel Vesa,
Abel Vesa, Robin Gong, Robin Gong, Enric Balletbo i Serra,
Sean Nyekjaer, Christophe JAILLET, Samuel Kayode, Abel Vesa,
Frank Li, Krzysztof Kozlowski
In-Reply-To: <20250917-pf1550-v11-0-e0649822fcc9@savoirfairelinux.com>
From: Samuel Kayode <samuel.kayode@savoirfairelinux.com>
Add MAINTAINERS entry for pf1550 PMIC.
Reviewed-by: Frank Li <Frank.Li@nxp.com>
Reviewed-by: Krzysztof Kozlowski <krzysztof.kozlowski@linaro.org>
Tested-by: Sean Nyekjaer <sean@geanix.com>
Signed-off-by: Samuel Kayode <samuel.kayode@savoirfairelinux.com>
---
v9:
- Pick up Frank's `Reviewed-by` tag
v6:
- Add imx mailing list
---
MAINTAINERS | 11 +++++++++++
1 file changed, 11 insertions(+)
diff --git a/MAINTAINERS b/MAINTAINERS
index 60bba48f5479a025f9da3eaf9dbacb67a194df07..ffc834aace4272e663f9717bcffd67100eb546c7 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -17996,6 +17996,17 @@ F: Documentation/devicetree/bindings/clock/imx*
F: drivers/clk/imx/
F: include/dt-bindings/clock/imx*
+NXP PF1550 PMIC MFD DRIVER
+M: Samuel Kayode <samuel.kayode@savoirfairelinux.com>
+L: imx@lists.linux.dev
+S: Maintained
+F: Documentation/devicetree/bindings/mfd/nxp,pf1550.yaml
+F: drivers/input/misc/pf1550-onkey.c
+F: drivers/mfd/pf1550.c
+F: drivers/power/supply/pf1550-charger.c
+F: drivers/regulator/pf1550-regulator.c
+F: include/linux/mfd/pfd1550.h
+
NXP PF8100/PF8121A/PF8200 PMIC REGULATOR DEVICE DRIVER
M: Jagan Teki <jagan@amarulasolutions.com>
S: Maintained
--
2.50.1
^ permalink raw reply related
* Re: [PATCH v4 4/6] dt-bindings: touchscreen: fsl,imx6ul-tsc: support glitch thresold
From: Frank Li @ 2025-09-17 16:07 UTC (permalink / raw)
To: Dario Binacchi
Cc: linux-kernel, linux-amarula, Conor Dooley, Dmitry Torokhov,
Fabio Estevam, Haibo Chen, Krzysztof Kozlowski,
Pengutronix Kernel Team, Rob Herring, Sascha Hauer, Shawn Guo,
devicetree, imx, linux-arm-kernel, linux-input
In-Reply-To: <20250917080534.1772202-5-dario.binacchi@amarulasolutions.com>
On Wed, Sep 17, 2025 at 10:05:09AM +0200, Dario Binacchi wrote:
> Support the touchscreen-glitch-threshold-ns property.
>
> Drivers must convert this value to IPG clock cycles and map it to one of
binding descript hardware, not drivers. So below sentence should be better.
"TSC only supports the four discrete thresholds, counted by IPG clock cycles.
See SC_DEBUG_MODE2 register."
> the four discrete thresholds exposed by the TSC_DEBUG_MODE2 register:
>
> 0: 8191 IPG cycles
> 1: 4095 IPG cycles
> 2: 2047 IPG cycles
> 3: 1023 IPG cycles
>
> Signed-off-by: Dario Binacchi <dario.binacchi@amarulasolutions.com>
>
> ---
>
> Changes in v4:
> - Adjust property description following the suggestions of
> Conor Dooley and Frank Li.
> - Update the commit description.
>
> Changes in v3:
> - Remove the final part of the description that refers to
> implementation details.
>
> .../bindings/input/touchscreen/fsl,imx6ul-tsc.yaml | 14 ++++++++++++++
> 1 file changed, 14 insertions(+)
>
> diff --git a/Documentation/devicetree/bindings/input/touchscreen/fsl,imx6ul-tsc.yaml b/Documentation/devicetree/bindings/input/touchscreen/fsl,imx6ul-tsc.yaml
> index 678756ad0f92..1975f741cf3d 100644
> --- a/Documentation/devicetree/bindings/input/touchscreen/fsl,imx6ul-tsc.yaml
> +++ b/Documentation/devicetree/bindings/input/touchscreen/fsl,imx6ul-tsc.yaml
> @@ -62,6 +62,20 @@ properties:
> description: Number of data samples which are averaged for each read.
> enum: [ 1, 4, 8, 16, 32 ]
>
> + touchscreen-glitch-threshold-ns:
> + description: |
> + Minimum duration in nanoseconds a signal must remain stable
> + to be considered valid.
> +
> + Drivers must convert this value to IPG clock cycles and map
> + it to one of the four discrete thresholds exposed by the
> + TSC_DEBUG_MODE2 register:
same as commit messsage, talk about hardware.
> +
> + 0: 8191 IPG cycles
> + 1: 4095 IPG cycles
> + 2: 2047 IPG cycles
> + 3: 1023 IPG cycles
> +
This case genenerally need enum 4 values, but it relates IPG frequency.
I have not idea how to restrict it base on clk frequency. May DT mainatainer
have idea.
Frank
> required:
> - compatible
> - reg
> --
> 2.43.0
>
^ permalink raw reply
* Re: [PATCH v4 6/6] Input: imx6ul_tsc - set glitch threshold by DTS property
From: Frank Li @ 2025-09-17 16:20 UTC (permalink / raw)
To: Dario Binacchi
Cc: linux-kernel, linux-amarula, Dmitry Torokhov, Fabio Estevam,
Michael Trimarchi, Pengutronix Kernel Team, Sascha Hauer,
Shawn Guo, imx, linux-arm-kernel, linux-input
In-Reply-To: <20250917080534.1772202-7-dario.binacchi@amarulasolutions.com>
On Wed, Sep 17, 2025 at 10:05:11AM +0200, Dario Binacchi wrote:
> Set the glitch threshold previously hardcoded in the driver. The change
> is backward compatible.
Set the glitch threshold by DTS property and keep the existing default
behavior if the 'touchscreen-glitch-threshold-ns' not present.
Reviewed-by: Frank Li <Frank.Li@nxp.com>
>
> Signed-off-by: Dario Binacchi <dario.binacchi@amarulasolutions.com>
>
> ---
>
> Changes in v4:
> - Adjust property description fsl,imx6ul-tsc.yaml following the
> suggestions of Conor Dooley and Frank Li.
>
> Changes in v3:
> - Remove the final part of the description that refers to
> implementation details in fsl,imx6ul-tsc.yaml.
>
> Changes in v2:
> - Replace patch ("dt-bindings: input: touchscreen: fsl,imx6ul-tsc: add
> fsl,glitch-threshold") with ("dt-bindings: touchscreen: add
> touchscreen-glitch-threshold-ns property"), making the previous property
> general by moving it to touchscreen.yaml.
> - Rework "Input: imx6ul_tsc - set glitch threshold by DTS property" patch
> to match changes made to the DTS property.
> - Move "Input: imx6ul_tsc - use BIT, FIELD_{GET,PREP} and GENMASK macros"
> patch right after the patch fixing the typo.
> - Rework to match changes made to the DTS property.
>
> drivers/input/touchscreen/imx6ul_tsc.c | 26 ++++++++++++++++++++++++--
> 1 file changed, 24 insertions(+), 2 deletions(-)
>
> diff --git a/drivers/input/touchscreen/imx6ul_tsc.c b/drivers/input/touchscreen/imx6ul_tsc.c
> index e2c59cc7c82c..0d753aa05fbf 100644
> --- a/drivers/input/touchscreen/imx6ul_tsc.c
> +++ b/drivers/input/touchscreen/imx6ul_tsc.c
> @@ -79,7 +79,7 @@
> #define MEASURE_SIG_EN BIT(0)
> #define VALID_SIG_EN BIT(8)
> #define DE_GLITCH_MASK GENMASK(30, 29)
> -#define DE_GLITCH_2 0x02
> +#define DE_GLITCH_DEF 0x02
> #define START_SENSE BIT(12)
> #define TSC_DISABLE BIT(16)
> #define DETECT_MODE 0x2
> @@ -98,6 +98,7 @@ struct imx6ul_tsc {
> u32 pre_charge_time;
> bool average_enable;
> u32 average_select;
> + u32 de_glitch;
>
> struct completion completion;
> };
> @@ -205,7 +206,7 @@ static void imx6ul_tsc_set(struct imx6ul_tsc *tsc)
> basic_setting |= AUTO_MEASURE;
> writel(basic_setting, tsc->tsc_regs + REG_TSC_BASIC_SETTING);
>
> - debug_mode2 = FIELD_PREP(DE_GLITCH_MASK, DE_GLITCH_2);
> + debug_mode2 = FIELD_PREP(DE_GLITCH_MASK, tsc->de_glitch);
> writel(debug_mode2, tsc->tsc_regs + REG_TSC_DEBUG_MODE2);
>
> writel(tsc->pre_charge_time, tsc->tsc_regs + REG_TSC_PRE_CHARGE_TIME);
> @@ -391,6 +392,7 @@ static int imx6ul_tsc_probe(struct platform_device *pdev)
> int tsc_irq;
> int adc_irq;
> u32 average_samples;
> + u32 de_glitch;
>
> tsc = devm_kzalloc(&pdev->dev, sizeof(*tsc), GFP_KERNEL);
> if (!tsc)
> @@ -513,6 +515,26 @@ static int imx6ul_tsc_probe(struct platform_device *pdev)
> return -EINVAL;
> }
>
> + err = of_property_read_u32(np, "touchscreen-glitch-threshold-ns",
> + &de_glitch);
> + if (err) {
> + tsc->de_glitch = DE_GLITCH_DEF;
> + } else {
> + u64 cycles;
> + unsigned long rate = clk_get_rate(tsc->tsc_clk);
> +
> + cycles = DIV64_U64_ROUND_UP((u64)de_glitch * rate, NSEC_PER_SEC);
> +
> + if (cycles <= 0x3ff)
> + tsc->de_glitch = 3;
> + else if (cycles <= 0x7ff)
> + tsc->de_glitch = 2;
> + else if (cycles <= 0xfff)
> + tsc->de_glitch = 1;
> + else
> + tsc->de_glitch = 0;
> + }
> +
> err = input_register_device(tsc->input);
> if (err) {
> dev_err(&pdev->dev,
> --
> 2.43.0
>
^ permalink raw reply
* Re: [PATCH v11 5/6] power: supply: pf1550: add battery charger support
From: Sebastian Reichel @ 2025-09-17 17:32 UTC (permalink / raw)
To: samuel.kayode
Cc: Lee Jones, Rob Herring, Krzysztof Kozlowski, Conor Dooley,
Liam Girdwood, Mark Brown, Dmitry Torokhov, Frank Li, imx,
devicetree, linux-kernel, linux-input, linux-pm, Abel Vesa,
Abel Vesa, Robin Gong, Robin Gong, Enric Balletbo i Serra,
Sean Nyekjaer, Christophe JAILLET
In-Reply-To: <20250917-pf1550-v11-5-e0649822fcc9@savoirfairelinux.com>
[-- Attachment #1: Type: text/plain, Size: 22881 bytes --]
Hi,
On Wed, Sep 17, 2025 at 11:52:38AM -0400, Samuel Kayode via B4 Relay wrote:
> From: Samuel Kayode <samuel.kayode@savoirfairelinux.com>
>
> Add support for the battery charger for pf1550 PMIC.
>
> Reviewed-by: Frank Li <Frank.Li@nxp.com>
> Tested-by: Sean Nyekjaer <sean@geanix.com>
> Signed-off-by: Samuel Kayode <samuel.kayode@savoirfairelinux.com>
> ---
Acked-by: Sebastian Reichel <sebastian.reichel@collabora.com>
-- Sebastian
> v11:
> - Seperate the battery properties from the charger properties
> v9:
> - Fix thermal regulation temperature ranges
> - Fix default thermal regulation temperature
> - Drop unused `data` variable in reg_init
> - Select charger operation mode based on application - suggested by Sean
> v8:
> - Drop PF1550_CHARGER_NAME
> - Drop unnecessary POWER_SUPPLY_STATUS_CHARGING s
> - Replace POWER_SUPPLY_HEALTH_DEAD with POWER_SUPPLY_HEALTH_NO_BATTERY
> - Drop check for charger in delayed_work s
> - Use dev_warn when battery is over-voltage
> - Define two power supplies: charger and battery
> - Use devm_delayed_work_autocancel to automate cleanup and fix race
> condition
> v7:
> - Use reverse christmas tree order
> - Drop unecessary 0 in id table's driver data field
> - Store virqs to avoid reinvoking platform_get_irq in the interrupt
> service routine
> - Drop manufacturer and model global variables
> v6:
> - Drop lock entirely
> - Reverse christmas tree order for variables defined in probe as
> suggested by Frank
> - return pf1550_reg_init
> v5:
> - Drop lock for battery and charger delayed_work
> - More conservative locking in vbus delayed_work
> - Apply lock when setting power supply type during register initialization
> v4:
> - Finish handling of some interrupts in threaded irq handler
> - Use platform_get_irq
> v3:
> - Use struct power_supply_get_battery_info to get constant charge
> voltage if specified
> - Use virqs mapped in MFD driver
> v2:
> - Address feedback from Enric Balletbo Serra
> ---
> drivers/power/supply/Kconfig | 11 +
> drivers/power/supply/Makefile | 1 +
> drivers/power/supply/pf1550-charger.c | 641 ++++++++++++++++++++++++++++++++++
> 3 files changed, 653 insertions(+)
>
> diff --git a/drivers/power/supply/Kconfig b/drivers/power/supply/Kconfig
> index 79ddb006e2dad6bf96b71ed570a37c006b5f9433..6d0c872edac1f45da314632e671af1aeda4c87b8 100644
> --- a/drivers/power/supply/Kconfig
> +++ b/drivers/power/supply/Kconfig
> @@ -471,6 +471,17 @@ config CHARGER_88PM860X
> help
> Say Y here to enable charger for Marvell 88PM860x chip.
>
> +config CHARGER_PF1550
> + tristate "NXP PF1550 battery charger driver"
> + depends on MFD_PF1550
> + help
> + Say Y to enable support for the NXP PF1550 battery charger.
> + The device is a single cell Li-Ion/Li-Polymer battery charger for
> + portable application.
> +
> + This driver can also be built as a module. If so, the module will be
> + called pf1550-charger.
> +
> config BATTERY_RX51
> tristate "Nokia RX-51 (N900) battery driver"
> depends on TWL4030_MADC
> diff --git a/drivers/power/supply/Makefile b/drivers/power/supply/Makefile
> index 4f5f8e3507f80da02812f0d08c2d81ddff0a272f..7f68380099c59dab71b73120150612a23e16a745 100644
> --- a/drivers/power/supply/Makefile
> +++ b/drivers/power/supply/Makefile
> @@ -64,6 +64,7 @@ obj-$(CONFIG_CHARGER_RT9467) += rt9467-charger.o
> obj-$(CONFIG_CHARGER_RT9471) += rt9471.o
> obj-$(CONFIG_BATTERY_TWL4030_MADC) += twl4030_madc_battery.o
> obj-$(CONFIG_CHARGER_88PM860X) += 88pm860x_charger.o
> +obj-$(CONFIG_CHARGER_PF1550) += pf1550-charger.o
> obj-$(CONFIG_BATTERY_RX51) += rx51_battery.o
> obj-$(CONFIG_AB8500_BM) += ab8500_bmdata.o ab8500_charger.o ab8500_fg.o ab8500_btemp.o ab8500_chargalg.o
> obj-$(CONFIG_CHARGER_CPCAP) += cpcap-charger.o
> diff --git a/drivers/power/supply/pf1550-charger.c b/drivers/power/supply/pf1550-charger.c
> new file mode 100644
> index 0000000000000000000000000000000000000000..98f1ee8eca3bc8dff2c3a697d157b9e3da204fe2
> --- /dev/null
> +++ b/drivers/power/supply/pf1550-charger.c
> @@ -0,0 +1,641 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/*
> + * charger driver for the PF1550
> + *
> + * Copyright (C) 2016 Freescale Semiconductor, Inc.
> + * Robin Gong <yibin.gong@freescale.com>
> + *
> + * Portions Copyright (c) 2025 Savoir-faire Linux Inc.
> + * Samuel Kayode <samuel.kayode@savoirfairelinux.com>
> + */
> +
> +#include <linux/devm-helpers.h>
> +#include <linux/interrupt.h>
> +#include <linux/mfd/pf1550.h>
> +#include <linux/module.h>
> +#include <linux/platform_device.h>
> +#include <linux/power_supply.h>
> +
> +#define PF1550_DEFAULT_CONSTANT_VOLT 4200000
> +#define PF1550_DEFAULT_MIN_SYSTEM_VOLT 3500000
> +#define PF1550_DEFAULT_THERMAL_TEMP 95
> +#define PF1550_CHARGER_IRQ_NR 5
> +
> +struct pf1550_charger {
> + struct device *dev;
> + const struct pf1550_ddata *pf1550;
> + struct power_supply *charger;
> + struct power_supply *battery;
> + struct delayed_work vbus_sense_work;
> + struct delayed_work chg_sense_work;
> + struct delayed_work bat_sense_work;
> + int virqs[PF1550_CHARGER_IRQ_NR];
> +
> + u32 constant_volt;
> + u32 min_system_volt;
> + u32 thermal_regulation_temp;
> +};
> +
> +static int pf1550_get_charger_state(struct regmap *regmap, int *val)
> +{
> + unsigned int data;
> + int ret;
> +
> + ret = regmap_read(regmap, PF1550_CHARG_REG_CHG_SNS, &data);
> + if (ret < 0)
> + return ret;
> +
> + data &= PF1550_CHG_SNS_MASK;
> +
> + switch (data) {
> + case PF1550_CHG_PRECHARGE:
> + case PF1550_CHG_CONSTANT_CURRENT:
> + case PF1550_CHG_CONSTANT_VOL:
> + case PF1550_CHG_EOC:
> + *val = POWER_SUPPLY_STATUS_CHARGING;
> + break;
> + case PF1550_CHG_DONE:
> + *val = POWER_SUPPLY_STATUS_FULL;
> + break;
> + case PF1550_CHG_TIMER_FAULT:
> + case PF1550_CHG_SUSPEND:
> + *val = POWER_SUPPLY_STATUS_NOT_CHARGING;
> + break;
> + case PF1550_CHG_OFF_INV:
> + case PF1550_CHG_OFF_TEMP:
> + case PF1550_CHG_LINEAR_ONLY:
> + *val = POWER_SUPPLY_STATUS_DISCHARGING;
> + break;
> + default:
> + *val = POWER_SUPPLY_STATUS_UNKNOWN;
> + }
> +
> + return 0;
> +}
> +
> +static int pf1550_get_charge_type(struct regmap *regmap, int *val)
> +{
> + unsigned int data;
> + int ret;
> +
> + ret = regmap_read(regmap, PF1550_CHARG_REG_CHG_SNS, &data);
> + if (ret < 0)
> + return ret;
> +
> + data &= PF1550_CHG_SNS_MASK;
> +
> + switch (data) {
> + case PF1550_CHG_SNS_MASK:
> + *val = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
> + break;
> + case PF1550_CHG_CONSTANT_CURRENT:
> + case PF1550_CHG_CONSTANT_VOL:
> + case PF1550_CHG_EOC:
> + *val = POWER_SUPPLY_CHARGE_TYPE_FAST;
> + break;
> + case PF1550_CHG_DONE:
> + case PF1550_CHG_TIMER_FAULT:
> + case PF1550_CHG_SUSPEND:
> + case PF1550_CHG_OFF_INV:
> + case PF1550_CHG_BAT_OVER:
> + case PF1550_CHG_OFF_TEMP:
> + case PF1550_CHG_LINEAR_ONLY:
> + *val = POWER_SUPPLY_CHARGE_TYPE_NONE;
> + break;
> + default:
> + *val = POWER_SUPPLY_CHARGE_TYPE_UNKNOWN;
> + }
> +
> + return 0;
> +}
> +
> +/*
> + * Supported health statuses:
> + * - POWER_SUPPLY_HEALTH_DEAD
> + * - POWER_SUPPLY_HEALTH_GOOD
> + * - POWER_SUPPLY_HEALTH_OVERVOLTAGE
> + * - POWER_SUPPLY_HEALTH_UNKNOWN
> + */
> +static int pf1550_get_battery_health(struct regmap *regmap, int *val)
> +{
> + unsigned int data;
> + int ret;
> +
> + ret = regmap_read(regmap, PF1550_CHARG_REG_BATT_SNS, &data);
> + if (ret < 0)
> + return ret;
> +
> + data &= PF1550_BAT_SNS_MASK;
> +
> + switch (data) {
> + case PF1550_BAT_NO_DETECT:
> + *val = POWER_SUPPLY_HEALTH_NO_BATTERY;
> + break;
> + case PF1550_BAT_NO_VBUS:
> + case PF1550_BAT_LOW_THAN_PRECHARG:
> + case PF1550_BAT_CHARG_FAIL:
> + case PF1550_BAT_HIGH_THAN_PRECHARG:
> + *val = POWER_SUPPLY_HEALTH_GOOD;
> + break;
> + case PF1550_BAT_OVER_VOL:
> + *val = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
> + break;
> + default:
> + *val = POWER_SUPPLY_HEALTH_UNKNOWN;
> + break;
> + }
> +
> + return 0;
> +}
> +
> +static int pf1550_get_present(struct regmap *regmap, int *val)
> +{
> + unsigned int data;
> + int ret;
> +
> + ret = regmap_read(regmap, PF1550_CHARG_REG_BATT_SNS, &data);
> + if (ret < 0)
> + return ret;
> +
> + data &= PF1550_BAT_SNS_MASK;
> + *val = (data == PF1550_BAT_NO_DETECT) ? 0 : 1;
> +
> + return 0;
> +}
> +
> +static int pf1550_get_online(struct regmap *regmap, int *val)
> +{
> + unsigned int data;
> + int ret;
> +
> + ret = regmap_read(regmap, PF1550_CHARG_REG_VBUS_SNS, &data);
> + if (ret < 0)
> + return ret;
> +
> + *val = (data & PF1550_VBUS_VALID) ? 1 : 0;
> +
> + return 0;
> +}
> +
> +static void pf1550_chg_bat_work(struct work_struct *work)
> +{
> + struct pf1550_charger *chg = container_of(to_delayed_work(work),
> + struct pf1550_charger,
> + bat_sense_work);
> + unsigned int data;
> +
> + if (regmap_read(chg->pf1550->regmap, PF1550_CHARG_REG_BATT_SNS, &data)) {
> + dev_err(chg->dev, "Read BATT_SNS error.\n");
> + return;
> + }
> +
> + switch (data & PF1550_BAT_SNS_MASK) {
> + case PF1550_BAT_NO_VBUS:
> + dev_dbg(chg->dev, "No valid VBUS input.\n");
> + break;
> + case PF1550_BAT_LOW_THAN_PRECHARG:
> + dev_dbg(chg->dev, "VBAT < VPRECHG.LB.\n");
> + break;
> + case PF1550_BAT_CHARG_FAIL:
> + dev_dbg(chg->dev, "Battery charging failed.\n");
> + break;
> + case PF1550_BAT_HIGH_THAN_PRECHARG:
> + dev_dbg(chg->dev, "VBAT > VPRECHG.LB.\n");
> + break;
> + case PF1550_BAT_OVER_VOL:
> + dev_dbg(chg->dev, "VBAT > VBATOV.\n");
> + break;
> + case PF1550_BAT_NO_DETECT:
> + dev_dbg(chg->dev, "Battery not detected.\n");
> + break;
> + default:
> + dev_err(chg->dev, "Unknown value read:%x\n",
> + data & PF1550_CHG_SNS_MASK);
> + }
> +}
> +
> +static void pf1550_chg_chg_work(struct work_struct *work)
> +{
> + struct pf1550_charger *chg = container_of(to_delayed_work(work),
> + struct pf1550_charger,
> + chg_sense_work);
> + unsigned int data;
> +
> + if (regmap_read(chg->pf1550->regmap, PF1550_CHARG_REG_CHG_SNS, &data)) {
> + dev_err(chg->dev, "Read CHG_SNS error.\n");
> + return;
> + }
> +
> + switch (data & PF1550_CHG_SNS_MASK) {
> + case PF1550_CHG_PRECHARGE:
> + dev_dbg(chg->dev, "In pre-charger mode.\n");
> + break;
> + case PF1550_CHG_CONSTANT_CURRENT:
> + dev_dbg(chg->dev, "In fast-charge constant current mode.\n");
> + break;
> + case PF1550_CHG_CONSTANT_VOL:
> + dev_dbg(chg->dev, "In fast-charge constant voltage mode.\n");
> + break;
> + case PF1550_CHG_EOC:
> + dev_dbg(chg->dev, "In EOC mode.\n");
> + break;
> + case PF1550_CHG_DONE:
> + dev_dbg(chg->dev, "In DONE mode.\n");
> + break;
> + case PF1550_CHG_TIMER_FAULT:
> + dev_info(chg->dev, "In timer fault mode.\n");
> + break;
> + case PF1550_CHG_SUSPEND:
> + dev_info(chg->dev, "In thermistor suspend mode.\n");
> + break;
> + case PF1550_CHG_OFF_INV:
> + dev_info(chg->dev, "Input invalid, charger off.\n");
> + break;
> + case PF1550_CHG_BAT_OVER:
> + dev_warn(chg->dev, "Battery over-voltage.\n");
> + break;
> + case PF1550_CHG_OFF_TEMP:
> + dev_info(chg->dev, "Temp high, charger off.\n");
> + break;
> + case PF1550_CHG_LINEAR_ONLY:
> + dev_dbg(chg->dev, "In Linear mode, not charging.\n");
> + break;
> + default:
> + dev_err(chg->dev, "Unknown value read:%x\n",
> + data & PF1550_CHG_SNS_MASK);
> + }
> +}
> +
> +static void pf1550_chg_vbus_work(struct work_struct *work)
> +{
> + struct pf1550_charger *chg = container_of(to_delayed_work(work),
> + struct pf1550_charger,
> + vbus_sense_work);
> + unsigned int data;
> +
> + if (regmap_read(chg->pf1550->regmap, PF1550_CHARG_REG_VBUS_SNS, &data)) {
> + dev_err(chg->dev, "Read VBUS_SNS error.\n");
> + return;
> + }
> +
> + if (data & PF1550_VBUS_UVLO) {
> + dev_dbg(chg->dev, "VBUS detached.\n");
> + power_supply_changed(chg->battery);
> + }
> + if (data & PF1550_VBUS_IN2SYS)
> + dev_dbg(chg->dev, "VBUS_IN2SYS_SNS.\n");
> + if (data & PF1550_VBUS_OVLO)
> + dev_dbg(chg->dev, "VBUS_OVLO_SNS.\n");
> + if (data & PF1550_VBUS_VALID) {
> + dev_dbg(chg->dev, "VBUS attached.\n");
> + power_supply_changed(chg->charger);
> + }
> +}
> +
> +static irqreturn_t pf1550_charger_irq_handler(int irq, void *data)
> +{
> + struct pf1550_charger *chg = data;
> + struct device *dev = chg->dev;
> + int i, irq_type = -1;
> +
> + for (i = 0; i < PF1550_CHARGER_IRQ_NR; i++)
> + if (irq == chg->virqs[i])
> + irq_type = i;
> +
> + switch (irq_type) {
> + case PF1550_CHARG_IRQ_BAT2SOCI:
> + dev_info(dev, "BAT to SYS Overcurrent interrupt.\n");
> + break;
> + case PF1550_CHARG_IRQ_BATI:
> + schedule_delayed_work(&chg->bat_sense_work,
> + msecs_to_jiffies(10));
> + break;
> + case PF1550_CHARG_IRQ_CHGI:
> + schedule_delayed_work(&chg->chg_sense_work,
> + msecs_to_jiffies(10));
> + break;
> + case PF1550_CHARG_IRQ_VBUSI:
> + schedule_delayed_work(&chg->vbus_sense_work,
> + msecs_to_jiffies(10));
> + break;
> + case PF1550_CHARG_IRQ_THMI:
> + dev_info(dev, "Thermal interrupt.\n");
> + break;
> + default:
> + dev_err(dev, "unknown interrupt occurred.\n");
> + }
> +
> + return IRQ_HANDLED;
> +}
> +
> +static enum power_supply_property pf1550_charger_props[] = {
> + POWER_SUPPLY_PROP_ONLINE,
> + POWER_SUPPLY_PROP_MODEL_NAME,
> + POWER_SUPPLY_PROP_MANUFACTURER,
> +};
> +
> +static enum power_supply_property pf1550_battery_props[] = {
> + POWER_SUPPLY_PROP_STATUS,
> + POWER_SUPPLY_PROP_CHARGE_TYPE,
> + POWER_SUPPLY_PROP_HEALTH,
> + POWER_SUPPLY_PROP_PRESENT,
> + POWER_SUPPLY_PROP_MODEL_NAME,
> + POWER_SUPPLY_PROP_MANUFACTURER,
> +};
> +
> +static int pf1550_charger_get_property(struct power_supply *psy,
> + enum power_supply_property psp,
> + union power_supply_propval *val)
> +{
> + struct pf1550_charger *chg = power_supply_get_drvdata(psy);
> + struct regmap *regmap = chg->pf1550->regmap;
> + int ret = 0;
> +
> + switch (psp) {
> + case POWER_SUPPLY_PROP_STATUS:
> + ret = pf1550_get_charger_state(regmap, &val->intval);
> + break;
> + case POWER_SUPPLY_PROP_CHARGE_TYPE:
> + ret = pf1550_get_charge_type(regmap, &val->intval);
> + break;
> + case POWER_SUPPLY_PROP_HEALTH:
> + ret = pf1550_get_battery_health(regmap, &val->intval);
> + break;
> + case POWER_SUPPLY_PROP_PRESENT:
> + ret = pf1550_get_present(regmap, &val->intval);
> + break;
> + case POWER_SUPPLY_PROP_ONLINE:
> + ret = pf1550_get_online(regmap, &val->intval);
> + break;
> + case POWER_SUPPLY_PROP_MODEL_NAME:
> + val->strval = "PF1550";
> + break;
> + case POWER_SUPPLY_PROP_MANUFACTURER:
> + val->strval = "NXP";
> + break;
> + default:
> + return -EINVAL;
> + }
> +
> + return ret;
> +}
> +
> +static const struct power_supply_desc pf1550_charger_desc = {
> + .name = "pf1550-charger",
> + .type = POWER_SUPPLY_TYPE_MAINS,
> + .properties = pf1550_charger_props,
> + .num_properties = ARRAY_SIZE(pf1550_charger_props),
> + .get_property = pf1550_charger_get_property,
> +};
> +
> +static const struct power_supply_desc pf1550_battery_desc = {
> + .name = "pf1550-battery",
> + .type = POWER_SUPPLY_TYPE_BATTERY,
> + .properties = pf1550_battery_props,
> + .num_properties = ARRAY_SIZE(pf1550_battery_props),
> + .get_property = pf1550_charger_get_property,
> +};
> +
> +static int pf1550_set_constant_volt(struct pf1550_charger *chg,
> + unsigned int uvolt)
> +{
> + unsigned int data;
> +
> + if (uvolt >= 3500000 && uvolt <= 4440000)
> + data = 8 + (uvolt - 3500000) / 20000;
> + else
> + return dev_err_probe(chg->dev, -EINVAL,
> + "Wrong value for constant voltage\n");
> +
> + dev_dbg(chg->dev, "Charging constant voltage: %u (0x%x)\n", uvolt,
> + data);
> +
> + return regmap_update_bits(chg->pf1550->regmap,
> + PF1550_CHARG_REG_BATT_REG,
> + PF1550_CHARG_REG_BATT_REG_CHGCV_MASK, data);
> +}
> +
> +static int pf1550_set_min_system_volt(struct pf1550_charger *chg,
> + unsigned int uvolt)
> +{
> + unsigned int data;
> +
> + switch (uvolt) {
> + case 3500000:
> + data = 0x0;
> + break;
> + case 3700000:
> + data = 0x1;
> + break;
> + case 4300000:
> + data = 0x2;
> + break;
> + default:
> + return dev_err_probe(chg->dev, -EINVAL,
> + "Wrong value for minimum system voltage\n");
> + }
> +
> + data <<= PF1550_CHARG_REG_BATT_REG_VMINSYS_SHIFT;
> +
> + dev_dbg(chg->dev, "Minimum system regulation voltage: %u (0x%x)\n",
> + uvolt, data);
> +
> + return regmap_update_bits(chg->pf1550->regmap,
> + PF1550_CHARG_REG_BATT_REG,
> + PF1550_CHARG_REG_BATT_REG_VMINSYS_MASK, data);
> +}
> +
> +static int pf1550_set_thermal_regulation_temp(struct pf1550_charger *chg,
> + unsigned int cells)
> +{
> + unsigned int data;
> +
> + switch (cells) {
> + case 80:
> + data = 0x0;
> + break;
> + case 95:
> + data = 0x1;
> + break;
> + case 110:
> + data = 0x2;
> + break;
> + case 125:
> + data = 0x3;
> + break;
> + default:
> + return dev_err_probe(chg->dev, -EINVAL,
> + "Wrong value for thermal temperature\n");
> + }
> +
> + data <<= PF1550_CHARG_REG_THM_REG_CNFG_REGTEMP_SHIFT;
> +
> + dev_dbg(chg->dev, "Thermal regulation loop temperature: %u (0x%x)\n",
> + cells, data);
> +
> + return regmap_update_bits(chg->pf1550->regmap,
> + PF1550_CHARG_REG_THM_REG_CNFG,
> + PF1550_CHARG_REG_THM_REG_CNFG_REGTEMP_MASK,
> + data);
> +}
> +
> +/*
> + * Sets charger registers to proper and safe default values.
> + */
> +static int pf1550_reg_init(struct pf1550_charger *chg)
> +{
> + struct power_supply_battery_info *info;
> + struct device *dev = chg->dev;
> + int ret;
> +
> + /* Unmask charger interrupt, mask DPMI and reserved bit */
> + ret = regmap_write(chg->pf1550->regmap, PF1550_CHARG_REG_CHG_INT_MASK,
> + PF1550_CHG_INT_MASK);
> + if (ret)
> + return dev_err_probe(dev, ret,
> + "Error unmask charger interrupt\n");
> +
> + ret = pf1550_set_constant_volt(chg, chg->constant_volt);
> + if (ret)
> + return ret;
> +
> + ret = pf1550_set_min_system_volt(chg, chg->min_system_volt);
> + if (ret)
> + return ret;
> +
> + ret = pf1550_set_thermal_regulation_temp(chg,
> + chg->thermal_regulation_temp);
> + if (ret)
> + return ret;
> +
> + /*
> + * The PF1550 charger has 3 modes of operation. By default, the charger
> + * is in mode 1; it remains off. Appropriate for applications not using
> + * a battery. The other supported mode is mode 2, the charger is turned
> + * on to charge a battery when present.
> + */
> + if (power_supply_get_battery_info(chg->charger, &info)) {
> + ret = regmap_write(chg->pf1550->regmap,
> + PF1550_CHARG_REG_CHG_OPER,
> + PF1550_CHG_BAT_ON);
> + if (ret)
> + return dev_err_probe(dev, ret,
> + "Error turn on charger\n");
> + }
> +
> + return 0;
> +}
> +
> +static void pf1550_dt_parse_dev_info(struct pf1550_charger *chg)
> +{
> + struct power_supply_battery_info *info;
> + struct device *dev = chg->dev;
> +
> + if (device_property_read_u32(dev->parent, "nxp,min-system-microvolt",
> + &chg->min_system_volt))
> + chg->min_system_volt = PF1550_DEFAULT_MIN_SYSTEM_VOLT;
> +
> + if (device_property_read_u32(dev->parent,
> + "nxp,thermal-regulation-celsius",
> + &chg->thermal_regulation_temp))
> + chg->thermal_regulation_temp = PF1550_DEFAULT_THERMAL_TEMP;
> +
> + if (power_supply_get_battery_info(chg->charger, &info))
> + chg->constant_volt = PF1550_DEFAULT_CONSTANT_VOLT;
> + else
> + chg->constant_volt = info->constant_charge_voltage_max_uv;
> +}
> +
> +static int pf1550_charger_probe(struct platform_device *pdev)
> +{
> + const struct pf1550_ddata *pf1550 = dev_get_drvdata(pdev->dev.parent);
> + struct power_supply_config psy_cfg = {};
> + struct pf1550_charger *chg;
> + int i, irq, ret;
> +
> + chg = devm_kzalloc(&pdev->dev, sizeof(*chg), GFP_KERNEL);
> + if (!chg)
> + return -ENOMEM;
> +
> + chg->dev = &pdev->dev;
> + chg->pf1550 = pf1550;
> +
> + if (!chg->pf1550->regmap)
> + return dev_err_probe(&pdev->dev, -ENODEV,
> + "failed to get regmap\n");
> +
> + platform_set_drvdata(pdev, chg);
> +
> + ret = devm_delayed_work_autocancel(chg->dev, &chg->vbus_sense_work,
> + pf1550_chg_vbus_work);
> + if (ret)
> + return dev_err_probe(chg->dev, ret,
> + "failed to add vbus sense work\n");
> +
> + ret = devm_delayed_work_autocancel(chg->dev, &chg->chg_sense_work,
> + pf1550_chg_chg_work);
> + if (ret)
> + return dev_err_probe(chg->dev, ret,
> + "failed to add charger sense work\n");
> +
> + ret = devm_delayed_work_autocancel(chg->dev, &chg->bat_sense_work,
> + pf1550_chg_bat_work);
> + if (ret)
> + return dev_err_probe(chg->dev, ret,
> + "failed to add battery sense work\n");
> +
> + for (i = 0; i < PF1550_CHARGER_IRQ_NR; i++) {
> + irq = platform_get_irq(pdev, i);
> + if (irq < 0)
> + return irq;
> +
> + chg->virqs[i] = irq;
> +
> + ret = devm_request_threaded_irq(&pdev->dev, irq, NULL,
> + pf1550_charger_irq_handler,
> + IRQF_NO_SUSPEND,
> + "pf1550-charger", chg);
> + if (ret)
> + return dev_err_probe(&pdev->dev, ret,
> + "failed irq request\n");
> + }
> +
> + psy_cfg.drv_data = chg;
> +
> + chg->charger = devm_power_supply_register(&pdev->dev,
> + &pf1550_charger_desc,
> + &psy_cfg);
> + if (IS_ERR(chg->charger))
> + return dev_err_probe(&pdev->dev, PTR_ERR(chg->charger),
> + "failed: power supply register\n");
> +
> + chg->battery = devm_power_supply_register(&pdev->dev,
> + &pf1550_battery_desc,
> + &psy_cfg);
> + if (IS_ERR(chg->battery))
> + return dev_err_probe(&pdev->dev, PTR_ERR(chg->battery),
> + "failed: power supply register\n");
> +
> + pf1550_dt_parse_dev_info(chg);
> +
> + return pf1550_reg_init(chg);
> +}
> +
> +static const struct platform_device_id pf1550_charger_id[] = {
> + { "pf1550-charger", },
> + { /* sentinel */ }
> +};
> +MODULE_DEVICE_TABLE(platform, pf1550_charger_id);
> +
> +static struct platform_driver pf1550_charger_driver = {
> + .driver = {
> + .name = "pf1550-charger",
> + },
> + .probe = pf1550_charger_probe,
> + .id_table = pf1550_charger_id,
> +};
> +module_platform_driver(pf1550_charger_driver);
> +
> +MODULE_AUTHOR("Robin Gong <yibin.gong@freescale.com>");
> +MODULE_DESCRIPTION("PF1550 charger driver");
> +MODULE_LICENSE("GPL");
>
> --
> 2.50.1
>
>
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 833 bytes --]
^ permalink raw reply
* Re: [PATCH v4 4/6] dt-bindings: touchscreen: fsl,imx6ul-tsc: support glitch thresold
From: Conor Dooley @ 2025-09-17 19:26 UTC (permalink / raw)
To: Frank Li
Cc: Dario Binacchi, linux-kernel, linux-amarula, Conor Dooley,
Dmitry Torokhov, Fabio Estevam, Haibo Chen, Krzysztof Kozlowski,
Pengutronix Kernel Team, Rob Herring, Sascha Hauer, Shawn Guo,
devicetree, imx, linux-arm-kernel, linux-input
In-Reply-To: <aMrc0GhVbpI38t3L@lizhi-Precision-Tower-5810>
[-- Attachment #1: Type: text/plain, Size: 2737 bytes --]
On Wed, Sep 17, 2025 at 12:07:44PM -0400, Frank Li wrote:
> On Wed, Sep 17, 2025 at 10:05:09AM +0200, Dario Binacchi wrote:
> > Support the touchscreen-glitch-threshold-ns property.
> >
> > Drivers must convert this value to IPG clock cycles and map it to one of
>
> binding descript hardware, not drivers. So below sentence should be better.
>
> "TSC only supports the four discrete thresholds, counted by IPG clock cycles.
> See SC_DEBUG_MODE2 register."
>
> > the four discrete thresholds exposed by the TSC_DEBUG_MODE2 register:
> >
> > 0: 8191 IPG cycles
> > 1: 4095 IPG cycles
> > 2: 2047 IPG cycles
> > 3: 1023 IPG cycles
> >
> > Signed-off-by: Dario Binacchi <dario.binacchi@amarulasolutions.com>
> >
> > ---
> >
> > Changes in v4:
> > - Adjust property description following the suggestions of
> > Conor Dooley and Frank Li.
> > - Update the commit description.
> >
> > Changes in v3:
> > - Remove the final part of the description that refers to
> > implementation details.
> >
> > .../bindings/input/touchscreen/fsl,imx6ul-tsc.yaml | 14 ++++++++++++++
> > 1 file changed, 14 insertions(+)
> >
> > diff --git a/Documentation/devicetree/bindings/input/touchscreen/fsl,imx6ul-tsc.yaml b/Documentation/devicetree/bindings/input/touchscreen/fsl,imx6ul-tsc.yaml
> > index 678756ad0f92..1975f741cf3d 100644
> > --- a/Documentation/devicetree/bindings/input/touchscreen/fsl,imx6ul-tsc.yaml
> > +++ b/Documentation/devicetree/bindings/input/touchscreen/fsl,imx6ul-tsc.yaml
> > @@ -62,6 +62,20 @@ properties:
> > description: Number of data samples which are averaged for each read.
> > enum: [ 1, 4, 8, 16, 32 ]
> >
> > + touchscreen-glitch-threshold-ns:
> > + description: |
> > + Minimum duration in nanoseconds a signal must remain stable
> > + to be considered valid.
> > +
> > + Drivers must convert this value to IPG clock cycles and map
> > + it to one of the four discrete thresholds exposed by the
> > + TSC_DEBUG_MODE2 register:
>
> same as commit messsage, talk about hardware.
This is fine. It's a generic comment about what must be done with the
property by software that helps people understand how to populate it.
Reviewed-by: Conor Dooley <conor.dooley@microchip.com>
> > + 0: 8191 IPG cycles
> > + 1: 4095 IPG cycles
> > + 2: 2047 IPG cycles
> > + 3: 1023 IPG cycles
> > +
>
> This case genenerally need enum 4 values, but it relates IPG frequency.
> I have not idea how to restrict it base on clk frequency. May DT mainatainer
> have idea.
I don't see how you really can restrict it based on the frequency of a
clock that can probably be varied at runtime.
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 228 bytes --]
^ permalink raw reply
* Re: [PATCH v4 3/6] dt-bindings: touchscreen: add touchscreen-glitch-threshold-ns property
From: Conor Dooley @ 2025-09-17 19:27 UTC (permalink / raw)
To: Dario Binacchi
Cc: linux-kernel, linux-amarula, Frank Li, Conor Dooley,
Dmitry Torokhov, Javier Carrasco, Jeff LaBundy,
Krzysztof Kozlowski, Rob Herring, devicetree, linux-input
In-Reply-To: <20250917080534.1772202-4-dario.binacchi@amarulasolutions.com>
[-- Attachment #1: Type: text/plain, Size: 364 bytes --]
On Wed, Sep 17, 2025 at 10:05:08AM +0200, Dario Binacchi wrote:
> Add support for glitch threshold configuration. A detected signal is valid
> only if it lasts longer than the set threshold; otherwise, it is regarded
> as a glitch.
>
> Signed-off-by: Dario Binacchi <dario.binacchi@amarulasolutions.com>
Acked-by: Conor Dooley <conor.dooley@microchip.com>
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 228 bytes --]
^ permalink raw reply
* Re: [PATCH v3] HID: lg-g15 - Add support for Logitech G13.
From: Leo L. Schwab @ 2025-09-17 19:50 UTC (permalink / raw)
To: Hans de Goede
Cc: Kate Hsuan, Jiri Kosina, Benjamin Tissoires, linux-input,
linux-kernel
In-Reply-To: <8e2c3560-6cba-4808-8207-ba3e1dd0e661@kernel.org>
On Wed, Sep 17, 2025 at 12:33:36PM +0200, Hans de Goede wrote:
> On 16-Sep-25 00:18, Leo L. Schwab wrote:
> > What do you want to happen to `brightness_hw_changed` when
> > `brightness` is changed in sysfs while the backlight is on? As it stands,
> > the current behavior is:
> > * Driver loads and probes; `brightness` and `brightness_hw_changed`
> > both set to 255.
>
> Ack, except that as mentioned above I would not touch brightness_hw_changed
> and just leave it at -1.
>
> > * sysfs `brightness` changed to 128. `brightness_hw_changed`
> > remains at 255.
> > * Toggle backilght off. `brightness_hw_changed` changed to 0.
> > `brightness` remains at 128.
> > * Toggle backlight back on. `brightness_hw_changed` gets a copy of
> > `brightness`, and both are now 128.
>
> Ack this is all correct.
>
...Oy.
Okay, I can give you that.
> > This seems inconsistent to me.
>
> This is working as intended / how the API was designed as
> Documentation/ABI/testing/sysfs-class-led says:
>
> Reading this file will return the last brightness level set
> by the hardware, this may be different from the current
> brightness. Reading this file when no hw brightness change
> event has happened will return an ENODATA error.
>
First: Why isn't this mentioned in Documentation/leds/leds_class.rst?
And second: This doesn't really clarify anything. That paragraph
may be legitimately interpreted to mean that `brightness_hw_changed` is
completely independent of `brightness`, as it was in my original
implementation.
> > Hence my earlier suggestion that
> > `brightness_hw_changed` should track all changes to `brightness`, except
> > when the backlight is toggled off.
>
> Then it also would be reporting values coming from sysfs writes,
> which it explicitly should not do.
>
Okay, fair, but having `brightness_hw_changed` read as 255, then
later as 128 after hitting the toggle button a couple of times strikes me as
inconsistent behavior.
> Summarizing in my view the following changes are necessary on v4:
>
> 1. Add backlight_disabled (or backlight_enabled) flag to struct lg_g15_data
> 2. Init that flag from prope()
> 3. Use that flag on receiving input reports to see if notify()
> should be called
> 4. Replace the LED_FULL passed to notify() (for off->on)
> with g15_led->brightness
>
Will do; will post v6 shortly. And someone should update the docs
describing the expected interaction between `brightness` and
`brightness_hw_changed`.
Schwab
^ permalink raw reply
* Re: [PATCH v1 2/2] Input: s6sa552 - add a driver for the Samsung A552 touchscreen controller
From: Dmitry Torokhov @ 2025-09-17 20:06 UTC (permalink / raw)
To: Ivaylo Ivanov
Cc: Krzysztof Kozlowski, Rob Herring, Conor Dooley, Henrik Rydberg,
linux-samsung-soc, linux-input, devicetree, linux-arm-kernel,
linux-kernel
In-Reply-To: <20250914134458.2624176-3-ivo.ivanov.ivanov1@gmail.com>
Hi Ivaylo,
On Sun, Sep 14, 2025 at 04:44:57PM +0300, Ivaylo Ivanov wrote:
> The S6SA552 touchscreen is a capacitive multi-touch controller for
> mobile use. It connects via i2c at the address 0x48.
>
> Introduce a basic driver, which can handle initialization, touch events
> and power states.
>
> At least the firmware for this IC on Galaxy S7 differs from S6SY761
> in register layout and bits, as well as some missing registers/functions,
> for example for retrieving the max X/Y coordinates and the amount
> of TX/RX channels.
I am not sure why you are using runtime PM in the driver, given that you
enable it on probe and disable it in remove and otherwise do not touch.
If you want to use it then you should probably call runtime_pm_get() and
runtime_pm_put() from open()/close() methods instead of toggling power
directly.
[...]
> +
> +static void s6sa552_input_close(struct input_dev *dev)
> +{
> + struct s6sa552_data *sdata = input_get_drvdata(dev);
> + int ret;
int error;
> +
> + ret = i2c_smbus_write_byte(sdata->client, S6SA552_SENSE_OFF);
> + if (ret)
> + dev_err(&sdata->client->dev, "failed to turn off sensing\n");
> +}
> +
> +static ssize_t s6sa552_sysfs_devid(struct device *dev,
> + struct device_attribute *attr, char *buf)
> +{
> + struct s6sa552_data *sdata = dev_get_drvdata(dev);
> +
> + return sprintf(buf, "%#x\n", sdata->devid);
> +}
> +
> +static DEVICE_ATTR(devid, 0444, s6sa552_sysfs_devid, NULL);
> +
> +static struct attribute *s6sa552_sysfs_attrs[] = {
> + &dev_attr_devid.attr,
> + NULL
> +};
> +ATTRIBUTE_GROUPS(s6sa552_sysfs);
> +
> +static int s6sa552_power_on(struct s6sa552_data *sdata)
> +{
> + u8 buffer[S6SA552_EVENT_SIZE];
> + int ret;
int error;
Use "error" for storing error values from APIs that return negative or
0. For APIs that also return real values "ret" is fine.
> +
> + ret = regulator_bulk_enable(ARRAY_SIZE(sdata->regulators),
> + sdata->regulators);
> + if (ret)
> + return ret;
> +
> + msleep(140);
> +
> + /* double check whether the touch is functional */
> + ret = i2c_smbus_read_i2c_block_data(sdata->client,
> + S6SA552_READ_ONE_EVENT,
> + S6SA552_EVENT_SIZE,
> + buffer);
> + if (ret < 0)
> + return ret;
> +
> + if (buffer[0] != S6SA552_EVENT_TYPE_ACK ||
> + buffer[1] != S6SA552_EVENT_ACK_BOOT) {
> + return -ENODEV;
> + }
> +
> + ret = i2c_smbus_read_byte_data(sdata->client, S6SA552_BOOT_STATUS);
> + if (ret < 0)
> + return ret;
> +
> + /* for some reasons the device might be stuck in the bootloader */
> + if (ret != S6SA552_BS_APPLICATION)
> + return -ENODEV;
> +
> + /* enable touch functionality */
> + ret = i2c_smbus_write_byte_data(sdata->client,
> + S6SA552_TOUCH_FUNCTION, 0x01);
> + if (ret)
> + return ret;
> +
> + mdelay(20); /* make sure everything is up */
> +
> + return 0;
> +}
> +
> +static int s6sa552_hw_init(struct s6sa552_data *sdata)
> +{
> + u8 buffer[S6SA552_DEVID_SIZE];
> + int ret;
> +
> + ret = s6sa552_power_on(sdata);
> + if (ret)
> + return ret;
> +
> + ret = i2c_smbus_read_i2c_block_data(sdata->client,
> + S6SA552_DEVICE_ID,
> + S6SA552_DEVID_SIZE,
> + buffer);
> + if (ret < 0)
> + return ret;
> +
> + sdata->devid = get_unaligned_be16(buffer + 1);
> +
> + return 0;
> +}
> +
> +static void s6sa552_power_off(void *data)
> +{
> + struct s6sa552_data *sdata = data;
> +
> + disable_irq(sdata->client->irq);
> + regulator_bulk_disable(ARRAY_SIZE(sdata->regulators),
> + sdata->regulators);
> +}
> +
> +static int s6sa552_probe(struct i2c_client *client)
> +{
> + struct s6sa552_data *sdata;
> + int err;
> +
> + if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C |
> + I2C_FUNC_SMBUS_BYTE_DATA |
> + I2C_FUNC_SMBUS_I2C_BLOCK))
> + return -ENODEV;
> +
> + sdata = devm_kzalloc(&client->dev, sizeof(*sdata), GFP_KERNEL);
> + if (!sdata)
> + return -ENOMEM;
> +
> + i2c_set_clientdata(client, sdata);
> + sdata->client = client;
> +
> + sdata->regulators[S6SA552_REGULATOR_VDD].supply = "vdd";
> + sdata->regulators[S6SA552_REGULATOR_AVDD].supply = "avdd";
> + err = devm_regulator_bulk_get(&client->dev,
> + ARRAY_SIZE(sdata->regulators),
> + sdata->regulators);
> + if (err)
> + return err;
> +
> + err = devm_add_action_or_reset(&client->dev, s6sa552_power_off, sdata);
> + if (err)
> + return err;
> +
> + err = s6sa552_hw_init(sdata);
> + if (err)
> + return err;
> +
> + sdata->input = devm_input_allocate_device(&client->dev);
> + if (!sdata->input)
> + return -ENOMEM;
> +
> + sdata->input->name = S6SA552_DEV_NAME;
> + sdata->input->id.bustype = BUS_I2C;
> + sdata->input->open = s6sa552_input_open;
> + sdata->input->close = s6sa552_input_close;
> +
> + input_set_abs_params(sdata->input, ABS_MT_POSITION_X, 0, S6SA552_MAX_X,
> + 0, 0);
> + input_set_abs_params(sdata->input, ABS_MT_POSITION_Y, 0, S6SA552_MAX_Y,
> + 0, 0);
> + input_set_abs_params(sdata->input, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
> + input_set_abs_params(sdata->input, ABS_MT_TOUCH_MINOR, 0, 255, 0, 0);
> + input_set_abs_params(sdata->input, ABS_MT_PRESSURE, 0, 255, 0, 0);
> +
> + touchscreen_parse_properties(sdata->input, true, &sdata->prop);
> +
> + if (!input_abs_get_max(sdata->input, ABS_X) ||
> + !input_abs_get_max(sdata->input, ABS_Y)) {
> + dev_warn(&client->dev, "the axis have not been set\n");
> + }
> +
> + err = input_mt_init_slots(sdata->input, S6SA552_TX_CHANNELS,
> + INPUT_MT_DIRECT);
> + if (err)
> + return err;
> +
> + input_set_drvdata(sdata->input, sdata);
> +
> + err = input_register_device(sdata->input);
> + if (err)
> + return err;
> +
> + err = devm_request_threaded_irq(&client->dev, client->irq, NULL,
> + s6sa552_irq_handler,
> + IRQF_TRIGGER_LOW | IRQF_ONESHOT,
Do not hardcode trigger type, just use IRQF_ONESHOT.
> + "s6sa552_irq", sdata);
> + if (err)
> + return err;
> +
> + pm_runtime_enable(&client->dev);
> +
> + return 0;
> +}
Thanks.
--
Dmitry
^ permalink raw reply
* [PATCH v4 0/2] Initial work for Rust abstraction for HID device driver development
From: Rahul Rameshbabu @ 2025-09-17 22:53 UTC (permalink / raw)
To: linux-input, linux-kernel, rust-for-linux
Cc: a.hindborg, alex.gaynor, aliceryhl, benjamin.tissoires,
benno.lossin, bjorn3_gh, boqun.feng, dakr, db48x, gary, jikos,
ojeda, peter.hutterer, tmgross, Rahul Rameshbabu
I wanted to thank Benjamin for his response on the previous v3 RESEND.
Greatly appreciated. I have gone ahead with some minor logistically changes
in the series, based on his response. I have dropped the C patch since he
also took that patch into the hid tree in v3.
Link: https://lore.kernel.org/rust-for-linux/wjfjzjc626n55zvhksiyldobwubr2imbvfavqej333lvnka2wn@r4zfcjqtanvu/
Link: https://lore.kernel.org/rust-for-linux/175810473311.3076338.14309101339951114135.b4-ty@kernel.org/
Rahul Rameshbabu (2):
rust: core abstractions for HID drivers
rust: hid: Glorious PC Gaming Race Model O and O- mice reference
driver
MAINTAINERS | 14 +
drivers/hid/Kconfig | 2 +
drivers/hid/hid-glorious.c | 2 +
drivers/hid/hid_glorious_rust.rs | 60 ++++
drivers/hid/rust/Kconfig | 28 ++
drivers/hid/rust/Makefile | 6 +
drivers/hid/rust/hid_glorious_rust.rs | 60 ++++
rust/bindings/bindings_helper.h | 3 +
rust/kernel/hid.rs | 497 ++++++++++++++++++++++++++
rust/kernel/lib.rs | 2 +
10 files changed, 674 insertions(+)
create mode 100644 drivers/hid/hid_glorious_rust.rs
create mode 100644 drivers/hid/rust/Kconfig
create mode 100644 drivers/hid/rust/Makefile
create mode 100644 drivers/hid/rust/hid_glorious_rust.rs
create mode 100644 rust/kernel/hid.rs
base-commit: 657403637f7d343352efb29b53d9f92dcf86aebb
--
2.51.0
^ permalink raw reply
* [PATCH v4 1/2] rust: core abstractions for HID drivers
From: Rahul Rameshbabu @ 2025-09-17 22:53 UTC (permalink / raw)
To: linux-input, linux-kernel, rust-for-linux
Cc: a.hindborg, alex.gaynor, aliceryhl, benjamin.tissoires,
benno.lossin, bjorn3_gh, boqun.feng, dakr, db48x, gary, jikos,
ojeda, peter.hutterer, tmgross, Rahul Rameshbabu
In-Reply-To: <20250917225341.4572-1-sergeantsagara@protonmail.com>
These abstractions enable the development of HID drivers in Rust by binding
with the HID core C API. They provide Rust types that map to the
equivalents in C. In this initial draft, only hid_device and hid_device_id
are provided direct Rust type equivalents. hid_driver is specially wrapped
with a custom Driver type. The module_hid_driver! macro provides analogous
functionality to its C equivalent. Only the .report_fixup callback is
binded to Rust so far.
Future work for these abstractions would include more bindings for common
HID-related types, such as hid_field, hid_report_enum, and hid_report as
well as more bus callbacks. Providing Rust equivalents to useful core HID
functions will also be necessary for HID driver development in Rust.
Signed-off-by: Rahul Rameshbabu <sergeantsagara@protonmail.com>
---
Notes:
Changelog:
v3->v4:
* Removed specifying tree in MAINTAINERS file since that is up for
debate
* Minor rebase cleanup
* Moved driver logic under drivers/hid/rust
v2->v3:
* Implemented AlwaysRefCounted trait using embedded struct device's
reference counts instead of the separate reference counter in struct
hid_device
* Used &raw mut as appropriate
* Binded include/linux/device.h for get_device and put_device
* Cleaned up various comment related formatting
* Minified dev_err! format string
* Updated Group enum to be repr(u16)
* Implemented From<u16> trait for Group
* Added TODO comment when const_trait_impl stabilizes
* Made group getter functions return a Group variant instead of a raw
number
* Made sure example code builds
v1->v2:
* Binded drivers/hid/hid-ids.h for use in Rust drivers
* Remove pre-emptive referencing of a C HID driver instance before
it is fully initialized in the driver registration path
* Moved static getters to generic Device trait implementation, so
they can be used by all device::DeviceContext
* Use core macros for supporting DeviceContext transitions
* Implemented the AlwaysRefCounted and AsRef traits
* Make use for dev_err! as appropriate
RFC->v1:
* Use Danilo's core infrastructure
* Account for HID device groups
* Remove probe and remove callbacks
* Implement report_fixup support
* Properly comment code including SAFETY comments
MAINTAINERS | 8 +
drivers/hid/Kconfig | 2 +
drivers/hid/rust/Kconfig | 12 +
rust/bindings/bindings_helper.h | 3 +
rust/kernel/hid.rs | 497 ++++++++++++++++++++++++++++++++
rust/kernel/lib.rs | 2 +
6 files changed, 524 insertions(+)
create mode 100644 drivers/hid/rust/Kconfig
create mode 100644 rust/kernel/hid.rs
diff --git a/MAINTAINERS b/MAINTAINERS
index cd7ff55b5d32..dc597bfe1a54 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -10850,6 +10850,14 @@ F: include/uapi/linux/hid*
F: samples/hid/
F: tools/testing/selftests/hid/
+HID CORE LAYER [RUST]
+M: Rahul Rameshbabu <sergeantsagara@protonmail.com>
+R: Benjamin Tissoires <bentiss@kernel.org>
+L: linux-input@vger.kernel.org
+S: Maintained
+F: drivers/hid/rust/*.rs
+F: rust/kernel/hid.rs
+
HID LOGITECH DRIVERS
R: Filipe Laíns <lains@riseup.net>
L: linux-input@vger.kernel.org
diff --git a/drivers/hid/Kconfig b/drivers/hid/Kconfig
index 79997553d8f9..073771d95966 100644
--- a/drivers/hid/Kconfig
+++ b/drivers/hid/Kconfig
@@ -1420,6 +1420,8 @@ endmenu
source "drivers/hid/bpf/Kconfig"
+source "drivers/hid/rust/Kconfig"
+
source "drivers/hid/i2c-hid/Kconfig"
source "drivers/hid/intel-ish-hid/Kconfig"
diff --git a/drivers/hid/rust/Kconfig b/drivers/hid/rust/Kconfig
new file mode 100644
index 000000000000..d3247651829e
--- /dev/null
+++ b/drivers/hid/rust/Kconfig
@@ -0,0 +1,12 @@
+# SPDX-License-Identifier: GPL-2.0-only
+menu "Rust HID support"
+
+config RUST_HID_ABSTRACTIONS
+ bool "Rust HID abstractions support"
+ depends on RUST
+ depends on HID=y
+ help
+ Adds support needed for HID drivers written in Rust. It provides a
+ wrapper around the C hid core.
+
+endmenu # Rust HID support
diff --git a/rust/bindings/bindings_helper.h b/rust/bindings/bindings_helper.h
index 4ad9add117ea..773468788d98 100644
--- a/rust/bindings/bindings_helper.h
+++ b/rust/bindings/bindings_helper.h
@@ -46,6 +46,7 @@
#include <linux/cpufreq.h>
#include <linux/cpumask.h>
#include <linux/cred.h>
+#include <linux/device.h>
#include <linux/device/faux.h>
#include <linux/dma-mapping.h>
#include <linux/errname.h>
@@ -53,6 +54,8 @@
#include <linux/file.h>
#include <linux/firmware.h>
#include <linux/fs.h>
+#include <linux/hid.h>
+#include "../../drivers/hid/hid-ids.h"
#include <linux/ioport.h>
#include <linux/jiffies.h>
#include <linux/jump_label.h>
diff --git a/rust/kernel/hid.rs b/rust/kernel/hid.rs
new file mode 100644
index 000000000000..588483bf7204
--- /dev/null
+++ b/rust/kernel/hid.rs
@@ -0,0 +1,497 @@
+// SPDX-License-Identifier: GPL-2.0
+
+// Copyright (C) 2025 Rahul Rameshbabu <sergeantsagara@protonmail.com>
+
+//! Abstractions for the HID interface.
+//!
+//! C header: [`include/linux/hid.h`](srctree/include/linux/hid.h)
+
+use crate::{device, device_id::RawDeviceId, driver, error::*, prelude::*, types::Opaque};
+use core::{
+ marker::PhantomData,
+ ptr::{addr_of_mut, NonNull},
+};
+
+/// Indicates the item is static read-only.
+///
+/// Refer to [Device Class Definition for HID 1.11]
+/// Section 6.2.2.5 Input, Output, and Feature Items.
+///
+/// [Device Class Definition for HID 1.11]: https://www.usb.org/sites/default/files/hid1_11.pdf
+pub const MAIN_ITEM_CONSTANT: u8 = bindings::HID_MAIN_ITEM_CONSTANT as u8;
+
+/// Indicates the item represents data from a physical control.
+///
+/// Refer to [Device Class Definition for HID 1.11]
+/// Section 6.2.2.5 Input, Output, and Feature Items.
+///
+/// [Device Class Definition for HID 1.11]: https://www.usb.org/sites/default/files/hid1_11.pdf
+pub const MAIN_ITEM_VARIABLE: u8 = bindings::HID_MAIN_ITEM_VARIABLE as u8;
+
+/// Indicates the item should be treated as a relative change from the previous
+/// report.
+///
+/// Refer to [Device Class Definition for HID 1.11]
+/// Section 6.2.2.5 Input, Output, and Feature Items.
+///
+/// [Device Class Definition for HID 1.11]: https://www.usb.org/sites/default/files/hid1_11.pdf
+pub const MAIN_ITEM_RELATIVE: u8 = bindings::HID_MAIN_ITEM_RELATIVE as u8;
+
+/// Indicates the item should wrap around when reaching the extreme high or
+/// extreme low values.
+///
+/// Refer to [Device Class Definition for HID 1.11]
+/// Section 6.2.2.5 Input, Output, and Feature Items.
+///
+/// [Device Class Definition for HID 1.11]: https://www.usb.org/sites/default/files/hid1_11.pdf
+pub const MAIN_ITEM_WRAP: u8 = bindings::HID_MAIN_ITEM_WRAP as u8;
+
+/// Indicates the item should wrap around when reaching the extreme high or
+/// extreme low values.
+///
+/// Refer to [Device Class Definition for HID 1.11]
+/// Section 6.2.2.5 Input, Output, and Feature Items.
+///
+/// [Device Class Definition for HID 1.11]: https://www.usb.org/sites/default/files/hid1_11.pdf
+pub const MAIN_ITEM_NONLINEAR: u8 = bindings::HID_MAIN_ITEM_NONLINEAR as u8;
+
+/// Indicates whether the control has a preferred state it will physically
+/// return to without user intervention.
+///
+/// Refer to [Device Class Definition for HID 1.11]
+/// Section 6.2.2.5 Input, Output, and Feature Items.
+///
+/// [Device Class Definition for HID 1.11]: https://www.usb.org/sites/default/files/hid1_11.pdf
+pub const MAIN_ITEM_NO_PREFERRED: u8 = bindings::HID_MAIN_ITEM_NO_PREFERRED as u8;
+
+/// Indicates whether the control has a physical state where it will not send
+/// any reports.
+///
+/// Refer to [Device Class Definition for HID 1.11]
+/// Section 6.2.2.5 Input, Output, and Feature Items.
+///
+/// [Device Class Definition for HID 1.11]: https://www.usb.org/sites/default/files/hid1_11.pdf
+pub const MAIN_ITEM_NULL_STATE: u8 = bindings::HID_MAIN_ITEM_NULL_STATE as u8;
+
+/// Indicates whether the control requires host system logic to change state.
+///
+/// Refer to [Device Class Definition for HID 1.11]
+/// Section 6.2.2.5 Input, Output, and Feature Items.
+///
+/// [Device Class Definition for HID 1.11]: https://www.usb.org/sites/default/files/hid1_11.pdf
+pub const MAIN_ITEM_VOLATILE: u8 = bindings::HID_MAIN_ITEM_VOLATILE as u8;
+
+/// Indicates whether the item is fixed size or a variable buffer of bytes.
+///
+/// Refer to [Device Class Definition for HID 1.11]
+/// Section 6.2.2.5 Input, Output, and Feature Items.
+///
+/// [Device Class Definition for HID 1.11]: https://www.usb.org/sites/default/files/hid1_11.pdf
+pub const MAIN_ITEM_BUFFERED_BYTE: u8 = bindings::HID_MAIN_ITEM_BUFFERED_BYTE as u8;
+
+/// HID device groups are intended to help categories HID devices based on a set
+/// of common quirks and logic that they will require to function correctly.
+#[repr(u16)]
+pub enum Group {
+ /// Used to match a device against any group when probing.
+ Any = bindings::HID_GROUP_ANY as u16,
+
+ /// Indicates a generic device that should need no custom logic from the
+ /// core HID stack.
+ Generic = bindings::HID_GROUP_GENERIC as u16,
+
+ /// Maps multitouch devices to hid-multitouch instead of hid-generic.
+ Multitouch = bindings::HID_GROUP_MULTITOUCH as u16,
+
+ /// Used for autodetecing and mapping of HID sensor hubs to
+ /// hid-sensor-hub.
+ SensorHub = bindings::HID_GROUP_SENSOR_HUB as u16,
+
+ /// Used for autodetecing and mapping Win 8 multitouch devices to set the
+ /// needed quirks.
+ MultitouchWin8 = bindings::HID_GROUP_MULTITOUCH_WIN_8 as u16,
+
+ // Vendor-specific device groups.
+ /// Used to distinguish Synpatics touchscreens from other products. The
+ /// touchscreens will be handled by hid-multitouch instead, while everything
+ /// else will be managed by hid-rmi.
+ RMI = bindings::HID_GROUP_RMI as u16,
+
+ /// Used for hid-core handling to automatically identify Wacom devices and
+ /// have them probed by hid-wacom.
+ Wacom = bindings::HID_GROUP_WACOM as u16,
+
+ /// Used by logitech-djreceiver and logitech-djdevice to autodetect if
+ /// devices paied to the DJ receivers are DJ devices and handle them with
+ /// the device driver.
+ LogitechDJDevice = bindings::HID_GROUP_LOGITECH_DJ_DEVICE as u16,
+
+ /// Since the Valve Steam Controller only has vendor-specific usages,
+ /// prevent hid-generic from parsing its reports since there would be
+ /// nothing hid-generic could do for the device.
+ Steam = bindings::HID_GROUP_STEAM as u16,
+
+ /// Used to differentiate 27 Mhz frequency Logitech DJ devices from other
+ /// Logitech DJ devices.
+ Logitech27MHzDevice = bindings::HID_GROUP_LOGITECH_27MHZ_DEVICE as u16,
+
+ /// Used for autodetecting and mapping Vivaldi devices to hid-vivaldi.
+ Vivaldi = bindings::HID_GROUP_VIVALDI as u16,
+}
+
+// TODO: use `const_trait_impl` once stabilized:
+//
+// ```
+// impl const From<Group> for u16 {
+// /// [`Group`] variants are represented by [`u16`] values.
+// fn from(value: Group) -> Self {
+// value as Self
+// }
+// }
+// ```
+impl Group {
+ /// Internal function used to convert [`Group`] variants into [`u16`].
+ const fn into(self) -> u16 {
+ self as u16
+ }
+}
+
+impl From<u16> for Group {
+ /// [`u16`] values can be safely converted to [`Group`] variants.
+ fn from(value: u16) -> Self {
+ match value.into() {
+ bindings::HID_GROUP_GENERIC => Group::Generic,
+ bindings::HID_GROUP_MULTITOUCH => Group::Multitouch,
+ bindings::HID_GROUP_SENSOR_HUB => Group::SensorHub,
+ bindings::HID_GROUP_MULTITOUCH_WIN_8 => Group::MultitouchWin8,
+ bindings::HID_GROUP_RMI => Group::RMI,
+ bindings::HID_GROUP_WACOM => Group::Wacom,
+ bindings::HID_GROUP_LOGITECH_DJ_DEVICE => Group::LogitechDJDevice,
+ bindings::HID_GROUP_STEAM => Group::Steam,
+ bindings::HID_GROUP_LOGITECH_27MHZ_DEVICE => Group::Logitech27MHzDevice,
+ bindings::HID_GROUP_VIVALDI => Group::Vivaldi,
+ _ => Group::Any,
+ }
+ }
+}
+
+/// The HID device representation.
+///
+/// This structure represents the Rust abstraction for a C `struct hid_device`.
+/// The implementation abstracts the usage of an already existing C `struct
+/// hid_device` within Rust code that we get passed from the C side.
+///
+/// # Invariants
+///
+/// A [`Device`] instance represents a valid `struct hid_device` created by the
+/// C portion of the kernel.
+#[repr(transparent)]
+pub struct Device<Ctx: device::DeviceContext = device::Normal>(
+ Opaque<bindings::hid_device>,
+ PhantomData<Ctx>,
+);
+
+impl<Ctx: device::DeviceContext> Device<Ctx> {
+ fn as_raw(&self) -> *mut bindings::hid_device {
+ self.0.get()
+ }
+
+ /// Returns the HID transport bus ID.
+ pub fn bus(&self) -> u16 {
+ // SAFETY: `self.as_raw` is a valid pointer to a `struct hid_device`
+ unsafe { *self.as_raw() }.bus
+ }
+
+ /// Returns the HID report group.
+ pub fn group(&self) -> Group {
+ // SAFETY: `self.as_raw` is a valid pointer to a `struct hid_device`
+ unsafe { *self.as_raw() }.group.into()
+ }
+
+ /// Returns the HID vendor ID.
+ pub fn vendor(&self) -> u32 {
+ // SAFETY: `self.as_raw` is a valid pointer to a `struct hid_device`
+ unsafe { *self.as_raw() }.vendor
+ }
+
+ /// Returns the HID product ID.
+ pub fn product(&self) -> u32 {
+ // SAFETY: `self.as_raw` is a valid pointer to a `struct hid_device`
+ unsafe { *self.as_raw() }.product
+ }
+}
+
+// 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 });
+kernel::impl_device_context_into_aref!(Device);
+
+// SAFETY: Instances of `Device` are always reference-counted.
+unsafe impl crate::types::AlwaysRefCounted for Device {
+ fn inc_ref(&self) {
+ // SAFETY: The existence of a shared reference guarantees that the refcount is non-zero.
+ unsafe { bindings::get_device(&raw mut (*self.as_raw()).dev) };
+ }
+
+ unsafe fn dec_ref(obj: NonNull<Self>) {
+ // SAFETY: The safety requirements guarantee that the refcount is non-zero.
+ unsafe { bindings::put_device(&raw mut (*obj.cast::<bindings::hid_device>().as_ptr()).dev) }
+ }
+}
+
+impl<Ctx: device::DeviceContext> AsRef<device::Device<Ctx>> for Device<Ctx> {
+ fn as_ref(&self) -> &device::Device<Ctx> {
+ // SAFETY: By the type invariant of `Self`, `self.as_raw()` is a pointer to a valid
+ // `struct hid_device`.
+ let dev = unsafe { addr_of_mut!((*self.as_raw()).dev) };
+
+ // SAFETY: `dev` points to a valid `struct device`.
+ unsafe { device::Device::from_raw(dev) }
+ }
+}
+
+/// Abstraction for the HID device ID structure `struct hid_device_id`.
+#[repr(transparent)]
+#[derive(Clone, Copy)]
+pub struct DeviceId(bindings::hid_device_id);
+
+impl DeviceId {
+ /// Equivalent to C's `HID_USB_DEVICE` macro.
+ ///
+ /// Create a new `hid::DeviceId` from a group, vendor ID, and device ID
+ /// number.
+ pub const fn new_usb(group: Group, vendor: u32, product: u32) -> Self {
+ Self(bindings::hid_device_id {
+ bus: 0x3, // BUS_USB
+ group: group.into(),
+ vendor,
+ product,
+ driver_data: 0,
+ })
+ }
+
+ /// Returns the HID transport bus ID.
+ pub fn bus(&self) -> u16 {
+ self.0.bus
+ }
+
+ /// Returns the HID report group.
+ pub fn group(&self) -> Group {
+ self.0.group.into()
+ }
+
+ /// Returns the HID vendor ID.
+ pub fn vendor(&self) -> u32 {
+ self.0.vendor
+ }
+
+ /// Returns the HID product ID.
+ pub fn product(&self) -> u32 {
+ self.0.product
+ }
+}
+
+// SAFETY:
+// * `DeviceId` is a `#[repr(transparent)` wrapper of `hid_device_id` and does not add
+// additional invariants, so it's safe to transmute to `RawType`.
+// * `DRIVER_DATA_OFFSET` is the offset to the `driver_data` field.
+unsafe impl RawDeviceId for DeviceId {
+ type RawType = bindings::hid_device_id;
+}
+
+/// [`IdTable`] type for HID.
+pub type IdTable<T> = &'static dyn kernel::device_id::IdTable<DeviceId, T>;
+
+/// Create a HID [`IdTable`] with its alias for modpost.
+#[macro_export]
+macro_rules! hid_device_table {
+ ($table_name:ident, $module_table_name:ident, $id_info_type: ty, $table_data: expr) => {
+ const $table_name: $crate::device_id::IdArray<
+ $crate::hid::DeviceId,
+ $id_info_type,
+ { $table_data.len() },
+ > = $crate::device_id::IdArray::new($table_data);
+
+ $crate::module_device_table!("hid", $module_table_name, $table_name);
+ };
+}
+
+/// The HID driver trait.
+///
+/// # Examples
+///
+/// ```
+/// use kernel::{bindings, device, hid};
+///
+/// struct MyDriver;
+///
+/// kernel::hid_device_table!(
+/// HID_TABLE,
+/// MODULE_HID_TABLE,
+/// <MyDriver as hid::Driver>::IdInfo,
+/// [(
+/// hid::DeviceId::new_usb(
+/// hid::Group::Steam,
+/// bindings::USB_VENDOR_ID_VALVE,
+/// bindings::USB_DEVICE_ID_STEAM_DECK,
+/// ),
+/// (),
+/// )]
+/// );
+///
+/// #[vtable]
+/// impl hid::Driver for MyDriver {
+/// type IdInfo = ();
+/// const ID_TABLE: hid::IdTable<Self::IdInfo> = &HID_TABLE;
+///
+/// /// This function is optional to implement.
+/// fn report_fixup<'a, 'b: 'a>(_hdev: &hid::Device<device::Core>, rdesc: &'b mut [u8]) -> &'a [u8] {
+/// // Perform some report descriptor fixup.
+/// rdesc
+/// }
+/// }
+/// ```
+/// Drivers must implement this trait in order to get a HID driver registered.
+/// Please refer to the `Adapter` documentation for an example.
+#[vtable]
+pub trait Driver: Send {
+ /// The type holding information about each device id supported by the driver.
+ // TODO: Use `associated_type_defaults` once stabilized:
+ //
+ // ```
+ // type IdInfo: 'static = ();
+ // ```
+ type IdInfo: 'static;
+
+ /// The table of device ids supported by the driver.
+ const ID_TABLE: IdTable<Self::IdInfo>;
+
+ /// Called before report descriptor parsing. Can be used to mutate the
+ /// report descriptor before the core HID logic processes the descriptor.
+ /// Useful for problematic report descriptors that prevent HID devices from
+ /// functioning correctly.
+ ///
+ /// Optional to implement.
+ fn report_fixup<'a, 'b: 'a>(_hdev: &Device<device::Core>, _rdesc: &'b mut [u8]) -> &'a [u8] {
+ build_error!(VTABLE_DEFAULT_ERROR)
+ }
+}
+
+/// An adapter for the registration of HID drivers.
+pub struct Adapter<T: Driver>(T);
+
+// SAFETY: A call to `unregister` for a given instance of `RegType` is guaranteed to be valid if
+// a preceding call to `register` has been successful.
+unsafe impl<T: Driver + 'static> driver::RegistrationOps for Adapter<T> {
+ type RegType = bindings::hid_driver;
+
+ unsafe fn register(
+ hdrv: &Opaque<Self::RegType>,
+ name: &'static CStr,
+ module: &'static ThisModule,
+ ) -> Result {
+ // SAFETY: It's safe to set the fields of `struct hid_driver` on initialization.
+ unsafe {
+ (*hdrv.get()).name = name.as_char_ptr();
+ (*hdrv.get()).id_table = T::ID_TABLE.as_ptr();
+ (*hdrv.get()).report_fixup = if T::HAS_REPORT_FIXUP {
+ Some(Self::report_fixup_callback)
+ } else {
+ None
+ };
+ }
+
+ // SAFETY: `hdrv` is guaranteed to be a valid `RegType`
+ to_result(unsafe {
+ bindings::__hid_register_driver(hdrv.get(), module.0, name.as_char_ptr())
+ })
+ }
+
+ unsafe fn unregister(hdrv: &Opaque<Self::RegType>) {
+ // SAFETY: `hdrv` is guaranteed to be a valid `RegType`
+ unsafe { bindings::hid_unregister_driver(hdrv.get()) }
+ }
+}
+
+impl<T: Driver + 'static> Adapter<T> {
+ extern "C" fn report_fixup_callback(
+ hdev: *mut bindings::hid_device,
+ buf: *mut u8,
+ size: *mut kernel::ffi::c_uint,
+ ) -> *const u8 {
+ // SAFETY: The HID subsystem only ever calls the report_fixup callback
+ // with a valid pointer to a `struct hid_device`.
+ //
+ // INVARIANT: `hdev` is valid for the duration of
+ // `report_fixup_callback()`.
+ let hdev = unsafe { &*hdev.cast::<Device<device::Core>>() };
+
+ // SAFETY: The HID subsystem only ever calls the report_fixup callback
+ // with a valid pointer to a `kernel::ffi::c_uint`.
+ //
+ // INVARIANT: `size` is valid for the duration of
+ // `report_fixup_callback()`.
+ let buf_len: usize = match unsafe { *size }.try_into() {
+ Ok(len) => len,
+ Err(e) => {
+ dev_err!(
+ hdev.as_ref(),
+ "Cannot fix report description due to {}!\n",
+ e
+ );
+
+ return buf;
+ }
+ };
+
+ // Build a mutable Rust slice from `buf` and `size`.
+ //
+ // SAFETY: The HID subsystem only ever calls the `report_fixup callback`
+ // with a valid pointer to a `u8` buffer.
+ //
+ // INVARIANT: `buf` is valid for the duration of
+ // `report_fixup_callback()`.
+ let rdesc_slice = unsafe { core::slice::from_raw_parts_mut(buf, buf_len) };
+ let rdesc_slice = T::report_fixup(hdev, rdesc_slice);
+
+ match rdesc_slice.len().try_into() {
+ // SAFETY: The HID subsystem only ever calls the report_fixup
+ // callback with a valid pointer to a `kernel::ffi::c_uint`.
+ //
+ // INVARIANT: `size` is valid for the duration of
+ // `report_fixup_callback()`.
+ Ok(len) => unsafe { *size = len },
+ Err(e) => {
+ dev_err!(
+ hdev.as_ref(),
+ "Fixed report description will not be used due to {}!\n",
+ e
+ );
+
+ return buf;
+ }
+ }
+
+ rdesc_slice.as_ptr()
+ }
+}
+
+/// Declares a kernel module that exposes a single HID driver.
+///
+/// # Examples
+///
+/// ```ignore
+/// kernel::module_hid_driver! {
+/// type: MyDriver,
+/// name: "Module name",
+/// authors: ["Author name"],
+/// description: "Description",
+/// license: "GPL",
+/// }
+/// ```
+#[macro_export]
+macro_rules! module_hid_driver {
+ ($($f:tt)*) => {
+ $crate::module_driver!(<T>, $crate::hid::Adapter<T>, { $($f)* });
+ };
+}
diff --git a/rust/kernel/lib.rs b/rust/kernel/lib.rs
index 733f4d4e9bae..1e50912e81f6 100644
--- a/rust/kernel/lib.rs
+++ b/rust/kernel/lib.rs
@@ -89,6 +89,8 @@
pub mod firmware;
pub mod fmt;
pub mod fs;
+#[cfg(CONFIG_RUST_HID_ABSTRACTIONS)]
+pub mod hid;
pub mod init;
pub mod io;
pub mod ioctl;
--
2.51.0
^ permalink raw reply related
page: next (older) | prev (newer) | latest
- recent:[subjects (threaded)|topics (new)|topics (active)]
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox