Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 021d60be authored by Tim Murray's avatar Tim Murray
Browse files

libsuspend: remove autosleep and earlysuspend 

autosleep and earlysuspend are long-deprecated, so remove them to make
libsuspend slightly more comprehensible.

Test: builds and still suspends on marlin

bug 32621856

Change-Id: I66a904c3fce0111fb5e9d1ab9d205c97617ae210
parent cd629590

libsuspend/Android.bp

+0 −2
Original line number Diff line number Diff line
@@ -4,8 +4,6 @@ cc_library { 
    name: "libsuspend",

    srcs: [

        "autosuspend.c",

        "autosuspend_autosleep.c",

        "autosuspend_earlysuspend.c",

        "autosuspend_wakeup_count.c",

    ],

    export_include_dirs: ["include"],

libsuspend/autosuspend.c

+0 −13
Original line number Diff line number Diff line
@@ -34,19 +34,6 @@ static int autosuspend_init(void) 
        return 0;

    }



    autosuspend_ops = autosuspend_earlysuspend_init();

    if (autosuspend_ops) {

        goto out;

    }



/* Remove autosleep so userspace can manager suspend/resume and keep stats */

#if 0

    autosuspend_ops = autosuspend_autosleep_init();

    if (autosuspend_ops) {

        goto out;

    }

