From b4fb6dceb5b8aef8696a335c302ce88c5ab72ad2 Mon Sep 17 00:00:00 2001
From: Florian Warzecha <liketechnik@disroot.org>
Date: Wed, 1 May 2024 18:24:44 +0200
Subject: [PATCH 1/3] feat(tuxedo_sysfs): implement charging profiles

---
 tailor_hwcaps/src/main.rs                     |  57 ++++++++
 tuxedo_sysfs/src/charging/charge_control.rs   | 128 ++++++++++++++++++
 tuxedo_sysfs/src/charging/charging_profile.rs |  68 ++++++++++
 tuxedo_sysfs/src/charging/mod.rs              |  38 ++++++
 tuxedo_sysfs/src/lib.rs                       |   1 +
 tuxedo_sysfs/src/sysfs_util.rs                |  24 ++++
 6 files changed, 316 insertions(+)
 create mode 100644 tuxedo_sysfs/src/charging/charge_control.rs
 create mode 100644 tuxedo_sysfs/src/charging/charging_profile.rs
 create mode 100644 tuxedo_sysfs/src/charging/mod.rs

diff --git a/tailor_hwcaps/src/main.rs b/tailor_hwcaps/src/main.rs
index bb4fea0..0a18d87 100644
--- a/tailor_hwcaps/src/main.rs
+++ b/tailor_hwcaps/src/main.rs
@@ -107,4 +107,61 @@ async fn sysfs() {
         print_value("LED mode", &controller.mode());
         print_value("LED device color", &controller.get_color().await);
     }
+
+    let mut charging_profile = tuxedo_sysfs::charging::ChargingProfile::new()
+        .await
+        .unwrap();
+    print_value(
+        "Available charging profiles",
+        &charging_profile.available_charging_profiles,
+    );
+    print_value(
+        "Current charging profile",
+        &charging_profile.get_charging_profile().await.unwrap(),
+    );
+    if let Some(priorities) = &charging_profile.available_charging_priorities {
+        print_value("Available charging priorities", priorities);
+    } else {
+        print_info("Charging priority control is not available");
+    }
+    if let Some(priority) = charging_profile.get_charging_priority().await.unwrap() {
+        print_value("Current charging priority", &priority);
+    }
+
+    let first_battery = tuxedo_sysfs::charging::BatteryChargeControl::new_first_battery()
+        .await
+        .unwrap();
+    if let Some(mut first_battery) = first_battery {
+        print_value("Battery name", &first_battery.name);
+        print_value(
+            "Battery charge type",
+            &first_battery.get_charge_type().await.unwrap(),
+        );
+        if let Some(available_start_thresholds) = &first_battery.available_start_thresholds {
+            print_value(
+                "Available charge control start thresholds",
+                available_start_thresholds,
+            );
+        } else {
+            print_info("Available charge control start thresholds not available");
+        }
+        print_value(
+            "Battery start threshold",
+            &first_battery.get_start_threshold().await.unwrap(),
+        );
+        if let Some(available_end_thresholds) = &first_battery.available_end_thresholds {
+            print_value(
+                "Available charge control end thresholds",
+                available_end_thresholds,
+            );
+        } else {
+            print_info("Available charge control end thresholds not available");
+        }
+        print_value(
+            "Battery end threshold",
+            &first_battery.get_end_threshold().await.unwrap(),
+        );
+    } else {
+        print_info("Charge control for start/end thresholds is not available");
+    }
 }
