提交: 9067003e1c7ae017e32fb6845295c47064a9a7fe - system-coremmmm (git)

system/corennnnn

Commit MetaInfo

• 修订版: 9067003e1c7ae017e32fb6845295c47064a9a7fe (tree)
• 时间: 2016-12-09 16:22:09
• 作者: Jaap Jan Meijer <jjmeijer88@gmai...>
• Commiter: Chih-Wei Huang

Log Message

libsuspend: make sleep state configurable and add a fallback

This patch allows the user to set the sleep state target from
Android properties for both wakeup_count and earlysuspend methods.
It also includes a fallback state if the default state is not
available and the user didn't set the sleep.state property.

Signed-off-by: Jaap Jan Meijer <[e-mail]>

更改概述

• modified: libsuspend/autosuspend.c
• modified: libsuspend/autosuspend_earlysuspend.c
• modified: libsuspend/autosuspend_ops.h
• modified: libsuspend/autosuspend_wakeup_count.c

差异

--- a/libsuspend/autosuspend.c
+++ b/libsuspend/autosuspend.c
@@ -14,15 +14,22 @@
  * limitations under the License.
  */
 
+#include <errno.h>
+#include <fcntl.h>
 #include <stdbool.h>
+#include <string.h>
 
 #define LOG_TAG "libsuspend"
 #include <cutils/log.h>
+#include <cutils/properties.h>
 
 #include <suspend/autosuspend.h>
 
 #include "autosuspend_ops.h"
 
+static const char *default_sleep_state = "mem";
+static const char *fallback_sleep_state = "freeze";
+
 static struct autosuspend_ops *autosuspend_ops;
 static bool autosuspend_enabled;
 static bool autosuspend_inited;
@@ -110,3 +117,34 @@ int autosuspend_disable(void)
     autosuspend_enabled = false;
     return 0;
 }
+
+static bool sleep_state_available(const char *state)
+{
+    char buf[64];
+    int fd = TEMP_FAILURE_RETRY(open(SYS_POWER_STATE, O_RDONLY));
+    if (fd < 0) {
+        ALOGE("Error reading power state: %s", SYS_POWER_STATE);
+        return false;
+    }
+    TEMP_FAILURE_RETRY(read(fd, buf, 64));
+    close(fd);
+    return !!strstr(buf, state);
+}
+
+const char *get_sleep_state()
+{
+    static char sleep_state[PROPERTY_VALUE_MAX] = "";
+
+    if (!sleep_state[0]) {
+        if (property_get("sleep.state", sleep_state, NULL) > 0) {
+            ALOGD("autosuspend using sleep.state property (%s)", sleep_state);
+        } else if (sleep_state_available(default_sleep_state)) {
+            ALOGD("autosuspend using default sleep_state (%s)", default_sleep_state);
+            strncpy(sleep_state, default_sleep_state, PROPERTY_VALUE_MAX);
+        } else {
+            ALOGW("autosuspend \"%s\" unavailable, using fallback sleep.state (%s)", default_sleep_state, fallback_sleep_state);
+            strncpy(sleep_state, fallback_sleep_state, PROPERTY_VALUE_MAX);
+        }
+    }
+    return sleep_state;
+}

--- a/libsuspend/autosuspend_earlysuspend.c
+++ b/libsuspend/autosuspend_earlysuspend.c
@@ -33,7 +33,6 @@
 #define EARLYSUSPEND_WAIT_FOR_FB_WAKE "/sys/power/wait_for_fb_wake"
 
 static int sPowerStatefd;
-static const char *pwr_state_mem = "mem";
 static const char *pwr_state_on = "on";
 static pthread_t earlysuspend_thread;
 static pthread_mutex_t earlysuspend_mutex = PTHREAD_MUTEX_INITIALIZER;
@@ -116,12 +115,13 @@ static void *earlysuspend_thread_func(void __unused *arg)
 static int autosuspend_earlysuspend_enable(void)
 {
     int ret;
+    const char *sleep_state = get_sleep_state();
 
     ALOGI("autosuspend_earlysuspend_enable");
 
-    ret = TEMP_FAILURE_RETRY(write(sPowerStatefd, pwr_state_mem, strlen(pwr_state_mem)));
+    ret = TEMP_FAILURE_RETRY(write(sPowerStatefd, sleep_state, strlen(sleep_state)));
     if (ret < 0) {
-        log_err("writing %s to %s", pwr_state_mem, SYS_POWER_STATE);
+        log_err("writing %s to %s", sleep_state, SYS_POWER_STATE);
         return ret;
     }
 

--- a/libsuspend/autosuspend_ops.h
+++ b/libsuspend/autosuspend_ops.h
@@ -28,4 +28,6 @@ struct autosuspend_ops *autosuspend_autosleep_init(void);
 struct autosuspend_ops *autosuspend_earlysuspend_init(void);
 struct autosuspend_ops *autosuspend_wakeup_count_init(void);
 
+const char *get_sleep_state();
+
 #endif

--- a/libsuspend/autosuspend_wakeup_count.c
+++ b/libsuspend/autosuspend_wakeup_count.c
@@ -37,7 +37,6 @@ static int state_fd;
 static int wakeup_count_fd;
 static pthread_t suspend_thread;
 static sem_t suspend_lockout;
-static const char *sleep_state = "mem";
 static void (*wakeup_func)(bool success) = NULL;
 
 static void *suspend_thread_func(void *arg __attribute__((unused)))
@@ -80,6 +79,7 @@ static void *suspend_thread_func(void *arg __attribute__((unused)))
             strerror_r(errno, buf, sizeof(buf));
             ALOGE("Error writing to %s: %s\n", SYS_POWER_WAKEUP_COUNT, buf);
         } else {
+            const char *sleep_state = get_sleep_state();
             ALOGV("%s: write %s to %s\n", __func__, sleep_state, SYS_POWER_STATE);
             ret = TEMP_FAILURE_RETRY(write(state_fd, sleep_state, strlen(sleep_state)));
             if (ret < 0) {