Add Apple Silicon fan control support with Ftst unlock mechanism

Signed-off-by: Alex Goodkind <alex@goodkind.io>

Author: agoodkind

Modules/Sensors/popup.swift

@@ -638,10 +638,14 @@ internal class FanView: NSStackView {
             height: view.frame.height - 8
         ), mode: self.fan.mode)
         buttons.callback = { [weak self] (mode: FanMode) in
-            if let fan = self?.fan, fan.mode != mode {
-                self?.fan.mode = mode
-                self?.fan.customMode = mode
-                SMCHelper.shared.setFanMode(fan.id, mode: mode.rawValue)
+            if let fan = self?.fan {
+                // Always call setFanMode for automatic to ensure Ftst is reset
+                // For manual, only call if mode changed to avoid redundant unlock
+                if mode == .automatic || fan.mode != mode {
+                    self?.fan.mode = mode
+                    self?.fan.customMode = mode
+                    SMCHelper.shared.setFanMode(fan.id, mode: mode.rawValue)
+                }
             }
             self?.toggleControlView(mode == .forced)
         }

Modules/Sensors/readers.swift

@@ -352,6 +352,14 @@ extension SensorsReader {
     }
 
     private func getFanMode(_ id: Int) -> FanMode {
+        #if arch(arm64)
+        // Apple Silicon: Read F%dMd directly
+        // Mode values: 0 = auto, 1 = manual, 3 = system (treated as auto for UI)
+        let modeValue = Int(SMC.shared.getValue("F\(id)Md") ?? 0)
+        return modeValue == 1 ? .forced : .automatic
+        #else
+        // Legacy Intel: Use FS! bitmask
+        // Bitmask: 0 = all auto, 1 = fan 0 forced, 2 = fan 1 forced, 3 = both forced
         let fansMode: Int = Int(SMC.shared.getValue("FS! ") ?? 0)
         var mode: FanMode = .automatic
 
@@ -366,6 +374,7 @@ extension SensorsReader {
         }
 
         return mode
+        #endif
     }
 }
 

Modules/Sensors/values.swift