diff --git a/tuxedo_sysfs/src/charging/charge_control.rs b/tuxedo_sysfs/src/charging/charge_control.rs
new file mode 100644
index 0000000..b9b2970
--- /dev/null
+++ b/tuxedo_sysfs/src/charging/charge_control.rs
@@ -0,0 +1,128 @@
+use std::io;
+
+use crate::sysfs_util::{
+    r_file, read_int_list, read_path_to_int_list, read_path_to_string, read_to_string,
+};
+
+use super::BatteryChargeControl;
+
+const SYSFS_POWER_SUPPLY_PATH: &str = "/sys/class/power_supply";
+const TYPE: &str = "/type";
+const CHARGE_TYPE: &str = "/charge_type";
+const START_THRESHOLD: &str = "/charge_control_start_threshold";
+const END_THRESHOLD: &str = "/charge_control_end_threshold";
+const AVAILABLE_START_THRESHOLDS: &str = "/charge_control_start_available_thresholds";
+const AVAILABLE_END_THRESHOLDS: &str = "/charge_control_end_available_thresholds";
+
+impl BatteryChargeControl {
+    pub async fn new(
+        name: String,
+        available_start_thresholds: Option<Vec<u32>>,
+        available_end_thresholds: Option<Vec<u32>>,
+        start_threshold_file: tokio_uring::fs::File,
+        end_threshold_file: tokio_uring::fs::File,
+        charge_type_file: tokio_uring::fs::File,
+    ) -> Result<Self, io::Error> {
+        Ok(Self {
+            name,
+            available_start_thresholds,
+            available_end_thresholds,
+            start_threshold_file,
+            end_threshold_file,
+            charge_type_file,
+        })
+    }
+
+    pub async fn new_first_battery() -> Result<Option<Self>, io::Error> {
+        let mut dirs = tokio::fs::read_dir(SYSFS_POWER_SUPPLY_PATH).await?;
+        while let Some(dir) = dirs.next_entry().await? {
+            let path = dir.path();
+
+            let file_name = path
+                .file_name()
+                .expect("the sysfs path must have a last segment");
+
+            let type_path = path.join(TYPE);
+            if let Ok(typ) = read_path_to_string(type_path).await {
+                // not a battery, uninteresting
+                if typ.trim() != "Battery" {
+                    continue;
+                }
+            } else {
+                tracing::warn!("Type file can't be read: {:?}", file_name);
+                continue;
+            }
+
+            let start_threshold_file =
+                if let Ok(start_threshold_file) = r_file(path.join(START_THRESHOLD)).await {
+                    start_threshold_file
+                } else {
+                    // thresholds not supported
+                    continue;
+                };
+            let end_threshold_file =
+                if let Ok(end_threshold_file) = r_file(path.join(END_THRESHOLD)).await {
+                    end_threshold_file
+                } else {
+                    // thresholds not supported
+                    continue;
+                };
+            let charge_type_file =
+                if let Ok(charge_type_file) = r_file(path.join(CHARGE_TYPE)).await {
+                    charge_type_file
+                } else {
+                    // thresholds not supported
+                    continue;
+                };
+
+            let available_start_thresholds_file = path.join(AVAILABLE_START_THRESHOLDS);
+            let available_start_thresholds = read_path_to_int_list(available_start_thresholds_file)
+                .await
+                .ok();
+
+            let available_end_thresholds_file = path.join(AVAILABLE_END_THRESHOLDS);
+            let available_end_thresholds = read_path_to_int_list(available_end_thresholds_file)
+                .await
+                .ok();
+
+            let name = file_name.to_string_lossy().into_owned();
+
+            // TODO: if there is more than 1 battery in the system,
+            // there is no guarantee which one is returned
+            return Ok(Some(
+                BatteryChargeControl::new(
+                    name,
+                    available_start_thresholds,
+                    available_end_thresholds,
+                    start_threshold_file,
+                    end_threshold_file,
+                    charge_type_file,
+                )
+                .await?,
+            ));
+        }
+
+        Ok(None)
+    }
+
+    pub async fn get_start_threshold(&mut self) -> Result<u32, io::Error> {
+        Ok(*read_int_list(&mut self.start_threshold_file)
+            .await?
+            .first()
+            .expect("start threshold file returns a value on read"))
+    }
+
+    pub async fn get_end_threshold(&mut self) -> Result<u32, io::Error> {
+        Ok(*read_int_list(&mut self.end_threshold_file)
+            .await?
+            .first()
+            .expect("end threshold file returns a value on read"))
+    }
+
+    pub async fn get_charge_type(&mut self) -> Result<String, io::Error> {
+        Ok(read_to_string(&mut self.charge_type_file)
+            .await?
+            .trim()
+            .to_owned())
+    }
+}
diff --git a/tuxedo_sysfs/src/charging/charging_profile.rs b/tuxedo_sysfs/src/charging/charging_profile.rs
new file mode 100644
index 0000000..765d52c
--- /dev/null
+++ b/tuxedo_sysfs/src/charging/charging_profile.rs
@@ -0,0 +1,68 @@
+use std::io;
+
+use crate::sysfs_util::{
+    r_file, read_path_to_string_list, read_to_string, read_to_string_list, rw_file,
+};
+
+use super::ChargingProfile;
+
+const CHARGING_PROFILE_PATH: &str =
+    "/sys/devices/platform/tuxedo_keyboard/charging_profile/charging_profile";
+const CHARGING_PROFILES_AVAILABLE_PATH: &str =
+    "/sys/devices/platform/tuxedo_keyboard/charging_profile/charging_profiles_available";
+const CHARGING_PRIORITY_PATH: &str =
+    "/sys/devices/platform/tuxedo_keyboard/charging_profile/charging_prio";
+const CHARGING_PRIORITIES_AVAILABLE_PATH: &str =
+    "/sys/devices/platform/tuxedo_keyboard/charging_profile/charging_prios_available";
+
+impl ChargingProfile {
+    // TODO: should this return Option<Self, io::Error> in case the whole charging_profile thing is unavailable?
+    pub async fn new() -> Result<Self, io::Error> {
+        let available_charging_profiles =
+            read_path_to_string_list(CHARGING_PROFILES_AVAILABLE_PATH).await?;
+        let charging_profile_file = rw_file(CHARGING_PROFILE_PATH).await?;
+
+        let (available_charging_priorities, charging_priority_file) =
+            if let Ok(mut available_charging_priorities_file) =
+                r_file(CHARGING_PRIORITIES_AVAILABLE_PATH).await
+            {
+                let priorities =
+                    read_to_string_list(&mut available_charging_priorities_file).await?;
+
+                let priority_file = rw_file(CHARGING_PRIORITY_PATH).await?;
+                (Some(priorities), Some(priority_file))
+            } else {
+                (None, None)
+            };
+
+        Ok(ChargingProfile {
+            available_charging_profiles,
+            charging_profile_file,
+            available_charging_priorities,
+            charging_priority_file,
+        })
+    }
+
+    pub async fn get_charging_profile(&mut self) -> Result<String, io::Error> {
+        Ok(read_to_string(&mut self.charging_profile_file)
+            .await?
+            .trim()
+            .to_owned())
+    }
+
+    // TODO: should this return Result<Option> or Option<Result>?
+    pub async fn get_charging_priority(&mut self) -> Result<Option<String>, io::Error> {
+        if let Some(charging_priority_file) = &mut self.charging_priority_file {
+            Ok(Some(
+                read_to_string(charging_priority_file)
+                    .await?
+                    .trim()
+                    .to_owned(),
+            ))
+        } else {
+            Ok(None)
+        }
+    }
+
+    // TODO: set_prio: how does this error in case prio is unavailable?
+}
diff --git a/tuxedo_sysfs/src/charging/mod.rs b/tuxedo_sysfs/src/charging/mod.rs
new file mode 100644
index 0000000..c26aa78
--- /dev/null
+++ b/tuxedo_sysfs/src/charging/mod.rs
@@ -0,0 +1,38 @@
+mod charge_control;
+mod charging_profile;
+
+// TODO: split ChargingProfile into Profile + Priority?
+// this would make the double Option<> thing for available + file less awkward to work with...
+// + it would make the get/set (especially set) charging_prio less awkward
+
+/// A type that manages all sysfs files related to
+/// charging profile options provided by the tuxedo_keyboard driver.
+///
+/// The charging profile imposes a firmware-enforced limit on the maximum charge of the
+/// battery.
+//
+// The charging priority allows prioritizing charging speed or system performance when charging via
+// USB-C.
+pub struct ChargingProfile {
+    pub available_charging_profiles: Vec<String>,
+    charging_profile_file: tokio_uring::fs::File,
+    pub available_charging_priorities: Option<Vec<String>>,
+    charging_priority_file: Option<tokio_uring::fs::File>,
+}
+
+/// A type that manages all sysfs files related to charging start/end thresholds.
+pub struct BatteryChargeControl {
+    pub name: String,
+    pub available_start_thresholds: Option<Vec<u32>>,
+    pub available_end_thresholds: Option<Vec<u32>>,
+    /// Percentage value between 0-100,
+    /// [`Self::available_start_thresholds`] lists further restrictions on accepted values.
+    start_threshold_file: tokio_uring::fs::File,
+    /// Percentage value between 0-100,
+    /// [`Self::available_end_thresholds`] lists further restrictions on accepted values.
+    end_threshold_file: tokio_uring::fs::File,
+    /// Must be 'Custom' to allow for custom thresholds.
+    ///
+    /// Possible values listed at <https://www.kernel.org/doc/Documentation/ABI/testing/sysfs-class-power> (section: /sys/class/power_supply/<supply_name>/charge_type)
+    charge_type_file: tokio_uring::fs::File,
+}
diff --git a/tuxedo_sysfs/src/lib.rs b/tuxedo_sysfs/src/lib.rs
index abede48..ef716aa 100644
--- a/tuxedo_sysfs/src/lib.rs
+++ b/tuxedo_sysfs/src/lib.rs
@@ -1,2 +1,3 @@
+pub mod charging;
 pub mod led;
 pub(crate) mod sysfs_util;
