use super::traits::{
Clocks, Device, Error, FanSpeed, GpuProcess, Memory, PciInfo, Power, Temperature,
TemperatureThresholds, Utilization, Vendor,
};
use std::fs;
use std::path::PathBuf;
pub struct AmdGpu {
index: u32,
#[allow(dead_code)]
card_path: PathBuf,
device_path: PathBuf,
hwmon_dir: Option<PathBuf>,
}
impl AmdGpu {
pub fn new(index: u32, card_path: PathBuf) -> Result<Self, Error> {
let device_path = card_path.join("device");
if !device_path.exists() {
return Err(Error::InitializationFailed(
"Device path does not exist".to_string(),
));
}
let hwmon_dir = fs::read_dir(device_path.join("hwmon")).ok().and_then(|rd| {
rd.filter_map(|e| e.ok())
.find(|e| e.file_name().to_string_lossy().starts_with("hwmon"))
.map(|e| e.path())
});
Ok(Self {
index,
card_path,
device_path,
hwmon_dir,
})
}
fn read_sysfs_string(&self, attr: &str) -> Option<String> {
fs::read_to_string(self.device_path.join(attr))
.ok()
.map(|s| s.trim().to_string())
}
fn read_sysfs_u64(&self, attr: &str) -> Option<u64> {
self.read_sysfs_string(attr)?.parse::<u64>().ok()
}
}
impl AmdGpu {
fn read_hwmon_temp(&self, hwmon_path: &std::path::Path, sensor: &str) -> Option<f32> {
fs::read_to_string(hwmon_path.join(sensor))
.ok()
.and_then(|s| s.trim().parse::<i32>().ok())
.map(|millidegrees| millidegrees as f32 / 1000.0)
}
fn get_temperature_thresholds(
&self,
hwmon_path: &std::path::Path,
) -> Option<TemperatureThresholds> {
let critical = self
.read_hwmon_temp(hwmon_path, "temp1_crit")
.or_else(|| self.read_hwmon_temp(hwmon_path, "temp2_crit"));
let shutdown = self
.read_hwmon_temp(hwmon_path, "temp1_emergency")
.or_else(|| self.read_hwmon_temp(hwmon_path, "temp2_emergency"));
let memory_critical = self.read_hwmon_temp(hwmon_path, "temp3_crit");
let slowdown = critical.map(|c| c * 0.85);
if critical.is_some() || shutdown.is_some() || slowdown.is_some() {
Some(TemperatureThresholds {
slowdown,
shutdown,
critical,
memory_critical,
})
} else {
None
}
}
fn read_current_clock(&self, file: &str) -> Option<u32> {
let content = self.read_sysfs_string(file)?;
for line in content.lines() {
if line.contains('*') {
let parts: Vec<&str> = line.split(':').collect();
if parts.len() >= 2 {
let freq_str = parts[1]
.trim()
.replace("Mhz", "")
.replace("*", "")
.trim()
.to_string();
if let Ok(freq) = freq_str.parse::<u32>() {
return Some(freq);
}
}
}
}
None
}
}
impl Device for AmdGpu {
fn vendor(&self) -> Vendor {
Vendor::Amd
}
fn index(&self) -> u32 {
self.index
}
fn name(&self) -> Result<String, Error> {
if let Some(name) = self.read_sysfs_string("product_name") {
return Ok(name);
}
if let Some(device_id) = self.read_sysfs_string("device") {
return Ok(format!("AMD GPU {}", device_id));
}
Ok(format!("AMD GPU #{}", self.index))
}
fn uuid(&self) -> Result<String, Error> {
let vendor = self.read_sysfs_string("vendor").unwrap_or_default();
let device = self.read_sysfs_string("device").unwrap_or_default();
let serial = self
.read_sysfs_string("serial")
.unwrap_or_else(|| format!("{}", self.index));
Ok(format!("GPU-{}-{}-{}", vendor, device, serial))
}
fn pci_info(&self) -> Result<PciInfo, Error> {
let link = fs::read_link(&self.device_path)
.map_err(|e| Error::QueryFailed(format!("Failed to read device link: {}", e)))?;
let path_str = link.to_string_lossy();
for component in path_str.split('/').rev() {
let parts: Vec<&str> = component.split(':').collect();
if parts.len() == 3 {
let domain_bus = parts[0];
let device_func = parts[2].split('.').collect::<Vec<&str>>();
if domain_bus.len() == 7 && device_func.len() == 2 {
if let (Ok(domain), Ok(bus), Ok(device), Ok(function)) = (
u16::from_str_radix(&domain_bus[0..4], 16),
u8::from_str_radix(&domain_bus[5..7], 16),
u8::from_str_radix(parts[1], 16),
u8::from_str_radix(device_func[1], 16),
) {
let bus_id =
format!("{:04x}:{:02x}:{:02x}.{}", domain, bus, device, function);
return Ok(PciInfo {
domain: domain as u32,
bus,
device,
function,
bus_id,
pcie_generation: None,
pcie_link_width: None,
});
}
}
}
}
Err(Error::QueryFailed("Could not parse PCI info".to_string()))
}
fn driver_version(&self) -> Result<String, Error> {
if let Ok(version) = fs::read_to_string("/sys/module/amdgpu/version") {
return Ok(version.trim().to_string());
}
if let Some(driver) = self.read_sysfs_string("driver") {
return Ok(driver);
}
Ok("amdgpu".to_string())
}
fn temperature(&self) -> Result<Temperature, Error> {
let hwmon = self.hwmon_dir.as_ref().ok_or(Error::NotSupported)?;
let edge = self.read_hwmon_temp(hwmon, "temp1_input");
let junction = self.read_hwmon_temp(hwmon, "temp2_input");
let memory = self.read_hwmon_temp(hwmon, "temp3_input");
let thresholds = self.get_temperature_thresholds(hwmon);
Ok(Temperature {
edge,
junction,
memory,
hotspot: None,
vr_gfx: None,
vr_soc: None,
vr_mem: None,
hbm: None,
thresholds,
})
}
fn power(&self) -> Result<Power, Error> {
let hwmon = self.hwmon_dir.as_ref().ok_or(Error::NotSupported)?;
let read_power = |sensor: &str| -> Option<f32> {
fs::read_to_string(hwmon.join(sensor))
.ok()
.and_then(|s| s.trim().parse::<u64>().ok())
.map(|microwatts| microwatts as f32 / 1_000_000.0)
};
let current = read_power("power1_average");
let limit = read_power("power1_cap");
let max_limit = read_power("power1_cap_max");
let min_limit = read_power("power1_cap_min");
Ok(Power {
current,
average: current,
limit,
default_limit: limit,
min_limit,
max_limit,
enforced_limit: limit,
})
}
fn clocks(&self) -> Result<Clocks, Error> {
let graphics = self.read_current_clock("pp_dpm_sclk");
let memory = self.read_current_clock("pp_dpm_mclk");
Ok(Clocks {
graphics,
memory,
sm: None,
video: None,
})
}
fn utilization(&self) -> Result<Utilization, Error> {
let gpu = self
.read_sysfs_string("gpu_busy_percent")
.and_then(|s| s.parse::<f32>().ok());
let memory = None;
Ok(Utilization {
gpu,
memory,
encoder: None,
decoder: None,
jpeg: None,
ofa: None,
})
}
fn memory(&self) -> Result<Memory, Error> {
let total = self.read_sysfs_u64("mem_info_vram_total");
let used = self.read_sysfs_u64("mem_info_vram_used");
let free = match (total, used) {
(Some(t), Some(u)) => Some(t.saturating_sub(u)),
_ => None,
};
Ok(Memory {
total,
used,
free,
bar1_total: None,
bar1_used: None,
})
}
fn fan_speed(&self) -> Result<Option<FanSpeed>, Error> {
let hwmon = match self.hwmon_dir.as_ref() {
Some(p) => p,
None => return Ok(None),
};
if let Some(pwm) = fs::read_to_string(hwmon.join("pwm1"))
.ok()
.and_then(|s| s.trim().parse::<u32>().ok())
{
let pwm_max = fs::read_to_string(hwmon.join("pwm1_max"))
.ok()
.and_then(|s| s.trim().parse::<u32>().ok())
.unwrap_or(255);
let percentage = (pwm * 100) / pwm_max;
return Ok(Some(FanSpeed::Percent(percentage)));
}
if let Some(rpm) = fs::read_to_string(hwmon.join("fan1_input"))
.ok()
.and_then(|s| s.trim().parse::<u32>().ok())
{
return Ok(Some(FanSpeed::Rpm(rpm)));
}
Ok(None)
}
fn performance_state(&self) -> Result<Option<String>, Error> {
Ok(self.read_sysfs_string("power_dpm_force_performance_level"))
}
fn processes(&self) -> Result<Vec<Box<dyn GpuProcess>>, Error> {
Ok(Vec::new())
}
fn set_power_limit(&mut self, watts: f32) -> Result<(), Error> {
let hwmon = self.hwmon_dir.as_ref().ok_or(Error::NotSupported)?;
let microwatts = (watts * 1_000_000.0) as u64;
let max_cap = fs::read_to_string(hwmon.join("power1_cap_max"))
.ok()
.and_then(|s| s.trim().parse::<u64>().ok())
.unwrap_or(u64::MAX);
let min_cap = fs::read_to_string(hwmon.join("power1_cap_min"))
.ok()
.and_then(|s| s.trim().parse::<u64>().ok())
.unwrap_or(0);
if microwatts > max_cap || microwatts < min_cap {
return Err(Error::InvalidArgument(format!(
"Power limit {:.1}W outside range [{:.1}W, {:.1}W]",
watts,
min_cap as f32 / 1_000_000.0,
max_cap as f32 / 1_000_000.0
)));
}
fs::write(hwmon.join("power1_cap"), microwatts.to_string()).map_err(|e| {
if e.kind() == std::io::ErrorKind::PermissionDenied {
Error::PermissionDenied("Setting power limit requires root".to_string())
} else {
Error::ControlFailed(format!("Failed to set power limit: {}", e))
}
})
}
fn lock_gpu_clocks(&mut self, min_mhz: u32, max_mhz: u32) -> Result<(), Error> {
fs::write(
self.device_path.join("power_dpm_force_performance_level"),
"manual",
)
.map_err(|e| {
if e.kind() == std::io::ErrorKind::PermissionDenied {
Error::PermissionDenied("Setting GPU clocks requires root".to_string())
} else {
Error::ControlFailed(format!("Failed to set performance level: {}", e))
}
})?;
let od_path = self.device_path.join("pp_od_clk_voltage");
if od_path.exists() {
fs::write(&od_path, format!("s 0 {}", min_mhz))
.map_err(|e| Error::ControlFailed(format!("Failed to set min clock: {}", e)))?;
fs::write(&od_path, format!("s 1 {}", max_mhz))
.map_err(|e| Error::ControlFailed(format!("Failed to set max clock: {}", e)))?;
fs::write(&od_path, "c")
.map_err(|e| Error::ControlFailed(format!("Failed to commit clocks: {}", e)))?;
}
Ok(())
}
fn reset_gpu_clocks(&mut self) -> Result<(), Error> {
fs::write(
self.device_path.join("power_dpm_force_performance_level"),
"auto",
)
.map_err(|e| {
if e.kind() == std::io::ErrorKind::PermissionDenied {
Error::PermissionDenied("Resetting GPU clocks requires root".to_string())
} else {
Error::ControlFailed(format!("Failed to reset performance level: {}", e))
}
})?;
let od_path = self.device_path.join("pp_od_clk_voltage");
if od_path.exists() {
fs::write(&od_path, "r").ok(); fs::write(&od_path, "c").ok(); }
Ok(())
}
}
pub fn enumerate() -> Result<Vec<Box<dyn Device>>, Error> {
let mut devices: Vec<Box<dyn Device>> = Vec::new();
let drm_path = std::path::Path::new("/sys/class/drm");
if !drm_path.exists() {
return Ok(devices);
}
let entries = fs::read_dir(drm_path).map_err(|e| {
Error::InitializationFailed(format!("Failed to read /sys/class/drm: {}", e))
})?;
for entry in entries.filter_map(|e| e.ok()) {
let name = entry.file_name();
let name_str = name.to_string_lossy();
if !name_str.starts_with("card") || name_str.contains('-') {
continue;
}
let index = name_str.trim_start_matches("card").parse::<u32>().ok();
let Some(index) = index else {
continue;
};
let card_path = entry.path();
let device_path = card_path.join("device");
if let Ok(vendor_id) = fs::read_to_string(device_path.join("vendor")) {
if vendor_id.trim() == "0x1002" {
match AmdGpu::new(index, card_path) {
Ok(gpu) => devices.push(Box::new(gpu)),
Err(_) => continue,
}
}
}
}
if devices.is_empty() {
return Err(Error::NoDevicesFound);
}
Ok(devices)
}