Add Apple Silicon fan control via direct SMC operations

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.1.0</string>
 	<key>CFBundleVersion</key>
-	<string>2</string>
+	<string>3</string>
 	<key>CFBundleInfoDictionaryVersion</key>
 	<string>6.0</string>
 	<key>SMAuthorizedClients</key>

SMC/Helper/main.swift

@@ -10,6 +10,7 @@
 //
 
 import Foundation
+import IOKit
 
 let helper = Helper()
 helper.run()
@@ -21,12 +22,27 @@ class Helper: NSObject, NSXPCListenerDelegate, HelperProtocol {
     private var shouldQuit = false
     private var shouldQuitCheckInterval = 1.0
 
-    private var smc: String? = nil
+    private var smcConnection: io_connect_t = 0
 
     override init() {
         self.listener = NSXPCListener(machServiceName: "eu.exelban.Stats.SMC.Helper")
         super.init()
         self.listener.delegate = self
+        
+        // Open SMC connection on initialization
+        let (conn, result) = smcOpenConnection()
+        if result == kIOReturnSuccess {
+            self.smcConnection = conn
+            NSLog("SMC connection opened successfully")
+        } else {
+            NSLog("Failed to open SMC connection: \(result)")
+        }
+    }
+    
+    deinit {
+        if self.smcConnection != 0 {
+            IOServiceClose(self.smcConnection)
+        }
     }
 
     public func run() {
@@ -111,40 +127,101 @@ extension Helper {
         completion(Bundle.main.object(forInfoDictionaryKey: "CFBundleShortVersionString") as? String ?? "0")
     }
     func setSMCPath(_ path: String) {
-        self.smc = path
+        // Legacy method - no longer needed with direct SMC access
+        // Kept for protocol compatibility
     }
 
     func setFanMode(id: Int, mode: Int, completion: (String?) -> Void) {
-        guard let smc = self.smc else {
-            completion("missing smc tool")
+        guard self.smcConnection != 0 else {
+            completion("SMC connection not available")
             return
         }
-        let result = syncShell("\(smc) fan \(id) -m \(mode)")
 
-        if let error = result.error, !error.isEmpty {
-            NSLog("error set fan mode: \(error)")
-            completion(nil)
-            return
+        if mode == 1 {
+            // Switching TO manual mode - unlock fan control for this specific fan
+            // The unlock function also sets the fan to manual mode
+            let unlockResult = smcUnlockFanControl(self.smcConnection, fanIndex: id)
+            if unlockResult != kIOReturnSuccess {
+                NSLog("Failed to unlock fan control: \(unlockResult)")
+                completion("Failed to unlock fan control")
+                return
+            }
+        } else if mode == 0 {
+            // Switching TO automatic mode
+            // Count how many OTHER fans are currently in manual mode (mode byte == 1)
+            let (numResult, numBytes, _) = smcRead(self.smcConnection, key: SMC_KEY_FNUM)
+            var otherFansManual = 0
+            
+            if numResult == kIOReturnSuccess && !numBytes.isEmpty {
+                let fanCount = Int(numBytes[0])
+                for i in 0..<fanCount {
+                    if i == id { continue }  // Skip the fan we're setting to auto
+                    let checkKey = String(format: SMC_KEY_FAN_MODE, i)
+                    let (_, checkBytes, _) = smcRead(self.smcConnection, key: checkKey)
+                    // Mode byte: 0=auto, 1=manual, 3=system
+                    if !checkBytes.isEmpty && checkBytes[0] == 1 {
+                        otherFansManual += 1
+                    }
+                }
+            }
+            
+            if otherFansManual > 0 {
+                // Other fans are still manual, keep Ftst=1 but set this fan to auto
+                let modeKey = String(format: SMC_KEY_FAN_MODE, id)
+                let modeResult = smcWrite(self.smcConnection, key: modeKey, value: [0], size: 1)
+                if modeResult != kIOReturnSuccess {
+                    NSLog("Warning: Failed to set auto mode for fan \(id): \(modeResult)")
+                }
+                NSLog("Set fan \(id) to auto, other fans still manual")
+            } else {
+                // No other fans in manual mode, reset Ftst to restore automatic control
+                // This allows fans to enter system mode (mode 3) and idle at 0 RPM
+                let resetResult = smcWrite(
+                    self.smcConnection, key: SMC_KEY_FAN_TEST, value: [0], size: 1
+                )
+                if resetResult != kIOReturnSuccess {
+                    NSLog("Warning: Failed to reset Ftst: \(resetResult)")
+                }
+                NSLog("Reset Ftst, restoring automatic fan control")
+            }
         }
 
-        completion(result.output)
+        NSLog("Fan \(id) mode set to \(mode)")
+        completion("Success")
     }
 
     func setFanSpeed(id: Int, value: Int, completion: (String?) -> Void) {
-        guard let smc = self.smc else {
-            completion("missing smc tool")
+        guard self.smcConnection != 0 else {
+            completion("SMC connection not available")
             return
         }
 
-        let result = syncShell("\(smc) fan \(id) -v \(value)")
+        // Read current target to determine data format (also verifies key exists)
+        let targetKey = String(format: SMC_KEY_FAN_TARGET, id)
+        let (readResult, _, size) = smcRead(self.smcConnection, key: targetKey)
 
-        if let error = result.error, !error.isEmpty {
-            NSLog("error set fan speed: \(error)")
-            completion(nil)
+        if readResult != kIOReturnSuccess {
+            NSLog("Error reading fan target: \(readResult)")
+            completion("Failed to read fan target")
             return
         }
 
-        completion(result.output)
+        // Convert speed to appropriate format based on data size
+        let speedBytes = floatToBytes(Float(value), size: size)
+        
+        // Write new target speed
+        // Note: Fan should already be in manual mode from a prior setFanMode call.
+        // If not, this write may not take effect until mode is set.
+        let writeResult = smcWrite(self.smcConnection, key: targetKey, value: speedBytes, size: size)
+        
+        if writeResult != kIOReturnSuccess {
+            NSLog("Error setting fan speed: \(writeResult)")
+            completion("Failed to set fan speed")
+            return
+        }
+        
+        NSLog("Fan \(id) speed set to \(value)")
+        completion("Success")
     }
 
     func powermetrics(_ samplers: [String], completion: @escaping (String?) -> Void) {

SMC/SMCConnection.swift

@@ -0,0 +1,129 @@
+//
+//  SMCConnection.swift
+//  Stats
+//
+//  Created by Alex Goodkind <alex@goodkind.io> on 23/01/2026
+//  Based on macos-smc-fan (github.com/agoodkind/macos-smc-fan)
+//
+
+import Foundation
+import IOKit
+
+// MARK: - SMC Connection Management
+
+//
+// These functions handle IOKit service discovery and connection lifecycle.
+// They use IOKit directly (no C struct packing required).
+
+/// Open connection to AppleSMC IOKit service
+func smcOpenConnection() -> (io_connect_t, kern_return_t) {
+    var iterator: io_iterator_t = 0
+    let matchingDict = IOServiceMatching("AppleSMC")
+
+    // Use kIOMainPortDefault on macOS 12.0+, kIOMasterPortDefault on older versions
+    let mainPort: mach_port_t
+    if #available(macOS 12.0, *) {
+        mainPort = kIOMainPortDefault
+    } else {
+        mainPort = kIOMasterPortDefault
+    }
+
+    let matchResult = IOServiceGetMatchingServices(
+        mainPort,
+        matchingDict,
+        &iterator
+    )
+    guard matchResult == kIOReturnSuccess else {
+        return (0, matchResult)
+    }
+
+    let device = IOIteratorNext(iterator)
+    IOObjectRelease(iterator)
+
+    guard device != 0 else {
+        return (0, kIOReturnNotFound)
+    }
+
+    var conn: io_connect_t = 0
+    let openResult = IOServiceOpen(device, mach_task_self_, 0, &conn)
+    IOObjectRelease(device)
+
+    return (conn, openResult)
+}
+
+// MARK: - Swift Wrappers for C SMC Functions
+
+//
+// Why these wrappers exist:
+// - C functions require raw pointers (const char*, unsigned char*)
+// - Swift arrays/strings don't auto-convert to C pointers
+// - withCString/withUnsafeBytes provides safe temporary pointers
+//
+// Why the underlying C functions exist (see smc.h):
+// - SMC requires IOConnectCallStructMethod with exact 80-byte struct layout
+// - Swift's automatic struct padding differs from C (offset 39 vs 42)
+
+/// Read SMC key, returning (result, value, size)
+func smcRead(_ conn: io_connect_t, key: String) -> (kern_return_t, [UInt8], UInt32) {
+    var value: [UInt8] = Array(repeating: 0, count: 32)
+    var size: UInt32 = 0
+
+    let result = key.withCString { keyPtr in
+        value.withUnsafeMutableBufferPointer { bufferPtr in
+            smc_read_key(conn, keyPtr, bufferPtr.baseAddress!, &size)
+        }
+    }
+
+    return (result, value, size)
+}
+
+/// Write SMC key with byte array
+func smcWrite(_ conn: io_connect_t, key: String, value: [UInt8], size: UInt32) -> kern_return_t {
+    var val = value
+    if val.count < 32 {
+        val.append(contentsOf: [UInt8](repeating: 0, count: 32 - val.count))
+    }
+
+    return key.withCString { keyPtr in
+        val.withUnsafeBytes { bytes in
+            smc_write_key(conn, keyPtr, bytes.baseAddress!.assumingMemoryBound(to: UInt8.self), size)
+        }
+    }
+}
+
+// MARK: - Fan Control Unlock
+
+/// Unlock fan control by writing Ftst=1 and retrying mode write for the specified fan.
+/// This unlocks the SMC for manual fan control on Apple Silicon.
+/// Sets the specified fan to manual mode (1) as part of the unlock.
+func smcUnlockFanControl(
+    _ conn: io_connect_t,
+    fanIndex: Int = 0,
+    maxRetries: Int = 100,
+    timeout: TimeInterval = 10.0
+) -> kern_return_t {
+    // Step 1: Write Ftst=1 to trigger unlock
+    var result = smcWrite(conn, key: SMC_KEY_FAN_TEST, value: [1], size: 1)
+    guard result == kIOReturnSuccess else { return result }
+
+    // Step 2: Retry writing mode=1 to the specified fan until it succeeds
+    // This both verifies unlock and sets the fan to manual mode
+    let modeKey = String(format: SMC_KEY_FAN_MODE, fanIndex)
+    let startTime = Date()
+
+    for _ in 0 ..< maxRetries {
+        result = smcWrite(conn, key: modeKey, value: [1], size: 1)
+
+        if result == kIOReturnSuccess {
+            return kIOReturnSuccess
+        }
+
+        if Date().timeIntervalSince(startTime) >= timeout {
+            return kIOReturnTimeout
+        }
+
+        Thread.sleep(forTimeInterval: 0.1)
+    }
+
+    return kIOReturnTimeout
+}