diff --git a/tuxedo_sysfs/src/sysfs_util.rs b/tuxedo_sysfs/src/sysfs_util.rs
index b83d537..a8f21a6 100644
--- a/tuxedo_sysfs/src/sysfs_util.rs
+++ b/tuxedo_sysfs/src/sysfs_util.rs
@@ -36,6 +36,14 @@ pub(crate) async fn read_to_string(file: &mut fs::File) -> Result<String, io::Er
     String::from_utf8(buffer).map_err(|err| io::Error::new(io::ErrorKind::InvalidData, err))
 }
 
+pub(crate) async fn read_path_to_int_list<P>(path: P) -> Result<Vec<u32>, io::Error>
+where
+    P: AsRef<Path>,
+{
+    let mut file = r_file(path).await?;
+    read_int_list(&mut file).await
+}
+
 pub(crate) async fn read_int_list(file: &mut fs::File) -> Result<Vec<u32>, io::Error> {
     let content = read_to_string(file).await?;
 
@@ -55,6 +63,22 @@ pub(crate) async fn read_int_list(file: &mut fs::File) -> Result<Vec<u32>, io::E
     }
 }
 
+pub(crate) async fn read_path_to_string_list<P>(path: P) -> Result<Vec<String>, io::Error>
+where
+    P: AsRef<Path>,
+{
+    let mut file = r_file(path).await?;
+    read_to_string_list(&mut file).await
+}
+
+pub(crate) async fn read_to_string_list(file: &mut fs::File) -> Result<Vec<String>, io::Error> {
+    let output = read_to_string(file).await?;
+    Ok(output
+        .split(' ')
+        .map(|s| s.trim().to_owned())
+        .collect::<Vec<String>>())
+}
+
 async fn write_buffer<V>(file: &mut fs::File, value: V) -> Result<(), io::Error>
 where
     V: tokio_uring::buf::IoBuf,

