camera/hal/intel/ipu3/psl/ipu3/ipc/client/Intel3AClient.cpp - mirrors/cros/chromiumos/platform2 - Git at Google

 /*
  * Copyright (C) 2018-2020 Intel Corporation.
  *
  * 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 "Intel3AClient"
 #include <sys/types.h>
 #include <sys/stat.h>

 #include <fcntl.h>
 #include <sys/mman.h>

 #include "Camera3HAL.h"
 #include "Intel3AClient.h"
 #include "Utils.h"

 namespace cros {
 namespace intel {
 Intel3AClient::Intel3AClient():
     mErrCb(nullptr),
     mIPCStatus(true),
     mInitialized(false)
 {
     LOG1("@%s", __FUNCTION__);

     mCallback = base::Bind(&Intel3AClient::callbackHandler, base::Unretained(this));
     Intel3AClient::return_callback = returnCallback;

     mNotifyCallback = base::Bind(&Intel3AClient::notifyHandler, base::Unretained(this));
     Intel3AClient::notify = notifyCallback;

     mBridge = cros::CameraAlgorithmBridge::CreateInstance(
         cros::CameraAlgorithmBackend::kVendorCpu, g_mojo_manager_token);
     CheckError(!mBridge, VOID_VALUE, "@%s, mBridge is nullptr", __FUNCTION__);
     CheckError((mBridge->Initialize(this) != 0), VOID_VALUE, "@%s, call mBridge->Initialize fail", __FUNCTION__);

     for (int i = 0; i < IPC_GROUP_NUM; i++) {
         mRunner[i] = std::unique_ptr<Runner>(new Runner(static_cast<IPC_GROUP>(i), mBridge.get()));
     }

     mInitialized = true;
 }

 Intel3AClient::~Intel3AClient()
 {
     LOG1("@%s", __FUNCTION__);
 }

 bool Intel3AClient::isInitialized()
 {
     LOG1("@%s, mInitialized:%d", __FUNCTION__, mInitialized);

     return mInitialized;
 }

 bool Intel3AClient::isIPCFine()
 {
     std::lock_guard<std::mutex> l(mIPCStatusMutex);
     LOG1("@%s, mIPCStatus:%d", __FUNCTION__, mIPCStatus);

     return mIPCStatus;
 }

 void Intel3AClient::registerErrorCallback(IErrorCallback* errCb)
 {
     LOG1("@%s, errCb:%p", __FUNCTION__, errCb);

     std::lock_guard<std::mutex> l(mIPCStatusMutex);
     mErrCb = errCb;

     if (!mIPCStatus && mErrCb) {
         mErrCb->deviceError();
     }
 }

 int Intel3AClient::allocateShmMem(std::string& name, int size, int* fd, void** addr)
 {
     LOG1("@%s, name:%s, size:%d", __FUNCTION__, name.c_str(), size);

     *fd = -1;
     *addr = nullptr;
     int shmFd = -1;
     void* shmAddr = nullptr;

     shmFd = shm_open(name.c_str(), O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);
     CheckError((shmFd == -1), UNKNOWN_ERROR, "@%s, call shm_open fail", __FUNCTION__);

     int ret = fcntl(shmFd, F_GETFD);
     CheckError((ret == -1), UNKNOWN_ERROR, "@%s, call fcntl fail", __FUNCTION__);

     ret = ftruncate(shmFd, size);
     CheckError((ret == -1), UNKNOWN_ERROR, "@%s, call fcntl fail", __FUNCTION__);

     struct stat sb;
     ret = fstat(shmFd, &sb);
     CheckError((ret == -1), UNKNOWN_ERROR, "@%s, call fstat fail", __FUNCTION__);
     CheckError((sb.st_size != size), UNKNOWN_ERROR, "@%s, sb.st_size:%jd", __FUNCTION__, (intmax_t)sb.st_size);

     shmAddr = mmap(0, sb.st_size, PROT_WRITE, MAP_SHARED, shmFd, 0);
     CheckError((!shmAddr), UNKNOWN_ERROR, "@%s, call mmap fail", __FUNCTION__);

     *fd = shmFd;
     *addr = shmAddr;

     return OK;
 }

 void Intel3AClient::releaseShmMem(std::string& name, int size, int fd, void* addr)
 {
     LOG1("@%s, name:%s, size:%d, fd:%d, addr:%p", __FUNCTION__, name.c_str(), size, fd, addr);

     munmap(addr, size);
     close(fd);
     shm_unlink(name.c_str());
 }

 int Intel3AClient::requestSync(IPC_CMD cmd, int32_t bufferHandle)
 {
     LOG1("@%s, cmd:%d:%s, bufferHandle:%d, mInitialized:%d",
          __FUNCTION__, cmd, Intel3AIpcCmdToString(cmd), bufferHandle, mInitialized);
     CheckError(!mInitialized, UNKNOWN_ERROR, "@%s, mInitialized is false", __FUNCTION__);
     CheckError(!isIPCFine(), UNKNOWN_ERROR, "@%s, IPC error happens", __FUNCTION__);

     IPC_GROUP group = Intel3AIpcCmdToGroup(cmd);

     return mRunner[group]->requestSync(cmd, bufferHandle);
 }

 int Intel3AClient::requestSync(IPC_CMD cmd)
 {
     return requestSync(cmd, -1);
 }

 int32_t Intel3AClient::registerBuffer(int bufferFd)
 {
     LOG1("@%s, bufferFd:%d, mInitialized:%d", __FUNCTION__, bufferFd, mInitialized);
     CheckError(!mInitialized, -1, "@%s, mInitialized is false", __FUNCTION__);
     CheckError(!isIPCFine(), -1, "@%s, IPC error happens", __FUNCTION__);

     return mBridge->RegisterBuffer(bufferFd);
 }

 void Intel3AClient::deregisterBuffer(int32_t bufferHandle)
 {
     LOG1("@%s, bufferHandle:%d, mInitialized:%d", __FUNCTION__, bufferHandle, mInitialized);
     CheckError(!mInitialized, VOID_VALUE, "@%s, mInitialized is false", __FUNCTION__);
     CheckError(!isIPCFine(), VOID_VALUE, "@%s, IPC error happens", __FUNCTION__);

     std::vector<int32_t> handles({bufferHandle});
     mBridge->DeregisterBuffers(handles);
 }

 void Intel3AClient::callbackHandler(uint32_t req_id, uint32_t status, int32_t buffer_handle)
 {
     LOG2("@%s, req_id:%d, status:%d, buffer_handle:%d",
          __FUNCTION__, req_id, status, buffer_handle);

     IPC_GROUP group = Intel3AIpcCmdToGroup(static_cast<IPC_CMD>(req_id));
     mRunner[group]->callbackHandler(status, buffer_handle);
 }

 void Intel3AClient::notifyHandler(uint32_t msg)
 {
     LOG2("@%s, msg:%d", __FUNCTION__, msg);

     if (msg != CAMERA_ALGORITHM_MSG_IPC_ERROR) {
         LOGE("@%s, receive msg:%d, not CAMERA_ALGORITHM_MSG_IPC_ERROR", __FUNCTION__, msg);
         return;
     }

     std::lock_guard<std::mutex> l(mIPCStatusMutex);
     mIPCStatus = false;
     if (mErrCb) {
         mErrCb->deviceError();
     } else {
         LOGE("@%s, mErrCb is nullptr, no device error is sent out", __FUNCTION__);
     }
     LOGE("@%s, receive CAMERA_ALGORITHM_MSG_IPC_ERROR", __FUNCTION__);
 }

 void Intel3AClient::returnCallback(const camera_algorithm_callback_ops_t* callback_ops,
                                    uint32_t req_id,
                                    uint32_t status,
                                    int32_t buffer_handle)
 {
     LOG2("@%s", __FUNCTION__);
     CheckError(!callback_ops, VOID_VALUE, "@%s, callback_ops is nullptr", __FUNCTION__);

     auto s = const_cast<Intel3AClient*>(static_cast<const Intel3AClient*>(callback_ops));
     s->mCallback.Run(req_id, status, buffer_handle);
 }

 void Intel3AClient::notifyCallback(const struct camera_algorithm_callback_ops* callback_ops,
                                  camera_algorithm_error_msg_code_t msg)
 {
     LOG2("@%s", __FUNCTION__);
     CheckError(!callback_ops, VOID_VALUE, "@%s, callback_ops is nullptr", __FUNCTION__);

     auto s = const_cast<Intel3AClient*>(static_cast<const Intel3AClient*>(callback_ops));
     s->mNotifyCallback.Run((uint32_t)msg);
 }

 Intel3AClient::Runner::Runner(IPC_GROUP group, cros::CameraAlgorithmBridge* bridge):
     mGroup(group),
     mBridge(bridge),
     mIsCallbacked(false),
     mCbResult(true),
     mInitialized(false)
 {
     LOG1("@%s, group:%d", __FUNCTION__, mGroup);

     pthread_condattr_t attr;
     int ret = pthread_condattr_init(&attr);
     if (ret != 0) {
         LOGE("@%s, call pthread_condattr_init fails, ret:%d", __FUNCTION__, ret);
         pthread_condattr_destroy(&attr);
         return;
     }

     ret = pthread_condattr_setclock(&attr, CLOCK_MONOTONIC);
     if (ret != 0) {
         LOGE("@%s, call pthread_condattr_setclock fails, ret:%d", __FUNCTION__, ret);
         pthread_condattr_destroy(&attr);
         return;
     }

     ret = pthread_cond_init(&mCbCond, &attr);
     if (ret != 0) {
         LOGE("@%s, call pthread_cond_init fails, ret:%d", __FUNCTION__, ret);
         pthread_condattr_destroy(&attr);
         return;
     }

     pthread_condattr_destroy(&attr);

     ret = pthread_mutex_init(&mCbLock, nullptr);
     CheckError(ret != 0, VOID_VALUE, "@%s, call pthread_mutex_init fails, ret:%d", __FUNCTION__, ret);

     mInitialized = true;
 }

 Intel3AClient::Runner::~Runner()
 {
     LOG1("@%s, group:%d", __FUNCTION__, mGroup);

     int ret = pthread_cond_destroy(&mCbCond);
     if (ret != 0) {
         LOGE("@%s, call pthread_cond_destroy fails, ret:%d", __FUNCTION__, ret);
     }

     ret = pthread_mutex_destroy(&mCbLock);
     if (ret != 0) {
         LOGE("@%s, call pthread_mutex_destroy fails, ret:%d", __FUNCTION__, ret);
     }
 }

 int Intel3AClient::Runner::requestSync(IPC_CMD cmd, int32_t bufferHandle)
 {
     LOG1("@%s, cmd:%d:%s, group:%d, bufferHandle:%d, mInitialized:%d",
           __FUNCTION__, cmd, Intel3AIpcCmdToString(cmd), mGroup, bufferHandle, mInitialized);
     CheckError(!mInitialized, UNKNOWN_ERROR, "@%s, mInitialized is false", __FUNCTION__);

     std::lock_guard<std::mutex> lck(mMutex);

     std::vector<uint8_t> reqHeader(IPC_REQUEST_HEADER_USED_NUM);
     reqHeader[0] = IPC_MATCHING_KEY;

     // cmd is for request id, no duplicate command will be issued at any given time.
     mBridge->Request(cmd, reqHeader, bufferHandle);
     int ret = waitCallback();
     CheckError((ret != OK), UNKNOWN_ERROR, "@%s, call waitCallback fail", __FUNCTION__);

     LOG2("@%s, cmd:%d:%s, group:%d, mCbResult:%d, done!",
           __FUNCTION__, cmd, Intel3AIpcCmdToString(cmd), mGroup, mCbResult);

     // check callback result
     CheckError((mCbResult != true), UNKNOWN_ERROR, "@%s, callback fail", __FUNCTION__);

     return OK;
 }

 void Intel3AClient::Runner::callbackHandler(uint32_t status, int32_t buffer_handle)
 {
     LOG2("@%s, group:%d, status:%d, buffer_handle:%d", __FUNCTION__, mGroup, status, buffer_handle);
     if (status != 0) {
         LOGE("@%s, group:%d, status:%d, buffer_handle:%d", __FUNCTION__, mGroup, status, buffer_handle);
     }
     mCbResult = status != 0 ? false : true;

     pthread_mutex_lock(&mCbLock);
     mIsCallbacked = true;
     int ret = pthread_cond_signal(&mCbCond);
     pthread_mutex_unlock(&mCbLock);

     CheckError(ret != 0, VOID_VALUE, "@%s, group:%d, call pthread_cond_signal fails, ret:%d", __FUNCTION__, mGroup, ret);
 }

 int Intel3AClient::Runner::waitCallback()
 {
     LOG2("@%s, group:%d", __FUNCTION__, mGroup);
     nsecs_t startTime = systemTime();

     pthread_mutex_lock(&mCbLock);
     if (!mIsCallbacked) {
         int ret = 0;
         struct timespec ts = {0, 0};
         clock_gettime(CLOCK_MONOTONIC, &ts);
         ts.tv_sec += 5; // 5s timeout

         while (!mIsCallbacked && !ret) {
             ret = pthread_cond_timedwait(&mCbCond, &mCbLock, &ts);
         }
         if (ret != 0) {
             LOGE("@%s, group:%d, call pthread_cond_timedwait fail, ret:%d, it takes %" PRId64 "ms",
                   __FUNCTION__, mGroup, ret, (systemTime() - startTime) / 1000000);
             pthread_mutex_unlock(&mCbLock);
             return UNKNOWN_ERROR;
         }
     }
     mIsCallbacked = false;
     pthread_mutex_unlock(&mCbLock);

     LOG2("@%s: group:%d, it takes %" PRId64 "ms", __FUNCTION__, mGroup, (systemTime() - startTime) / 1000000);

     return OK;
 }

 } /* namespace intel */
 } /* namespace cros */
	/*
	* Copyright (C) 2018-2020 Intel Corporation.
	*
	* 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 "Intel3AClient"
	#include <sys/types.h>
	#include <sys/stat.h>

	#include <fcntl.h>
	#include <sys/mman.h>

	#include "Camera3HAL.h"
	#include "Intel3AClient.h"
	#include "Utils.h"

	namespace cros {
	namespace intel {
	Intel3AClient::Intel3AClient():
	mErrCb(nullptr),
	mIPCStatus(true),
	mInitialized(false)
	{
	LOG1("@%s", __FUNCTION__);

	mCallback = base::Bind(&Intel3AClient::callbackHandler, base::Unretained(this));
	Intel3AClient::return_callback = returnCallback;

	mNotifyCallback = base::Bind(&Intel3AClient::notifyHandler, base::Unretained(this));
	Intel3AClient::notify = notifyCallback;

	mBridge = cros::CameraAlgorithmBridge::CreateInstance(
	cros::CameraAlgorithmBackend::kVendorCpu, g_mojo_manager_token);
	CheckError(!mBridge, VOID_VALUE, "@%s, mBridge is nullptr", __FUNCTION__);
	CheckError((mBridge->Initialize(this) != 0), VOID_VALUE, "@%s, call mBridge->Initialize fail", __FUNCTION__);

	for (int i = 0; i < IPC_GROUP_NUM; i++) {
	mRunner[i] = std::unique_ptr<Runner>(new Runner(static_cast<IPC_GROUP>(i), mBridge.get()));
	}

	mInitialized = true;
	}

	Intel3AClient::~Intel3AClient()
	{
	LOG1("@%s", __FUNCTION__);
	}

	bool Intel3AClient::isInitialized()
	{
	LOG1("@%s, mInitialized:%d", __FUNCTION__, mInitialized);

	return mInitialized;
	}

	bool Intel3AClient::isIPCFine()
	{
	std::lock_guard<std::mutex> l(mIPCStatusMutex);
	LOG1("@%s, mIPCStatus:%d", __FUNCTION__, mIPCStatus);

	return mIPCStatus;
	}

	void Intel3AClient::registerErrorCallback(IErrorCallback* errCb)
	{
	LOG1("@%s, errCb:%p", __FUNCTION__, errCb);

	std::lock_guard<std::mutex> l(mIPCStatusMutex);
	mErrCb = errCb;

	if (!mIPCStatus && mErrCb) {
	mErrCb->deviceError();
	}
	}

	int Intel3AClient::allocateShmMem(std::string& name, int size, int* fd, void** addr)
	{
	LOG1("@%s, name:%s, size:%d", __FUNCTION__, name.c_str(), size);

	*fd = -1;
	*addr = nullptr;
	int shmFd = -1;
	void* shmAddr = nullptr;

	shmFd = shm_open(name.c_str(), O_CREAT \| O_RDWR, S_IRUSR \| S_IWUSR);
	CheckError((shmFd == -1), UNKNOWN_ERROR, "@%s, call shm_open fail", __FUNCTION__);

	int ret = fcntl(shmFd, F_GETFD);
	CheckError((ret == -1), UNKNOWN_ERROR, "@%s, call fcntl fail", __FUNCTION__);

	ret = ftruncate(shmFd, size);
	CheckError((ret == -1), UNKNOWN_ERROR, "@%s, call fcntl fail", __FUNCTION__);

	struct stat sb;
	ret = fstat(shmFd, &sb);
	CheckError((ret == -1), UNKNOWN_ERROR, "@%s, call fstat fail", __FUNCTION__);
	CheckError((sb.st_size != size), UNKNOWN_ERROR, "@%s, sb.st_size:%jd", __FUNCTION__, (intmax_t)sb.st_size);

	shmAddr = mmap(0, sb.st_size, PROT_WRITE, MAP_SHARED, shmFd, 0);
	CheckError((!shmAddr), UNKNOWN_ERROR, "@%s, call mmap fail", __FUNCTION__);

	*fd = shmFd;
	*addr = shmAddr;

	return OK;
	}

	void Intel3AClient::releaseShmMem(std::string& name, int size, int fd, void* addr)
	{
	LOG1("@%s, name:%s, size:%d, fd:%d, addr:%p", __FUNCTION__, name.c_str(), size, fd, addr);

	munmap(addr, size);
	close(fd);
	shm_unlink(name.c_str());
	}

	int Intel3AClient::requestSync(IPC_CMD cmd, int32_t bufferHandle)
	{
	LOG1("@%s, cmd:%d:%s, bufferHandle:%d, mInitialized:%d",
	__FUNCTION__, cmd, Intel3AIpcCmdToString(cmd), bufferHandle, mInitialized);
	CheckError(!mInitialized, UNKNOWN_ERROR, "@%s, mInitialized is false", __FUNCTION__);
	CheckError(!isIPCFine(), UNKNOWN_ERROR, "@%s, IPC error happens", __FUNCTION__);

	IPC_GROUP group = Intel3AIpcCmdToGroup(cmd);

	return mRunner[group]->requestSync(cmd, bufferHandle);
	}

	int Intel3AClient::requestSync(IPC_CMD cmd)
	{
	return requestSync(cmd, -1);
	}

	int32_t Intel3AClient::registerBuffer(int bufferFd)
	{
	LOG1("@%s, bufferFd:%d, mInitialized:%d", __FUNCTION__, bufferFd, mInitialized);
	CheckError(!mInitialized, -1, "@%s, mInitialized is false", __FUNCTION__);
	CheckError(!isIPCFine(), -1, "@%s, IPC error happens", __FUNCTION__);

	return mBridge->RegisterBuffer(bufferFd);
	}

	void Intel3AClient::deregisterBuffer(int32_t bufferHandle)
	{
	LOG1("@%s, bufferHandle:%d, mInitialized:%d", __FUNCTION__, bufferHandle, mInitialized);
	CheckError(!mInitialized, VOID_VALUE, "@%s, mInitialized is false", __FUNCTION__);
	CheckError(!isIPCFine(), VOID_VALUE, "@%s, IPC error happens", __FUNCTION__);

	std::vector<int32_t> handles({bufferHandle});
	mBridge->DeregisterBuffers(handles);
	}

	void Intel3AClient::callbackHandler(uint32_t req_id, uint32_t status, int32_t buffer_handle)
	{
	LOG2("@%s, req_id:%d, status:%d, buffer_handle:%d",
	__FUNCTION__, req_id, status, buffer_handle);

	IPC_GROUP group = Intel3AIpcCmdToGroup(static_cast<IPC_CMD>(req_id));
	mRunner[group]->callbackHandler(status, buffer_handle);
	}

	void Intel3AClient::notifyHandler(uint32_t msg)
	{
	LOG2("@%s, msg:%d", __FUNCTION__, msg);

	if (msg != CAMERA_ALGORITHM_MSG_IPC_ERROR) {
	LOGE("@%s, receive msg:%d, not CAMERA_ALGORITHM_MSG_IPC_ERROR", __FUNCTION__, msg);
	return;
	}

	std::lock_guard<std::mutex> l(mIPCStatusMutex);
	mIPCStatus = false;
	if (mErrCb) {
	mErrCb->deviceError();
	} else {
	LOGE("@%s, mErrCb is nullptr, no device error is sent out", __FUNCTION__);
	}
	LOGE("@%s, receive CAMERA_ALGORITHM_MSG_IPC_ERROR", __FUNCTION__);
	}

	void Intel3AClient::returnCallback(const camera_algorithm_callback_ops_t* callback_ops,
	uint32_t req_id,
	uint32_t status,
	int32_t buffer_handle)
	{
	LOG2("@%s", __FUNCTION__);
	CheckError(!callback_ops, VOID_VALUE, "@%s, callback_ops is nullptr", __FUNCTION__);

	auto s = const_cast<Intel3AClient>(static_cast<const Intel3AClient>(callback_ops));
	s->mCallback.Run(req_id, status, buffer_handle);
	}

	void Intel3AClient::notifyCallback(const struct camera_algorithm_callback_ops* callback_ops,
	camera_algorithm_error_msg_code_t msg)
	{
	LOG2("@%s", __FUNCTION__);
	CheckError(!callback_ops, VOID_VALUE, "@%s, callback_ops is nullptr", __FUNCTION__);

	auto s = const_cast<Intel3AClient>(static_cast<const Intel3AClient>(callback_ops));
	s->mNotifyCallback.Run((uint32_t)msg);
	}

	Intel3AClient::Runner::Runner(IPC_GROUP group, cros::CameraAlgorithmBridge* bridge):
	mGroup(group),
	mBridge(bridge),
	mIsCallbacked(false),
	mCbResult(true),
	mInitialized(false)
	{
	LOG1("@%s, group:%d", __FUNCTION__, mGroup);

	pthread_condattr_t attr;
	int ret = pthread_condattr_init(&attr);
	if (ret != 0) {
	LOGE("@%s, call pthread_condattr_init fails, ret:%d", __FUNCTION__, ret);
	pthread_condattr_destroy(&attr);
	return;
	}

	ret = pthread_condattr_setclock(&attr, CLOCK_MONOTONIC);
	if (ret != 0) {
	LOGE("@%s, call pthread_condattr_setclock fails, ret:%d", __FUNCTION__, ret);
	pthread_condattr_destroy(&attr);
	return;
	}

	ret = pthread_cond_init(&mCbCond, &attr);
	if (ret != 0) {
	LOGE("@%s, call pthread_cond_init fails, ret:%d", __FUNCTION__, ret);
	pthread_condattr_destroy(&attr);
	return;
	}

	pthread_condattr_destroy(&attr);

	ret = pthread_mutex_init(&mCbLock, nullptr);
	CheckError(ret != 0, VOID_VALUE, "@%s, call pthread_mutex_init fails, ret:%d", __FUNCTION__, ret);

	mInitialized = true;
	}

	Intel3AClient::Runner::~Runner()
	{
	LOG1("@%s, group:%d", __FUNCTION__, mGroup);

	int ret = pthread_cond_destroy(&mCbCond);
	if (ret != 0) {
	LOGE("@%s, call pthread_cond_destroy fails, ret:%d", __FUNCTION__, ret);
	}

	ret = pthread_mutex_destroy(&mCbLock);
	if (ret != 0) {
	LOGE("@%s, call pthread_mutex_destroy fails, ret:%d", __FUNCTION__, ret);
	}
	}

	int Intel3AClient::Runner::requestSync(IPC_CMD cmd, int32_t bufferHandle)
	{
	LOG1("@%s, cmd:%d:%s, group:%d, bufferHandle:%d, mInitialized:%d",
	__FUNCTION__, cmd, Intel3AIpcCmdToString(cmd), mGroup, bufferHandle, mInitialized);
	CheckError(!mInitialized, UNKNOWN_ERROR, "@%s, mInitialized is false", __FUNCTION__);

	std::lock_guard<std::mutex> lck(mMutex);

	std::vector<uint8_t> reqHeader(IPC_REQUEST_HEADER_USED_NUM);
	reqHeader[0] = IPC_MATCHING_KEY;

	// cmd is for request id, no duplicate command will be issued at any given time.
	mBridge->Request(cmd, reqHeader, bufferHandle);
	int ret = waitCallback();
	CheckError((ret != OK), UNKNOWN_ERROR, "@%s, call waitCallback fail", __FUNCTION__);

	LOG2("@%s, cmd:%d:%s, group:%d, mCbResult:%d, done!",
	__FUNCTION__, cmd, Intel3AIpcCmdToString(cmd), mGroup, mCbResult);

	// check callback result
	CheckError((mCbResult != true), UNKNOWN_ERROR, "@%s, callback fail", __FUNCTION__);

	return OK;
	}

	void Intel3AClient::Runner::callbackHandler(uint32_t status, int32_t buffer_handle)
	{
	LOG2("@%s, group:%d, status:%d, buffer_handle:%d", __FUNCTION__, mGroup, status, buffer_handle);
	if (status != 0) {
	LOGE("@%s, group:%d, status:%d, buffer_handle:%d", __FUNCTION__, mGroup, status, buffer_handle);
	}
	mCbResult = status != 0 ? false : true;

	pthread_mutex_lock(&mCbLock);
	mIsCallbacked = true;
	int ret = pthread_cond_signal(&mCbCond);
	pthread_mutex_unlock(&mCbLock);

	CheckError(ret != 0, VOID_VALUE, "@%s, group:%d, call pthread_cond_signal fails, ret:%d", __FUNCTION__, mGroup, ret);
	}

	int Intel3AClient::Runner::waitCallback()
	{
	LOG2("@%s, group:%d", __FUNCTION__, mGroup);
	nsecs_t startTime = systemTime();

	pthread_mutex_lock(&mCbLock);
	if (!mIsCallbacked) {
	int ret = 0;
	struct timespec ts = {0, 0};
	clock_gettime(CLOCK_MONOTONIC, &ts);
	ts.tv_sec += 5; // 5s timeout

	while (!mIsCallbacked && !ret) {
	ret = pthread_cond_timedwait(&mCbCond, &mCbLock, &ts);
	}
	if (ret != 0) {
	LOGE("@%s, group:%d, call pthread_cond_timedwait fail, ret:%d, it takes %" PRId64 "ms",
	__FUNCTION__, mGroup, ret, (systemTime() - startTime) / 1000000);
	pthread_mutex_unlock(&mCbLock);
	return UNKNOWN_ERROR;
	}
	}
	mIsCallbacked = false;
	pthread_mutex_unlock(&mCbLock);

	LOG2("@%s: group:%d, it takes %" PRId64 "ms", __FUNCTION__, mGroup, (systemTime() - startTime) / 1000000);

	return OK;
	}

	} /* namespace intel */
	} /* namespace cros */