Merge "hwc: Color layer always has zero transform."
diff --git a/common.mk b/common.mk
index d8ea260..64f60e4 100644
--- a/common.mk
+++ b/common.mk
@@ -33,11 +33,6 @@
     common_flags += -DMDSS_TARGET
 endif
 
-ifeq ($(call is-board-platform-in-list, mpq8092), true)
-    common_flags += -DVPU_TARGET
-endif
-
-
 common_deps  :=
 kernel_includes :=
 
diff --git a/libgralloc/ionalloc.cpp b/libgralloc/ionalloc.cpp
index 311fd8f..bb6c2c8 100644
--- a/libgralloc/ionalloc.cpp
+++ b/libgralloc/ionalloc.cpp
@@ -28,7 +28,7 @@
  */
 
 #define DEBUG 0
-#include <linux/ioctl.h>
+#include <sys/ioctl.h>
 #include <sys/mman.h>
 #include <stdlib.h>
 #include <fcntl.h>
diff --git a/libhwcomposer/Android.mk b/libhwcomposer/Android.mk
index 9749c69..68da8a0 100644
--- a/libhwcomposer/Android.mk
+++ b/libhwcomposer/Android.mk
@@ -25,8 +25,4 @@
                                  hwc_dump_layers.cpp \
                                  hwc_ad.cpp \
                                  hwc_virtual.cpp
-ifeq ($(call is-board-platform-in-list, mpq8092), true)
-    LOCAL_SRC_FILES += hwc_vpuclient.cpp
-endif
-
 include $(BUILD_SHARED_LIBRARY)
diff --git a/libhwcomposer/hwc.cpp b/libhwcomposer/hwc.cpp
index 15b9da4..bfcfa78 100644
--- a/libhwcomposer/hwc.cpp
+++ b/libhwcomposer/hwc.cpp
@@ -38,7 +38,6 @@
 #include "hwc_copybit.h"
 #include "hwc_ad.h"
 #include "profiler.h"
-#include "hwc_vpuclient.h"
 #include "hwc_virtual.h"
 
 using namespace qhwc;
@@ -202,12 +201,7 @@
         reset_layer_prop(ctx, dpy, list->numHwLayers - 1);
         setListStats(ctx, list, dpy);
 
-        if (ctx->mVPUClient == NULL)
-            fbComp = (ctx->mMDPComp[dpy]->prepare(ctx, list) < 0);
-#ifdef VPU_TARGET
-        else
-            fbComp = (ctx->mVPUClient->prepare(ctx, dpy, list) < 0);
-#endif
+        fbComp = (ctx->mMDPComp[dpy]->prepare(ctx, list) < 0);
 
         if (fbComp) {
             const int fbZ = 0;
@@ -218,6 +212,7 @@
             if(ctx->mCopyBit[dpy])
                 ctx->mCopyBit[dpy]->prepare(ctx, list, dpy);
         }
+        setGPUHint(ctx, list);
     }
     return 0;
 }
@@ -476,7 +471,8 @@
     case HWC_DISPLAY_TYPES_SUPPORTED:
         if(ctx->mMDP.hasOverlay) {
             supported |= HWC_DISPLAY_VIRTUAL_BIT;
-            if(!qdutils::MDPVersion::getInstance().is8x26())
+            if(!(qdutils::MDPVersion::getInstance().is8x26() ||
+                        qdutils::MDPVersion::getInstance().is8x16()))
                 supported |= HWC_DISPLAY_EXTERNAL_BIT;
         }
         value[0] = supported;
@@ -513,12 +509,7 @@
         if(ctx->mHwcDebug[dpy])
             ctx->mHwcDebug[dpy]->dumpLayers(list);
 
-        if (ctx->mVPUClient != NULL) {
-#ifdef VPU_TARGET
-            ctx->mVPUClient->predraw(ctx, dpy, list);
-#endif
-        }
-        else if (!ctx->mMDPComp[dpy]->draw(ctx, list)) {
+        if (!ctx->mMDPComp[dpy]->draw(ctx, list)) {
             ALOGE("%s: MDPComp draw failed", __FUNCTION__);
             ret = -1;
         }
@@ -543,10 +534,6 @@
             ret = -1;
         }
 
-#ifdef VPU_TARGET
-        if (ctx->mVPUClient != NULL)
-            ctx->mVPUClient->draw(ctx, dpy, list);
-#endif
     }
 
     closeAcquireFds(list);
diff --git a/libhwcomposer/hwc_fbupdate.cpp b/libhwcomposer/hwc_fbupdate.cpp
index 678eecb..bf2aee5 100644
--- a/libhwcomposer/hwc_fbupdate.cpp
+++ b/libhwcomposer/hwc_fbupdate.cpp
@@ -140,7 +140,8 @@
 
         //Request a pipe
         ovutils::eMdpPipeType type = ovutils::OV_MDP_PIPE_ANY;
-        if(qdutils::MDPVersion::getInstance().is8x26() && mDpy) {
+        if((qdutils::MDPVersion::getInstance().is8x26() ||
+                   qdutils::MDPVersion::getInstance().is8x16()) && mDpy) {
             //For 8x26 external always use DMA pipe
             type = ovutils::OV_MDP_PIPE_DMA;
         }
diff --git a/libhwcomposer/hwc_mdpcomp.cpp b/libhwcomposer/hwc_mdpcomp.cpp
index 8f2a6e8..12b4256 100644
--- a/libhwcomposer/hwc_mdpcomp.cpp
+++ b/libhwcomposer/hwc_mdpcomp.cpp
@@ -1438,6 +1438,10 @@
             && Overlay::getDMAMode() != Overlay::DMA_BLOCK_MODE
             && ctx->mMDP.version >= qdutils::MDSS_V5) {
             type = MDPCOMP_OV_DMA;
+        } else if(qhwc::needsScaling(layer) &&
+                !(ctx->listStats[mDpy].yuvCount) &&
+                ! qdutils::MDPVersion::getInstance().isRGBScalarSupported()){
+            type = MDPCOMP_OV_VG;
         }
 
         pipe_info.index = getMdpPipe(ctx, type, Overlay::MIXER_DEFAULT);
diff --git a/libhwcomposer/hwc_mdpcomp.h b/libhwcomposer/hwc_mdpcomp.h
index 22b8baf..2d65755 100644
--- a/libhwcomposer/hwc_mdpcomp.h
+++ b/libhwcomposer/hwc_mdpcomp.h
@@ -53,6 +53,7 @@
     static bool init(hwc_context_t *ctx);
     static void resetIdleFallBack() { sIdleFallBack = false; }
     static void reset() { sHandleTimeout = false; };
+    static bool isIdleFallback() { return sIdleFallBack; }
 
 protected:
     enum { MAX_SEC_LAYERS = 1 }; //TODO add property support
diff --git a/libhwcomposer/hwc_qclient.cpp b/libhwcomposer/hwc_qclient.cpp
index 2320bc0..5313795 100644
--- a/libhwcomposer/hwc_qclient.cpp
+++ b/libhwcomposer/hwc_qclient.cpp
@@ -30,7 +30,6 @@
 #include <hwc_qclient.h>
 #include <IQService.h>
 #include <hwc_utils.h>
-#include <hwc_vpuclient.h>
 #include <mdp_version.h>
 
 #define QCLIENT_DEBUG 0
@@ -95,20 +94,6 @@
     return result;
 }
 
-#ifdef VPU_TARGET
-static android::status_t vpuCommand(hwc_context_t *ctx,
-        uint32_t command,
-        const Parcel* inParcel,
-        Parcel* outParcel) {
-    status_t result = NO_INIT;
-#ifdef QCOM_BSP
-    if(qdutils::MDPVersion::getInstance().is8092())
-        result = ctx->mVPUClient->processCommand(command, inParcel, outParcel);
-#endif
-    return result;
-}
-#endif
-
 static void setExtOrientation(hwc_context_t *ctx, uint32_t orientation) {
     ctx->mExtOrientation = orientation;
 }