From 56c6734edf33c882f3b2ff03fa810272b8dbed8f Mon Sep 17 00:00:00 2001
From: Florian Warzecha <liketechnik@disroot.org>
Date: Sat, 1 Jun 2024 11:05:13 +0200
Subject: [PATCH 2/3] refactor(tuxedo_sysfs/charging): split-up profiles and
 priorities

---
 tailor_hwcaps/src/main.rs                     | 40 +++++++++-----
 .../src/charging/charging_priority.rs         | 35 ++++++++++++
 tuxedo_sysfs/src/charging/charging_profile.rs | 53 ++++---------------
 tuxedo_sysfs/src/charging/mod.rs              | 20 +++----
 tuxedo_sysfs/src/sysfs_util.rs                |  8 ---
 5 files changed, 82 insertions(+), 74 deletions(-)
 create mode 100644 tuxedo_sysfs/src/charging/charging_priority.rs

diff --git a/tailor_hwcaps/src/main.rs b/tailor_hwcaps/src/main.rs
index 0a18d87..5aa6e12 100644
--- a/tailor_hwcaps/src/main.rs
+++ b/tailor_hwcaps/src/main.rs
@@ -108,24 +108,36 @@ async fn sysfs() {
         print_value("LED device color", &controller.get_color().await);
     }
 
