Add support for Intel turbo frequency throttling through intel_pstate

mbpfan.conf

@@ -16,3 +16,4 @@ low_temp = 63			# try ranges 55-63, default is 63
 high_temp = 66			# try ranges 58-66, default is 66
 max_temp = 86			# take highest number returned by "cat /sys/devices/platform/coretemp.*/hwmon/hwmon*/temp*_max", divide by 1000
 polling_interval = 1	# default is 1 seconds
+intel_pstate_control = 0	# whether mbpfan should throttle down max turbo speed when exceeding max temp

src/daemon.c

@@ -34,6 +34,7 @@
 #include "global.h"
 #include "daemon.h"
 #include "util.h"
+#include "intel_pstate.h"
 
 int daemonize = 1;
 int verbose = 0;
@@ -108,6 +109,9 @@ static void cleanup_and_exit(int exit_code)
 		sensors = next_sensor;
 	}
 
+	intel_pstate_exit(intel_pstate);
+	free(intel_pstate);
+
 	exit(exit_code);
 }
 

src/intel_pstate.c

@@ -0,0 +1,148 @@
+/**
+ *  intel_pstate.c - automatically control turbo frequency for MacBook Pro
+ *  Copyright (C) 2021 Gokturk Yuksek <[email protected]>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <dirent.h>
+#include <errno.h>
+
+#include "intel_pstate.h"
+#include "util.h"
+#include <syslog.h>
+
+static int read_int(FILE *fp, int *val)
+{
+    char buf[4]; /* Maximum we can read in this module is '100\0' */
+    ssize_t ret;
+
+    ret = pread(fileno(fp), buf, sizeof(buf), 0);
+    if (ret >= 0) {
+        buf[ret] = '\0';
+        *val = atoi(buf);
+        return 0;
+    } else {
+        return (int)ret;
+    }
+}
+
+static inline int write_str(FILE *fp, char *str, int len)
+{
+    ssize_t ret;
+    ret = (int)pwrite(fileno(fp), str, len, 0);
+    if (ret == len)
+        return 0;
+    else
+        return -1;
+}
+
+static int write_int(FILE *fp, int val)
+{
+    char buf[4]; /* Maximum we can read in this module is '100\0' */
+    int ret;
+
+    ret = snprintf(buf, sizeof(buf), "%d", val);
+    if (ret < 0)
+        return ret;
+
+    return write_str(fp, buf, ret);
+}
+
+int intel_pstate_init(t_intel_pstate *intel_pstate)
+{
+    const char *path_max_perf_pct = INTEL_PT_PATH "/max_perf_pct";
+    const char *path_min_perf_pct = INTEL_PT_PATH "/min_perf_pct";
+    FILE *fp;
+    int err;
+
+    fp = fopen(path_max_perf_pct, "w+");
+    if (!fp)
+        return -1;
+    /* Save the initial value of max_perf_pct, to restore it on exit */
+    err = read_int(fp, &intel_pstate->preserved_max_perf_pct);
+    if (err)
+        return err;
+    /* Start with the maximum performance percentage at 100% */
+    err = write_str(fp, "100", 4);
+    if (err)
+        return err;
+    intel_pstate->f_max_perf_pct = fp;
+
+    fp = fopen(path_min_perf_pct, "w+");
+    if (!fp)
+        return -1;
+    /* Save the initial value of min_perf_pct, to restore it on exit */
+    err = read_int(fp, &intel_pstate->preserved_min_perf_pct);
+    if (err)
+        return err;
+    /* Set the minimum performance percentage to 0 */
+    err = write_str(fp, "0", 2);
+    if (err)
+        return err;
+    intel_pstate->f_min_perf_pct = fp;
+
+    return 0;
+}
+
+int intel_pstate_is_available(void)
+{
+    DIR* dir = opendir(INTEL_PT_PATH);
+
+    if ((!dir) && ENOENT == errno)
+        return 0;
+
+    closedir(dir);
+    return 1;
+}
+
+int intel_pstate_adjust(t_intel_pstate *intel_pstate, int step)
+{
+    int val;
+    int err;
+
+    if (!intel_pstate)
+        return 1;
+
+    err = read_int(intel_pstate->f_max_perf_pct, &val);
+    if (err)
+        return err;
+
+    mbp_log(LOG_INFO, "Adjusting intel_pstate: val: %d, step: %d", val, step);
+
+    val += step;
+    if (val < 0)
+        val = 0;
+    if (val > 100)
+        val = 100;
+
+    return write_int(intel_pstate->f_max_perf_pct, val);
+}
+
+void intel_pstate_exit(t_intel_pstate *intel_pstate)
+{
+    if (!intel_pstate)
+        return;
+
+    (void)write_int(intel_pstate->f_max_perf_pct, intel_pstate->preserved_max_perf_pct);
+    (void)write_int(intel_pstate->f_min_perf_pct, intel_pstate->preserved_min_perf_pct);
+
+    fclose(intel_pstate->f_max_perf_pct);
+    fclose(intel_pstate->f_min_perf_pct);
+
+    memset(intel_pstate, 0, sizeof(*intel_pstate));
+}