@@ -186,12 +171,6 @@
         Parcel* outParcel) {
     status_t ret = NO_ERROR;
 
-#ifdef VPU_TARGET
-    if (command > IQService::VPU_COMMAND_LIST_START &&
-        command < IQService::VPU_COMMAND_LIST_END) {
-        return vpuCommand(mHwcContext, command, inParcel, outParcel);
-    }
-#endif
     switch(command) {
         case IQService::SECURING:
             securing(mHwcContext, inParcel->readInt32());
diff --git a/libhwcomposer/hwc_uevents.cpp b/libhwcomposer/hwc_uevents.cpp
index e51a1a4..7bc29bc 100644
--- a/libhwcomposer/hwc_uevents.cpp
+++ b/libhwcomposer/hwc_uevents.cpp
@@ -32,6 +32,7 @@
 #include "comptype.h"
 #include "external.h"
 #include "virtual.h"
+#include "hwc_virtual.h"
 #include "mdp_version.h"
 using namespace overlay;
 namespace qhwc {
@@ -107,53 +108,15 @@
 }
 
 void handle_pause(hwc_context_t* ctx, int dpy) {
-    {
-        Locker::Autolock _l(ctx->mDrawLock);
-        ctx->dpyAttr[dpy].isActive = true;
-        ctx->dpyAttr[dpy].isPause = true;
-        ctx->proc->invalidate(ctx->proc);
-    }
-    usleep(ctx->dpyAttr[HWC_DISPLAY_PRIMARY].vsync_period
-           * 2 / 1000);
-    // At this point all the pipes used by External have been
-    // marked as UNSET.
-    {
-        Locker::Autolock _l(ctx->mDrawLock);
-        // Perform commit to unstage the pipes.
-        if (!Overlay::displayCommit(ctx->dpyAttr[dpy].fd)) {
-            ALOGE("%s: display commit fail! for %d dpy",
-                  __FUNCTION__, dpy);
-        }
+    if(ctx->mHWCVirtual) {
+        ctx->mHWCVirtual->pause(ctx, dpy);
     }
     return;
 }
 
 void handle_resume(hwc_context_t* ctx, int dpy) {
-    //Treat Resume as Online event
-    //Since external didnt have any pipes, force primary to give up
-    //its pipes; we don't allow inter-mixer pipe transfers.
-    {
-        Locker::Autolock _l(ctx->mDrawLock);
-
-        // A dynamic resolution change (DRC) can be made for a WiFi
-        // display. In order to support the resolution change, we
-        // need to reconfigure the corresponding display attributes.
-        // Since DRC is only on WiFi display, we only need to call
-        // configure() on the VirtualDisplay device.
-        if(dpy == HWC_DISPLAY_VIRTUAL)
-            ctx->mVirtualDisplay->configure();
-
-        ctx->dpyAttr[dpy].isConfiguring = true;
-        ctx->dpyAttr[dpy].isActive = true;
-        ctx->proc->invalidate(ctx->proc);
-    }
-    usleep(ctx->dpyAttr[HWC_DISPLAY_PRIMARY].vsync_period
-           * 2 / 1000);
-    //At this point external has all the pipes it would need.
-    {
-        Locker::Autolock _l(ctx->mDrawLock);
-        ctx->dpyAttr[dpy].isPause = false;
-        ctx->proc->invalidate(ctx->proc);
+    if(ctx->mHWCVirtual) {
+        ctx->mHWCVirtual->resume(ctx, dpy);
     }
     return;
 }
diff --git a/libhwcomposer/hwc_utils.cpp b/libhwcomposer/hwc_utils.cpp
index 8a42b38..8742990 100644
--- a/libhwcomposer/hwc_utils.cpp
+++ b/libhwcomposer/hwc_utils.cpp
@@ -37,7 +37,6 @@
 #include "mdp_version.h"
 #include "hwc_copybit.h"
 #include "hwc_dump_layers.h"
-#include "hwc_vpuclient.h"
 #include "external.h"
 #include "virtual.h"
 #include "hwc_qclient.h"
@@ -53,6 +52,26 @@
 using namespace overlay::utils;
 namespace ovutils = overlay::utils;
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+EGLAPI EGLBoolean eglGpuPerfHintQCOM(EGLDisplay dpy, EGLContext ctx,
+                                           EGLint *attrib_list);
+#define EGL_GPU_HINT_1        0x32D0
+#define EGL_GPU_HINT_2        0x32D1
+
+#define EGL_GPU_LEVEL_0       0x0
+#define EGL_GPU_LEVEL_1       0x1
+#define EGL_GPU_LEVEL_2       0x2
+#define EGL_GPU_LEVEL_3       0x3
+#define EGL_GPU_LEVEL_4       0x4
+#define EGL_GPU_LEVEL_5       0x5
+
+#ifdef __cplusplus
+}
+#endif
+
 namespace qhwc {
 
 bool isValidResolution(hwc_context_t *ctx, uint32_t xres, uint32_t yres)
@@ -237,7 +256,6 @@
     // Initialize device orientation to its default orientation
     ctx->deviceOrientation = 0;
     ctx->mBufferMirrorMode = false;
-    ctx->mVPUClient = NULL;
 
     // Read the system property to determine if downscale feature is enabled.
     ctx->mMDPDownscaleEnabled = false;
@@ -247,10 +265,14 @@
         ctx->mMDPDownscaleEnabled = true;
     }
 
-#ifdef VPU_TARGET
-    if(qdutils::MDPVersion::getInstance().is8092())
-        ctx->mVPUClient = new VPUClient(ctx);
-#endif
+    // Initialize gpu perfomance hint related parameters
+    property_get("sys.hwc.gpu_perf_mode", value, "0");
+    ctx->mGPUHintInfo.mGpuPerfModeEnable = atoi(value)? true : false;
+
+    ctx->mGPUHintInfo.mEGLDisplay = NULL;
+    ctx->mGPUHintInfo.mEGLContext = NULL;
+    ctx->mGPUHintInfo.mPrevCompositionGLES = false;
+    ctx->mGPUHintInfo.mCurrGPUPerfMode = EGL_GPU_LEVEL_0;
 
     ALOGI("Initializing Qualcomm Hardware Composer");
     ALOGI("MDP version: %d", ctx->mMDP.version);
@@ -285,11 +307,6 @@
         ctx->mExtDisplay = NULL;
     }
 
-#ifdef VPU_TARGET
-    if(ctx->mVPUClient != NULL)
-        delete ctx->mVPUClient;
-#endif
-
     for(int i = 0; i < HWC_NUM_DISPLAY_TYPES; i++) {
         if(ctx->mFBUpdate[i]) {
             delete ctx->mFBUpdate[i];
@@ -405,7 +422,6 @@
 // based on the position and aspect ratio with orientation
 void getAspectRatioPosition(hwc_context_t* ctx, int dpy, int extOrientation,
                             hwc_rect_t& inRect, hwc_rect_t& outRect) {
-    hwc_rect_t viewFrame = ctx->mViewFrame[dpy];
     // Physical display resolution
     float fbWidth  = ctx->dpyAttr[dpy].xres;
     float fbHeight = ctx->dpyAttr[dpy].yres;
@@ -443,17 +459,11 @@
         yPos = rect.top;
         width = rect.right - rect.left;
         height = rect.bottom - rect.top;
-        // swap viewframe coordinates for 90 degree rotation.
-        swap(viewFrame.left, viewFrame.top);
-        swap(viewFrame.right, viewFrame.bottom);
     }
-    // if viewframe left and top coordinates are non zero value then exclude it
-    // during the computation of xRatio and yRatio
-    xRatio = (inPos.x - viewFrame.left)/actualWidth;
-    yRatio = (inPos.y - viewFrame.top)/actualHeight;
-    // Use viewframe width and height to compute wRatio and hRatio.
-    wRatio = (float)inPos.w/(float)(viewFrame.right - viewFrame.left);
-    hRatio = (float)inPos.h/(float)(viewFrame.bottom - viewFrame.top);
+    xRatio = inPos.x/actualWidth;
+    yRatio = inPos.y/actualHeight;
+    wRatio = inPos.w/actualWidth;
+    hRatio = inPos.h/actualHeight;
 
 
     //Calculate the position...
@@ -1332,10 +1342,8 @@
                 // Release all the app layer fds immediately,
                 // if animation is in progress.
                 list->hwLayers[i].releaseFenceFd = -1;
-            } else if(list->hwLayers[i].releaseFenceFd < 0 &&
-                    !(layerProp[i].mFlags & HWC_VPUCOMP)) {
+            } else if(list->hwLayers[i].releaseFenceFd < 0 ) {
                 //If rotator has not already populated this field
-                // & if it's a not VPU layer
                 if(list->hwLayers[i].compositionType == HWC_BLIT) {
                     //For Blit, the app layers should be released when the Blit is
                     //complete. This fd was passed from copybit->draw
@@ -1379,19 +1387,13 @@
                 ovutils::OV_MDP_BLEND_FG_PREMULT);
     }
 
-    if (layer->flags & HWC_VPU_PIPE) {
-        ovutils::setMdpFlags(mdpFlags, ovutils::OV_MDP_VPU_PIPE);
-    }
-
     if(isYuvBuffer(hnd)) {
         if(isSecureBuffer(hnd)) {
             ovutils::setMdpFlags(mdpFlags,
                     ovutils::OV_MDP_SECURE_OVERLAY_SESSION);
         }
-        // in mpq, deinterlacing is done in vpu
         if(metadata && (metadata->operation & PP_PARAM_INTERLACED) &&
-                metadata->interlaced &&
-                (!qdutils::MDPVersion::getInstance().is8092())) {
+                metadata->interlaced) {
             ovutils::setMdpFlags(mdpFlags,
                     ovutils::OV_MDP_DEINTERLACE);
         }
@@ -1579,16 +1581,6 @@
     uint32_t format = ovutils::getMdpFormat(hnd->format, isTileRendered(hnd));
     Whf whf(getWidth(hnd), getHeight(hnd), format, hnd->size);
 
-#ifdef VPU_TARGET
-    if(ctx->mVPUClient != NULL &&
-            ctx->mVPUClient->supportedVPULayer(dpy, layer)) {
-        whf.format = getMdpFormat(
-                ctx->mVPUClient->getLayerFormat(dpy, layer));
-        whf.w = ctx->mVPUClient->getWidth(dpy, layer);
-        whf.h = ctx->mVPUClient->getHeight(dpy, layer);
-    }
-#endif
-
     // Handle R/B swap
     if (layer->flags & HWC_FORMAT_RB_SWAP) {
         if (hnd->format == HAL_PIXEL_FORMAT_RGBA_8888)
@@ -1696,16 +1688,6 @@
     uint32_t format = ovutils::getMdpFormat(hnd->format, isTileRendered(hnd));
     Whf whf(getWidth(hnd), getHeight(hnd), format, hnd->size);
 
-#ifdef VPU_TARGET
-    if(ctx->mVPUClient != NULL &&
-            ctx->mVPUClient->supportedVPULayer(dpy, layer)) {
-        whf.format = getMdpFormat(
-                ctx->mVPUClient->getLayerFormat(dpy, layer));
-        whf.w = ctx->mVPUClient->getWidth(dpy, layer);
-        whf.h = ctx->mVPUClient->getHeight(dpy, layer);
-    }
-#endif
-
     // Handle R/B swap
     if (layer->flags & HWC_FORMAT_RB_SWAP) {
         if (hnd->format == HAL_PIXEL_FORMAT_RGBA_8888)
@@ -2024,6 +2006,78 @@
     return true;
 }
 
+bool isGLESComp(hwc_context_t *ctx,
+                     hwc_display_contents_1_t* list) {
+    int numAppLayers = ctx->listStats[HWC_DISPLAY_PRIMARY].numAppLayers;
+    for(int index = 0; index < numAppLayers; index++) {
+        hwc_layer_1_t* layer = &(list->hwLayers[index]);
+        if(layer->compositionType == HWC_FRAMEBUFFER)
+            return true;
+    }
+    return false;
+}
+
+void setGPUHint(hwc_context_t* ctx, hwc_display_contents_1_t* list) {
+    struct gpu_hint_info *gpuHint = &ctx->mGPUHintInfo;
+    if(!gpuHint->mGpuPerfModeEnable)
+        return;
+    /* Set the GPU hint flag to high for MIXED/GPU composition only for
+       first frame after MDP -> GPU/MIXED mode transition. Set the GPU
+       hint to default if the previous composition is GPU or current GPU
+       composition is due to idle fallback */
+    if(!gpuHint->mEGLDisplay || !gpuHint->mEGLContext) {
+        gpuHint->mEGLDisplay = eglGetCurrentDisplay();
+        if(!gpuHint->mEGLDisplay) {
+            ALOGW("%s Warning: EGL current display is NULL", __FUNCTION__);
+            return;
+        }
+        gpuHint->mEGLContext = eglGetCurrentContext();
+        if(!gpuHint->mEGLContext) {
+            ALOGW("%s Warning: EGL current context is NULL", __FUNCTION__);
+            return;
+        }
+    }
+    if(isGLESComp(ctx, list)) {
+        if(!gpuHint->mPrevCompositionGLES && !MDPComp::isIdleFallback()) {
+            EGLint attr_list[] = {EGL_GPU_HINT_1,
+                                  EGL_GPU_LEVEL_3,
+                                  EGL_NONE };
+            if((gpuHint->mCurrGPUPerfMode != EGL_GPU_LEVEL_3) &&
+                !eglGpuPerfHintQCOM(gpuHint->mEGLDisplay,
+                                    gpuHint->mEGLContext, attr_list)) {
+                ALOGW("eglGpuPerfHintQCOM failed for Built in display");
+            } else {
+                gpuHint->mCurrGPUPerfMode = EGL_GPU_LEVEL_3;
+                gpuHint->mPrevCompositionGLES = true;
+            }
+        } else {
+            EGLint attr_list[] = {EGL_GPU_HINT_1,
+                                  EGL_GPU_LEVEL_0,
+                                  EGL_NONE };
+            if((gpuHint->mCurrGPUPerfMode != EGL_GPU_LEVEL_0) &&
+                !eglGpuPerfHintQCOM(gpuHint->mEGLDisplay,
+                                    gpuHint->mEGLContext, attr_list)) {
+                ALOGW("eglGpuPerfHintQCOM failed for Built in display");
+            } else {
+                gpuHint->mCurrGPUPerfMode = EGL_GPU_LEVEL_0;
+            }
+        }
+    } else {
+        /* set the GPU hint flag to default for MDP composition */
+        EGLint attr_list[] = {EGL_GPU_HINT_1,
+                              EGL_GPU_LEVEL_0,
+                              EGL_NONE };
+        if((gpuHint->mCurrGPUPerfMode != EGL_GPU_LEVEL_0) &&
+                !eglGpuPerfHintQCOM(gpuHint->mEGLDisplay,
+                                    gpuHint->mEGLContext, attr_list)) {
+            ALOGW("eglGpuPerfHintQCOM failed for Built in display");
+        } else {
+            gpuHint->mCurrGPUPerfMode = EGL_GPU_LEVEL_0;
+        }
+        gpuHint->mPrevCompositionGLES = false;
+    }
+}
+
 void BwcPM::setBwc(const hwc_rect_t& crop,
             const hwc_rect_t& dst, const int& transform,
             ovutils::eMdpFlags& mdpFlags) {
diff --git a/libhwcomposer/hwc_utils.h b/libhwcomposer/hwc_utils.h
index 4aa6410..ad023ad 100644
--- a/libhwcomposer/hwc_utils.h
+++ b/libhwcomposer/hwc_utils.h
@@ -30,6 +30,8 @@
 #include <utils/String8.h>
 #include "qdMetaData.h"
 #include <overlayUtils.h>
+#include <EGL/egl.h>
+
 
 #define ALIGN_TO(x, align)     (((x) + ((align)-1)) & ~((align)-1))
 #define LIKELY( exp )       (__builtin_expect( (exp) != 0, true  ))
@@ -60,7 +62,6 @@
 class CopyBit;
 class HwcDebug;
 class AssertiveDisplay;
-class VPUClient;
 class HWCVirtualBase;
 
 
@@ -145,14 +146,12 @@
 enum {
     HWC_MDPCOMP = 0x00000001,
     HWC_COPYBIT = 0x00000002,
-    HWC_VPUCOMP = 0x00000004,
 };
 
 // HAL specific features
 enum {
     HWC_COLOR_FILL = 0x00000008,
     HWC_FORMAT_RB_SWAP = 0x00000040,
-    HWC_VPU_PIPE = 0x00000200,
 };
 
 class LayerRotMap {
@@ -344,6 +343,12 @@
 
 bool isDisplaySplit(hwc_context_t* ctx, int dpy);
 
+// Set the GPU hint flag to high for MIXED/GPU composition only for
+// first frame after MDP to GPU/MIXED mode transition.
+// Set the GPU hint to default if the current composition type is GPU
+// due to idle fallback or MDP composition.
+void setGPUHint(hwc_context_t* ctx, hwc_display_contents_1_t* list);
+
 // Inline utility functions
 static inline bool isSkipLayer(const hwc_layer_1_t* l) {
     return (UNLIKELY(l && (l->flags & HWC_SKIP_LAYER)));
@@ -442,6 +447,20 @@
     ANIMATION_STARTED,
 };
 
+// Structure holds the information about the GPU hint.
+struct gpu_hint_info {
+    // system level flag to enable gpu_perf_mode
+    bool mGpuPerfModeEnable;
+    // Stores the current GPU performance mode DEFAULT/HIGH
+    bool mCurrGPUPerfMode;
+    // true if previous composition used GPU
+    bool mPrevCompositionGLES;
+    // Stores the EGLContext of current process
+    EGLContext mEGLContext;
+    // Stores the EGLDisplay of current process
+    EGLDisplay mEGLDisplay;
+};
+
 // -----------------------------------------------------------------------------
 // HWC context
 // This structure contains overall state
@@ -471,7 +490,6 @@
     qhwc::HwcDebug *mHwcDebug[HWC_NUM_DISPLAY_TYPES];
     hwc_rect_t mViewFrame[HWC_NUM_DISPLAY_TYPES];
     qhwc::AssertiveDisplay *mAD;
-    qhwc::VPUClient *mVPUClient;
     eAnimationState mAnimationState[HWC_NUM_DISPLAY_TYPES];
     qhwc::HWCVirtualBase *mHWCVirtual;
 
@@ -506,6 +524,7 @@
     // Downscale feature switch, set via system the property
     // sys.hwc.mdp_downscale_enabled
     bool mMDPDownscaleEnabled;
+    struct gpu_hint_info mGPUHintInfo;
 };
 
 namespace qhwc {
diff --git a/libhwcomposer/hwc_virtual.cpp b/libhwcomposer/hwc_virtual.cpp
index cc29d45..37d87e2 100644
--- a/libhwcomposer/hwc_virtual.cpp
+++ b/libhwcomposer/hwc_virtual.cpp
@@ -69,6 +69,7 @@
     //Cleanup virtual display objs, since there is no explicit disconnect
     if(ctx->dpyAttr[dpy].connected && (displays[dpy] == NULL)) {
         ctx->dpyAttr[dpy].connected = false;
+        ctx->dpyAttr[dpy].isPause = false;
 
         if(ctx->mFBUpdate[dpy]) {
             delete ctx->mFBUpdate[dpy];
@@ -104,6 +105,7 @@
 
         if(ctx->dpyAttr[dpy].connected == false) {
             ctx->dpyAttr[dpy].connected = true;
+            ctx->dpyAttr[dpy].isPause = false;
             // We set the vsync period to the primary refresh rate, leaving
             // it up to the consumer to decide how fast to consume frames.
             ctx->dpyAttr[dpy].vsync_period
@@ -113,16 +115,27 @@
             // allow one padding round to free up resources but this breaks
             // certain use cases.
         }
+        if(!ctx->dpyAttr[dpy].isPause) {
+            ctx->dpyAttr[dpy].isConfiguring = false;
+            ctx->dpyAttr[dpy].fd = Writeback::getInstance()->getFbFd();
+            private_handle_t *ohnd = (private_handle_t *)list->outbuf;
+            Writeback::getInstance()->configureDpyInfo(ohnd->width,
+                                                          ohnd->height);
+            setListStats(ctx, list, dpy);
 
-        ctx->dpyAttr[dpy].isConfiguring = false;
-        ctx->dpyAttr[dpy].fd = Writeback::getInstance()->getFbFd();
-        private_handle_t *ohnd = (private_handle_t *)list->outbuf;
-        Writeback::getInstance()->configureDpyInfo(ohnd->width, ohnd->height);
-        setListStats(ctx, list, dpy);
-
-        if(ctx->mMDPComp[dpy]->prepare(ctx, list) < 0) {
-            const int fbZ = 0;
-            ctx->mFBUpdate[dpy]->prepareAndValidate(ctx, list, fbZ);
+            if(ctx->mMDPComp[dpy]->prepare(ctx, list) < 0) {
+                const int fbZ = 0;
+                ctx->mFBUpdate[dpy]->prepareAndValidate(ctx, list, fbZ);
+            }
+        } else {
+            /* Virtual Display is in Pause state.
+             * Mark all application layers as OVERLAY so that
+             * GPU will not compose.
+             */
+            for(size_t i = 0 ;i < (size_t)(list->numHwLayers - 1); i++) {
+                hwc_layer_1_t *layer = &list->hwLayers[i];
+                layer->compositionType = HWC_OVERLAY;
+            }
         }
     }
     return 0;
@@ -137,7 +150,9 @@
         uint32_t last = list->numHwLayers - 1;
         hwc_layer_1_t *fbLayer = &list->hwLayers[last];
 
-        if(ctx->dpyAttr[dpy].connected) {
+        if(ctx->dpyAttr[dpy].connected
+                && (!ctx->dpyAttr[dpy].isPause))
+        {
             private_handle_t *ohnd = (private_handle_t *)list->outbuf;
             int format = ohnd->format;
             if (format == HAL_PIXEL_FORMAT_RGBA_8888)
@@ -194,6 +209,36 @@
     return ret;
 }
 
+void HWCVirtualVDS::pause(hwc_context_t* ctx, int dpy) {
+    {
+        Locker::Autolock _l(ctx->mDrawLock);
+        ctx->dpyAttr[dpy].isActive = true;
+        ctx->dpyAttr[dpy].isPause = true;
+        ctx->proc->invalidate(ctx->proc);
+    }
+    usleep(ctx->dpyAttr[HWC_DISPLAY_PRIMARY].vsync_period
+            * 2 / 1000);
+    return;
+}
+
+void HWCVirtualVDS::resume(hwc_context_t* ctx, int dpy) {
+    {
+        Locker::Autolock _l(ctx->mDrawLock);
+        ctx->dpyAttr[dpy].isConfiguring = true;
+        ctx->dpyAttr[dpy].isActive = true;
+        ctx->proc->invalidate(ctx->proc);
+    }
+    usleep(ctx->dpyAttr[HWC_DISPLAY_PRIMARY].vsync_period
+            * 2 / 1000);
+    //At this point external has all the pipes it would need.
+    {
+        Locker::Autolock _l(ctx->mDrawLock);
+        ctx->dpyAttr[dpy].isPause = false;
+        ctx->proc->invalidate(ctx->proc);
+    }
+    return;
+}
+
 /* Implementation for HWCVirtualV4L2 class */
 
 int HWCVirtualV4L2::prepare(hwc_composer_device_1 *dev,
@@ -294,3 +339,56 @@
 
     return ret;
 }
+
+void HWCVirtualV4L2::pause(hwc_context_t* ctx, int dpy) {
+    {
+        Locker::Autolock _l(ctx->mDrawLock);
+        ctx->dpyAttr[dpy].isActive = true;
+        ctx->dpyAttr[dpy].isPause = true;
+        ctx->proc->invalidate(ctx->proc);
+    }
+    usleep(ctx->dpyAttr[HWC_DISPLAY_PRIMARY].vsync_period
+            * 2 / 1000);
+    // At this point all the pipes used by External have been
+    // marked as UNSET.
+    {
+        Locker::Autolock _l(ctx->mDrawLock);
+        // Perform commit to unstage the pipes.
+        if (!Overlay::displayCommit(ctx->dpyAttr[dpy].fd)) {
+            ALOGE("%s: display commit fail! for %d dpy",
+                    __FUNCTION__, dpy);
+        }
+    }
+    return;
+}
+
+void HWCVirtualV4L2::resume(hwc_context_t* ctx, int dpy){
+    //Treat Resume as Online event
+    //Since external didnt have any pipes, force primary to give up
+    //its pipes; we don't allow inter-mixer pipe transfers.
+    {
+        Locker::Autolock _l(ctx->mDrawLock);
+
+        // A dynamic resolution change (DRC) can be made for a WiFi
+        // display. In order to support the resolution change, we
+        // need to reconfigure the corresponding display attributes.
+        // Since DRC is only on WiFi display, we only need to call
+        // configure() on the VirtualDisplay device.
+        //TODO: clean up
+        if(dpy == HWC_DISPLAY_VIRTUAL)
+            ctx->mVirtualDisplay->configure();
+
+        ctx->dpyAttr[dpy].isConfiguring = true;
+        ctx->dpyAttr[dpy].isActive = true;
+        ctx->proc->invalidate(ctx->proc);
+    }
+    usleep(ctx->dpyAttr[HWC_DISPLAY_PRIMARY].vsync_period
+            * 2 / 1000);
+    //At this point external has all the pipes it would need.
+    {
+        Locker::Autolock _l(ctx->mDrawLock);
+        ctx->dpyAttr[dpy].isPause = false;
+        ctx->proc->invalidate(ctx->proc);
+    }
+    return;
+}
diff --git a/libhwcomposer/hwc_virtual.h b/libhwcomposer/hwc_virtual.h
index 26f401f..6bc3898 100644
--- a/libhwcomposer/hwc_virtual.h
+++ b/libhwcomposer/hwc_virtual.h
@@ -22,6 +22,7 @@
 #define HWC_VIRTUAL
 
 #include <hwc_utils.h>
+#include <virtual.h>
 
 namespace qhwc {
 namespace ovutils = overlay::utils;
@@ -39,6 +40,8 @@
     virtual void init(hwc_context_t *ctx) = 0;
     virtual void destroy(hwc_context_t *ctx, size_t numDisplays,
                        hwc_display_contents_1_t** displays) = 0;
+    virtual void pause(hwc_context_t* ctx, int dpy) = 0;
+    virtual void resume(hwc_context_t* ctx, int dpy) = 0;
 };
 
 class HWCVirtualVDS : public HWCVirtualBase {
@@ -59,6 +62,8 @@
     // during virtual display disconnect.
     virtual void destroy(hwc_context_t *ctx, size_t numDisplays,
                        hwc_display_contents_1_t** displays);
+    virtual void pause(hwc_context_t* ctx, int dpy);
+    virtual void resume(hwc_context_t* ctx, int dpy);
 };
 
 class HWCVirtualV4L2 : public HWCVirtualBase {
@@ -80,6 +85,8 @@
     // during virtual display disconnect. This function is no-op for V4L2 design
     virtual void destroy(hwc_context_t *, size_t ,
                        hwc_display_contents_1_t** ) {};
+    virtual void pause(hwc_context_t* ctx, int dpy);
+    virtual void resume(hwc_context_t* ctx, int dpy);
 };
 
 }; //namespace
diff --git a/libhwcomposer/hwc_vpuclient.cpp b/libhwcomposer/hwc_vpuclient.cpp
deleted file mode 100644
index 6904efc..0000000
--- a/libhwcomposer/hwc_vpuclient.cpp
+++ /dev/null
@@ -1,964 +0,0 @@
-/*
- * Copyright (c) 2013-2014 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.  INNO 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 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER INCONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING INANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include <dlfcn.h>
-#include "hwc_vpuclient.h"
-#include <binder/Parcel.h>
-#include "hwc_fbupdate.h"
-#include <vpu/vpu.h>
-
-using namespace vpu;
-using namespace android;
-using namespace overlay::utils;
-namespace ovutils = overlay::utils;
-
-namespace qhwc {
-
-VPUClient::VPUClient(hwc_context_t *ctx)
-{
-    mVPULib = dlopen("libvpu.so", RTLD_NOW);
-    VPU* (*getObject)();
-
-    mVPU = NULL;
-    if (mVPULib == NULL) {
-        ALOGE("%s: Cannot open libvpu.so object", __FUNCTION__);
-        return;
-    }
-
-    *(void **) &getObject =  dlsym(mVPULib, "getObject");
-    if (getObject) {
-        mVPU = getObject();
-        ALOGI("Initializing VPU client..");
-
-       // calling vpu init
-        if (mVPU->init() == NO_ERROR) {
-            // passing display attributes to libvpu
-            ALOGD_IF(isDebug(), "%s: VFM init successful!", __FUNCTION__);
-
-            DispAttr_t attr;
-            attr.width = ctx->dpyAttr[HWC_DISPLAY_PRIMARY].xres;
-            attr.height = ctx->dpyAttr[HWC_DISPLAY_PRIMARY].yres;
-            attr.fp100s = (ctx->dpyAttr[HWC_DISPLAY_PRIMARY].vsync_period) ?
-              1000000000/(ctx->dpyAttr[HWC_DISPLAY_PRIMARY].vsync_period/100):0;
-            mVPU->setDisplayAttr((DISPLAY_ID)HWC_DISPLAY_PRIMARY, attr);
-
-            ALOGD_IF(isDebug(),"%s: Display attr: width:%d height:%d fp100s:%d",
-                    __FUNCTION__, attr.width, attr.height, attr.fp100s);
-
-            // memsetting the pipe structure to 0
-            memset(mProp, 0, sizeof(mProp));
-
-            mDebugLogs = 0;
-            // enable logs
-            char property[PROPERTY_VALUE_MAX];
-            if ( property_get("debug.vpuclient.logs", property, NULL) > 0 )
-                mDebugLogs = atoi(property);
-
-            // allocating memory for LayerList
-            for (int i = 0; i < HWC_NUM_DISPLAY_TYPES; ++i)
-                vList[i] = (LayerList*) malloc(sizeof(LayerList));
-        }
-        else {
-            ALOGE("Error: VPU init failed!");
-            mVPU = NULL;
-        }
-    }
-}
-
-VPUClient::~VPUClient()
-{
-    // freeing LayerList
-    for (int i = 0; i < HWC_NUM_DISPLAY_TYPES; ++i) {
-        if (vList[i])
-            free(vList[i]);
-    }
-
-    void (*destroy) (VPU*);
-    *(void **) &destroy = dlsym(mVPULib, "deleteObject");
-    dlclose(mVPULib);
-}
-
-void setLayer(hwc_layer_1_t *layer, Layer *vLayer)
-{
-    // setting handle info in vLayer
-    vLayer->handle = (private_handle_t *)(layer->handle);
-
-    if (vLayer->handle) {
-        vLayer->srcStride.width = getWidth(vLayer->handle);
-        vLayer->srcStride.height = getHeight(vLayer->handle);
-    }
-
-    // setting source crop
-    hwc_rect_t sourceRect = integerizeSourceCrop(layer->sourceCropf);
-    vLayer->srcRect.left = sourceRect.left;
-    vLayer->srcRect.top  = sourceRect.top;
-    vLayer->srcRect.right = sourceRect.right;
-    vLayer->srcRect.bottom = sourceRect.bottom;
-
-    // setting destination crop
-    vLayer->tgtRect.left = layer->displayFrame.left;
-    vLayer->tgtRect.top = layer->displayFrame.top;
-    vLayer->tgtRect.right = layer->displayFrame.right;
-    vLayer->tgtRect.bottom = layer->displayFrame.bottom;
-
-    if (layer->flags & HWC_GEOMETRY_CHANGED)
-        vLayer->inFlags |= GEOMETRY_CHANGED;
-
-    vLayer->acquireFenceFd = layer->acquireFenceFd;
-
-    if (layer->compositionType == HWC_FRAMEBUFFER_TARGET || isSkipLayer(layer))
-        vLayer->inFlags |= SKIP_LAYER;
-}
-
-int VPUClient::setupVpuSession(hwc_context_t *ctx, int display,
-                                            hwc_display_contents_1_t* list)
-{
-    memset(vList[display], 0, sizeof(LayerList));
-    memset(mProp, 0, sizeof(mProp));
-    mNumVpuLayers = 0;
-
-    // setting up the layer
-    LayerList *vpuList = vList[display];
-    vpuList->numLayers = list->numHwLayers;
-    for (unsigned int i=0; i<(list->numHwLayers); ++i) {
-        hwc_layer_1_t *layer = &list->hwLayers[i];
-        Layer *vLayer = &vpuList->layers[i];
-        VpuLayerProp* prop = &mProp[display][i];
-
-        // Storing the sourceCropf, as it's going to be changed for overlay Set
-        // will be restored after overlay set in prepare.
-        prop->sourceCropf = layer->sourceCropf;
-
-        // filling up the vpu list
-        setLayer(layer, vLayer);
-        ALOGD_IF(isDebug2(), "%s:Done setting lyr:%d for VFM", __FUNCTION__, i);
-    }
-
-    if (mVPU->setupVpuSession((DISPLAY_ID)display, vpuList) != NO_ERROR) {
-        //error in vpu prepare
-        ALOGE("%s: ERROR in VPU::setupVpuSession", __FUNCTION__);
-        return -1;
-    }
-    ALOGD_IF(isDebug2(), "%s: Done VFM: setupVpuSession", __FUNCTION__);
-
-    mGpuFallback = true;
-    LayerProp *layerProp = ctx->layerProp[display];
-    // check if the pipeID is already set for this layer, then will need to
-    // ensure that it is reserved in overlay
-    for (unsigned int i=0; i<(vpuList->numLayers); ++i) {
-        hwc_layer_1_t *layer = &list->hwLayers[i];
-        Layer *vLayer = &vpuList->layers[i];
-        VpuLayerProp* prop = &mProp[display][i];
-
-        if (vLayer->outFlags & VPU_LAYER) {
-            ALOGD_IF(isDebug(), "%s: VPU supported layer:%d", __FUNCTION__, i);
-
-            mNumVpuLayers++;
-            mGpuFallback = false;
-            // Reserving the pipe used in last iteration for the same layer
-            if ((vLayer->outFlags & RESERVE_PREV_PIPES) &&
-                                            vLayer->sDestPipes.numPipes > 0) {
-                prop->pipeCount = vLayer->sDestPipes.numPipes;
-                if (prop->pipeCount == 1) {
-                    setPipeId(prop, vLayer->sDestPipes.pipe[0]);
-                    ALOGD_IF(isDebug(), "%s: VPU: Reserved pipe:%d",
-                            __FUNCTION__, prop->pipeID[0]);
-                }
-                else if (prop->pipeCount == 2) {
-                    setPipeId(prop, vLayer->sDestPipes.pipe[0],
-                                                    vLayer->sDestPipes.pipe[1]);
-                    ALOGD_IF(isDebug(), "%s: VPU: Reserved lpipe:%d, rpipe:%d",
-                            __FUNCTION__, prop->pipeID[0], prop->pipeID[1]);
-                }
-                else {
-                    ALOGE("%s: Invalid pipeCount for resevation", __FUNCTION__);
-                }
-            }
-            else {
-                ALOGD_IF(isDebug(), "%s: 1st vid frame for VPU", __FUNCTION__);
-                prop->firstBuffer = true;
-            }
-
-            // marking the layer pipes for vpu.
-            prop->vpuLayer = true;
-            prop->layer = layer;
-            layer->flags |= HWC_VPU_PIPE;
-
-            // getting image width and height
-            prop->width = layer->displayFrame.right - layer->displayFrame.left;
-            prop->height = layer->displayFrame.bottom - layer->displayFrame.top;
-
-            //setting source crop = dest crop (only for layers drawn by vpu,
-            // since we know it will be scaled up/down by vpu)
-            layer->sourceCropf.left = 0.0;
-            layer->sourceCropf.top = 0.0;
-            layer->sourceCropf.right = (float) prop->width;
-            layer->sourceCropf.bottom = (float) prop->height;
-
-            // setting the flag so that mdpComp wont recognize it as the MDPCOMP
-            layerProp[i].mFlags |= HWC_VPUCOMP;
-
-            // TODO: need to get the proper solution for color fill
-
-            // storing locally the vpu supported format from VFM
-            prop->format = vLayer->vpuOutPixFmt;
-            ALOGD_IF(isDebug(), "%s: MDP: sourceCropf: w:%d h:%d format:%d",
-                    __FUNCTION__, prop->width, prop->height, prop->format);
-        }
-    }
-    return 0;
-}
-
-bool VPUClient::allocResLayerPipes(hwc_context_t* ctx, int dpy,
-                                         hwc_display_contents_1_t* list)
-{
-    overlay::Overlay& ov = *ctx->mOverlay;
-    for (unsigned int i=0; i<(list->numHwLayers); ++i) {
-        int pipeid = -1;
-        VpuLayerProp* prop = &mProp[dpy][i];
-
-        // checking if there is already a reserved pipe for this layer
-        // then use the same allocated pipe for this layer
-        getPipeId(prop, pipeid);
-
-        if (pipeid != -1) {
-            // there is a reserved pipe for this layer.
-            ovutils::eDest dest = ov.reservePipe(pipeid);
-            if (dest == ovutils::OV_INVALID) {
-                ALOGE("%s: Unable to get reserved pipe: layer#%d",
-                        __FUNCTION__, i);
-                return false;
-            }
-
-            // setting dest locally
-            setDest(prop, dest);
-            ALOGD_IF(isDebug(), "%s: Reserving pipe:%d, dest:%d ", __FUNCTION__,
-                    pipeid, dest);
-        }
-        else {
-            ALOGD_IF(isDebug2(), "%s: No reserved pipe for layer:%d",
-                    __FUNCTION__, i);
-        }
-    }
-    return true;
-}
-
-bool VPUClient::allocLayerPipes(hwc_context_t* ctx, int dpy,
-                                         hwc_display_contents_1_t* list)
-{
-    // checking if the pipes are reserved for any layer,
-    // if yes, then updating the index of the pipes
-    if (!allocResLayerPipes(ctx, dpy, list)) {
-        ALOGE("%s: Reserved pipe alloc failed", __FUNCTION__);
-        return false;
-    }
-
-    for (unsigned int i=0; i<(list->numHwLayers); ++i) {
-        hwc_layer_1_t* layer = &list->hwLayers[i];
-        private_handle_t *hnd = (private_handle_t *)layer->handle;
-        VpuLayerProp* prop = &mProp[dpy][i];
-        int pipe = -1;
-        overlay::Overlay& ov = *ctx->mOverlay;
-
-        // only care about the layers supported by VPU
-        if (!prop->vpuLayer)
-            continue;
-
-        // continue if this layer has reserved pipe
-        getPipeId(prop, pipe);
-        if (pipe != -1)
-            continue;
-
-        ovutils::eDest dest = ov.nextPipe(ovutils::OV_MDP_PIPE_VG, dpy,
-                overlay::Overlay::MIXER_DEFAULT);
-        if (dest == ovutils::OV_INVALID) {
-            ALOGE("%s: Unable to allocate pipe for layer#%d", __FUNCTION__, i);
-            return false;
-        }
-
-        // setting dest locally
-        setDest(prop, dest);
-        ALOGD_IF(isDebug(), "%s: Newly allocated pipe_dest:%d", __FUNCTION__,
-                dest);
-    }
-    return true;
-}
-
-bool VPUClient::allocResLayerPipesSplit(hwc_context_t* ctx, int dpy,
-                                         hwc_display_contents_1_t* list)
-{
-    overlay::Overlay& ov = *ctx->mOverlay;
-    for (unsigned int i=0; i<(list->numHwLayers); ++i) {
-        int lpipeid = -1;
-        int rpipeid = -1;
-        VpuLayerProp* prop = &mProp[dpy][i];
-
-        // checking if there is already a reserved pipe for this layer
-        // then use the same allocated pipe for this layer
-        getPipeId(prop, lpipeid, rpipeid);
-
-        if (lpipeid != -1 && rpipeid != -1) {
-            ovutils::eDest ldest = ov.reservePipe(lpipeid);
-            if (ldest == ovutils::OV_INVALID) {
-                ALOGD_IF(isDebug(), "%s: Unable to get reserved pipe-lsplit: "
-                         "layer#%d", __FUNCTION__, i);
-                return false;
-            }
-
-            ovutils::eDest rdest = ov.reservePipe(rpipeid);
-            if (rdest == ovutils::OV_INVALID) {
-                ALOGD_IF(isDebug(), "%s: Unable to get reserved pipe-rsplit: "
-                         "layer#%d", __FUNCTION__, i);
-                return false;
-            }
-
-            setDest(prop, ldest, rdest);
-            ALOGD_IF(isDebug(), "%s: Reserve lpipe:%d, ldest:%d, rpipe:%d, "
-                    "rdest:%d", __FUNCTION__, lpipeid, ldest, rpipeid, rdest);
-        }
-        else if (lpipeid != -1 || rpipeid != -1) {
-            ALOGE("%s: Bug: only one pipe reserved!", __FUNCTION__);
-            return false;
-        }
-    }
-    return true;
-}
-
-bool VPUClient::allocLayerPipesSplit(hwc_context_t* ctx, int dpy,
-                                         hwc_display_contents_1_t* list)
-{
-    // checking if the pipes are reserved for any layer,
-    // if yes, then updating the index of the pipes
-    if (!allocResLayerPipesSplit(ctx, dpy, list)) {
-        ALOGE("%s: Reserved pipe alloc failed", __FUNCTION__);
-        return false;
-    }
-
-    for (unsigned int i=0; i<(list->numHwLayers); ++i) {
-        hwc_layer_1_t* layer = &list->hwLayers[i];
-        private_handle_t *hnd = (private_handle_t *)layer->handle;
-        VpuLayerProp* prop = &mProp[dpy][i];
-        int lpipe, rpipe;
-        overlay::Overlay& ov = *ctx->mOverlay;
-
-        // only care about the layers supported by VPU
-        if (!prop->vpuLayer)
-            continue;
-
-        // only care about the layers supported by VPU
-        getPipeId(prop, lpipe, rpipe);
-        if (lpipe != -1 && rpipe != -1)
-            continue;
-
-        ovutils::eDest ldest = ov.nextPipe(ovutils::OV_MDP_PIPE_VG, dpy,
-                overlay::Overlay::MIXER_LEFT);
-        if (ldest == ovutils::OV_INVALID) {
-            ALOGE("%s: Unable to allocate pipe for layer#%d", __FUNCTION__, i);
-            return false;
-        }
-
-        ovutils::eDest rdest = ov.nextPipe(ovutils::OV_MDP_PIPE_VG, dpy,
-                overlay::Overlay::MIXER_RIGHT);
-        if (rdest == ovutils::OV_INVALID) {
-            ALOGE("%s: Unable to allocate pipe for layer#%d", __FUNCTION__, i);
-            return false;
-        }
-
-        // setting dests locally
-        setDest(prop, ldest, rdest);
-        ALOGD_IF(isDebug(), "%s: Newly allocated ldest:%d rdest:%d",
-                __FUNCTION__, ldest, rdest);
-    }
-    return true;
-}
-
-bool VPUClient::configureLayers(hwc_context_t* ctx, int dpy,
-                                         hwc_display_contents_1_t* list)
-{
-    for (unsigned int i=0; i<(list->numHwLayers); ++i) {
-        VpuLayerProp* prop = &mProp[dpy][i];
-        hwc_layer_1_t* layer = &list->hwLayers[i];
-
-        if (!prop->vpuLayer)
-            continue;
-
-        eMdpFlags mdpFlags = OV_MDP_BACKEND_COMPOSITION;
-        eZorder zOrder = static_cast<eZorder>(i);
-        eIsFg isFg = IS_FG_OFF;
-        setPipeCount(prop, 1);
-        eDest dest = (eDest) getDest(prop, 0);
-
-        ALOGD_IF(isDebug(),"%s: configuring: layer:%p z_order:%d dest_pipe:%d",
-                __FUNCTION__, layer, zOrder, dest);
-
-        if (configureNonSplit(ctx, layer, dpy, mdpFlags, zOrder, isFg,
-                            dest, NULL)) {
-            ALOGE("%s: Failed to configure overlay for layer %d",
-                    __FUNCTION__, i);
-            return false;
-        }
-        ALOGD_IF(isDebug2(), "%s: layer:%d configured!", __FUNCTION__, i);
-
-        // Pipe is successfully allocated for this layer; retrieving it from
-        // overlay
-        int pipeId = ctx->mOverlay->getPipeId((eDest) getDest(prop, 0));
-        setPipeId(prop, pipeId);
-
-        ALOGD_IF(isDebug(), "%s: allocated pipe:%d layer:%d", __FUNCTION__,
-                    pipeId, i);
-    }
-    return true;
-}
-
-bool VPUClient::configureLayersSplit(hwc_context_t* ctx, int dpy,
-                                         hwc_display_contents_1_t* list)
-{
-    for (unsigned int i=0; i<(list->numHwLayers); ++i) {
-        VpuLayerProp* prop = &mProp[dpy][i];
-        hwc_layer_1_t* layer = &list->hwLayers[i];
-
-        if (!prop->vpuLayer)
-            continue;
-
-        eMdpFlags mdpFlags = OV_MDP_BACKEND_COMPOSITION;
-        eZorder zOrder = static_cast<eZorder>(i);
-        eIsFg isFg = IS_FG_OFF;
-        setPipeCount(prop, 2);
-        eDest ldest = (eDest) getDest(prop, 0);
-        eDest rdest = (eDest) getDest(prop, 1);
-
-        ALOGD_IF(isDebug(),"%s: configuring: layer:%p z_order:%d dest_pipeL:%d"
-                "dest_pipeR:%d",__FUNCTION__, layer, zOrder, ldest, rdest);
-
-        if (configureSplit(ctx, layer, dpy, mdpFlags, zOrder, isFg, ldest,
-                            rdest, NULL)) {
-            ALOGE("%s: Failed to configure overlay for layer %d",
-                    __FUNCTION__, i);
-            return false;
-        }
-        ALOGD_IF(isDebug2(), "%s: layer:%d configured!", __FUNCTION__, i);
-
-        // Pipe is successfully allocated for this layer; retrieving it from
-        // overlay
-        int lpipeId = ctx->mOverlay->getPipeId((eDest) getDest(prop, 0));
-        int rpipeId = ctx->mOverlay->getPipeId((eDest) getDest(prop, 1));
-        setPipeId(prop, lpipeId, rpipeId);
-
-        ALOGD_IF(isDebug(), "%s: allocated l-pipe:%d - r-pipe:%d for layer:%d",
-                __FUNCTION__, lpipeId, rpipeId, i);
-    }
-    return true;
-}
-
-void VPUClient::setMDPCompLayerFlags(hwc_context_t *ctx, int dpy,
-                                   hwc_display_contents_1_t* list)
-{
-    LayerProp *layerProp = ctx->layerProp[dpy];
-
-    // disableGpu only disables gpu for video layer. The expected behavior is to
-    // show a blank screen in case VPU doesnt support a video layer, and gpu
-    // fallback is disabled by the user.
-    bool disableGpu = false;
-    char property[PROPERTY_VALUE_MAX];
-    if ((property_get("persist.hwc.noGpuFallback", property, NULL) > 0) &&
-        (!strncmp(property, "1", PROPERTY_VALUE_MAX ) ||
-            (!strncasecmp(property,"true", PROPERTY_VALUE_MAX )))) {
-        ALOGD_IF(isDebug(), "%s: GPU fallback is disabled through prop",
-                __FUNCTION__);
-        disableGpu = true;
-    }
-
-    // no layers are supported by vpu
-    if (mGpuFallback && !disableGpu) {
-        ALOGD_IF(isDebug(), "%s: No VPU supported layers - Falling back to GPU",
-                __FUNCTION__);
-        return;
-    }
-
-    for (unsigned int i=0; i<(list->numHwLayers); ++i) {
-        hwc_layer_1_t* layer = &(list->hwLayers[i]);
-        VpuLayerProp* prop = &mProp[dpy][i];
-        private_handle_t *hnd = (private_handle_t *)layer->handle;
-
-        // mark vpu layers as HWC_OVERLAY, and those video layers that
-        // are not supported by vpu and gpu fallback is disabled by the
-        // user.
-        if (prop->vpuLayer || (isYuvBuffer(hnd) && disableGpu)) {
-            layer->compositionType = HWC_OVERLAY;
-            layer->hints |= HWC_HINT_CLEAR_FB;
-            ALOGD_IF(isDebug(), "%s: Marking layer:%d as overlay",
-                    __FUNCTION__, i);
-        }
-    }
-}
-
-int VPUClient::prepare(hwc_context_t *ctx, int display,
-            hwc_display_contents_1_t* list)
-{
-    if (!mVPU) {
-        return -1;
-    }
-
-    const int numLayers = ctx->listStats[display].numAppLayers;
-    //number of app layers exceeds MAX_NUM_APP_LAYERS fall back to GPU
-    //do not cache the information for next draw cycle.
-    if (numLayers > MAX_NUM_APP_LAYERS) {
-        ALOGE("%s: Number of App layers exceeded the limit ",__FUNCTION__);
-        return -1;
-    }
-
-    if (setupVpuSession(ctx, display, list)) {
-        ALOGD_IF(isDebug(), "%s: Vpu session setup failed! ",__FUNCTION__);
-        return -1;
-    }
-
-    LayerProp *layerProp = ctx->layerProp[display];
-    bool isSplit = isDisplaySplit(ctx, display);
-    ALOGD_IF(isDebug2(), "%s: Split Pipe:%d ", __FUNCTION__,
-            isSplit ? 1 : 0);
-
-    // setting up the layer
-    LayerList *vpuList = vList[display];
-    vpuList->numLayers = list->numHwLayers;
-
-    // Prepare FB Update at z-0
-    if (numLayers > mNumVpuLayers) {
-        if (!ctx->mFBUpdate[display]->prepare(ctx, list, mNumVpuLayers)) {
-            ALOGD_IF(isDebug(), "%s configure framebuffer failed",
-                    __FUNCTION__);
-            return -1;
-        }
-    }
-
-    // Allocate pipe for layers
-    if (!isSplit ? !allocLayerPipes(ctx, display, list) :
-                 !allocLayerPipesSplit(ctx, display, list)) {
-        ALOGD_IF(isDebug(), "%s: Unable to allocate MDP pipes", __FUNCTION__);
-        return -1;
-    }
-
-    // Configure layers
-    if (!isSplit ? !configureLayers(ctx, display, list) :
-                 !configureLayersSplit(ctx, display, list)) {
-        ALOGD_IF(isDebug(), "%s: Unable to configure MDP pipes", __FUNCTION__);
-        return -1;
-    }
-
-    // Set layer flags for MDP/VPU composition
-    setMDPCompLayerFlags(ctx, display, list);
-
-    for (unsigned int i=0; i<(list->numHwLayers); ++i) {
-        VpuLayerProp* prop = &mProp[display][i];
-
-        if (!prop->vpuLayer)
-            continue;
-
-        hwc_layer_1_t *layer = &list->hwLayers[i];
-        Layer *vLayer = &vpuList->layers[i];
-
-        // re-storing the sourceCropf, as it was changed in setVpuSession for
-        // overlay set
-        layer->sourceCropf = prop->sourceCropf;
-
-        // updating the pipe info inside vfm list
-        if ( prop->pipeCount > 0  && prop->pipeCount <= MAX_PIPES_PER_LAYER ) {
-            vLayer->sDestPipes.numPipes = prop->pipeCount;
-
-            for (int j=0; j < prop->pipeCount; ++j) {
-                // Setting pipe for VPU
-                vLayer->sDestPipes.pipe[j] = prop->pipeID[j];
-            }
-        }
-    }
-
-    if (mVPU->prepare((DISPLAY_ID)display, vpuList) != NO_ERROR) {
-        //error in vpu prepare
-        ALOGE("%s: ERROR in VPU::prepare", __func__);
-        return -1;
-    }
-    return 0;
-}
-
-bool VPUClient::queueHandle(hwc_context_t* ctx, VpuLayerProp* prop,
-        private_handle_t* hnd)
-{
-    overlay::Overlay& ov = *ctx->mOverlay;
-    ovutils::eDest dest = (eDest) getDest(prop, 0);
-
-    int fd = hnd->fd;
-    uint32_t offset = hnd->offset;
-
-    if (dest != ovutils::OV_INVALID) {
-        if (!ov.queueBuffer(fd, offset, dest)) {
-            ALOGE("%s: queueBuffer failed", __FUNCTION__);
-            return false;
-        }
-        else {
-            ALOGD_IF(isDebug(), "%s: Queue handle successful: hnd:0x%x "
-                    "dest:%d", __FUNCTION__, (unsigned int) hnd, dest);
-        }
-    }
-    else {
-        ALOGE("%s: Invalid Dest: dest:%d", __FUNCTION__, dest);
-        return false;
-    }
-    return true;
-}
-
-bool VPUClient::queueHandleSplit(hwc_context_t* ctx, VpuLayerProp* prop,
-        private_handle_t* hnd)
-{
-    overlay::Overlay& ov = *ctx->mOverlay;
-    ovutils::eDest ldest = (eDest) getDest(prop, 0);
-    ovutils::eDest rdest = (eDest) getDest(prop, 1);
-
-    int fd = hnd->fd;
-    uint32_t offset = hnd->offset;
-
-    // play left mixer
-    if (ldest != ovutils::OV_INVALID) {
-        ALOGD_IF(isDebug(), "%s: Queuing left mixer", __FUNCTION__);
-        if (!ov.queueBuffer(fd, offset, ldest)) {
-            ALOGE("%s: queueBuffer failed for left mixer ", __FUNCTION__);
-            return false;
-        }
-        else {
-            ALOGD_IF(isDebug(), "%s: Queue left-handle successful: hnd:0x%x "
-                    "ldest:%d", __FUNCTION__, (unsigned int) hnd, ldest);
-        }
-    }
-    else {
-        ALOGE("%s: Invalid l-Split Dest", __FUNCTION__);
-        return false;
-    }
-
-    // play right mixer
-    if (rdest != ovutils::OV_INVALID) {
-        ALOGD_IF(isDebug(), "%s: Queuing right mixer", __FUNCTION__);
-        if (!ov.queueBuffer(fd, offset, rdest)) {
-            ALOGE("%s: queueBuffer failed for right mixer ", __FUNCTION__);
-            return false;
-        }
-        else {
-            ALOGD_IF(isDebug(), "%s: Queue right-handle successful: hnd:0x%x "
-                    "rdest:%d", __FUNCTION__, (unsigned int) hnd, rdest);
-        }
-    }
-    else {
-        ALOGE("%s: Invalid r-Split Dest", __FUNCTION__);
-        return false;
-    }
-    return true;
-}
-
-bool VPUClient::drawDummyLayers(hwc_context_t* ctx, int dpy,
-                    hwc_display_contents_1_t* list)
-{
-    int err = 0;
-    for (unsigned int i=0; i<(list->numHwLayers); ++i) {
-        VpuLayerProp* prop = &mProp[dpy][i];
-
-        if (!prop->vpuLayer)
-            continue;
-
-        // displaying blank screen for the first frame
-        if (prop->firstBuffer) {
-            ALOGD_IF(isDebug(), "%s: Displaying first (blank) frame",
-                    __FUNCTION__);
-            prop->firstBuffer = false;
-
-            if (mHnd[dpy][i] != NULL)
-                free_buffer(mHnd[dpy][i]);
-
-            // TO-FIX: out dummy buffer is currently allocated based on
-            // RGB888 format
-            err = alloc_buffer(&mHnd[dpy][i], prop->width, prop->height,
-                HAL_PIXEL_FORMAT_RGB_888, GRALLOC_USAGE_PRIVATE_IOMMU_HEAP);
-            if (err == -1) {
-                ALOGE("%s: Dummy buffer allocation failed!", __FUNCTION__);
-                return false;
-            }
-
-            private_handle_t* hnd = mHnd[dpy][i];
-            if (prop->format == HAL_PIXEL_FORMAT_RGB_888) {
-                ALOGD_IF(isDebug(), "%s: Format: RGB888", __FUNCTION__);
-                memset((void*)hnd->base, 0x0, hnd->size);
-            }
-            else if (prop->format ==
-                    HAL_PIXEL_FORMAT_YCbCr_422_I_10BIT_COMPRESSED) {
-                ALOGD_IF(isDebug(), "%s: Format: 10BIT_BWC", __FUNCTION__);
-                memset((void*)hnd->base, 0xaa, hnd->size);
-            }
-            else {
-                ALOGE("%s: Error! Wrong VPU out format - layer:%d",
-                        __FUNCTION__, i);
-                return false;
-            }
-
-            bool isSplit = isDisplaySplit(ctx, dpy);
-            if (!isSplit ? !queueHandle(ctx, prop, hnd) :
-                        !queueHandleSplit(ctx, prop, hnd)) {
-                ALOGD_IF(isDebug(), "%s: Error in queue handle: layer:%d",
-                        __FUNCTION__, i);
-                return false;
-            }
-            else {
-                ALOGD_IF(isDebug(), "%s: queue handle successful: hnd:0x%x "
-                        "layer:%d", __FUNCTION__, (unsigned int) hnd, i);
-            }
-        }
-    }
-    return true;
-}
-
-int VPUClient::predraw(hwc_context_t *ctx, int display,
-                                        hwc_display_contents_1_t* list)
-{
-    if (!mVPU) {
-        return -1;
-    }
-
-    if (!ctx || !list) {
-        ALOGE("%s: invalid contxt or list",__FUNCTION__);
-        return -1;
-    }
-
-    if (ctx->listStats[display].numAppLayers > MAX_NUM_APP_LAYERS) {
-        ALOGE("%s: Exceeding max layer count", __FUNCTION__);
-        return -1;
-    }
-
-    // Although all the video layers are composed through VPU, but still need to
-    // queue the first buffer (blank screen) to mdp in order to initialize the
-    // settings
-    if (!drawDummyLayers(ctx, display, list)) {
-        ALOGE("%s: Failed to draw the first layer through overlay",
-                __FUNCTION__);
-        return -1;
-    }
-    return 0;
-}
-
-int VPUClient::draw(hwc_context_t *ctx, int display,
-                                        hwc_display_contents_1_t* list)
-{
-    if (!mVPU) {
-        return -1;
-    }
-
-    LayerList *vpuList = vList[display];
-    vpuList->numLayers = list->numHwLayers;
-
-    for (unsigned int i=0; i<(list->numHwLayers); ++i) {
-        hwc_layer_1_t *layer = &list->hwLayers[i];
-        Layer *vLayer = &vpuList->layers[i];
-
-        // setting layer info again for the update content.
-        setLayer(layer, vLayer);
-    }
-
-    // queuing the buffer to VPU
-    if (mVPU->draw((DISPLAY_ID)display, vpuList) != NO_ERROR) {
-        //error in vpu draw
-        ALOGE("%s: ERROR in VPU::draw", __func__);
-        return -1;
-    }
-
-    ALOGD_IF(isDebug2(), "%s: Done VFM draw", __FUNCTION__);
-
-    LayerProp *layerProp = ctx->layerProp[display];
-    // setting releaseFenceFd for the vpu layer
-    for (unsigned int i=0; i<(vpuList->numLayers); ++i) {
-
-        VpuLayerProp* prop = &mProp[display][i];
-        if (!prop->vpuLayer)
-            continue;
-
-        hwc_layer_1_t *layer = &list->hwLayers[i];
-        Layer *vLayer = &vpuList->layers[i];
-
-        // TODO: Fix properly once the releaseFenceFd is implemented
-        layer->releaseFenceFd = vLayer->releaseFenceFd;
-        ALOGD_IF(isDebug(), "%s: releaseFd:%d for layer:%d", __FUNCTION__,
-                layer->releaseFenceFd, i);
-    }
-    return 0;
-}
-
-int VPUClient::getLayerIdx(int dpy, hwc_layer_1_t *layer)
-{
-    for (int i=0; i < MAX_NUM_APP_LAYERS; ++i) {
-        VpuLayerProp* prop = &mProp[dpy][i];
-
-        if (!prop->vpuLayer)
-            continue;
-
-        if (prop->layer == layer) {
-            ALOGD_IF(isDebug2(), "%s: OUT - dpy:%d", __FUNCTION__, dpy);
-            return i;
-        }
-    }
-    return -1;
-}
-
-int VPUClient::getLayerFormat(int dpy, hwc_layer_1_t *layer)
-{
-    if (!mVPU) {
-        return -1;
-    }
-
-    int idx = -1;
-    if ((idx = getLayerIdx(dpy, layer)) == -1) {
-        ALOGE("%s: Layer not found!", __FUNCTION__);
-        return -1;
-    }
-
-    VpuLayerProp* prop = &mProp[dpy][idx];
-    ALOGD_IF(isDebug(), "%s: layer:%d format:0x%x", __FUNCTION__, idx,
-            (unsigned int) prop->format);
-
-    return prop->format;
-}
-
-int VPUClient::getWidth(int dpy, hwc_layer_1_t *layer)
-{
-    if (!mVPU) {
-        return -1;
-    }
-
-    int idx = -1;
-    if ((idx = getLayerIdx(dpy, layer)) == -1) {
-        ALOGE("%s: Layer not found!", __FUNCTION__);
-        return -1;
-    }
-
-    VpuLayerProp* prop = &mProp[dpy][idx];
-    ALOGD_IF(isDebug(), "%s: layer:%d width:%d", __FUNCTION__, idx,
-            prop->width);
-
-    return prop->width;
-}
-
-int VPUClient::getHeight(int dpy, hwc_layer_1_t *layer)
-{
-    if (!mVPU) {
-        return -1;
-    }
-
-    int idx = -1;
-    if ((idx = getLayerIdx(dpy, layer)) == -1) {
-        ALOGE("%s: Layer not found!", __FUNCTION__);
-        return -1;
-    }
-
-    VpuLayerProp* prop = &mProp[dpy][idx];
-    ALOGD_IF(isDebug(), "%s: layer:%d height:%d", __FUNCTION__, idx,
-            prop->height);
-
-    return prop->height;
-}
-
-// TODO: getter function has side-effect. Need to cleanup
-void VPUClient::getPipeId(VpuLayerProp* prop, int &pipe)
-{
-    pipe = (prop->pipeCount == 1) ? (prop->pipeID[0]) : -1;
-}
-
-void VPUClient::getPipeId(VpuLayerProp* prop, int &lPipe, int &rPipe)
-{
-    lPipe = (prop->pipeCount == 2) ? (prop->pipeID[0]) : -1;
-    rPipe = (prop->pipeCount == 2) ? (prop->pipeID[1]) : -1;
-}
-
-int VPUClient::getDest(VpuLayerProp* prop, int pipenum)
-{
-    return (prop->pipeCount > 0) ? (prop->dest[pipenum]) : -1;
-}
-
-void VPUClient::setPipeCount(VpuLayerProp* prop, int count)
-{
-    prop->pipeCount = count;
-}
-
-void VPUClient::setPipeId(VpuLayerProp* prop, int lPipeId, int rPipeId)
-{
-    prop->pipeCount = 2;
-    prop->pipeID[0] = lPipeId;
-    prop->pipeID[1] = rPipeId;
-}
-
-void VPUClient::setPipeId(VpuLayerProp* prop, int pipeId)
-{
-    prop->pipeCount = 1;
-    prop->pipeID[0] = pipeId;
-}
-
-void VPUClient::setDest(VpuLayerProp* prop, int lDest, int rDest)
-{
-    prop->dest[0] = lDest;
-    prop->dest[1] = rDest;
-}
-
-void VPUClient::setDest(VpuLayerProp* prop, int dest)
-{
-    prop->dest[0] = dest;
-}
-
-bool VPUClient::supportedVPULayer(VpuLayerProp* prop)
-{
-    if (!prop->vpuLayer)
-        return false;
-
-    return true;
-}
-
-bool VPUClient::supportedVPULayer(int dpy, hwc_layer_1_t *layer)
-{
-    if (!mVPU) {
-        return false;
-    }
-
-    int idx = -1;
-    if ((idx = getLayerIdx(dpy, layer)) == -1) {
-        ALOGD_IF(isDebug(), "%s: Layer not found!", __FUNCTION__);
-        return false;
-    }
-    return true;
-}
-
-int VPUClient::processCommand(uint32_t command,
-                              const Parcel* inParcel, Parcel* outParcel)
-{
-    if (!mVPU)
-        return 0;
-
-    return mVPU->processCommand(command, inParcel, outParcel);
-}
-
-}; // namespace qhwc
diff --git a/libhwcomposer/hwc_vpuclient.h b/libhwcomposer/hwc_vpuclient.h
deleted file mode 100644
index bb2a4b6..0000000
--- a/libhwcomposer/hwc_vpuclient.h
+++ /dev/null
@@ -1,144 +0,0 @@
-/*
-* Copyright (c) 2013-2014 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 SERVICES; 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.
-*/
-
-#ifndef HWC_VPU_H
-#define HWC_VPU_H
-
-#include <sys/types.h>
-#include "hwc_utils.h"
-
-#define MAX_PIPES_PER_LAYER 2
-
-//Forward declarations
-struct hwc_display_contents_1;
-typedef struct hwc_display_contents_1 hwc_display_contents_1_t;
-struct hwc_layer_1;
-typedef struct hwc_layer_1 hwc_layer_1_t;
-struct hwc_context_t;
-
-namespace vpu {
-class VPU;
-struct LayerList;
-};
-namespace android {
-class Parcel;
-};
-
-namespace qhwc {
-
-class VPUClient {
-public:
-    VPUClient(hwc_context_t *ctx);
-
-    ~VPUClient();
-
-    int setupVpuSession(hwc_context_t *ctx, int display,
-                            hwc_display_contents_1_t* list);
-    int prepare(hwc_context_t *ctx, int display,
-                            hwc_display_contents_1_t* list);
-    int predraw(hwc_context_t *ctx, int display,
-                            hwc_display_contents_1_t* list);
-    int draw(hwc_context_t *ctx, int display,
-                            hwc_display_contents_1_t* list);
-    int processCommand(uint32_t command,
-        const android::Parcel* inParcel, android::Parcel* outParcel);
-    int getLayerFormat(int dpy, hwc_layer_1_t *layer);
-    int getWidth(int dpy, hwc_layer_1_t *layer);
-    int getHeight(int dpy, hwc_layer_1_t *layer);
-    bool supportedVPULayer(int dpy, hwc_layer_1_t *layer);
-
-private:
-    vpu::VPU *mVPU;
-    void* mVPULib;
-
-    /* VpuLayerProp struct:
-     *  This struct corresponds to only one layer
-     *  pipeCount: number of pipes required for a layer
-     *  pipeID[]: pipe ids corresponding to the layer
-     */
-    struct VpuLayerProp {
-        int format;
-        int width;
-        int height;
-        int pipeCount;
-        bool vpuLayer;
-        bool firstBuffer;
-        hwc_frect_t sourceCropf;
-        hwc_layer_1_t *layer;
-        int pipeID[MAX_PIPES_PER_LAYER];
-        int dest[MAX_PIPES_PER_LAYER];
-    };
-    int mNumVpuLayers;  /* total num of vpu supported layers */
-    int mGpuFallback;   /* all layers are not supported by vpu */
-
-    VpuLayerProp mProp[HWC_NUM_DISPLAY_TYPES][MAX_NUM_APP_LAYERS];
-    int mDebugLogs;
-    private_handle_t *mHnd[HWC_NUM_DISPLAY_TYPES][MAX_NUM_APP_LAYERS];
-    vpu::LayerList *vList[HWC_NUM_DISPLAY_TYPES];
-
-    /* Private debug functions */
-    int32_t isDebug() { return (mDebugLogs >= 1); }
-    int32_t isDebug2() { return (mDebugLogs >= 2); }
-
-    /* Private Get/Set functions */
-    int getLayerIdx(int dpy, hwc_layer_1_t *layer);
-    void getPipeId(VpuLayerProp* prop, int &pipe);
-    void getPipeId(VpuLayerProp* prop, int &lPipe, int &rPipe);
-    int getDest(VpuLayerProp* prop, int pipenum);
-    void setPipeCount(VpuLayerProp* prop, int count);
-    void setPipeId(VpuLayerProp* prop, int lPipeId, int rPipeId);
-    void setPipeId(VpuLayerProp* prop, int pipeId);
-    void setDest(VpuLayerProp* prop, int lDest, int rDest);
-    void setDest(VpuLayerProp* prop, int dest);
-
-    /* Private implementations */
-    bool supportedVPULayer(VpuLayerProp* prop);
-    bool allocResLayerPipes(hwc_context_t* ctx, int dpy,
-                            hwc_display_contents_1_t* list);
-    bool allocLayerPipes(hwc_context_t* ctx, int dpy,
-                            hwc_display_contents_1_t* list);
-    bool allocResLayerPipesSplit(hwc_context_t* ctx, int dpy,
-                            hwc_display_contents_1_t* list);
-    bool allocLayerPipesSplit(hwc_context_t* ctx, int dpy,
-                            hwc_display_contents_1_t* list);
-    bool configureLayers(hwc_context_t* ctx, int dpy,
-                            hwc_display_contents_1_t* list);
-    bool configureLayersSplit(hwc_context_t* ctx, int dpy,
-                            hwc_display_contents_1_t* list);
-    void setMDPCompLayerFlags(hwc_context_t *ctx, int dpy,
-                            hwc_display_contents_1_t* list);
-    bool drawDummyLayers(hwc_context_t* ctx, int dpy,
-                            hwc_display_contents_1_t* list);
-    bool queueHandle(hwc_context_t* ctx, VpuLayerProp* prop,
-                            private_handle_t* hnd);
-    bool queueHandleSplit(hwc_context_t* ctx, VpuLayerProp* prop,
-                            private_handle_t* hnd);
-}; // class VPU
-}; // namespace qhwc
-#endif /* end of include guard: HWC_VPU_H */
diff --git a/libhwcomposer/hwc_vsync.cpp b/libhwcomposer/hwc_vsync.cpp
index 3729f21..6781e7b 100644
--- a/libhwcomposer/hwc_vsync.cpp
+++ b/libhwcomposer/hwc_vsync.cpp
@@ -37,6 +37,10 @@
 
 #define HWC_VSYNC_THREAD_NAME "hwcVsyncThread"
 #define MAX_SYSFS_FILE_PATH             255
+#define PANEL_ON_STR "panel_power_on ="
+#define ARRAY_LENGTH(array) (sizeof((array))/sizeof((array)[0]))
+const int MAX_DATA = 64;
+bool logvsync = false;
 
 int hwc_vsync_control(hwc_context_t* ctx, int dpy, int enable)
 {
@@ -51,6 +55,40 @@
     return ret;
 }
 
+static void handle_vsync_event(hwc_context_t* ctx, int dpy, char *data)
+{
+    // extract timestamp
+    uint64_t timestamp = 0;
+    if (!strncmp(data, "VSYNC=", strlen("VSYNC="))) {
+        timestamp = strtoull(data + strlen("VSYNC="), NULL, 0);
+    }
+    // send timestamp to SurfaceFlinger
+    ALOGD_IF (logvsync, "%s: timestamp %"PRIu64" sent to SF for dpy=%d",
+            __FUNCTION__, timestamp, dpy);
+    ctx->proc->vsync(ctx->proc, dpy, timestamp);
+}
+
+static void handle_blank_event(hwc_context_t* ctx, int dpy, char *data)
+{
+    if (!strncmp(data, PANEL_ON_STR, strlen(PANEL_ON_STR))) {
+        uint32_t poweron = strtoul(data + strlen(PANEL_ON_STR), NULL, 0);
+        ALOGI("%s: dpy:%d panel power state: %d", __FUNCTION__, dpy, poweron);
+        ctx->dpyAttr[dpy].isActive = poweron ? true: false;
+    }
+}
+
+struct event {
+    const char* name;
+    void (*callback)(hwc_context_t* ctx, int dpy, char *data);
+};
+
+struct event event_list[] =  {
+    { "vsync_event", handle_vsync_event },
+    { "show_blank_event", handle_blank_event },
+};
+
+#define num_events ARRAY_LENGTH(event_list)
+
 static void *vsync_loop(void *param)
 {
     hwc_context_t * ctx = reinterpret_cast<hwc_context_t *>(param);
@@ -60,14 +98,11 @@
     setpriority(PRIO_PROCESS, 0, HAL_PRIORITY_URGENT_DISPLAY +
                 android::PRIORITY_MORE_FAVORABLE);
 
-    const int MAX_DATA = 64;
     char vdata[MAX_DATA];
-    bool logvsync = false;
-
-    struct pollfd pfd[2];
-    int fb_fd[2];
-    uint64_t timestamp[2] = {0,0};
-    int num_displays;
+    //Number of physical displays
+    //We poll on all the nodes.
+    int num_displays = HWC_NUM_DISPLAY_TYPES - 1;
+    struct pollfd pfd[num_displays][num_events];
 
     char property[PROPERTY_VALUE_MAX];
     if(property_get("debug.hwc.fakevsync", property, NULL) > 0) {
@@ -80,69 +115,62 @@
             logvsync = true;
     }
 
-    if (ctx->mExtDisplay->isConnected())
-        num_displays = 2;
-    else
-        num_displays = 1;
+    char node_path[MAX_SYSFS_FILE_PATH];
 
-    char vsync_node_path[MAX_SYSFS_FILE_PATH];
     for (int dpy = HWC_DISPLAY_PRIMARY; dpy < num_displays; dpy++) {
-        snprintf(vsync_node_path, sizeof(vsync_node_path),
-                "/sys/class/graphics/fb%d/vsync_event",
-                dpy == HWC_DISPLAY_PRIMARY ? 0 :
-                overlay::Overlay::getInstance()->
-                                getFbForDpy(HWC_DISPLAY_EXTERNAL));
-        ALOGI("%s: Reading vsync for dpy=%d from %s", __FUNCTION__, dpy,
-                vsync_node_path);
-        fb_fd[dpy] = open(vsync_node_path, O_RDONLY);
+        for(size_t ev = 0; ev < num_events; ev++) {
+            snprintf(node_path, sizeof(node_path),
+                    "/sys/class/graphics/fb%d/%s",
+                    dpy == HWC_DISPLAY_PRIMARY ? 0 :
+                    overlay::Overlay::getInstance()->
+                    getFbForDpy(HWC_DISPLAY_EXTERNAL),
+                    event_list[ev].name);
 
-        if (fb_fd[dpy] < 0) {
-            // Make sure fb device is opened before starting this thread so this
-            // never happens.
-            ALOGE ("%s:not able to open vsync node for dpy=%d, %s",
-                    __FUNCTION__, dpy, strerror(errno));
-            if (dpy == HWC_DISPLAY_PRIMARY) {
-                ctx->vstate.fakevsync = true;
-                break;
+            ALOGI("%s: Reading event %zu for dpy %d from %s", __FUNCTION__,
+                    ev, dpy, node_path);
+            pfd[dpy][ev].fd = open(node_path, O_RDONLY);
+
+            if (dpy == HWC_DISPLAY_PRIMARY && pfd[dpy][ev].fd < 0) {
+                // Make sure fb device is opened before starting
+                // this thread so this never happens.
+                ALOGE ("%s:unable to open event node for dpy=%d event=%zu, %s",
+                        __FUNCTION__, dpy, ev, strerror(errno));
+                if (ev == 0) {
+                    ctx->vstate.fakevsync = true;
+                    //XXX: Blank events don't work with fake vsync,
+                    //but we shouldn't be running on fake vsync anyway.
+                    break;
+                }
             }
-        }
-        // Read once from the fds to clear the first notify
-        pread(fb_fd[dpy], vdata , MAX_DATA, 0);
 
-        pfd[dpy].fd = fb_fd[dpy];
-        if (pfd[dpy].fd >= 0)
-            pfd[dpy].events = POLLPRI | POLLERR;
+            pread(pfd[dpy][ev].fd, vdata , MAX_DATA, 0);
+            if (pfd[dpy][ev].fd >= 0)
+                pfd[dpy][ev].events = POLLPRI | POLLERR;
+        }
     }
 
     if (LIKELY(!ctx->vstate.fakevsync)) {
         do {
-            int err = poll(pfd, num_displays, -1);
+            int err = poll(*pfd, num_displays * num_events, -1);
             if(err > 0) {
                 for (int dpy = HWC_DISPLAY_PRIMARY; dpy < num_displays; dpy++) {
-                    if (pfd[dpy].revents & POLLPRI) {
-                        int len = pread(pfd[dpy].fd, vdata, MAX_DATA, 0);
-                        if (UNLIKELY(len < 0)) {
-                            // If the read was just interrupted - it is not a
-                            // fatal error. Just continue in this case
-                            ALOGE ("%s: Unable to read vsync for dpy=%d : %s",
-                                    __FUNCTION__, dpy, strerror(errno));
-                            continue;
+                    for(size_t ev = 0; ev < num_events; ev++) {
+                        if (pfd[dpy][ev].revents & POLLPRI) {
+                            err = pread(pfd[dpy][ev].fd, vdata, MAX_DATA, 0);
+                            if (UNLIKELY(err < 0)) {
+                                // If the read was just interrupted - it is not
+                                // a fatal error. Just continue in this case
+                                ALOGE ("%s: Unable to read event:%zu for \
+                                        dpy=%d : %s",
+                                        __FUNCTION__, ev, dpy, strerror(errno));
+                                continue;
+                            }
+                            event_list[ev].callback(ctx, dpy, vdata);
                         }
-                        // extract timestamp
-                        if (!strncmp(vdata, "VSYNC=", strlen("VSYNC="))) {
-                            timestamp[dpy] = strtoull(vdata + strlen("VSYNC="),
-                                    NULL, 0);
-                        }
-                        // send timestamp to SurfaceFlinger
-                        ALOGD_IF (logvsync,
-                            "%s: timestamp %"PRIu64" sent to SF for dpy=%d",
-                            __FUNCTION__, timestamp[dpy], dpy);
-                        ctx->proc->vsync(ctx->proc, dpy, timestamp[dpy]);
                     }
                 }
-
             } else {
-                ALOGE("%s: vsync poll failed errno: %s", __FUNCTION__,
+                ALOGE("%s: poll failed errno: %s", __FUNCTION__,
                         strerror(errno));
                 continue;
             }
@@ -157,16 +185,17 @@
         //Also, fake vsync is delivered only for the primary display.
         do {
             usleep(16666);
-            timestamp[HWC_DISPLAY_PRIMARY] = systemTime();
-            ctx->proc->vsync(ctx->proc, HWC_DISPLAY_PRIMARY,
-                    timestamp[HWC_DISPLAY_PRIMARY]);
+            uint64_t timestamp = systemTime();
+            ctx->proc->vsync(ctx->proc, HWC_DISPLAY_PRIMARY, timestamp);
 
         } while (true);
     }
 
     for (int dpy = HWC_DISPLAY_PRIMARY; dpy <= HWC_DISPLAY_EXTERNAL; dpy++ ) {
-        if(fb_fd[dpy] >= 0)
-            close (fb_fd[dpy]);
+        for( size_t event = 0; event < num_events; event++) {
+            if(pfd[dpy][event].fd >= 0)
+                close (pfd[dpy][event].fd);
+        }
     }
 
     return NULL;
diff --git a/liboverlay/overlayUtils.h b/liboverlay/overlayUtils.h
index c0066f3..c2649f3 100644
--- a/liboverlay/overlayUtils.h
+++ b/liboverlay/overlayUtils.h
@@ -272,7 +272,6 @@
     OV_MDSS_MDP_BWC_EN = MDP_BWC_EN,
     OV_MDSS_MDP_DUAL_PIPE = MDSS_MDP_DUAL_PIPE,
     OV_MDP_SOLID_FILL = MDP_SOLID_FILL,
-    OV_MDP_VPU_PIPE = MDP_VPU_PIPE,
 };
 
 enum eZorder {
diff --git a/libqdutils/mdp_version.cpp b/libqdutils/mdp_version.cpp
index ed21b2c..a757e69 100644
--- a/libqdutils/mdp_version.cpp
+++ b/libqdutils/mdp_version.cpp
@@ -45,7 +45,7 @@
     MDSS_MDP_HW_REV_103 = 0x10030000, //8084
     MDSS_MDP_HW_REV_104 = 0x10040000, //Next version
     MDSS_MDP_HW_REV_105 = 0x10050000, //Next version
-    MDSS_MDP_HW_REV_107 = 0x10070000, //Next version
+    MDSS_MDP_HW_REV_106 = 0x10060000, //8x16
     MDSS_MDP_HW_REV_200 = 0x20000000, //8092
     MDSS_MDP_HW_REV_206 = 0x20060000, //Future
 };
@@ -53,6 +53,7 @@
 enum mdp_rev {
     MDSS_MDP_HW_REV_104 = 0x10040000, //Next version
     MDSS_MDP_HW_REV_206 = 0x20060000, //Future
+    MDSS_MDP_HW_REV_107 = 0x10070000, //Next version
 };
 #endif
 
@@ -67,14 +68,13 @@
     mMDPUpscale = 0;
     mMDPDownscale = 0;
     mMacroTileEnabled = false;
-    mPanelType = NO_PANEL;
     mLowBw = 0;
     mHighBw = 0;
     mSourceSplit = false;
+    mRGBHasNoScalar = false;
 
-    if(!updatePanelInfo()) {
-        ALOGE("Unable to read Primary Panel Information");
-    }
+    updatePanelInfo();
+
     if(!updateSysFsInfo()) {
         ALOGE("Unable to read display sysfs node");
     }
@@ -114,10 +114,12 @@
 }
 // This function reads the sysfs node to read the primary panel type
 // and updates information accordingly
-bool MDPVersion::updatePanelInfo() {
+void  MDPVersion::updatePanelInfo() {
     FILE *displayDeviceFP = NULL;
+    FILE *panelInfoNodeFP = NULL;
     const int MAX_FRAME_BUFFER_NAME_SIZE = 128;
     char fbType[MAX_FRAME_BUFFER_NAME_SIZE];
+    char panelInfo[MAX_FRAME_BUFFER_NAME_SIZE];
     const char *strCmdPanel = "mipi dsi cmd panel";
     const char *strVideoPanel = "mipi dsi video panel";
     const char *strLVDSPanel = "lvds panel";
@@ -128,21 +130,62 @@
         fread(fbType, sizeof(char), MAX_FRAME_BUFFER_NAME_SIZE,
                 displayDeviceFP);
         if(strncmp(fbType, strCmdPanel, strlen(strCmdPanel)) == 0) {
-            mPanelType = MIPI_CMD_PANEL;
+            mPanelInfo.mType = MIPI_CMD_PANEL;
         }
         else if(strncmp(fbType, strVideoPanel, strlen(strVideoPanel)) == 0) {
-            mPanelType = MIPI_VIDEO_PANEL;
+            mPanelInfo.mType = MIPI_VIDEO_PANEL;
         }
         else if(strncmp(fbType, strLVDSPanel, strlen(strLVDSPanel)) == 0) {
-            mPanelType = LVDS_PANEL;
+            mPanelInfo.mType = LVDS_PANEL;
         }
         else if(strncmp(fbType, strEDPPanel, strlen(strEDPPanel)) == 0) {
-            mPanelType = EDP_PANEL;
+            mPanelInfo.mType = EDP_PANEL;
         }
         fclose(displayDeviceFP);
-        return true;
-    }else {
-        return false;
+    } else {
+        ALOGE("Unable to read Primary Panel Information");
+    }
+
+    panelInfoNodeFP = fopen("/sys/class/graphics/fb0/msm_fb_panel_info", "r");
+    if(panelInfoNodeFP){
+        size_t len = PAGE_SIZE;
+        ssize_t read;
+        char *readLine = (char *) malloc (len);
+        while((read = getline((char **)&readLine, &len,
+                              panelInfoNodeFP)) != -1) {
+            int token_ct=0;
+            char *tokens[10];
+            memset(tokens, 0, sizeof(tokens));
+
+            if(!tokenizeParams(readLine, TOKEN_PARAMS_DELIM, tokens,
+                               &token_ct)) {
+                if(!strncmp(tokens[0], "pu_en", strlen("pu_en"))) {
+                    mPanelInfo.mPartialUpdateEnable = atoi(tokens[1]);
+                    ALOGI("PartialUpdate status: %s",
+                          mPanelInfo.mPartialUpdateEnable? "Enabled" :
+                          "Disabled");
+                }
+                if(!strncmp(tokens[0], "xalign", strlen("xalign"))) {
+                    mPanelInfo.mLeftAlign = atoi(tokens[1]);
+                    ALOGI("Left Align: %d", mPanelInfo.mLeftAlign);
+                }
+                if(!strncmp(tokens[0], "walign", strlen("walign"))) {
+                    mPanelInfo.mWidthAlign = atoi(tokens[1]);
+                    ALOGI("Width Align: %d", mPanelInfo.mWidthAlign);
+                }
+                if(!strncmp(tokens[0], "ystart", strlen("ystart"))) {
+                    mPanelInfo.mTopAlign = atoi(tokens[1]);
+                    ALOGI("Top Align: %d", mPanelInfo.mTopAlign);
+                }
+                if(!strncmp(tokens[0], "halign", strlen("halign"))) {
+                    mPanelInfo.mHeightAlign = atoi(tokens[1]);
+                    ALOGI("Height Align: %d", mPanelInfo.mHeightAlign);
+                }
+            }
+        }
+        fclose(panelInfoNodeFP);
+    } else {
+        ALOGE("Failed to open msm_fb_panel_info node");
     }
 }
 
@@ -223,6 +266,10 @@
                                     strlen("src_split"))) {
                             mSourceSplit = true;
                         }
+                        else if(!strncmp(tokens[i], "non_scalar_rgb",
+                                    strlen("non_scalar_rgb"))) {
+                            mRGBHasNoScalar = true;
+                        }
                     }
                 }
             }
@@ -295,6 +342,10 @@
     return mSourceSplit;
 }
 
+bool MDPVersion::isRGBScalarSupported() const {
+    return (!mRGBHasNoScalar);
+}
+
 bool MDPVersion::is8x26() {
     return (mMdpRev >= MDSS_MDP_HW_REV_101 and
             mMdpRev < MDSS_MDP_HW_REV_102);
@@ -315,5 +366,10 @@
             mMdpRev < MDSS_MDP_HW_REV_206);
 }
 
+bool MDPVersion::is8x16() {
+    return (mMdpRev >= MDSS_MDP_HW_REV_106 and
+            mMdpRev < MDSS_MDP_HW_REV_107);
+}
+
 }; //namespace qdutils
 
diff --git a/libqdutils/mdp_version.h b/libqdutils/mdp_version.h
index 5e36291..aab8643 100644
--- a/libqdutils/mdp_version.h
+++ b/libqdutils/mdp_version.h
@@ -92,13 +92,25 @@
     friend class MDPVersion;
 };
 
+struct PanelInfo {
+    char mType;                  // Smart or Dumb
+    int mPartialUpdateEnable;    // Partial update feature
+    int mLeftAlign;              // ROI left alignment restriction
+    int mWidthAlign;             // ROI width alignment restriction
+    int mTopAlign;               // ROI top alignment restriction
+    int mHeightAlign;            // ROI height alignment restriction
+    PanelInfo() : mType(NO_PANEL), mPartialUpdateEnable(0),
+    mLeftAlign(0), mWidthAlign(0), mTopAlign(0), mHeightAlign(0){}
+    friend class MDPVersion;
+};
+
 class MDPVersion : public Singleton <MDPVersion>
 {
 public:
     MDPVersion();
     ~MDPVersion();
     int getMDPVersion() {return mMDPVersion;}
-    char getPanelType() {return mPanelType;}
+    char getPanelType() {return mPanelInfo.mType;}
     bool hasOverlay() {return mHasOverlay;}
     uint8_t getTotalPipes() {
         return (uint8_t)(mRGBPipes + mVGPipes + mDMAPipes);
@@ -113,23 +125,29 @@
     bool supportsMacroTile();
     int getLeftSplit() { return mSplit.left(); }
     int getRightSplit() { return mSplit.right(); }
+    int isPartialUpdateEnabled() { return mPanelInfo.mPartialUpdateEnable; }
+    int getLeftAlign() { return mPanelInfo.mLeftAlign; }
+    int getWidthAlign() { return mPanelInfo.mWidthAlign; }
+    int getTopAlign() { return mPanelInfo.mTopAlign; }
+    int getHeightAlign() { return mPanelInfo.mHeightAlign; }
     unsigned long getLowBw() { return mLowBw; }
     unsigned long getHighBw() { return mHighBw; }
     bool isSrcSplit() const;
+    bool isRGBScalarSupported() const;
     bool is8x26();
     bool is8x74v2();
     bool is8084();
     bool is8092();
+    bool is8x16();
 
 private:
     bool updateSysFsInfo();
-    bool updatePanelInfo();
+    void updatePanelInfo();
     bool updateSplitInfo();
     int tokenizeParams(char *inputParams, const char *delim,
                         char* tokenStr[], int *idx);
     int mFd;
     int mMDPVersion;
-    char mPanelType;
     bool mHasOverlay;
     uint32_t mMdpRev;
     uint8_t mRGBPipes;
@@ -140,9 +158,11 @@
     uint32_t mMDPUpscale;
     bool mMacroTileEnabled;
     Split mSplit;
+    PanelInfo mPanelInfo;
     unsigned long mLowBw; //kbps
     unsigned long mHighBw; //kbps
     bool mSourceSplit;
+    bool mRGBHasNoScalar;
 };
 }; //namespace qdutils
 #endif //INCLUDE_LIBQCOMUTILS_MDPVER
diff --git a/libqdutils/qdMetaData.cpp b/libqdutils/qdMetaData.cpp
index b736478..0390599 100644
--- a/libqdutils/qdMetaData.cpp
+++ b/libqdutils/qdMetaData.cpp
@@ -82,26 +82,6 @@
             break;
         case UPDATE_BUFFER_GEOMETRY:
             memcpy((void *)&data->bufferDim, param, sizeof(BufferDim_t));
-            break;
-        case PP_PARAM_VFM_DATA:
-        {
-            int32_t     indx = 0;
-            VfmData_t*  pVfmData = reinterpret_cast <VfmData_t *>(param);
-            int32_t     dataType = pVfmData->dataType;
-
-            if(dataType > 0){
-                indx = getVfmDataIdx(dataType);
-                if(indx < MAX_VFM_DATA_COUNT){
-                    data->vfmDataBitMap |= dataType;
-                    memcpy((void *)&data->vfmData[indx], param,
-                        sizeof(VfmData_t));
-                }else{
-                    ALOGE("unknown dataType %d", dataType);
-                }
-            }else{
-                ALOGE("invalid dataType in PP_PARAM_VFM_DATA %d", dataType);
-            }
-        }
         break;
         case UPDATE_COLOR_SPACE:
             data->colorSpace = *((ColorSpace_t *)param);
diff --git a/libqdutils/qdMetaData.h b/libqdutils/qdMetaData.h
index 3a0e615..3ebe782 100644
--- a/libqdutils/qdMetaData.h
+++ b/libqdutils/qdMetaData.h
@@ -35,19 +35,6 @@
 #endif
 
 #define MAX_IGC_LUT_ENTRIES 256
-#define MAX_VFM_DATA_SIZE   64 //bytes per data buffer
-#define MAX_VFM_DATA_COUNT  16 //number of data buffers
-
-/* This macro finds the index corresponding to a type */
-/* This is equivalent to indx = LOG_2(type) */
-inline int32_t getVfmDataIdx(int32_t type){
-    int32_t indx = 0, x = type;
-    while( x >> 1) {
-        x = (x >> 1);
-        indx++;
-    }
-    return indx;
-}
 
 enum ColorSpace_t{
     ITU_R_601,
@@ -80,11 +67,6 @@
     int32_t sliceHeight;
 };
 
-struct VfmData_t {
-    int32_t dataType;
-    char    data[MAX_VFM_DATA_SIZE];
-};
-
 struct MetaData_t {
     int32_t operation;
     int32_t interlaced;
@@ -95,8 +77,6 @@
     struct IGCData_t igcData;
     struct Sharp2Data_t Sharp2Data;
     int64_t timestamp;
-    int32_t vfmDataBitMap;
-    struct VfmData_t vfmData[MAX_VFM_DATA_COUNT];
     enum ColorSpace_t colorSpace;
 };
 
@@ -109,7 +89,6 @@
     PP_PARAM_SHARP2     = 0x0020,
     PP_PARAM_TIMESTAMP  = 0x0040,
     UPDATE_BUFFER_GEOMETRY = 0x0080,
-    PP_PARAM_VFM_DATA   = 0x0100,
     UPDATE_COLOR_SPACE = 0x0200,
 };
 
diff --git a/libqservice/IQService.h b/libqservice/IQService.h
index 33c3ca0..6c1bba6 100644
--- a/libqservice/IQService.h
+++ b/libqservice/IQService.h
@@ -50,8 +50,6 @@
         SET_HSIC_DATA,           // Set HSIC on dspp
         GET_DISPLAY_VISIBLE_REGION,  // Get the visibleRegion for dpy
         PAUSE_WFD,               // Pause/Resume WFD
-        VPU_COMMAND_LIST_START = 100, //Reserved block for VPU commands
-        VPU_COMMAND_LIST_END   = 200,
         COMMAND_LIST_END = 400,
     };