-    let mut charging_profile = tuxedo_sysfs::charging::ChargingProfile::new()
+    let charging_profile = tuxedo_sysfs::charging::ChargingProfile::new()
         .await
         .unwrap();
-    print_value(
-        "Available charging profiles",
-        &charging_profile.available_charging_profiles,
-    );
-    print_value(
-        "Current charging profile",
-        &charging_profile.get_charging_profile().await.unwrap(),
-    );
-    if let Some(priorities) = &charging_profile.available_charging_priorities {
-        print_value("Available charging priorities", priorities);
+    if let Some(mut charging_profile) = charging_profile {
+        print_value(
+            "Available charging profiles",
+            &charging_profile.available_charging_profiles,
+        );
+        print_value(
+            "Current charging profile",
+            &charging_profile.get_charging_profile().await.unwrap(),
+        );
     } else {
-        print_info("Charging priority control is not available");
+        print_info("Charging profile control is not available");
     }
-    if let Some(priority) = charging_profile.get_charging_priority().await.unwrap() {
-        print_value("Current charging priority", &priority);
+
+    let charging_priority = tuxedo_sysfs::charging::ChargingPriority::new()
+        .await
+        .unwrap();
+    if let Some(mut charging_priority) = charging_priority {
+        print_value(
+            "Available charging priorities",
+            &charging_priority.available_charging_priorities,
+        );
+        print_value(
+            "Current charging priority",
+            &charging_priority.get_charging_priority().await.unwrap(),
+        );
+    } else {
+        print_info("Charging priority control is not available");
     }
 
     let first_battery = tuxedo_sysfs::charging::BatteryChargeControl::new_first_battery()
diff --git a/tuxedo_sysfs/src/charging/charging_priority.rs b/tuxedo_sysfs/src/charging/charging_priority.rs
new file mode 100644
index 0000000..808874e
--- /dev/null
+++ b/tuxedo_sysfs/src/charging/charging_priority.rs
@@ -0,0 +1,35 @@
+use std::io;
+
+use crate::sysfs_util::{r_file, read_to_string, read_to_string_list, rw_file};
+
+use super::ChargingPriority;
+
+const CHARGING_PRIORITY_PATH: &str =
+    "/sys/devices/platform/tuxedo_keyboard/charging_profile/charging_prio";
+const CHARGING_PRIORITIES_AVAILABLE_PATH: &str =
+    "/sys/devices/platform/tuxedo_keyboard/charging_profile/charging_prios_available";
+
+impl ChargingPriority {
+    pub async fn new() -> Result<Option<Self>, io::Error> {
+        let mut available_charging_priorities_file =
+            match r_file(CHARGING_PRIORITIES_AVAILABLE_PATH).await {
+                Ok(f) => f,
+                Err(_) => return Ok(None),
+            };
+        let priorities = read_to_string_list(&mut available_charging_priorities_file).await?;
+
+        let priority_file = rw_file(CHARGING_PRIORITY_PATH).await?;
+
+        Ok(Some(ChargingPriority {
+            available_charging_priorities: priorities,
+            charging_priority_file: priority_file,
+        }))
+    }
+
+    pub async fn get_charging_priority(&mut self) -> Result<String, io::Error> {
+        Ok(read_to_string(&mut self.charging_priority_file)
+            .await?
+            .trim()
+            .to_owned())
+    }
+}
diff --git a/tuxedo_sysfs/src/charging/charging_profile.rs b/tuxedo_sysfs/src/charging/charging_profile.rs
index 765d52c..65c6a17 100644
--- a/tuxedo_sysfs/src/charging/charging_profile.rs
+++ b/tuxedo_sysfs/src/charging/charging_profile.rs
@@ -1,8 +1,6 @@
 use std::io;
 
-use crate::sysfs_util::{
-    r_file, read_path_to_string_list, read_to_string, read_to_string_list, rw_file,
-};
+use crate::sysfs_util::{r_file, read_to_string, read_to_string_list, rw_file};
 
 use super::ChargingProfile;
 
@@ -10,37 +8,22 @@ const CHARGING_PROFILE_PATH: &str =
     "/sys/devices/platform/tuxedo_keyboard/charging_profile/charging_profile";
 const CHARGING_PROFILES_AVAILABLE_PATH: &str =
     "/sys/devices/platform/tuxedo_keyboard/charging_profile/charging_profiles_available";
-const CHARGING_PRIORITY_PATH: &str =
-    "/sys/devices/platform/tuxedo_keyboard/charging_profile/charging_prio";
-const CHARGING_PRIORITIES_AVAILABLE_PATH: &str =
-    "/sys/devices/platform/tuxedo_keyboard/charging_profile/charging_prios_available";
 
 impl ChargingProfile {
-    // TODO: should this return Option<Self, io::Error> in case the whole charging_profile thing is unavailable?
-    pub async fn new() -> Result<Self, io::Error> {
+    pub async fn new() -> Result<Option<Self>, io::Error> {
+        let mut available_charging_profiles_file =
+            match r_file(CHARGING_PROFILES_AVAILABLE_PATH).await {
+                Ok(f) => f,
+                Err(_) => return Ok(None),
+            };
         let available_charging_profiles =
-            read_path_to_string_list(CHARGING_PROFILES_AVAILABLE_PATH).await?;
+            read_to_string_list(&mut available_charging_profiles_file).await?;
         let charging_profile_file = rw_file(CHARGING_PROFILE_PATH).await?;
 
-        let (available_charging_priorities, charging_priority_file) =
-            if let Ok(mut available_charging_priorities_file) =
-                r_file(CHARGING_PRIORITIES_AVAILABLE_PATH).await
-            {
-                let priorities =
-                    read_to_string_list(&mut available_charging_priorities_file).await?;
-
-                let priority_file = rw_file(CHARGING_PRIORITY_PATH).await?;
-                (Some(priorities), Some(priority_file))
-            } else {
-                (None, None)
-            };
-
-        Ok(ChargingProfile {
+        Ok(Some(ChargingProfile {
             available_charging_profiles,
             charging_profile_file,
-            available_charging_priorities,
-            charging_priority_file,
-        })
+        }))
     }
 
     pub async fn get_charging_profile(&mut self) -> Result<String, io::Error> {
@@ -49,20 +32,4 @@ impl ChargingProfile {
             .trim()
             .to_owned())
     }
-
-    // TODO: should this return Result<Option> or Option<Result>?
-    pub async fn get_charging_priority(&mut self) -> Result<Option<String>, io::Error> {
-        if let Some(charging_priority_file) = &mut self.charging_priority_file {
-            Ok(Some(
-                read_to_string(charging_priority_file)
-                    .await?
-                    .trim()
-                    .to_owned(),
-            ))
-        } else {
-            Ok(None)
-        }
-    }
-
-    // TODO: set_prio: how does this error in case prio is unavailable?
 }
diff --git a/tuxedo_sysfs/src/charging/mod.rs b/tuxedo_sysfs/src/charging/mod.rs
index c26aa78..fa4d79c 100644
--- a/tuxedo_sysfs/src/charging/mod.rs
+++ b/tuxedo_sysfs/src/charging/mod.rs
@@ -1,23 +1,25 @@
 mod charge_control;
+mod charging_priority;
 mod charging_profile;
 
-// TODO: split ChargingProfile into Profile + Priority?
-// this would make the double Option<> thing for available + file less awkward to work with...
-// + it would make the get/set (especially set) charging_prio less awkward
-
 /// A type that manages all sysfs files related to
 /// charging profile options provided by the tuxedo_keyboard driver.
 ///
 /// The charging profile imposes a firmware-enforced limit on the maximum charge of the
 /// battery.
-//
-// The charging priority allows prioritizing charging speed or system performance when charging via
-// USB-C.
 pub struct ChargingProfile {
     pub available_charging_profiles: Vec<String>,
     charging_profile_file: tokio_uring::fs::File,
-    pub available_charging_priorities: Option<Vec<String>>,
-    charging_priority_file: Option<tokio_uring::fs::File>,
+}
+
+/// A type that manages all sysfs files related to
+/// charging priority options provided by the tuxedo_keyboard driver.
+///
+/// The charging priority determines whether charging speed or
+/// performance is prioritized when charging over USB-C.
+pub struct ChargingPriority {
+    pub available_charging_priorities: Vec<String>,
+    charging_priority_file: tokio_uring::fs::File,
 }
 
 /// A type that manages all sysfs files related to charging start/end thresholds.
diff --git a/tuxedo_sysfs/src/sysfs_util.rs b/tuxedo_sysfs/src/sysfs_util.rs
index a8f21a6..cdfeba4 100644
--- a/tuxedo_sysfs/src/sysfs_util.rs
+++ b/tuxedo_sysfs/src/sysfs_util.rs
@@ -63,14 +63,6 @@ pub(crate) async fn read_int_list(file: &mut fs::File) -> Result<Vec<u32>, io::E
     }
 }
 
-pub(crate) async fn read_path_to_string_list<P>(path: P) -> Result<Vec<String>, io::Error>
-where
-    P: AsRef<Path>,
-{
-    let mut file = r_file(path).await?;
-    read_to_string_list(&mut file).await
-}
-
 pub(crate) async fn read_to_string_list(file: &mut fs::File) -> Result<Vec<String>, io::Error> {
     let output = read_to_string(file).await?;
     Ok(output

From 9d41b950ccb19cb9350ad62c4afaea7cd5b78a98 Mon Sep 17 00:00:00 2001
From: Florian Warzecha <liketechnik@disroot.org>
Date: Sat, 22 Jun 2024 22:39:38 +0200
Subject: [PATCH 3/3] feat(tuxedo_sysfs): write part of charging profiles

---
 tuxedo_sysfs/src/charging/charge_control.rs   | 21 ++++++++++++++++++-
 .../src/charging/charging_priority.rs         | 10 ++++++++-
 tuxedo_sysfs/src/charging/charging_profile.rs | 10 ++++++++-
 tuxedo_sysfs/src/sysfs_util.rs                |  4 ++++
 4 files changed, 42 insertions(+), 3 deletions(-)

diff --git a/tuxedo_sysfs/src/charging/charge_control.rs b/tuxedo_sysfs/src/charging/charge_control.rs
index b9b2970..7cff791 100644
--- a/tuxedo_sysfs/src/charging/charge_control.rs
+++ b/tuxedo_sysfs/src/charging/charge_control.rs
@@ -1,7 +1,8 @@
 use std::io;
 
 use crate::sysfs_util::{
-    r_file, read_int_list, read_path_to_int_list, read_path_to_string, read_to_string,
+    r_file, read_int_list, read_path_to_int_list, read_path_to_string, read_to_string, write_int,
+    write_string,
 };
 
 use super::BatteryChargeControl;
@@ -125,4 +126,22 @@ impl BatteryChargeControl {
             .trim()
             .to_owned())
     }
+
+    /// <https://www.kernel.org/doc/Documentation/ABI/testing/sysfs-class-power>
+    /// (section charge_type)
+    pub async fn set_charge_type(&mut self, charge_type: String) -> Result<(), io::Error> {
+        write_string(&mut self.charge_type_file, charge_type).await
+    }
+
+    /// generally: 0-100,
+    /// but may be further restricted to [`Self::available_start_thresholds`]
+    pub async fn set_start_threshold(&mut self, threshold: u32) -> Result<(), io::Error> {
+        write_int(&mut self.start_threshold_file, threshold).await
+    }
+
+    /// generally: 0-100,
+    /// but may be further restricted to [`Self::available_end_thresholds`]
+    pub async fn set_end_threshold(&mut self, threshold: u32) -> Result<(), io::Error> {
+        write_int(&mut self.end_threshold_file, threshold).await
+    }
 }
diff --git a/tuxedo_sysfs/src/charging/charging_priority.rs b/tuxedo_sysfs/src/charging/charging_priority.rs
index 808874e..17264f0 100644
--- a/tuxedo_sysfs/src/charging/charging_priority.rs
+++ b/tuxedo_sysfs/src/charging/charging_priority.rs
@@ -1,6 +1,6 @@
 use std::io;
 
-use crate::sysfs_util::{r_file, read_to_string, read_to_string_list, rw_file};
+use crate::sysfs_util::{r_file, read_to_string, read_to_string_list, rw_file, write_string};
 
 use super::ChargingPriority;
 
@@ -32,4 +32,12 @@ impl ChargingPriority {
             .trim()
             .to_owned())
     }