src/intel_pstate.h

@@ -0,0 +1,38 @@
+/**
+ *  intel_pstate.c - automatically control turbo frequency for MacBook Pro
+ *  Copyright (C) 2021 Gokturk Yuksek <[email protected]>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ */
+
+#ifndef  _INTEL_PT_H_
+#define _INTEL_PT_H_
+
+#define INTEL_PT_PATH "/sys/devices/system/cpu/intel_pstate/"
+
+struct s_intel_pstate {
+    FILE *f_max_perf_pct;
+    FILE *f_min_perf_pct;
+    int preserved_max_perf_pct;
+    int preserved_min_perf_pct;
+};
+
+typedef struct s_intel_pstate t_intel_pstate;
+
+extern t_intel_pstate *intel_pstate;
+
+extern int intel_pstate_init(t_intel_pstate *intel_pstate);
+extern int intel_pstate_is_available(void);
+extern int intel_pstate_adjust(t_intel_pstate *intel_pstate, int step);
+extern void intel_pstate_exit(t_intel_pstate *intel_pstate);
+
+#endif /*_INTEL_PT_H_*/

src/mbpfan.c

@@ -45,6 +45,7 @@
 #include "global.h"
 #include "settings.h"
 #include "util.h"
+#include "intel_pstate.h"
 
 /* lazy min/max... */
 #define min(a,b) ((a) < (b) ? (a) : (b))
@@ -61,6 +62,9 @@ int low_temp = 63;   // try ranges 55-63
 int high_temp = 66;  // try ranges 58-66
 int max_temp = 86;   // do not set it > 90
 
+/* Whether mbpfan should control the turbo frequency or not */
+int intel_pstate_control = 0;  // disabled by default
+
 // maximum number of processors etc supported
 #define NUM_PROCESSORS 6
 #define NUM_HWMONS 12
@@ -74,6 +78,7 @@ int polling_interval = 1;
 
 t_sensors* sensors = NULL;
 t_fans* fans = NULL;
+t_intel_pstate* intel_pstate = NULL;
 
 char *smprintf(const char *fmt, ...)
 {
@@ -524,6 +529,12 @@ void retrieve_settings(const char* settings_path, t_fans* fans)
                 polling_interval = result;
             }
 
+            result = settings_get_int(settings, "general", "intel_pstate_control");
+
+            if (result != 0) {
+                intel_pstate_control = (result == 0) ? 0 : 1;
+            }
+
             /* Destroy the settings object */
             settings_delete(settings);
         }
@@ -573,12 +584,31 @@ void mbpfan()
 {
     int old_temp, new_temp, fan_speed, steps;
     int temp_change;
+    int err;
 
     sensors = retrieve_sensors();
     fans = retrieve_fans();
 
     retrieve_settings(NULL, fans);
 
+    if (intel_pstate_control) {
+        if (!intel_pstate_is_available()) {
+            mbp_log(LOG_ERR, "Intel pstate control is requested but not available");
+            exit(EXIT_FAILURE);
+        } else {
+            intel_pstate = (t_intel_pstate*)malloc(sizeof(t_intel_pstate));
+            if (!intel_pstate) {
+                mbp_log(LOG_ERR, "Failed to allocate memory for intel_pstate control");
+                exit(EXIT_FAILURE);
+            }
+            err = intel_pstate_init(intel_pstate);
+            if (err) {
+                mbp_log(LOG_ERR, "Failed to initialize intel_pstate control");
+                exit(EXIT_FAILURE);
+            }
+        }
+    }
+
     t_fans* fan = fans;
     while(fan != NULL) {
 
@@ -620,6 +650,13 @@ void mbpfan()
         old_temp = new_temp;
         new_temp = get_temp(sensors);
 
+	if (new_temp <= high_temp) /* maximize turbo below high_temp */
+	    intel_pstate_adjust(intel_pstate, +100);
+	else if (new_temp >= max_temp) /* throttle down to keep the temp in control */
+	    intel_pstate_adjust(intel_pstate, -4);
+	else if ((new_temp - old_temp) <= -3) /* core is cooling down, increase turbo */
+	    intel_pstate_adjust(intel_pstate, +1);
+
         fan = fans;
 
 	while(fan != NULL) {