msm8994: import msm8994/msm8992 display code
AU_LINUX_ANDROID_LA.BF64.1.2.1_RB1.05.00.00.019.037
Change-Id: Ie94c9207ea736a114bfdf4f35d372ccc326d7207
Signed-off-by: Patrick Tjin <[email protected]>
diff --git a/msm8994/libhwcomposer/hwc_qclient.cpp b/msm8994/libhwcomposer/hwc_qclient.cpp
new file mode 100644
index 0000000..09013c6
--- /dev/null
+++ b/msm8994/libhwcomposer/hwc_qclient.cpp
@@ -0,0 +1,407 @@
+/*
+ * Copyright (c) 2013-14, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ * * Neither the name of The Linux Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR CLIENTS; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <hwc_qclient.h>
+#include <IQService.h>
+#include <hwc_utils.h>
+#include <mdp_version.h>
+#include <hwc_mdpcomp.h>
+#include <hwc_virtual.h>
+#include <overlay.h>
+#include <display_config.h>
+
+#define QCLIENT_DEBUG 0
+
+using namespace android;
+using namespace qService;
+using namespace qhwc;
+using namespace overlay;
+using namespace qdutils;
+
+namespace qClient {
+
+// ----------------------------------------------------------------------------
+QClient::QClient(hwc_context_t *ctx) : mHwcContext(ctx),
+ mMPDeathNotifier(new MPDeathNotifier(ctx))
+{
+ ALOGD_IF(QCLIENT_DEBUG, "QClient Constructor invoked");
+}
+
+QClient::~QClient()
+{
+ ALOGD_IF(QCLIENT_DEBUG,"QClient Destructor invoked");
+}
+
+static void securing(hwc_context_t *ctx, uint32_t startEnd) {
+ //The only way to make this class in this process subscribe to media
+ //player's death.
+ IMediaDeathNotifier::getMediaPlayerService();
+
+ ctx->mDrawLock.lock();
+ ctx->mSecuring = startEnd;
+ //We're done securing
+ if(startEnd == IQService::END)
+ ctx->mSecureMode = true;
+ ctx->mDrawLock.unlock();
+
+ if(ctx->proc)
+ ctx->proc->invalidate(ctx->proc);
+}
+
+static void unsecuring(hwc_context_t *ctx, uint32_t startEnd) {
+ ctx->mDrawLock.lock();
+ ctx->mSecuring = startEnd;
+ //We're done unsecuring
+ if(startEnd == IQService::END)
+ ctx->mSecureMode = false;
+ ctx->mDrawLock.unlock();
+
+ if(ctx->proc)
+ ctx->proc->invalidate(ctx->proc);
+}
+
+void QClient::MPDeathNotifier::died() {
+ mHwcContext->mDrawLock.lock();
+ ALOGD_IF(QCLIENT_DEBUG, "Media Player died");
+ mHwcContext->mSecuring = false;
+ mHwcContext->mSecureMode = false;
+ mHwcContext->mDrawLock.unlock();
+ if(mHwcContext->proc)
+ mHwcContext->proc->invalidate(mHwcContext->proc);
+}
+
+static android::status_t screenRefresh(hwc_context_t *ctx) {
+ status_t result = NO_INIT;
+ if(ctx->proc) {
+ ctx->proc->invalidate(ctx->proc);
+ result = NO_ERROR;
+ }
+ return result;
+}
+
+static void setExtOrientation(hwc_context_t *ctx, uint32_t orientation) {
+ ctx->mExtOrientation = orientation;
+}
+
+static void isExternalConnected(hwc_context_t* ctx, Parcel* outParcel) {
+ int connected;
+ connected = ctx->dpyAttr[HWC_DISPLAY_EXTERNAL].connected ? 1 : 0;
+ outParcel->writeInt32(connected);
+}
+
+static void getDisplayAttributes(hwc_context_t* ctx, const Parcel* inParcel,
+ Parcel* outParcel) {
+ int dpy = inParcel->readInt32();
+ outParcel->writeInt32(ctx->dpyAttr[dpy].vsync_period);
+ if (ctx->dpyAttr[dpy].customFBSize) {
+ outParcel->writeInt32(ctx->dpyAttr[dpy].xres_new);
+ outParcel->writeInt32(ctx->dpyAttr[dpy].yres_new);
+ } else {
+ outParcel->writeInt32(ctx->dpyAttr[dpy].xres);
+ outParcel->writeInt32(ctx->dpyAttr[dpy].yres);
+ }
+ outParcel->writeFloat(ctx->dpyAttr[dpy].xdpi);
+ outParcel->writeFloat(ctx->dpyAttr[dpy].ydpi);
+ //XXX: Need to check what to return for HDMI
+ outParcel->writeInt32(ctx->mMDP.panel);
+}
+static void setHSIC(const Parcel* inParcel) {
+ int dpy = inParcel->readInt32();
+ ALOGD_IF(0, "In %s: dpy = %d", __FUNCTION__, dpy);
+ HSICData_t hsic_data;
+ hsic_data.hue = inParcel->readInt32();
+ hsic_data.saturation = inParcel->readFloat();
+ hsic_data.intensity = inParcel->readInt32();
+ hsic_data.contrast = inParcel->readFloat();
+ //XXX: Actually set the HSIC data through ABL lib
+}
+
+
+static void setBufferMirrorMode(hwc_context_t *ctx, uint32_t enable) {
+ ctx->mBufferMirrorMode = enable;
+}
+
+static status_t getDisplayVisibleRegion(hwc_context_t* ctx, int dpy,
+ Parcel* outParcel) {
+ // Get the info only if the dpy is valid
+ if(dpy >= HWC_DISPLAY_PRIMARY && dpy <= HWC_DISPLAY_VIRTUAL) {
+ Locker::Autolock _sl(ctx->mDrawLock);
+ if(dpy && (ctx->mExtOrientation || ctx->mBufferMirrorMode)) {
+ // Return the destRect on external, if external orienation
+ // is enabled
+ outParcel->writeInt32(ctx->dpyAttr[dpy].mDstRect.left);
+ outParcel->writeInt32(ctx->dpyAttr[dpy].mDstRect.top);
+ outParcel->writeInt32(ctx->dpyAttr[dpy].mDstRect.right);
+ outParcel->writeInt32(ctx->dpyAttr[dpy].mDstRect.bottom);
+ } else {
+ outParcel->writeInt32(ctx->mViewFrame[dpy].left);
+ outParcel->writeInt32(ctx->mViewFrame[dpy].top);
+ outParcel->writeInt32(ctx->mViewFrame[dpy].right);
+ outParcel->writeInt32(ctx->mViewFrame[dpy].bottom);
+ }
+ return NO_ERROR;
+ } else {
+ ALOGE("In %s: invalid dpy index %d", __FUNCTION__, dpy);
+ return BAD_VALUE;
+ }
+}
+
+// USed for setting the secondary(hdmi/wfd) status
+static void setSecondaryDisplayStatus(hwc_context_t *ctx,
+ const Parcel* inParcel) {
+ uint32_t dpy = inParcel->readInt32();
+ uint32_t status = inParcel->readInt32();
+ ALOGD_IF(QCLIENT_DEBUG, "%s: dpy = %d status = %s", __FUNCTION__,
+ dpy, getExternalDisplayState(status));
+
+ if(dpy > HWC_DISPLAY_PRIMARY && dpy <= HWC_DISPLAY_VIRTUAL) {
+ if(dpy == HWC_DISPLAY_VIRTUAL && status == qdutils::EXTERNAL_OFFLINE) {
+ ctx->mWfdSyncLock.lock();
+ ctx->mWfdSyncLock.signal();
+ ctx->mWfdSyncLock.unlock();
+ } else if(status == qdutils::EXTERNAL_PAUSE) {
+ handle_pause(ctx, dpy);
+ } else if(status == qdutils::EXTERNAL_RESUME) {
+ handle_resume(ctx, dpy);
+ }
+ } else {
+ ALOGE("%s: Invalid dpy %d", __FUNCTION__, dpy);
+ return;
+ }
+}
+
+
+static status_t setViewFrame(hwc_context_t* ctx, const Parcel* inParcel) {
+ int dpy = inParcel->readInt32();
+ if(dpy >= HWC_DISPLAY_PRIMARY && dpy <= HWC_DISPLAY_VIRTUAL) {
+ Locker::Autolock _sl(ctx->mDrawLock);
+ ctx->mViewFrame[dpy].left = inParcel->readInt32();
+ ctx->mViewFrame[dpy].top = inParcel->readInt32();
+ ctx->mViewFrame[dpy].right = inParcel->readInt32();
+ ctx->mViewFrame[dpy].bottom = inParcel->readInt32();
+ ALOGD_IF(QCLIENT_DEBUG, "%s: mViewFrame[%d] = [%d %d %d %d]",
+ __FUNCTION__, dpy,
+ ctx->mViewFrame[dpy].left, ctx->mViewFrame[dpy].top,
+ ctx->mViewFrame[dpy].right, ctx->mViewFrame[dpy].bottom);
+ return NO_ERROR;
+ } else {
+ ALOGE("In %s: invalid dpy index %d", __FUNCTION__, dpy);
+ return BAD_VALUE;
+ }
+}
+
+static void toggleDynamicDebug(hwc_context_t* ctx, const Parcel* inParcel) {
+ int debug_type = inParcel->readInt32();
+ bool enable = !!inParcel->readInt32();
+ ALOGD("%s: debug_type: %d enable:%d",
+ __FUNCTION__, debug_type, enable);
+ Locker::Autolock _sl(ctx->mDrawLock);
+ switch (debug_type) {
+ //break is ignored for DEBUG_ALL to toggle all of them at once
+ case IQService::DEBUG_ALL:
+ case IQService::DEBUG_MDPCOMP:
+ qhwc::MDPComp::dynamicDebug(enable);
+ if (debug_type != IQService::DEBUG_ALL)
+ break;
+ case IQService::DEBUG_VSYNC:
+ ctx->vstate.debug = enable;
+ if (debug_type != IQService::DEBUG_ALL)
+ break;
+ case IQService::DEBUG_VD:
+ HWCVirtualVDS::dynamicDebug(enable);
+ if (debug_type != IQService::DEBUG_ALL)
+ break;
+ case IQService::DEBUG_PIPE_LIFECYCLE:
+ Overlay::debugPipeLifecycle(enable);
+ if (debug_type != IQService::DEBUG_ALL)
+ break;
+ }
+}
+
+static void setIdleTimeout(hwc_context_t* ctx, const Parcel* inParcel) {
+ uint32_t timeout = (uint32_t)inParcel->readInt32();
+ ALOGD("%s :%u ms", __FUNCTION__, timeout);
+ Locker::Autolock _sl(ctx->mDrawLock);
+ MDPComp::setIdleTimeout(timeout);
+}
+
+static void setMaxPipesPerMixer(hwc_context_t* ctx, const Parcel* inParcel) {
+ uint32_t value = (uint32_t)inParcel->readInt32();
+ ALOGD("%s : setting MaxPipesPerMixer: %d ", __FUNCTION__, value);
+ Locker::Autolock _sl(ctx->mDrawLock);
+ MDPComp::setMaxPipesPerMixer(value);
+}
+
+static void toggleBWC(hwc_context_t* ctx, const Parcel* inParcel) {
+ uint32_t enable = (uint32_t)inParcel->readInt32();
+ if(MDPVersion::getInstance().supportsBWC()) {
+ Locker::Autolock _sl(ctx->mDrawLock);
+ ctx->mBWCEnabled = (bool) enable;
+ ALOGI("%s: Set BWC to %d", __FUNCTION__, enable);
+ } else {
+ ALOGI("%s: Target doesn't support BWC", __FUNCTION__);
+ }
+}
+
+static void configureDynRefreshRate(hwc_context_t* ctx,
+ const Parcel* inParcel) {
+ uint32_t op = (uint32_t)inParcel->readInt32();
+ uint32_t refresh_rate = (uint32_t)inParcel->readInt32();
+ MDPVersion& mdpHw = MDPVersion::getInstance();
+ uint32_t dpy = HWC_DISPLAY_PRIMARY;
+
+ if(mdpHw.isDynFpsSupported()) {
+ Locker::Autolock _sl(ctx->mDrawLock);
+
+ switch (op) {
+ case DISABLE_METADATA_DYN_REFRESH_RATE:
+ ctx->mUseMetaDataRefreshRate = false;
+ setRefreshRate(ctx, dpy, ctx->dpyAttr[dpy].refreshRate);
+ break;
+ case ENABLE_METADATA_DYN_REFRESH_RATE:
+ ctx->mUseMetaDataRefreshRate = true;
+ setRefreshRate(ctx, dpy, ctx->dpyAttr[dpy].refreshRate);
+ break;
+ case SET_BINDER_DYN_REFRESH_RATE:
+ if(ctx->mUseMetaDataRefreshRate)
+ ALOGW("%s: Ignoring binder request to change refresh-rate",
+ __FUNCTION__);
+ else {
+ uint32_t rate = roundOff(refresh_rate);
+ if((rate >= mdpHw.getMinFpsSupported() &&
+ rate <= mdpHw.getMaxFpsSupported())) {
+ setRefreshRate(ctx, dpy, rate);
+ } else {
+ ALOGE("%s: Requested refresh-rate should be between \
+ (%d) and (%d). Given (%d)", __FUNCTION__,
+ mdpHw.getMinFpsSupported(),
+ mdpHw.getMaxFpsSupported(), rate);
+ }
+ }
+ break;
+ default:
+ ALOGE("%s: Invalid op %d",__FUNCTION__,op);
+ }
+ }
+}
+
+static status_t setPartialUpdatePref(hwc_context_t *ctx, uint32_t enable) {
+ ALOGD("%s: enable: %d", __FUNCTION__, enable);
+ if(qhwc::MDPComp::setPartialUpdatePref(ctx, (bool)enable) < 0)
+ return NO_INIT;
+ return NO_ERROR;
+}
+
+static void toggleScreenUpdate(hwc_context_t* ctx, uint32_t on) {
+ ALOGD("%s: toggle update: %d", __FUNCTION__, on);
+ if (on == 0) {
+ ctx->mDrawLock.lock();
+ ctx->dpyAttr[HWC_DISPLAY_PRIMARY].isPause = true;
+ ctx->mOverlay->configBegin();
+ ctx->mOverlay->configDone();
+ ctx->mRotMgr->clear();
+ if(!Overlay::displayCommit(ctx->dpyAttr[0].fd)) {
+ ALOGE("%s: Display commit failed", __FUNCTION__);
+ }
+ ctx->mDrawLock.unlock();
+ } else {
+ ctx->mDrawLock.lock();
+ ctx->dpyAttr[HWC_DISPLAY_PRIMARY].isPause = false;
+ ctx->mDrawLock.unlock();
+ ctx->proc->invalidate(ctx->proc);
+ }
+}
+
+status_t QClient::notifyCallback(uint32_t command, const Parcel* inParcel,
+ Parcel* outParcel) {
+ status_t ret = NO_ERROR;
+
+ switch(command) {
+ case IQService::SECURING:
+ securing(mHwcContext, inParcel->readInt32());
+ break;
+ case IQService::UNSECURING:
+ unsecuring(mHwcContext, inParcel->readInt32());
+ break;
+ case IQService::SCREEN_REFRESH:
+ return screenRefresh(mHwcContext);
+ break;
+ case IQService::EXTERNAL_ORIENTATION:
+ setExtOrientation(mHwcContext, inParcel->readInt32());
+ break;
+ case IQService::BUFFER_MIRRORMODE:
+ setBufferMirrorMode(mHwcContext, inParcel->readInt32());
+ break;
+ case IQService::GET_DISPLAY_VISIBLE_REGION:
+ ret = getDisplayVisibleRegion(mHwcContext, inParcel->readInt32(),
+ outParcel);
+ break;
+ case IQService::CHECK_EXTERNAL_STATUS:
+ isExternalConnected(mHwcContext, outParcel);
+ break;
+ case IQService::GET_DISPLAY_ATTRIBUTES:
+ getDisplayAttributes(mHwcContext, inParcel, outParcel);
+ break;
+ case IQService::SET_HSIC_DATA:
+ setHSIC(inParcel);
+ break;
+ case IQService::SET_SECONDARY_DISPLAY_STATUS:
+ setSecondaryDisplayStatus(mHwcContext, inParcel);
+ break;
+ case IQService::SET_VIEW_FRAME:
+ setViewFrame(mHwcContext, inParcel);
+ break;
+ case IQService::DYNAMIC_DEBUG:
+ toggleDynamicDebug(mHwcContext, inParcel);
+ break;
+ case IQService::SET_IDLE_TIMEOUT:
+ setIdleTimeout(mHwcContext, inParcel);
+ break;
+ case IQService::SET_MAX_PIPES_PER_MIXER:
+ setMaxPipesPerMixer(mHwcContext, inParcel);
+ break;
+ case IQService::SET_PARTIAL_UPDATE:
+ ret = setPartialUpdatePref(mHwcContext, inParcel->readInt32());
+ break;
+ case IQService::TOGGLE_BWC:
+ toggleBWC(mHwcContext, inParcel);
+ break;
+ case IQService::CONFIGURE_DYN_REFRESH_RATE:
+ configureDynRefreshRate(mHwcContext, inParcel);
+ break;
+ case IQService::TOGGLE_SCREEN_UPDATE:
+ toggleScreenUpdate(mHwcContext, inParcel->readInt32());
+ break;
+ default:
+ ret = NO_ERROR;
+ }
+ return ret;
+}
+
+}