+
+    /// charge_battery, performance
+    /// src/ng-app/app/charging-settings/charging-settings.component.ts
+    /// in TCC
+    /// / src/uniwill_keyboard.h in tuxedo-keyboard
+    pub async fn set_charging_priority(&mut self, priority: String) -> Result<(), io::Error> {
+        write_string(&mut self.charging_priority_file, priority).await
+    }
 }
diff --git a/tuxedo_sysfs/src/charging/charging_profile.rs b/tuxedo_sysfs/src/charging/charging_profile.rs
index 65c6a17..6a86d0e 100644
--- a/tuxedo_sysfs/src/charging/charging_profile.rs
+++ b/tuxedo_sysfs/src/charging/charging_profile.rs
@@ -1,6 +1,6 @@
 use std::io;
 
-use crate::sysfs_util::{r_file, read_to_string, read_to_string_list, rw_file};
+use crate::sysfs_util::{r_file, read_to_string, read_to_string_list, rw_file, write_string};
 
 use super::ChargingProfile;
 
@@ -32,4 +32,12 @@ impl ChargingProfile {
             .trim()
             .to_owned())
     }
+
+    /// high_capacity, balanced, stationary according to
+    /// src/ng-app/app/charging-settings/charging-settings.component.ts
+    /// in TCC
+    /// / src/uniwill_keyboard.h in tuxedo-keyboard
+    pub async fn set_charging_profile(&mut self, profile: String) -> Result<(), io::Error> {
+        write_string(&mut self.charging_profile_file, profile).await
+    }
 }
diff --git a/tuxedo_sysfs/src/sysfs_util.rs b/tuxedo_sysfs/src/sysfs_util.rs
index cdfeba4..01dd20f 100644
--- a/tuxedo_sysfs/src/sysfs_util.rs
+++ b/tuxedo_sysfs/src/sysfs_util.rs
@@ -82,3 +82,7 @@ where
 pub(crate) async fn write_string(file: &mut fs::File, string: String) -> Result<(), io::Error> {
     write_buffer(file, string.into_bytes()).await
 }
+
+pub(crate) async fn write_int(file: &mut fs::File, int: u32) -> Result<(), io::Error> {
+    write_string(file, format!("{}", int)).await
+}