Merge "libsuspend: create new library to handle triggering suspend" into jb-dev

# Copyright 2012 The Android Open Source Project

LOCAL_PATH:= $(call my-dir)

libsuspend_src_files := \

	autosuspend.c \

	autosuspend_autosleep.c \

	autosuspend_earlysuspend.c \

	autosuspend_wakeup_count.c \

libsuspend_libraries := \

	liblog libcutils

include $(CLEAR_VARS)

LOCAL_SRC_FILES := $(libsuspend_src_files)

LOCAL_MODULE := libsuspend

LOCAL_MODULE_TAGS := optional

LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)/include

LOCAL_C_INCLUDES += $(LOCAL_PATH)/include

LOCAL_SHARED_LIBRARIES := $(libsuspend_libraries)

#LOCAL_CFLAGS += -DLOG_NDEBUG=0

include $(BUILD_SHARED_LIBRARY)

/*

 * 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.

 */

#include <stdbool.h>

#define LOG_TAG "libsuspend"

#include <cutils/log.h>

#include <suspend/autosuspend.h>

#include "autosuspend_ops.h"

static struct autosuspend_ops *autosuspend_ops;

static bool autosuspend_enabled;

static bool autosuspend_inited;

static int autosuspend_init(void)

{

    if (autosuspend_inited) {

        return 0;

    }

    autosuspend_inited = true;

    autosuspend_ops = autosuspend_earlysuspend_init();

    if (autosuspend_ops) {

        goto out;

    }

    autosuspend_ops = autosuspend_autosleep_init();

    if (autosuspend_ops) {

        goto out;

    }

    autosuspend_ops = autosuspend_wakeup_count_init();

    if (autosuspend_ops) {

        goto out;

    }

    if (!autosuspend_ops) {

        ALOGE("failed to initialize autosuspend\n");

        return -1;

    }

out:

    ALOGV("autosuspend initialized\n");

    return 0;

}

int autosuspend_enable(void)

{

    int ret;

    ret = autosuspend_init();

    if (ret) {

        return ret;

    }

    ALOGV("autosuspend_enable\n");

    if (autosuspend_enabled) {

        return 0;

    }

    ret = autosuspend_ops->enable();

    if (ret) {

        return ret;

    }

    autosuspend_enabled = true;

    return 0;

}

int autosuspend_disable(void)

{

    int ret;

    ret = autosuspend_init();

    if (ret) {

        return ret;

    }

    ALOGV("autosuspend_disable\n");

    if (!autosuspend_enabled) {

        return 0;

    }

    ret = autosuspend_ops->disable();

    if (ret) {

        return ret;

    }

    autosuspend_enabled = false;

    return 0;

}

/*

 * 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.

 */

#include <errno.h>

#include <fcntl.h>

#include <stddef.h>

#include <string.h>

#include <sys/stat.h>

#include <sys/types.h>

#include <unistd.h>

#define LOG_TAG "libsuspend"

#include <cutils/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 = 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 = 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)

{

    int ret;

    char buf[80];

    autosleep_fd = 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");

    return &autosuspend_autosleep_ops;

}

/*

 * 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.

 */

#include <errno.h>

#include <fcntl.h>

#include <stddef.h>

#include <string.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <unistd.h>

#define LOG_TAG "libsuspend"

#include <cutils/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 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;

    }

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

    }

    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,

};

struct autosuspend_ops *autosuspend_earlysuspend_init(void)

{

    char buf[80];

    int ret;

    ret = access(EARLYSUSPEND_WAIT_FOR_FB_SLEEP, F_OK);

    if (ret < 0) {

        return NULL;

    }

    ret = access(EARLYSUSPEND_WAIT_FOR_FB_WAKE, F_OK);

    if (ret < 0) {

        return NULL;

    }

    sPowerStatefd = open(EARLYSUSPEND_SYS_POWER_STATE, O_RDWR);

    if (sPowerStatefd < 0) {

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

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

        return NULL;

    }

    ALOGI("Selected early suspend\n");

    return &autosuspend_earlysuspend_ops;

}

/*

 * 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.

 */

#ifndef _LIBSUSPEND_AUTOSUSPEND_OPS_H_

#define _LIBSUSPEND_AUTOSUSPEND_OPS_H_

struct autosuspend_ops {

    int (*enable)(void);

    int (*disable)(void);

};

struct autosuspend_ops *autosuspend_autosleep_init(void);

struct autosuspend_ops *autosuspend_earlysuspend_init(void);

struct autosuspend_ops *autosuspend_wakeup_count_init(void);

#endif