Add command to get and set charge limit

The minimum limit cannot be changed.

Tested on platforms:
- Intel 12th Gen with BIOS 3.07
- AMD 13th inch with BIOS 3.04

Tested with drivers;
- portio on UEFI Shell
- portio on Linux
- cros_ec on Linux

Examples:

```
> framework_tool --driver portio --charge-limit
Minimum 0%, Maximum 100%

> framework_tool --charge-limit 90
Minimum 0%, Maximum 90%
```

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

Author: JohnAZoidberg

framework_lib/src/chromium_ec/command.rs

@@ -30,6 +30,8 @@ pub enum EcCommands {
     // Framework specific commands
     /// Configure the behavior of the flash notify
     FlashNotified = 0x3E01,
+    /// Change charge limit
+    ChargeLimitControl = 0x3E03,
     /// Get information about the current chassis open/close status
     ChassisOpenCheck = 0x3E0F,
     /// Get information about historical chassis open/close (intrusion) information

framework_lib/src/chromium_ec/commands.rs

@@ -359,3 +359,41 @@ impl EcRequest<EcResponseGetHwDiag> for EcRequestGetHwDiag {
         EcCommands::GetHwDiag
     }
 }
+
+#[repr(u8)]
+pub enum ChargeLimitControlModes {
+    /// Disable all settings, handled automatically
+    Disable = 0x01,
+    /// Set maxiumum and minimum percentage
+    Set = 0x02,
+    /// Get current setting
+    /// ATTENTION!!! This is the only mode that will return a response
+    Get = 0x08,
+    /// Allow charge to full this time
+    Override = 0x80,
+}
+
+#[repr(C, packed)]
+pub struct EcRequestChargeLimitControl {
+    pub modes: u8,
+    pub max_percentage: u8,
+    pub min_percentage: u8,
+}
+
+#[repr(C, packed)]
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub struct EcResponseChargeLimitControl {
+    pub max_percentage: u8,
+    pub min_percentage: u8,
+}
+
+impl EcRequest<EcResponseChargeLimitControl> for EcRequestChargeLimitControl {
+    fn command_id() -> EcCommands {
+        EcCommands::ChargeLimitControl
+    }
+}
+
+/*
+ * Configure the behavior of the charge limit control.
+ */
+pub const EC_CHARGE_LIMIT_RESTORE: u8 = 0x7F;

framework_lib/src/chromium_ec/mod.rs

@@ -229,6 +229,33 @@ impl CrosEc {
         Ok((status.microphone == 1, status.camera == 1))
     }
 
