aidl/power-libperfmgr/InteractionHandler.cpp - LeafOS-Devices/android_hardware_mediatek - Gitiles

 /*
  * Copyright (C) 2018 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 ATRACE_TAG (ATRACE_TAG_POWER | ATRACE_TAG_HAL)
 #define LOG_TAG "android.hardware.power-service.mediatek-libperfmgr"

 #include <array>
 #include <memory>

 #include <fcntl.h>
 #include <poll.h>
 #include <sys/eventfd.h>
 #include <time.h>
 #include <unistd.h>

 #include <android-base/properties.h>
 #include <utils/Log.h>
 #include <utils/Trace.h>

 #include "InteractionHandler.h"

 #define MAX_LENGTH 64

 #define MSINSEC 1000L
 #define NSINMS 1000000L

 namespace aidl {
 namespace google {
 namespace hardware {
 namespace power {
 namespace impl {
 namespace pixel {

 namespace {

 static const bool kDisplayIdleSupport =
         ::android::base::GetBoolProperty("vendor.powerhal.disp.idle_support", true);
 static const std::array<const char *, 2> kDispIdlePath = {"/sys/class/drm/card0/device/idle_state",
                                                           "/sys/class/graphics/fb0/idle_state"};
 static const uint32_t kWaitMs =
         ::android::base::GetUintProperty("vendor.powerhal.disp.idle_wait", /*default*/ 100U);
 static const uint32_t kMinDurationMs =
         ::android::base::GetUintProperty("vendor.powerhal.interaction.min", /*default*/ 1400U);
 static const uint32_t kMaxDurationMs =
         ::android::base::GetUintProperty("vendor.powerhal.interaction.max", /*default*/ 5650U);
 static const uint32_t kDurationOffsetMs =
         ::android::base::GetUintProperty("vendor.powerhal.interaction.offset", /*default*/ 650U);

 static size_t CalcTimespecDiffMs(struct timespec start, struct timespec end) {
     size_t diff_in_ms = 0;
     diff_in_ms += (end.tv_sec - start.tv_sec) * MSINSEC;
     diff_in_ms += (end.tv_nsec - start.tv_nsec) / NSINMS;
     return diff_in_ms;
 }

 static int FbIdleOpen(void) {
     int fd;
     for (const auto &path : kDispIdlePath) {
         fd = open(path, O_RDONLY);
         if (fd >= 0)
             return fd;
     }
     ALOGE("Unable to open fb idle state path (%d)", errno);
     return -1;
 }

 }  // namespace

 InteractionHandler::InteractionHandler(std::shared_ptr<HintManager> const &hint_manager)
     : mState(INTERACTION_STATE_UNINITIALIZED),
       mDurationMs(0),
       mHintManager(hint_manager) {}

 InteractionHandler::~InteractionHandler() {
     Exit();
 }

 bool InteractionHandler::Init() {
     std::lock_guard<std::mutex> lk(mLock);

     if (mState != INTERACTION_STATE_UNINITIALIZED)
         return true;

     int fd = FbIdleOpen();
     if (fd < 0)
         return false;
     mIdleFd = fd;

     mEventFd = eventfd(0, EFD_NONBLOCK);
     if (mEventFd < 0) {
         ALOGE("Unable to create event fd (%d)", errno);
         close(mIdleFd);
         return false;
     }

     mState = INTERACTION_STATE_IDLE;
     mThread = std::unique_ptr<std::thread>(new std::thread(&InteractionHandler::Routine, this));

     return true;
 }

 void InteractionHandler::Exit() {
     std::unique_lock<std::mutex> lk(mLock);
     if (mState == INTERACTION_STATE_UNINITIALIZED)
         return;

     AbortWaitLocked();
     mState = INTERACTION_STATE_UNINITIALIZED;
     lk.unlock();

     mCond.notify_all();
     mThread->join();

     close(mEventFd);
     close(mIdleFd);
 }

 void InteractionHandler::PerfLock() {
     ALOGV("%s: acquiring perf lock", __func__);
     if (!mHintManager->DoHint("INTERACTION")) {
         ALOGE("%s: do hint INTERACTION failed", __func__);
     }
     ATRACE_INT("interaction_lock", 1);
 }

 void InteractionHandler::PerfRel() {
     ALOGV("%s: releasing perf lock", __func__);
     if (!mHintManager->EndHint("INTERACTION")) {
         ALOGE("%s: end hint INTERACTION failed", __func__);
     }
     ATRACE_INT("interaction_lock", 0);
 }

 void InteractionHandler::Acquire(int32_t duration) {
     ATRACE_CALL();

     std::lock_guard<std::mutex> lk(mLock);

     int inputDuration = duration + kDurationOffsetMs;
     int finalDuration;
     if (inputDuration > kMaxDurationMs)
         finalDuration = kMaxDurationMs;
     else if (inputDuration > kMinDurationMs)
         finalDuration = inputDuration;
     else
         finalDuration = kMinDurationMs;

     // Fallback to do boost directly
     // 1) override property is set OR
     // 2) InteractionHandler not initialized
     if (!kDisplayIdleSupport || mState == INTERACTION_STATE_UNINITIALIZED) {
         mHintManager->DoHint("INTERACTION", std::chrono::milliseconds(finalDuration));
         return;
     }

     struct timespec cur_timespec;
     clock_gettime(CLOCK_MONOTONIC, &cur_timespec);
     if (mState != INTERACTION_STATE_IDLE && finalDuration <= mDurationMs) {
         size_t elapsed_time = CalcTimespecDiffMs(mLastTimespec, cur_timespec);
         // don't hint if previous hint's duration covers this hint's duration
         if (elapsed_time <= (mDurationMs - finalDuration)) {
             ALOGV("%s: Previous duration (%d) cover this (%d) elapsed: %lld", __func__,
                   static_cast<int>(mDurationMs), static_cast<int>(finalDuration),
                   static_cast<long long>(elapsed_time));
             return;
         }
     }
     mLastTimespec = cur_timespec;
     mDurationMs = finalDuration;

     ALOGV("%s: input: %d final duration: %d", __func__, duration, finalDuration);

     if (mState == INTERACTION_STATE_WAITING)
         AbortWaitLocked();
     else if (mState == INTERACTION_STATE_IDLE)
         PerfLock();

     mState = INTERACTION_STATE_INTERACTION;
     mCond.notify_one();
 }

 void InteractionHandler::Release() {
     std::lock_guard<std::mutex> lk(mLock);
     if (mState == INTERACTION_STATE_WAITING) {
         ATRACE_CALL();
         PerfRel();
         mState = INTERACTION_STATE_IDLE;
     } else {
         // clear any wait aborts pending in event fd
         uint64_t val;
         ssize_t ret = read(mEventFd, &val, sizeof(val));

         ALOGW_IF(ret < 0, "%s: failed to clear eventfd (%zd, %d)", __func__, ret, errno);
     }
 }

 // should be called while locked
 void InteractionHandler::AbortWaitLocked() {
     uint64_t val = 1;
     ssize_t ret = write(mEventFd, &val, sizeof(val));
     if (ret != sizeof(val))
         ALOGW("Unable to write to event fd (%zd)", ret);
 }

 void InteractionHandler::WaitForIdle(int32_t wait_ms, int32_t timeout_ms) {
     char data[MAX_LENGTH];
     ssize_t ret;
     struct pollfd pfd[2];

     ATRACE_CALL();

     ALOGV("%s: wait:%d timeout:%d", __func__, wait_ms, timeout_ms);

     pfd[0].fd = mEventFd;
     pfd[0].events = POLLIN;
     pfd[1].fd = mIdleFd;
     pfd[1].events = POLLPRI | POLLERR;

     ret = poll(pfd, 1, wait_ms);
     if (ret > 0) {
         ALOGV("%s: wait aborted", __func__);
         return;
     } else if (ret < 0) {
         ALOGE("%s: error in poll while waiting", __func__);
         return;
     }

     ret = pread(mIdleFd, data, sizeof(data), 0);
     if (!ret) {
         ALOGE("%s: Unexpected EOF!", __func__);
         return;
     }

     if (!strncmp(data, "idle", 4)) {
         ALOGV("%s: already idle", __func__);
         return;
     }

     ret = poll(pfd, 2, timeout_ms);
     if (ret < 0)
         ALOGE("%s: Error on waiting for idle (%zd)", __func__, ret);
     else if (ret == 0)
         ALOGV("%s: timed out waiting for idle", __func__);
     else if (pfd[0].revents)
         ALOGV("%s: wait for idle aborted", __func__);
     else if (pfd[1].revents)
         ALOGV("%s: idle detected", __func__);
 }

 void InteractionHandler::Routine() {
     pthread_setname_np(pthread_self(), "DispIdle");
     std::unique_lock<std::mutex> lk(mLock, std::defer_lock);

     while (true) {
         lk.lock();
         mCond.wait(lk, [&] { return mState != INTERACTION_STATE_IDLE; });
         if (mState == INTERACTION_STATE_UNINITIALIZED)
             return;
         mState = INTERACTION_STATE_WAITING;
         lk.unlock();

         WaitForIdle(kWaitMs, mDurationMs);
         Release();
     }
 }

 }  // namespace pixel
 }  // namespace impl
 }  // namespace power
 }  // namespace hardware
 }  // namespace google
 }  // namespace aidl
	/*
	* Copyright (C) 2018 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 ATRACE_TAG (ATRACE_TAG_POWER \| ATRACE_TAG_HAL)
	#define LOG_TAG "android.hardware.power-service.mediatek-libperfmgr"

	#include <array>
	#include <memory>

	#include <fcntl.h>
	#include <poll.h>
	#include <sys/eventfd.h>
	#include <time.h>
	#include <unistd.h>

	#include <android-base/properties.h>
	#include <utils/Log.h>
	#include <utils/Trace.h>

	#include "InteractionHandler.h"

	#define MAX_LENGTH 64

	#define MSINSEC 1000L
	#define NSINMS 1000000L

	namespace aidl {
	namespace google {
	namespace hardware {
	namespace power {
	namespace impl {
	namespace pixel {

	namespace {

	static const bool kDisplayIdleSupport =
	::android::base::GetBoolProperty("vendor.powerhal.disp.idle_support", true);
	static const std::array<const char *, 2> kDispIdlePath = {"/sys/class/drm/card0/device/idle_state",
	"/sys/class/graphics/fb0/idle_state"};
	static const uint32_t kWaitMs =
	::android::base::GetUintProperty("vendor.powerhal.disp.idle_wait", /default/ 100U);
	static const uint32_t kMinDurationMs =
	::android::base::GetUintProperty("vendor.powerhal.interaction.min", /default/ 1400U);
	static const uint32_t kMaxDurationMs =
	::android::base::GetUintProperty("vendor.powerhal.interaction.max", /default/ 5650U);
	static const uint32_t kDurationOffsetMs =
	::android::base::GetUintProperty("vendor.powerhal.interaction.offset", /default/ 650U);

	static size_t CalcTimespecDiffMs(struct timespec start, struct timespec end) {
	size_t diff_in_ms = 0;
	diff_in_ms += (end.tv_sec - start.tv_sec) * MSINSEC;
	diff_in_ms += (end.tv_nsec - start.tv_nsec) / NSINMS;
	return diff_in_ms;
	}

	static int FbIdleOpen(void) {
	int fd;
	for (const auto &path : kDispIdlePath) {
	fd = open(path, O_RDONLY);
	if (fd >= 0)
	return fd;
	}
	ALOGE("Unable to open fb idle state path (%d)", errno);
	return -1;
	}

	} // namespace

	InteractionHandler::InteractionHandler(std::shared_ptr<HintManager> const &hint_manager)
	: mState(INTERACTION_STATE_UNINITIALIZED),
	mDurationMs(0),
	mHintManager(hint_manager) {}

	InteractionHandler::~InteractionHandler() {
	Exit();
	}

	bool InteractionHandler::Init() {
	std::lock_guard<std::mutex> lk(mLock);

	if (mState != INTERACTION_STATE_UNINITIALIZED)
	return true;

	int fd = FbIdleOpen();
	if (fd < 0)
	return false;
	mIdleFd = fd;

	mEventFd = eventfd(0, EFD_NONBLOCK);
	if (mEventFd < 0) {
	ALOGE("Unable to create event fd (%d)", errno);
	close(mIdleFd);
	return false;
	}

	mState = INTERACTION_STATE_IDLE;
	mThread = std::unique_ptr<std::thread>(new std::thread(&InteractionHandler::Routine, this));

	return true;
	}

	void InteractionHandler::Exit() {
	std::unique_lock<std::mutex> lk(mLock);
	if (mState == INTERACTION_STATE_UNINITIALIZED)
	return;

	AbortWaitLocked();
	mState = INTERACTION_STATE_UNINITIALIZED;
	lk.unlock();

	mCond.notify_all();
	mThread->join();

	close(mEventFd);
	close(mIdleFd);
	}

	void InteractionHandler::PerfLock() {
	ALOGV("%s: acquiring perf lock", __func__);
	if (!mHintManager->DoHint("INTERACTION")) {
	ALOGE("%s: do hint INTERACTION failed", __func__);
	}
	ATRACE_INT("interaction_lock", 1);
	}

	void InteractionHandler::PerfRel() {
	ALOGV("%s: releasing perf lock", __func__);
	if (!mHintManager->EndHint("INTERACTION")) {
	ALOGE("%s: end hint INTERACTION failed", __func__);
	}
	ATRACE_INT("interaction_lock", 0);
	}

	void InteractionHandler::Acquire(int32_t duration) {
	ATRACE_CALL();

	std::lock_guard<std::mutex> lk(mLock);

	int inputDuration = duration + kDurationOffsetMs;
	int finalDuration;
	if (inputDuration > kMaxDurationMs)
	finalDuration = kMaxDurationMs;
	else if (inputDuration > kMinDurationMs)
	finalDuration = inputDuration;
	else
	finalDuration = kMinDurationMs;

	// Fallback to do boost directly
	// 1) override property is set OR
	// 2) InteractionHandler not initialized
	if (!kDisplayIdleSupport \|\| mState == INTERACTION_STATE_UNINITIALIZED) {
	mHintManager->DoHint("INTERACTION", std::chrono::milliseconds(finalDuration));
	return;
	}

	struct timespec cur_timespec;
	clock_gettime(CLOCK_MONOTONIC, &cur_timespec);
	if (mState != INTERACTION_STATE_IDLE && finalDuration <= mDurationMs) {
	size_t elapsed_time = CalcTimespecDiffMs(mLastTimespec, cur_timespec);
	// don't hint if previous hint's duration covers this hint's duration
	if (elapsed_time <= (mDurationMs - finalDuration)) {
	ALOGV("%s: Previous duration (%d) cover this (%d) elapsed: %lld", __func__,
	static_cast<int>(mDurationMs), static_cast<int>(finalDuration),
	static_cast<long long>(elapsed_time));
	return;
	}
	}
	mLastTimespec = cur_timespec;
	mDurationMs = finalDuration;

	ALOGV("%s: input: %d final duration: %d", __func__, duration, finalDuration);

	if (mState == INTERACTION_STATE_WAITING)
	AbortWaitLocked();
	else if (mState == INTERACTION_STATE_IDLE)
	PerfLock();

	mState = INTERACTION_STATE_INTERACTION;
	mCond.notify_one();
	}

	void InteractionHandler::Release() {
	std::lock_guard<std::mutex> lk(mLock);
	if (mState == INTERACTION_STATE_WAITING) {
	ATRACE_CALL();
	PerfRel();
	mState = INTERACTION_STATE_IDLE;
	} else {
	// clear any wait aborts pending in event fd
	uint64_t val;
	ssize_t ret = read(mEventFd, &val, sizeof(val));

	ALOGW_IF(ret < 0, "%s: failed to clear eventfd (%zd, %d)", __func__, ret, errno);
	}
	}

	// should be called while locked
	void InteractionHandler::AbortWaitLocked() {
	uint64_t val = 1;
	ssize_t ret = write(mEventFd, &val, sizeof(val));
	if (ret != sizeof(val))
	ALOGW("Unable to write to event fd (%zd)", ret);
	}

	void InteractionHandler::WaitForIdle(int32_t wait_ms, int32_t timeout_ms) {
	char data[MAX_LENGTH];
	ssize_t ret;
	struct pollfd pfd[2];

	ATRACE_CALL();

	ALOGV("%s: wait:%d timeout:%d", __func__, wait_ms, timeout_ms);

	pfd[0].fd = mEventFd;
	pfd[0].events = POLLIN;
	pfd[1].fd = mIdleFd;
	pfd[1].events = POLLPRI \| POLLERR;

	ret = poll(pfd, 1, wait_ms);
	if (ret > 0) {
	ALOGV("%s: wait aborted", __func__);
	return;
	} else if (ret < 0) {
	ALOGE("%s: error in poll while waiting", __func__);
	return;
	}

	ret = pread(mIdleFd, data, sizeof(data), 0);
	if (!ret) {
	ALOGE("%s: Unexpected EOF!", __func__);
	return;
	}

	if (!strncmp(data, "idle", 4)) {
	ALOGV("%s: already idle", __func__);
	return;
	}

	ret = poll(pfd, 2, timeout_ms);
	if (ret < 0)
	ALOGE("%s: Error on waiting for idle (%zd)", __func__, ret);
	else if (ret == 0)
	ALOGV("%s: timed out waiting for idle", __func__);
	else if (pfd[0].revents)
	ALOGV("%s: wait for idle aborted", __func__);
	else if (pfd[1].revents)
	ALOGV("%s: idle detected", __func__);
	}

	void InteractionHandler::Routine() {
	pthread_setname_np(pthread_self(), "DispIdle");
	std::unique_lock<std::mutex> lk(mLock, std::defer_lock);

	while (true) {
	lk.lock();
	mCond.wait(lk, [&] { return mState != INTERACTION_STATE_IDLE; });
	if (mState == INTERACTION_STATE_UNINITIALIZED)
	return;
	mState = INTERACTION_STATE_WAITING;
	lk.unlock();

	WaitForIdle(kWaitMs, mDurationMs);
	Release();
	}
	}

	} // namespace pixel
	} // namespace impl
	} // namespace power
	} // namespace hardware
	} // namespace google
	} // namespace aidl