@@ -255,10 +255,15 @@ public struct Fan: Sensor_p, Codable {
     public var mode: FanMode
 
     public var percentage: Int {
-        if self.value != 0 && self.maxSpeed != 0 && self.value != 1 && self.maxSpeed != 1 {
-            return (100*Int(self.value)) / Int(self.maxSpeed)
-        }
-        return 0
+        let range = self.maxSpeed - self.minSpeed
+        // Avoid division by zero and handle edge cases
+        guard range > 0 && self.maxSpeed > 1 else { return 0 }
+        
+        // Calculate percentage based on min/max range
+        // value at minSpeed = 0%, value at maxSpeed = 100%
+        let normalized = self.value - self.minSpeed
+        if normalized <= 0 { return 0 }
+        return min(100, Int((100 * normalized) / range))
     }
 
     public var group: SensorGroup = .sensor

SMC/Helper/Info.plist

@@ -7,9 +7,9 @@
 	<key>CFBundleName</key>
 	<string>eu.exelban.Stats.SMC.Helper</string>
 	<key>CFBundleShortVersionString</key>
-	<string>1.0.1</string>
+	<string>1.0.2</string>
 	<key>CFBundleVersion</key>
-	<string>2</string>
+	<string>3</string>
 	<key>CFBundleInfoDictionaryVersion</key>
 	<string>6.0</string>
 	<key>SMAuthorizedClients</key>

SMC/smc.swift

@@ -352,6 +352,56 @@ public class SMC {
     // MARK: - fans
 
     public func setFanMode(_ id: Int, mode: FanMode) {
+        #if arch(arm64)
+        // Apple Silicon: unlock before setting manual mode
+        if mode == .forced {
+            if !unlockFanControl(fanId: id) {
+                print("Error: failed to unlock fan control for fan \(id)")
+                return
+            }
+            // unlockFanControl already set the mode to 1, so we're done with F%dMd
+        } else {
+            // Setting to automatic - count OTHER fans in manual mode (skip current fan)
+            guard let fanCount = getValue("FNum") else {
+                print("Error: Failed to read fan count")
+                return
+            }
+            var otherFansManual = 0
+            for i in 0 ..< Int(fanCount) {
+                if i == id { continue }
+                var modeVal = SMCVal_t("F\(i)Md")
+                if read(&modeVal) == kIOReturnSuccess {
+                    if modeVal.bytes[0] == 1 {
+                        otherFansManual += 1
+                    }
+                }
+            }
+            
+            // Set mode and target to 0
+            if self.getValue("F\(id)Md") != nil {
+                var value = SMCVal_t("F\(id)Md")
+                _ = read(&value)
+                value.bytes[0] = 0
+                _ = write(value)
+            }
+            
+            // Apple Silicon uses flt (IEEE 754 float) format
+            var targetValue = SMCVal_t("F\(id)Tg")
+            _ = read(&targetValue)
+            let bytes = Float(0).bytes
+            targetValue.bytes[0] = bytes[0]
+            targetValue.bytes[1] = bytes[1]
+            targetValue.bytes[2] = bytes[2]
+            targetValue.bytes[3] = bytes[3]
+            _ = write(targetValue)
+            
+            if otherFansManual == 0 {
+                resetFanControl()
+                print("Last manual fan - Ftst reset, thermalmonitord has control")
+            }
+        }
+        #else
+        // Intel
         if self.getValue("F\(id)Md") != nil {
             var result: kern_return_t = 0
             var value = SMCVal_t("F\(id)Md")
@@ -422,6 +472,7 @@ public class SMC {
             print("Error write: " + (String(cString: mach_error_string(result), encoding: String.Encoding.ascii) ?? "unknown error"))
             return
         }
+        #endif
     }
 
     public func setFanSpeed(_ id: Int, speed: Int) {
@@ -432,6 +483,18 @@ public class SMC {
             return
         }
 
+        #if arch(arm64)
+        // Apple Silicon: ensure fan is in manual mode before setting speed
+        var modeVal = SMCVal_t("F\(id)Md")
+        _ = read(&modeVal)
+        if modeVal.bytes[0] != 1 {
+            if !unlockFanControl(fanId: id) {
+                print("Error: Failed to unlock fan \(id) for speed change")
+                return
+            }
+        }
+        #endif
+        
         var result: kern_return_t = 0
         var value = SMCVal_t("F\(id)Tg")
 
@@ -441,18 +504,20 @@ public class SMC {
             return
         }
 
-        if value.dataType == "flt " {
-            let bytes = Float(speed).bytes
-            value.bytes[0] = bytes[0]
-            value.bytes[1] = bytes[1]
-            value.bytes[2] = bytes[2]
-            value.bytes[3] = bytes[3]
-        } else if value.dataType == "fpe2" {
-            value.bytes[0] = UInt8(speed >> 6)
-            value.bytes[1] = UInt8((speed << 2) ^ ((speed >> 6) << 8))
-            value.bytes[2] = UInt8(0)
-            value.bytes[3] = UInt8(0)
-        }
+        #if arch(arm64)
+        // Apple Silicon: flt (IEEE 754 float) format
+        let bytes = Float(speed).bytes
+        value.bytes[0] = bytes[0]
+        value.bytes[1] = bytes[1]
+        value.bytes[2] = bytes[2]
+        value.bytes[3] = bytes[3]
+        #else
+        // Intel: fpe2 format
+        value.bytes[0] = UInt8(speed >> 6)
+        value.bytes[1] = UInt8((speed << 2) ^ ((speed >> 6) << 8))
+        value.bytes[2] = UInt8(0)
+        value.bytes[3] = UInt8(0)
+        #endif
 
         result = write(value)
         if result != kIOReturnSuccess {
@@ -469,7 +534,81 @@ public class SMC {
         if result != kIOReturnSuccess {
             print("Error write: " + (String(cString: mach_error_string(result), encoding: String.Encoding.ascii) ?? "unknown error"))
         }
+        
+        #if arch(arm64)
+        // Also reset Ftst on Apple Silicon
+        resetFanControl()
+        #endif
+    }
+    
+    // MARK: - Apple Silicon Fan Control
+    
+    #if arch(arm64)
+    /// Unlock fan control for Apple Silicon by writing Ftst=1
+    /// This prevents thermalmonitord from overriding manual fan settings
+    private func unlockFanControl(fanId: Int) -> Bool {
+        // Check if already unlocked (Ftst=1 from another fan)
+        var ftstCheck = SMCVal_t("Ftst")
+        _ = read(&ftstCheck)
+        let alreadyUnlocked = ftstCheck.bytes[0] == 1
+        
+        if !alreadyUnlocked {
+            var ftstVal = SMCVal_t("Ftst")
+            _ = read(&ftstVal)
+            ftstVal.bytes[0] = 1
+            let ftstResult = write(ftstVal)
+            if ftstResult != kIOReturnSuccess {
+                print("Error unlocking fan control: " + (String(cString: mach_error_string(ftstResult), encoding: String.Encoding.ascii) ?? "unknown error"))
+                return false
+            }
+        }
+        
+        // Retry writing mode=1 until thermalmonitord releases control
+        let modeKey = "F\(fanId)Md"
+        let maxAttempts = alreadyUnlocked ? 10 : 100
+        for attempt in 0..<maxAttempts {
+            var modeVal = SMCVal_t(modeKey)
+            _ = read(&modeVal)
+            modeVal.bytes[0] = 1
+            let result = write(modeVal)
+            if result == kIOReturnSuccess {
+                print("Fan \(fanId) set to manual mode after \(attempt + 1) attempts")
+                return true
+            }
+            usleep(alreadyUnlocked ? 10_000 : 50_000)
+        }
+        print("Timeout setting fan \(fanId) to manual mode")
+        return false
+    }
+    
+    /// Reset Ftst to 0, returning control to thermalmonitord
+    private func resetFanControl() {
+        var value = SMCVal_t("Ftst")
+        _ = read(&value)
+        value.bytes[0] = 0
+        let result = write(value)
+        if result == kIOReturnSuccess {
+            print("Ftst=0 written successfully")
+        } else {
+            print("Error writing Ftst=0: \(result)")
+        }
+    }
+    
+    /// Check how many fans are currently in manual mode
+    private func countManualFans() -> Int {
+        guard let fanCount = getValue("FNum") else { return 0 }
+        var count = 0
+        for i in 0..<Int(fanCount) {
+            var modeVal = SMCVal_t("F\(i)Md")
+            if read(&modeVal) == kIOReturnSuccess {
+                if modeVal.bytes[0] == 1 {
+                    count += 1
+                }
+            }
+        }
+        return count
     }
+    #endif
 
     // MARK: - internal functions
 

Stats.xcodeproj/project.pbxproj

@@ -387,6 +387,20 @@
 			remoteGlobalIDString = 9AF9EE0124648751005D2270;
 			remoteInfo = Disk;
 		};
+		B2D05E752F253BFA0021E479 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 9A1410ED229E721100D29793 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 9ADE6FD7265D032100D2FBA8;
+			remoteInfo = SMC;
+		};
+		B2D05E792F2548790021E479 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 9A1410ED229E721100D29793 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 5CFE492629264DF1000F2856;
+			remoteInfo = Helper;
+		};
 /* End PBXContainerItemProxy section */
 
 /* Begin PBXCopyFilesBuildPhase section */
@@ -1481,6 +1495,8 @@
 			buildRules = (
 			);
 			dependencies = (
+				B2D05E7A2F2548790021E479 /* PBXTargetDependency */,
+				B2D05E762F253BFA0021E479 /* PBXTargetDependency */,
 				9A81C75C2449A41400825D92 /* PBXTargetDependency */,
 				9AF9EE0824648751005D2270 /* PBXTargetDependency */,
 				9A3E17D2247A94AF00449CD1 /* PBXTargetDependency */,
@@ -2374,6 +2390,16 @@
 			target = 9AF9EE0124648751005D2270 /* Disk */;
 			targetProxy = 9AF9EE0724648751005D2270 /* PBXContainerItemProxy */;
 		};
+		B2D05E762F253BFA0021E479 /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 9ADE6FD7265D032100D2FBA8 /* SMC */;
+			targetProxy = B2D05E752F253BFA0021E479 /* PBXContainerItemProxy */;
+		};
+		B2D05E7A2F2548790021E479 /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 5CFE492629264DF1000F2856 /* Helper */;
+			targetProxy = B2D05E792F2548790021E479 /* PBXContainerItemProxy */;
+		};
 /* End PBXTargetDependency section */
 
 /* Begin PBXVariantGroup section */