+    pub fn set_charge_limit(&self, min: u8, max: u8) -> EcResult<()> {
+        // Sending bytes manually because the Set command, as opposed to the Get command,
+        // does not return any data
+        let limits = &[ChargeLimitControlModes::Set as u8, max, min];
+        let data = self.send_command(EcCommands::ChargeLimitControl as u16, 0, limits)?;
+        assert_eq!(data.len(), 0);
+
+        Ok(())
+    }
+
+    /// Get charge limit in percent (min, max)
+    pub fn get_charge_limit(&self) -> EcResult<(u8, u8)> {
+        let limits = EcRequestChargeLimitControl {
+            modes: ChargeLimitControlModes::Get as u8,
+            max_percentage: 0xFF,
+            min_percentage: 0xFF,
+        }
+        .send_command(self)?;
+
+        debug!(
+            "Min Raw: {}, Max Raw: {}",
+            limits.min_percentage, limits.max_percentage
+        );
+
+        Ok((limits.min_percentage, limits.max_percentage))
+    }
+
     /// Get the intrusion switch status (whether the chassis is open or not)
     pub fn get_intrusion_status(&self) -> EcResult<IntrusionStatus> {
         let status = EcRequestChassisOpenCheck {}.send_command(self)?;

framework_lib/src/commandline/clap_std.rs

@@ -89,6 +89,10 @@ struct ClapCli {
     #[arg(long)]
     input_deck_mode: Option<InputDeckModeArg>,
 
+    /// Get or set max charge limit
+    #[arg(long)]
+    charge_limit: Option<Option<u8>>,
+
     /// Set keyboard backlight percentage or get, if no value provided
     #[arg(long)]
     kblight: Option<Option<u8>>,
@@ -142,6 +146,7 @@ pub fn parse(args: &[String]) -> Cli {
         intrusion: args.intrusion,
         inputmodules: args.inputmodules,
         input_deck_mode: args.input_deck_mode,
+        charge_limit: args.charge_limit,
         kblight: args.kblight,
         console: args.console,
         driver: args.driver,

framework_lib/src/commandline/mod.rs

@@ -30,6 +30,8 @@ use crate::ccgx::{self, SiliconId::*};
 use crate::chromium_ec;
 use crate::chromium_ec::commands::DeckStateMode;
 use crate::chromium_ec::print_err;
+use crate::chromium_ec::EcError;
+use crate::chromium_ec::EcResult;
 #[cfg(feature = "linux")]
 use crate::csme;
 use crate::ec_binary;
@@ -100,6 +102,7 @@ pub struct Cli {
     pub intrusion: bool,
     pub inputmodules: bool,
     pub input_deck_mode: Option<InputDeckModeArg>,
+    pub charge_limit: Option<Option<u8>>,
     pub kblight: Option<Option<u8>>,
     pub console: Option<ConsoleArg>,
     pub help: bool,
@@ -435,6 +438,8 @@ pub fn run_with_args(args: &Cli, _allupdate: bool) -> i32 {
     } else if let Some(mode) = &args.input_deck_mode {
         println!("Set mode to: {:?}", mode);
         ec.set_input_deck_mode((*mode).into()).unwrap();
+    } else if let Some(maybe_limit) = args.charge_limit {
+        print_err(handle_charge_limit(&ec, maybe_limit));
     } else if let Some(Some(kblight)) = args.kblight {
         assert!(kblight <= 100);
         ec.set_keyboard_backlight(kblight);
@@ -841,3 +846,21 @@ pub fn analyze_capsule(data: &[u8]) -> Option<capsule::EfiCapsuleHeader> {
 
     Some(header)
 }
+
+fn handle_charge_limit(ec: &CrosEc, maybe_limit: Option<u8>) -> EcResult<()> {
+    let (cur_min, _cur_max) = ec.get_charge_limit()?;
+    if let Some(limit) = maybe_limit {
+        // Prevent accidentally setting a very low limit
+        if limit < 25 {
+            return Err(EcError::DeviceError(
+                "Not recommended to set charge limit below 25%".to_string(),
+            ));
+        }
+        ec.set_charge_limit(cur_min, limit)?;
+    }
+
+    let (min, max) = ec.get_charge_limit()?;
+    println!("Minimum {}%, Maximum {}%", min, max);
+
+    Ok(())
+}

framework_lib/src/commandline/uefi.rs

@@ -73,6 +73,7 @@ pub fn parse(args: &[String]) -> Cli {
         intrusion: false,
         inputmodules: false,
         input_deck_mode: None,
+        charge_limit: None,
         kblight: None,
         console: None,
         // This is the only driver that works on UEFI
@@ -151,6 +152,21 @@ pub fn parse(args: &[String]) -> Cli {
                 None
             };
             found_an_option = true;
+        } else if arg == "--charge-limit" {
+            cli.charge_limit = if args.len() > i + 1 {
+                if let Ok(percent) = args[i + 1].parse::<u8>() {
+                    Some(Some(percent))
+                } else {
+                    println!(
+                        "Invalid value for --charge_limit: '{}'. Must be integer < 100.",
+                        args[i + 1]
+                    );
+                    None
+                }
+            } else {
+                Some(None)
+            };
+            found_an_option = true;
         } else if arg == "--kblight" {
             cli.kblight = if args.len() > i + 1 {
                 if let Ok(percent) = args[i + 1].parse::<u8>() {