Fix charging continuing above the max limit

Charge inhibition wrote only CH0C=0x01, which left the battery trickle
charging above the limit instead of bypassing it. Match the batt
reference: write CH0B and CH0C together (0x02 = inhibit) on pre-Tahoe
firmware, or CHTE on Tahoe firmware. SMCComm probes key capability once
and picks the right path, so both firmware families work.

All control paths (heat protection, charge-to-full, manual overrides,
auto limit) now route through SMCComm.disableCharging()/enableCharging().
With charging properly inhibited the adapter still powers the system, so
the battery is held at the limit rather than charged or discharged.

Update the README SMC-key table to match.

Author: will2022

Daemon/PowerMonitor.swift

@@ -326,8 +326,7 @@ class PowerMonitor {
             if currentTemp >= heatThreshold {
                 DaemonLogger.shared.log("Heat protection active (\(currentTemp)°C). Disabling charging.")
                 isHeatProtectionTriggered = true
-                _ = SMCComm.writeKey("CH0C", value: [0x01])
-                _ = SMCComm.writeKey("CHTE", value: [0x01, 0x00, 0x00, 0x00])
+                _ = SMCComm.disableCharging()
                 updateMagSafeLED(chargingDisabled: true, isManualDischarge: false)
                 updateSleepAssertion(isCharging: false, isDischarging: false)
                 return
@@ -338,8 +337,7 @@ class PowerMonitor {
         // 2. Charge to Full
         if chargingToFull {
             DaemonLogger.shared.log("Charge to full active.")
-            _ = SMCComm.writeKey("CH0C", value: [0x00])
-            _ = SMCComm.writeKey("CHTE", value: [0x00, 0x00, 0x00, 0x00])
+            _ = SMCComm.enableCharging()
             _ = SMCComm.writeKey("CHIE", value: [0x00])
             _ = SMCComm.writeKey("CH0J", value: [0x00])
             updateMagSafeLED(chargingDisabled: false, isManualDischarge: false)
@@ -350,8 +348,7 @@ class PowerMonitor {
         // 3. Manual Overrides
         if adapterDisabledManual {
             DaemonLogger.shared.log("Manual adapter disable active.")
-            _ = SMCComm.writeKey("CH0C", value: [0x01])
-            _ = SMCComm.writeKey("CHTE", value: [0x01, 0x00, 0x00, 0x00])
+            _ = SMCComm.disableCharging()
             _ = SMCComm.writeKey("CHIE", value: [0x08])
             _ = SMCComm.writeKey("CH0J", value: [0x20])
             updateMagSafeLED(chargingDisabled: true, isManualDischarge: true)
@@ -361,8 +358,7 @@ class PowerMonitor {
 
         if chargingDisabledManual {
             DaemonLogger.shared.log("Manual charging disable active.")
-            _ = SMCComm.writeKey("CH0C", value: [0x01])
-            _ = SMCComm.writeKey("CHTE", value: [0x01, 0x00, 0x00, 0x00])
+            _ = SMCComm.disableCharging()
             _ = SMCComm.writeKey("CHIE", value: [0x00])
             _ = SMCComm.writeKey("CH0J", value: [0x00])
             updateMagSafeLED(chargingDisabled: true, isManualDischarge: false)
@@ -389,13 +385,12 @@ class PowerMonitor {
                     }
 
                     if !isChargingEnabledState {
-                        // Check if macOS overrode our setting
+                        // Check if macOS overrode our setting (CH0C 0x00 == charging enabled)
                         if let currentCH0C = SMCComm.readKey("CH0C"), currentCH0C.first == 0x00 {
-                            DaemonLogger.shared.log("macOS override detected! CH0C was 00 (enabled), forcing back to 01 (inhibited).")
+                            DaemonLogger.shared.log("macOS override detected! CH0C was 00 (enabled), forcing back to inhibited.")
                         }
 
-                        _ = SMCComm.writeKey("CH0C", value: [0x01])
-                        _ = SMCComm.writeKey("CHTE", value: [0x01, 0x00, 0x00, 0x00])
+                        _ = SMCComm.disableCharging()
 
                         var isDischarging = false
                         if floatingModeEnabled || (autoDischargeEnabled && cap > maxLimit) {
@@ -418,8 +413,7 @@ class PowerMonitor {
                         updateSleepAssertion(isCharging: false, isDischarging: isDischarging)
                     } else {
                         DaemonLogger.shared.log("Control: Allowing charge (\(cap)% < \(startLimit)% start target).")
-                        _ = SMCComm.writeKey("CH0C", value: [0x00])
-                        _ = SMCComm.writeKey("CHTE", value: [0x00, 0x00, 0x00, 0x00])
+                        _ = SMCComm.enableCharging()
                         _ = SMCComm.writeKey("CHIE", value: [0x00])
                         _ = SMCComm.writeKey("CH0J", value: [0x00])
 

Daemon/SMCComm.swift

@@ -6,7 +6,11 @@ let smcLogger = Logger(subsystem: "com.chargecontrol.daemon", category: "SMC")
 
 public struct SMCComm {
     private static var connection: io_connect_t = 0
-    
+
+    /// Cache of which keys the SMC exposes, so firmware detection probes each
+    /// key only once.
+    private static var keyCapabilities: [String: Bool] = [:]
+
     public static func open() -> Bool {
         guard connection == 0 else { return true }
 
@@ -190,6 +194,55 @@ public struct SMCComm {
         return bytes.withUnsafeBytes { $0.load(as: UInt32.self) }
     }
 
+    /// Whether the SMC exposes a given key on this machine. The result is
+    /// cached, so the key-info lookup only runs once per key.
+    private static func keyExists(_ key: String) -> Bool {
+        if let cached = keyCapabilities[key] { return cached }
+        guard open() else { return false }
+
+        var input = SMCParamStruct()
+        var output = SMCParamStruct()
+        input.key = key.fourCharCode
+        input.data8 = UInt8(kSMCGetKeyInfo)
+
+        let result = callSMCFunctionYPC(input: &input, output: &output)
+        let exists = result == kIOReturnSuccess && output.result == UInt8(kSMCSuccess)
+        keyCapabilities[key] = exists
+        return exists
+    }
+
+    /// Pre-Tahoe firmware exposes the CH0B/CH0C charging keys; Tahoe and later
+    /// use CHTE instead. We prefer the legacy pair when both are present.
+    private static var usesLegacyChargingKeys: Bool {
+        return keyExists("CH0B") && keyExists("CH0C")
+    }
+
+    /// Inhibit or allow battery charging. While inhibited the system runs from
+    /// the adapter and the battery is bypassed (neither charged nor discharged).
+    ///
+    /// Values match the `batt` reference: pre-Tahoe firmware writes 0x02/0x00 to
+    /// both CH0B and CH0C; Tahoe firmware writes 0x01/0x00 to CHTE.
+    private static func setChargingInhibited(_ inhibited: Bool) -> Bool {
+        if usesLegacyChargingKeys {
+            let value: UInt8 = inhibited ? 0x02 : 0x00
+            let b = writeKey("CH0B", value: [value])
+            let c = writeKey("CH0C", value: [value])
+            return b && c
+        }
+        let value: UInt8 = inhibited ? 0x01 : 0x00
+        return writeKey("CHTE", value: [value, 0x00, 0x00, 0x00])
+    }
+
+    /// Inhibit charging (bypass the battery, run from the adapter).
+    public static func disableCharging() -> Bool {
+        return setChargingInhibited(true)
+    }
+
+    /// Allow charging.
+    public static func enableCharging() -> Bool {
+        return setChargingInhibited(false)
+    }
+
     public enum MagSafeColor: UInt8 {
         case system = 0x00
         case off    = 0x01

README.md

@@ -187,7 +187,8 @@ graph TD
 
 ### SMC Keys (Apple Silicon)
 ChargeControl interacts with the AppleSMC using the following keys:
-- `CH0C` / `CHTE`: Charging control (0 = Enable, 1 = Disable).
+- `CH0B` / `CH0C`: Charging control on pre-Tahoe firmware — both are written together (`0x00` = Enable, `0x02` = Disable/bypass).
+- `CHTE`: Charging control on Tahoe firmware (`00 00 00 00` = Enable, `01 00 00 00` = Disable).
 - `CHIE` / `CH0J`: Power adapter isolation (0 = Connected, 8/32 = Isolated).
 - `ACLC`: MagSafe LED control (0 = System, 1 = Off, 3 = Green, 4 = Orange).
 - `B0Te`, `TC0P`, `TG0P`, `Ts0P`: Thermal sensors (Battery, CPU, GPU, Palm Rest).