feat: RDNA4 support (#487)

* feat: initial rdna4 support

* fix: disable writing clocks settings for now

* feat: work around misreported clock offsets, only set max offset

* feat: support new (kernel 6.15+) sclk offset format

* fix: fan curve zero page zero rpm switch

* feat: show zero rpm stop temperature on fan curve page

* feat: disable zero rpm on static control

* chore: update test snapshot

* feat: explicitly fail when setting a pmfw fan curve outside of allowed ranges

* feat: fall back to gpu_metrics for fan info when hwmon is not available

* chore: add gpu_metrics test data

* chore: fmt

* chore: update default fan curve

* chore: update 9070xt-new test data

* fix: make missing zero rpm option a non-fatal error

* chore: switch amdgpu-sysfs crate version

Author: ilya-zlobintsev

Cargo.lock

@@ -10,7 +10,7 @@ members = [
 ]
 
 [workspace.dependencies]
-amdgpu-sysfs = { version = "0.17.3", features = ["serde"] }
+amdgpu-sysfs = { version = "0.18.0", features = ["serde"] }
 serde = { version = "1.0", features = ["derive"] }
 serde_with = { version = "3.5.0", default-features = false, features = [
     "macros",

Cargo.toml

@@ -166,7 +166,7 @@ gpus:
     # Voltage offset value in mV for RDNA and newer AMD GPUs.
     voltage_offset: 0
 
-    # GPU and VRAM clockspeed offset values, per-pstate. Only applicable on Nvidia.
+    # GPU and VRAM clockspeed offset values, per-pstate. Applicable on Nvidia and on AMD RDNA4.
     gpu_clock_offsets:
       0: -100
     mem_clock_offsets:

docs/CONFIG.md

@@ -40,7 +40,7 @@ pub trait GpuController {
 
     fn get_stats(&self, gpu_config: Option<&config::Gpu>) -> DeviceStats;
 
-    fn get_clocks_info(&self) -> anyhow::Result<ClocksInfo>;
+    fn get_clocks_info(&self, gpu_config: Option<&config::Gpu>) -> anyhow::Result<ClocksInfo>;
 
     fn get_power_states(&self, gpu_config: Option<&config::Gpu>) -> PowerStates;
 

lact-daemon/src/server/gpu_controller.rs

@@ -14,14 +14,15 @@ use amdgpu_sysfs::{
         CommitHandle, GpuHandle, PerformanceLevel, PowerLevelKind, PowerLevels,
     },
     hw_mon::{FanControlMethod, HwMon},
+    sysfs::SysFS,
 };
 use anyhow::{anyhow, Context};
 use futures::{future::LocalBoxFuture, FutureExt};
 use lact_schema::{
     ClocksInfo, ClockspeedStats, DeviceInfo, DeviceStats, DrmInfo, FanStats, IntelDrmInfo,
     LinkInfo, PmfwInfo, PowerState, PowerStates, PowerStats, VoltageStats, VramStats,
 };
-use libdrm_amdgpu_sys::AMDGPU::{ThrottleStatus, ThrottlerBit};
+use libdrm_amdgpu_sys::AMDGPU::{GpuMetrics, ThrottleStatus, ThrottlerBit};
 use libdrm_amdgpu_sys::{LibDrmAmdgpu, AMDGPU::SENSOR_INFO::SENSOR_TYPE};
 use std::{
     cell::RefCell,
@@ -102,6 +103,12 @@ impl AmdGpuController {
 
         // Use PMFW curve functionality for static speed when it is available
         if let Ok(current_curve) = self.handle.get_fan_curve() {
+            if let Ok(true) = self.handle.get_fan_zero_rpm_enable() {
+                if let Err(err) = self.handle.set_fan_zero_rpm_enable(false) {
+                    error!("could not disable zero RPM mode for static fan control: {err}");
+                }
+            }
+
             let allowed_ranges = current_curve.allowed_ranges.clone().ok_or_else(|| {
                 anyhow!("The GPU does not allow setting custom fan values (is overdrive enabled?)")
             })?;
@@ -606,6 +613,9 @@ impl GpuController for AmdGpuController {
     }
 
     fn get_stats(&self, gpu_config: Option<&config::Gpu>) -> DeviceStats {
+        let metrics = GpuMetrics::get_from_sysfs_path(self.handle.get_path()).ok();
+        let metrics = metrics.as_ref();
+
         let fan_settings = gpu_config.and_then(|config| config.fan_control_settings.as_ref());
         DeviceStats {
             fan: FanStats {
@@ -615,10 +625,18 @@ impl GpuController for AmdGpuController {
                 curve: fan_settings.map(|settings| settings.curve.0.clone()),
                 spindown_delay_ms: fan_settings.and_then(|settings| settings.spindown_delay_ms),
                 change_threshold: fan_settings.and_then(|settings| settings.change_threshold),
-                speed_current: self.hw_mon_and_then(HwMon::get_fan_current),
+                speed_current: self.hw_mon_and_then(HwMon::get_fan_current).or_else(|| {
+                    metrics
+                        .and_then(MetricsInfo::get_current_fan_speed)
+                        .map(u32::from)
+                }),
                 speed_max: self.hw_mon_and_then(HwMon::get_fan_max),
                 speed_min: self.hw_mon_and_then(HwMon::get_fan_min),
-                pwm_current: self.hw_mon_and_then(HwMon::get_fan_pwm),
+                pwm_current: self.hw_mon_and_then(HwMon::get_fan_pwm).or_else(|| {
+                    metrics
+                        .and_then(MetricsInfo::get_fan_pwm)
+                        .and_then(|pwm| u8::try_from(pwm).ok())
+                }),
                 pmfw_info: PmfwInfo {
                     acoustic_limit: self.handle.get_fan_acoustic_limit().ok(),
                     acoustic_target: self.handle.get_fan_acoustic_target().ok(),
@@ -667,11 +685,32 @@ impl GpuController for AmdGpuController {
         }
     }
 
-    fn get_clocks_info(&self) -> anyhow::Result<ClocksInfo> {
-        let clocks_table = self
+    fn get_clocks_info(&self, gpu_config: Option<&config::Gpu>) -> anyhow::Result<ClocksInfo> {
+        let mut clocks_table = self
             .handle
             .get_clocks_table()
             .context("Clocks table not available")?;
+
+        if let ClocksTableGen::Vega20(table) = &mut clocks_table {
+            // Workaround for RDNA4 not reporting current SCLK offset in the original format:
+            // https://github.com/ilya-zlobintsev/LACT/issues/485#issuecomment-2712502906
+            if table.rdna4_sclk_offset_workaround {
+                // The values present in the old clocks table format for the current slck offset are rubbish,
+                // we should report the configured value instead
+                let offset = gpu_config
+                    .and_then(|config| {
+                        config
+                            .clocks_configuration
+                            .gpu_clock_offsets
+                            .get(&0)
+                            .copied()
+                    })
+                    .unwrap_or(0);
+
+                table.sclk_offset = Some(offset);
+            }
+        }
+
         Ok(clocks_table.into())
     }
 
@@ -836,7 +875,7 @@ impl GpuController for AmdGpuController {
                         commit_handles.push(handle);
                     }
                     Err(err) => {
-                        error!("custom clock settings are present but will be ignored, but could not get clocks table: {err}");
+                        error!("custom clock settings are present but will be ignored, could not get clocks table: {err}");
                     }
                 }
             }
@@ -969,30 +1008,36 @@ impl GpuController for AmdGpuController {
 
             // Unlike the other PMFW options, zero rpm should be functional with a custom curve
             if let Some(zero_rpm) = config.pmfw_options.zero_rpm {
-                let current_zero_rpm = self
-                    .handle
-                    .get_fan_zero_rpm_enable()
-                    .context("Could not get zero RPM mode")?;
-                if current_zero_rpm != zero_rpm {
-                    let commit_handle = self
-                        .handle
-                        .set_fan_zero_rpm_enable(zero_rpm)
-                        .context("Could not set zero RPM mode")?;
-                    commit_handles.push(commit_handle);
+                match self.handle.get_fan_zero_rpm_enable() {
+                    Ok(current_zero_rpm) => {
+                        if current_zero_rpm != zero_rpm {
+                            let commit_handle = self
+                                .handle
+                                .set_fan_zero_rpm_enable(zero_rpm)
+                                .context("Could not set zero RPM mode")?;
+                            commit_handles.push(commit_handle);
+                        }
+                    }
+                    Err(err) => {
+                        error!("zero RPM is present in the config, but not available on the GPU: {err}");
+                    }
                 }
             }
 
             if let Some(zero_rpm_threshold) = config.pmfw_options.zero_rpm_threshold {
-                let current_threshold = self
-                    .handle
-                    .get_fan_zero_rpm_stop_temperature()
-                    .context("Could not get zero RPM temperature")?;
-                if current_threshold.current != zero_rpm_threshold {
-                    let commit_handle = self
-                        .handle
-                        .set_fan_zero_rpm_stop_temperature(zero_rpm_threshold)
-                        .context("Could not set zero RPM temperature")?;
-                    commit_handles.push(commit_handle);
+                match self.handle.get_fan_zero_rpm_stop_temperature() {
+                    Ok(current_threshold) => {
+                        if current_threshold.current != zero_rpm_threshold {
+                            let commit_handle = self
+                                .handle
+                                .set_fan_zero_rpm_stop_temperature(zero_rpm_threshold)
+                                .context("Could not set zero RPM temperature")?;
+                            commit_handles.push(commit_handle);
+                        }
+                    }
+                    Err(err) => {
+                        error!("zero RPM threshold is present in the config, but not available on the GPU: {err}");
+                    }
                 }
             }
 
@@ -1073,6 +1118,10 @@ impl ClocksConfiguration {
                 Some(offset) => table.set_voltage_offset(offset)?,
                 None => table.voltage_offset = None,
             }
+
+            if let Some(offset) = self.gpu_clock_offsets.get(&0) {
+                table.sclk_offset = Some(*offset);
+            }
         }
 
         if let Some(min_clockspeed) = self.min_core_clock {

lact-daemon/src/server/gpu_controller/amd.rs

@@ -1,7 +1,5 @@
-use std::cmp;
-
 use amdgpu_sysfs::{gpu_handle::fan_control::FanCurve as PmfwCurve, hw_mon::Temperature};
-use anyhow::{anyhow, Context};
+use anyhow::{anyhow, bail, Context};
 use lact_schema::{default_fan_curve, FanCurveMap};
 use serde::{Deserialize, Serialize};
 use tracing::warn;
@@ -52,18 +50,28 @@ impl FanCurve {
         let allowed_ranges = current_pmfw_curve
             .allowed_ranges
             .context("The GPU does not allow fan curve modifications")?;
-        let min_pwm = *allowed_ranges.speed_range.start();
-        let max_pwm = f32::from(*allowed_ranges.speed_range.end());
+        let min_percent = *allowed_ranges.speed_range.start();
+        let max_percent = *allowed_ranges.speed_range.end();
+        let min_temp = *allowed_ranges.temperature_range.start();
+        let max_temp = *allowed_ranges.temperature_range.end();
 
         let points = self
             .0
             .into_iter()
             .map(|(temp, ratio)| {
-                let custom_pwm = (max_pwm * ratio) as u8;
-                let pwm = cmp::max(min_pwm, custom_pwm);
-                (temp, pwm)
+                let custom_percent = (ratio * 100.0) as u8;
+
+                if !(min_temp..=max_temp).contains(&temp) {
+                    bail!("Temperature {temp}℃ is outside of the allowed range {min_temp}℃ to {max_temp}℃");
+                }
+
+                if !(min_percent..=max_percent).contains(&custom_percent) {
+                    bail!("Speed {custom_percent}% is outside of the allowed range {min_percent}% to {max_percent}%");
+                }
+
+                Ok((temp, custom_percent))
             })
-            .collect();
+            .collect::<anyhow::Result<_>>()?;
 
         Ok(PmfwCurve {
             points,
@@ -93,6 +101,7 @@ impl Default for FanCurve {
 mod tests {
     use super::{FanCurve, PmfwCurve};
     use amdgpu_sysfs::{gpu_handle::fan_control::FanCurveRanges, hw_mon::Temperature};
+    use anyhow::anyhow;
 
     fn simple_pwm(temp: f32) -> u8 {
         let curve = FanCurve([(0, 0.0), (100, 1.0)].into());
@@ -178,7 +187,7 @@ mod tests {
             };
             curve.pwm_at_temp(temp)
         };
-        assert_eq!(pwm_at_temp(40.0), 51);
+        assert_eq!(pwm_at_temp(40.0), 76);
         assert_eq!(pwm_at_temp(60.0), 127);
         assert_eq!(pwm_at_temp(65.0), 159);
         assert_eq!(pwm_at_temp(70.0), 191);
@@ -193,12 +202,42 @@ mod tests {
         let current_pmfw_curve = PmfwCurve {
             points: Box::new([(0, 0); 5]),
             allowed_ranges: Some(FanCurveRanges {
-                temperature_range: 15..=90,
-                speed_range: 20..=100,
+                temperature_range: 25..=100,
+                speed_range: 30..=100,
             }),
         };
         let pmfw_curve = curve.into_pmfw_curve(current_pmfw_curve).unwrap();
-        let expected_points = [(40, 20), (50, 35), (60, 50), (70, 75), (80, 100)];
+        let expected_points = [(40, 30), (50, 35), (60, 50), (70, 75), (80, 100)];
         assert_eq!(&expected_points, pmfw_curve.points.as_ref());
     }
+
+    #[test]
+    fn curve_outside_of_limits_to_pmfw() {
+        let curve_invalid_temp =
+            FanCurve([(20, 0.4), (50, 0.35), (60, 0.5), (70, 0.75), (80, 1.0)].into());
+        let curve_invalid_speed =
+            FanCurve([(40, 0.1), (50, 0.35), (60, 0.5), (70, 0.75), (80, 1.0)].into());
+
+        let current_pmfw_curve = PmfwCurve {
+            points: Box::new([(0, 0); 5]),
+            allowed_ranges: Some(FanCurveRanges {
+                temperature_range: 25..=100,
+                speed_range: 30..=100,
+            }),
+        };
+        assert_eq!(
+            anyhow!("Temperature 20℃ is outside of the allowed range 25℃ to 100℃").to_string(),
+            curve_invalid_temp
+                .into_pmfw_curve(current_pmfw_curve.clone())
+                .unwrap_err()
+                .to_string()
+        );
+        assert_eq!(
+            anyhow!("Speed 10% is outside of the allowed range 30% to 100%").to_string(),
+            curve_invalid_speed
+                .into_pmfw_curve(current_pmfw_curve)
+                .unwrap_err()
+                .to_string()
+        );
+    }
 }

lact-daemon/src/server/gpu_controller/fan_control.rs

@@ -655,7 +655,7 @@ impl GpuController for IntelGpuController {
         }
     }
 
-    fn get_clocks_info(&self) -> anyhow::Result<ClocksInfo> {
+    fn get_clocks_info(&self, _gpu_config: Option<&config::Gpu>) -> anyhow::Result<ClocksInfo> {
         let clocks_table = IntelClocksTable {
             gt_freq: self
                 .read_freq(FrequencyType::Min)

lact-daemon/src/server/gpu_controller/intel.rs

@@ -483,7 +483,7 @@ impl GpuController for NvidiaGpuController {
     }
 
     #[allow(clippy::cast_possible_wrap)]
-    fn get_clocks_info(&self) -> anyhow::Result<ClocksInfo> {
+    fn get_clocks_info(&self, _gpu_config: Option<&config::Gpu>) -> anyhow::Result<ClocksInfo> {
         let device = self.device();
 
         let mut gpu_offsets = IndexMap::new();

lact-daemon/src/server/gpu_controller/nvidia.rs

@@ -72,6 +72,8 @@ const SNAPSHOT_DEVICE_FILES: &[&str] = &[
     "current_link_speed",
     "current_link_width",
     "power_dpm_force_performance_level",
+    "mem_info_vram_vendor",
+    "gpu_metrics",
 ];
 /// Prefixes for entries that will be recursively included in the debug snapshot
 const SNAPSHOT_DEVICE_RECURSIVE_PATHS_PREFIXES: &[&str] = &["tile"];
@@ -393,7 +395,9 @@ impl<'a> Handler {
     }
 
     pub async fn get_clocks_info(&'a self, id: &str) -> anyhow::Result<ClocksInfo> {
-        self.controller_by_id(id).await?.get_clocks_info()
+        let config = self.config.read().await;
+        let gpu_config = config.gpus()?.get(id);
+        self.controller_by_id(id).await?.get_clocks_info(gpu_config)
     }
 
     pub async fn set_fan_control(&'a self, opts: FanOptions<'_>) -> anyhow::Result<u64> {
@@ -739,7 +743,7 @@ impl<'a> Handler {
                 "pci_info": controller.controller_info().pci_info.clone(),
                 "info": controller.get_info().await,
                 "stats": controller.get_stats(gpu_config),
-                "clocks_info": controller.get_clocks_info().ok(),
+                "clocks_info": controller.get_clocks_info(gpu_config).ok(),
                 "power_profile_modes": controller.get_power_profile_modes().ok(),
                 "power_states": controller.get_power_states(gpu_config),
             });

lact-daemon/src/server/handler.rs

@@ -5,11 +5,11 @@ fan_control_settings:
   temperature_key: edge
   interval_ms: 500
   curve:
-    40: 0.14352942
+    40: 0.15
     50: 0.17411764
     60: 0.22352941
     70: 0.29
-    86: 0.5
+    86: 0.6
   spindown_delay_ms: 0
   change_threshold: 0
 pmfw_options: