1 /*
2 * Copyright (c) 2014 Intel Corporation All Rights Reserved
3 * Copyright (C) 2012 The Android Open Source Project
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18 #include <sys/types.h>
19 #include <sys/stat.h>
20 #include <fcntl.h>
21 #include <stdlib.h>
22
23 //#define LOG_NDEBUG 0
24 #define LOG_TAG "IntelPowerHAL"
25 #include <utils/Log.h>
26
27 #include <hardware/hardware.h>
28 #include <hardware/power.h>
29
30 #define BOOST_PULSE_SYSFS "/sys/devices/system/cpu/cpufreq/interactive/boostpulse"
31 #define BOOST_FREQ_SYSFS "/sys/devices/system/cpu/cpufreq/interactive/hispeed_freq"
32 #define BOOST_DURATION_SYSFS "/sys/devices/system/cpu/cpufreq/interactive/boostpulse_duration"
33
34 struct intel_power_module {
35 struct power_module container;
36 uint32_t pulse_duration;
37 struct timespec last_boost_time; /* latest POWER_HINT_INTERACTION boost */
38 };
39
sysfs_write(char * path,char * s)40 static ssize_t sysfs_write(char *path, char *s)
41 {
42 char buf[80];
43 ssize_t len;
44 int fd = open(path, O_WRONLY);
45
46 if (fd < 0) {
47 strerror_r(errno, buf, sizeof(buf));
48 ALOGE("Error opening %s: %s\n", path, buf);
49 return -1;
50 }
51
52 if ((len = write(fd, s, strlen(s))) < 0) {
53 strerror_r(errno, buf, sizeof(buf));
54 ALOGE("Error writing to %s: %s\n", path, buf);
55 }
56
57 close(fd);
58 ALOGV("wrote '%s' to %s", s, path);
59
60 return len;
61 }
62
sysfs_read(char * path,char * s,int num_bytes)63 static ssize_t sysfs_read(char *path, char *s, int num_bytes)
64 {
65 char buf[80];
66 ssize_t count;
67 int fd = open(path, O_RDONLY);
68
69 if (fd < 0) {
70 strerror_r(errno, buf, sizeof(buf));
71 ALOGE("Error reading from %s: %s\n", path, buf);
72 return -1;
73 }
74
75 if ((count = read(fd, s, (num_bytes - 1))) < 0) {
76 strerror_r(errno, buf, sizeof(buf));
77 ALOGE("Error reading from %s: %s\n", path, buf);
78 } else {
79 if ((count >= 1) && (s[count-1] == '\n')) {
80 s[count-1] = '\0';
81 } else {
82 s[count] = '\0';
83 }
84 }
85
86 close(fd);
87 ALOGV("read '%s' from %s", s, path);
88
89 return count;
90 }
91
fugu_power_init(struct power_module * module)92 static void fugu_power_init(struct power_module *module)
93 {
94 struct intel_power_module *mod = (struct intel_power_module *) module;
95 char boost_freq[32];
96 char boostpulse_duration[32];
97
98 /* Keep default boost_freq for fugu => max freq */
99
100 if (sysfs_read(BOOST_FREQ_SYSFS, boost_freq, 32) < 0) {
101 strcpy(boost_freq, "?");
102 }
103 if (sysfs_read(BOOST_DURATION_SYSFS, boostpulse_duration, 32) < 0) {
104 /* above should not fail but just in case it does use an arbitrary 20ms value */
105 snprintf(boostpulse_duration, 32, "%d", 20000);
106 }
107 mod->pulse_duration = atoi(boostpulse_duration);
108 /* initialize last_boost_time */
109 clock_gettime(CLOCK_MONOTONIC, &mod->last_boost_time);
110
111 ALOGI("init done: will boost CPU to %skHz for %dus on input events",
112 boost_freq, mod->pulse_duration);
113 }
114
fugu_power_set_interactive(struct power_module * module,int on)115 static void fugu_power_set_interactive(struct power_module *module, int on)
116 {
117 struct dirent **device_list = NULL;
118
119 ALOGI("setInteractive: on=%d", on);
120 (void) module; /* unused */
121 (void) on; /* unused */
122 }
123
timespec_sub(struct timespec * res,struct timespec * a,struct timespec * b)124 static inline void timespec_sub(struct timespec *res, struct timespec *a, struct timespec *b)
125 {
126 res->tv_sec = a->tv_sec - b->tv_sec;
127 if (a->tv_sec >= b->tv_sec) {
128 res->tv_nsec = a->tv_nsec - b->tv_nsec;
129 } else {
130 res->tv_nsec = 1000000000 - b->tv_nsec + a->tv_nsec;
131 res->tv_sec--;
132 }
133 }
134
timespec_to_us(struct timespec * t)135 static inline uint64_t timespec_to_us(struct timespec *t)
136 {
137 return t->tv_sec * 1000000 + t->tv_nsec / 1000;
138 }
139
fugu_power_hint(struct power_module * module,power_hint_t hint,void * data)140 static void fugu_power_hint(struct power_module *module, power_hint_t hint, void *data)
141 {
142 struct intel_power_module *mod = (struct intel_power_module *) module;
143 char sysfs_val[80];
144 struct timespec curr_time;
145 struct timespec diff_time;
146 uint64_t diff;
147
148 (void) data;
149
150 switch (hint) {
151 case POWER_HINT_INTERACTION:
152 clock_gettime(CLOCK_MONOTONIC, &curr_time);
153 timespec_sub(&diff_time, &curr_time, &mod->last_boost_time);
154 diff = timespec_to_us(&diff_time);
155
156 ALOGV("POWER_HINT_INTERACTION: diff=%llu", diff);
157
158 if (diff > mod->pulse_duration) {
159 sysfs_write(BOOST_PULSE_SYSFS, "1");
160 mod->last_boost_time = curr_time;
161 }
162 break;
163 case POWER_HINT_VSYNC:
164 break;
165 default:
166 break;
167 }
168 }
169
170 static struct hw_module_methods_t power_module_methods = {
171 .open = NULL,
172 };
173
174 struct intel_power_module HAL_MODULE_INFO_SYM = {
175 container:{
176 common: {
177 tag: HARDWARE_MODULE_TAG,
178 module_api_version: POWER_MODULE_API_VERSION_0_2,
179 hal_api_version: HARDWARE_HAL_API_VERSION,
180 id: POWER_HARDWARE_MODULE_ID,
181 name: "Fugu Power HAL",
182 author: "Intel",
183 methods: &power_module_methods,
184 },
185 init: fugu_power_init,
186 setInteractive: fugu_power_set_interactive,
187 powerHint: fugu_power_hint,
188 },
189 };
190