Add --charge-rate-limit

Usually the user won't want to specify a mA value to limit the charge
current. Setting a charge rate 0.0-1.0 is more useful.

```
PS C:\Users\Daniel\clone\framework-system-private> sudo .\target\debug\framework_tool.exe --power
Charger Status
  AC is:            connected
  Charger Voltage:  17800mV
  Charger Current:  2740mA
                    0.6998723C
  Chg Input Current:2848mA
  Battery SoC:      94%
Battery Status
  AC is:            connected
  Battery is:       connected
  Battery LFCC:     4021 mAh (Last Full Charge Capacity)
  Battery Capacity: 3751 mAh
                    66.512 Wh
  Charge level:     93%
  Battery charging
PS C:\Users\Daniel\clone\framework-system-private> sudo .\target\debug\framework_tool.exe --charge-rate-limit 0.5
Requested Rate:      0.5C
Design Current:      3915mA
Limiting Current to: 1957mA
PS C:\Users\Daniel\clone\framework-system-private> sudo .\target\debug\framework_tool.exe --power
Charger Status
  AC is:            connected
  Charger Voltage:  17800mV
  Charger Current:  1956mA
                    0.49961686C
  Chg Input Current:2848mA
  Battery SoC:      94%
Battery Status
  AC is:            connected
  Battery is:       connected
  Battery LFCC:     4021 mAh (Last Full Charge Capacity)
  Battery Capacity: 3754 mAh
                    66.584 Wh
  Charge level:     93%
  Battery charging
```

Signed-off-by: Daniel Schaefer <[email protected]>

Author: JohnAZoidberg

framework_lib/src/chromium_ec/mod.rs

@@ -10,6 +10,7 @@
 
 use crate::ec_binary;
 use crate::os_specific;
+use crate::power;
 use crate::smbios;
 #[cfg(feature = "uefi")]
 use crate::uefi::shell_get_execution_break_flag;
@@ -407,6 +408,29 @@ impl CrosEc {
         }
     }
 
+    pub fn set_charge_rate_limit(&self, rate: f32, battery_soc: Option<f32>) -> EcResult<()> {
+        let power_info = power::power_info(self).ok_or(EcError::DeviceError(
+            "Failed to get battery info".to_string(),
+        ))?;
+        let battery = power_info
+            .battery
+            .ok_or(EcError::DeviceError("No battery present".to_string()))?;
+        println!("Requested Rate:      {}C", rate);
+        println!("Design Current:      {}mA", battery.design_capacity);
+        let current = (rate * (battery.design_capacity as f32)) as u32;
+        println!("Limiting Current to: {}mA", current);
+        if let Some(battery_soc) = battery_soc {
+            let battery_soc = battery_soc as u8;
+            EcRequestCurrentLimitV1 {
+                current,
+                battery_soc,
+            }
+            .send_command(self)
+        } else {
+            EcRequestCurrentLimitV0 { current }.send_command(self)
+        }
+    }
+
     pub fn set_fp_led_percentage(&self, percentage: u8) -> EcResult<()> {
         // Sending bytes manually because the Set command, as opposed to the Get command,
         // does not return any data
@@ -1096,7 +1120,7 @@ impl CrosEc {
         }
     }
 
