Add manual fan control

Allow fan target duties to be set via ACPI or SMFI command. This will
allow system firmware or OS to set fan duty, which can be used for
testing or implementing user-defined fan tables.

Setting PWM via SMFI already existed, but would not work as the value
would simply be overwritten by the EC.

RPM target is not supported.

Signed-off-by: Tim Crawford <tcrawford@system76.com>

Author: crawfxrd

src/board/system76/common/acpi.c

@@ -177,6 +177,10 @@ uint8_t acpi_read(uint8_t addr) {
         ACPI_16(0xD2, fan2_rpm);
 #endif // FAN2_PWM
 
+        case 0xD4:
+            data = fan_get_mode();
+            break;
+
 #if HAVE_LED_AIRPLANE_N
         // Airplane mode LED
         case 0xD9:
@@ -224,6 +228,29 @@ void acpi_write(uint8_t addr, uint8_t data) {
         (void)battery_save_thresholds();
         break;
 
+    case 0xCE:
+        if (fan_get_mode() == FAN_MODE_PWM) {
+            fan1_pwm_target = data;
+        }
+        break;
+
+#ifdef FAN2_PWM
+    case 0xCF:
+        if (fan_get_mode() == FAN_MODE_PWM) {
+            fan2_pwm_target = data;
+        }
+        break;
+#endif
+
+    case 0xD4:
+        switch (data) {
+        case FAN_MODE_AUTO:
+        case FAN_MODE_PWM:
+            fan_set_mode(data);
+            break;
+        }
+        break;
+
 #if HAVE_LED_AIRPLANE_N
     // Airplane mode LED
     case 0xD9:

src/board/system76/common/fan.c

@@ -12,6 +12,7 @@
 #endif
 
 bool fan_max = false;
+static enum FanMode fan_mode = FAN_MODE_AUTO;
 
 uint8_t fan1_pwm_actual = 0;
 uint8_t fan1_pwm_target = 0;
@@ -261,3 +262,11 @@ void fan_update_duty(void) {
     fan2_rpm = fan_get_tach1_rpm();
 #endif
 }
+
+enum FanMode fan_get_mode(void) {
+    return fan_mode;
+}
+
+void fan_set_mode(enum FanMode mode) {
+    fan_mode = mode;
+}

src/board/system76/common/include/board/fan.h

@@ -21,6 +21,15 @@ struct Fan {
     uint8_t pwm_min;
 };
 
+enum FanMode {
+    // EC control
+    FAN_MODE_AUTO = 0,
+    // Host control via target PWM
+    FAN_MODE_PWM = 1,
+    // Host control via target RPM
+    FAN_MODE_RPM = 2,
+};
+
 extern bool fan_max;
 
 extern uint8_t fan1_pwm_actual;
@@ -34,4 +43,7 @@ void fan_reset(void);
 void fan_update_duty(void);
 void fan_update_target(void);
 
+enum FanMode fan_get_mode(void);
+void fan_set_mode(enum FanMode);
+
 #endif // _BOARD_FAN_H

src/board/system76/common/main.c

@@ -173,7 +173,10 @@ void main(void) {
             last_time_1sec = time;
 
             battery_event();
-            fan_update_target();
+
+            if (fan_get_mode() == FAN_MODE_AUTO) {
+                fan_update_target();
+            }
         }
 
         // Idle until next timer interrupt

src/board/system76/common/smfi.c

@@ -140,6 +140,10 @@ static enum Result cmd_fan_get_pwm(void) {
 }
 
 static enum Result cmd_fan_set_pwm(void) {
+    if (fan_get_mode() != FAN_MODE_PWM) {
+        return RES_ERR;
+    }
+
     switch (smfi_cmd[SMFI_CMD_DATA]) {
     case 1:
         // Set duty cycle of FAN1
@@ -157,6 +161,24 @@ static enum Result cmd_fan_set_pwm(void) {
     return RES_ERR;
 }
 
+static enum Result cmd_fan_get_mode(void) {
+    smfi_cmd[SMFI_CMD_DATA] = fan_get_mode();
+    return RES_OK;
+}
+
+static enum Result cmd_fan_set_mode(void) {
+    enum FanMode mode = smfi_cmd[SMFI_CMD_DATA];
+
+    switch (mode) {
+    case FAN_MODE_AUTO:
+    case FAN_MODE_PWM:
+        fan_set_mode(mode);
+        return RES_OK;
+    }
+
+    return RES_ERR;
+}
+
 static enum Result cmd_keymap_get(void) {
     int16_t layer = smfi_cmd[SMFI_CMD_DATA];
     int16_t output = smfi_cmd[SMFI_CMD_DATA + 1];
@@ -421,6 +443,13 @@ void smfi_event(void) {
             break;
 #endif // CONFIG_SECURITY
 
+        case CMD_FAN_GET_MODE:
+            smfi_cmd[SMFI_CMD_RES] = cmd_fan_get_mode();
+            break;
+        case CMD_FAN_SET_MODE:
+            smfi_cmd[SMFI_CMD_RES] = cmd_fan_set_mode();
+            break;
+
 #endif // !defined(__SCRATCH__)
         case CMD_SPI:
             smfi_cmd[SMFI_CMD_RES] = cmd_spi();

src/common/include/common/command.h

@@ -50,7 +50,10 @@ enum Command {
     CMD_SECURITY_GET = 20,
     // Set security state
     CMD_SECURITY_SET = 21,
-    //TODO
+    // Get fan control mode
+    CMD_FAN_GET_MODE = 22,
+    // Set fan control mode
+    CMD_FAN_SET_MODE = 23,
 };
 
 enum Result {

tool/src/ec.rs

@@ -6,6 +6,7 @@ use alloc::{
     vec,
 };
 use core::convert::TryFrom;
+use core::fmt;
 
 use crate::{
     Access,
@@ -39,6 +40,8 @@ enum Cmd {
     SetNoInput = 19,
     SecurityGet = 20,
     SecuritySet = 21,
+    FanGetMode = 22,
+    FanSetMode = 23,
 }
 
 const CMD_SPI_FLAG_READ: u8 = 1 << 0;
@@ -73,6 +76,42 @@ impl TryFrom<u8> for SecurityState {
     }
 }
 
+#[derive(Clone, Copy, Default, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "std", derive(clap::ValueEnum))]
+#[repr(u8)]
+pub enum FanMode {
+    /// EC control
+    #[default]
+    Auto = 0,
+    /// Host control via target PWM
+    Pwm = 1,
+    /// Host control via target RPM
+    Rpm = 2,
+}
+
+impl fmt::Display for FanMode {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Self::Auto => write!(f, "auto"),
+            Self::Pwm => write!(f, "pwm"),
+            Self::Rpm => write!(f, "rpm"),
+        }
+    }
+}
+
+impl TryFrom<u8> for FanMode {
+    type Error = Error;
+
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        match value {
+            0 => Ok(Self::Auto),
+            1 => Ok(Self::Pwm),
+            2 => Ok(Self::Rpm),
+            _ => Err(Error::Verify),
+        }
+    }
+}
+
 /// Run EC commands using a provided access method
 pub struct Ec<A: Access> {
     access: A,
@@ -327,6 +366,19 @@ impl<A: Access> Ec<A> {
        self.command(Cmd::SecuritySet, &mut data)
     }
 
+    /// Get fan control mode.
+    pub unsafe fn fan_get_mode(&mut self) -> Result<FanMode, Error> {
+        let mut data = [0];
+        self.command(Cmd::FanGetMode, &mut data)?;
+        FanMode::try_from(data[0])
+    }
+
+    /// Set fan control mode.
+    pub unsafe fn fan_set_mode(&mut self, mode: FanMode) -> Result<(), Error> {
+        let mut data = [mode as u8];
+       self.command(Cmd::FanSetMode, &mut data)
+    }
+
     pub fn into_dyn(self) -> Ec<Box<dyn Access>>
     where A: 'static {
         Ec {

tool/src/lib.rs

@@ -25,7 +25,7 @@ extern crate alloc;
 pub use self::access::*;
 mod access;
 
-pub use self::ec::{Ec, SecurityState};
+pub use self::ec::{Ec, FanMode, SecurityState};
 mod ec;
 
 pub use self::error::Error;

tool/src/main.rs

@@ -277,6 +277,17 @@ unsafe fn fan_set_pwm(ec: &mut Ec<Box<dyn Access>>, index: u8, duty: u8) -> Resu
     ec.fan_set_pwm(index, duty)
 }
 
+unsafe fn fan_get_mode(ec: &mut Ec<Box<dyn Access>>) -> Result<(), Error> {
+    let mode = ec.fan_get_mode()?;
+    println!("{}", mode);
+
+    Ok(())
+}
+
+unsafe fn fan_set_mode(ec: &mut Ec<Box<dyn Access>>, mode: ectool::FanMode) -> Result<(), Error> {
+    ec.fan_set_mode(mode)
+}
+
 unsafe fn keymap_get(ec: &mut Ec<Box<dyn Access>>, layer: u8, output: u8, input: u8) -> Result<(), Error> {
     let value = ec.keymap_get(layer, output, input)?;
     println!("{:04X}", value);
@@ -320,6 +331,9 @@ enum SubCommand {
         index: u8,
         duty: Option<u8>,
     },
+    FanMode {
+        mode: Option<ectool::FanMode>,
+    },
     Flash {
         path: String,
     },
@@ -456,6 +470,24 @@ fn main() {
                 },
             }
         },
+        SubCommand::FanMode { mode } => {
+            match mode {
+                Some(mode) => match unsafe { fan_set_mode(&mut ec, mode) } {
+                    Ok(()) => (),
+                    Err(err) => {
+                        eprintln!("failed to set fan mode {}: {:X?}", mode, err);
+                        process::exit(1);
+                    }
+                },
+                None => match unsafe { fan_get_mode(&mut ec) } {
+                    Ok(()) => (),
+                    Err(err) => {
+                        eprintln!("failed to get fan mode: {:X?}", err);
+                        process::exit(1);
+                    }
+                },
+            }
+        },
         SubCommand::Flash { path } => {
             match unsafe { flash(&mut ec, &path, SpiTarget::Main) } {
                 Ok(()) => (),