power/power_dragon.cpp - device/google/dragon - Git at Google

 /*
  * Copyright (C) 2014 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include <dirent.h>
 #include <errno.h>
 #include <string.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <stdlib.h>
 #include <stdbool.h>
 #include <cutils/properties.h>
 //#define LOG_NDEBUG 0

 #define LOG_TAG "DragonPowerHAL"
 #include <utils/Log.h>

 #include <hardware/hardware.h>
 #include <hardware/power.h>

 #include "timed_qos_manager.h"

 #define BOOSTPULSE_PATH "/sys/devices/system/cpu/cpufreq/interactive/boostpulse"
 #define CPU_MAX_FREQ_PATH "/sys/devices/system/cpu/cpu0/cpufreq/scaling_max_freq"
 #define IO_IS_BUSY_PATH "/sys/devices/system/cpu/cpufreq/interactive/io_is_busy"
 #define LIGHTBAR_SEQUENCE_PATH "/sys/class/chromeos/cros_ec/lightbar/sequence"
 #define IIO_ACTIVITY_DEVICE_PATH "/sys/class/chromeos/cros_ec/device/cros-ec-activity.0"
 #define IIO_DOUBLE_TAP_EVENT "events/in_activity_double_tap_change_falling_en"
 #define IIO_DEVICE_PREFIX "iio:device"
 #define EXT_VOLTAGE_LIM_PATH "/sys/class/chromeos/cros_ec/usb-pd-charger/ext_voltage_lim"
 #define EC_POWER_LIMIT_NONE "0xffff"
 #define LOW_POWER_MAX_FREQ "1020000"
 #define NORMAL_MAX_FREQ "1912500"
 #define GPU_CAP_PATH "/sys/kernel/debug/system_edp/capping/force_gpu"
 #define LOW_POWER_GPU_CAP "3000"
 #define NORMAL_GPU_CAP "0"
 #define GPU_BOOST_PATH "/sys/devices/57000000.gpu/pstate"
 #define GPU_BOOST_ENTER_CMD "06,0C"    // boost GPU to work at least on 06 - 460MHz
 #define GPU_BOOST_DURATION_MS 2000
 #define GPU_BOOST_EXIT_CMD "auto"
 #define GPU_FREQ_CONSTRAINT "852000 852000 -1 2000"

 struct dragon_power_module {
     struct power_module base;
     pthread_mutex_t boost_pulse_lock;
     pthread_mutex_t low_power_lock;
     int boostpulse_fd;
     int boostpulse_warned;
     TimedQosManager *gpu_qos_manager;
 };

 static bool low_power_mode = false;
 static char *iio_activity_device = NULL;

 static const char *max_cpu_freq = NORMAL_MAX_FREQ;
 static const char *low_power_max_cpu_freq = LOW_POWER_MAX_FREQ;

 static const char *normal_gpu_cap = NORMAL_GPU_CAP;
 static const char *low_power_gpu_cap = LOW_POWER_GPU_CAP;


 void sysfs_write(const char *path, const char *s)
 {
     char buf[80];
     int len;
     int fd = open(path, O_WRONLY);

     if (fd < 0) {
         strerror_r(errno, buf, sizeof(buf));
         ALOGE("Error opening %s: %s\n", path, buf);
         return;
     }

     len = write(fd, s, strlen(s));
     if (len < 0) {
         strerror_r(errno, buf, sizeof(buf));
         ALOGE("Error writing to %s: %s\n", path, buf);
     }

     close(fd);
 }

 static void power_init(struct power_module __unused *module)
 {
     struct dragon_power_module *dragon =
             (struct dragon_power_module *) module;

     dragon->gpu_qos_manager = new TimedQosManager("GPU",
         new SysfsQosObject(GPU_BOOST_PATH, GPU_BOOST_ENTER_CMD, GPU_BOOST_EXIT_CMD),
         false);
     dragon->gpu_qos_manager->run("GpuTimedQosManager", PRIORITY_FOREGROUND);

     sysfs_write("/sys/devices/system/cpu/cpufreq/interactive/timer_rate",
                 "20000");
     sysfs_write("/sys/devices/system/cpu/cpufreq/interactive/timer_slack",
                 "20000");
     sysfs_write("/sys/devices/system/cpu/cpufreq/interactive/min_sample_time",
                 "80000");
     sysfs_write("/sys/devices/system/cpu/cpufreq/interactive/hispeed_freq",
                 "1530000");
     sysfs_write("/sys/devices/system/cpu/cpufreq/interactive/go_hispeed_load",
                 "99");
     sysfs_write("/sys/devices/system/cpu/cpufreq/interactive/target_loads",
                 "65 228000:75 624000:85");
     sysfs_write("/sys/devices/system/cpu/cpufreq/interactive/above_hispeed_delay",
                 "20000");
     sysfs_write("/sys/devices/system/cpu/cpufreq/interactive/boostpulse_duration",
                 "1000000");
     sysfs_write("/sys/devices/system/cpu/cpufreq/interactive/io_is_busy", "0");
     sysfs_write("/sys/class/chromeos/cros_ec/lightbar/userspace_control", "1");

     /* Find the iio device used for activities/estures recognition */
     DIR *iio_activity_dir = opendir(IIO_ACTIVITY_DEVICE_PATH);
     if (iio_activity_dir == NULL) {
         ALOGE("%s is not available.\n", iio_activity_dir);
         return;
     }
     const struct dirent *ent_device;
     while (ent_device = readdir(iio_activity_dir), ent_device != NULL) {
         if (!strncmp(ent_device->d_name, IIO_DEVICE_PREFIX, strlen(IIO_DEVICE_PREFIX))) {
             iio_activity_device = strdup(ent_device->d_name);
             break;
         }
     }
     if (iio_activity_device == NULL)
         ALOGE("Activity device not found");
 }

 static void power_set_interactive(struct power_module __unused *module, int on)
 {
     ALOGV("power_set_interactive: %d\n", on);

     /*
      * Lower maximum frequency when screen is off.
      */
     sysfs_write(CPU_MAX_FREQ_PATH,
                 (!on || low_power_mode) ? low_power_max_cpu_freq : max_cpu_freq);
     sysfs_write(IO_IS_BUSY_PATH, on ? "1" : "0");
     sysfs_write(LIGHTBAR_SEQUENCE_PATH, on ? "s3s0" : "s0s3");
     /* limit charging voltage to 5V when interactive otherwise no limit */
     sysfs_write(EXT_VOLTAGE_LIM_PATH, on ? "5000" : EC_POWER_LIMIT_NONE);
     if (iio_activity_device != NULL) {
         char buf[128];
         snprintf(buf, sizeof(buf), "%s/%s/%s", IIO_ACTIVITY_DEVICE_PATH,
                  iio_activity_device, IIO_DOUBLE_TAP_EVENT);
         sysfs_write(buf, on ? "0" : "1");
     }
     ALOGV("power_set_interactive: %d done\n", on);
 }

 static int boostpulse_open(struct dragon_power_module *dragon)
 {
     char buf[80];
     int len;

     pthread_mutex_lock(&dragon->boost_pulse_lock);

     if (dragon->boostpulse_fd < 0) {
         dragon->boostpulse_fd = open(BOOSTPULSE_PATH, O_WRONLY);

         if (dragon->boostpulse_fd < 0) {
             if (!dragon->boostpulse_warned) {
                 strerror_r(errno, buf, sizeof(buf));
                 ALOGE("Error opening %s: %s\n", BOOSTPULSE_PATH, buf);
                 dragon->boostpulse_warned = 1;
             }
         }
     }

     pthread_mutex_unlock(&dragon->boost_pulse_lock);
     return dragon->boostpulse_fd;
 }

 static void dragon_power_hint(struct power_module *module, power_hint_t hint,
                                 void *data)
 {
     struct dragon_power_module *dragon =
             (struct dragon_power_module *) module;
     char buf[80];
     int len;

     switch (hint) {
     case POWER_HINT_INTERACTION:
         if (boostpulse_open(dragon) >= 0) {
             len = write(dragon->boostpulse_fd, "1", 1);

             if (len < 0) {
                 strerror_r(errno, buf, sizeof(buf));
                 ALOGE("Error writing to %s: %s\n", BOOSTPULSE_PATH, buf);
             }
         }
         if (dragon->gpu_qos_manager != NULL)
             dragon->gpu_qos_manager->requestTimedQos(ms2ns(GPU_BOOST_DURATION_MS));

         break;

     case POWER_HINT_VSYNC:
         break;

     case POWER_HINT_LOW_POWER:
         pthread_mutex_lock(&dragon->low_power_lock);
         if (data) {
             sysfs_write(CPU_MAX_FREQ_PATH, low_power_max_cpu_freq);
             sysfs_write(GPU_CAP_PATH, low_power_gpu_cap);
         } else {
             sysfs_write(CPU_MAX_FREQ_PATH, max_cpu_freq);
             sysfs_write(GPU_CAP_PATH, normal_gpu_cap);
         }
         low_power_mode = data;
         pthread_mutex_unlock(&dragon->low_power_lock);
         break;

     default:
             break;
     }
 }

 static int dragon_power_open(const hw_module_t *module, const char *name,
                             hw_device_t **device)
 {
     ALOGD("%s: enter; name=%s", __FUNCTION__, name);
     int retval = 0; /* 0 is ok; -1 is error */

     if (strcmp(name, POWER_HARDWARE_MODULE_ID) == 0) {
         dragon_power_module *dev = (dragon_power_module *)calloc(1,
                 sizeof(dragon_power_module));

         if (dev) {
             /* Common hw_device_t fields */
             dev->base.common.tag = HARDWARE_MODULE_TAG;
             dev->base.common.module_api_version = POWER_MODULE_API_VERSION_0_2;
             dev->base.common.hal_api_version = HARDWARE_HAL_API_VERSION;

             dev->base.init = power_init;
             dev->base.powerHint = dragon_power_hint;
             dev->base.setInteractive = power_set_interactive;
             dev->boost_pulse_lock = PTHREAD_MUTEX_INITIALIZER;
             dev->low_power_lock = PTHREAD_MUTEX_INITIALIZER;
             dev->boostpulse_fd = -1;
             dev->boostpulse_warned = 0;
             dev->gpu_qos_manager = NULL;

             *device = (hw_device_t*)dev;
         } else
             retval = -ENOMEM;
     } else {
         retval = -EINVAL;
     }

     ALOGD("%s: exit %d", __FUNCTION__, retval);
     return retval;
 }


 static struct hw_module_methods_t power_module_methods = {
     .open = dragon_power_open,
 };

 struct dragon_power_module HAL_MODULE_INFO_SYM = {
     base: {
         common: {
             tag: HARDWARE_MODULE_TAG,
             module_api_version: POWER_MODULE_API_VERSION_0_2,
             hal_api_version: HARDWARE_HAL_API_VERSION,
             id: POWER_HARDWARE_MODULE_ID,
             name: "Dragon Power HAL",
             author: "The Android Open Source Project",
             methods: &power_module_methods,
             dso: NULL,
             reserved: {0},
         },

         init: power_init,
         setInteractive: power_set_interactive,
         powerHint: dragon_power_hint,
     },

     boost_pulse_lock: PTHREAD_MUTEX_INITIALIZER,
     low_power_lock: PTHREAD_MUTEX_INITIALIZER,
     boostpulse_fd: -1,
     boostpulse_warned: 0,
     gpu_qos_manager: NULL,
 };
	/*
	* Copyright (C) 2014 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include <dirent.h>
	#include <errno.h>
	#include <string.h>
	#include <sys/types.h>
	#include <sys/stat.h>
	#include <fcntl.h>
	#include <unistd.h>
	#include <stdlib.h>
	#include <stdbool.h>
	#include <cutils/properties.h>
	//#define LOG_NDEBUG 0

	#define LOG_TAG "DragonPowerHAL"
	#include <utils/Log.h>

	#include <hardware/hardware.h>
	#include <hardware/power.h>

	#include "timed_qos_manager.h"

	#define BOOSTPULSE_PATH "/sys/devices/system/cpu/cpufreq/interactive/boostpulse"
	#define CPU_MAX_FREQ_PATH "/sys/devices/system/cpu/cpu0/cpufreq/scaling_max_freq"
	#define IO_IS_BUSY_PATH "/sys/devices/system/cpu/cpufreq/interactive/io_is_busy"
	#define LIGHTBAR_SEQUENCE_PATH "/sys/class/chromeos/cros_ec/lightbar/sequence"
	#define IIO_ACTIVITY_DEVICE_PATH "/sys/class/chromeos/cros_ec/device/cros-ec-activity.0"
	#define IIO_DOUBLE_TAP_EVENT "events/in_activity_double_tap_change_falling_en"
	#define IIO_DEVICE_PREFIX "iio:device"
	#define EXT_VOLTAGE_LIM_PATH "/sys/class/chromeos/cros_ec/usb-pd-charger/ext_voltage_lim"
	#define EC_POWER_LIMIT_NONE "0xffff"
	#define LOW_POWER_MAX_FREQ "1020000"
	#define NORMAL_MAX_FREQ "1912500"
	#define GPU_CAP_PATH "/sys/kernel/debug/system_edp/capping/force_gpu"
	#define LOW_POWER_GPU_CAP "3000"
	#define NORMAL_GPU_CAP "0"
	#define GPU_BOOST_PATH "/sys/devices/57000000.gpu/pstate"
	#define GPU_BOOST_ENTER_CMD "06,0C" // boost GPU to work at least on 06 - 460MHz
	#define GPU_BOOST_DURATION_MS 2000
	#define GPU_BOOST_EXIT_CMD "auto"
	#define GPU_FREQ_CONSTRAINT "852000 852000 -1 2000"

	struct dragon_power_module {
	struct power_module base;
	pthread_mutex_t boost_pulse_lock;
	pthread_mutex_t low_power_lock;
	int boostpulse_fd;
	int boostpulse_warned;
	TimedQosManager *gpu_qos_manager;
	};

	static bool low_power_mode = false;
	static char *iio_activity_device = NULL;

	static const char *max_cpu_freq = NORMAL_MAX_FREQ;
	static const char *low_power_max_cpu_freq = LOW_POWER_MAX_FREQ;

	static const char *normal_gpu_cap = NORMAL_GPU_CAP;
	static const char *low_power_gpu_cap = LOW_POWER_GPU_CAP;


	void sysfs_write(const char path, const char s)
	{
	char buf[80];
	int len;
	int fd = open(path, O_WRONLY);

	if (fd < 0) {
	strerror_r(errno, buf, sizeof(buf));
	ALOGE("Error opening %s: %s\n", path, buf);
	return;
	}

	len = write(fd, s, strlen(s));
	if (len < 0) {
	strerror_r(errno, buf, sizeof(buf));
	ALOGE("Error writing to %s: %s\n", path, buf);
	}

	close(fd);
	}

	static void power_init(struct power_module __unused *module)
	{
	struct dragon_power_module *dragon =
	(struct dragon_power_module *) module;

	dragon->gpu_qos_manager = new TimedQosManager("GPU",
	new SysfsQosObject(GPU_BOOST_PATH, GPU_BOOST_ENTER_CMD, GPU_BOOST_EXIT_CMD),
	false);
	dragon->gpu_qos_manager->run("GpuTimedQosManager", PRIORITY_FOREGROUND);

	sysfs_write("/sys/devices/system/cpu/cpufreq/interactive/timer_rate",
	"20000");
	sysfs_write("/sys/devices/system/cpu/cpufreq/interactive/timer_slack",
	"20000");
	sysfs_write("/sys/devices/system/cpu/cpufreq/interactive/min_sample_time",
	"80000");
	sysfs_write("/sys/devices/system/cpu/cpufreq/interactive/hispeed_freq",
	"1530000");
	sysfs_write("/sys/devices/system/cpu/cpufreq/interactive/go_hispeed_load",
	"99");
	sysfs_write("/sys/devices/system/cpu/cpufreq/interactive/target_loads",
	"65 228000:75 624000:85");
	sysfs_write("/sys/devices/system/cpu/cpufreq/interactive/above_hispeed_delay",
	"20000");
	sysfs_write("/sys/devices/system/cpu/cpufreq/interactive/boostpulse_duration",
	"1000000");
	sysfs_write("/sys/devices/system/cpu/cpufreq/interactive/io_is_busy", "0");
	sysfs_write("/sys/class/chromeos/cros_ec/lightbar/userspace_control", "1");

	/* Find the iio device used for activities/estures recognition */
	DIR *iio_activity_dir = opendir(IIO_ACTIVITY_DEVICE_PATH);
	if (iio_activity_dir == NULL) {
	ALOGE("%s is not available.\n", iio_activity_dir);
	return;
	}
	const struct dirent *ent_device;
	while (ent_device = readdir(iio_activity_dir), ent_device != NULL) {
	if (!strncmp(ent_device->d_name, IIO_DEVICE_PREFIX, strlen(IIO_DEVICE_PREFIX))) {
	iio_activity_device = strdup(ent_device->d_name);
	break;
	}
	}
	if (iio_activity_device == NULL)
	ALOGE("Activity device not found");
	}

	static void power_set_interactive(struct power_module __unused *module, int on)
	{
	ALOGV("power_set_interactive: %d\n", on);

	/*
	* Lower maximum frequency when screen is off.
	*/
	sysfs_write(CPU_MAX_FREQ_PATH,
	(!on \|\| low_power_mode) ? low_power_max_cpu_freq : max_cpu_freq);
	sysfs_write(IO_IS_BUSY_PATH, on ? "1" : "0");
	sysfs_write(LIGHTBAR_SEQUENCE_PATH, on ? "s3s0" : "s0s3");
	/* limit charging voltage to 5V when interactive otherwise no limit */
	sysfs_write(EXT_VOLTAGE_LIM_PATH, on ? "5000" : EC_POWER_LIMIT_NONE);
	if (iio_activity_device != NULL) {
	char buf[128];
	snprintf(buf, sizeof(buf), "%s/%s/%s", IIO_ACTIVITY_DEVICE_PATH,
	iio_activity_device, IIO_DOUBLE_TAP_EVENT);
	sysfs_write(buf, on ? "0" : "1");
	}
	ALOGV("power_set_interactive: %d done\n", on);
	}

	static int boostpulse_open(struct dragon_power_module *dragon)
	{
	char buf[80];
	int len;

	pthread_mutex_lock(&dragon->boost_pulse_lock);

	if (dragon->boostpulse_fd < 0) {
	dragon->boostpulse_fd = open(BOOSTPULSE_PATH, O_WRONLY);

	if (dragon->boostpulse_fd < 0) {
	if (!dragon->boostpulse_warned) {
	strerror_r(errno, buf, sizeof(buf));
	ALOGE("Error opening %s: %s\n", BOOSTPULSE_PATH, buf);
	dragon->boostpulse_warned = 1;
	}
	}
	}

	pthread_mutex_unlock(&dragon->boost_pulse_lock);
	return dragon->boostpulse_fd;
	}

	static void dragon_power_hint(struct power_module *module, power_hint_t hint,
	void *data)
	{
	struct dragon_power_module *dragon =
	(struct dragon_power_module *) module;
	char buf[80];
	int len;

	switch (hint) {
	case POWER_HINT_INTERACTION:
	if (boostpulse_open(dragon) >= 0) {
	len = write(dragon->boostpulse_fd, "1", 1);

	if (len < 0) {
	strerror_r(errno, buf, sizeof(buf));
	ALOGE("Error writing to %s: %s\n", BOOSTPULSE_PATH, buf);
	}
	}
	if (dragon->gpu_qos_manager != NULL)
	dragon->gpu_qos_manager->requestTimedQos(ms2ns(GPU_BOOST_DURATION_MS));

	break;

	case POWER_HINT_VSYNC:
	break;

	case POWER_HINT_LOW_POWER:
	pthread_mutex_lock(&dragon->low_power_lock);
	if (data) {
	sysfs_write(CPU_MAX_FREQ_PATH, low_power_max_cpu_freq);
	sysfs_write(GPU_CAP_PATH, low_power_gpu_cap);
	} else {
	sysfs_write(CPU_MAX_FREQ_PATH, max_cpu_freq);
	sysfs_write(GPU_CAP_PATH, normal_gpu_cap);
	}
	low_power_mode = data;
	pthread_mutex_unlock(&dragon->low_power_lock);
	break;

	default:
	break;
	}
	}

	static int dragon_power_open(const hw_module_t module, const char name,
	hw_device_t **device)
	{
	ALOGD("%s: enter; name=%s", __FUNCTION__, name);
	int retval = 0; /* 0 is ok; -1 is error */

	if (strcmp(name, POWER_HARDWARE_MODULE_ID) == 0) {
	dragon_power_module dev = (dragon_power_module )calloc(1,
	sizeof(dragon_power_module));

	if (dev) {
	/* Common hw_device_t fields */
	dev->base.common.tag = HARDWARE_MODULE_TAG;
	dev->base.common.module_api_version = POWER_MODULE_API_VERSION_0_2;
	dev->base.common.hal_api_version = HARDWARE_HAL_API_VERSION;

	dev->base.init = power_init;
	dev->base.powerHint = dragon_power_hint;
	dev->base.setInteractive = power_set_interactive;
	dev->boost_pulse_lock = PTHREAD_MUTEX_INITIALIZER;
	dev->low_power_lock = PTHREAD_MUTEX_INITIALIZER;
	dev->boostpulse_fd = -1;
	dev->boostpulse_warned = 0;
	dev->gpu_qos_manager = NULL;

	device = (hw_device_t)dev;
	} else
	retval = -ENOMEM;
	} else {
	retval = -EINVAL;
	}

	ALOGD("%s: exit %d", __FUNCTION__, retval);
	return retval;
	}


	static struct hw_module_methods_t power_module_methods = {
	.open = dragon_power_open,
	};

	struct dragon_power_module HAL_MODULE_INFO_SYM = {
	base: {
	common: {
	tag: HARDWARE_MODULE_TAG,
	module_api_version: POWER_MODULE_API_VERSION_0_2,
	hal_api_version: HARDWARE_HAL_API_VERSION,
	id: POWER_HARDWARE_MODULE_ID,
	name: "Dragon Power HAL",
	author: "The Android Open Source Project",
	methods: &power_module_methods,
	dso: NULL,
	reserved: {0},
	},

	init: power_init,
	setInteractive: power_set_interactive,
	powerHint: dragon_power_hint,
	},

	boost_pulse_lock: PTHREAD_MUTEX_INITIALIZER,
	low_power_lock: PTHREAD_MUTEX_INITIALIZER,
	boostpulse_fd: -1,
	boostpulse_warned: 0,
	gpu_qos_manager: NULL,
	};