-    pub fn get_charge_state(&self) -> EcResult<()> {
+    pub fn get_charge_state(&self, power_info: &power::PowerInfo) -> EcResult<()> {
         let res = EcRequestChargeStateGetV0 {
             cmd: ChargeStateCmd::GetState as u8,
             param: 0,
@@ -1113,6 +1137,10 @@ impl CrosEc {
         );
         println!("  Charger Voltage:  {}mV", { res.chg_voltage });
         println!("  Charger Current:  {}mA", { res.chg_current });
+        if let Some(battery) = &power_info.battery {
+            let charge_rate = (res.chg_current as f32) / (battery.design_capacity as f32);
+            println!("                    {:.2}C", charge_rate);
+        }
         println!("  Chg Input Current:{}mA", { res.chg_input_current });
         println!("  Battery SoC:      {}%", { res.batt_state_of_charge });
 

framework_lib/src/commandline/clap_std.rs

@@ -160,6 +160,11 @@ struct ClapCli {
     #[clap(num_args = ..2)]
     charge_current_limit: Vec<u32>,
 
+    /// Get or set max charge current limit
+    #[arg(long)]
+    #[clap(num_args = ..2)]
+    charge_rate_limit: Vec<f32>,
+
     /// Get GPIO value by name
     #[arg(long)]
     get_gpio: Option<String>,
@@ -318,6 +323,11 @@ pub fn parse(args: &[String]) -> Cli {
         1 => Some((args.charge_current_limit[0], None)),
         _ => None,
     };
+    let charge_rate_limit = match args.charge_rate_limit.len() {
+        2 => Some((args.charge_rate_limit[0], Some(args.charge_rate_limit[1]))),
+        1 => Some((args.charge_rate_limit[0], None)),
+        _ => None,
+    };
 
     Cli {
         verbosity: args.verbosity.log_level_filter(),
@@ -372,6 +382,7 @@ pub fn parse(args: &[String]) -> Cli {
         expansion_bay: args.expansion_bay,
         charge_limit: args.charge_limit,
         charge_current_limit,
+        charge_rate_limit,
         get_gpio: args.get_gpio,
         fp_led_level: args.fp_led_level,
         fp_brightness: args.fp_brightness,

framework_lib/src/commandline/mod.rs

@@ -176,6 +176,7 @@ pub struct Cli {
     pub expansion_bay: bool,
     pub charge_limit: Option<Option<u8>>,
     pub charge_current_limit: Option<(u32, Option<u32>)>,
+    pub charge_rate_limit: Option<(f32, Option<f32>)>,
     pub get_gpio: Option<String>,
     pub fp_led_level: Option<Option<FpBrightnessArg>>,
     pub fp_brightness: Option<Option<u8>>,
@@ -765,6 +766,8 @@ pub fn run_with_args(args: &Cli, _allupdate: bool) -> i32 {
         print_err(handle_charge_limit(&ec, maybe_limit));
     } else if let Some((limit, soc)) = args.charge_current_limit {
         print_err(ec.set_charge_current_limit(limit, soc));
+    } else if let Some((limit, soc)) = args.charge_rate_limit {
+        print_err(ec.set_charge_rate_limit(limit, soc));
     } else if let Some(gpio_name) = &args.get_gpio {
         print!("Getting GPIO value {}: ", gpio_name);
         if let Ok(value) = ec.get_gpio(gpio_name) {

framework_lib/src/commandline/uefi.rs

@@ -89,6 +89,7 @@ pub fn parse(args: &[String]) -> Cli {
         expansion_bay: false,
         charge_limit: None,
         charge_current_limit: None,
+        charge_rate_limit: None,
         get_gpio: None,
         fp_led_level: None,
         fp_brightness: None,
@@ -296,6 +297,35 @@ pub fn parse(args: &[String]) -> Cli {
                 None
             };
             found_an_option = true;
+        } else if arg == "--charge-rate-limit" {
+            cli.charge_rate_limit = if args.len() > i + 2 {
+                let limit = args[i + 1].parse::<f32>();
+                let soc = args[i + 2].parse::<f32>();
+                if let (Ok(limit), Ok(soc)) = (limit, soc) {
+                    Some((limit, Some(soc)))
+                } else {
+                    println!(
+                        "Invalid values for --charge-rate-limit: '{} {}'. Must be u32 integers.",
+                        args[i + 1],
+                        args[i + 2]
+                    );
+                    None
+                }
+            } else if args.len() > i + 1 {
+                if let Ok(limit) = args[i + 1].parse::<f32>() {
+                    Some((limit, None))
+                } else {
+                    println!(
+                        "Invalid values for --charge-rate-limit: '{}'. Must be an integer.",
+                        args[i + 1],
+                    );
+                    None
+                }
+            } else {
+                println!("--charge-rate-limit requires one or two. [limit] [soc] or [limit]");
+                None
+            };
+            found_an_option = true;
         } else if arg == "--get-gpio" {
             cli.get_gpio = if args.len() > i + 1 {
                 Some(args[i + 1].clone())

framework_lib/src/power.rs

@@ -471,8 +471,8 @@ pub fn is_standalone(ec: &CrosEc) -> bool {
 }
 
 pub fn get_and_print_power_info(ec: &CrosEc) -> i32 {
-    print_err_ref(&ec.get_charge_state());
     if let Some(power_info) = power_info(ec) {
+        print_err_ref(&ec.get_charge_state(&power_info));
         print_battery_information(&power_info);
         if let Some(_battery) = &power_info.battery {
             return 0;