Fix Ftst key handling for Apple Silicon fan control

agoodkind · agoodkind · commit 1452aab72906 · 2026-01-24T18:24:25.000-08:00
diff --git a/Modules/Sensors/popup.swift b/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)
         }
diff --git a/Modules/Sensors/readers.swift b/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
     }
 }
 
diff --git a/Modules/Sensors/values.swift b/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
diff --git a/SMC/Helper/Info.plist b/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>
diff --git a/SMC/smc.swift b/SMC/smc.swift
@@ -43,6 +43,7 @@ internal enum SMCKeys: UInt8 {
     case readVers = 12
 }
 
+
 public enum FanMode: Int, Codable {
     case automatic = 0
     case forced = 1
@@ -352,6 +353,65 @@ 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 - check if OTHER fans are still in manual mode
+            let otherFansManual = countManualFans(excluding: id)
+
+            var result: kern_return_t = 0
+            // Set mode and target to 0
+            if self.getValue("F\(id)Md") != nil {
+                var value = SMCVal_t("F\(id)Md")
+                
+                result = read(&value)
+                guard result == kIOReturnSuccess else {
+                    print("Error read fan mode: " + (String(cString: mach_error_string(result), encoding: String.Encoding.ascii) ?? "unknown error"))
+                    return
+                }
+                
+                value.bytes[0] = 0
+                result = write(value)
+                guard result == kIOReturnSuccess else {
+                    print("Error write fan mode: " + (String(cString: mach_error_string(result), encoding: String.Encoding.ascii) ?? "unknown error"))
+                    return
+                }
+            }
+            
+            // Apple Silicon uses flt (IEEE 754 float) format
+            var targetValue = SMCVal_t("F\(id)Tg")
+            
+            result = read(&targetValue)
+            guard result == kIOReturnSuccess else {
+                print("Error read fan target: " + (String(cString: mach_error_string(result), encoding: String.Encoding.ascii) ?? "unknown error"))
+                return
+            }
+            
+            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]
+            
+            result = write(targetValue)
+            guard result == kIOReturnSuccess else {
+                print("Error write fan target: " + (String(cString: mach_error_string(result), encoding: String.Encoding.ascii) ?? "unknown error"))
+                return
+            }
+            
+            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,15 +482,31 @@ 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) {
-        let maxSpeed = Int(self.getValue("F\(id)Mx") ?? 4000)
+        // Enforce recommended max as safety limit
+        if let maxSpeed = self.getValue("F\(id)Mx"), speed > Int(maxSpeed) {
+            print("Fan speed (\(speed)) exceeds maximum (\(Int(maxSpeed))), clamping")
+            return setFanSpeed(id, speed: Int(maxSpeed))
+        }
         
-        if speed > maxSpeed {
-            print("new fan speed (\(speed)) is more than maximum speed (\(maxSpeed))")
+        #if arch(arm64)
+        // Apple Silicon: ensure fan is in manual mode before setting speed
+        var modeVal = SMCVal_t("F\(id)Md")
+        let modeResult = read(&modeVal)
+        guard modeResult == kIOReturnSuccess else {
+            print("Error read fan mode: " + (String(cString: mach_error_string(modeResult), encoding: String.Encoding.ascii) ?? "unknown error"))
             return
         }
+        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")
@@ -471,6 +547,92 @@ public class SMC {
         }
     }
     
+    // 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")
+        var result = read(&ftstCheck)
+        guard result == kIOReturnSuccess else {
+            print("Error read Ftst: " + (String(cString: mach_error_string(result), encoding: String.Encoding.ascii) ?? "unknown error"))
+            return false
+        }
+        let alreadyUnlocked = ftstCheck.bytes[0] == 1
+        
+        if !alreadyUnlocked {
+            var ftstVal = SMCVal_t("Ftst")
+            result = read(&ftstVal)
+            guard result == kIOReturnSuccess else {
+                print("Error read Ftst: " + (String(cString: mach_error_string(result), encoding: String.Encoding.ascii) ?? "unknown error"))
+                return false
+            }
+            ftstVal.bytes[0] = 1
+            let ftstResult = write(ftstVal)
+            guard ftstResult == kIOReturnSuccess else {
+                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)
+            guard read(&modeVal) == kIOReturnSuccess else {
+                usleep(alreadyUnlocked ? 10_000 : 50_000)
+                continue
+            }
+            modeVal.bytes[0] = 1
+            let writeResult = write(modeVal)
+            if writeResult == 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")
+        var result = read(&value)
+        guard result == kIOReturnSuccess else {
+            print("Error read Ftst: " + (String(cString: mach_error_string(result), encoding: String.Encoding.ascii) ?? "unknown error"))
+            return
+        }
+        value.bytes[0] = 0
+        result = write(value)
+        if result == kIOReturnSuccess {
+            print("Ftst=0 written successfully")
+        } else {
+            print("Error writing Ftst=0: " + (String(cString: mach_error_string(result), encoding: String.Encoding.ascii) ?? "unknown error"))
+        }
+    }
+    
+    /// Check how many fans are currently in manual mode
+    /// - Parameter excluding: Optional fan ID to exclude from count (for checking OTHER fans)
+    private func countManualFans(excluding fanId: Int? = nil) -> Int {
+        guard let fanCount = getValue("FNum") else { return 0 }
+        var count = 0
+        for i in 0..<Int(fanCount) {
+            if let exclude = fanId, i == exclude { continue }
+            var modeVal = SMCVal_t("F\(i)Md")
+            if read(&modeVal) == kIOReturnSuccess {
+                if modeVal.bytes[0] == 1 {
+                    count += 1
+                }
+            }
+        }
+        return count
+    }
+    #endif
+    
     // MARK: - internal functions
     
     private func read(_ value: UnsafeMutablePointer<SMCVal_t>) -> kern_return_t {
@@ -520,6 +682,12 @@ public class SMC {
             return result
         }
         
+        // IOKit can return kIOReturnSuccess but SMC firmware may still reject the write.
+        // Check SMC-level result code (0x00 = success, non-zero = error)
+        if output.result != 0x00 {
+            return kIOReturnError
+        }
+        
         return kIOReturnSuccess
     }
     
diff --git a/Stats.xcodeproj/project.pbxproj b/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 */

Original file line number	Diff line number	Diff line change
`@@ -352,6 +352,14 @@ extension SensorsReader {`
`352`	`352`	`}`
`353`	`353`
`354`	`354`	`private func getFanMode(_ id: Int) -> FanMode {`
	`355`	`+ #if arch(arm64)`
	`356`	`+ // Apple Silicon: Read F%dMd directly`
	`357`	`+ // Mode values: 0 = auto, 1 = manual, 3 = system (treated as auto for UI)`
	`358`	`+ let modeValue = Int(SMC.shared.getValue("F\(id)Md") ?? 0)`
	`359`	`+ return modeValue == 1 ? .forced : .automatic`
	`360`	`+ #else`
	`361`	`+ // Legacy Intel: Use FS! bitmask`
	`362`	`+ // Bitmask: 0 = all auto, 1 = fan 0 forced, 2 = fan 1 forced, 3 = both forced`
`355`	`363`	`let fansMode: Int = Int(SMC.shared.getValue("FS! ") ?? 0)`
`356`	`364`	`var mode: FanMode = .automatic`
`357`	`365`
`@@ -366,6 +374,7 @@ extension SensorsReader {`
`366`	`374`	`}`
`367`	`375`
`368`	`376`	`return mode`
	`377`	`+ #endif`
`369`	`378`	`}`
`370`	`379`	`}`
`371`	`380`