From nobody Sat Feb 7 16:45:34 2026 Received: from mail-pl1-f171.google.com (mail-pl1-f171.google.com [209.85.214.171]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 97355133987 for ; Thu, 11 Jul 2024 06:58:12 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.171 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1720681095; cv=none; b=evM7uxvEUx0ioFS4VdpU1zFZCPK7+pDpcxbs/EvVJcJ59mWE82LLFsb4201mQj+38OG0HCy37xkYRbaD1tWqAdfWd+1nFzYhi9FWMfqsK/zJ2Y15avWz+15TxEprJRHvdDJd6rN4fg7iTrp/aBOqIumZDrWBxLjPnt4sMTUr2qk= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1720681095; c=relaxed/simple; bh=hEoGb7fCNUZKYG09Vi4rnNZxFTRVFSFRbOt84vEUm5Y=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=YHH/DRS9O8ncmFmHBpTZj4qDmw85oywi0POg4NmRo8TZilAUh6V5z7M83tkVErJz4NvN7PVG/UQLs46x5LKqjFzVcoy8OosjDzVol1hZcUrYoclLpSpilA0s9S81gloUpv04yPmdQ8Eo8NhTThPUNqx+leIgB7Edq7VDn1EUK10= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linaro.org; spf=pass smtp.mailfrom=linaro.org; dkim=pass (2048-bit key) header.d=linaro.org header.i=@linaro.org header.b=U88dgJty; arc=none smtp.client-ip=209.85.214.171 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linaro.org Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=linaro.org Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=linaro.org header.i=@linaro.org header.b="U88dgJty" Received: by mail-pl1-f171.google.com with SMTP id d9443c01a7336-1fb3b7d0d56so2746145ad.1 for ; Wed, 10 Jul 2024 23:58:12 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; t=1720681092; x=1721285892; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=sqKk8lVDz/dgOgz3FOgHxzv1n1Gyizp08G47uTvrEjI=; b=U88dgJtylpusMi6uzejN67LZPRsIEq+z1Ii8gIvvsb5ulnE1Q9sjvVq1OoQQAvfBos aF4J7Hp74i307U8fxeBfwIbxDse5hVr/RmxijUdIRhJ42JMYYHFnSwTj52NWbWXA2eP5 rhIIp1bjcwbO5o10PxZIigiUG+Uy6DwyVtEOinFzfE8aN87Ok6nhwX5wVEPxE/fMSEF6 jdS5poAJ3jMzJjEA+F6G0TF2tu1r6dR9Fy2XFxCCsVIumKWt1hqHHqx24HuhEf8II9pv Jo8uywd/666+I5LIcgBHd9KCjo6cpkvGNbIGuCtVeWNigNDruWx0sAPOVifrX+YG3y+0 cQsg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1720681092; x=1721285892; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=sqKk8lVDz/dgOgz3FOgHxzv1n1Gyizp08G47uTvrEjI=; b=Nvbi3Q7a+x9bh02xXXws3rIgbsErP34WcNmxAezynfvJoYerkoXOB6I1DmS8bT3Ykv CeIv0wA2+/0UJUfVvVPO9H7nVBF/1btH6sOxeGBY8O49d/oyNND/xHZ6yk1g7KLtcuFD OeGT3G6Q4Gf09ve+KZKejUqug8zbmbDxSIENILq/VRBhIOra3L+Ut77A/CAOTtvG91Ru 9FvB5zuGeFVi590e4vEBNErqHIHhi55LCWlgiwxiOBfMhtK6iKIXl6AL1sFOWBLnRpJq lzmx9U1herI701ovisLBYf6gq8tzgGbqi6E0+ckAJFOuy2U4ohQmtTKVlBKXYKRwDsv5 INsA== X-Forwarded-Encrypted: i=1; AJvYcCUKe8GqvuePlqjOkrSrdYcHmNfW5D+lRF0AZvQXz2AY5xiyOcdC5uvwhjvGubx+IvBKfSWd3Ip1k7uk8NAZ2Bi7jMEiFF9dREuJ4FyJ X-Gm-Message-State: AOJu0YypwuqEqzElfs9gAisHF/qWs4aDaX9lxKZFZMIYfV/hedOQF6C0 PLhQdpC1ICywbrBJrk0WogElRGvAdll8Lh1JKG4u4AgvnixfdocW+60KQEn9glw= X-Google-Smtp-Source: AGHT+IHXoY9B8xcSCc3trKZadGfghQGwvAH8jXk6mQ68R48fQi5XTTPTj2VgRZPWfp9dfYdEOCytCg== X-Received: by 2002:a17:902:fc88:b0:1f9:9221:6c2d with SMTP id d9443c01a7336-1fbb6ec1c52mr50966155ad.53.1720681091859; Wed, 10 Jul 2024 23:58:11 -0700 (PDT) Received: from localhost ([122.172.84.129]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-1fbb6a2b6bcsm43712215ad.78.2024.07.10.23.58.10 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 10 Jul 2024 23:58:11 -0700 (PDT) From: Viresh Kumar To: "Rafael J. Wysocki" , Miguel Ojeda , Danilo Krummrich , Miguel Ojeda , Alex Gaynor , Wedson Almeida Filho , Boqun Feng , Gary Guo , =?UTF-8?q?Bj=C3=B6rn=20Roy=20Baron?= , Benno Lossin , Andreas Hindborg , Alice Ryhl Cc: Viresh Kumar , linux-pm@vger.kernel.org, Vincent Guittot , Stephen Boyd , Nishanth Menon , rust-for-linux@vger.kernel.org, Manos Pitsidianakis , Erik Schilling , =?UTF-8?q?Alex=20Benn=C3=A9e?= , Joakim Bech , Rob Herring , linux-kernel@vger.kernel.org Subject: [PATCH V4 1/8] rust: Add initial bindings for OPP framework Date: Thu, 11 Jul 2024 12:27:43 +0530 Message-Id: <3214f87b792cf1f902cf0e5a6069f310215e3d30.1720680252.git.viresh.kumar@linaro.org> X-Mailer: git-send-email 2.31.1.272.g89b43f80a514 In-Reply-To: References: Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" This commit adds initial Rust bindings for the Operating performance points (OPP) core. This adds bindings for `struct dev_pm_opp` and `struct dev_pm_opp_data` to begin with. Reviewed-by: Manos Pitsidianakis Signed-off-by: Viresh Kumar --- rust/bindings/bindings_helper.h | 1 + rust/kernel/lib.rs | 2 + rust/kernel/opp.rs | 189 ++++++++++++++++++++++++++++++++ 3 files changed, 192 insertions(+) create mode 100644 rust/kernel/opp.rs diff --git a/rust/bindings/bindings_helper.h b/rust/bindings/bindings_helpe= r.h index d8b54b9fa4d0..1bf8e053c8f4 100644 --- a/rust/bindings/bindings_helper.h +++ b/rust/bindings/bindings_helper.h @@ -15,6 +15,7 @@ #include #include #include +#include #include #include #include diff --git a/rust/kernel/lib.rs b/rust/kernel/lib.rs index 3bf1089b87a3..e309d7774cbd 100644 --- a/rust/kernel/lib.rs +++ b/rust/kernel/lib.rs @@ -45,6 +45,8 @@ #[cfg(CONFIG_NET)] pub mod net; pub mod of; +#[cfg(CONFIG_PM_OPP)] +pub mod opp; pub mod platform; pub mod prelude; pub mod print; diff --git a/rust/kernel/opp.rs b/rust/kernel/opp.rs new file mode 100644 index 000000000000..dec832edec9b --- /dev/null +++ b/rust/kernel/opp.rs @@ -0,0 +1,189 @@ +// SPDX-License-Identifier: GPL-2.0 + +//! Operating performance points. +//! +//! This module provides bindings for interacting with the OPP subsystem. +//! +//! C header: [`include/linux/pm_opp.h`](srctree/include/linux/pm_opp.h) + +use crate::{ + bindings, + device::Device, + error::{code::*, to_result, Result}, + types::{ARef, AlwaysRefCounted, Opaque}, +}; + +use core::ptr; + +/// Dynamically created Operating performance point (OPP). +pub struct Token { + dev: ARef, + freq: u64, +} + +impl Token { + /// Adds an OPP dynamically. + pub fn new(dev: &ARef, mut data: Data) -> Result { + // SAFETY: The requirements are satisfied by the existence of `Dev= ice` and its safety + // requirements. + to_result(unsafe { bindings::dev_pm_opp_add_dynamic(dev.as_raw(), = &mut data.0) })?; + Ok(Self { + dev: dev.clone(), + freq: data.freq(), + }) + } +} + +impl Drop for Token { + fn drop(&mut self) { + // SAFETY: The requirements are satisfied by the existence of `Dev= ice` and its safety + // requirements. + unsafe { bindings::dev_pm_opp_remove(self.dev.as_raw(), self.freq)= }; + } +} + +/// Equivalent to `struct dev_pm_opp_data` in the C Code. +#[repr(transparent)] +pub struct Data(bindings::dev_pm_opp_data); + +impl Data { + /// Creates new instance of [`Data`]. + pub fn new(freq: u64, u_volt: u64, level: u32, turbo: bool) -> Self { + Self(bindings::dev_pm_opp_data { + turbo, + freq, + u_volt, + level, + }) + } + + /// Adds an OPP dynamically. The OPP is freed once the [`Token`] gets = freed. + pub fn add_opp(self, dev: &ARef) -> Result { + Token::new(dev, self) + } + + fn freq(&self) -> u64 { + self.0.freq + } +} + +/// Operating performance point (OPP). +/// +/// Wraps the kernel's `struct dev_pm_opp`. +/// +/// The pointer to `struct dev_pm_opp` is non-null and valid for the lifet= ime of the `OPP` +/// instance. +/// +/// # Invariants +/// +/// Instances of this type are reference-counted. The reference count is i= ncremented by the +/// `dev_pm_opp_get()` function and decremented by `dev_pm_opp_put`. The R= ust type `ARef` +/// represents a pointer that owns a reference count on the OPP. +/// +/// A reference to the `OPP`, `&OPP` isn't refcounted by the Rust code. + +#[repr(transparent)] +pub struct OPP(Opaque); + +// SAFETY: It's OK to send the ownership of `OPP` across thread boundaries. +unsafe impl Send for OPP {} + +// SAFETY: It's OK to access `OPP` through shared references from other th= reads because we're +// either accessing properties that don't change or that are properly sync= hronised by C code. +unsafe impl Sync for OPP {} + +// SAFETY: The type invariants guarantee that [`OPP`] is always refcounted. +unsafe impl AlwaysRefCounted for OPP { + fn inc_ref(&self) { + // SAFETY: The existence of a shared reference means that the refc= ount is nonzero. + unsafe { bindings::dev_pm_opp_get(self.0.get()) }; + } + + unsafe fn dec_ref(obj: ptr::NonNull) { + // SAFETY: The safety requirements guarantee that the refcount is = nonzero. + unsafe { bindings::dev_pm_opp_put(obj.cast().as_ptr()) } + } +} + +impl OPP { + /// Creates an owned reference to a [`OPP`] from a valid pointer. + /// + /// The refcount is incremented by the C code and will be decremented = by `dec_ref()` when the + /// ARef object is dropped. + /// + /// # Safety + /// + /// The caller must ensure that `ptr` is valid and the OPP's refcount = is incremented. The + /// caller must also ensure that it doesn't explicitly drop the refcou= nt of the OPP, as the + /// returned ARef object takes over the refcount increment on the unde= rlying object and the + /// same will be dropped along with it. + pub unsafe fn from_raw_opp_owned(ptr: *mut bindings::dev_pm_opp) -> Re= sult> { + let ptr =3D ptr::NonNull::new(ptr).ok_or(ENODEV)?; + + // SAFETY: The safety requirements guarantee the validity of the p= ointer. + Ok(unsafe { ARef::from_raw(ptr.cast()) }) + } + + /// Creates a reference to a [`OPP`] from a valid pointer. + /// + /// The refcount is not updated by the Rust API unless the returned re= ference is converted to + /// an ARef object. + /// + /// # Safety + /// + /// The caller must ensure that `ptr` is valid and remains valid for t= he duration of 'a. + pub unsafe fn from_raw_opp<'a>(ptr: *mut bindings::dev_pm_opp) -> Resu= lt<&'a Self> { + // SAFETY: The caller guarantees that the pointer is not dangling = and stays valid for the + // duration of 'a. The cast is okay because `OPP` is `repr(transpa= rent)`. + Ok(unsafe { &*ptr.cast() }) + } + + #[inline] + fn as_raw(&self) -> *mut bindings::dev_pm_opp { + self.0.get() + } + + /// Returns the frequency of an OPP. + pub fn freq(&self, index: Option) -> u64 { + let index =3D index.unwrap_or(0); + + // SAFETY: By the type invariants, we know that `self` owns a refe= rence, so it is safe to + // use it. + unsafe { bindings::dev_pm_opp_get_freq_indexed(self.as_raw(), inde= x) } + } + + /// Returns the voltage of an OPP. + pub fn voltage(&self) -> u64 { + // SAFETY: By the type invariants, we know that `self` owns a refe= rence, so it is safe to + // use it. + unsafe { bindings::dev_pm_opp_get_voltage(self.as_raw()) } + } + + /// Returns the level of an OPP. + pub fn level(&self) -> u32 { + // SAFETY: By the type invariants, we know that `self` owns a refe= rence, so it is safe to + // use it. + unsafe { bindings::dev_pm_opp_get_level(self.as_raw()) } + } + + /// Returns the power of an OPP. + pub fn power(&self) -> u64 { + // SAFETY: By the type invariants, we know that `self` owns a refe= rence, so it is safe to + // use it. + unsafe { bindings::dev_pm_opp_get_power(self.as_raw()) } + } + + /// Returns the required pstate of an OPP. + pub fn required_pstate(&self, index: u32) -> u32 { + // SAFETY: By the type invariants, we know that `self` owns a refe= rence, so it is safe to + // use it. + unsafe { bindings::dev_pm_opp_get_required_pstate(self.as_raw(), i= ndex) } + } + + /// Returns true if the OPP is turbo. + pub fn is_turbo(&self) -> bool { + // SAFETY: By the type invariants, we know that `self` owns a refe= rence, so it is safe to + // use it. + unsafe { bindings::dev_pm_opp_is_turbo(self.as_raw()) } + } +} --=20 2.31.1.272.g89b43f80a514 From nobody Sat Feb 7 16:45:35 2026 Received: from mail-pf1-f176.google.com (mail-pf1-f176.google.com [209.85.210.176]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 84BED14039D for ; Thu, 11 Jul 2024 06:58:16 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.176 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1720681098; cv=none; b=Lqxz6BwqT8RathysrUSJpgIwrvSGM5INOeWY2bwJEPF3yA55UsspotLtkZW9DkVWZY++R1wwwjPa8P9yk9xI1G2321aiyQ2jjqerdC2MPSBAZZZdVnqv9cu5By2diXz3g6xz+lUxhWn/p08Rp0uDs1hNRa8vNoCGVTaCgT3aJEg= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1720681098; c=relaxed/simple; bh=YjNq75QgFeA7Yus4IxCVFfuEQI50uhXJwK9Os0w9Dag=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=hQk4YS3LjpCdqtvMlQkdRbeVJXM2rK7yAOrX01Co7muH6rwAXC11AK3Vac9SmRCkEZDmQgcyLy/5AGRnLJQqc1XqLAVRZc+3OoeqQ9qFTKxLGc7dsaE3WW8ipbQRumx63N5RT61diH4gsuQKVW5Kc0pRZ1u3aEGdpfClxgxSLKQ= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linaro.org; spf=pass smtp.mailfrom=linaro.org; dkim=pass (2048-bit key) header.d=linaro.org header.i=@linaro.org header.b=A46ZrzWf; arc=none smtp.client-ip=209.85.210.176 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linaro.org Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=linaro.org Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=linaro.org header.i=@linaro.org header.b="A46ZrzWf" Received: by mail-pf1-f176.google.com with SMTP id d2e1a72fcca58-70b0ebd1ef9so468467b3a.2 for ; Wed, 10 Jul 2024 23:58:16 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; t=1720681096; x=1721285896; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=bwz/REpE+iNc1GUN5OnD3+R/RJ6eiupzXXvcQ/qHpdo=; b=A46ZrzWfvCaRjFHQChb5owoig7hQoTgtNFatMWiJGAzcJyuo4iR1kvIxF84NnqfBIE ugPWePu+Rc0DayJfE4102kFj9HWAhnPZqGb/vqMijNWnJFfHVKhTHrzKWn1jKyw+wrHH w9GQ/cQqePP2HangBmiTYcbALbEQvRT4GXhKzqucHHrDyZrXZPZ9W5IEzqd+dMvrDFY9 CCuJ19cF2W3lvx5MGw2DHg/6la805RN4srZ0Rbxgg0hpaw2+9Kyq4BD6OJw2sPNcrZFN DlioPk5itd88Zl9UfdRNzc0UFCwHMKoSTee17BPCRRaRkluvmgMBHmJR5VqgTeAEtdwB U/ww== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1720681096; x=1721285896; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=bwz/REpE+iNc1GUN5OnD3+R/RJ6eiupzXXvcQ/qHpdo=; b=wnCy9e0S1qVik+YTY/iTNTZ2BS9Zl1jWuVhAfo/+zhHxzlsGLecQjmfTkeTLmaBRTp ces6WyVYxw8aerDC2ufy4CfTFkHgEEij6JLkKdDB73JQphccI4kP2odsiHUoEHTJ1NGE /qiX8Q3r0VP2a+MUkP3J9A0HaYnheUiv8s+TnQSAvgd/M2PpoKDv8kC901xEkn7PvPwE lKudycRk0UVAjrCqf4rEXb5+DskVCpsaGgiYIz9O1D2EGNzeMvdmPwds9WdBn+s6O3Tz kjpCDzDtpO7LoJHD0NIN1vkRtsBwg2qyOg3wlhvPJFvOOO/9hp0CpMi9zpy+S1mGQp5n b95A== X-Forwarded-Encrypted: i=1; AJvYcCXlckOsotR38ImaTNs0WsOH+VmPZYgh9/MI1Y8bOW3zyqnk8tOXAC1T+QNk8yKuw/qaoe22dgBTAfzMJelG/ua1sClg6rEyj4I1l3LK X-Gm-Message-State: AOJu0Ywnm5wAbxqUQ/ooNXiC9laOwECIDmvbsbUnLW5xdwDVEaB0Nndq ve8MLGRG/sNV0lhBKpqW95N9XAdkLTQMzJ6TXvA1Kqs7Tt/ymsFXDloL4g2CKWw= X-Google-Smtp-Source: AGHT+IHrj66ESvK2qr7QpQ11U/N2gu5ZYsRKXVPHurDOiffXBh0LXlPMVHQ3gqeEufGZLEIvyYQ81g== X-Received: by 2002:aa7:88d6:0:b0:705:b0c0:d7d7 with SMTP id d2e1a72fcca58-70b434f63fcmr9278737b3a.7.1720681095609; Wed, 10 Jul 2024 23:58:15 -0700 (PDT) Received: from localhost ([122.172.84.129]) by smtp.gmail.com with ESMTPSA id d2e1a72fcca58-70b438c0119sm4922562b3a.46.2024.07.10.23.58.14 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 10 Jul 2024 23:58:15 -0700 (PDT) From: Viresh Kumar To: "Rafael J. Wysocki" , Miguel Ojeda , Danilo Krummrich , Miguel Ojeda , Alex Gaynor , Wedson Almeida Filho , Boqun Feng , Gary Guo , =?UTF-8?q?Bj=C3=B6rn=20Roy=20Baron?= , Benno Lossin , Andreas Hindborg , Alice Ryhl Cc: Viresh Kumar , linux-pm@vger.kernel.org, Vincent Guittot , Stephen Boyd , Nishanth Menon , rust-for-linux@vger.kernel.org, Manos Pitsidianakis , Erik Schilling , =?UTF-8?q?Alex=20Benn=C3=A9e?= , Joakim Bech , Rob Herring , linux-kernel@vger.kernel.org Subject: [PATCH V4 2/8] rust: Extend OPP bindings for the OPP table Date: Thu, 11 Jul 2024 12:27:44 +0530 Message-Id: X-Mailer: git-send-email 2.31.1.272.g89b43f80a514 In-Reply-To: References: Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" This extends OPP bindings with the bindings for the `struct opp_table`. Signed-off-by: Viresh Kumar --- rust/kernel/opp.rs | 382 ++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 381 insertions(+), 1 deletion(-) diff --git a/rust/kernel/opp.rs b/rust/kernel/opp.rs index dec832edec9b..c3433b0d8221 100644 --- a/rust/kernel/opp.rs +++ b/rust/kernel/opp.rs @@ -8,8 +8,9 @@ =20 use crate::{ bindings, + cpumask::Cpumask, device::Device, - error::{code::*, to_result, Result}, + error::{code::*, from_err_ptr, to_result, Error, Result}, types::{ARef, AlwaysRefCounted, Opaque}, }; =20 @@ -67,6 +68,385 @@ fn freq(&self) -> u64 { } } =20 +/// OPP search types. +#[derive(Copy, Clone, Debug, Eq, PartialEq)] +pub enum SearchType { + /// Search for exact value. + Exact, + /// Search for highest value less than equal to value. + Floor, + /// Search for lowest value greater than equal to value. + Ceil, +} + +/// Operating performance point (OPP) table. +/// +/// Wraps the kernel's `struct opp_table`. +/// +/// The pointer stored in `Self` is non-null and valid for the lifetime of= the `Table`. +pub struct Table { + ptr: *mut bindings::opp_table, + dev: ARef, + em: bool, + of: bool, + cpumask: Option, +} + +// SAFETY: It is okay to send ownership of `Table` across thread boundarie= s. +unsafe impl Send for Table {} + +// SAFETY: It's OK to access `Table` through shared references from other = threads because we're +// either accessing properties that don't change or that are properly sync= hronised by C code. +unsafe impl Sync for Table {} + +impl Table { + /// Creates a new OPP table instance from raw pointer. + /// + /// # Safety + /// + /// Callers must ensure that `ptr` is valid and non-null. + unsafe fn from_raw_table(ptr: *mut bindings::opp_table, dev: &ARef) -> Self { + // SAFETY: By the safety requirements, ptr is valid and its refcou= nt will be incremented. + unsafe { bindings::dev_pm_opp_get_opp_table_ref(ptr) }; + + Self { + ptr, + dev: dev.clone(), + em: false, + of: false, + cpumask: None, + } + } + + /// Find OPP table from device. + pub fn from_dev(dev: &ARef) -> Result { + // SAFETY: The requirements are satisfied by the existence of `Dev= ice` and its safety + // requirements. Refcount of the OPP table is incremented by the C= code. + let ptr =3D from_err_ptr(unsafe { bindings::dev_pm_opp_get_opp_tab= le(dev.as_raw()) })?; + + Ok(Self { + ptr, + dev: dev.clone(), + em: false, + of: false, + cpumask: None, + }) + } + + /// Add device tree based OPP table for the device. + #[cfg(CONFIG_OF)] + pub fn from_of(dev: &ARef, index: i32) -> Result { + // SAFETY: The requirements are satisfied by the existence of `Dev= ice` and its safety + // requirements. Refcount of the OPP table is incremented by the C= code. + to_result(unsafe { bindings::dev_pm_opp_of_add_table_indexed(dev.a= s_raw(), index) })?; + + // Fetch the newly created table. + let mut table =3D Self::from_dev(dev)?; + table.of =3D true; + + Ok(table) + } + + // Remove device tree based OPP table for the device. + #[cfg(CONFIG_OF)] + fn remove_of(&self) { + // SAFETY: The requirements are satisfied by the existence of `Dev= ice` and its safety + // requirements. We took the reference earlier from `from_of` earl= ier, it is safe to drop + // the same now. + unsafe { bindings::dev_pm_opp_of_remove_table(self.dev.as_raw()) }; + } + + /// Add device tree based OPP table for CPU devices. + #[cfg(CONFIG_OF)] + pub fn from_of_cpumask(dev: &ARef, cpumask: &Cpumask) -> Resul= t { + // SAFETY: The cpumask is valid and the returned ptr will be owned= by the [`Table`] instance. + to_result(unsafe { bindings::dev_pm_opp_of_cpumask_add_table(cpuma= sk.as_ptr()) })?; + + // Fetch the newly created table. + let mut table =3D Self::from_dev(dev)?; + + let mut mask =3D Cpumask::new()?; + cpumask.copy(&mut mask); + table.cpumask =3D Some(mask); + + Ok(table) + } + + // Remove device tree based OPP table for CPU devices. + #[cfg(CONFIG_OF)] + fn remove_of_cpumask(&self, cpumask: Cpumask) { + // SAFETY: The cpumask is valid and we took the reference from `fr= om_of_cpumask` earlier, + // it is safe to drop the same now. + unsafe { bindings::dev_pm_opp_of_cpumask_remove_table(cpumask.as_p= tr()) }; + } + + /// Returns the number of OPPs in the table. + pub fn opp_count(&self) -> Result { + // SAFETY: The requirements are satisfied by the existence of `Dev= ice` and its safety + // requirements. + let ret =3D unsafe { bindings::dev_pm_opp_get_opp_count(self.dev.a= s_raw()) }; + if ret < 0 { + Err(Error::from_errno(ret)) + } else { + Ok(ret as u32) + } + } + + /// Returns max clock latency of the OPPs in the table. + pub fn max_clock_latency(&self) -> u64 { + // SAFETY: The requirements are satisfied by the existence of `Dev= ice` and its safety + // requirements. + unsafe { bindings::dev_pm_opp_get_max_clock_latency(self.dev.as_ra= w()) } + } + + /// Returns max volt latency of the OPPs in the table. + pub fn max_volt_latency(&self) -> u64 { + // SAFETY: The requirements are satisfied by the existence of `Dev= ice` and its safety + // requirements. + unsafe { bindings::dev_pm_opp_get_max_volt_latency(self.dev.as_raw= ()) } + } + + /// Returns max transition latency of the OPPs in the table. + pub fn max_transition_latency(&self) -> u64 { + // SAFETY: The requirements are satisfied by the existence of `Dev= ice` and its safety + // requirements. + unsafe { bindings::dev_pm_opp_get_max_transition_latency(self.dev.= as_raw()) } + } + + /// Returns the suspend OPP. + pub fn suspend_freq(&self) -> u64 { + // SAFETY: The requirements are satisfied by the existence of `Dev= ice` and its safety + // requirements. + unsafe { bindings::dev_pm_opp_get_suspend_opp_freq(self.dev.as_raw= ()) } + } + + /// Synchronizes regulators used by the OPP table. + pub fn sync_regulators(&self) -> Result<()> { + // SAFETY: The requirements are satisfied by the existence of `Dev= ice` and its safety + // requirements. + to_result(unsafe { bindings::dev_pm_opp_sync_regulators(self.dev.a= s_raw()) }) + } + + /// Gets sharing CPUs. + pub fn sharing_cpus(dev: &Device, cpumask: &mut Cpumask) -> Result<()>= { + // SAFETY: The requirements are satisfied by the existence of `Dev= ice` and its safety + // requirements. + to_result(unsafe { + bindings::dev_pm_opp_get_sharing_cpus(dev.as_raw(), cpumask.as= _mut_ptr()) + }) + } + + /// Sets sharing CPUs. + pub fn set_sharing_cpus(&mut self, cpumask: &Cpumask) -> Result<()> { + // SAFETY: The requirements are satisfied by the existence of `Dev= ice` and its safety + // requirements. + to_result(unsafe { + bindings::dev_pm_opp_set_sharing_cpus(self.dev.as_raw(), cpuma= sk.as_ptr()) + })?; + + if let Some(mask) =3D self.cpumask.as_mut() { + // Update the cpumask as this will be used while removing the = table. + cpumask.copy(mask); + } + + Ok(()) + } + + /// Gets sharing CPUs from Device tree. + #[cfg(CONFIG_OF)] + pub fn of_sharing_cpus(dev: &Device, cpumask: &mut Cpumask) -> Result<= ()> { + // SAFETY: The requirements are satisfied by the existence of `Dev= ice` and its safety + // requirements. + to_result(unsafe { + bindings::dev_pm_opp_of_get_sharing_cpus(dev.as_raw(), cpumask= .as_mut_ptr()) + }) + } + + /// Updates the voltage value for an OPP. + pub fn adjust_voltage( + &self, + freq: u64, + u_volt: u64, + u_volt_min: u64, + u_volt_max: u64, + ) -> Result<()> { + // SAFETY: The requirements are satisfied by the existence of `Dev= ice` and its safety + // requirements. + to_result(unsafe { + bindings::dev_pm_opp_adjust_voltage( + self.dev.as_raw(), + freq, + u_volt, + u_volt_min, + u_volt_max, + ) + }) + } + + /// Sets a matching OPP based on frequency. + pub fn set_rate(&self, freq: u64) -> Result<()> { + // SAFETY: The requirements are satisfied by the existence of `Dev= ice` and its safety + // requirements. + to_result(unsafe { bindings::dev_pm_opp_set_rate(self.dev.as_raw()= , freq) }) + } + + /// Sets exact OPP. + pub fn set_opp(&self, opp: &OPP) -> Result<()> { + // SAFETY: The requirements are satisfied by the existence of `Dev= ice` and its safety + // requirements. + to_result(unsafe { bindings::dev_pm_opp_set_opp(self.dev.as_raw(),= opp.as_raw()) }) + } + + /// Finds OPP based on frequency. + pub fn opp_from_freq( + &self, + mut freq: u64, + available: Option, + index: Option, + stype: SearchType, + ) -> Result> { + let rdev =3D self.dev.as_raw(); + let index =3D index.unwrap_or(0); + + let ptr =3D from_err_ptr(match stype { + SearchType::Exact =3D> { + if let Some(available) =3D available { + // SAFETY: The requirements are satisfied by the exist= ence of `Device` and + // its safety requirements. The returned ptr will be o= wned by the new [`OPP`] + // instance. + unsafe { + bindings::dev_pm_opp_find_freq_exact_indexed(rdev,= freq, index, available) + } + } else { + return Err(EINVAL); + } + } + + // SAFETY: The requirements are satisfied by the existence of = `Device` and its + // safety requirements. The returned ptr will be owned by the = new [`OPP`] instance. + SearchType::Ceil =3D> unsafe { + bindings::dev_pm_opp_find_freq_ceil_indexed(rdev, &mut fre= q as *mut u64, index) + }, + + // SAFETY: The requirements are satisfied by the existence of = `Device` and its + // safety requirements. The returned ptr will be owned by the = new [`OPP`] instance. + SearchType::Floor =3D> unsafe { + bindings::dev_pm_opp_find_freq_floor_indexed(rdev, &mut fr= eq as *mut u64, index) + }, + })?; + + // SAFETY: The `ptr` is guaranteed by the C code to be valid. + unsafe { OPP::from_raw_opp_owned(ptr) } + } + + /// Finds OPP based on level. + pub fn opp_from_level(&self, mut level: u32, stype: SearchType) -> Res= ult> { + let rdev =3D self.dev.as_raw(); + + let ptr =3D from_err_ptr(match stype { + // SAFETY: The requirements are satisfied by the existence of = `Device` and its + // safety requirements. The returned ptr will be owned by the = new [`OPP`] instance. + SearchType::Exact =3D> unsafe { bindings::dev_pm_opp_find_leve= l_exact(rdev, level) }, + + // SAFETY: The requirements are satisfied by the existence of = `Device` and its + // safety requirements. The returned ptr will be owned by the = new [`OPP`] instance. + SearchType::Ceil =3D> unsafe { + bindings::dev_pm_opp_find_level_ceil(rdev, &mut level as *= mut u32) + }, + + // SAFETY: The requirements are satisfied by the existence of = `Device` and its + // safety requirements. The returned ptr will be owned by the = new [`OPP`] instance. + SearchType::Floor =3D> unsafe { + bindings::dev_pm_opp_find_level_floor(rdev, &mut level as = *mut u32) + }, + })?; + + // SAFETY: The `ptr` is guaranteed by the C code to be valid. + unsafe { OPP::from_raw_opp_owned(ptr) } + } + + /// Finds OPP based on bandwidth. + pub fn opp_from_bw(&self, mut bw: u32, index: i32, stype: SearchType) = -> Result> { + let rdev =3D self.dev.as_raw(); + + let ptr =3D from_err_ptr(match stype { + // The OPP core doesn't support this yet. + SearchType::Exact =3D> return Err(EINVAL), + + // SAFETY: The requirements are satisfied by the existence of = `Device` and its + // safety requirements. The returned ptr will be owned by the = new [`OPP`] instance. + SearchType::Ceil =3D> unsafe { + bindings::dev_pm_opp_find_bw_ceil(rdev, &mut bw as *mut u3= 2, index) + }, + + // SAFETY: The requirements are satisfied by the existence of = `Device` and its + // safety requirements. The returned ptr will be owned by the = new [`OPP`] instance. + SearchType::Floor =3D> unsafe { + bindings::dev_pm_opp_find_bw_floor(rdev, &mut bw as *mut u= 32, index) + }, + })?; + + // SAFETY: The `ptr` is guaranteed by the C code to be valid. + unsafe { OPP::from_raw_opp_owned(ptr) } + } + + /// Enable the OPP. + pub fn enable_opp(&self, freq: u64) -> Result<()> { + // SAFETY: The requirements are satisfied by the existence of `Dev= ice` and its safety + // requirements. + to_result(unsafe { bindings::dev_pm_opp_enable(self.dev.as_raw(), = freq) }) + } + + /// Disable the OPP. + pub fn disable_opp(&self, freq: u64) -> Result<()> { + // SAFETY: The requirements are satisfied by the existence of `Dev= ice` and its safety + // requirements. + to_result(unsafe { bindings::dev_pm_opp_disable(self.dev.as_raw(),= freq) }) + } + + /// Registers with Energy model. + #[cfg(CONFIG_OF)] + pub fn of_register_em(&mut self, cpumask: &mut Cpumask) -> Result<()> { + // SAFETY: The requirements are satisfied by the existence of `Dev= ice` and its safety + // requirements. + to_result(unsafe { + bindings::dev_pm_opp_of_register_em(self.dev.as_raw(), cpumask= .as_mut_ptr()) + })?; + + self.em =3D true; + Ok(()) + } + + // Unregisters with Energy model. + #[cfg(CONFIG_OF)] + fn of_unregister_em(&self) { + // SAFETY: The requirements are satisfied by the existence of `Dev= ice` and its safety + // requirements. We registered with the EM framework earlier, it i= s safe to unregister now. + unsafe { bindings::em_dev_unregister_perf_domain(self.dev.as_raw()= ) }; + } +} + +impl Drop for Table { + fn drop(&mut self) { + // SAFETY: By the type invariants, we know that `self` owns a refe= rence, so it is safe + // to relinquish it now. + unsafe { bindings::dev_pm_opp_put_opp_table(self.ptr) }; + + #[cfg(CONFIG_OF)] + { + if self.em { + self.of_unregister_em(); + } + + if self.of { + self.remove_of(); + } else if let Some(cpumask) =3D self.cpumask.take() { + self.remove_of_cpumask(cpumask); + } + } + } +} + /// Operating performance point (OPP). /// /// Wraps the kernel's `struct dev_pm_opp`. --=20 2.31.1.272.g89b43f80a514 From nobody Sat Feb 7 16:45:35 2026 Received: from mail-pl1-f181.google.com (mail-pl1-f181.google.com [209.85.214.181]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id C76AF1482EE for ; Thu, 11 Jul 2024 06:58:20 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.181 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1720681102; cv=none; b=g1r2XwtFGtPlsrsODlvlMnPNhmcu1pvRjAjgzlu+8eTwVLP7sIyGtLTPazSfio3apVThztf2dfgT7Yu92u1OowpcIsgUWXwtmDUM8R+57iBy8qB+QHXHU6mmQHDUY8Y/fCPi1YOJl2Dx/dwuipRMwqjz06UusRciigy/sTRrMMM= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1720681102; c=relaxed/simple; bh=OzPunyqGE/5TW6uLHohmOvJN9eUza1Duw/uCRtbeQoQ=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=Za9vM6CswOnsaBFkT5OVjFVc47MJZDqWmrHi6Nm+2emhFfjtIPvjlJLr02XdA3DLALAN1LyzjmwXFjxwdqi1+QSwp/y+i/kzavJ+STWQUJHLGG1n+0fAuX8wQMekJD0RWw9m98kNBHOZUlGPvo4nWvhxQH5zgzoEHA2NLUIkTlI= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linaro.org; spf=pass smtp.mailfrom=linaro.org; dkim=pass (2048-bit key) header.d=linaro.org header.i=@linaro.org header.b=Yk4/SsFL; arc=none smtp.client-ip=209.85.214.181 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linaro.org Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=linaro.org Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=linaro.org header.i=@linaro.org header.b="Yk4/SsFL" Received: by mail-pl1-f181.google.com with SMTP id d9443c01a7336-1fb3cf78fbdso3295265ad.1 for ; Wed, 10 Jul 2024 23:58:20 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; t=1720681100; x=1721285900; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=CeU9Cta51JYSW0ONrM7wbRe9y3vgozaJuy5zKjtbdGM=; b=Yk4/SsFLKJQ5zRYMkFeW4vtpgVfLmyVqmSEqhxAjQcQnadP6oOLKlLmKVvS7UfUgkV 7MQz4TDGpL2bdOEgpzL3YqjAC2YapmZkYrA/wY9e+Q7L72/uUpUXgf6JmBU0KannAiNR HbVgJSfFQJhDChV35yTkAKx7eWd0wrJ/7niDG6yZbdMNlLC5FXtiX8mCvE9DXwkUP/m9 xPCBxyYqRheT0tCzX8bzBIhxfih/HoEKtR+48dl46NuR4Rz20F3w6ZFxPrHNWuRKyxVo Nx2wok18M6jQKlIpVacOubXqiFLsNkxGsNCPBBd4zup0ExYwEoEtwJ+/ROsj7VppK8SI ZTig== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1720681100; x=1721285900; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=CeU9Cta51JYSW0ONrM7wbRe9y3vgozaJuy5zKjtbdGM=; b=vjbGdkrc2BQHLcdP9obZ0TuhtVD2j9t3lwXa2jZGK0FPxSQXblmjKSDxKQFokuWWfw 2ERfPz32LvDOv9wqybIKfaAzMBreuX2mutvEAWOPUbaFvc0ikKnN4tQBH0AHGmB+T+f8 CjxyNdEEnpmzKDVv3h0LBmcQQh/oJzWHytYXlSEPoD9NxGBaJP27G8iqh2BWBWj3nGIm A5dmC5wcBzWYDr1vuAj5T8bVikZ6/FBMQtNTCSKXg0pqrsN085EdSmbNlgK4UKAqXN0n q0b+2HE7ibJs/cy9+AW3mXwRkQekkboZl/3g2wWpSvE3loJQmYPsfhnzwiIfVRKDcB9F OWRg== X-Forwarded-Encrypted: i=1; AJvYcCVY4ph8HqdXvcImRzzxjkxWMUsWNdECY6wK1KwpO6ebtcVujueEKCMVmYO0/G9I+nSpt9N5M14HJJgOopCBQo2PfUlzakWwD3pJ/B6Q X-Gm-Message-State: AOJu0YyZhJz5YGoRljiOOoAVb0j+BYJdC97R5sbLSIzDVrCb01cUL2t+ mSP8PaL3676u8SmIvIxm6vh6W0oQiNx5o2eialan1Oy4BUNh51dk5uJqbjA7Q9I= X-Google-Smtp-Source: AGHT+IHZEdzTt16dHu15COpUqNsv8Xsprymp2m3Hb+w/4XobX7E7d/pl5hcnJXj7MKJDGoO2OZI7QQ== X-Received: by 2002:a17:902:f543:b0:1fb:3107:ec45 with SMTP id d9443c01a7336-1fbb6d53607mr66752285ad.54.1720681099602; Wed, 10 Jul 2024 23:58:19 -0700 (PDT) Received: from localhost ([122.172.84.129]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-1fbb6a0fc8csm43840235ad.28.2024.07.10.23.58.18 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 10 Jul 2024 23:58:19 -0700 (PDT) From: Viresh Kumar To: "Rafael J. Wysocki" , Miguel Ojeda , Danilo Krummrich , Miguel Ojeda , Alex Gaynor , Wedson Almeida Filho , Boqun Feng , Gary Guo , =?UTF-8?q?Bj=C3=B6rn=20Roy=20Baron?= , Benno Lossin , Andreas Hindborg , Alice Ryhl Cc: Viresh Kumar , linux-pm@vger.kernel.org, Vincent Guittot , Stephen Boyd , Nishanth Menon , rust-for-linux@vger.kernel.org, Manos Pitsidianakis , Erik Schilling , =?UTF-8?q?Alex=20Benn=C3=A9e?= , Joakim Bech , Rob Herring , linux-kernel@vger.kernel.org Subject: [PATCH V4 3/8] rust: Extend OPP bindings for the configuration options Date: Thu, 11 Jul 2024 12:27:45 +0530 Message-Id: <2695ca39e599bacb82cbd3f621eabfc60138575d.1720680252.git.viresh.kumar@linaro.org> X-Mailer: git-send-email 2.31.1.272.g89b43f80a514 In-Reply-To: References: Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" This extends OPP bindings with the bindings for the OPP core configuration options. Reviewed-by: Manos Pitsidianakis Signed-off-by: Viresh Kumar --- rust/kernel/opp.rs | 301 ++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 299 insertions(+), 2 deletions(-) diff --git a/rust/kernel/opp.rs b/rust/kernel/opp.rs index c3433b0d8221..113652448056 100644 --- a/rust/kernel/opp.rs +++ b/rust/kernel/opp.rs @@ -10,11 +10,28 @@ bindings, cpumask::Cpumask, device::Device, - error::{code::*, from_err_ptr, to_result, Error, Result}, + error::{code::*, from_err_ptr, from_result, to_result, Error, Result, = VTABLE_DEFAULT_ERROR}, + prelude::*, + str::CString, types::{ARef, AlwaysRefCounted, Opaque}, }; =20 -use core::ptr; +use core::{ffi::c_char, marker::PhantomData, ptr}; + +use macros::vtable; + +// Creates a null-terminated slice of pointers to Cstrings. +fn to_c_str_array(names: &[CString]) -> Result> { + // Allocated a null-terminated vector of pointers. + let mut list =3D Vec::with_capacity(names.len() + 1, GFP_KERNEL)?; + + for name in names.iter() { + list.push(name.as_ptr() as _, GFP_KERNEL)?; + } + + list.push(ptr::null(), GFP_KERNEL)?; + Ok(list) +} =20 /// Dynamically created Operating performance point (OPP). pub struct Token { @@ -79,6 +96,286 @@ pub enum SearchType { Ceil, } =20 +/// Implement this trait to provide OPP Configuration callbacks. +#[vtable] +pub trait ConfigOps { + /// Called by the OPP core to configure OPP clks. + fn config_clks(_dev: &Device, _table: &Table, _opp: &OPP, _scaling_dow= n: bool) -> Result<()> { + kernel::build_error(VTABLE_DEFAULT_ERROR) + } + + /// Called by the OPP core to configure OPP regulators. + fn config_regulators( + _dev: &Device, + _opp_old: &OPP, + _opp_new: &OPP, + _data: *mut *mut bindings::regulator, + _count: u32, + ) -> Result<()> { + kernel::build_error(VTABLE_DEFAULT_ERROR) + } +} + +/// Config token returned by the C code. +pub struct ConfigToken(i32); + +impl Drop for ConfigToken { + fn drop(&mut self) { + // SAFETY: Its safe to return the configuration token number previ= ously received from the C + // code. + unsafe { bindings::dev_pm_opp_clear_config(self.0) }; + } +} + +/// Equivalent to `struct dev_pm_opp_config` in the C Code. +#[derive(Default)] +pub struct Config { + clk_names: Option>, + prop_name: Option, + regulator_names: Option>, + genpd_names: Option>, + supported_hw: Option>, + required_devs: Option>>, + _data: PhantomData, +} + +impl Config { + /// Creates a new instance of [`Config`]. + pub fn new() -> Self { + Self { + clk_names: None, + prop_name: None, + regulator_names: None, + genpd_names: None, + supported_hw: None, + required_devs: None, + _data: PhantomData, + } + } + + /// Initializes clock names. + pub fn set_clk_names(mut self, names: Vec) -> Result { + // Already configured. + if self.clk_names.is_some() { + return Err(EBUSY); + } + + if names.is_empty() { + return Err(EINVAL); + } + + self.clk_names =3D Some(names); + Ok(self) + } + + /// Initializes property name. + pub fn set_prop_name(mut self, name: CString) -> Result { + // Already configured. + if self.prop_name.is_some() { + return Err(EBUSY); + } + + self.prop_name =3D Some(name); + Ok(self) + } + + /// Initializes regulator names. + pub fn set_regulator_names(mut self, names: Vec) -> Result { + // Already configured. + if self.regulator_names.is_some() { + return Err(EBUSY); + } + + if names.is_empty() { + return Err(EINVAL); + } + + self.regulator_names =3D Some(names); + + Ok(self) + } + + /// Initializes genpd names. + pub fn set_genpd_names(mut self, names: Vec) -> Result { + // Already configured. Only one of genpd or required devs can be c= onfigured. + if self.genpd_names.is_some() || self.required_devs.is_some() { + return Err(EBUSY); + } + + if names.is_empty() { + return Err(EINVAL); + } + + self.genpd_names =3D Some(names); + Ok(self) + } + + /// Initializes required devices. + pub fn set_required_devs(mut self, devs: Vec>) -> Result<= Self> { + // Already configured. Only one of genpd or required devs can be c= onfigured. + if self.genpd_names.is_some() || self.required_devs.is_some() { + return Err(EBUSY); + } + + if devs.is_empty() { + return Err(EINVAL); + } + + self.required_devs =3D Some(devs); + Ok(self) + } + + /// Initializes supported hardware. + pub fn set_supported_hw(mut self, hw: Vec) -> Result { + // Already configured. + if self.supported_hw.is_some() { + return Err(EBUSY); + } + + if hw.is_empty() { + return Err(EINVAL); + } + + self.supported_hw =3D Some(hw); + Ok(self) + } + + /// Sets the configuration with the OPP core. + pub fn set(self, dev: &Device) -> Result { + let (_clk_list, clk_names) =3D match &self.clk_names { + Some(x) =3D> { + let list =3D to_c_str_array(x)?; + let ptr =3D list.as_ptr(); + (Some(list), ptr) + } + None =3D> (None, ptr::null()), + }; + + let (_regulator_list, regulator_names) =3D match &self.regulator_n= ames { + Some(x) =3D> { + let list =3D to_c_str_array(x)?; + let ptr =3D list.as_ptr(); + (Some(list), ptr) + } + None =3D> (None, ptr::null()), + }; + + let (_genpd_list, genpd_names) =3D match &self.genpd_names { + Some(x) =3D> { + let list =3D to_c_str_array(x)?; + let ptr =3D list.as_ptr(); + (Some(list), ptr) + } + None =3D> (None, ptr::null()), + }; + + let prop_name =3D match &self.prop_name { + Some(x) =3D> x.as_char_ptr(), + None =3D> ptr::null(), + }; + + let (supported_hw, supported_hw_count) =3D match &self.supported_h= w { + Some(x) =3D> (x.as_ptr(), x.len() as u32), + None =3D> (ptr::null(), 0), + }; + + let (_required_devs_list, required_devs) =3D match &self.required_= devs { + Some(x) =3D> { + // Create a non-NULL-terminated vectorof pointers. + let mut list =3D Vec::with_capacity(x.len(), GFP_KERNEL)?; + + for dev in x.iter() { + list.push(dev.as_raw(), GFP_KERNEL)?; + } + + let ptr =3D list.as_mut_ptr(); + (Some(list), ptr) + } + None =3D> (None, ptr::null_mut()), + }; + + let mut config =3D bindings::dev_pm_opp_config { + clk_names, + config_clks: if T::HAS_CONFIG_CLKS { + Some(Self::config_clks) + } else { + None + }, + prop_name, + regulator_names, + config_regulators: if T::HAS_CONFIG_REGULATORS { + Some(Self::config_regulators) + } else { + None + }, + genpd_names, + supported_hw, + supported_hw_count, + + // Don't need to support virt_devs for now. + virt_devs: ptr::null_mut(), + required_devs, + }; + + // SAFETY: The requirements are satisfied by the existence of `Dev= ice` and its safety + // requirements. The OPP core guarantees to not use fields of `con= fig`, after this call has + // returned and so we don't need to save a copy of them for future= use + let ret =3D unsafe { bindings::dev_pm_opp_set_config(dev.as_raw(),= &mut config) }; + if ret < 0 { + Err(Error::from_errno(ret)) + } else { + Ok(ConfigToken(ret)) + } + } + + // Config's config_clks callback. + extern "C" fn config_clks( + dev: *mut bindings::device, + opp_table: *mut bindings::opp_table, + opp: *mut bindings::dev_pm_opp, + _data: *mut core::ffi::c_void, + scaling_down: bool, + ) -> core::ffi::c_int { + from_result(|| { + // SAFETY: 'dev' is guaranteed by the C code to be valid. + let dev =3D unsafe { Device::from_raw(dev) }; + T::config_clks( + &dev, + // SAFETY: 'opp_table' is guaranteed by the C code to be v= alid. + &unsafe { Table::from_raw_table(opp_table, &dev) }, + // SAFETY: 'opp' is guaranteed by the C code to be valid. + unsafe { OPP::from_raw_opp(opp)? }, + scaling_down, + ) + .map(|_| 0) + }) + } + + // Config's config_regulators callback. + extern "C" fn config_regulators( + dev: *mut bindings::device, + old_opp: *mut bindings::dev_pm_opp, + new_opp: *mut bindings::dev_pm_opp, + regulators: *mut *mut bindings::regulator, + count: core::ffi::c_uint, + ) -> core::ffi::c_int { + from_result(|| { + // SAFETY: 'dev' is guaranteed by the C code to be valid. + let dev =3D unsafe { Device::from_raw(dev) }; + T::config_regulators( + &dev, + // SAFETY: 'old_opp' is guaranteed by the C code to be val= id. + unsafe { OPP::from_raw_opp(old_opp)? }, + // SAFETY: 'new_opp' is guaranteed by the C code to be val= id. + unsafe { OPP::from_raw_opp(new_opp)? }, + regulators, + count, + ) + .map(|_| 0) + }) + } +} + /// Operating performance point (OPP) table. /// /// Wraps the kernel's `struct opp_table`. --=20 2.31.1.272.g89b43f80a514 From nobody Sat Feb 7 16:45:35 2026 Received: from mail-pg1-f169.google.com (mail-pg1-f169.google.com [209.85.215.169]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id EE55714A0B2 for ; Thu, 11 Jul 2024 06:58:24 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.215.169 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1720681108; cv=none; b=qNrk8FGS1ycsaH+WDB5vImzRmbipfY58eHMjVS+Me1Ai6TCXcFN1YuJWXauWMSJH3tGi5Szj3vQeGGgbYOheml1hzeZ+TXaPeetm5YNvgXuu+Qxq6yzkll9ahx8a5w4HNtdyPH/wZCPd+hoD1p10BomY3klEbEdLwVF9/bL5FOM= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1720681108; c=relaxed/simple; bh=Y+CcW8VkySrWCeYFH3Y4/OOUgO02IDdYByumnU6s9tQ=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=ezx6GSEf+vOwQcduLB0lAHxW/TGEhzHNklwbEA9kMZItKpfFht1I+eBO8Y9qaIdnMpTUFnXA+MTzshvqacGD+Zi7WmcaTyz76vlui4XuoskUaDyv4KtGJQesrFnvuv4jyaL2Bz6Wsxk+LZVK4Cpi4J9+SHycgTuultui9dHr1yc= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linaro.org; spf=pass smtp.mailfrom=linaro.org; dkim=pass (2048-bit key) header.d=linaro.org header.i=@linaro.org header.b=Ad069gJ4; arc=none smtp.client-ip=209.85.215.169 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linaro.org Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=linaro.org Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=linaro.org header.i=@linaro.org header.b="Ad069gJ4" Received: by mail-pg1-f169.google.com with SMTP id 41be03b00d2f7-75e7e110e89so320508a12.3 for ; Wed, 10 Jul 2024 23:58:24 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; t=1720681104; x=1721285904; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=XlmPvg7UbbQVkoa9GlcypOu0EN89b3fXwDNHPf9Otng=; b=Ad069gJ4ZOCmpwrIx5d010ZURuQ+JGiZsm/gQ0utmmiSryLIScmYcUJ7f8vkMO42LH dkWxh4mUh6iz4VaTpLL5qKx4Q7oCVce6lunUP0DFqK8nEySRIdl5Su3d5ktsjhsVYpxl DwgEgvyZPAzFX1KhpY3XQpvglooICbwCJv9RVhKHq99mxYgf5JPlelGoWFxDJ4izaqfZ c3iu/ri8u2nfem78zrRFi4kpI3JkCG47pfndb1ih9IG9hsMtwEX9fzDpeg4ZGCxcTttY W2BC+jY38lnQrKmHyem8UJM7nzET+5FhPrwFdq9kbBOFGrjOqHXcWA0Njx68EfiTF6gP YwPg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1720681104; x=1721285904; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=XlmPvg7UbbQVkoa9GlcypOu0EN89b3fXwDNHPf9Otng=; b=GWLHntjrxJrVipJFA8IATsQuQAAr7D8a6whDJdYx5t8uyektbUrf7pabsi90iNl9Fk o1s0GdXhH54SPVn9fSj2bZfHWg46+JjvRc9Rf2TTV5nqBawPvLNUBVh4iXSaAmRNPP6m zlniW36VeCbFrXytSbWReMj9vMnYp6k8qE17qQ8JcoRxlhZSfcM/501LqIUP5vEKnhO1 iLggLK94YF7vXGXQqopT3TDl9B3qvlowX1shtILpZW3ilkV19WWEwGd4ew8qTFpADxJe 3SUaEcTD0RcshOvh4pag9YbTuquwNSFwyS7rVEZRsqL4NFBmCzORRiD1Yj5RZGIOPlBi yY+Q== X-Forwarded-Encrypted: i=1; AJvYcCX2PyCLkPcQrgoCoNhGaGJtVh5O8H4IlQJ+X1jCmEkG70+rGI8uIEIloLVh+OjMtEo1Fk34sgzJnGAQjIlo2wS8maOCVHNZCmCXAwQP X-Gm-Message-State: AOJu0YzN1kes4wee5RwoTw2THT/VcXNfUcrObcIEvBEAR10xawYhJdCl JaixriLJYxKroG/l+6ZxJ4uok3z6X7e0qOZDS4Y3kpJYGadYHcBhVKGLDqQLF20= X-Google-Smtp-Source: AGHT+IEaulusM8P0aqHRcGQqtblTAm4gJQqQFaFQVG8i4yy1LwpiVx/RKwjPdInM+ZAnXvkSSADZ8Q== X-Received: by 2002:a05:6a21:6704:b0:1c0:f080:ed5b with SMTP id adf61e73a8af0-1c2984ce612mr7825635637.54.1720681104233; Wed, 10 Jul 2024 23:58:24 -0700 (PDT) Received: from localhost ([122.172.84.129]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-1fbb6a2b2b0sm43713635ad.84.2024.07.10.23.58.23 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 10 Jul 2024 23:58:23 -0700 (PDT) From: Viresh Kumar To: "Rafael J. Wysocki" , Miguel Ojeda , Danilo Krummrich , Miguel Ojeda , Alex Gaynor , Wedson Almeida Filho , Boqun Feng , Gary Guo , =?UTF-8?q?Bj=C3=B6rn=20Roy=20Baron?= , Benno Lossin , Andreas Hindborg , Alice Ryhl Cc: Viresh Kumar , linux-pm@vger.kernel.org, Vincent Guittot , Stephen Boyd , Nishanth Menon , rust-for-linux@vger.kernel.org, Manos Pitsidianakis , Erik Schilling , =?UTF-8?q?Alex=20Benn=C3=A9e?= , Joakim Bech , Rob Herring , linux-kernel@vger.kernel.org Subject: [PATCH V4 4/8] rust: Add initial bindings for cpufreq framework Date: Thu, 11 Jul 2024 12:27:46 +0530 Message-Id: <1774628922bfd29a9b7248d1995189db6bfdd87d.1720680252.git.viresh.kumar@linaro.org> X-Mailer: git-send-email 2.31.1.272.g89b43f80a514 In-Reply-To: References: Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" This commit adds initial Rust bindings for the cpufreq core. This adds basic bindings for cpufreq flags, relations and cpufreq table. Reviewed-by: Manos Pitsidianakis Signed-off-by: Viresh Kumar --- rust/bindings/bindings_helper.h | 1 + rust/helpers.c | 15 ++ rust/kernel/cpufreq.rs | 254 ++++++++++++++++++++++++++++++++ rust/kernel/lib.rs | 2 + 4 files changed, 272 insertions(+) create mode 100644 rust/kernel/cpufreq.rs diff --git a/rust/bindings/bindings_helper.h b/rust/bindings/bindings_helpe= r.h index 1bf8e053c8f4..bee2b6013690 100644 --- a/rust/bindings/bindings_helper.h +++ b/rust/bindings/bindings_helper.h @@ -7,6 +7,7 @@ */ =20 #include +#include #include #include #include diff --git a/rust/helpers.c b/rust/helpers.c index 7a15d0ebe49b..3b2850a11859 100644 --- a/rust/helpers.c +++ b/rust/helpers.c @@ -24,6 +24,7 @@ #include #include #include +#include #include #include #include @@ -357,6 +358,20 @@ void rust_helper_free_cpumask_var(cpumask_var_t mask) EXPORT_SYMBOL_GPL(rust_helper_free_cpumask_var); #endif =20 +#ifdef CONFIG_CPU_FREQ +unsigned int rust_helper_cpufreq_table_len(struct cpufreq_frequency_table = *freq_table) +{ + return cpufreq_table_len(freq_table); +} +EXPORT_SYMBOL_GPL(rust_helper_cpufreq_table_len); + +void rust_helper_cpufreq_register_em_with_opp(struct cpufreq_policy *polic= y) +{ + cpufreq_register_em_with_opp(policy); +} +EXPORT_SYMBOL_GPL(rust_helper_cpufreq_register_em_with_opp); +#endif + #ifndef CONFIG_OF_DYNAMIC struct device_node *rust_helper_of_node_get(struct device_node *node) { diff --git a/rust/kernel/cpufreq.rs b/rust/kernel/cpufreq.rs new file mode 100644 index 000000000000..0751ad9459e2 --- /dev/null +++ b/rust/kernel/cpufreq.rs @@ -0,0 +1,254 @@ +// SPDX-License-Identifier: GPL-2.0 + +//! CPU frequency scaling. +//! +//! This module provides bindings for interacting with the cpufreq subsyst= em. +//! +//! C header: [`include/linux/cpufreq.h`](srctree/include/linux/cpufreq.h) + +use crate::{ + bindings, + error::{code::*, to_result, Result}, + prelude::*, +}; + +use core::{ + pin::Pin, +}; + +/// Default transition latency value. +pub const ETERNAL_LATENCY: u32 =3D bindings::CPUFREQ_ETERNAL as u32; + +/// Container for cpufreq driver flags. +pub mod flags { + use crate::bindings; + + /// Set by drivers that need to update internal upper and lower bounda= ries along with the + /// target frequency and so the core and governors should also invoke = the driver if the target + /// frequency does not change, but the policy min or max may have chan= ged. + pub const NEED_UPDATE_LIMITS: u16 =3D bindings::CPUFREQ_NEED_UPDATE_LI= MITS as _; + + /// Set by drivers for platforms where loops_per_jiffy or other kernel= "constants" aren't + /// affected by frequency transitions. + pub const CONST_LOOPS: u16 =3D bindings::CPUFREQ_CONST_LOOPS as _; + + /// Set by drivers that want the core to automatically register the cp= ufreq driver as a thermal + /// cooling device. + pub const IS_COOLING_DEV: u16 =3D bindings::CPUFREQ_IS_COOLING_DEV as = _; + + /// Set by drivers for platforms that have multiple clock-domains, i.e= . supporting multiple + /// policies. With this sysfs directories of governor would be created= in cpu/cpuN/cpufreq/ + /// directory and so they can use the same governor with different tun= ables for different + /// clusters. + pub const HAVE_GOVERNOR_PER_POLICY: u16 =3D bindings::CPUFREQ_HAVE_GOV= ERNOR_PER_POLICY as _; + + /// Set by drivers which do POSTCHANGE notifications from outside of t= heir ->target() routine. + pub const ASYNC_NOTIFICATION: u16 =3D bindings::CPUFREQ_ASYNC_NOTIFICA= TION as _; + + /// Set by drivers that want cpufreq core to check if CPU is running a= t a frequency present in + /// freq-table exposed by the driver. For these drivers if CPU is foun= d running at an out of + /// table freq, the cpufreq core will try to change the frequency to a= value from the table. + /// And if that fails, it will stop further boot process by issuing a = BUG_ON(). + pub const NEED_INITIAL_FREQ_CHECK: u16 =3D bindings::CPUFREQ_NEED_INIT= IAL_FREQ_CHECK as _; + + /// Set by drivers to disallow use of governors with "dynamic_switchin= g" flag set. + pub const NO_AUTO_DYNAMIC_SWITCHING: u16 =3D bindings::CPUFREQ_NO_AUTO= _DYNAMIC_SWITCHING as _; +} + +/// CPU frequency selection relations. Each value contains a `bool` argume= nt which corresponds to +/// the Relation being efficient. +#[derive(Copy, Clone, Debug, Eq, PartialEq)] +pub enum Relation { + /// Select the lowest frequency at or above target. + Low(bool), + /// Select the highest frequency below or at target. + High(bool), + /// Select the closest frequency to the target. + Close(bool), +} + +impl Relation { + // Converts from a value compatible with the C code. + fn new(val: u32) -> Result { + let efficient =3D val & bindings::CPUFREQ_RELATION_E !=3D 0; + + Ok(match val & !bindings::CPUFREQ_RELATION_E { + bindings::CPUFREQ_RELATION_L =3D> Self::Low(efficient), + bindings::CPUFREQ_RELATION_H =3D> Self::High(efficient), + bindings::CPUFREQ_RELATION_C =3D> Self::Close(efficient), + _ =3D> return Err(EINVAL), + }) + } + + /// Converts to a value compatible with the C code. + pub fn val(&self) -> u32 { + let (mut val, e) =3D match self { + Self::Low(e) =3D> (bindings::CPUFREQ_RELATION_L, e), + Self::High(e) =3D> (bindings::CPUFREQ_RELATION_H, e), + Self::Close(e) =3D> (bindings::CPUFREQ_RELATION_C, e), + }; + + if *e { + val |=3D bindings::CPUFREQ_RELATION_E; + } + + val + } +} + +/// Equivalent to `struct cpufreq_policy_data` in the C code. +#[repr(transparent)] +pub struct PolicyData(*mut bindings::cpufreq_policy_data); + +impl PolicyData { + /// Creates new instance of [`PolicyData`]. + /// + /// # Safety + /// + /// Callers must ensure that `ptr` is valid and non-null. + pub unsafe fn from_raw_policy_data(ptr: *mut bindings::cpufreq_policy_= data) -> Self { + Self(ptr) + } + + /// Returns the raw pointer to the C structure. + #[inline] + pub fn as_raw(&self) -> *mut bindings::cpufreq_policy_data { + self.0 + } + + /// Provides a wrapper to the generic verify routine. + pub fn generic_verify(&self) -> Result<()> { + // SAFETY: By the type invariants, we know that `self` owns a refe= rence, so it is safe to + // use it now. + to_result(unsafe { bindings::cpufreq_generic_frequency_table_verif= y(self.as_raw()) }) + } +} + +/// Builder for the `struct cpufreq_frequency_table` in the C code. +#[repr(transparent)] +#[derive(Default)] +pub struct TableBuilder { + entries: Vec, +} + +impl TableBuilder { + /// Creates new instance of [`TableBuilder`]. + pub fn new() -> Self { + Self { + entries: Vec::new(), + } + } + + /// Adds a new entry to the table. + pub fn add(&mut self, frequency: u32, flags: u32, driver_data: u32) ->= Result<()> { + // Adds new entry to the end of the vector. + Ok(self.entries.push( + bindings::cpufreq_frequency_table { + flags, + driver_data, + frequency, + }, + GFP_KERNEL, + )?) + } + + /// Creates [`Table`] from [`TableBuilder`]. + pub fn into_table(mut self) -> Result { + // Add last entry to the table. + self.add(bindings::CPUFREQ_TABLE_END as u32, 0, 0)?; + Table::from_builder(self.entries) + } +} + +/// A simple implementation of the cpufreq table, equivalent to the `struct +/// cpufreq_frequency_table` in the C code. +pub struct Table { + #[allow(dead_code)] + // Dynamically created table. + entries: Option>>, + + // Pointer to the statically or dynamically created table. + ptr: *mut bindings::cpufreq_frequency_table, + + // Number of entries in the table. + len: usize, +} + +impl Table { + /// Creates new instance of [`Table`] from [`TableBuilder`]. + fn from_builder(entries: Vec) -> Re= sult { + let len =3D entries.len(); + if len =3D=3D 0 { + return Err(EINVAL); + } + + // Pin the entries to memory, since we are passing its pointer to = the C code. + let mut entries =3D Pin::new(entries); + + // The pointer is valid until the table gets dropped. + let ptr =3D entries.as_mut_ptr(); + + Ok(Self { + entries: Some(entries), + ptr, + // The last entry in table is reserved for `CPUFREQ_TABLE_END`. + len: len - 1, + }) + } + + /// Creates new instance of [`Table`] from raw pointer. + /// + /// # Safety + /// + /// Callers must ensure that `ptr` is valid and non-null for the lifet= ime of the [`Table`]. + pub unsafe fn from_raw(ptr: *mut bindings::cpufreq_frequency_table) ->= Self { + Self { + entries: None, + ptr, + // SAFETY: The pointer is guaranteed to be valid for the lifet= ime of `Self`. + len: unsafe { bindings::cpufreq_table_len(ptr) } as usize, + } + } + + // Validate the index. + fn validate(&self, index: usize) -> Result<()> { + if index >=3D self.len { + Err(EINVAL) + } else { + Ok(()) + } + } + + /// Returns raw pointer to the `struct cpufreq_frequency_table` compat= ible with the C code. + #[inline] + pub fn as_raw(&self) -> *mut bindings::cpufreq_frequency_table { + self.ptr + } + + /// Returns `frequency` at index in the [`Table`]. + pub fn freq(&self, index: usize) -> Result { + self.validate(index)?; + + // SAFETY: The pointer is guaranteed to be valid for the lifetime = of `self` and `index` is + // also validated before this and is guaranteed to be within limit= s of the frequency table. + Ok(unsafe { (*self.ptr.add(index)).frequency }) + } + + /// Returns `flags` at index in the [`Table`]. + pub fn flags(&self, index: usize) -> Result { + self.validate(index)?; + + // SAFETY: The pointer is guaranteed to be valid for the lifetime = of `self` and `index` is + // also validated before this and is guaranteed to be within limit= s of the frequency table. + Ok(unsafe { (*self.ptr.add(index)).flags }) + } + + /// Returns `data` at index in the [`Table`]. + pub fn data(&self, index: usize) -> Result { + self.validate(index)?; + + // SAFETY: The pointer is guaranteed to be valid for the lifetime = of `self` and `index` is + // also validated before this and is guaranteed to be within limit= s of the frequency table. + Ok(unsafe { (*self.ptr.add(index)).driver_data }) + } +} diff --git a/rust/kernel/lib.rs b/rust/kernel/lib.rs index e309d7774cbd..77348fc33803 100644 --- a/rust/kernel/lib.rs +++ b/rust/kernel/lib.rs @@ -30,6 +30,8 @@ pub mod alloc; mod build_assert; pub mod clk; +#[cfg(CONFIG_CPU_FREQ)] +pub mod cpufreq; pub mod cpumask; pub mod device; pub mod device_id; --=20 2.31.1.272.g89b43f80a514 From nobody Sat Feb 7 16:45:35 2026 Received: from mail-pg1-f176.google.com (mail-pg1-f176.google.com [209.85.215.176]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id F0E4B14B94B for ; Thu, 11 Jul 2024 06:58:28 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.215.176 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1720681111; cv=none; b=MjoGXde9zt/AmgInK87eaEn20mU+yjVHh7219FlgbqNHUbwBGTx8DpAFnACs/B8B/7tQV3IhOVNHRGnT7DHu8Z0o81hfOFeMiv5Nz5Eh71JJ5KPAyMzfvGcYIodyFK3ETpGYO6q8X5ER1HUM1kTHRvzE6JgYCYl0gmLGwHUVo5c= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1720681111; c=relaxed/simple; bh=JrIqdLXOKsgLnmkFZ98ZZ7V7b3MO61ztZBHVJHMyFBk=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=dNzfw92y+3QgrVMWqkL+KBy7dBu1fO1zDtYAjnCqIyF+altyY1FX7KCwTxpxZgiyL4zLbeOFEnXgV4TXAZjMWX99wIUHDiWEQfIzUjMYlQEhM8VV2dczjHoRoYsDgmwB7JYBS3DutHAMYFzEd7ymMNiJ4ndmWteJ0NdDReqGZO4= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linaro.org; spf=pass smtp.mailfrom=linaro.org; dkim=pass (2048-bit key) header.d=linaro.org header.i=@linaro.org header.b=xmbM0NZU; arc=none smtp.client-ip=209.85.215.176 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linaro.org Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=linaro.org Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=linaro.org header.i=@linaro.org header.b="xmbM0NZU" Received: by mail-pg1-f176.google.com with SMTP id 41be03b00d2f7-7611b6a617cso375217a12.3 for ; Wed, 10 Jul 2024 23:58:28 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; t=1720681108; x=1721285908; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=ZiAYeNUaYtfs4MtrCjwt6UV709MtWKglHtY8sLRknhk=; b=xmbM0NZUFwLqBXjpqYZ1Z+QUBZTFU9z/nXv5W0xqxQgVYptcY9Wz1UoF7C6QBd0Bip Dlg3A9OjLfSWhBLTRJ8Ivt+5SnaFD+0bILYPet/2K8WmPUhTnAFjPp8CnN31CXxwdvNX e8SAX24c9SMzUSps9SA+T4E4qIyuvaOB3k7UrKpBJrdqzhM2v/hc85aXNYSQCUPtITg9 vmf44tNwmHSwmebCerS+3LHBgzMpXDYcwef0PSh4b0Geiz5Y1Cp0QtjkQziPzKJu+LXY wTGPEvlMit1q43JuFpLk50clvIDsOQgLn/7581DVBYnhx0YP4fcWTTofhu790+r7lnaZ MFig== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1720681108; x=1721285908; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=ZiAYeNUaYtfs4MtrCjwt6UV709MtWKglHtY8sLRknhk=; b=Czk+2hXtxRY0l3wer37C6Bg2gcKEm7WoVTnCUkNUZaCXY7MnP58UEamVPy+MwILnM6 lDFshqAvNqIoRDTrOPOI/oPzeU699L/YjjzPnvuL/F9vEQL+0pOfRJy/4PR9tbsTpZgg wVYZG3cS3TnYY3PdvoVxSUsMbKMRTT2fJYoVzLWwuViymgFoAbHphXtCbeCAVj49kx+Z 8jGmLijlmjZea01yI5fmjkxCS6uOEgqDXaOMBysWys65XVffwL/3cmE0exNO8lz8IocW kAZ5fZUPNP641sC23lMmcRh1N+jfq+eiNagdxy9rRSmh9OAqJ7I3pzIe3Cu7RzcEqZTw B7og== X-Forwarded-Encrypted: i=1; AJvYcCVmcvGj2Z53tq3WJZLMNVfV5MWU22eylu41YoeTpgc/G2Pif2yN6o0VGYZo3eJ/wihX1h1+udltIshImXF6ccle67VX8R1JT6088TBX X-Gm-Message-State: AOJu0Yw+EM40nU2DdpWQO9i1z1QTAWLJOnNkDXXnPnt02FGYYdYAucVC iM2WbeXZkgc1tm+gCZ/0WDTLbXIqM61cQLoT3NqBVVuzRCC1vlJlLFmsj5eoppM= X-Google-Smtp-Source: AGHT+IGyIRYjO/gSAliNDMNBXwcTDvV2dox339uL39zwuoaE2IC1RCwYO7LuDSAzZotCrQ844Oy7og== X-Received: by 2002:a05:6a20:7347:b0:1c0:ee1a:da2d with SMTP id adf61e73a8af0-1c2984cd9demr9242278637.41.1720681108145; Wed, 10 Jul 2024 23:58:28 -0700 (PDT) Received: from localhost ([122.172.84.129]) by smtp.gmail.com with ESMTPSA id 98e67ed59e1d1-2c99a98395csm13003570a91.29.2024.07.10.23.58.27 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 10 Jul 2024 23:58:27 -0700 (PDT) From: Viresh Kumar To: "Rafael J. Wysocki" , Miguel Ojeda , Danilo Krummrich , Miguel Ojeda , Alex Gaynor , Wedson Almeida Filho , Boqun Feng , Gary Guo , =?UTF-8?q?Bj=C3=B6rn=20Roy=20Baron?= , Benno Lossin , Andreas Hindborg , Alice Ryhl Cc: Viresh Kumar , linux-pm@vger.kernel.org, Vincent Guittot , Stephen Boyd , Nishanth Menon , rust-for-linux@vger.kernel.org, Manos Pitsidianakis , Erik Schilling , =?UTF-8?q?Alex=20Benn=C3=A9e?= , Joakim Bech , Rob Herring , linux-kernel@vger.kernel.org Subject: [PATCH V4 5/8] rust: Extend cpufreq bindings for policy and driver ops Date: Thu, 11 Jul 2024 12:27:47 +0530 Message-Id: <69353708ff40bf46f0609447187aeb180f00aeb8.1720680252.git.viresh.kumar@linaro.org> X-Mailer: git-send-email 2.31.1.272.g89b43f80a514 In-Reply-To: References: Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" This extends the cpufreq bindings with bindings for cpufreq policy and driver operations. Signed-off-by: Viresh Kumar --- rust/kernel/cpufreq.rs | 315 ++++++++++++++++++++++++++++++++++++++++- 1 file changed, 313 insertions(+), 2 deletions(-) diff --git a/rust/kernel/cpufreq.rs b/rust/kernel/cpufreq.rs index 0751ad9459e2..d58bb0bbaad4 100644 --- a/rust/kernel/cpufreq.rs +++ b/rust/kernel/cpufreq.rs @@ -7,15 +7,20 @@ //! C header: [`include/linux/cpufreq.h`](srctree/include/linux/cpufreq.h) =20 use crate::{ - bindings, - error::{code::*, to_result, Result}, + bindings, clk, cpumask, + device::Device, + error::{code::*, from_err_ptr, to_result, Result, VTABLE_DEFAULT_ERROR= }, prelude::*, + types::ForeignOwnable, }; =20 use core::{ pin::Pin, + ptr::self, }; =20 +use macros::vtable; + /// Default transition latency value. pub const ETERNAL_LATENCY: u32 =3D bindings::CPUFREQ_ETERNAL as u32; =20 @@ -252,3 +257,309 @@ pub fn data(&self, index: usize) -> Result { Ok(unsafe { (*self.ptr.add(index)).driver_data }) } } + +/// Equivalent to `struct cpufreq_policy` in the C code. +pub struct Policy { + ptr: *mut bindings::cpufreq_policy, + put_cpu: bool, + cpumask: cpumask::Cpumask, +} + +impl Policy { + /// Creates a new instance of [`Policy`]. + /// + /// # Safety + /// + /// Callers must ensure that `ptr` is valid and non-null. + pub unsafe fn from_raw_policy(ptr: *mut bindings::cpufreq_policy) -> S= elf { + Self { + ptr, + put_cpu: false, + // SAFETY: The pointer is guaranteed to be valid for the lifet= ime of `Self`. The `cpus` + // pointer is guaranteed to be valid by the C code. + cpumask: unsafe { cpumask::Cpumask::from_raw((*ptr).cpus) }, + } + } + + fn from_cpu(cpu: u32) -> Result { + // SAFETY: It is safe to call `cpufreq_cpu_get()` for any CPU. + let ptr =3D from_err_ptr(unsafe { bindings::cpufreq_cpu_get(cpu) }= )?; + + // SAFETY: The pointer is guaranteed to be valid by the C code. + let mut policy =3D unsafe { Policy::from_raw_policy(ptr) }; + policy.put_cpu =3D true; + Ok(policy) + } + + /// Raw pointer to the underlying cpufreq policy. + #[inline] + pub fn as_raw(&self) -> *mut bindings::cpufreq_policy { + self.ptr + } + + fn as_ref(&self) -> &bindings::cpufreq_policy { + // SAFETY: By the type invariants, we know that `self` owns a refe= rence to the pointer. + unsafe { &(*self.ptr) } + } + fn as_mut_ref(&mut self) -> &mut bindings::cpufreq_policy { + // SAFETY: By the type invariants, we know that `self` owns a refe= rence to the pointer. + unsafe { &mut (*self.ptr) } + } + + /// Returns the primary CPU for a cpufreq policy. + pub fn cpu(&self) -> u32 { + self.as_ref().cpu + } + + /// Returns the minimum frequency for a cpufreq policy. + pub fn min(&self) -> u32 { + self.as_ref().min + } + + /// Returns the maximum frequency for a cpufreq policy. + pub fn max(&self) -> u32 { + self.as_ref().max + } + + /// Returns the current frequency for a cpufreq policy. + pub fn cur(&self) -> u32 { + self.as_ref().cur + } + + /// Sets the suspend frequency for a cpufreq policy. + pub fn set_suspend_freq(&mut self, freq: u32) -> &mut Self { + self.as_mut_ref().suspend_freq =3D freq; + self + } + + /// Returns the suspend frequency for a cpufreq policy. + pub fn suspend_freq(&self) -> u32 { + self.as_ref().suspend_freq + } + + /// Provides a wrapper to the generic suspend routine. + pub fn generic_suspend(&self) -> Result<()> { + // SAFETY: By the type invariants, we know that `self` owns a refe= rence, so it is safe to + // use it now. + to_result(unsafe { bindings::cpufreq_generic_suspend(self.as_raw()= ) }) + } + + /// Provides a wrapper to the generic get routine. + pub fn generic_get(&self) -> Result { + // SAFETY: By the type invariants, we know that `self` owns a refe= rence, so it is safe to + // use it now. + Ok(unsafe { bindings::cpufreq_generic_get(self.cpu()) }) + } + + /// Provides a wrapper to the register em with OPP routine. + pub fn register_em_opp(&self) { + // SAFETY: By the type invariants, we know that `self` owns a refe= rence, so it is safe to + // use it now. + unsafe { bindings::cpufreq_register_em_with_opp(self.as_raw()) }; + } + + /// Gets raw pointer to cpufreq policy's CPUs mask. + pub fn cpus(&mut self) -> &mut cpumask::Cpumask { + &mut self.cpumask + } + + /// Sets clock for a cpufreq policy. + pub fn set_clk(&mut self, dev: &Device, name: Option<&CStr>) -> Result= { + let clk =3D clk::Clk::new(dev, name)?; + self.as_mut_ref().clk =3D clk.as_raw(); + Ok(clk) + } + + /// Allows frequency switching code to run on any CPU. + pub fn set_dvfs_possible_from_any_cpu(&mut self) -> &mut Self { + self.as_mut_ref().dvfs_possible_from_any_cpu =3D true; + self + } + + /// Sets transition latency for a cpufreq policy. + pub fn set_transition_latency(&mut self, latency: u32) -> &mut Self { + self.as_mut_ref().cpuinfo.transition_latency =3D latency; + self + } + + /// Returns the cpufreq table for a cpufreq policy. The cpufreq table = is recreated in a + /// light-weight manner from the raw pointer. The table in C code is n= ot freed once this table + /// is dropped. + pub fn freq_table(&self) -> Result
{ + if self.as_ref().freq_table.is_null() { + return Err(EINVAL); + } + + // SAFETY: The `freq_table` is guaranteed to be valid. + Ok(unsafe { Table::from_raw(self.as_ref().freq_table) }) + } + + /// Sets the cpufreq table for a cpufreq policy. + /// + /// The cpufreq driver must guarantee that the frequency table does no= t get freed while it is + /// still being used by the C code. + pub fn set_freq_table(&mut self, table: &Table) -> &mut Self { + self.as_mut_ref().freq_table =3D table.as_raw(); + self + } + + /// Returns the data for a cpufreq policy. + pub fn data(&mut self) -> Option<::Borrowed<'_>>= { + if self.as_ref().driver_data.is_null() { + None + } else { + // SAFETY: The data is earlier set by us from [`set_data()`]. + Some(unsafe { T::borrow(self.as_ref().driver_data) }) + } + } + + // Sets the data for a cpufreq policy. + fn set_data(&mut self, data: T) -> Result<()> { + if self.as_ref().driver_data.is_null() { + // Pass the ownership of the data to the foreign interface. + self.as_mut_ref().driver_data =3D ::into_= foreign(data) as _; + Ok(()) + } else { + Err(EBUSY) + } + } + + // Returns the data for a cpufreq policy. + fn clear_data(&mut self) -> Option { + if self.as_ref().driver_data.is_null() { + None + } else { + // SAFETY: The data is earlier set by us from [`set_data()`]. = It is safe to take back + // the ownership of the data from the foreign interface. + let data =3D + Some(unsafe { ::from_foreign(self.as_= ref().driver_data) }); + self.as_mut_ref().driver_data =3D ptr::null_mut(); + data + } + } +} + +impl Drop for Policy { + fn drop(&mut self) { + if self.put_cpu { + // SAFETY: By the type invariants, we know that `self` owns a = reference, so it is safe to + // relinquish it now. + unsafe { bindings::cpufreq_cpu_put(self.as_raw()) }; + } + } +} + +/// Operations to be implemented by a cpufreq driver. +#[vtable] +pub trait Driver { + /// Driver specific data. + /// + /// Corresponds to the data retrieved via the kernel's + /// `cpufreq_get_driver_data()` function. + /// + /// Require that `Data` implements `ForeignOwnable`. We guarantee to + /// never move the underlying wrapped data structure. + type Data: ForeignOwnable; + + /// Policy specific data. + /// + /// Require that `PData` implements `ForeignOwnable`. We guarantee to + /// never move the underlying wrapped data structure. + type PData: ForeignOwnable; + + /// Policy's init callback. + fn init(policy: &mut Policy) -> Result; + + /// Policy's exit callback. + fn exit(_policy: &mut Policy, _data: Option) -> Result<()= > { + kernel::build_error(VTABLE_DEFAULT_ERROR) + } + + /// Policy's online callback. + fn online(_policy: &mut Policy) -> Result<()> { + kernel::build_error(VTABLE_DEFAULT_ERROR) + } + + /// Policy's offline callback. + fn offline(_policy: &mut Policy) -> Result<()> { + kernel::build_error(VTABLE_DEFAULT_ERROR) + } + + /// Policy's suspend callback. + fn suspend(_policy: &mut Policy) -> Result<()> { + kernel::build_error(VTABLE_DEFAULT_ERROR) + } + + /// Policy's resume callback. + fn resume(_policy: &mut Policy) -> Result<()> { + kernel::build_error(VTABLE_DEFAULT_ERROR) + } + + /// Policy's ready callback. + fn ready(_policy: &mut Policy) { + kernel::build_error(VTABLE_DEFAULT_ERROR) + } + + /// Policy's verify callback. + fn verify(data: &mut PolicyData) -> Result<()>; + + /// Policy's setpolicy callback. + fn setpolicy(_policy: &mut Policy) -> Result<()> { + kernel::build_error(VTABLE_DEFAULT_ERROR) + } + + /// Policy's target callback. + fn target(_policy: &mut Policy, _target_freq: u32, _relation: Relation= ) -> Result<()> { + kernel::build_error(VTABLE_DEFAULT_ERROR) + } + + /// Policy's target_index callback. + fn target_index(_policy: &mut Policy, _index: u32) -> Result<()> { + kernel::build_error(VTABLE_DEFAULT_ERROR) + } + + /// Policy's fast_switch callback. + fn fast_switch(_policy: &mut Policy, _target_freq: u32) -> u32 { + kernel::build_error(VTABLE_DEFAULT_ERROR) + } + + /// Policy's adjust_perf callback. + fn adjust_perf(_policy: &mut Policy, _min_perf: u64, _target_perf: u64= , _capacity: u64) { + kernel::build_error(VTABLE_DEFAULT_ERROR) + } + + /// Policy's get_intermediate callback. + fn get_intermediate(_policy: &mut Policy, _index: u32) -> u32 { + kernel::build_error(VTABLE_DEFAULT_ERROR) + } + + /// Policy's target_intermediate callback. + fn target_intermediate(_policy: &mut Policy, _index: u32) -> Result<()= > { + kernel::build_error(VTABLE_DEFAULT_ERROR) + } + + /// Policy's get callback. + fn get(_policy: &mut Policy) -> Result { + kernel::build_error(VTABLE_DEFAULT_ERROR) + } + + /// Policy's update_limits callback. + fn update_limits(_policy: &mut Policy) { + kernel::build_error(VTABLE_DEFAULT_ERROR) + } + + /// Policy's bios_limit callback. + fn bios_limit(_policy: &mut Policy, _limit: &mut u32) -> Result<()> { + kernel::build_error(VTABLE_DEFAULT_ERROR) + } + + /// Policy's set_boost callback. + fn set_boost(_policy: &mut Policy, _state: i32) -> Result<()> { + kernel::build_error(VTABLE_DEFAULT_ERROR) + } + + /// Policy's register_em callback. + fn register_em(_policy: &mut Policy) { + kernel::build_error(VTABLE_DEFAULT_ERROR) + } +} --=20 2.31.1.272.g89b43f80a514 From nobody Sat Feb 7 16:45:35 2026 Received: from mail-oa1-f43.google.com (mail-oa1-f43.google.com [209.85.160.43]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 4DABF13B59E for ; Thu, 11 Jul 2024 06:58:33 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.160.43 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1720681115; cv=none; b=F+XdHnt0iAH2RcmVgRQR4EgsSzUeXWVKDjpLxDT8ovDPBcjSRDKR6in8KYZvZV3ndYZqpvjaW8hbjPaIqlRaocmaA3ELBdSekqUDnOMcCIlfal23LlRtVHq/LRMQuxPBcOC9tgU2baVzlzm8/nvzc56vQz0fuoaRY4cGK7ILybA= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1720681115; c=relaxed/simple; bh=c2J2y2NBtsjR7VffOsuDJ+T9Y3mzwDbqqxWAdAJO2Yg=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=W9giXXQLiPN0jmc7zNIjGW32gAWVUH6jRSWrIswgykdxIQaZRyVKapEIDCtkLCJQv0tETtGi64i9YDLBrSTNbNBmA/3iCBWwu6sQhUFILt9Kf+H0k11fPIJgDMGIh0LC5bwBDBs/RTqIp3SLBOJZ+P6HqQZh1Z5n0iEgq1ER3v4= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linaro.org; spf=pass smtp.mailfrom=linaro.org; dkim=pass (2048-bit key) header.d=linaro.org header.i=@linaro.org header.b=VGESX5Ps; arc=none smtp.client-ip=209.85.160.43 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linaro.org Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=linaro.org Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=linaro.org header.i=@linaro.org header.b="VGESX5Ps" Received: by mail-oa1-f43.google.com with SMTP id 586e51a60fabf-24c9f6338a4so272716fac.1 for ; Wed, 10 Jul 2024 23:58:32 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; t=1720681112; x=1721285912; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=SWL3PwNIokw4ycDQVXGTMBErGrTuKshaiA8FD5O1rHo=; b=VGESX5Psq2iwqiLfBeCtaoOF/wwBNaZ5LtVsLSBTzj7uidWWxzMyN+0uPo/+JrPt03 BJfQ+vRbPRtCSSquK3xgkH8fQJe4adoc5rFusvylfe2b0Dn235TkaIsurpJWhwA6eDUL SIcCsadWStZV8xdHcQ3C8i5MvRbUOZA/9XLXaaN1F/1YxQ2gwXM7RKQP3Z80VbbPbN1T etBYorlGEko+JQgkBveiBSaTzImO/2CrhFQT/fw8vtFFWDUq5Z7gwpO+j0pj+u2p4mPn +jNJxOtqHJODLzd1doZqf5kAiHEWkv05XJPx+vy9lG45qoog5svGDS/g1T2itRFagtWn S88w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1720681112; x=1721285912; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=SWL3PwNIokw4ycDQVXGTMBErGrTuKshaiA8FD5O1rHo=; b=sRVEQE5vm4Lgg9c4S/LTe1WeQuFqV7mSEKlAyJ920aBkUQF8vQPYf7UtJf7OrsoCfs qWtjmO8o0x893BDRnumwdI94Cb7lIThv8mIQnTEVOljC+9fcFpEexLANyaFefEeIKrgm LrUiOfOI4bZa2O4LauqIYUhdUvqQ53Don36gz0MoIetLO7Owp/IdcDZb/dVJuwtLqiGQ 9z0Ete5sBb1qs0M7aKj2IF/AGGIm4nvv87eVCY0tVrfqvQTJ/sIHZbaEWg/Hy3eNayjJ CZhPGijI5/k0MTeuqzd2E8seZpXsEpqd6NWsr+W9it1h9Du6fRFHofy+BRb/6ChA3C37 Ph+w== X-Forwarded-Encrypted: i=1; AJvYcCWgxVNyNq40AczVBalmRWcUAeFSPnArwdop8ss2zCCg6q6ExsTEP2zztSGEKstn24QAejFXtWMw/GQlqnoYZloxBnOLxpWJ46sganGJ X-Gm-Message-State: AOJu0YxTic6bAU9SIIEQw7vKV66If970bg+UAG2PI9XgqEg851QcTPHj UtYMWJHSdKwugY+reTg6X6TO+2U7eLkA1t4K2Ak2UyR1Vd0L6l7T/jWFUQQP6zQ= X-Google-Smtp-Source: AGHT+IEQ0YicXWB8pd4T3LCU1vR9qnI39UMltxKOJKJrM/rpUHiZMoBSn9PnprVhuJw9vVdQKyRyxA== X-Received: by 2002:a05:6870:e2c9:b0:25d:fab0:b6f4 with SMTP id 586e51a60fabf-25eae764b17mr6151607fac.1.1720681111999; Wed, 10 Jul 2024 23:58:31 -0700 (PDT) Received: from localhost ([122.172.84.129]) by smtp.gmail.com with ESMTPSA id d2e1a72fcca58-70b4397e4fesm4904504b3a.152.2024.07.10.23.58.31 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 10 Jul 2024 23:58:31 -0700 (PDT) From: Viresh Kumar To: "Rafael J. Wysocki" , Miguel Ojeda , Danilo Krummrich , Miguel Ojeda , Alex Gaynor , Wedson Almeida Filho , Boqun Feng , Gary Guo , =?UTF-8?q?Bj=C3=B6rn=20Roy=20Baron?= , Benno Lossin , Andreas Hindborg , Alice Ryhl Cc: Viresh Kumar , linux-pm@vger.kernel.org, Vincent Guittot , Stephen Boyd , Nishanth Menon , rust-for-linux@vger.kernel.org, Manos Pitsidianakis , Erik Schilling , =?UTF-8?q?Alex=20Benn=C3=A9e?= , Joakim Bech , Rob Herring , linux-kernel@vger.kernel.org Subject: [PATCH V4 6/8] rust: Extend cpufreq bindings for driver registration Date: Thu, 11 Jul 2024 12:27:48 +0530 Message-Id: <8730560329eb7354a46d950f5bd84528669ebe94.1720680252.git.viresh.kumar@linaro.org> X-Mailer: git-send-email 2.31.1.272.g89b43f80a514 In-Reply-To: References: Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" This extends the cpufreq bindings with bindings for registering a driver. Signed-off-by: Viresh Kumar --- rust/kernel/cpufreq.rs | 462 ++++++++++++++++++++++++++++++++++++++++- 1 file changed, 460 insertions(+), 2 deletions(-) diff --git a/rust/kernel/cpufreq.rs b/rust/kernel/cpufreq.rs index d58bb0bbaad4..b395694de6c4 100644 --- a/rust/kernel/cpufreq.rs +++ b/rust/kernel/cpufreq.rs @@ -9,14 +9,16 @@ use crate::{ bindings, clk, cpumask, device::Device, - error::{code::*, from_err_ptr, to_result, Result, VTABLE_DEFAULT_ERROR= }, + error::{code::*, from_err_ptr, from_result, to_result, Result, VTABLE_= DEFAULT_ERROR}, prelude::*, types::ForeignOwnable, }; =20 use core::{ + cell::UnsafeCell, + marker::PhantomData, pin::Pin, - ptr::self, + ptr::{self, addr_of_mut}, }; =20 use macros::vtable; @@ -563,3 +565,459 @@ fn register_em(_policy: &mut Policy) { kernel::build_error(VTABLE_DEFAULT_ERROR) } } + +/// Registration of a cpufreq driver. +pub struct Registration { + drv: Box>, + _p: PhantomData, +} + +// SAFETY: `Registration` doesn't offer any methods or access to fields wh= en shared between threads +// or CPUs, so it is safe to share it. +unsafe impl Sync for Registration {} + +// SAFETY: Registration with and unregistration from the cpufreq subsystem= can happen from any thread. +// Additionally, `T::Data` (which is dropped during unregistration) is `Se= nd`, so it is okay to move +// `Registration` to different threads. +#[allow(clippy::non_send_fields_in_send_ty)] +unsafe impl Send for Registration {} + +impl Registration { + /// Registers a cpufreq driver with the rest of the kernel. + pub fn register(name: &'static CStr, data: T::Data, flags: u16, boost:= bool) -> Result { + let mut drv =3D Box::new( + UnsafeCell::new(bindings::cpufreq_driver::default()), + GFP_KERNEL, + )?; + let drv_ref =3D drv.get_mut(); + + // Account for the trailing null character. + let len =3D name.len() + 1; + if len > drv_ref.name.len() { + return Err(EINVAL); + }; + + // SAFETY: `name` is a valid Cstr, and we are copying it to an arr= ay of equal or larger + // size. + let name =3D unsafe { &*(name.as_bytes_with_nul() as *const [u8] a= s *const [i8]) }; + drv_ref.name[..len].copy_from_slice(name); + + drv_ref.boost_enabled =3D boost; + drv_ref.flags =3D flags; + + // Allocate an array of 3 pointers to be passed to the C code. + let mut attr =3D Box::new([ptr::null_mut(); 3], GFP_KERNEL)?; + let mut next =3D 0; + + // SAFETY: The C code returns a valid pointer here, which is again= passed to the C code in + // an array. + attr[next] =3D + unsafe { addr_of_mut!(bindings::cpufreq_freq_attr_scaling_avai= lable_freqs) as *mut _ }; + next +=3D 1; + + if boost { + // SAFETY: The C code returns a valid pointer here, which is a= gain passed to the C code + // in an array. + attr[next] =3D + unsafe { addr_of_mut!(bindings::cpufreq_freq_attr_scaling_= boost_freqs) as *mut _ }; + next +=3D 1; + } + attr[next] =3D ptr::null_mut(); + + // Pass the ownership of the memory block to the C code. This will= be freed when + // the [`Registration`] object goes out of scope. + drv_ref.attr =3D Box::leak(attr) as *mut _; + + // Initialize mandatory callbacks. + drv_ref.init =3D Some(Self::init_callback); + drv_ref.verify =3D Some(Self::verify_callback); + + // Initialize optional callbacks. + drv_ref.setpolicy =3D if T::HAS_SETPOLICY { + Some(Self::setpolicy_callback) + } else { + None + }; + drv_ref.target =3D if T::HAS_TARGET { + Some(Self::target_callback) + } else { + None + }; + drv_ref.target_index =3D if T::HAS_TARGET_INDEX { + Some(Self::target_index_callback) + } else { + None + }; + drv_ref.fast_switch =3D if T::HAS_FAST_SWITCH { + Some(Self::fast_switch_callback) + } else { + None + }; + drv_ref.adjust_perf =3D if T::HAS_ADJUST_PERF { + Some(Self::adjust_perf_callback) + } else { + None + }; + drv_ref.get_intermediate =3D if T::HAS_GET_INTERMEDIATE { + Some(Self::get_intermediate_callback) + } else { + None + }; + drv_ref.target_intermediate =3D if T::HAS_TARGET_INTERMEDIATE { + Some(Self::target_intermediate_callback) + } else { + None + }; + drv_ref.get =3D if T::HAS_GET { + Some(Self::get_callback) + } else { + None + }; + drv_ref.update_limits =3D if T::HAS_UPDATE_LIMITS { + Some(Self::update_limits_callback) + } else { + None + }; + drv_ref.bios_limit =3D if T::HAS_BIOS_LIMIT { + Some(Self::bios_limit_callback) + } else { + None + }; + drv_ref.online =3D if T::HAS_ONLINE { + Some(Self::online_callback) + } else { + None + }; + drv_ref.offline =3D if T::HAS_OFFLINE { + Some(Self::offline_callback) + } else { + None + }; + drv_ref.exit =3D if T::HAS_EXIT { + Some(Self::exit_callback) + } else { + None + }; + drv_ref.suspend =3D if T::HAS_SUSPEND { + Some(Self::suspend_callback) + } else { + None + }; + drv_ref.resume =3D if T::HAS_RESUME { + Some(Self::resume_callback) + } else { + None + }; + drv_ref.ready =3D if T::HAS_READY { + Some(Self::ready_callback) + } else { + None + }; + drv_ref.set_boost =3D if T::HAS_SET_BOOST { + Some(Self::set_boost_callback) + } else { + None + }; + drv_ref.register_em =3D if T::HAS_REGISTER_EM { + Some(Self::register_em_callback) + } else { + None + }; + + // Set driver data before registering the driver, as the cpufreq c= ore may call few + // callbacks before `cpufreq_register_driver()` returns. + Self::set_data(drv_ref, data)?; + + // SAFETY: It is safe to register the driver with the cpufreq core= in the C code. + to_result(unsafe { bindings::cpufreq_register_driver(drv_ref) })?; + + Ok(Self { + drv, + _p: PhantomData, + }) + } + + // Sets the data for a cpufreq driver. + fn set_data(drv: &mut bindings::cpufreq_driver, data: T::Data) -> Resu= lt<()> { + if drv.driver_data.is_null() { + // Pass the ownership of the data to the foreign interface. + drv.driver_data =3D ::into_foreign(= data) as _; + Ok(()) + } else { + Err(EBUSY) + } + } + + /// Returns the previous set data for a cpufreq driver. + pub fn data(&mut self) -> Option<::Borrowed= <'static>> { + let drv =3D self.drv.get_mut(); + + if drv.driver_data.is_null() { + None + } else { + // SAFETY: The data is earlier set by us from [`set_data()`]. + Some(unsafe { ::borrow(drv.driver_d= ata) }) + } + } + + // Clears and returns the data for a cpufreq driver. + fn clear_data(&mut self) -> Option { + let drv =3D self.drv.get_mut(); + + if drv.driver_data.is_null() { + None + } else { + // SAFETY: By the type invariants, we know that `self` owns a = reference, so it is safe to + // relinquish it now. + let data =3D Some(unsafe { ::from_f= oreign(drv.driver_data) }); + drv.driver_data =3D ptr::null_mut(); + data + } + } +} + +// cpufreq driver callbacks. +impl Registration { + // Policy's init callback. + extern "C" fn init_callback(ptr: *mut bindings::cpufreq_policy) -> cor= e::ffi::c_int { + from_result(|| { + // SAFETY: `ptr` is valid by the contract with the C code. `po= licy` is alive only for the + // duration of this call, so it is guaranteed to remain alive = for the lifetime of + // `ptr`. + let mut policy =3D unsafe { Policy::from_raw_policy(ptr) }; + + let data =3D T::init(&mut policy)?; + policy.set_data(data)?; + Ok(0) + }) + } + + // Policy's exit callback. + extern "C" fn exit_callback(ptr: *mut bindings::cpufreq_policy) -> cor= e::ffi::c_int { + from_result(|| { + // SAFETY: `ptr` is valid by the contract with the C code. `po= licy` is alive only for the + // duration of this call, so it is guaranteed to remain alive = for the lifetime of + // `ptr`. + let mut policy =3D unsafe { Policy::from_raw_policy(ptr) }; + + let data =3D policy.clear_data(); + T::exit(&mut policy, data).map(|_| 0) + }) + } + + // Policy's online callback. + extern "C" fn online_callback(ptr: *mut bindings::cpufreq_policy) -> c= ore::ffi::c_int { + from_result(|| { + // SAFETY: `ptr` is valid by the contract with the C code. `po= licy` is alive only for the + // duration of this call, so it is guaranteed to remain alive = for the lifetime of + // `ptr`. + let mut policy =3D unsafe { Policy::from_raw_policy(ptr) }; + T::online(&mut policy).map(|_| 0) + }) + } + + // Policy's offline callback. + extern "C" fn offline_callback(ptr: *mut bindings::cpufreq_policy) -> = core::ffi::c_int { + from_result(|| { + // SAFETY: `ptr` is valid by the contract with the C code. `po= licy` is alive only for the + // duration of this call, so it is guaranteed to remain alive = for the lifetime of + // `ptr`. + let mut policy =3D unsafe { Policy::from_raw_policy(ptr) }; + T::offline(&mut policy).map(|_| 0) + }) + } + + // Policy's suspend callback. + extern "C" fn suspend_callback(ptr: *mut bindings::cpufreq_policy) -> = core::ffi::c_int { + from_result(|| { + // SAFETY: `ptr` is valid by the contract with the C code. `po= licy` is alive only for the + // duration of this call, so it is guaranteed to remain alive = for the lifetime of + // `ptr`. + let mut policy =3D unsafe { Policy::from_raw_policy(ptr) }; + T::suspend(&mut policy).map(|_| 0) + }) + } + + // Policy's resume callback. + extern "C" fn resume_callback(ptr: *mut bindings::cpufreq_policy) -> c= ore::ffi::c_int { + from_result(|| { + // SAFETY: `ptr` is valid by the contract with the C code. `po= licy` is alive only for the + // duration of this call, so it is guaranteed to remain alive = for the lifetime of + // `ptr`. + let mut policy =3D unsafe { Policy::from_raw_policy(ptr) }; + T::resume(&mut policy).map(|_| 0) + }) + } + + // Policy's ready callback. + extern "C" fn ready_callback(ptr: *mut bindings::cpufreq_policy) { + // SAFETY: `ptr` is valid by the contract with the C code. `policy= ` is alive only for the + // duration of this call, so it is guaranteed to remain alive for = the lifetime of + // `ptr`. + let mut policy =3D unsafe { Policy::from_raw_policy(ptr) }; + T::ready(&mut policy); + } + + // Policy's verify callback. + extern "C" fn verify_callback(ptr: *mut bindings::cpufreq_policy_data)= -> core::ffi::c_int { + from_result(|| { + // SAFETY: `ptr` is valid by the contract with the C code. `po= licy` is alive only for the + // duration of this call, so it is guaranteed to remain alive = for the lifetime of + // `ptr`. + let mut data =3D unsafe { PolicyData::from_raw_policy_data(ptr= ) }; + T::verify(&mut data).map(|_| 0) + }) + } + + // Policy's setpolicy callback. + extern "C" fn setpolicy_callback(ptr: *mut bindings::cpufreq_policy) -= > core::ffi::c_int { + from_result(|| { + // SAFETY: `ptr` is valid by the contract with the C code. `po= licy` is alive only for the + // duration of this call, so it is guaranteed to remain alive = for the lifetime of + // `ptr`. + let mut policy =3D unsafe { Policy::from_raw_policy(ptr) }; + T::setpolicy(&mut policy).map(|_| 0) + }) + } + + // Policy's target callback. + extern "C" fn target_callback( + ptr: *mut bindings::cpufreq_policy, + target_freq: u32, + relation: u32, + ) -> core::ffi::c_int { + from_result(|| { + // SAFETY: `ptr` is valid by the contract with the C code. `po= licy` is alive only for the + // duration of this call, so it is guaranteed to remain alive = for the lifetime of + // `ptr`. + let mut policy =3D unsafe { Policy::from_raw_policy(ptr) }; + T::target(&mut policy, target_freq, Relation::new(relation)?).= map(|_| 0) + }) + } + + // Policy's target_index callback. + extern "C" fn target_index_callback( + ptr: *mut bindings::cpufreq_policy, + index: u32, + ) -> core::ffi::c_int { + from_result(|| { + // SAFETY: `ptr` is valid by the contract with the C code. `po= licy` is alive only for the + // duration of this call, so it is guaranteed to remain alive = for the lifetime of + // `ptr`. + let mut policy =3D unsafe { Policy::from_raw_policy(ptr) }; + T::target_index(&mut policy, index).map(|_| 0) + }) + } + + // Policy's fast_switch callback. + extern "C" fn fast_switch_callback( + ptr: *mut bindings::cpufreq_policy, + target_freq: u32, + ) -> core::ffi::c_uint { + // SAFETY: `ptr` is valid by the contract with the C code. `policy= ` is alive only for the + // duration of this call, so it is guaranteed to remain alive for = the lifetime of + // `ptr`. + let mut policy =3D unsafe { Policy::from_raw_policy(ptr) }; + T::fast_switch(&mut policy, target_freq) + } + + // Policy's adjust_perf callback. + extern "C" fn adjust_perf_callback(cpu: u32, min_perf: u64, target_per= f: u64, capacity: u64) { + if let Ok(mut policy) =3D Policy::from_cpu(cpu) { + T::adjust_perf(&mut policy, min_perf, target_perf, capacity); + } + } + + // Policy's get_intermediate callback. + extern "C" fn get_intermediate_callback( + ptr: *mut bindings::cpufreq_policy, + index: u32, + ) -> core::ffi::c_uint { + // SAFETY: `ptr` is valid by the contract with the C code. `policy= ` is alive only for the + // duration of this call, so it is guaranteed to remain alive for = the lifetime of + // `ptr`. + let mut policy =3D unsafe { Policy::from_raw_policy(ptr) }; + T::get_intermediate(&mut policy, index) + } + + // Policy's target_intermediate callback. + extern "C" fn target_intermediate_callback( + ptr: *mut bindings::cpufreq_policy, + index: u32, + ) -> core::ffi::c_int { + from_result(|| { + // SAFETY: `ptr` is valid by the contract with the C code. `po= licy` is alive only for the + // duration of this call, so it is guaranteed to remain alive = for the lifetime of + // `ptr`. + let mut policy =3D unsafe { Policy::from_raw_policy(ptr) }; + T::target_intermediate(&mut policy, index).map(|_| 0) + }) + } + + // Policy's get callback. + extern "C" fn get_callback(cpu: u32) -> core::ffi::c_uint { + // SAFETY: Get the policy for a CPU. + Policy::from_cpu(cpu).map_or(0, |mut policy| T::get(&mut policy).m= ap_or(0, |f| f)) + } + + // Policy's update_limit callback. + extern "C" fn update_limits_callback(cpu: u32) { + // SAFETY: Get the policy for a CPU. + if let Ok(mut policy) =3D Policy::from_cpu(cpu) { + T::update_limits(&mut policy); + } + } + + // Policy's bios_limit callback. + extern "C" fn bios_limit_callback(cpu: i32, limit: *mut u32) -> core::= ffi::c_int { + from_result(|| { + let mut policy =3D Policy::from_cpu(cpu as u32)?; + + // SAFETY: The pointer is guaranteed by the C code to be valid. + T::bios_limit(&mut policy, &mut (unsafe { *limit })).map(|_| 0) + }) + } + + // Policy's set_boost callback. + extern "C" fn set_boost_callback( + ptr: *mut bindings::cpufreq_policy, + state: i32, + ) -> core::ffi::c_int { + from_result(|| { + // SAFETY: `ptr` is valid by the contract with the C code. `po= licy` is alive only for the + // duration of this call, so it is guaranteed to remain alive = for the lifetime of + // `ptr`. + let mut policy =3D unsafe { Policy::from_raw_policy(ptr) }; + T::set_boost(&mut policy, state).map(|_| 0) + }) + } + + // Policy's register_em callback. + extern "C" fn register_em_callback(ptr: *mut bindings::cpufreq_policy)= { + // SAFETY: `ptr` is valid by the contract with the C code. `policy= ` is alive only for the + // duration of this call, so it is guaranteed to remain alive for = the lifetime of + // `ptr`. + let mut policy =3D unsafe { Policy::from_raw_policy(ptr) }; + T::register_em(&mut policy); + } +} + +impl Drop for Registration { + // Removes the registration from the kernel if it has completed succes= sfully before. + fn drop(&mut self) { + pr_info!("Registration dropped\n"); + let drv =3D self.drv.get_mut(); + + // SAFETY: The driver was earlier registered from `register()`. + unsafe { bindings::cpufreq_unregister_driver(drv) }; + + // Free the previously leaked memory to the C code. + if !drv.attr.is_null() { + // SAFETY: The pointer was earlier initialized from the result= of `Box::leak`. + unsafe { drop(Box::from_raw(drv.attr)) }; + } + + // Free data + drop(self.clear_data()); + } +} --=20 2.31.1.272.g89b43f80a514 From nobody Sat Feb 7 16:45:35 2026 Received: from mail-pl1-f170.google.com (mail-pl1-f170.google.com [209.85.214.170]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 43EC714EC5E for ; Thu, 11 Jul 2024 06:58:36 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.170 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1720681117; cv=none; b=Q0eXmta99QcCMR7SZfjaQCiCvxAlfccCNmmjTnrndwrGBYZqN3awS6UlPvLBS3VkZt8DZNXEV8gdwt6QXRQkBkplTuXX+tuF/5kvXi/38UNXdGW19epxt9wxQm+ZVYmqDeNFLNWhzh2pGLSDK0POUmdoRRG32wl4cArdxmQzyX8= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1720681117; c=relaxed/simple; bh=dO0CWc/xKDTHkuWPDNFu1TEYJonQR+X8T3Udl4DMBu8=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=U8Hf10Y1iyLr84taOsAK5ZdIXuDVmvTqDK6xWZwrZybJ7VCLbFOwSimwL4r/Mqr3aI+n6q+xb0GE2aykcNk+LvD8XZYpCx48oaw1xAZiyUrUyJIZg0gzuAhO18HKvwHzAZ97C9PWjgRa5JYyZAMkFKDH71zvxe008Csgc1XBfkk= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linaro.org; spf=pass smtp.mailfrom=linaro.org; dkim=pass (2048-bit key) header.d=linaro.org header.i=@linaro.org header.b=ZBuR8xO0; arc=none smtp.client-ip=209.85.214.170 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linaro.org Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=linaro.org Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=linaro.org header.i=@linaro.org header.b="ZBuR8xO0" Received: by mail-pl1-f170.google.com with SMTP id d9443c01a7336-1fb0d88fd25so4207445ad.0 for ; Wed, 10 Jul 2024 23:58:36 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; t=1720681116; x=1721285916; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=uGcVVh6shkk/cP1y6RKWzcHFgRZvU/7gGba22DNsHXQ=; b=ZBuR8xO0kKEasHfScUj71x1BedhSpHYdCSlX+2lMFVrXyPeUVKdDdKbTheFeC7R+Hf GDR70Ij2bPpsy8ChmRJVb1SGCxvDSlixjE6dpE3c79lmchfP43ZK0LFEonIEnwJyqUNk xYrivKPhS990Q1J4JYA+Hcno29sskie2M03WirQFD7st7VDmjnbfjGBhkIiksOSt2vRk kC2901z2nEB+xtFEMMhUQn9aZd6kkovDSzZRbd2lfBVlghjmEYyDw9kzcytOKKpjWOmV UaiCkAt4FaFHqKtNrbXvLuIJpS3BmdE7fAnrJOV8dBWkc6oR57u4ocTFHzSbDiw0dy+C DlqA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1720681116; x=1721285916; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=uGcVVh6shkk/cP1y6RKWzcHFgRZvU/7gGba22DNsHXQ=; b=s4oUKH/h1rAGNMd41W33pVY10EfLlA3sTXv4XqEVqhagfu7fGpaj++WemRMUhVBCpn H4KVJdxIZ5Xr72AYUOM5GYgBFhZgUAyzJqMnLcAXrtm00YMjqU+OUP2X1QNfdT3SB0ot AMfvh53NCmFBJ34ry2coXpwhvK9cGOUFSgRWUmHuPiFSSkJmDDxElPk8XdyWu0JWgn9w AUjy4JwovAMkVGnZEnnJCd1L/RMPrrTGJOYPN/7QPZa4rGozheyMPzN20u95ctkZv+7k WpgcrF+mJv3iEEfPvnZMSZH8K5gGei7TW9Bz9vxq22+lGddVdYoCq3KBOm4PobDt64aO ZCqA== X-Forwarded-Encrypted: i=1; AJvYcCX5Nm6PV3O/kO5FkRLc2QyuywHFPI43z2BoL8KgsLlQFjDKeuyzQ+Y/YDVEekvCTynFRPnEJzTfzdp3MSzNo4gh9tvH/Mjzu+k4b82V X-Gm-Message-State: AOJu0Yxify0HiE/0QM2drC1nKPGR1fakKaDqBefIDGYn/oE2rx2GDc6Z ugJZWGxTHMt6eprS6VChnv0uPZZy+lCLv1/1hJ5JocrAPsYKWz+TkZKjYTtC6T8= X-Google-Smtp-Source: AGHT+IHttmQ+CJmAEGiN+ZpLgx1FkTxuA+txB4y8lJKqk+ahCAt7PiixgF+qi4Udu0Q7oaRRF/rSwA== X-Received: by 2002:a17:902:f78e:b0:1fb:8e29:621f with SMTP id d9443c01a7336-1fbdba13720mr24954095ad.16.1720681115548; Wed, 10 Jul 2024 23:58:35 -0700 (PDT) Received: from localhost ([122.172.84.129]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-1fbb6ad0103sm43520175ad.279.2024.07.10.23.58.34 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 10 Jul 2024 23:58:35 -0700 (PDT) From: Viresh Kumar To: "Rafael J. Wysocki" , Miguel Ojeda , Danilo Krummrich , Miguel Ojeda , Alex Gaynor , Wedson Almeida Filho , Boqun Feng , Gary Guo , =?UTF-8?q?Bj=C3=B6rn=20Roy=20Baron?= , Benno Lossin , Andreas Hindborg , Alice Ryhl Cc: Viresh Kumar , linux-pm@vger.kernel.org, Vincent Guittot , Stephen Boyd , Nishanth Menon , rust-for-linux@vger.kernel.org, Manos Pitsidianakis , Erik Schilling , =?UTF-8?q?Alex=20Benn=C3=A9e?= , Joakim Bech , Rob Herring , linux-kernel@vger.kernel.org Subject: [PATCH V4 7/8] rust: Extend OPP bindings with CPU frequency table Date: Thu, 11 Jul 2024 12:27:49 +0530 Message-Id: X-Mailer: git-send-email 2.31.1.272.g89b43f80a514 In-Reply-To: References: Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" This commit adds bindings for CPUFreq core related API. Signed-off-by: Viresh Kumar --- rust/kernel/opp.rs | 61 +++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 60 insertions(+), 1 deletion(-) diff --git a/rust/kernel/opp.rs b/rust/kernel/opp.rs index 113652448056..7317a5e922cc 100644 --- a/rust/kernel/opp.rs +++ b/rust/kernel/opp.rs @@ -16,7 +16,10 @@ types::{ARef, AlwaysRefCounted, Opaque}, }; =20 -use core::{ffi::c_char, marker::PhantomData, ptr}; +#[cfg(CONFIG_CPU_FREQ)] +use crate::cpufreq; + +use core::{ffi::c_char, marker::PhantomData, ops::Deref, ptr}; =20 use macros::vtable; =20 @@ -376,6 +379,56 @@ extern "C" fn config_regulators( } } =20 +/// CPU Frequency table created from OPP entries. +#[cfg(CONFIG_CPU_FREQ)] +pub struct FreqTable { + dev: ARef, + table: cpufreq::Table, +} + +#[cfg(CONFIG_CPU_FREQ)] +impl FreqTable { + /// Creates new instance of [`FreqTable`] from raw pointer. + fn new(table: &Table) -> Result { + let mut ptr: *mut bindings::cpufreq_frequency_table =3D ptr::null_= mut(); + + // SAFETY: The requirements are satisfied by the existence of `Dev= ice` and its safety + // requirements. + to_result(unsafe { + bindings::dev_pm_opp_init_cpufreq_table(table.dev.as_raw(), &m= ut ptr) + })?; + Ok(Self { + dev: table.dev.clone(), + // SAFETY: The `ptr` is guaranteed by the C code to be valid. + table: unsafe { cpufreq::Table::from_raw(ptr) }, + }) + } + + /// Returns reference to the underlying [`cpufreq::Table`]. + pub fn table(&self) -> &cpufreq::Table { + &self.table + } +} + +#[cfg(CONFIG_CPU_FREQ)] +impl Deref for FreqTable { + type Target =3D cpufreq::Table; + + #[inline] + fn deref(&self) -> &Self::Target { + &self.table + } +} + +#[cfg(CONFIG_CPU_FREQ)] +impl Drop for FreqTable { + fn drop(&mut self) { + // SAFETY: The requirements are satisfied by the existence of `Dev= ice` and its safety + // requirements. + unsafe { bindings::dev_pm_opp_free_cpufreq_table(self.dev.as_raw()= , &mut self.as_raw()) }; + } +} + /// Operating performance point (OPP) table. /// /// Wraps the kernel's `struct opp_table`. @@ -580,6 +633,12 @@ pub fn adjust_voltage( }) } =20 + /// Create cpufreq table from OPP table. + #[cfg(CONFIG_CPU_FREQ)] + pub fn to_cpufreq_table(&mut self) -> Result { + FreqTable::new(self) + } + /// Sets a matching OPP based on frequency. pub fn set_rate(&self, freq: u64) -> Result<()> { // SAFETY: The requirements are satisfied by the existence of `Dev= ice` and its safety --=20 2.31.1.272.g89b43f80a514 From nobody Sat Feb 7 16:45:35 2026 Received: from mail-pl1-f171.google.com (mail-pl1-f171.google.com [209.85.214.171]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 040BB14B950 for ; Thu, 11 Jul 2024 06:58:40 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.171 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1720681122; cv=none; b=XFEYqWi3JbYglPix025uNo5ECAGcsztqJOKo1wR+LF8w1vacMrmUtzkEkDShwoCEe+kmvmfWBB/64y5tCzXbNaFz4U+ZgcAIxhIs6L2s455xIcP8YpSjMKqrci30yMqf+5Nw/flvUkGNzcwhGbH+z5zfeV0kEitB2PicbwINlVk= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1720681122; c=relaxed/simple; bh=1Xy9KHDychYMFo45DJYM4XIeOyy+ftVDsh/XzMyp4bs=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=ltVztHEqtOI1UjMFHiJMkhpPhHQzsD0kw/hfoO1BPC0TakWMXYEcXdq/MhWYFNkJoyAF2AnwuVroSFU2lJP+/xQD58NlNolyKJFMG0ZXsnsz+CV+/PWnp9q+qa4+qegHeHW2XmaKIh96lCuqttfLHwpeCvqp22DaUJTyhhdKf/M= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linaro.org; spf=pass smtp.mailfrom=linaro.org; dkim=pass (2048-bit key) header.d=linaro.org header.i=@linaro.org header.b=wZS2OaRd; arc=none smtp.client-ip=209.85.214.171 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linaro.org Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=linaro.org Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=linaro.org header.i=@linaro.org header.b="wZS2OaRd" Received: by mail-pl1-f171.google.com with SMTP id d9443c01a7336-1fa55dbf2e7so3082625ad.2 for ; Wed, 10 Jul 2024 23:58:40 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; t=1720681120; x=1721285920; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=9e8HCkv4MqLK7B9EDdw2qJNgX3GUhxvt7rYdMaHiBII=; b=wZS2OaRdNnn0D/GJn1JWSLTLMj+kgolN2aLu3gZ1oMTuQBTsxTvAveCuAvT8O1QNal 1JioGRVKlydjw8jQgWqGa2y430W3eaRIu6uJS3307faJ2a5CuCvK2HLDmkhfR38cPH1l C+1DFbPPhv6QC5T8V6jYy7aKMz0ozmuXFHl4Em93wAXSq7ZMYXIeyfcRC/en3ubREbKh kNCsRjX1ConLL0YpTCvQ8OoeoosD+0Gb5vGl8Ryb8wbl+ie5SBMBOP0svaYkDt8LDtsa GDhSShIFzDS9dhwh7PUA+wunEUwzMu0qxe/QnjDLGI00dinF3z61U+m+6T39xjdaN/6+ zcVw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1720681120; x=1721285920; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=9e8HCkv4MqLK7B9EDdw2qJNgX3GUhxvt7rYdMaHiBII=; b=hGDTFw4XlgED9Zk+ISIyKVCEQqR1A56Ii2kXdbS+Kog8AnXELItrddHBEv/Rij2ckC NI63kMrcohzM/7WnbKCB0oa4YAmdywN1alqSyXjoijGavQ3dno9+rvxkUZ1fSz2L6yYO uYu7+tXnlstDu2Xwp2AxrVZb3NkdzJLkzSybyQGhEgBcJl2RJ9qv+VPgsspPh/HQsrHe R31NlMY6PpydYF+LpWeQZc7VplfnkpPU6w1D1g0wtiGeunZLa73JciabsHka5+JhB7mW X7RjdIAbGogb+mWiVa3Hhw1xwjc0HgdLsdMcQYDpe/Mgxe7xUQwWXLZouW0zhdLABxhS GM3Q== X-Forwarded-Encrypted: i=1; AJvYcCUdAdVHrQwRd2WXRIcgTrbwKGEBEWbU2d9xb0c2D9PaMSBHUVzn+E3GQ2uukvq+2aFytdA0IloqfogV2crEG+PF3rGBNwWUX0AXcTQx X-Gm-Message-State: AOJu0Yw7DR3rswQQ9tWGOKsLKohb2Qh6cowJKlsWBDu7qxkcTPa6XZmW JGbCakgJdjFbx6dEmlx0DmCNh1f7t+SoIT+kRJQfk4YKgqNCprXy5De2NDBJG+U= X-Google-Smtp-Source: AGHT+IG6KiJN8RvMFc2x7IkaNiACkQ6MjAB6O5+E4DFT+Hi8we5+RzfQHFoGsT7JgQSL8HqEIHgfSQ== X-Received: by 2002:a17:902:c952:b0:1fb:1b16:eb80 with SMTP id d9443c01a7336-1fbb6d0e113mr66096045ad.26.1720681120236; Wed, 10 Jul 2024 23:58:40 -0700 (PDT) Received: from localhost ([122.172.84.129]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-1fbb6ac80f1sm43753745ad.235.2024.07.10.23.58.39 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 10 Jul 2024 23:58:39 -0700 (PDT) From: Viresh Kumar To: "Rafael J. Wysocki" , Miguel Ojeda , Danilo Krummrich , Viresh Kumar , Miguel Ojeda , Alex Gaynor , Wedson Almeida Filho , Boqun Feng , Gary Guo , =?UTF-8?q?Bj=C3=B6rn=20Roy=20Baron?= , Benno Lossin , Andreas Hindborg , Alice Ryhl Cc: linux-pm@vger.kernel.org, Vincent Guittot , Stephen Boyd , Nishanth Menon , rust-for-linux@vger.kernel.org, Manos Pitsidianakis , Erik Schilling , =?UTF-8?q?Alex=20Benn=C3=A9e?= , Joakim Bech , Rob Herring , linux-kernel@vger.kernel.org Subject: [PATCH V4 8/8] cpufreq: Add Rust based cpufreq-dt driver Date: Thu, 11 Jul 2024 12:27:50 +0530 Message-Id: X-Mailer: git-send-email 2.31.1.272.g89b43f80a514 In-Reply-To: References: Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" This commit adds a Rust based cpufreq-dt driver, which covers most of the functionality of the existing C based driver. Only a handful of things are left, like fetching platform data from cpufreq-dt-platdev.c. This is tested with the help of QEMU for now and switching of frequencies work as expected. Signed-off-by: Viresh Kumar --- drivers/cpufreq/Kconfig | 12 ++ drivers/cpufreq/Makefile | 1 + drivers/cpufreq/rcpufreq_dt.rs | 222 +++++++++++++++++++++++++++++++++ 3 files changed, 235 insertions(+) create mode 100644 drivers/cpufreq/rcpufreq_dt.rs diff --git a/drivers/cpufreq/Kconfig b/drivers/cpufreq/Kconfig index 94e55c40970a..eb9359bd3c5c 100644 --- a/drivers/cpufreq/Kconfig +++ b/drivers/cpufreq/Kconfig @@ -217,6 +217,18 @@ config CPUFREQ_DT =20 If in doubt, say N. =20 +config CPUFREQ_DT_RUST + tristate "Rust based Generic DT based cpufreq driver" + depends on HAVE_CLK && OF && RUST + select CPUFREQ_DT_PLATDEV + select PM_OPP + help + This adds a Rust based generic DT based cpufreq driver for frequency + management. It supports both uniprocessor (UP) and symmetric + multiprocessor (SMP) systems. + + If in doubt, say N. + config CPUFREQ_DT_PLATDEV tristate "Generic DT based cpufreq platdev driver" depends on OF diff --git a/drivers/cpufreq/Makefile b/drivers/cpufreq/Makefile index 8d141c71b016..4981d908b803 100644 --- a/drivers/cpufreq/Makefile +++ b/drivers/cpufreq/Makefile @@ -15,6 +15,7 @@ obj-$(CONFIG_CPU_FREQ_GOV_COMMON) +=3D cpufreq_governor.o obj-$(CONFIG_CPU_FREQ_GOV_ATTR_SET) +=3D cpufreq_governor_attr_set.o =20 obj-$(CONFIG_CPUFREQ_DT) +=3D cpufreq-dt.o +obj-$(CONFIG_CPUFREQ_DT_RUST) +=3D rcpufreq_dt.o obj-$(CONFIG_CPUFREQ_DT_PLATDEV) +=3D cpufreq-dt-platdev.o =20 # Traces diff --git a/drivers/cpufreq/rcpufreq_dt.rs b/drivers/cpufreq/rcpufreq_dt.rs new file mode 100644 index 000000000000..3e86ad134e13 --- /dev/null +++ b/drivers/cpufreq/rcpufreq_dt.rs @@ -0,0 +1,222 @@ +// SPDX-License-Identifier: GPL-2.0 + +//! Rust based implementation of the cpufreq-dt driver. + +use core::format_args; + +use kernel::{ + b_str, c_str, clk, cpufreq, cpumask::Cpumask, define_of_id_table, devi= ce::Device, + devres::Devres, error::code::*, fmt, macros::vtable, module_platform_d= river, of, opp, platform, + prelude::*, str::CString, sync::Arc, +}; + +// Finds exact supply name from the OF node. +fn find_supply_name_exact(np: &of::DeviceNode, name: &str) -> Option { + let name_cstr =3D CString::try_from_fmt(fmt!("{}-supply", name)).ok()?; + + np.find_property(&name_cstr).ok()?; + CString::try_from_fmt(fmt!("{}", name)).ok() +} + +// Finds supply name for the CPU from DT. +fn find_supply_names(dev: &Device, cpu: u32) -> Option> { + let np =3D of::DeviceNode::from_dev(dev).ok()?; + + // Try "cpu0" for older DTs. + let name =3D match cpu { + 0 =3D> find_supply_name_exact(&np, "cpu0"), + _ =3D> None, + } + .or(find_supply_name_exact(&np, "cpu"))?; + + let mut list =3D Vec::with_capacity(1, GFP_KERNEL).ok()?; + list.push(name, GFP_KERNEL).ok()?; + + Some(list) +} + +// Represents the cpufreq dt device. +struct CPUFreqDTDevice { + opp_table: opp::Table, + freq_table: opp::FreqTable, + #[allow(dead_code)] + mask: Cpumask, + #[allow(dead_code)] + token: Option, + #[allow(dead_code)] + clk: clk::Clk, +} + +struct CPUFreqDTDriver; + +#[vtable] +impl opp::ConfigOps for CPUFreqDTDriver {} + +#[vtable] +impl cpufreq::Driver for CPUFreqDTDriver { + type Data =3D (); + type PData =3D Arc; + + fn init(policy: &mut cpufreq::Policy) -> Result { + let cpu =3D policy.cpu(); + let dev =3D Device::from_cpu(cpu)?; + let mut mask =3D Cpumask::new()?; + + mask.set(cpu); + + let token =3D match find_supply_names(&dev, cpu) { + Some(names) =3D> Some( + opp::Config::::new() + .set_regulator_names(names)? + .set(&dev)?, + ), + _ =3D> None, + }; + + // Get OPP-sharing information from "operating-points-v2" bindings. + let fallback =3D match opp::Table::of_sharing_cpus(&dev, &mut mask= ) { + Ok(_) =3D> false, + Err(e) =3D> { + if e !=3D ENOENT { + return Err(e); + } + + // "operating-points-v2" not supported. If the platform ha= sn't + // set sharing CPUs, fallback to all CPUs share the `Polic= y` + // for backward compatibility. + opp::Table::sharing_cpus(&dev, &mut mask).is_err() + } + }; + + // Initialize OPP tables for all policy cpus. + // + // For platforms not using "operating-points-v2" bindings, we do t= his + // before updating policy cpus. Otherwise, we will end up creating + // duplicate OPPs for the CPUs. + // + // OPPs might be populated at runtime, don't fail for error here u= nless + // it is -EPROBE_DEFER. + let mut opp_table =3D match opp::Table::from_of_cpumask(&dev, &mas= k) { + Ok(table) =3D> table, + Err(e) =3D> { + if e =3D=3D EPROBE_DEFER { + return Err(e); + } + + // The table is added dynamically ? + opp::Table::from_dev(&dev)? + } + }; + + // The OPP table must be initialized, statically or dynamically, b= y this point. + opp_table.opp_count()?; + + // Set sharing cpus for fallback scenario. + if fallback { + mask.set_all(); + opp_table.set_sharing_cpus(&mask)?; + } + + let mut transition_latency =3D opp_table.max_transition_latency() = as u32; + if transition_latency =3D=3D 0 { + transition_latency =3D cpufreq::ETERNAL_LATENCY; + } + + let freq_table =3D opp_table.to_cpufreq_table()?; + let clk =3D policy + .set_freq_table(freq_table.table()) + .set_dvfs_possible_from_any_cpu() + .set_suspend_freq((opp_table.suspend_freq() / 1000) as u32) + .set_transition_latency(transition_latency) + .set_clk(&dev, None)?; + + mask.copy(policy.cpus()); + + Ok(Arc::new( + CPUFreqDTDevice { + opp_table, + freq_table, + mask, + token, + clk, + }, + GFP_KERNEL, + )?) + } + + fn exit(_policy: &mut cpufreq::Policy, _data: Option) -> = Result<()> { + Ok(()) + } + + fn online(_policy: &mut cpufreq::Policy) -> Result<()> { + // We did light-weight tear down earlier, nothing to do here. + Ok(()) + } + + fn offline(_policy: &mut cpufreq::Policy) -> Result<()> { + // Preserve policy->data and don't free resources on light-weight + // tear down. + Ok(()) + } + + fn suspend(policy: &mut cpufreq::Policy) -> Result<()> { + policy.generic_suspend() + } + + fn verify(data: &mut cpufreq::PolicyData) -> Result<()> { + data.generic_verify() + } + + fn target_index(policy: &mut cpufreq::Policy, index: u32) -> Result<()= > { + let data =3D match policy.data::() { + Some(data) =3D> data, + None =3D> return Err(ENOENT), + }; + + let freq =3D data.freq_table.freq(index.try_into().unwrap())? as u= 64; + data.opp_table.set_rate(freq * 1000) + } + + fn get(policy: &mut cpufreq::Policy) -> Result { + policy.generic_get() + } + + fn set_boost(_policy: &mut cpufreq::Policy, _state: i32) -> Result<()>= { + Ok(()) + } + + fn register_em(policy: &mut cpufreq::Policy) { + policy.register_em_opp() + } +} + +impl platform::Driver for CPUFreqDTDriver { + type Data =3D (); + + define_of_id_table! {(), [ + (of::DeviceId(b_str!("operating-points-v2")), None), + ]} + + fn probe(dev: &mut platform::Device, _id_info: Option<&Self::IdInfo>) = -> Result { + let drv =3D cpufreq::Registration::::register( + c_str!("cpufreq-dt"), + (), + cpufreq::flags::NEED_INITIAL_FREQ_CHECK | cpufreq::flags::IS_C= OOLING_DEV, + true, + )?; + + Devres::new_foreign_owned(dev.as_ref(), drv, GFP_KERNEL)?; + + pr_info!("CPUFreq DT driver registered\n"); + + Ok(()) + } +} + +module_platform_driver! { + type: CPUFreqDTDriver, + name: "cpufreq_dt", + author: "Viresh Kumar ", + description: "Generic CPUFreq DT driver", + license: "GPL v2", +} --=20 2.31.1.272.g89b43f80a514