#endif



    autosuspend_ops = autosuspend_wakeup_count_init();

    if (autosuspend_ops) {

        goto out;

libsuspend/autosuspend_autosleep.c

deleted100644 → 0
+0 −102
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2012 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.

 */



#define LOG_TAG "libsuspend"



#include <errno.h>

#include <fcntl.h>

#include <stddef.h>

#include <string.h>

#include <sys/stat.h>

#include <sys/types.h>

#include <unistd.h>



#include <android/log.h>



#include "autosuspend_ops.h"



#define SYS_POWER_AUTOSLEEP "/sys/power/autosleep"



static int autosleep_fd;

static const char *sleep_state = "mem";

static const char *on_state = "off";



static int autosuspend_autosleep_enable(void)

{

    char buf[80];

    int ret;



    ALOGV("autosuspend_autosleep_enable\n");



    ret = TEMP_FAILURE_RETRY(write(autosleep_fd, sleep_state, strlen(sleep_state)));

    if (ret < 0) {

        strerror_r(errno, buf, sizeof(buf));

        ALOGE("Error writing to %s: %s\n", SYS_POWER_AUTOSLEEP, buf);

        goto err;

    }



    ALOGV("autosuspend_autosleep_enable done\n");



    return 0;



err:

    return ret;

}



static int autosuspend_autosleep_disable(void)

{

    char buf[80];

    int ret;



    ALOGV("autosuspend_autosleep_disable\n");



    ret = TEMP_FAILURE_RETRY(write(autosleep_fd, on_state, strlen(on_state)));

    if (ret < 0) {

        strerror_r(errno, buf, sizeof(buf));

        ALOGE("Error writing to %s: %s\n", SYS_POWER_AUTOSLEEP, buf);

        goto err;

    }



    ALOGV("autosuspend_autosleep_disable done\n");



    return 0;



err:

    return ret;

}



struct autosuspend_ops autosuspend_autosleep_ops = {

        .enable = autosuspend_autosleep_enable,

        .disable = autosuspend_autosleep_disable,

};



struct autosuspend_ops *autosuspend_autosleep_init(void)

{

    char buf[80];



    autosleep_fd = TEMP_FAILURE_RETRY(open(SYS_POWER_AUTOSLEEP, O_WRONLY));

    if (autosleep_fd < 0) {

        strerror_r(errno, buf, sizeof(buf));

        ALOGE("Error opening %s: %s\n", SYS_POWER_AUTOSLEEP, buf);

        return NULL;

    }



    ALOGI("Selected autosleep\n");



    autosuspend_autosleep_disable();



    return &autosuspend_autosleep_ops;

}

libsuspend/autosuspend_earlysuspend.c

deleted100644 → 0
+0 −219
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2012 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.

 */



#define LOG_TAG "libsuspend"



#include <errno.h>

#include <fcntl.h>

#include <pthread.h>

#include <stdbool.h>

#include <stddef.h>

#include <string.h>

#include <sys/stat.h>

#include <sys/types.h>

#include <unistd.h>



#include <android/log.h>



#include "autosuspend_ops.h"



#define EARLYSUSPEND_SYS_POWER_STATE "/sys/power/state"

#define EARLYSUSPEND_WAIT_FOR_FB_SLEEP "/sys/power/wait_for_fb_sleep"

#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;

static pthread_cond_t earlysuspend_cond = PTHREAD_COND_INITIALIZER;

static bool wait_for_earlysuspend;

static enum {

    EARLYSUSPEND_ON,

    EARLYSUSPEND_MEM,

} earlysuspend_state = EARLYSUSPEND_ON;



int wait_for_fb_wake(void)

{

    int err = 0;

    char buf;

    int fd = TEMP_FAILURE_RETRY(open(EARLYSUSPEND_WAIT_FOR_FB_WAKE, O_RDONLY, 0));

    // if the file doesn't exist, the error will be caught in read() below

    err = TEMP_FAILURE_RETRY(read(fd, &buf, 1));

    ALOGE_IF(err < 0,

            "*** ANDROID_WAIT_FOR_FB_WAKE failed (%s)", strerror(errno));

    close(fd);

    return err < 0 ? err : 0;

}



static int wait_for_fb_sleep(void)

{

    int err = 0;

    char buf;

    int fd = TEMP_FAILURE_RETRY(open(EARLYSUSPEND_WAIT_FOR_FB_SLEEP, O_RDONLY, 0));

    // if the file doesn't exist, the error will be caught in read() below

    err = TEMP_FAILURE_RETRY(read(fd, &buf, 1));

    ALOGE_IF(err < 0,

            "*** ANDROID_WAIT_FOR_FB_SLEEP failed (%s)", strerror(errno));

    close(fd);

    return err < 0 ? err : 0;

}



static void *earlysuspend_thread_func(void __unused *arg)

{

    while (1) {

        if (wait_for_fb_sleep()) {

            ALOGE("Failed reading wait_for_fb_sleep, exiting earlysuspend thread\n");

            return NULL;

        }

        pthread_mutex_lock(&earlysuspend_mutex);

        earlysuspend_state = EARLYSUSPEND_MEM;

        pthread_cond_signal(&earlysuspend_cond);

        pthread_mutex_unlock(&earlysuspend_mutex);



        if (wait_for_fb_wake()) {

            ALOGE("Failed reading wait_for_fb_wake, exiting earlysuspend thread\n");

            return NULL;

        }

        pthread_mutex_lock(&earlysuspend_mutex);

        earlysuspend_state = EARLYSUSPEND_ON;

        pthread_cond_signal(&earlysuspend_cond);

        pthread_mutex_unlock(&earlysuspend_mutex);

    }

}

static int autosuspend_earlysuspend_enable(void)

{

    char buf[80];

    int ret;



    ALOGV("autosuspend_earlysuspend_enable\n");



    ret = write(sPowerStatefd, pwr_state_mem, strlen(pwr_state_mem));

    if (ret < 0) {

        strerror_r(errno, buf, sizeof(buf));

        ALOGE("Error writing to %s: %s\n", EARLYSUSPEND_SYS_POWER_STATE, buf);

        goto err;

    }



    if (wait_for_earlysuspend) {

        pthread_mutex_lock(&earlysuspend_mutex);

        while (earlysuspend_state != EARLYSUSPEND_MEM) {

            pthread_cond_wait(&earlysuspend_cond, &earlysuspend_mutex);

        }

        pthread_mutex_unlock(&earlysuspend_mutex);

    }



    ALOGV("autosuspend_earlysuspend_enable done\n");



    return 0;



err:

    return ret;

}



static int autosuspend_earlysuspend_disable(void)

{

    char buf[80];

    int ret;



    ALOGV("autosuspend_earlysuspend_disable\n");



    ret = TEMP_FAILURE_RETRY(write(sPowerStatefd, pwr_state_on, strlen(pwr_state_on)));

    if (ret < 0) {

        strerror_r(errno, buf, sizeof(buf));

        ALOGE("Error writing to %s: %s\n", EARLYSUSPEND_SYS_POWER_STATE, buf);

        goto err;

    }



    if (wait_for_earlysuspend) {

        pthread_mutex_lock(&earlysuspend_mutex);

        while (earlysuspend_state != EARLYSUSPEND_ON) {

            pthread_cond_wait(&earlysuspend_cond, &earlysuspend_mutex);

        }

        pthread_mutex_unlock(&earlysuspend_mutex);

    }



    ALOGV("autosuspend_earlysuspend_disable done\n");



    return 0;



err:

    return ret;

}



struct autosuspend_ops autosuspend_earlysuspend_ops = {

        .enable = autosuspend_earlysuspend_enable,

        .disable = autosuspend_earlysuspend_disable,

};



void start_earlysuspend_thread(void)

{

    char buf[80];

    int ret;



    ret = access(EARLYSUSPEND_WAIT_FOR_FB_SLEEP, F_OK);

    if (ret < 0) {

        return;

    }



    ret = access(EARLYSUSPEND_WAIT_FOR_FB_WAKE, F_OK);

    if (ret < 0) {

        return;

    }



    wait_for_fb_wake();



    ALOGI("Starting early suspend unblocker thread\n");

    ret = pthread_create(&earlysuspend_thread, NULL, earlysuspend_thread_func, NULL);

    if (ret) {

        strerror_r(errno, buf, sizeof(buf));

        ALOGE("Error creating thread: %s\n", buf);

        return;

    }



    wait_for_earlysuspend = true;

}



struct autosuspend_ops *autosuspend_earlysuspend_init(void)

{

    char buf[80];

    int ret;



    sPowerStatefd = TEMP_FAILURE_RETRY(open(EARLYSUSPEND_SYS_POWER_STATE, O_RDWR));



    if (sPowerStatefd < 0) {

        strerror_r(errno, buf, sizeof(buf));

        ALOGW("Error opening %s: %s\n", EARLYSUSPEND_SYS_POWER_STATE, buf);

        return NULL;

    }



    ret = TEMP_FAILURE_RETRY(write(sPowerStatefd, "on", 2));

    if (ret < 0) {

        strerror_r(errno, buf, sizeof(buf));

        ALOGW("Error writing 'on' to %s: %s\n", EARLYSUSPEND_SYS_POWER_STATE, buf);

        goto err_write;

    }



    ALOGI("Selected early suspend\n");



    start_earlysuspend_thread();



    return &autosuspend_earlysuspend_ops;



err_write:

    close(sPowerStatefd);

    return NULL;

}