[V6,00/15] Rust bindings for cpufreq and OPP core + sample driver

Miguel / Danilo,

I would like to get some of this (if not all) merged now into the rust/dev
branch, since this stuff has been around for some time and many other
dependencies are already merged new (like OF, platform, device/driver). Please
suggest how can we move forward to get that done.

-------------------------8<-------------------------

This patch series introduces initial Rust bindings for two subsystems: cpufreq
and Operating Performance Points (OPP). The bindings cover most of the
interfaces exposed by these subsystems.

Included in this series is a sample `cpufreq` driver, `rcpufreq-dt`, which is a
duplicate of the existing `cpufreq-dt` driver. The `cpufreq-dt` driver is a
generic, platform-agnostic, device-tree-based driver used on many ARM platforms.

Currently, the implementation has been tested using QEMU, verifying that
frequency transitions, various configurations, and driver binding/unbinding
functions as expected. However, performance measurements have not been
conducted.

For those interested in trying these patches, along with a few dependencies,
they can be found at:

git://git.kernel.org/pub/scm/linux/kernel/git/vireshk/linux.git rust/cpufreq-dt

The series includes all the patches to make it work:
- few new APIs to cpufreq/OPP frameworks.
- Avoiding using BIT() macro in cpufreq core (we need to make Rust work with
  it).
- Renaming of the cpufreq-dt platform device (this too needs to be fixed in
  Rust).
- Basic Rust bindings for clk and cpumask layers.

The work is based on `staging/dev` from the Rust tree, which is derived
from v6.13-rc3.

V5->V6:
- Rebase over latest rust/dev branch, which changed few interfaces that the
  patches were using.
- Included all other patches, which weren't included until now to focus only on
  core APIs.
- Other minor cleanups, additions.

V4->V5:
- Rename Registration::register() as new().
- Provide a new API: Registration::new_foreign_owned() and use it for
  rcpufreq_dt driver.
- Update MAINTAINERS file.

V3->V4:
- Fix bugs with freeing of OPP structure. Dropped the Drop routine and fixed
  reference counting.
- Registration object of the cpufreq core is modified a bit to remove the
  registered field, and few other cleanups.
- Use Devres for instead of platform data.
- Improve SAFETY comments.

V2->V3:
- Rebased on latest rust-device changes, which removed `Data` and so few changes
  were required to make it work.
- use srctree links (Alice Ryhl).
- Various changes the OPP creation APIs, new APIs: from_raw_opp() and
  from_raw_opp_owned() (Alice Ryhl).
- Inline as_raw() helpers (Alice Ryhl).
- Add new interface (`OPP::Token`) for dynamically created OPPs.
- Add Reviewed-by tag from Manos.
- Modified/simplified cpufreq registration structure / method a bit.

V1->V2:
- Create and use separate bindings for OF, clk, cpumask, etc (not included in
  this patchset but pushed to the above branch). This helped removing direct
  calls from the driver.
- Fix wrong usage of Pinning + Vec.
- Use Token for OPP Config.
- Use Opaque, transparent and Aref for few structures.
- Broken down into smaller patches to make it easy for reviewers.
- Based over staging/rust-device.

Thanks.

Viresh Kumar (15):
  PM / OPP: Expose refcounting helpers for the Rust implementation
  cpufreq: Add cpufreq_table_len()
  cpufreq: Rust implementation doesn't parse BIT() macro
  rust: device: Add few helpers
  rust: Add bindings for cpumask
  rust: Add bare minimal bindings for clk framework
  rust: Add initial bindings for OPP framework
  rust: Extend OPP bindings for the OPP table
  rust: Extend OPP bindings for the configuration options
  rust: Add initial bindings for cpufreq framework
  rust: Extend cpufreq bindings for policy and driver ops
  rust: Extend cpufreq bindings for driver registration
  rust: Extend OPP bindings with CPU frequency table
  cpufreq: Add Rust based cpufreq-dt driver
  DO-NOT_MERGE: cpufreq: Rename cpufreq-dt platdev

 MAINTAINERS                          |    2 +
 drivers/cpufreq/Kconfig              |   12 +
 drivers/cpufreq/Makefile             |    1 +
 drivers/cpufreq/cpufreq-dt-platdev.c |    2 +-
 drivers/cpufreq/rcpufreq_dt.rs       |  232 ++++++
 drivers/opp/core.c                   |   17 +-
 drivers/opp/opp.h                    |    1 -
 include/linux/cpufreq.h              |   27 +-
 include/linux/pm_opp.h               |    6 +
 rust/bindings/bindings_helper.h      |    5 +
 rust/helpers/cpufreq.c               |   16 +
 rust/helpers/cpumask.c               |   35 +
 rust/helpers/helpers.c               |    2 +
 rust/kernel/clk.rs                   |   48 ++
 rust/kernel/cpufreq.rs               | 1079 ++++++++++++++++++++++++++
 rust/kernel/cpumask.rs               |   85 ++
 rust/kernel/device.rs                |   21 +
 rust/kernel/lib.rs                   |    6 +
 rust/kernel/opp.rs                   |  886 +++++++++++++++++++++
 19 files changed, 2468 insertions(+), 15 deletions(-)
 create mode 100644 drivers/cpufreq/rcpufreq_dt.rs
 create mode 100644 rust/helpers/cpufreq.c
 create mode 100644 rust/helpers/cpumask.c
 create mode 100644 rust/kernel/clk.rs
 create mode 100644 rust/kernel/cpufreq.rs
 create mode 100644 rust/kernel/cpumask.rs
 create mode 100644 rust/kernel/opp.rs

On 07-01-25, 12:58, Greg KH wrote:
> On Tue, Jan 07, 2025 at 04:51:34PM +0530, Viresh Kumar wrote:
> > The Rust implementation needs these APIs for its working. Expose them.
> 
> Why is the rust code unique here?  Why does C code not need these
> exported?
> 
> And that first sentance isn't really good grammer :)
> 
> Also, you created a new function here and didn't document it anywhere,
> nor do you mention it here in the changelog text, making this a
> non-starter right off :(

How about this ?

    PM / OPP: Add reference counting helpers for Rust implementation

    To ensure that resources such as OPP tables or OPP nodes are not freed
    while in use by the Rust implementation, it is necessary to increment
    their reference count from Rust code.

    This commit introduces a new helper function,
    `dev_pm_opp_get_opp_table_ref()`, to increment the reference count of an
    OPP table and declares the existing helper `dev_pm_opp_get()` in
    `pm_opp.h`.

On Wed, Jan 8, 2025 at 6:20 AM Viresh Kumar <viresh.kumar@linaro.org> wrote:
>
> On 07-01-25, 12:47, Danilo Krummrich wrote:
> > On Tue, Jan 07, 2025 at 04:51:33PM +0530, Viresh Kumar wrote:
> > > I would like to get some of this (if not all) merged now into the rust/dev
> >
> > You mean rust-dev or staging/dev?
>
> Right.

I think something was missing there :) i.e. which one?

In any case, for upstreaming eventually, then this should ideally go
through the relevant maintainers. So I guess that means yourself in a
few cases here.

Cheers,
Miguel