archives/steamos-manager
archives/steamos-manager
2
0
Fork 1
mirror of https://gitlab.steamos.cloud/holo/steamos-manager.git synced 2025-07-04 21:50:36 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Kill UnsupportedFeature

Browse source
This commit is contained in:
Vicki Pfau 2024-03-29 15:30:55 -07:00
parent ffebee0930
commit 452690adee
4 changed files with 16 additions and 59 deletions
Download patch file Download diff file Expand all files Collapse all files

5
src/hardware.rs
View file

@ -26,7 +26,6 @@ pub enum HardwareVariant {
#[derive(PartialEq, Debug, Copy, Clone)]
#[repr(u32)]
pub enum HardwareCurrentlySupported {
UnsupportedFeature = 0,
Unsupported = 1,
Supported = 2,
}
@ -46,9 +45,6 @@ impl TryFrom<u32> for HardwareCurrentlySupported {
type Error = &'static str;
fn try_from(v: u32) -> Result<Self, Self::Error> {
match v {
x if x == HardwareCurrentlySupported::UnsupportedFeature as u32 => {
Ok(HardwareCurrentlySupported::UnsupportedFeature)
}
x if x == HardwareCurrentlySupported::Unsupported as u32 => {
Ok(HardwareCurrentlySupported::Unsupported)
}
@ -63,7 +59,6 @@ impl TryFrom<u32> for HardwareCurrentlySupported {
impl fmt::Display for HardwareCurrentlySupported {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
HardwareCurrentlySupported::UnsupportedFeature => write!(f, "Unsupported feature"),
HardwareCurrentlySupported::Unsupported => write!(f, "Unsupported"),
HardwareCurrentlySupported::Supported => write!(f, "Supported"),
}

40
src/manager.rs
View file

@ -11,7 +11,7 @@ use tokio::fs::File;
use tracing::error;
use zbus::{interface, zvariant::Fd};
use crate::hardware::{check_support, variant, HardwareCurrentlySupported, HardwareVariant};
use crate::hardware::{check_support, variant, HardwareVariant};
use crate::power::{
get_gpu_performance_level, set_gpu_clocks, set_gpu_performance_level, set_tdp_limit,
GPUPerformanceLevel,
@ -30,7 +30,6 @@ enum PrepareFactoryReset {
#[derive(PartialEq, Debug, Copy, Clone)]
#[repr(u32)]
enum FanControl {
UnsupportedFeature = 0,
BIOS = 1,
OS = 2,
}
@ -39,7 +38,6 @@ impl TryFrom<u32> for FanControl {
type Error = &'static str;
fn try_from(v: u32) -> Result<Self, Self::Error> {
match v {
x if x == FanControl::UnsupportedFeature as u32 => Ok(FanControl::UnsupportedFeature),
x if x == FanControl::BIOS as u32 => Ok(FanControl::BIOS),
x if x == FanControl::OS as u32 => Ok(FanControl::BIOS),
_ => Err("No enum match for value {v}"),
@ -50,7 +48,6 @@ impl TryFrom<u32> for FanControl {
impl fmt::Display for FanControl {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
FanControl::UnsupportedFeature => write!(f, "Unsupported feature"),
FanControl::BIOS => write!(f, "BIOS"),
FanControl::OS => write!(f, "OS"),
}
@ -94,8 +91,8 @@ impl SteamOSManager {
}
#[zbus(property)]
fn wifi_power_management_state(&self) -> u32 {
WifiPowerManagement::UnsupportedFeature as u32 // TODO
fn wifi_power_management_state(&self) -> zbus::fdo::Result<u32> {
Err(zbus::fdo::Error::UnknownProperty(String::from("This property can't currently be read")))
}
#[zbus(property)]
@ -107,12 +104,6 @@ impl SteamOSManager {
let state = match state {
WifiPowerManagement::Disabled => "off",
WifiPowerManagement::Enabled => "on",
WifiPowerManagement::UnsupportedFeature => {
return Err(zbus::fdo::Error::InvalidArgs(String::from(
"Can't set state to unsupported",
))
.into())
}
};
run_script(
@ -125,8 +116,8 @@ impl SteamOSManager {
}
#[zbus(property)]
fn fan_control_state(&self) -> u32 {
FanControl::UnsupportedFeature as u32 // TODO
fn fan_control_state(&self) -> zbus::fdo::Result<u32> {
Err(zbus::fdo::Error::UnknownProperty(String::from("This property can't currently be read")))
}
#[zbus(property)]
@ -138,12 +129,6 @@ impl SteamOSManager {
let state = match state {
FanControl::OS => "stop",
FanControl::BIOS => "start",
FanControl::UnsupportedFeature => {
return Err(zbus::fdo::Error::InvalidArgs(String::from(
"Can't set state to unsupported",
))
.into())
}
};
// Run what steamos-polkit-helpers/jupiter-fan-control does
@ -157,10 +142,10 @@ impl SteamOSManager {
}
#[zbus(property)]
async fn hardware_currently_supported(&self) -> u32 {
async fn hardware_currently_supported(&self) -> zbus::fdo::Result<u32> {
match check_support().await {
Ok(res) => res as u32,
Err(_) => HardwareCurrentlySupported::UnsupportedFeature as u32,
Ok(res) => Ok(res as u32),
Err(e) => Err(anyhow_to_zbus_fdo(e)),
}
}
@ -246,10 +231,10 @@ impl SteamOSManager {
}
#[zbus(property)]
async fn gpu_performance_level(&self) -> u32 {
async fn gpu_performance_level(&self) -> zbus::fdo::Result<u32> {
match get_gpu_performance_level().await {
Ok(level) => level as u32,
Err(_) => GPUPerformanceLevel::UnsupportedFeature as u32,
Ok(level) => Ok(level as u32),
Err(e) => Err(anyhow_to_zbus_fdo(e)),
}
}
@ -288,9 +273,6 @@ impl SteamOSManager {
// Return false on error
let wanted_mode = match WifiDebugMode::try_from(mode) {
Ok(WifiDebugMode::UnsupportedFeature) => {
return Err(zbus::fdo::Error::InvalidArgs(String::from("Invalid mode")))
}
Ok(mode) => mode,
Err(e) => return Err(zbus::fdo::Error::InvalidArgs(e.to_string())),
};

16
src/power.rs
View file

@ -22,7 +22,6 @@ const GPU_CLOCKS_PATH: &str = "/sys/class/drm/card0/device/pp_od_clk_voltage";
#[derive(PartialEq, Debug, Copy, Clone)]
#[repr(u32)]
pub enum GPUPerformanceLevel {
UnsupportedFeature = 0,
Auto = 1,
Low = 2,
High = 3,
@ -34,9 +33,6 @@ impl TryFrom<u32> for GPUPerformanceLevel {
type Error = &'static str;
fn try_from(v: u32) -> Result<Self, Self::Error> {
match v {
x if x == GPUPerformanceLevel::UnsupportedFeature as u32 => {
Ok(GPUPerformanceLevel::UnsupportedFeature)
}
x if x == GPUPerformanceLevel::Auto as u32 => Ok(GPUPerformanceLevel::Auto),
x if x == GPUPerformanceLevel::Low as u32 => Ok(GPUPerformanceLevel::Low),
x if x == GPUPerformanceLevel::High as u32 => Ok(GPUPerformanceLevel::High),
@ -63,17 +59,15 @@ impl FromStr for GPUPerformanceLevel {
}
}
impl TryInto<String> for GPUPerformanceLevel {
type Error = Error;
fn try_into(self) -> Result<String, Self::Error> {
Ok(String::from(match self {
impl ToString for GPUPerformanceLevel {
fn to_string(&self) -> String {
String::from(match self {
GPUPerformanceLevel::Auto => "auto",
GPUPerformanceLevel::Low => "low",
GPUPerformanceLevel::High => "high",
GPUPerformanceLevel::Manual => "manual",
GPUPerformanceLevel::ProfilePeak => "peak_performance",
GPUPerformanceLevel::UnsupportedFeature => bail!("No valid string representation"),
}))
})
}
}
@ -90,7 +84,7 @@ pub async fn set_gpu_performance_level(level: GPUPerformanceLevel) -> Result<()>
.await
.inspect_err(|message| error!("Error opening sysfs file for writing: {message}"))?;
let level: String = level.try_into()?;
let level: String = level.to_string();
myfile
.write_all(level.as_bytes())

14
src/wifi.rs
View file

@ -29,7 +29,6 @@ const MIN_BUFFER_SIZE: u32 = 100;
#[derive(PartialEq, Debug, Copy, Clone)]
#[repr(u32)]
pub enum WifiDebugMode {
UnsupportedFeature = 0,
Off = 1,
On = 2,
}
@ -37,7 +36,6 @@ pub enum WifiDebugMode {
#[derive(PartialEq, Debug, Copy, Clone)]
#[repr(u32)]
pub enum WifiPowerManagement {
UnsupportedFeature = 0,
Disabled = 1,
Enabled = 2,
}
@ -46,9 +44,6 @@ impl TryFrom<u32> for WifiDebugMode {
type Error = &'static str;
fn try_from(v: u32) -> Result<Self, Self::Error> {
match v {
x if x == WifiDebugMode::UnsupportedFeature as u32 => {
Ok(WifiDebugMode::UnsupportedFeature)
}
x if x == WifiDebugMode::Off as u32 => Ok(WifiDebugMode::Off),
x if x == WifiDebugMode::On as u32 => Ok(WifiDebugMode::On),
_ => Err("No enum match for value {v}"),
@ -59,7 +54,6 @@ impl TryFrom<u32> for WifiDebugMode {
impl fmt::Display for WifiDebugMode {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
WifiDebugMode::UnsupportedFeature => write!(f, "Unsupported feature"),
WifiDebugMode::Off => write!(f, "Off"),
WifiDebugMode::On => write!(f, "On"),
}
@ -70,9 +64,6 @@ impl TryFrom<u32> for WifiPowerManagement {
type Error = &'static str;
fn try_from(v: u32) -> Result<Self, Self::Error> {
match v {
x if x == WifiPowerManagement::UnsupportedFeature as u32 => {
Ok(WifiPowerManagement::UnsupportedFeature)
}
x if x == WifiPowerManagement::Disabled as u32 => Ok(WifiPowerManagement::Disabled),
x if x == WifiPowerManagement::Enabled as u32 => Ok(WifiPowerManagement::Enabled),
_ => Err("No enum match for value {v}"),
@ -83,7 +74,6 @@ impl TryFrom<u32> for WifiPowerManagement {
impl fmt::Display for WifiPowerManagement {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
WifiPowerManagement::UnsupportedFeature => write!(f, "Unsupported feature"),
WifiPowerManagement::Disabled => write!(f, "Disabled"),
WifiPowerManagement::Enabled => write!(f, "Enabled"),
}
@ -188,10 +178,6 @@ pub async fn set_wifi_debug_mode(
};
}
}
mode => {
// Invalid mode requested, more coming later, but add this catch-all for now
bail!("Invalid wifi debug mode {mode} requested");
}
}
Ok(())
}