diff --git a/Android.mk b/Android.mk
index 1a285bf..44393b0 100644
--- a/Android.mk
+++ b/Android.mk
@@ -3,14 +3,10 @@
 
 ifneq ($(TARGET_IS_HEADLESS), true)
     display-hals += libcopybit liblight libmemtrack hdmi_cec \
-                    $(sdm-libs)/hwc $(sdm-libs)/hwc2 gpu_tonemapper libdrmutils libdisplayconfig
+                    $(sdm-libs)/hwc2 gpu_tonemapper libdrmutils libdisplayconfig
 endif
 
-ifneq ($(TARGET_USES_GRALLOC1), true)
-    display-hals += libgralloc
-else
-    display-hals += libgralloc1
-endif
+display-hals += libgralloc1
 
 ifeq ($(call is-vendor-board-platform,QCOM),true)
     include $(call all-named-subdir-makefiles,$(display-hals))
diff --git a/Makefile.am b/Makefile.am
index 781b836..8ecc86b 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -2,4 +2,4 @@
 
 ACLOCAL_AMFLAGS = -I m4
 
-SUBDIRS = libqservice libqdutils libgralloc sdm/libs/utils sdm/libs/core
+SUBDIRS = libqservice libqdutils sdm/libs/utils sdm/libs/core
diff --git a/common.mk b/common.mk
index b253c80..2318165 100644
--- a/common.mk
+++ b/common.mk
@@ -4,6 +4,7 @@
 #Common C flags
 common_flags := -DDEBUG_CALC_FPS -Wno-missing-field-initializers
 common_flags += -Wconversion -Wall -Werror -std=c++14
+common_flags += -DUSE_GRALLOC1
 ifeq ($(TARGET_IS_HEADLESS), true)
     common_flags += -DTARGET_HEADLESS
     LOCAL_CLANG := false
@@ -31,8 +32,8 @@
     common_flags += -DVIDEO_MODE_DEFER_RETIRE_FENCE
 endif
 
-ifeq ($(TARGET_USES_GRALLOC1), true)
-    common_flags += -DUSE_GRALLOC1
+ifneq (,$(filter userdebug eng, $(TARGET_BUILD_VARIANT)))
+    common_flags += -DUSER_DEBUG
 endif
 
 common_includes := system/core/base/include
diff --git a/configure.ac b/configure.ac
index 6fe7d0a..24c41fd 100644
--- a/configure.ac
+++ b/configure.ac
@@ -50,8 +50,7 @@
         Makefile \
         libqservice/Makefile \
         libqdutils/Makefile \
-        libgralloc/Makefile \
         sdm/libs/utils/Makefile \
         sdm/libs/core/Makefile
         ])
-AC_OUTPUT
\ No newline at end of file
+AC_OUTPUT
diff --git a/include/Android.mk b/include/Android.mk
index ec07dde..6aacfb8 100644
--- a/include/Android.mk
+++ b/include/Android.mk
@@ -16,11 +16,7 @@
                                  $(display_top)/libqdutils \
                                  $(display_top)/libqservice \
                                  $(display_top)/gpu_tonemapper \
-                                 $(display_top)/sdm/include
+                                 $(display_top)/sdm/include \
+                                 $(display_top)/libgralloc1
 
-ifeq ($(TARGET_USES_GRALLOC1), true)
-    LOCAL_EXPORT_C_INCLUDE_DIRS += $(display_top)/libgralloc1
-else
-    LOCAL_EXPORT_C_INCLUDE_DIRS += $(display_top)/libgralloc
-endif
 include $(BUILD_HEADER_LIBRARY)
diff --git a/libcopybit/Android.mk b/libcopybit/Android.mk
index 6e906c3..a363b85 100644
--- a/libcopybit/Android.mk
+++ b/libcopybit/Android.mk
@@ -20,34 +20,3 @@
 LOCAL_COPY_HEADERS            := copybit.h copybit_priv.h c2d2.h
 #Copy the headers regardless of whether copybit is built
 include $(BUILD_COPY_HEADERS)
-
-include $(CLEAR_VARS)
-ifneq ($(TARGET_USES_GRALLOC1), true)
-LOCAL_MODULE                  := copybit.$(TARGET_BOARD_PLATFORM)
-LOCAL_VENDOR_MODULE           := true
-LOCAL_MODULE_RELATIVE_PATH    := hw
-LOCAL_MODULE_TAGS             := optional
-LOCAL_C_INCLUDES              := $(common_includes) $(kernel_includes)
-LOCAL_SHARED_LIBRARIES        := $(common_libs) libdl libmemalloc
-LOCAL_CFLAGS                  := $(common_flags) -DLOG_TAG=\"qdcopybit\" -Wno-sign-conversion
-LOCAL_ADDITIONAL_DEPENDENCIES := $(common_deps)
-LOCAL_CLANG                   := true
-
-ifeq ($(TARGET_USES_C2D_COMPOSITION),true)
-    LOCAL_CFLAGS += -DCOPYBIT_Z180=1 -DC2D_SUPPORT_DISPLAY=1
-    LOCAL_SRC_FILES := copybit_c2d.cpp software_converter.cpp
-    include $(BUILD_SHARED_LIBRARY)
-else
-    ifneq ($(call is-chipset-in-board-platform,msm7630),true)
-        ifeq ($(call is-board-platform-in-list,$(MSM7K_BOARD_PLATFORMS)),true)
-            LOCAL_CFLAGS += -DCOPYBIT_MSM7K=1
-            LOCAL_SRC_FILES := software_converter.cpp copybit.cpp
-            include $(BUILD_SHARED_LIBRARY)
-        endif
-        ifeq ($(call is-board-platform-in-list, msm8610 msm8909),true)
-            LOCAL_SRC_FILES := software_converter.cpp copybit.cpp
-            include $(BUILD_SHARED_LIBRARY)
-        endif
-    endif
-endif
-endif
diff --git a/libdisplayconfig/DisplayConfig.cpp b/libdisplayconfig/DisplayConfig.cpp
index c55715b..29fcc94 100644
--- a/libdisplayconfig/DisplayConfig.cpp
+++ b/libdisplayconfig/DisplayConfig.cpp
@@ -170,7 +170,7 @@
     }
 
     int count = 0;
-    intf->getActiveConfig(MapDisplayType(dpy),
+    intf->getConfigCount(MapDisplayType(dpy),
         [&](const auto &tmpError, const auto &tmpCount) {
             if (tmpError) {
                 return;
diff --git a/libdrmutils/drm_interface.h b/libdrmutils/drm_interface.h
index 97c8ad8..35285ee 100644
--- a/libdrmutils/drm_interface.h
+++ b/libdrmutils/drm_interface.h
@@ -37,6 +37,7 @@
 
 #include "xf86drm.h"
 #include "xf86drmMode.h"
+#include <drm/msm_drm.h>
 
 namespace sde_drm {
 
@@ -131,6 +132,12 @@
    */
   PLANE_SET_ROTATION_DST_RECT,
   /*
+   * Op: Sets FB Secure mode for this plane.
+   * Arg: uint32_t - Plane ID
+   *      uint32_t - Value of the FB Secure mode.
+   */
+  PLANE_SET_FB_SECURE_MODE,
+  /*
    * Op: Activate or deactivate a CRTC
    * Arg: uint32_t - CRTC ID
    *      uint32_t - 1 to enable, 0 to disable
@@ -217,6 +224,18 @@
    */
   CRTC_SET_ROI,
   /*
+   * Op: Sets Security level for CRTC.
+   * Arg: uint32_t - CRTC ID
+   *      uint32_t - Security level
+   */
+  CRTC_SET_SECURITY_LEVEL,
+  /*
+   * Op: sets solid fill stages
+   * Arg: uint32_t - CRTC ID
+   *      Vector of DRMSolidfillStage
+   */
+  CRTC_SET_SOLIDFILL_STAGES,
+  /*
    * Op: Returns retire fence for this commit. Should be called after Commit() on
    * DRMAtomicReqInterface.
    * Arg: uint32_t - Connector ID
@@ -308,6 +327,7 @@
 struct DRMCrtcInfo {
   bool has_src_split;
   uint32_t max_blend_stages;
+  uint32_t max_solidfill_stages;
   QSEEDVersion qseed_version;
   SmartDMARevision smart_dma_rev;
   float ib_fudge_factor;
@@ -325,6 +345,7 @@
   uint32_t max_sde_clk;
   CompRatioMap comp_ratio_rt_map;
   CompRatioMap comp_ratio_nrt_map;
+  uint32_t hw_version;
 };
 
 enum struct DRMPlaneType {
@@ -400,6 +421,7 @@
   int hmin;
   bool roi_merge;
   DRMRotation panel_orientation;
+  drm_panel_hdr_properties panel_hdr_prop;
 };
 
 /* Identifier token for a display */
@@ -444,6 +466,26 @@
   uint64_t sep_lut = 0;
 };
 
+enum struct DRMSecureMode {
+  NON_SECURE,
+  SECURE,
+  NON_SECURE_DIR_TRANSLATION,
+  SECURE_DIR_TRANSLATION,
+};
+
+enum struct DRMSecurityLevel {
+  SECURE_NON_SECURE,
+  SECURE_ONLY,
+};
+
+struct DRMSolidfillStage {
+ DRMRect bounding_rect {};
+ bool is_exclusion_rect = false;
+ uint32_t color = 0xff000000; // in 8bit argb
+ uint32_t z_order = 0;
+ uint32_t plane_alpha = 0xff;
+};
+
 /* DRM Atomic Request Property Set.
  *
  * Helper class to create and populate atomic properties of DRM components
diff --git a/libdrmutils/drm_master.cpp b/libdrmutils/drm_master.cpp
index 09e0729..ff7770b 100644
--- a/libdrmutils/drm_master.cpp
+++ b/libdrmutils/drm_master.cpp
@@ -146,4 +146,11 @@
   return ret;
 }
 
+bool DRMMaster::IsRmFbRefCounted() {
+#ifdef DRM_IOCTL_MSM_RMFB2
+  return true;
+#endif
+  return false;
+}
+
 }  // namespace drm_utils
diff --git a/libdrmutils/drm_master.h b/libdrmutils/drm_master.h
index 52a8b02..18f51eb 100644
--- a/libdrmutils/drm_master.h
+++ b/libdrmutils/drm_master.h
@@ -71,6 +71,8 @@
    *   fd: Pointer to store master fd into
    */
   void GetHandle(int *fd) { *fd = dev_fd_; }
+  /* Returns true if the ref counted version of rmfb is being used */
+  bool IsRmFbRefCounted();
 
   /* Creates an instance of DRMMaster if it doesn't exist and initializes it. Threadsafe.
    * Input:
diff --git a/libgralloc/Android.mk b/libgralloc/Android.mk
deleted file mode 100644
index 86c0f04..0000000
--- a/libgralloc/Android.mk
+++ /dev/null
@@ -1,52 +0,0 @@
-# Copyright (C) 2008 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# Gralloc module
-LOCAL_PATH := $(call my-dir)
-include $(LOCAL_PATH)/../common.mk
-include $(CLEAR_VARS)
-
-LOCAL_MODULE                  := gralloc.$(TARGET_BOARD_PLATFORM)
-LOCAL_VENDOR_MODULE           := true
-LOCAL_MODULE_RELATIVE_PATH    := hw
-LOCAL_MODULE_TAGS             := optional
-LOCAL_C_INCLUDES              := $(common_includes) $(kernel_includes)
-LOCAL_HEADER_LIBRARIES        := display_headers
-LOCAL_SHARED_LIBRARIES        := $(common_libs) libmemalloc libqdMetaData libqdutils
-ifneq ($(TARGET_IS_HEADLESS), true)
-LOCAL_SHARED_LIBRARIES        += libGLESv1_CM
-endif
-LOCAL_CFLAGS                  := $(common_flags) -DLOG_TAG=\"qdgralloc\" -Wno-sign-conversion
-LOCAL_ADDITIONAL_DEPENDENCIES := $(common_deps) $(kernel_deps)
-LOCAL_SRC_FILES               := gpu.cpp gralloc.cpp framebuffer.cpp mapper.cpp
-LOCAL_COPY_HEADERS_TO         := $(common_header_export_path)
-LOCAL_COPY_HEADERS            := gralloc_priv.h gr.h adreno_utils.h
-
-include $(BUILD_SHARED_LIBRARY)
-
-# MemAlloc Library
-include $(CLEAR_VARS)
-
-LOCAL_MODULE                  := libmemalloc
-LOCAL_VENDOR_MODULE           := true
-LOCAL_MODULE_TAGS             := optional
-LOCAL_C_INCLUDES              := $(common_includes) $(kernel_includes)
-LOCAL_HEADER_LIBRARIES        := display_headers
-LOCAL_SHARED_LIBRARIES        := $(common_libs) libqdutils libdl
-LOCAL_CFLAGS                  := $(common_flags) -DLOG_TAG=\"qdmemalloc\" -Wno-sign-conversion
-LOCAL_ADDITIONAL_DEPENDENCIES := $(common_deps) $(kernel_deps)
-LOCAL_SRC_FILES               := ionalloc.cpp alloc_controller.cpp
-LOCAL_COPY_HEADERS            := alloc_controller.h memalloc.h
-
-include $(BUILD_SHARED_LIBRARY)
diff --git a/libgralloc/MODULE_LICENSE_APACHE2 b/libgralloc/MODULE_LICENSE_APACHE2
deleted file mode 100644
index e69de29..0000000
--- a/libgralloc/MODULE_LICENSE_APACHE2
+++ /dev/null
diff --git a/libgralloc/Makefile.am b/libgralloc/Makefile.am
deleted file mode 100644
index 3cf3960..0000000
--- a/libgralloc/Makefile.am
+++ /dev/null
@@ -1,42 +0,0 @@
-HEADER_PATH := ${WORKSPACE}/display/display-hal/include
-h_sources = alloc_controller.h \
-            memalloc.h
-
-cpp_sources = ionalloc.cpp \
-              alloc_controller.cpp
-
-memalloc_includedir = $(pkgincludedir)
-memalloc_include_HEADERS = $(h_sources)
-
-lib_LTLIBRARIES = libmemalloc.la
-libmemalloc_la_CC = @CC@
-libmemalloc_la_SOURCES = $(cpp_sources)
-libmemalloc_la_CFLAGS = $(COMMON_CFLAGS) -DLOG_TAG=\"qdmemalloc\"
-libmemalloc_la_CPPFLAGS = $(AM_CPPFLAGS)
-libmemalloc_la_LIBADD = ../libqdutils/libqdutils.la
-libmemalloc_la_LIBADD += -lhardware -lcutils -llog -lutils -ldl
-libmemalloc_la_LDFLAGS = -shared -avoid-version
-
-header_sources = gralloc_priv.h \
-                 gr.h \
-                 adreno_utils.h \
-                 $(HEADER_PATH)/color_metadata.h
-
-c_sources = gpu.cpp \
-            gralloc.cpp \
-            framebuffer.cpp \
-            mapper.cpp
-
-library_includedir = $(pkgincludedir)
-library_include_HEADERS = $(header_sources)
-
-lib_LTLIBRARIES += libgralloc.la
-libgralloc_la_CC = @CC@
-libgralloc_la_SOURCES = $(c_sources)
-libgralloc_la_CFLAGS = $(COMMON_CFLAGS) -DLOG_TAG=\"qdgralloc\"
-libgralloc_la_CPPFLAGS = $(AM_CPPFLAGS)
-libgralloc_la_LIBADD = ../libqdutils/libqdutils.la
-libgralloc_la_LIBADD += ../libqdutils/libqdMetaData.la
-libgralloc_la_LIBADD += -lhardware -lcutils -llog -lutils -lbinder
-libgralloc_la_LIBADD += libmemalloc.la
-libgralloc_la_LDFLAGS = -shared -avoid-version
diff --git a/libgralloc/NOTICE b/libgralloc/NOTICE
deleted file mode 100644
index 3237da6..0000000
--- a/libgralloc/NOTICE
+++ /dev/null
@@ -1,190 +0,0 @@
-
-   Copyright (c) 2008-2009, The Android Open Source Project
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
diff --git a/libgralloc/adreno_utils.h b/libgralloc/adreno_utils.h
deleted file mode 100644
index baecef9..0000000
--- a/libgralloc/adreno_utils.h
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
-* Copyright (c) 2015 - 2017, 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.
-*/
-
-// Adreno Pixel Formats
-typedef enum {
-
-    ADRENO_PIXELFORMAT_UNKNOWN       = 0,
-    ADRENO_PIXELFORMAT_R10G10B10A2_UNORM = 24,  // Vertex, Normalized GL_UNSIGNED_INT_10_10_10_2_OES
-    ADRENO_PIXELFORMAT_R8G8B8A8      = 28,
-    ADRENO_PIXELFORMAT_R8G8B8A8_SRGB = 29,
-    ADRENO_PIXELFORMAT_B5G6R5        = 85,
-    ADRENO_PIXELFORMAT_B5G5R5A1      = 86,
-    ADRENO_PIXELFORMAT_B8G8R8A8      = 90,
-    ADRENO_PIXELFORMAT_B8G8R8A8_SRGB = 91,
-    ADRENO_PIXELFORMAT_B8G8R8X8_SRGB = 93,
-    ADRENO_PIXELFORMAT_NV12          = 103,
-    ADRENO_PIXELFORMAT_P010          = 104,
-    ADRENO_PIXELFORMAT_YUY2          = 107,
-    ADRENO_PIXELFORMAT_B4G4R4A4      = 115,
-    ADRENO_PIXELFORMAT_NV12_EXT      = 506,  // NV12 with non-std alignment and offsets
-    ADRENO_PIXELFORMAT_R8G8B8X8      = 507,  // GL_RGB8 (Internal)
-    ADRENO_PIXELFORMAT_R8G8B8        = 508,  // GL_RGB8
-    ADRENO_PIXELFORMAT_A1B5G5R5      = 519,  // GL_RGB5_A1
-    ADRENO_PIXELFORMAT_R8G8B8X8_SRGB = 520,  // GL_SRGB8
-    ADRENO_PIXELFORMAT_R8G8B8_SRGB   = 521,  // GL_SRGB8
-    ADRENO_PIXELFORMAT_A2B10G10R10_UNORM = 532,
-                                             // Vertex, Normalized GL_UNSIGNED_INT_10_10_10_2_OES
-    ADRENO_PIXELFORMAT_R10G10B10X2_UNORM = 537,
-                                             // Vertex, Normalized GL_UNSIGNED_INT_10_10_10_2_OES
-    ADRENO_PIXELFORMAT_R5G6B5        = 610,  // RGBA version of B5G6R5
-    ADRENO_PIXELFORMAT_R5G5B5A1      = 611,  // RGBA version of B5G5R5A1
-    ADRENO_PIXELFORMAT_R4G4B4A4      = 612,  // RGBA version of B4G4R4A4
-    ADRENO_PIXELFORMAT_UYVY          = 614,  // YUV 4:2:2 packed progressive (1 plane)
-    ADRENO_PIXELFORMAT_NV21          = 619,
-    ADRENO_PIXELFORMAT_Y8U8V8A8      = 620,  // YUV 4:4:4 packed (1 plane)
-    ADRENO_PIXELFORMAT_Y8            = 625,  // Single 8-bit luma only channel YUV format
-    ADRENO_PIXELFORMAT_TP10          = 654,  // YUV 4:2:0 planar 10 bits/comp (2 planes)
-} ADRENOPIXELFORMAT;
diff --git a/libgralloc/alloc_controller.cpp b/libgralloc/alloc_controller.cpp
deleted file mode 100644
index d2a522e..0000000
--- a/libgralloc/alloc_controller.cpp
+++ /dev/null
@@ -1,1223 +0,0 @@
-/*
- * Copyright (c) 2011 - 2017, 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.
- */
-
-#include <cutils/log.h>
-#include <fcntl.h>
-#include <dlfcn.h>
-#include <media/msm_media_info.h>
-#include <qdMetaData.h>
-#include <utils/Singleton.h>
-#include <utils/Mutex.h>
-#include <algorithm>
-
-#include "gralloc_priv.h"
-#include "alloc_controller.h"
-#include "memalloc.h"
-#include "ionalloc.h"
-#include "gr.h"
-#include "qd_utils.h"
-
-#define ASTC_BLOCK_SIZE 16
-
-#ifndef ION_FLAG_CP_PIXEL
-#define ION_FLAG_CP_PIXEL 0
-#endif
-
-#ifndef ION_FLAG_ALLOW_NON_CONTIG
-#define ION_FLAG_ALLOW_NON_CONTIG 0
-#endif
-
-#ifndef ION_FLAG_CP_CAMERA_PREVIEW
-#define ION_FLAG_CP_CAMERA_PREVIEW 0
-#endif
-
-#ifdef MASTER_SIDE_CP
-#define CP_HEAP_ID ION_SECURE_HEAP_ID
-#define SD_HEAP_ID ION_SECURE_DISPLAY_HEAP_ID
-#define ION_CP_FLAGS (ION_SECURE | ION_FLAG_CP_PIXEL)
-#define ION_SD_FLAGS (ION_SECURE | ION_FLAG_CP_SEC_DISPLAY)
-#define ION_SC_FLAGS (ION_SECURE | ION_FLAG_CP_CAMERA)
-#define ION_SC_PREVIEW_FLAGS (ION_SECURE | ION_FLAG_CP_CAMERA_PREVIEW)
-#else // SLAVE_SIDE_CP
-#define CP_HEAP_ID ION_CP_MM_HEAP_ID
-#define SD_HEAP_ID CP_HEAP_ID
-#define ION_CP_FLAGS (ION_SECURE | ION_FLAG_ALLOW_NON_CONTIG)
-#define ION_SD_FLAGS ION_SECURE
-#define ION_SC_FLAGS ION_SECURE
-#define ION_SC_PREVIEW_FLAGS ION_SECURE
-#endif
-
-#ifndef COLOR_FMT_P010_UBWC
-#define COLOR_FMT_P010_UBWC 9
-#endif
-
-using namespace gralloc;
-using namespace qdutils;
-using namespace android;
-
-ANDROID_SINGLETON_STATIC_INSTANCE(AdrenoMemInfo);
-ANDROID_SINGLETON_STATIC_INSTANCE(MDPCapabilityInfo);
-
-static void getYuvUBwcWidthHeight(int, int, int, int&, int&);
-static unsigned int getUBwcSize(int, int, int, const int, const int);
-
-//Common functions
-
-/* The default policy is to return cached buffers unless the client explicity
- * sets the PRIVATE_UNCACHED flag or indicates that the buffer will be rarely
- * read or written in software. Any combination with a _RARELY_ flag will be
- * treated as uncached. */
-static bool useUncached(const int& usage) {
-    if ((usage & GRALLOC_USAGE_PROTECTED) or
-        (usage & GRALLOC_USAGE_PRIVATE_UNCACHED) or
-        ((usage & GRALLOC_USAGE_SW_WRITE_MASK) == GRALLOC_USAGE_SW_WRITE_RARELY) or
-        ((usage & GRALLOC_USAGE_SW_READ_MASK) ==  GRALLOC_USAGE_SW_READ_RARELY))
-        return true;
-
-    return false;
-}
-
-//------------- MDPCapabilityInfo-----------------------//
-MDPCapabilityInfo :: MDPCapabilityInfo() {
-  qdutils::querySDEInfo(HAS_UBWC, &isUBwcSupported);
-  qdutils::querySDEInfo(HAS_WB_UBWC, &isWBUBWCSupported);
-}
-
-//------------- AdrenoMemInfo-----------------------//
-AdrenoMemInfo::AdrenoMemInfo()
-{
-    LINK_adreno_compute_aligned_width_and_height = NULL;
-    LINK_adreno_compute_padding = NULL;
-    LINK_adreno_compute_compressedfmt_aligned_width_and_height = NULL;
-    LINK_adreno_isUBWCSupportedByGpu = NULL;
-    LINK_adreno_get_gpu_pixel_alignment = NULL;
-
-    libadreno_utils = ::dlopen("libadreno_utils.so", RTLD_NOW);
-    if (libadreno_utils) {
-        *(void **)&LINK_adreno_compute_aligned_width_and_height =
-                ::dlsym(libadreno_utils, "compute_aligned_width_and_height");
-        *(void **)&LINK_adreno_compute_padding =
-                ::dlsym(libadreno_utils, "compute_surface_padding");
-        *(void **)&LINK_adreno_compute_compressedfmt_aligned_width_and_height =
-                ::dlsym(libadreno_utils,
-                        "compute_compressedfmt_aligned_width_and_height");
-        *(void **)&LINK_adreno_isUBWCSupportedByGpu =
-                ::dlsym(libadreno_utils, "isUBWCSupportedByGpu");
-        *(void **)&LINK_adreno_get_gpu_pixel_alignment =
-                ::dlsym(libadreno_utils, "get_gpu_pixel_alignment");
-    }
-
-    // Check if the overriding property debug.gralloc.gfx_ubwc_disable
-    // that disables UBWC allocations for the graphics stack is set
-    gfx_ubwc_disable = 0;
-    char property[PROPERTY_VALUE_MAX];
-    property_get("debug.gralloc.gfx_ubwc_disable", property, "0");
-    if(!(strncmp(property, "1", PROPERTY_VALUE_MAX)) ||
-       !(strncmp(property, "true", PROPERTY_VALUE_MAX))) {
-        gfx_ubwc_disable = 1;
-    }
-}
-
-AdrenoMemInfo::~AdrenoMemInfo()
-{
-    if (libadreno_utils) {
-        ::dlclose(libadreno_utils);
-    }
-}
-
-void AdrenoMemInfo::getAlignedWidthAndHeight(const private_handle_t *hnd, int& aligned_w,
-                          int& aligned_h) {
-    MetaData_t *metadata = (MetaData_t *)hnd->base_metadata;
-    if(metadata && metadata->operation & UPDATE_BUFFER_GEOMETRY) {
-        int w = metadata->bufferDim.sliceWidth;
-        int h = metadata->bufferDim.sliceHeight;
-        int f = hnd->format;
-        int usage = 0;
-
-        if (hnd->flags & private_handle_t::PRIV_FLAGS_UBWC_ALIGNED) {
-            usage = GRALLOC_USAGE_PRIVATE_ALLOC_UBWC;
-        }
-
-        getAlignedWidthAndHeight(w, h, f, usage, aligned_w, aligned_h);
-    } else {
-        aligned_w = hnd->width;
-        aligned_h = hnd->height;
-    }
-
-}
-
-void AdrenoMemInfo::getUnalignedWidthAndHeight(const private_handle_t *hnd, int& unaligned_w,
-                                               int& unaligned_h) {
-    MetaData_t *metadata = (MetaData_t *)hnd->base_metadata;
-    if(metadata && metadata->operation & UPDATE_BUFFER_GEOMETRY) {
-        unaligned_w = metadata->bufferDim.sliceWidth;
-        unaligned_h = metadata->bufferDim.sliceHeight;
-    } else {
-        unaligned_w = hnd->unaligned_width;
-        unaligned_h = hnd->unaligned_height;
-    }
-}
-
-bool isUncompressedRgbFormat(int format)
-{
-    bool is_rgb_format = false;
-
-    switch (format)
-    {
-        case HAL_PIXEL_FORMAT_RGBA_8888:
-        case HAL_PIXEL_FORMAT_RGBX_8888:
-        case HAL_PIXEL_FORMAT_RGB_888:
-        case HAL_PIXEL_FORMAT_RGB_565:
-        case HAL_PIXEL_FORMAT_BGR_565:
-        case HAL_PIXEL_FORMAT_BGRA_8888:
-        case HAL_PIXEL_FORMAT_RGBA_5551:
-        case HAL_PIXEL_FORMAT_RGBA_4444:
-        case HAL_PIXEL_FORMAT_R_8:
-        case HAL_PIXEL_FORMAT_RG_88:
-        case HAL_PIXEL_FORMAT_BGRX_8888:
-        case HAL_PIXEL_FORMAT_BGR_888:
-        case HAL_PIXEL_FORMAT_RGBA_1010102:
-        case HAL_PIXEL_FORMAT_ARGB_2101010:
-        case HAL_PIXEL_FORMAT_RGBX_1010102:
-        case HAL_PIXEL_FORMAT_XRGB_2101010:
-        case HAL_PIXEL_FORMAT_BGRA_1010102:
-        case HAL_PIXEL_FORMAT_ABGR_2101010:
-        case HAL_PIXEL_FORMAT_BGRX_1010102:
-        case HAL_PIXEL_FORMAT_XBGR_2101010:    // Intentional fallthrough
-            is_rgb_format = true;
-            break;
-        default:
-            break;
-    }
-
-    return is_rgb_format;
-}
-
-void AdrenoMemInfo::getAlignedWidthAndHeight(int width, int height, int format,
-                            int usage, int& aligned_w, int& aligned_h)
-{
-    bool ubwc_enabled = isUBwcEnabled(format, usage);
-
-    // Currently surface padding is only computed for RGB* surfaces.
-    if (isUncompressedRgbFormat(format) == true) {
-        int tileEnabled = ubwc_enabled;
-        getGpuAlignedWidthHeight(width, height, format, tileEnabled, aligned_w, aligned_h);
-    } else if (ubwc_enabled) {
-        getYuvUBwcWidthHeight(width, height, format, aligned_w, aligned_h);
-    } else {
-        aligned_w = width;
-        aligned_h = height;
-        int alignment = 32;
-        switch (format)
-        {
-            case HAL_PIXEL_FORMAT_YCrCb_420_SP:
-            case HAL_PIXEL_FORMAT_YCbCr_420_SP:
-                if (LINK_adreno_get_gpu_pixel_alignment) {
-                  alignment = LINK_adreno_get_gpu_pixel_alignment();
-                }
-                aligned_w = ALIGN(width, alignment);
-                break;
-            case HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO:
-                aligned_w = ALIGN(width, alignment);
-                break;
-            case HAL_PIXEL_FORMAT_RAW16:
-            case HAL_PIXEL_FORMAT_Y16:
-            case HAL_PIXEL_FORMAT_Y8:
-                aligned_w = ALIGN(width, 16);
-                break;
-            case HAL_PIXEL_FORMAT_RAW12:
-                aligned_w = ALIGN(width * 12 / 8, 8);
-                break;
-            case HAL_PIXEL_FORMAT_RAW10:
-                aligned_w = ALIGN(width * 10 / 8, 8);
-                break;
-            case HAL_PIXEL_FORMAT_RAW8:
-                aligned_w = ALIGN(width, 8);
-                break;
-            case HAL_PIXEL_FORMAT_YCbCr_420_SP_TILED:
-                aligned_w = ALIGN(width, 128);
-                break;
-            case HAL_PIXEL_FORMAT_YV12:
-            case HAL_PIXEL_FORMAT_YCbCr_422_SP:
-            case HAL_PIXEL_FORMAT_YCrCb_422_SP:
-            case HAL_PIXEL_FORMAT_YCbCr_422_I:
-            case HAL_PIXEL_FORMAT_YCrCb_422_I:
-            case HAL_PIXEL_FORMAT_YCbCr_420_P010:
-            case HAL_PIXEL_FORMAT_CbYCrY_422_I:
-                aligned_w = ALIGN(width, 16);
-                break;
-            case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
-            case HAL_PIXEL_FORMAT_NV12_ENCODEABLE:
-                aligned_w = VENUS_Y_STRIDE(COLOR_FMT_NV12, width);
-                aligned_h = VENUS_Y_SCANLINES(COLOR_FMT_NV12, height);
-                break;
-            case HAL_PIXEL_FORMAT_YCrCb_420_SP_VENUS:
-                aligned_w = VENUS_Y_STRIDE(COLOR_FMT_NV21, width);
-                aligned_h = VENUS_Y_SCANLINES(COLOR_FMT_NV21, height);
-                break;
-            case HAL_PIXEL_FORMAT_BLOB:
-            case HAL_PIXEL_FORMAT_RAW_OPAQUE:
-                break;
-            case HAL_PIXEL_FORMAT_NV21_ZSL:
-                aligned_w = ALIGN(width, 64);
-                aligned_h = ALIGN(height, 64);
-                break;
-            case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_4x4_KHR:
-            case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR:
-            case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_5x4_KHR:
-            case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR:
-            case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_5x5_KHR:
-            case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR:
-            case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_6x5_KHR:
-            case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR:
-            case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_6x6_KHR:
-            case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR:
-            case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_8x5_KHR:
-            case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR:
-            case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_8x6_KHR:
-            case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR:
-            case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_8x8_KHR:
-            case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR:
-            case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_10x5_KHR:
-            case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR:
-            case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_10x6_KHR:
-            case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR:
-            case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_10x8_KHR:
-            case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR:
-            case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_10x10_KHR:
-            case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR:
-            case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_12x10_KHR:
-            case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR:
-            case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_12x12_KHR:
-            case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR:
-                if(LINK_adreno_compute_compressedfmt_aligned_width_and_height) {
-                    int bytesPerPixel = 0;
-                    int raster_mode         = 0;   //Adreno unknown raster mode.
-                    int padding_threshold   = 512; //Threshold for padding
-                    //surfaces.
-
-                    LINK_adreno_compute_compressedfmt_aligned_width_and_height(
-                        width, height, format, 0,raster_mode, padding_threshold,
-                        &aligned_w, &aligned_h, &bytesPerPixel);
-                } else {
-                    ALOGW("%s: Warning!! Symbols" \
-                          " compute_compressedfmt_aligned_width_and_height" \
-                          " not found", __FUNCTION__);
-                }
-                break;
-            default: break;
-        }
-    }
-}
-
-void AdrenoMemInfo::getGpuAlignedWidthHeight(int width, int height, int format,
-                            int tile_enabled, int& aligned_w, int& aligned_h)
-{
-    aligned_w = ALIGN(width, 32);
-    aligned_h = ALIGN(height, 32);
-
-    // Don't add any additional padding if debug.gralloc.map_fb_memory
-    // is enabled
-    char property[PROPERTY_VALUE_MAX];
-    if((property_get("debug.gralloc.map_fb_memory", property, NULL) > 0) &&
-       (!strncmp(property, "1", PROPERTY_VALUE_MAX ) ||
-       (!strncasecmp(property,"true", PROPERTY_VALUE_MAX )))) {
-        return;
-    }
-
-    int bpp = 4;
-    switch(format)
-    {
-        case HAL_PIXEL_FORMAT_RGB_888:
-            bpp = 3;
-            break;
-        case HAL_PIXEL_FORMAT_RGB_565:
-        case HAL_PIXEL_FORMAT_BGR_565:
-        case HAL_PIXEL_FORMAT_RGBA_5551:
-        case HAL_PIXEL_FORMAT_RGBA_4444:
-            bpp = 2;
-            break;
-        default: break;
-    }
-
-    if (libadreno_utils) {
-        int raster_mode         = 0;   // Adreno unknown raster mode.
-        int padding_threshold   = 512; // Threshold for padding surfaces.
-        // the function below computes aligned width and aligned height
-        // based on linear or macro tile mode selected.
-        if(LINK_adreno_compute_aligned_width_and_height) {
-            LINK_adreno_compute_aligned_width_and_height(width,
-                                 height, bpp, tile_enabled,
-                                 raster_mode, padding_threshold,
-                                 &aligned_w, &aligned_h);
-
-        } else if(LINK_adreno_compute_padding) {
-            int surface_tile_height = 1;   // Linear surface
-            aligned_w = LINK_adreno_compute_padding(width, bpp,
-                                 surface_tile_height, raster_mode,
-                                 padding_threshold);
-            ALOGW("%s: Warning!! Old GFX API is used to calculate stride",
-                                                            __FUNCTION__);
-        } else {
-            ALOGW("%s: Warning!! Symbols compute_surface_padding and " \
-                 "compute_aligned_width_and_height not found", __FUNCTION__);
-        }
-   }
-}
-
-int AdrenoMemInfo::isUBWCSupportedByGPU(int format)
-{
-    if (!gfx_ubwc_disable && libadreno_utils) {
-        if (LINK_adreno_isUBWCSupportedByGpu) {
-            ADRENOPIXELFORMAT gpu_format = getGpuPixelFormat(format);
-            return LINK_adreno_isUBWCSupportedByGpu(gpu_format);
-        }
-    }
-    return 0;
-}
-
-ADRENOPIXELFORMAT AdrenoMemInfo::getGpuPixelFormat(int hal_format)
-{
-    switch (hal_format) {
-        case HAL_PIXEL_FORMAT_RGBA_8888:
-            return ADRENO_PIXELFORMAT_R8G8B8A8;
-        case HAL_PIXEL_FORMAT_RGBX_8888:
-            return ADRENO_PIXELFORMAT_R8G8B8X8;
-        case HAL_PIXEL_FORMAT_RGB_565:
-            return ADRENO_PIXELFORMAT_B5G6R5;
-        case HAL_PIXEL_FORMAT_BGR_565:
-            return ADRENO_PIXELFORMAT_R5G6B5;
-        case HAL_PIXEL_FORMAT_NV12_ENCODEABLE:
-            return ADRENO_PIXELFORMAT_NV12;
-        case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
-        case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC:
-            return ADRENO_PIXELFORMAT_NV12_EXT;
-        case HAL_PIXEL_FORMAT_YCbCr_420_TP10_UBWC:
-            return ADRENO_PIXELFORMAT_TP10;
-        case HAL_PIXEL_FORMAT_YCbCr_420_P010:
-        case HAL_PIXEL_FORMAT_YCbCr_420_P010_UBWC:
-            return ADRENO_PIXELFORMAT_P010;
-        case HAL_PIXEL_FORMAT_RGBA_1010102:
-            return ADRENO_PIXELFORMAT_R10G10B10A2_UNORM;
-        case HAL_PIXEL_FORMAT_RGBX_1010102:
-            return ADRENO_PIXELFORMAT_R10G10B10X2_UNORM;
-        case HAL_PIXEL_FORMAT_ABGR_2101010:
-            return ADRENO_PIXELFORMAT_A2B10G10R10_UNORM;
-        default:
-            ALOGE("%s: No map for format: 0x%x", __FUNCTION__, hal_format);
-            break;
-    }
-    return ADRENO_PIXELFORMAT_UNKNOWN;
-}
-
-//-------------- IAllocController-----------------------//
-IAllocController* IAllocController::sController = NULL;
-IAllocController* IAllocController::getInstance(void)
-{
-    if(sController == NULL) {
-        sController = new IonController();
-    }
-    return sController;
-}
-
-
-//-------------- IonController-----------------------//
-IonController::IonController()
-{
-    allocateIonMem();
-
-    char property[PROPERTY_VALUE_MAX];
-    property_get("video.disable.ubwc", property, "0");
-    mDisableUBWCForEncode = atoi(property);
-}
-
-void IonController::allocateIonMem()
-{
-   mIonAlloc = new IonAlloc();
-}
-
-int IonController::allocate(alloc_data& data, int usage)
-{
-    int ionFlags = 0;
-    int ionHeapId = 0;
-    int ret;
-
-    data.uncached = useUncached(usage);
-    data.allocType = 0;
-
-    if(usage & GRALLOC_USAGE_PROTECTED) {
-        if (usage & GRALLOC_USAGE_PRIVATE_SECURE_DISPLAY) {
-            ionHeapId = ION_HEAP(SD_HEAP_ID);
-            /*
-             * There is currently no flag in ION for Secure Display
-             * VM. Please add it to the define once available.
-             */
-            ionFlags |= ION_SD_FLAGS;
-        } else if (usage & GRALLOC_USAGE_HW_CAMERA_MASK) {
-            ionHeapId = ION_HEAP(SD_HEAP_ID);
-            ionFlags |= (usage & GRALLOC_USAGE_HW_COMPOSER) ? ION_SC_PREVIEW_FLAGS : ION_SC_FLAGS;
-        } else {
-            ionHeapId = ION_HEAP(CP_HEAP_ID);
-            ionFlags |= ION_CP_FLAGS;
-        }
-    } else if(usage & GRALLOC_USAGE_PRIVATE_MM_HEAP) {
-        //MM Heap is exclusively a secure heap.
-        //If it is used for non secure cases, fallback to IOMMU heap
-        ALOGW("GRALLOC_USAGE_PRIVATE_MM_HEAP \
-                                cannot be used as an insecure heap!\
-                                trying to use system heap instead !!");
-        ionHeapId |= ION_HEAP(ION_SYSTEM_HEAP_ID);
-    }
-
-    if(usage & GRALLOC_USAGE_PRIVATE_CAMERA_HEAP)
-        ionHeapId |= ION_HEAP(ION_CAMERA_HEAP_ID);
-
-    if(usage & GRALLOC_USAGE_PRIVATE_ADSP_HEAP)
-        ionHeapId |= ION_HEAP(ION_ADSP_HEAP_ID);
-
-    if(ionFlags & ION_SECURE)
-         data.allocType |= private_handle_t::PRIV_FLAGS_SECURE_BUFFER;
-
-    // if no ion heap flags are set, default to system heap
-    if(!ionHeapId)
-        ionHeapId = ION_HEAP(ION_SYSTEM_HEAP_ID);
-
-    //At this point we should have the right heap set, there is no fallback
-    data.flags = ionFlags;
-    data.heapId = ionHeapId;
-    ret = mIonAlloc->alloc_buffer(data);
-
-    if(ret >= 0 ) {
-        data.allocType |= private_handle_t::PRIV_FLAGS_USES_ION;
-    } else {
-        ALOGE("%s: Failed to allocate buffer - heap: 0x%x flags: 0x%x",
-                __FUNCTION__, ionHeapId, ionFlags);
-    }
-
-    return ret;
-}
-
-IMemAlloc* IonController::getAllocator(int flags)
-{
-    IMemAlloc* memalloc = NULL;
-    if (flags & private_handle_t::PRIV_FLAGS_USES_ION) {
-        memalloc = mIonAlloc;
-    } else {
-        ALOGE("%s: Invalid flags passed: 0x%x", __FUNCTION__, flags);
-    }
-
-    return memalloc;
-}
-
-// helper function
-unsigned int getSize(int format, int width, int height, int usage,
-        const int alignedw, const int alignedh) {
-
-    if (isUBwcEnabled(format, usage)) {
-        return getUBwcSize(width, height, format, alignedw, alignedh);
-    }
-
-    unsigned int size = 0;
-    switch (format) {
-        case HAL_PIXEL_FORMAT_RGBA_8888:
-        case HAL_PIXEL_FORMAT_RGBX_8888:
-        case HAL_PIXEL_FORMAT_BGRA_8888:
-        case HAL_PIXEL_FORMAT_RGBA_1010102:
-        case HAL_PIXEL_FORMAT_ARGB_2101010:
-        case HAL_PIXEL_FORMAT_RGBX_1010102:
-        case HAL_PIXEL_FORMAT_XRGB_2101010:
-        case HAL_PIXEL_FORMAT_BGRA_1010102:
-        case HAL_PIXEL_FORMAT_ABGR_2101010:
-        case HAL_PIXEL_FORMAT_BGRX_1010102:
-        case HAL_PIXEL_FORMAT_XBGR_2101010:
-            size = alignedw * alignedh * 4;
-            break;
-        case HAL_PIXEL_FORMAT_RGB_888:
-            size = alignedw * alignedh * 3;
-            break;
-        case HAL_PIXEL_FORMAT_RGB_565:
-        case HAL_PIXEL_FORMAT_BGR_565:
-        case HAL_PIXEL_FORMAT_RGBA_5551:
-        case HAL_PIXEL_FORMAT_RGBA_4444:
-        case HAL_PIXEL_FORMAT_RAW16:
-        case HAL_PIXEL_FORMAT_Y16:
-            size = alignedw * alignedh * 2;
-            break;
-        case HAL_PIXEL_FORMAT_RAW12:
-            size = ALIGN(alignedw * alignedh, 4096);
-            break;
-        case HAL_PIXEL_FORMAT_RAW10:
-            size = ALIGN(alignedw * alignedh, 4096);
-            break;
-        case HAL_PIXEL_FORMAT_RAW8:
-        case HAL_PIXEL_FORMAT_Y8:
-            size = alignedw * alignedh;
-            break;
-            // adreno formats
-        case HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO:  // NV21
-            size  = ALIGN(alignedw*alignedh, 4096);
-            size += ALIGN(2 * ALIGN(width/2, 32) * ALIGN(height/2, 32), 4096);
-            break;
-        case HAL_PIXEL_FORMAT_YCbCr_420_SP_TILED:   // NV12
-            // The chroma plane is subsampled,
-            // but the pitch in bytes is unchanged
-            // The GPU needs 4K alignment, but the video decoder needs 8K
-            size  = ALIGN( alignedw * alignedh, 8192);
-            size += ALIGN( alignedw * ALIGN(height/2, 32), 8192);
-            break;
-        case HAL_PIXEL_FORMAT_YV12:
-            if ((format == HAL_PIXEL_FORMAT_YV12) && ((width&1) || (height&1))) {
-                ALOGE("w or h is odd for the YV12 format");
-                return 0;
-            }
-            size = alignedw*alignedh +
-                    (ALIGN(alignedw/2, 16) * (alignedh/2))*2;
-            size = ALIGN(size, (unsigned int)4096);
-            break;
-        case HAL_PIXEL_FORMAT_YCbCr_420_SP:
-        case HAL_PIXEL_FORMAT_YCrCb_420_SP:
-            size = ALIGN((alignedw*alignedh) + (alignedw* alignedh)/2 + 1, 4096);
-            break;
-        case HAL_PIXEL_FORMAT_YCbCr_420_P010:
-            size = ALIGN((alignedw * alignedh * 2) + (alignedw * alignedh) + 1, 4096);
-            break;
-        case HAL_PIXEL_FORMAT_YCbCr_422_SP:
-        case HAL_PIXEL_FORMAT_YCrCb_422_SP:
-        case HAL_PIXEL_FORMAT_YCbCr_422_I:
-        case HAL_PIXEL_FORMAT_YCrCb_422_I:
-        case HAL_PIXEL_FORMAT_CbYCrY_422_I:
-            if(width & 1) {
-                ALOGE("width is odd for the YUV422_SP format");
-                return 0;
-            }
-            size = ALIGN(alignedw * alignedh * 2, 4096);
-            break;
-        case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
-        case HAL_PIXEL_FORMAT_NV12_ENCODEABLE:
-            size = VENUS_BUFFER_SIZE(COLOR_FMT_NV12, width, height);
-            break;
-        case HAL_PIXEL_FORMAT_YCrCb_420_SP_VENUS:
-            size = VENUS_BUFFER_SIZE(COLOR_FMT_NV21, width, height);
-            break;
-        case HAL_PIXEL_FORMAT_BLOB:
-        case HAL_PIXEL_FORMAT_RAW_OPAQUE:
-            if(height != 1) {
-                ALOGE("%s: Buffers with format HAL_PIXEL_FORMAT_BLOB \
-                      must have height==1 ", __FUNCTION__);
-                return 0;
-            }
-            size = width;
-            break;
-        case HAL_PIXEL_FORMAT_NV21_ZSL:
-            size = ALIGN((alignedw*alignedh) + (alignedw* alignedh)/2, 4096);
-            break;
-        case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_4x4_KHR:
-        case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_5x4_KHR:
-        case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_5x5_KHR:
-        case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_6x5_KHR:
-        case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_6x6_KHR:
-        case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_8x5_KHR:
-        case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_8x6_KHR:
-        case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_8x8_KHR:
-        case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_10x5_KHR:
-        case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_10x6_KHR:
-        case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_10x8_KHR:
-        case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_10x10_KHR:
-        case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_12x10_KHR:
-        case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_12x12_KHR:
-        case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR:
-        case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR:
-        case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR:
-        case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR:
-        case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR:
-        case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR:
-        case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR:
-        case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR:
-        case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR:
-        case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR:
-        case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR:
-        case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR:
-        case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR:
-        case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR:
-            size = alignedw * alignedh * ASTC_BLOCK_SIZE;
-            break;
-        default:
-            ALOGE("%s: Unrecognized pixel format: 0x%x", __FUNCTION__, format);
-            return 0;
-    }
-    return size;
-}
-
-unsigned int getBufferSizeAndDimensions(int width, int height, int format,
-        int& alignedw, int &alignedh)
-{
-    unsigned int size;
-
-    AdrenoMemInfo::getInstance().getAlignedWidthAndHeight(width,
-            height,
-            format,
-            0,
-            alignedw,
-            alignedh);
-
-    size = getSize(format, width, height, 0 /* usage */, alignedw, alignedh);
-
-    return size;
-}
-
-
-unsigned int getBufferSizeAndDimensions(int width, int height, int format,
-        int usage, int& alignedw, int &alignedh)
-{
-    unsigned int size;
-
-    AdrenoMemInfo::getInstance().getAlignedWidthAndHeight(width,
-            height,
-            format,
-            usage,
-            alignedw,
-            alignedh);
-
-    size = getSize(format, width, height, usage, alignedw, alignedh);
-
-    return size;
-}
-
-void getYuvUbwcSPPlaneInfo(uint64_t base, int width, int height,
-                           int color_format, struct android_ycbcr* ycbcr)
-{
-    // UBWC buffer has these 4 planes in the following sequence:
-    // Y_Meta_Plane, Y_Plane, UV_Meta_Plane, UV_Plane
-    unsigned int y_meta_stride, y_meta_height, y_meta_size;
-    unsigned int y_stride, y_height, y_size;
-    unsigned int c_meta_stride, c_meta_height, c_meta_size;
-    unsigned int alignment = 4096;
-
-    y_meta_stride = VENUS_Y_META_STRIDE(color_format, width);
-    y_meta_height = VENUS_Y_META_SCANLINES(color_format, height);
-    y_meta_size = ALIGN((y_meta_stride * y_meta_height), alignment);
-
-    y_stride = VENUS_Y_STRIDE(color_format, width);
-    y_height = VENUS_Y_SCANLINES(color_format, height);
-    y_size = ALIGN((y_stride * y_height), alignment);
-
-    c_meta_stride = VENUS_UV_META_STRIDE(color_format, width);
-    c_meta_height = VENUS_UV_META_SCANLINES(color_format, height);
-    c_meta_size = ALIGN((c_meta_stride * c_meta_height), alignment);
-
-    ycbcr->y  = (void*)(base + y_meta_size);
-    ycbcr->cb = (void*)(base + y_meta_size + y_size + c_meta_size);
-    ycbcr->cr = (void*)(base + y_meta_size + y_size +
-                        c_meta_size + 1);
-    ycbcr->ystride = y_stride;
-    ycbcr->cstride = VENUS_UV_STRIDE(color_format, width);
-}
-
-void getYuvSPPlaneInfo(uint64_t base, int width, int height, int bpp,
-                       struct android_ycbcr* ycbcr)
-{
-    unsigned int ystride, cstride;
-
-    ystride = cstride = width * bpp;
-    ycbcr->y  = (void*)base;
-    ycbcr->cb = (void*)(base + ystride * height);
-    ycbcr->cr = (void*)(base + ystride * height + 1);
-    ycbcr->ystride = ystride;
-    ycbcr->cstride = cstride;
-    ycbcr->chroma_step = 2 * bpp;
-}
-
-int getYUVPlaneInfo(private_handle_t* hnd, struct android_ycbcr* ycbcr)
-{
-    int err = 0;
-    int width = hnd->width;
-    int height = hnd->height;
-    int format = hnd->format;
-
-    unsigned int ystride, cstride;
-
-    memset(ycbcr->reserved, 0, sizeof(ycbcr->reserved));
-    MetaData_t *metadata = (MetaData_t *)hnd->base_metadata;
-
-    // Check if UBWC buffer has been rendered in linear format.
-    if (metadata && (metadata->operation & LINEAR_FORMAT)) {
-        format = metadata->linearFormat;
-    }
-
-    // Check metadata if the geometry has been updated.
-    if(metadata && metadata->operation & UPDATE_BUFFER_GEOMETRY) {
-        int usage = 0;
-
-        if (hnd->flags & private_handle_t::PRIV_FLAGS_UBWC_ALIGNED) {
-            usage = GRALLOC_USAGE_PRIVATE_ALLOC_UBWC;
-        }
-
-        AdrenoMemInfo::getInstance().getAlignedWidthAndHeight(metadata->bufferDim.sliceWidth,
-                   metadata->bufferDim.sliceHeight, format, usage, width, height);
-    }
-
-    // Get the chroma offsets from the handle width/height. We take advantage
-    // of the fact the width _is_ the stride
-    switch (format) {
-        //Semiplanar
-        case HAL_PIXEL_FORMAT_YCbCr_420_SP:
-        case HAL_PIXEL_FORMAT_YCbCr_422_SP:
-        case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
-        case HAL_PIXEL_FORMAT_NV12_ENCODEABLE: //Same as YCbCr_420_SP_VENUS
-            getYuvSPPlaneInfo(hnd->base, width, height, 1, ycbcr);
-        break;
-
-        case HAL_PIXEL_FORMAT_YCbCr_420_P010:
-            getYuvSPPlaneInfo(hnd->base, width, height, 2, ycbcr);
-        break;
-
-        case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC:
-            getYuvUbwcSPPlaneInfo(hnd->base, width, height,
-                                  COLOR_FMT_NV12_UBWC, ycbcr);
-            ycbcr->chroma_step = 2;
-        break;
-
-        case HAL_PIXEL_FORMAT_YCbCr_420_TP10_UBWC:
-            getYuvUbwcSPPlaneInfo(hnd->base, width, height,
-                                  COLOR_FMT_NV12_BPP10_UBWC, ycbcr);
-            ycbcr->chroma_step = 3;
-        break;
-        case HAL_PIXEL_FORMAT_YCbCr_420_P010_UBWC:
-            getYuvUbwcSPPlaneInfo(hnd->base, width, height,
-                                  COLOR_FMT_P010_UBWC, ycbcr);
-            ycbcr->chroma_step = 4;
-        break;
-        case HAL_PIXEL_FORMAT_YCrCb_420_SP:
-        case HAL_PIXEL_FORMAT_YCrCb_422_SP:
-        case HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO:
-        case HAL_PIXEL_FORMAT_YCrCb_420_SP_VENUS:
-        case HAL_PIXEL_FORMAT_NV21_ZSL:
-        case HAL_PIXEL_FORMAT_RAW16:
-        case HAL_PIXEL_FORMAT_Y16:
-        case HAL_PIXEL_FORMAT_RAW12:
-        case HAL_PIXEL_FORMAT_RAW10:
-        case HAL_PIXEL_FORMAT_RAW8:
-        case HAL_PIXEL_FORMAT_Y8:
-            getYuvSPPlaneInfo(hnd->base, width, height, 1, ycbcr);
-            std::swap(ycbcr->cb, ycbcr->cr);
-        break;
-
-        //Planar
-        case HAL_PIXEL_FORMAT_YV12:
-            ystride = width;
-            cstride = ALIGN(width/2, 16);
-            ycbcr->y  = (void*)hnd->base;
-            ycbcr->cr = (void*)(hnd->base + ystride * height);
-            ycbcr->cb = (void*)(hnd->base + ystride * height +
-                    cstride * height/2);
-            ycbcr->ystride = ystride;
-            ycbcr->cstride = cstride;
-            ycbcr->chroma_step = 1;
-        break;
-        case HAL_PIXEL_FORMAT_CbYCrY_422_I:
-            ystride = width * 2;
-            cstride = 0;
-            ycbcr->y  = (void*)hnd->base;
-            ycbcr->cr = NULL;
-            ycbcr->cb = NULL;
-            ycbcr->ystride = ystride;
-            ycbcr->cstride = 0;
-            ycbcr->chroma_step = 0;
-        break;
-        //Unsupported formats
-        case HAL_PIXEL_FORMAT_YCbCr_422_I:
-        case HAL_PIXEL_FORMAT_YCrCb_422_I:
-        case HAL_PIXEL_FORMAT_YCbCr_420_SP_TILED:
-        default:
-        ALOGD("%s: Invalid format passed: 0x%x", __FUNCTION__, format);
-        err = -EINVAL;
-    }
-    return err;
-
-}
-
-
-
-// Allocate buffer from width, height and format into a
-// private_handle_t. It is the responsibility of the caller
-// to free the buffer using the free_buffer function
-int alloc_buffer(private_handle_t **pHnd, int w, int h, int format, int usage)
-{
-    alloc_data data;
-    int alignedw, alignedh;
-    gralloc::IAllocController* sAlloc =
-        gralloc::IAllocController::getInstance();
-    data.base = 0;
-    data.fd = -1;
-    data.offset = 0;
-    data.size = getBufferSizeAndDimensions(w, h, format, usage, alignedw,
-                                            alignedh);
-
-    data.align = getpagesize();
-    data.uncached = useUncached(usage);
-    int allocFlags = usage;
-
-    int err = sAlloc->allocate(data, allocFlags);
-    if (0 != err) {
-        ALOGE("%s: allocate failed", __FUNCTION__);
-        return -ENOMEM;
-    }
-
-    if(isUBwcEnabled(format, usage)) {
-      data.allocType |= private_handle_t::PRIV_FLAGS_UBWC_ALIGNED;
-    }
-
-    private_handle_t* hnd = new private_handle_t(data.fd, data.size,
-                                                 data.allocType, 0, format,
-                                                 alignedw, alignedh, -1, 0, 0, w, h);
-    hnd->base = (uint64_t) data.base;
-    hnd->offset = data.offset;
-    hnd->gpuaddr = 0;
-    *pHnd = hnd;
-    return 0;
-}
-
-void free_buffer(private_handle_t *hnd)
-{
-    gralloc::IAllocController* sAlloc =
-        gralloc::IAllocController::getInstance();
-    if (hnd && hnd->fd > 0) {
-        IMemAlloc* memalloc = sAlloc->getAllocator(hnd->flags);
-        memalloc->free_buffer((void*)hnd->base, hnd->size, hnd->offset, hnd->fd);
-    }
-    if(hnd)
-        delete hnd;
-
-}
-
-// UBWC helper functions
-static bool isUBwcFormat(int format)
-{
-    // Explicitly defined UBWC formats
-    switch(format)
-    {
-        case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC:
-        case HAL_PIXEL_FORMAT_YCbCr_420_TP10_UBWC:
-        case HAL_PIXEL_FORMAT_YCbCr_420_P010_UBWC:
-            return true;
-        default:
-            return false;
-    }
-}
-
-static bool isUBwcSupported(int format)
-{
-    if (MDPCapabilityInfo::getInstance().isUBwcSupportedByMDP()) {
-        // Existing HAL formats with UBWC support
-        switch(format)
-        {
-            case HAL_PIXEL_FORMAT_BGR_565:
-            case HAL_PIXEL_FORMAT_RGBA_8888:
-            case HAL_PIXEL_FORMAT_RGBX_8888:
-            case HAL_PIXEL_FORMAT_NV12_ENCODEABLE:
-            case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
-            case HAL_PIXEL_FORMAT_RGBA_1010102:
-            case HAL_PIXEL_FORMAT_RGBX_1010102:
-                return true;
-            default:
-                break;
-        }
-    }
-    return false;
-}
-
-bool isUBwcEnabled(int format, int usage)
-{
-    // Allow UBWC, if client is using an explicitly defined UBWC pixel format.
-    if (isUBwcFormat(format))
-        return true;
-
-    if ((usage & GRALLOC_USAGE_HW_VIDEO_ENCODER) &&
-        gralloc::IAllocController::getInstance()->isDisableUBWCForEncoder()) {
-            return false;
-    }
-
-    // Allow UBWC, if an OpenGL client sets UBWC usage flag and GPU plus MDP
-    // support the format. OR if a non-OpenGL client like Rotator, sets UBWC
-    // usage flag and MDP supports the format.
-    if ((usage & GRALLOC_USAGE_PRIVATE_ALLOC_UBWC) && isUBwcSupported(format)) {
-        bool enable = true;
-        // Query GPU for UBWC only if buffer is intended to be used by GPU.
-        if (usage & (GRALLOC_USAGE_HW_TEXTURE | GRALLOC_USAGE_HW_RENDER)) {
-            enable = AdrenoMemInfo::getInstance().isUBWCSupportedByGPU(format);
-        }
-        // Allow UBWC, only if CPU usage flags are not set
-        if (enable && !(usage & (GRALLOC_USAGE_SW_READ_MASK |
-            GRALLOC_USAGE_SW_WRITE_MASK))) {
-            return true;
-        }
-    }
-    return false;
-}
-
-static void getYuvUBwcWidthHeight(int width, int height, int format,
-        int& aligned_w, int& aligned_h)
-{
-    switch (format)
-    {
-        case HAL_PIXEL_FORMAT_NV12_ENCODEABLE:
-        case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
-        case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC:
-            aligned_w = VENUS_Y_STRIDE(COLOR_FMT_NV12_UBWC, width);
-            aligned_h = VENUS_Y_SCANLINES(COLOR_FMT_NV12_UBWC, height);
-            break;
-        case HAL_PIXEL_FORMAT_YCbCr_420_TP10_UBWC:
-            // The macro returns the stride which is 4/3 times the width, hence * 3/4
-            aligned_w = (VENUS_Y_STRIDE(COLOR_FMT_NV12_BPP10_UBWC, width) * 3) / 4;
-            aligned_h = VENUS_Y_SCANLINES(COLOR_FMT_NV12_BPP10_UBWC, height);
-            break;
-        case HAL_PIXEL_FORMAT_YCbCr_420_P010_UBWC:
-            // The macro returns the stride which is 2 times the width, hence / 2
-            aligned_w = (VENUS_Y_STRIDE(COLOR_FMT_P010_UBWC, width) / 2);
-            aligned_h = VENUS_Y_SCANLINES(COLOR_FMT_P010_UBWC, height);
-            break;
-        default:
-            ALOGE("%s: Unsupported pixel format: 0x%x", __FUNCTION__, format);
-            aligned_w = 0;
-            aligned_h = 0;
-            break;
-    }
-}
-
-static void getRgbUBwcBlockSize(int bpp, int& block_width, int& block_height)
-{
-    block_width = 0;
-    block_height = 0;
-
-    switch(bpp)
-    {
-         case 2:
-         case 4:
-             block_width = 16;
-             block_height = 4;
-             break;
-         case 8:
-             block_width = 8;
-             block_height = 4;
-             break;
-         case 16:
-             block_width = 4;
-             block_height = 4;
-             break;
-         default:
-             ALOGE("%s: Unsupported bpp: %d", __FUNCTION__, bpp);
-             break;
-    }
-}
-
-static unsigned int getRgbUBwcMetaBufferSize(int width, int height, int bpp)
-{
-    unsigned int size = 0;
-    int meta_width, meta_height;
-    int block_width, block_height;
-
-    getRgbUBwcBlockSize(bpp, block_width, block_height);
-
-    if (!block_width || !block_height) {
-        ALOGE("%s: Unsupported bpp: %d", __FUNCTION__, bpp);
-        return size;
-    }
-
-    // Align meta buffer height to 16 blocks
-    meta_height = ALIGN(((height + block_height - 1) / block_height), 16);
-
-    // Align meta buffer width to 64 blocks
-    meta_width = ALIGN(((width + block_width - 1) / block_width), 64);
-
-    // Align meta buffer size to 4K
-    size = ALIGN((meta_width * meta_height), 4096);
-    return size;
-}
-
-static unsigned int getUBwcSize(int width, int height, int format,
-        const int alignedw, const int alignedh) {
-
-    unsigned int size = 0;
-    switch (format) {
-        case HAL_PIXEL_FORMAT_BGR_565:
-            size = alignedw * alignedh * 2;
-            size += getRgbUBwcMetaBufferSize(width, height, 2);
-            break;
-        case HAL_PIXEL_FORMAT_RGBA_8888:
-        case HAL_PIXEL_FORMAT_RGBX_8888:
-        case HAL_PIXEL_FORMAT_RGBA_1010102:
-        case HAL_PIXEL_FORMAT_RGBX_1010102:
-            size = alignedw * alignedh * 4;
-            size += getRgbUBwcMetaBufferSize(width, height, 4);
-            break;
-        case HAL_PIXEL_FORMAT_NV12_ENCODEABLE:
-        case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
-        case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC:
-            size = VENUS_BUFFER_SIZE(COLOR_FMT_NV12_UBWC, width, height);
-            break;
-        case HAL_PIXEL_FORMAT_YCbCr_420_TP10_UBWC:
-            size = VENUS_BUFFER_SIZE(COLOR_FMT_NV12_BPP10_UBWC, width, height);
-            break;
-        case HAL_PIXEL_FORMAT_YCbCr_420_P010_UBWC:
-            size = VENUS_BUFFER_SIZE(COLOR_FMT_P010_UBWC, width, height);
-            break;
-        default:
-            ALOGE("%s: Unsupported pixel format: 0x%x", __FUNCTION__, format);
-            break;
-    }
-    return size;
-}
-
-int getRgbDataAddress(private_handle_t* hnd, void** rgb_data)
-{
-    int err = 0;
-
-    // This api is for RGB* formats
-    if (!isUncompressedRgbFormat(hnd->format)) {
-        return -EINVAL;
-    }
-
-    // linear buffer
-    if (!(hnd->flags & private_handle_t::PRIV_FLAGS_UBWC_ALIGNED)) {
-        *rgb_data = (void*)hnd->base;
-        return err;
-    }
-
-    // Ubwc buffers
-    unsigned int meta_size = 0;
-    switch (hnd->format) {
-        case HAL_PIXEL_FORMAT_BGR_565:
-            meta_size = getRgbUBwcMetaBufferSize(hnd->width, hnd->height, 2);
-            break;
-        case HAL_PIXEL_FORMAT_RGBA_8888:
-        case HAL_PIXEL_FORMAT_RGBX_8888:
-        case HAL_PIXEL_FORMAT_RGBA_1010102:
-        case HAL_PIXEL_FORMAT_RGBX_1010102:
-            meta_size = getRgbUBwcMetaBufferSize(hnd->width, hnd->height, 4);
-            break;
-        default:
-            ALOGE("%s:Unsupported RGB format: 0x%x", __FUNCTION__, hnd->format);
-            err = -EINVAL;
-            break;
-    }
-
-    *rgb_data = (void*)(hnd->base + meta_size);
-    return err;
-}
-
-int getBufferLayout(private_handle_t *hnd, uint32_t stride[4],
-        uint32_t offset[4], uint32_t *num_planes) {
-    if (!hnd || !stride || !offset || !num_planes) {
-        return -EINVAL;
-    }
-
-    struct android_ycbcr yuvInfo = {};
-    *num_planes = 1;
-    stride[0] = 0;
-
-    switch (hnd->format) {
-        case HAL_PIXEL_FORMAT_RGB_565:
-        case HAL_PIXEL_FORMAT_BGR_565:
-        case HAL_PIXEL_FORMAT_RGBA_5551:
-        case HAL_PIXEL_FORMAT_RGBA_4444:
-            stride[0] = hnd->width * 2;
-            break;
-        case HAL_PIXEL_FORMAT_RGB_888:
-            stride[0] = hnd->width * 3;
-            break;
-        case HAL_PIXEL_FORMAT_RGBA_8888:
-        case HAL_PIXEL_FORMAT_BGRA_8888:
-        case HAL_PIXEL_FORMAT_RGBX_8888:
-        case HAL_PIXEL_FORMAT_BGRX_8888:
-        case HAL_PIXEL_FORMAT_RGBA_1010102:
-        case HAL_PIXEL_FORMAT_ARGB_2101010:
-        case HAL_PIXEL_FORMAT_RGBX_1010102:
-        case HAL_PIXEL_FORMAT_XRGB_2101010:
-        case HAL_PIXEL_FORMAT_BGRA_1010102:
-        case HAL_PIXEL_FORMAT_ABGR_2101010:
-        case HAL_PIXEL_FORMAT_BGRX_1010102:
-        case HAL_PIXEL_FORMAT_XBGR_2101010:
-            stride[0] = hnd->width * 4;
-            break;
-    }
-
-    // Format is RGB
-    if (stride[0]) {
-        return 0;
-    }
-
-    (*num_planes)++;
-    int ret = getYUVPlaneInfo(hnd, &yuvInfo);
-    if (ret < 0) {
-        ALOGE("%s failed", __FUNCTION__);
-        return ret;
-    }
-
-    stride[0] = static_cast<uint32_t>(yuvInfo.ystride);
-    offset[0] = static_cast<uint32_t>(
-                    reinterpret_cast<uint64_t>(yuvInfo.y) - hnd->base);
-    stride[1] = static_cast<uint32_t>(yuvInfo.cstride);
-    switch (hnd->format) {
-        case HAL_PIXEL_FORMAT_YCbCr_420_SP:
-        case HAL_PIXEL_FORMAT_YCbCr_422_SP:
-        case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
-        case HAL_PIXEL_FORMAT_NV12_ENCODEABLE:
-        case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC:
-        case HAL_PIXEL_FORMAT_YCbCr_420_P010:
-        case HAL_PIXEL_FORMAT_YCbCr_420_TP10_UBWC:
-        case HAL_PIXEL_FORMAT_YCbCr_420_P010_UBWC:
-            offset[1] = static_cast<uint32_t>(
-                    reinterpret_cast<uint64_t>(yuvInfo.cb) - hnd->base);
-            break;
-        case HAL_PIXEL_FORMAT_YCrCb_420_SP:
-        case HAL_PIXEL_FORMAT_YCrCb_420_SP_VENUS:
-        case HAL_PIXEL_FORMAT_YCrCb_422_SP:
-            offset[1] = static_cast<uint32_t>(
-                    reinterpret_cast<uint64_t>(yuvInfo.cr) - hnd->base);
-            break;
-        case HAL_PIXEL_FORMAT_YV12:
-            offset[1] = static_cast<uint32_t>(
-                    reinterpret_cast<uint64_t>(yuvInfo.cr) - hnd->base);
-            stride[2] = static_cast<uint32_t>(yuvInfo.cstride);
-            offset[2] = static_cast<uint32_t>(
-                    reinterpret_cast<uint64_t>(yuvInfo.cb) - hnd->base);
-            (*num_planes)++;
-            break;
-        default:
-            ALOGW("%s: Unsupported format %s", __FUNCTION__,
-                    qdutils::GetHALPixelFormatString(hnd->format));
-            ret = -EINVAL;
-    }
-
-    if (hnd->flags & private_handle_t::PRIV_FLAGS_UBWC_ALIGNED) {
-        std::fill(offset, offset + 4, 0);
-    }
-
-    return 0;
-}
diff --git a/libgralloc/alloc_controller.h b/libgralloc/alloc_controller.h
deleted file mode 100644
index 45977e2..0000000
--- a/libgralloc/alloc_controller.h
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
- * Copyright (c) 2011-2012, 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 GRALLOC_ALLOCCONTROLLER_H
-#define GRALLOC_ALLOCCONTROLLER_H
-
-#define SZ_2M 0x200000
-#define SZ_1M 0x100000
-#define SZ_4K 0x1000
-
-/* TODO: Move this to the common makefile */
-#ifdef MASTER_SIDE_CP
-#define SECURE_ALIGN SZ_4K
-#else
-#define SECURE_ALIGN SZ_1M
-#endif
-
-namespace gralloc {
-
-struct alloc_data;
-class IMemAlloc;
-class IonAlloc;
-
-class IAllocController {
-
-    public:
-    /* Allocate using a suitable method
-     * Returns the type of buffer allocated
-     */
-    virtual int allocate(alloc_data& data, int usage) = 0;
-
-    virtual IMemAlloc* getAllocator(int flags) = 0;
-
-    virtual bool isDisableUBWCForEncoder() = 0;
-
-    virtual ~IAllocController() {};
-
-    static IAllocController* getInstance(void);
-
-    private:
-    static IAllocController* sController;
-
-};
-
-class IonController : public IAllocController {
-
-    public:
-    virtual int allocate(alloc_data& data, int usage);
-
-    virtual IMemAlloc* getAllocator(int flags);
-
-    virtual bool isDisableUBWCForEncoder() {
-        return mDisableUBWCForEncode;
-    }
-
-    IonController();
-
-    private:
-    IonAlloc* mIonAlloc;
-    bool mDisableUBWCForEncode;
-    void allocateIonMem();
-
-};
-} //end namespace gralloc
-#endif // GRALLOC_ALLOCCONTROLLER_H
diff --git a/libgralloc/fb_priv.h b/libgralloc/fb_priv.h
deleted file mode 100644
index e2eba6a..0000000
--- a/libgralloc/fb_priv.h
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- * Copyright (C) 2008 The Android Open Source Project
- * Copyright (c) 2012-2014, The Linux Foundation. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef FB_PRIV_H
-#define FB_PRIV_H
-#include <linux/fb.h>
-#include <linux/msm_mdp.h>
-
-#define NUM_FRAMEBUFFERS_MIN  2
-#define NUM_FRAMEBUFFERS_MAX  3
-
-#define NO_SURFACEFLINGER_SWAPINTERVAL
-#define COLOR_FORMAT(x) (x & 0xFFF) // Max range for colorFormats is 0 - FFF
-
-struct private_handle_t;
-
-enum {
-    // flag to indicate we'll post this buffer
-    PRIV_USAGE_LOCKED_FOR_POST = 0x80000000,
-    PRIV_MIN_SWAP_INTERVAL = 0,
-    PRIV_MAX_SWAP_INTERVAL = 1,
-};
-
-struct private_module_t {
-    gralloc_module_t base;
-    struct private_handle_t* framebuffer;
-    uint32_t fbFormat;
-    uint32_t flags;
-    uint32_t numBuffers;
-    uint32_t bufferMask;
-    pthread_mutex_t lock;
-    struct fb_var_screeninfo info;
-    struct fb_fix_screeninfo finfo;
-    float xdpi;
-    float ydpi;
-    float fps;
-    uint32_t swapInterval;
-};
-
-
-
-#endif /* FB_PRIV_H */
diff --git a/libgralloc/framebuffer.cpp b/libgralloc/framebuffer.cpp
deleted file mode 100644
index dd4842f..0000000
--- a/libgralloc/framebuffer.cpp
+++ /dev/null
@@ -1,457 +0,0 @@
-/*
- * Copyright (C) 2008 The Android Open Source Project
- * Copyright (c) 2010-2014 The Linux Foundation. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <sys/mman.h>
-
-#include <cutils/log.h>
-#include <cutils/properties.h>
-#include <dlfcn.h>
-
-#include <hardware/hardware.h>
-
-#include <fcntl.h>
-#include <errno.h>
-#include <sys/ioctl.h>
-#include <string.h>
-#include <stdlib.h>
-#include <pthread.h>
-#include <cutils/atomic.h>
-
-#include <linux/fb.h>
-#include <linux/msm_mdp.h>
-
-#ifndef TARGET_HEADLESS
-#include <GLES/gl.h>
-#endif
-
-#include "gralloc_priv.h"
-#include "fb_priv.h"
-#include "gr.h"
-#include <cutils/properties.h>
-#include <profiler.h>
-
-#define EVEN_OUT(x) if (x & 0x0001) {x--;}
-
-enum {
-    PAGE_FLIP = 0x00000001,
-};
-
-struct fb_context_t {
-    framebuffer_device_t  device;
-    //fd - which is returned on open
-    int fbFd;
-};
-
-static int fb_setSwapInterval(struct framebuffer_device_t* dev,
-                              int interval)
-{
-    //XXX: Get the value here and implement along with
-    //single vsync in HWC
-    char pval[PROPERTY_VALUE_MAX];
-    property_get("debug.egl.swapinterval", pval, "-1");
-    int property_interval = atoi(pval);
-    if (property_interval >= 0)
-        interval = property_interval;
-
-    private_module_t* m = reinterpret_cast<private_module_t*>(
-        dev->common.module);
-    if (interval < dev->minSwapInterval || interval > dev->maxSwapInterval)
-        return -EINVAL;
-
-    m->swapInterval = interval;
-    return 0;
-}
-
-static int fb_post(struct framebuffer_device_t* dev, buffer_handle_t buffer)
-{
-    private_module_t* m =
-        reinterpret_cast<private_module_t*>(dev->common.module);
-    private_handle_t *hnd = static_cast<private_handle_t*>
-        (const_cast<native_handle_t*>(buffer));
-    fb_context_t *ctx = reinterpret_cast<fb_context_t*>(dev);
-    const unsigned int offset = (unsigned int) (hnd->base -
-            m->framebuffer->base);
-    m->info.activate = FB_ACTIVATE_VBL;
-    m->info.yoffset = (int)(offset / m->finfo.line_length);
-    if (ioctl(ctx->fbFd, FBIOPUT_VSCREENINFO, &m->info) == -1) {
-        ALOGE("%s: FBIOPUT_VSCREENINFO for primary failed, str: %s",
-                __FUNCTION__, strerror(errno));
-        return -errno;
-    }
-    return 0;
-}
-
-static int fb_compositionComplete(struct framebuffer_device_t* dev)
-{
-    // TODO: Properly implement composition complete callback
-    if(!dev) {
-        return -1;
-    }
-#ifndef TARGET_HEADLESS
-    glFinish();
-#endif
-
-    return 0;
-}
-
-int mapFrameBufferLocked(framebuffer_device_t *dev)
-{
-    private_module_t* module =
-        reinterpret_cast<private_module_t*>(dev->common.module);
-    fb_context_t *ctx = reinterpret_cast<fb_context_t*>(dev);
-    // already initialized...
-    if (module->framebuffer) {
-        return 0;
-    }
-    char const * const device_template[] = {
-        "/dev/graphics/fb%u",
-        "/dev/fb%u",
-        0 };
-
-    int fd = -1;
-    int i=0;
-    char name[64];
-    char property[PROPERTY_VALUE_MAX];
-
-    while ((fd==-1) && device_template[i]) {
-        snprintf(name, 64, device_template[i], 0);
-        fd = open(name, O_RDWR, 0);
-        i++;
-    }
-    if (fd < 0)
-        return -errno;
-
-    struct fb_fix_screeninfo finfo;
-    if (ioctl(fd, FBIOGET_FSCREENINFO, &finfo) == -1) {
-        close(fd);
-        return -errno;
-    }
-
-    struct fb_var_screeninfo info;
-    if (ioctl(fd, FBIOGET_VSCREENINFO, &info) == -1) {
-        close(fd);
-        return -errno;
-    }
-
-    info.reserved[0] = 0;
-    info.reserved[1] = 0;
-    info.reserved[2] = 0;
-    info.xoffset = 0;
-    info.yoffset = 0;
-    info.activate = FB_ACTIVATE_NOW;
-
-    /* Interpretation of offset for color fields: All offsets are from the
-     * right, inside a "pixel" value, which is exactly 'bits_per_pixel' wide
-     * (means: you can use the offset as right argument to <<). A pixel
-     * afterwards is a bit stream and is written to video memory as that
-     * unmodified. This implies big-endian byte order if bits_per_pixel is
-     * greater than 8.
-     */
-
-    if(info.bits_per_pixel == 32) {
-        /*
-         * Explicitly request RGBA_8888
-         */
-        info.bits_per_pixel = 32;
-        info.red.offset     = 24;
-        info.red.length     = 8;
-        info.green.offset   = 16;
-        info.green.length   = 8;
-        info.blue.offset    = 8;
-        info.blue.length    = 8;
-        info.transp.offset  = 0;
-        info.transp.length  = 8;
-
-        /* Note: the GL driver does not have a r=8 g=8 b=8 a=0 config, so if we
-         * do not use the MDP for composition (i.e. hw composition == 0), ask
-         * for RGBA instead of RGBX. */
-        if (property_get("debug.sf.hw", property, NULL) > 0 &&
-                                                           atoi(property) == 0)
-            module->fbFormat = HAL_PIXEL_FORMAT_RGBX_8888;
-        else if(property_get("debug.composition.type", property, NULL) > 0 &&
-                (strncmp(property, "mdp", 3) == 0))
-            module->fbFormat = HAL_PIXEL_FORMAT_RGBX_8888;
-        else
-            module->fbFormat = HAL_PIXEL_FORMAT_RGBA_8888;
-    } else {
-        /*
-         * Explicitly request 5/6/5
-         */
-        info.bits_per_pixel = 16;
-        info.red.offset     = 11;
-        info.red.length     = 5;
-        info.green.offset   = 5;
-        info.green.length   = 6;
-        info.blue.offset    = 0;
-        info.blue.length    = 5;
-        info.transp.offset  = 0;
-        info.transp.length  = 0;
-        module->fbFormat = HAL_PIXEL_FORMAT_RGB_565;
-    }
-
-    //adreno needs 4k aligned offsets. Max hole size is 4096-1
-    unsigned int size = roundUpToPageSize(info.yres * info.xres *
-                                               (info.bits_per_pixel/8));
-
-    /*
-     * Request NUM_BUFFERS screens (at least 2 for page flipping)
-     */
-    int numberOfBuffers = (int)(finfo.smem_len/size);
-    ALOGV("num supported framebuffers in kernel = %d", numberOfBuffers);
-
-    if (property_get("debug.gr.numframebuffers", property, NULL) > 0) {
-        int num = atoi(property);
-        if ((num >= NUM_FRAMEBUFFERS_MIN) && (num <= NUM_FRAMEBUFFERS_MAX)) {
-            numberOfBuffers = num;
-        }
-    }
-    if (numberOfBuffers > NUM_FRAMEBUFFERS_MAX)
-        numberOfBuffers = NUM_FRAMEBUFFERS_MAX;
-
-    ALOGV("We support %d buffers", numberOfBuffers);
-
-    //consider the included hole by 4k alignment
-    uint32_t line_length = (info.xres * info.bits_per_pixel / 8);
-    info.yres_virtual = (uint32_t) ((size * numberOfBuffers) / line_length);
-
-    uint32_t flags = PAGE_FLIP;
-
-    if (info.yres_virtual < ((size * 2) / line_length) ) {
-        // we need at least 2 for page-flipping
-        info.yres_virtual = (int)(size / line_length);
-        flags &= ~PAGE_FLIP;
-        ALOGW("page flipping not supported (yres_virtual=%d, requested=%d)",
-              info.yres_virtual, info.yres*2);
-    }
-
-    if (ioctl(fd, FBIOGET_VSCREENINFO, &info) == -1) {
-        close(fd);
-        return -errno;
-    }
-
-    if (int(info.width) <= 0 || int(info.height) <= 0) {
-        // the driver doesn't return that information
-        // default to 160 dpi
-        info.width  = (uint32_t)(((float)(info.xres) * 25.4f)/160.0f + 0.5f);
-        info.height = (uint32_t)(((float)(info.yres) * 25.4f)/160.0f + 0.5f);
-    }
-
-    float xdpi = ((float)(info.xres) * 25.4f) / (float)info.width;
-    float ydpi = ((float)(info.yres) * 25.4f) / (float)info.height;
-
-#ifdef MSMFB_METADATA_GET
-    struct msmfb_metadata metadata;
-    memset(&metadata, 0 , sizeof(metadata));
-    metadata.op = metadata_op_frame_rate;
-    if (ioctl(fd, MSMFB_METADATA_GET, &metadata) == -1) {
-        ALOGE("Error retrieving panel frame rate");
-        close(fd);
-        return -errno;
-    }
-    float fps = (float)metadata.data.panel_frame_rate;
-#else
-    //XXX: Remove reserved field usage on all baselines
-    //The reserved[3] field is used to store FPS by the driver.
-    float fps  = info.reserved[3] & 0xFF;
-#endif
-    ALOGI("using (fd=%d)\n"
-          "id           = %s\n"
-          "xres         = %d px\n"
-          "yres         = %d px\n"
-          "xres_virtual = %d px\n"
-          "yres_virtual = %d px\n"
-          "bpp          = %d\n"
-          "r            = %2u:%u\n"
-          "g            = %2u:%u\n"
-          "b            = %2u:%u\n",
-          fd,
-          finfo.id,
-          info.xres,
-          info.yres,
-          info.xres_virtual,
-          info.yres_virtual,
-          info.bits_per_pixel,
-          info.red.offset, info.red.length,
-          info.green.offset, info.green.length,
-          info.blue.offset, info.blue.length
-         );
-
-    ALOGI("width        = %d mm (%f dpi)\n"
-          "height       = %d mm (%f dpi)\n"
-          "refresh rate = %.2f Hz\n",
-          info.width,  xdpi,
-          info.height, ydpi,
-          fps
-         );
-
-
-    if (ioctl(fd, FBIOGET_FSCREENINFO, &finfo) == -1) {
-        close(fd);
-        return -errno;
-    }
-
-    if (finfo.smem_len <= 0) {
-        close(fd);
-        return -errno;
-    }
-
-    module->flags = flags;
-    module->info = info;
-    module->finfo = finfo;
-    module->xdpi = xdpi;
-    module->ydpi = ydpi;
-    module->fps = fps;
-    module->swapInterval = 1;
-
-    CALC_INIT();
-
-    /*
-     * map the framebuffer
-     */
-
-    module->numBuffers = info.yres_virtual / info.yres;
-    module->bufferMask = 0;
-    //adreno needs page aligned offsets. Align the fbsize to pagesize.
-    unsigned int fbSize = roundUpToPageSize(finfo.line_length * info.yres)*
-                    module->numBuffers;
-    void* vaddr = mmap(0, fbSize, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
-    if (vaddr == MAP_FAILED) {
-        ALOGE("Error mapping the framebuffer (%s)", strerror(errno));
-        close(fd);
-        return -errno;
-    }
-    //store the framebuffer fd in the ctx
-    ctx->fbFd = fd;
-#ifdef MSMFB_METADATA_GET
-    memset(&metadata, 0 , sizeof(metadata));
-    metadata.op = metadata_op_get_ion_fd;
-    // get the ION fd for the framebuffer, as GPU needs ION fd
-    if (ioctl(fd, MSMFB_METADATA_GET, &metadata) == -1) {
-        ALOGE("Error getting ION fd (%s)", strerror(errno));
-        close(fd);
-        return -errno;
-    }
-    if(metadata.data.fbmem_ionfd < 0) {
-        ALOGE("Error: Ioctl returned invalid ION fd = %d",
-                                        metadata.data.fbmem_ionfd);
-        close(fd);
-        return -errno;
-    }
-    fd = metadata.data.fbmem_ionfd;
-#endif
-    // Create framebuffer handle using the ION fd
-    module->framebuffer = new private_handle_t(fd, fbSize,
-                                        private_handle_t::PRIV_FLAGS_USES_ION,
-                                        BUFFER_TYPE_UI,
-                                        module->fbFormat, info.xres, info.yres);
-    module->framebuffer->base = uint64_t(vaddr);
-    memset(vaddr, 0, fbSize);
-    //Enable vsync
-    int enable = 1;
-    ioctl(ctx->fbFd, MSMFB_OVERLAY_VSYNC_CTRL, &enable);
-    return 0;
-}
-
-static int mapFrameBuffer(framebuffer_device_t *dev)
-{
-    int err = -1;
-    char property[PROPERTY_VALUE_MAX];
-    if((property_get("debug.gralloc.map_fb_memory", property, NULL) > 0) &&
-       (!strncmp(property, "1", PROPERTY_VALUE_MAX ) ||
-        (!strncasecmp(property,"true", PROPERTY_VALUE_MAX )))) {
-        private_module_t* module =
-            reinterpret_cast<private_module_t*>(dev->common.module);
-        pthread_mutex_lock(&module->lock);
-        err = mapFrameBufferLocked(dev);
-        pthread_mutex_unlock(&module->lock);
-    }
-    return err;
-}
-
-/*****************************************************************************/
-
-static int fb_close(struct hw_device_t *dev)
-{
-    fb_context_t* ctx = (fb_context_t*)dev;
-    if (ctx) {
-#ifdef MSMFB_METADATA_GET
-        if(ctx->fbFd >=0) {
-            close(ctx->fbFd);
-        }
-#endif
-        //Hack until fbdev is removed. Framework could close this causing hwc a
-        //pain.
-        //free(ctx);
-    }
-    return 0;
-}
-
-int fb_device_open(hw_module_t const* module, const char* name,
-                   hw_device_t** device)
-{
-    int status = -EINVAL;
-    if (!strcmp(name, GRALLOC_HARDWARE_FB0)) {
-        alloc_device_t* gralloc_device;
-        status = gralloc_open(module, &gralloc_device);
-        if (status < 0)
-            return status;
-
-        /* initialize our state here */
-        fb_context_t *dev = (fb_context_t*)malloc(sizeof(*dev));
-        if(dev == NULL) {
-            gralloc_close(gralloc_device);
-            return status;
-        }
-        memset(dev, 0, sizeof(*dev));
-
-        /* initialize the procs */
-        dev->device.common.tag      = HARDWARE_DEVICE_TAG;
-        dev->device.common.version  = 0;
-        dev->device.common.module   = const_cast<hw_module_t*>(module);
-        dev->device.common.close    = fb_close;
-        dev->device.setSwapInterval = fb_setSwapInterval;
-        dev->device.post            = fb_post;
-        dev->device.setUpdateRect   = 0;
-        dev->device.compositionComplete = fb_compositionComplete;
-
-        status = mapFrameBuffer((framebuffer_device_t*)dev);
-        private_module_t* m = (private_module_t*)dev->device.common.module;
-        if (status >= 0) {
-            int stride = m->finfo.line_length / (m->info.bits_per_pixel >> 3);
-            const_cast<uint32_t&>(dev->device.flags) = 0;
-            const_cast<uint32_t&>(dev->device.width) = m->info.xres;
-            const_cast<uint32_t&>(dev->device.height) = m->info.yres;
-            const_cast<int&>(dev->device.stride) = stride;
-            const_cast<int&>(dev->device.format) = m->fbFormat;
-            const_cast<float&>(dev->device.xdpi) = m->xdpi;
-            const_cast<float&>(dev->device.ydpi) = m->ydpi;
-            const_cast<float&>(dev->device.fps) = m->fps;
-            const_cast<int&>(dev->device.minSwapInterval) =
-                                                        PRIV_MIN_SWAP_INTERVAL;
-            const_cast<int&>(dev->device.maxSwapInterval) =
-                                                        PRIV_MAX_SWAP_INTERVAL;
-            const_cast<int&>(dev->device.numFramebuffers) = m->numBuffers;
-            dev->device.setUpdateRect = 0;
-
-            *device = &dev->device.common;
-        }
-
-        // Close the gralloc module
-        gralloc_close(gralloc_device);
-    }
-    return status;
-}
diff --git a/libgralloc/gpu.cpp b/libgralloc/gpu.cpp
deleted file mode 100644
index c57ff90..0000000
--- a/libgralloc/gpu.cpp
+++ /dev/null
@@ -1,423 +0,0 @@
-/*
- * Copyright (C) 2010 The Android Open Source Project
- * Copyright (c) 2011-2014,2017 The Linux Foundation. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <limits.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <cutils/properties.h>
-#include <sys/mman.h>
-#include <linux/msm_ion.h>
-#include <qdMetaData.h>
-#include <algorithm>
-
-#include "gr.h"
-#include "gpu.h"
-#include "memalloc.h"
-#include "alloc_controller.h"
-
-using namespace gralloc;
-
-gpu_context_t::gpu_context_t(const private_module_t* module,
-                             IAllocController* alloc_ctrl ) :
-    mAllocCtrl(alloc_ctrl)
-{
-    // Zero out the alloc_device_t
-    memset(static_cast<alloc_device_t*>(this), 0, sizeof(alloc_device_t));
-
-    // Initialize the procs
-    common.tag     = HARDWARE_DEVICE_TAG;
-    common.version = 0;
-    common.module  = const_cast<hw_module_t*>(&module->base.common);
-    common.close   = gralloc_close;
-    alloc          = gralloc_alloc;
-    free           = gralloc_free;
-
-}
-
-int gpu_context_t::gralloc_alloc_buffer(unsigned int size, int usage,
-                                        buffer_handle_t* pHandle, int bufferType,
-                                        int format, int width, int height)
-{
-    int err = 0;
-    int flags = 0;
-    int alignedw = 0;
-    int alignedh = 0;
-
-    AdrenoMemInfo::getInstance().getAlignedWidthAndHeight(width,
-            height,
-            format,
-            usage,
-            alignedw,
-            alignedh);
-
-    size = roundUpToPageSize(size);
-    alloc_data data;
-    data.offset = 0;
-    data.fd = -1;
-    data.base = 0;
-    if(format == HAL_PIXEL_FORMAT_YCbCr_420_SP_TILED)
-        data.align = 8192;
-    else
-        data.align = getpagesize();
-
-    if (usage & GRALLOC_USAGE_PROTECTED) {
-            if ((usage & GRALLOC_USAGE_PRIVATE_SECURE_DISPLAY) ||
-                (usage & GRALLOC_USAGE_HW_CAMERA_MASK)) {
-                /* The alignment here reflects qsee mmu V7L/V8L requirement */
-                data.align = SZ_2M;
-            } else {
-                data.align = SECURE_ALIGN;
-            }
-        size = ALIGN(size, data.align);
-    }
-
-    data.size = size;
-    data.pHandle = (uintptr_t) pHandle;
-    err = mAllocCtrl->allocate(data, usage);
-
-    if (!err) {
-        /* allocate memory for enhancement data */
-        alloc_data eData;
-        eData.fd = -1;
-        eData.base = 0;
-        eData.offset = 0;
-        eData.size = ROUND_UP_PAGESIZE(sizeof(MetaData_t));
-        eData.pHandle = data.pHandle;
-        eData.align = getpagesize();
-        int eDataUsage = 0;
-        int eDataErr = mAllocCtrl->allocate(eData, eDataUsage);
-        ALOGE_IF(eDataErr, "gralloc failed for eDataErr=%s",
-                                          strerror(-eDataErr));
-
-        if (usage & GRALLOC_USAGE_PRIVATE_EXTERNAL_ONLY) {
-            flags |= private_handle_t::PRIV_FLAGS_EXTERNAL_ONLY;
-        }
-
-        if (usage & GRALLOC_USAGE_PRIVATE_INTERNAL_ONLY) {
-            flags |= private_handle_t::PRIV_FLAGS_INTERNAL_ONLY;
-        }
-
-        if (usage & GRALLOC_USAGE_HW_VIDEO_ENCODER ) {
-            flags |= private_handle_t::PRIV_FLAGS_VIDEO_ENCODER;
-        }
-
-        if (usage & GRALLOC_USAGE_HW_CAMERA_WRITE) {
-            flags |= private_handle_t::PRIV_FLAGS_CAMERA_WRITE;
-        }
-
-        if (usage & GRALLOC_USAGE_HW_CAMERA_READ) {
-            flags |= private_handle_t::PRIV_FLAGS_CAMERA_READ;
-        }
-
-        if (usage & GRALLOC_USAGE_HW_COMPOSER) {
-            flags |= private_handle_t::PRIV_FLAGS_HW_COMPOSER;
-        }
-
-        if (usage & GRALLOC_USAGE_HW_TEXTURE) {
-            flags |= private_handle_t::PRIV_FLAGS_HW_TEXTURE;
-        }
-
-        if(usage & GRALLOC_USAGE_PRIVATE_SECURE_DISPLAY) {
-            flags |= private_handle_t::PRIV_FLAGS_SECURE_DISPLAY;
-        }
-
-        if (isUBwcEnabled(format, usage)) {
-            flags |= private_handle_t::PRIV_FLAGS_UBWC_ALIGNED;
-        }
-
-        if(usage & (GRALLOC_USAGE_SW_READ_MASK | GRALLOC_USAGE_SW_WRITE_MASK)) {
-            flags |= private_handle_t::PRIV_FLAGS_CPU_RENDERED;
-        }
-
-        if (usage & (GRALLOC_USAGE_HW_VIDEO_ENCODER |
-                GRALLOC_USAGE_HW_CAMERA_WRITE |
-                GRALLOC_USAGE_HW_RENDER |
-                GRALLOC_USAGE_HW_FB)) {
-            flags |= private_handle_t::PRIV_FLAGS_NON_CPU_WRITER;
-        }
-
-        if(usage & GRALLOC_USAGE_HW_COMPOSER) {
-            flags |= private_handle_t::PRIV_FLAGS_DISP_CONSUMER;
-        }
-
-        if(false == data.uncached) {
-            flags |= private_handle_t::PRIV_FLAGS_CACHED;
-        }
-
-        flags |= data.allocType;
-        uint64_t eBaseAddr = (uint64_t)(eData.base) + eData.offset;
-        private_handle_t *hnd = new private_handle_t(data.fd, size, flags,
-                bufferType, format, alignedw, alignedh,
-                eData.fd, eData.offset, eBaseAddr, width, height);
-
-        hnd->offset = data.offset;
-        hnd->base = (uint64_t)(data.base) + data.offset;
-        hnd->gpuaddr = 0;
-        ColorSpace_t colorSpace = ITU_R_601;
-        setMetaData(hnd, UPDATE_COLOR_SPACE, (void*) &colorSpace);
-        *pHandle = hnd;
-    }
-
-    ALOGE_IF(err, "gralloc failed err=%s", strerror(-err));
-    return err;
-}
-
-void gpu_context_t::getGrallocInformationFromFormat(int inputFormat,
-                                                    int *bufferType)
-{
-    *bufferType = BUFFER_TYPE_VIDEO;
-
-    if (isUncompressedRgbFormat(inputFormat) == TRUE) {
-        // RGB formats
-        *bufferType = BUFFER_TYPE_UI;
-    }
-}
-
-int gpu_context_t::gralloc_alloc_framebuffer_locked(int usage,
-                                                    buffer_handle_t* pHandle)
-{
-    private_module_t* m = reinterpret_cast<private_module_t*>(common.module);
-
-    // This allocation will only happen when gralloc is in fb mode
-
-    if (m->framebuffer == NULL) {
-        ALOGE("%s: Invalid framebuffer", __FUNCTION__);
-        return -EINVAL;
-    }
-
-    const unsigned int bufferMask = m->bufferMask;
-    const uint32_t numBuffers = m->numBuffers;
-    unsigned int bufferSize = m->finfo.line_length * m->info.yres;
-
-    //adreno needs FB size to be page aligned
-    bufferSize = roundUpToPageSize(bufferSize);
-
-    if (numBuffers == 1) {
-        // If we have only one buffer, we never use page-flipping. Instead,
-        // we return a regular buffer which will be memcpy'ed to the main
-        // screen when post is called.
-        int newUsage = (usage & ~GRALLOC_USAGE_HW_FB) | GRALLOC_USAGE_HW_2D;
-        return gralloc_alloc_buffer(bufferSize, newUsage, pHandle, BUFFER_TYPE_UI,
-                                    m->fbFormat, m->info.xres, m->info.yres);
-    }
-
-    if (bufferMask >= ((1LU<<numBuffers)-1)) {
-        // We ran out of buffers.
-        return -ENOMEM;
-    }
-
-    // create a "fake" handle for it
-    uint64_t vaddr = uint64_t(m->framebuffer->base);
-    // As GPU needs ION FD, the private handle is created
-    // using ION fd and ION flags are set
-    private_handle_t* hnd = new private_handle_t(
-        dup(m->framebuffer->fd), bufferSize,
-        private_handle_t::PRIV_FLAGS_USES_ION |
-        private_handle_t::PRIV_FLAGS_FRAMEBUFFER,
-        BUFFER_TYPE_UI, m->fbFormat, m->info.xres,
-        m->info.yres);
-
-    // find a free slot
-    for (uint32_t i=0 ; i<numBuffers ; i++) {
-        if ((bufferMask & (1LU<<i)) == 0) {
-            m->bufferMask |= (uint32_t)(1LU<<i);
-            break;
-        }
-        vaddr += bufferSize;
-    }
-    hnd->base = vaddr;
-    hnd->offset = (unsigned int)(vaddr - m->framebuffer->base);
-    *pHandle = hnd;
-    return 0;
-}
-
-
-int gpu_context_t::gralloc_alloc_framebuffer(int usage,
-                                             buffer_handle_t* pHandle)
-{
-    private_module_t* m = reinterpret_cast<private_module_t*>(common.module);
-    pthread_mutex_lock(&m->lock);
-    int err = gralloc_alloc_framebuffer_locked(usage, pHandle);
-    pthread_mutex_unlock(&m->lock);
-    return err;
-}
-
-int gpu_context_t::alloc_impl(int w, int h, int format, int usage,
-                              buffer_handle_t* pHandle, int* pStride,
-                              unsigned int bufferSize) {
-    if (!pHandle || !pStride)
-        return -EINVAL;
-
-    unsigned int size;
-    int alignedw, alignedh;
-    int grallocFormat = format;
-    int bufferType;
-
-    //If input format is HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED then based on
-    //the usage bits, gralloc assigns a format.
-    if(format == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED ||
-       format == HAL_PIXEL_FORMAT_YCbCr_420_888) {
-        if (usage & GRALLOC_USAGE_PRIVATE_ALLOC_UBWC)
-            grallocFormat = HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC;
-        else if(usage & GRALLOC_USAGE_HW_VIDEO_ENCODER) {
-            if(MDPCapabilityInfo::getInstance().isWBUBWCSupportedByMDP() &&
-               !IAllocController::getInstance()->isDisableUBWCForEncoder() &&
-               usage & GRALLOC_USAGE_HW_COMPOSER)
-              grallocFormat = HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC;
-            else
-              grallocFormat = HAL_PIXEL_FORMAT_NV12_ENCODEABLE; //NV12
-        } else if((usage & GRALLOC_USAGE_HW_CAMERA_MASK)
-                == GRALLOC_USAGE_HW_CAMERA_ZSL)
-            grallocFormat = HAL_PIXEL_FORMAT_NV21_ZSL; //NV21 ZSL
-        else if(usage & GRALLOC_USAGE_HW_CAMERA_READ)
-            grallocFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP; //NV21
-        else if(usage & GRALLOC_USAGE_HW_CAMERA_WRITE) {
-           if (format == HAL_PIXEL_FORMAT_YCbCr_420_888) {
-               grallocFormat = HAL_PIXEL_FORMAT_NV21_ZSL; //NV21
-           } else {
-               grallocFormat = HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS; //NV12 preview
-           }
-        } else if(usage & GRALLOC_USAGE_HW_COMPOSER)
-            //XXX: If we still haven't set a format, default to RGBA8888
-            grallocFormat = HAL_PIXEL_FORMAT_RGBA_8888;
-        else if(format == HAL_PIXEL_FORMAT_YCbCr_420_888) {
-            //If no other usage flags are detected, default the
-            //flexible YUV format to NV21_ZSL
-            grallocFormat = HAL_PIXEL_FORMAT_NV21_ZSL;
-        }
-    }
-
-    bool useFbMem = false;
-    char property[PROPERTY_VALUE_MAX];
-    char isUBWC[PROPERTY_VALUE_MAX];
-    if (usage & GRALLOC_USAGE_HW_FB) {
-        if ((property_get("debug.gralloc.map_fb_memory", property, NULL) > 0) &&
-            (!strncmp(property, "1", PROPERTY_VALUE_MAX ) ||
-            (!strncasecmp(property,"true", PROPERTY_VALUE_MAX )))) {
-            useFbMem = true;
-        } else {
-            usage &= ~GRALLOC_USAGE_PRIVATE_ALLOC_UBWC;
-            if (property_get("debug.gralloc.enable_fb_ubwc", isUBWC, NULL) > 0){
-                if ((!strncmp(isUBWC, "1", PROPERTY_VALUE_MAX)) ||
-                    (!strncasecmp(isUBWC, "true", PROPERTY_VALUE_MAX))) {
-                    // Allocate UBWC aligned framebuffer
-                    usage |= GRALLOC_USAGE_PRIVATE_ALLOC_UBWC;
-                }
-            }
-        }
-    }
-
-    getGrallocInformationFromFormat(grallocFormat, &bufferType);
-    size = getBufferSizeAndDimensions(w, h, grallocFormat, usage, alignedw,
-                   alignedh);
-
-    if ((unsigned int)size <= 0)
-        return -EINVAL;
-    size = (bufferSize >= size)? bufferSize : size;
-
-    int err = 0;
-    if(useFbMem) {
-        err = gralloc_alloc_framebuffer(usage, pHandle);
-    } else {
-        err = gralloc_alloc_buffer(size, usage, pHandle, bufferType,
-                                   grallocFormat, w, h);
-    }
-
-    if (err < 0) {
-        return err;
-    }
-
-    *pStride = alignedw;
-    return 0;
-}
-
-int gpu_context_t::free_impl(private_handle_t const* hnd) {
-    private_module_t* m = reinterpret_cast<private_module_t*>(common.module);
-    if (hnd->flags & private_handle_t::PRIV_FLAGS_FRAMEBUFFER) {
-        const unsigned int bufferSize = m->finfo.line_length * m->info.yres;
-        unsigned int index = (unsigned int) ((hnd->base - m->framebuffer->base)
-                / bufferSize);
-        m->bufferMask &= (uint32_t)~(1LU<<index);
-    } else {
-
-        terminateBuffer(&m->base, const_cast<private_handle_t*>(hnd));
-        IMemAlloc* memalloc = mAllocCtrl->getAllocator(hnd->flags);
-        int err = memalloc->free_buffer((void*)hnd->base, hnd->size,
-                                        hnd->offset, hnd->fd);
-        if(err)
-            return err;
-        // free the metadata space
-        unsigned int size = ROUND_UP_PAGESIZE(sizeof(MetaData_t));
-        err = memalloc->free_buffer((void*)hnd->base_metadata,
-                                    size, hnd->offset_metadata,
-                                    hnd->fd_metadata);
-        if (err)
-            return err;
-    }
-
-    delete hnd;
-    return 0;
-}
-
-int gpu_context_t::gralloc_alloc(alloc_device_t* dev, int w, int h, int format,
-                                 int usage, buffer_handle_t* pHandle,
-                                 int* pStride)
-{
-    if (!dev) {
-        return -EINVAL;
-    }
-    gpu_context_t* gpu = reinterpret_cast<gpu_context_t*>(dev);
-    return gpu->alloc_impl(w, h, format, usage, pHandle, pStride, 0);
-}
-int gpu_context_t::gralloc_alloc_size(alloc_device_t* dev, int w, int h,
-                                      int format, int usage,
-                                      buffer_handle_t* pHandle, int* pStride,
-                                      int bufferSize)
-{
-    if (!dev) {
-        return -EINVAL;
-    }
-    gpu_context_t* gpu = reinterpret_cast<gpu_context_t*>(dev);
-    return gpu->alloc_impl(w, h, format, usage, pHandle, pStride, bufferSize);
-}
-
-
-int gpu_context_t::gralloc_free(alloc_device_t* dev,
-                                buffer_handle_t handle)
-{
-    if (private_handle_t::validate(handle) < 0)
-        return -EINVAL;
-
-    private_handle_t const* hnd = reinterpret_cast<private_handle_t const*>(handle);
-    gpu_context_t* gpu = reinterpret_cast<gpu_context_t*>(dev);
-    return gpu->free_impl(hnd);
-}
-
-/*****************************************************************************/
-
-int gpu_context_t::gralloc_close(struct hw_device_t *dev)
-{
-    gpu_context_t* ctx = reinterpret_cast<gpu_context_t*>(dev);
-    if (ctx) {
-        /* TODO: keep a list of all buffer_handle_t created, and free them
-         * all here.
-         */
-        delete ctx;
-    }
-    return 0;
-}
-
diff --git a/libgralloc/gpu.h b/libgralloc/gpu.h
deleted file mode 100644
index 2248d30..0000000
--- a/libgralloc/gpu.h
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
- * Copyright (C) 2008 The Android Open Source Project
- * Copyright (c) 2011-2014, The Linux Foundation. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef GRALLOC_GPU_H_
-#define GRALLOC_GPU_H_
-
-#include <errno.h>
-#include <pthread.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include <cutils/log.h>
-
-#include "gralloc_priv.h"
-#include "fb_priv.h"
-
-namespace gralloc {
-class IAllocController;
-class gpu_context_t : public alloc_device_t {
-    public:
-    gpu_context_t(const private_module_t* module,
-                  IAllocController* alloc_ctrl);
-
-    int gralloc_alloc_buffer(unsigned int size, int usage,
-                             buffer_handle_t* pHandle,
-                             int bufferType, int format,
-                             int width, int height);
-
-    int free_impl(private_handle_t const* hnd);
-
-    int alloc_impl(int w, int h, int format, int usage,
-                   buffer_handle_t* pHandle, int* pStride,
-                   unsigned int bufferSize = 0);
-
-    static int gralloc_alloc(alloc_device_t* dev, int w, int h,
-                             int format, int usage,
-                             buffer_handle_t* pHandle,
-                             int* pStride);
-    int gralloc_alloc_framebuffer_locked(int usage,
-                                         buffer_handle_t* pHandle);
-
-    int gralloc_alloc_framebuffer(int usage,
-                                  buffer_handle_t* pHandle);
-
-    static int gralloc_free(alloc_device_t* dev, buffer_handle_t handle);
-
-    static int gralloc_alloc_size(alloc_device_t* dev,
-                                  int w, int h, int format,
-                                  int usage, buffer_handle_t* pHandle,
-                                  int* pStride, int bufferSize);
-
-    static int gralloc_close(struct hw_device_t *dev);
-
-    private:
-   IAllocController* mAllocCtrl;
-    void getGrallocInformationFromFormat(int inputFormat,
-                                         int *bufferType);
-};
-}
-#endif  // GRALLOC_GPU_H
diff --git a/libgralloc/gr.h b/libgralloc/gr.h
deleted file mode 100644
index dad4a38..0000000
--- a/libgralloc/gr.h
+++ /dev/null
@@ -1,218 +0,0 @@
-/*
- * Copyright (C) 2008 The Android Open Source Project
- * Copyright (c) 2011 - 2017, The Linux Foundation. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef GR_H_
-#define GR_H_
-
-#include <stdint.h>
-#include <limits.h>
-#include <sys/cdefs.h>
-#include <hardware/gralloc.h>
-#include <pthread.h>
-#include <errno.h>
-#include <unistd.h>
-
-#include <cutils/native_handle.h>
-#include <utils/Singleton.h>
-#include "adreno_utils.h"
-
-/*****************************************************************************/
-
-struct private_module_t;
-struct private_handle_t;
-
-inline unsigned int roundUpToPageSize(unsigned int x) {
-    return (x + (getpagesize()-1)) & ~(getpagesize()-1);
-}
-
-template <class Type>
-inline Type ALIGN(Type x, Type align) {
-    return (x + align-1) & ~(align-1);
-}
-
-#define FALSE 0
-#define TRUE  1
-
-int mapFrameBufferLocked(struct private_module_t* module);
-int terminateBuffer(gralloc_module_t const* module, private_handle_t* hnd);
-unsigned int getBufferSizeAndDimensions(int width, int height, int format,
-        int usage, int& alignedw, int &alignedh);
-unsigned int getBufferSizeAndDimensions(int width, int height, int format,
-        int& alignedw, int &alignedh);
-
-int decideBufferHandlingMechanism(int format, const char *compositionUsed,
-                                  int hasBlitEngine, int *needConversion,
-                                  int *useBufferDirectly);
-
-// Allocate buffer from width, height, format into a private_handle_t
-// It is the responsibility of the caller to free the buffer
-int alloc_buffer(private_handle_t **pHnd, int w, int h, int format, int usage);
-void free_buffer(private_handle_t *hnd);
-int getYUVPlaneInfo(private_handle_t* pHnd, struct android_ycbcr* ycbcr);
-int getRgbDataAddress(private_handle_t* pHnd, void** rgb_data);
-
-// To query if UBWC is enabled, based on format and usage flags
-bool isUBwcEnabled(int format, int usage);
-
-// Function to check if the format is an RGB format
-bool isUncompressedRgbFormat(int format);
-
-// Returns number of planes, stride and offset of each plane for a given w,h,f
-int getBufferLayout(private_handle_t *hnd, uint32_t stride[4],
-        uint32_t offset[4], uint32_t *num_planes);
-/*****************************************************************************/
-
-class Locker {
-    pthread_mutex_t mutex;
-    pthread_cond_t cond;
-    public:
-    class Autolock {
-        Locker& locker;
-        public:
-        inline Autolock(Locker& locker) : locker(locker) {  locker.lock(); }
-        inline ~Autolock() { locker.unlock(); }
-    };
-    inline Locker()        {
-        pthread_mutex_init(&mutex, 0);
-        pthread_cond_init(&cond, 0);
-    }
-    inline ~Locker()       {
-        pthread_mutex_destroy(&mutex);
-        pthread_cond_destroy(&cond);
-    }
-    inline void lock()     { pthread_mutex_lock(&mutex); }
-    inline void wait()     { pthread_cond_wait(&cond, &mutex); }
-    inline void unlock()   { pthread_mutex_unlock(&mutex); }
-    inline void signal()   { pthread_cond_signal(&cond); }
-};
-
-
-class AdrenoMemInfo : public android::Singleton <AdrenoMemInfo>
-{
-    public:
-    AdrenoMemInfo();
-
-    ~AdrenoMemInfo();
-
-    /*
-     * Function to compute aligned width and aligned height based on
-     * width, height, format and usage flags.
-     *
-     * @return aligned width, aligned height
-     */
-    void getAlignedWidthAndHeight(int width, int height, int format,
-                            int usage, int& aligned_w, int& aligned_h);
-
-    /*
-     * Function to compute aligned width and aligned height based on
-     * private handle
-     *
-     * @return aligned width, aligned height
-     */
-    void getAlignedWidthAndHeight(const private_handle_t *hnd, int& aligned_w, int& aligned_h);
-
-    /*
-     * Function to compute the adreno aligned width and aligned height
-     * based on the width and format.
-     *
-     * @return aligned width, aligned height
-     */
-    void getGpuAlignedWidthHeight(int width, int height, int format,
-                            int tileEnabled, int& alignedw, int &alignedh);
-
-    /*
-     * Function to compute unaligned width and unaligned height based on
-     * private handle
-     *
-     * @return unaligned width, unaligned height
-     */
-    void getUnalignedWidthAndHeight(const private_handle_t *hnd, int& unaligned_w,
-                            int& unaligned_h);
-    /*
-     * Function to query whether GPU supports UBWC for given HAL format
-     * @return > 0 : supported
-     *           0 : not supported
-     */
-    int isUBWCSupportedByGPU(int format);
-
-    /*
-     * Function to get the corresponding Adreno format for given HAL format
-     */
-    ADRENOPIXELFORMAT getGpuPixelFormat(int hal_format);
-
-    private:
-        // Overriding flag to disable UBWC alloc for graphics stack
-        int  gfx_ubwc_disable;
-        // Pointer to the padding library.
-        void *libadreno_utils;
-
-        // link(s)to adreno surface padding library.
-        int (*LINK_adreno_compute_padding) (int width, int bpp,
-                                                int surface_tile_height,
-                                                int screen_tile_height,
-                                                int padding_threshold);
-
-        void (*LINK_adreno_compute_aligned_width_and_height) (int width,
-                                                int height,
-                                                int bpp,
-                                                int tile_mode,
-                                                int raster_mode,
-                                                int padding_threshold,
-                                                int *aligned_w,
-                                                int *aligned_h);
-
-        void(*LINK_adreno_compute_compressedfmt_aligned_width_and_height)(
-                                                int width,
-                                                int height,
-                                                int format,
-                                                int tile_mode,
-                                                int raster_mode,
-                                                int padding_threshold,
-                                                int *aligned_w,
-                                                int *aligned_h,
-                                                int *bpp);
-
-        int (*LINK_adreno_isUBWCSupportedByGpu) (ADRENOPIXELFORMAT format);
-
-        unsigned int (*LINK_adreno_get_gpu_pixel_alignment) ();
-};
-
-
-class MDPCapabilityInfo : public android::Singleton <MDPCapabilityInfo>
-{
-    int isUBwcSupported = 0;
-    int isWBUBWCSupported = 0;
-
-    public:
-        MDPCapabilityInfo();
-        /*
-        * Function to return whether MDP supports UBWC feature
-        *
-        * @return  1 : supported
-        *          0 : not supported
-        */
-        int isUBwcSupportedByMDP() { return isUBwcSupported; }
-        /*
-        * Function to return whether MDP WB block outputs UBWC format
-        *
-        * @return  1 : supported
-        *          0 : not supported
-        */
-        int isWBUBWCSupportedByMDP() { return isWBUBWCSupported; }
-};
-
-#endif /* GR_H_ */
diff --git a/libgralloc/gralloc.cpp b/libgralloc/gralloc.cpp
deleted file mode 100644
index 237b8a8..0000000
--- a/libgralloc/gralloc.cpp
+++ /dev/null
@@ -1,116 +0,0 @@
-/*
- * Copyright (C) 2008, The Android Open Source Project
- * Copyright (c) 2011-2012, The Linux Foundation. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <unistd.h>
-#include <fcntl.h>
-
-#include <sys/mman.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <sys/ioctl.h>
-#include <cutils/properties.h>
-
-#include "gr.h"
-#include "gpu.h"
-#include "memalloc.h"
-#include "alloc_controller.h"
-
-using namespace gralloc;
-
-int fb_device_open(const hw_module_t* module, const char* name,
-                   hw_device_t** device);
-
-static int gralloc_device_open(const hw_module_t* module, const char* name,
-                               hw_device_t** device);
-
-extern int gralloc_lock(gralloc_module_t const* module,
-                        buffer_handle_t handle, int usage,
-                        int l, int t, int w, int h,
-                        void** vaddr);
-
-extern int gralloc_lock_ycbcr(gralloc_module_t const* module,
-                        buffer_handle_t handle, int usage,
-                        int l, int t, int w, int h,
-                        struct android_ycbcr *ycbcr);
-
-extern int gralloc_unlock(gralloc_module_t const* module,
-                          buffer_handle_t handle);
-
-extern int gralloc_register_buffer(gralloc_module_t const* module,
-                                   buffer_handle_t handle);
-
-extern int gralloc_unregister_buffer(gralloc_module_t const* module,
-                                     buffer_handle_t handle);
-
-extern int gralloc_perform(struct gralloc_module_t const* module,
-                           int operation, ... );
-
-// HAL module methods
-static struct hw_module_methods_t gralloc_module_methods = {
-    .open = gralloc_device_open
-};
-
-// HAL module initialize
-struct private_module_t HAL_MODULE_INFO_SYM = {
-    .base = {
-        .common = {
-            .tag = HARDWARE_MODULE_TAG,
-            .version_major = 1,
-            .version_minor = 0,
-            .id = GRALLOC_HARDWARE_MODULE_ID,
-            .name = "Graphics Memory Allocator Module",
-            .author = "The Android Open Source Project",
-            .methods = &gralloc_module_methods,
-            .dso = 0,
-            .reserved = {0},
-        },
-        .registerBuffer = gralloc_register_buffer,
-        .unregisterBuffer = gralloc_unregister_buffer,
-        .lock = gralloc_lock,
-        .unlock = gralloc_unlock,
-        .perform = gralloc_perform,
-        .lock_ycbcr = gralloc_lock_ycbcr,
-    },
-    .framebuffer = 0,
-    .fbFormat = 0,
-    .flags = 0,
-    .numBuffers = 0,
-    .bufferMask = 0,
-    .lock = PTHREAD_MUTEX_INITIALIZER,
-};
-
-// Open Gralloc device
-int gralloc_device_open(const hw_module_t* module, const char* name,
-                        hw_device_t** device)
-{
-    int status = -EINVAL;
-    if (!strcmp(name, GRALLOC_HARDWARE_GPU0)) {
-        const private_module_t* m = reinterpret_cast<const private_module_t*>(
-            module);
-        gpu_context_t *dev;
-        IAllocController* alloc_ctrl = IAllocController::getInstance();
-        dev = new gpu_context_t(m, alloc_ctrl);
-        if(!dev)
-            return status;
-
-        *device = &dev->common;
-        status = 0;
-    } else {
-        status = fb_device_open(module, name, device);
-    }
-    return status;
-}
diff --git a/libgralloc/gralloc_priv.h b/libgralloc/gralloc_priv.h
index 0f1f97a..f0c6b4d 100644
--- a/libgralloc/gralloc_priv.h
+++ b/libgralloc/gralloc_priv.h
@@ -26,6 +26,14 @@
 #include <errno.h>
 #include <unistd.h>
 
+
+/* DEPRECATION NOTICE: This file is no longer used, please use the new
+ * implementation in libgralloc1
+ */
+
+
+
+
 #include <cutils/native_handle.h>
 
 #include <cutils/log.h>
diff --git a/libgralloc/ionalloc.cpp b/libgralloc/ionalloc.cpp
deleted file mode 100644
index 329e30f..0000000
--- a/libgralloc/ionalloc.cpp
+++ /dev/null
@@ -1,236 +0,0 @@
-/*
- * Copyright (c) 2011-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.
- */
-
-#define DEBUG 0
-#define ATRACE_TAG (ATRACE_TAG_GRAPHICS | ATRACE_TAG_HAL)
-#include <sys/ioctl.h>
-#include <sys/mman.h>
-#include <stdlib.h>
-#include <fcntl.h>
-#include <cutils/log.h>
-#include <errno.h>
-#include <utils/Trace.h>
-#include <cutils/trace.h>
-#include "gralloc_priv.h"
-#include "ionalloc.h"
-
-using gralloc::IonAlloc;
-
-#define ION_DEVICE "/dev/ion"
-
-int IonAlloc::open_device()
-{
-    if(mIonFd == FD_INIT)
-        mIonFd = open(ION_DEVICE, O_RDONLY);
-
-    if(mIonFd < 0 ) {
-        ALOGE("%s: Failed to open ion device - %s",
-              __FUNCTION__, strerror(errno));
-        mIonFd = FD_INIT;
-        return -errno;
-    }
-    return 0;
-}
-
-void IonAlloc::close_device()
-{
-    if(mIonFd >= 0)
-        close(mIonFd);
-    mIonFd = FD_INIT;
-}
-
-int IonAlloc::alloc_buffer(alloc_data& data)
-{
-    ATRACE_CALL();
-    Locker::Autolock _l(mLock);
-    int err = 0;
-    struct ion_handle_data handle_data;
-    struct ion_fd_data fd_data;
-    struct ion_allocation_data ionAllocData;
-    void *base = 0;
-
-    ionAllocData.len = data.size;
-    ionAllocData.align = data.align;
-    ionAllocData.heap_id_mask = data.heapId;
-    ionAllocData.flags = data.flags;
-    ionAllocData.flags |= data.uncached ? 0 : ION_FLAG_CACHED;
-    err = open_device();
-    if (err)
-        return err;
-    if(ioctl(mIonFd, ION_IOC_ALLOC, &ionAllocData)) {
-        err = -errno;
-        ALOGE("ION_IOC_ALLOC failed with error - %s", strerror(errno));
-        return err;
-    }
-
-    fd_data.handle = ionAllocData.handle;
-    handle_data.handle = ionAllocData.handle;
-    if(ioctl(mIonFd, ION_IOC_MAP, &fd_data)) {
-        err = -errno;
-        ALOGE("%s: ION_IOC_MAP failed with error - %s",
-              __FUNCTION__, strerror(errno));
-        ioctl(mIonFd, ION_IOC_FREE, &handle_data);
-        return err;
-    }
-
-    if(!(data.flags & ION_SECURE)) {
-        base = mmap(0, ionAllocData.len, PROT_READ|PROT_WRITE,
-                    MAP_SHARED, fd_data.fd, 0);
-        if(base == MAP_FAILED) {
-            err = -errno;
-            ALOGE("%s: Failed to map the allocated memory: %s",
-                  __FUNCTION__, strerror(errno));
-            ioctl(mIonFd, ION_IOC_FREE, &handle_data);
-            return err;
-        }
-    }
-
-    data.base = base;
-    data.fd = fd_data.fd;
-    ioctl(mIonFd, ION_IOC_FREE, &handle_data);
-    ALOGD_IF(DEBUG, "ion: Allocated buffer base:%p size:%zu fd:%d",
-          data.base, ionAllocData.len, data.fd);
-    return 0;
-}
-
-
-int IonAlloc::free_buffer(void* base, unsigned int size, unsigned int offset,
-        int fd)
-{
-    ATRACE_CALL();
-    Locker::Autolock _l(mLock);
-    ALOGD_IF(DEBUG, "ion: Freeing buffer base:%p size:%u fd:%d",
-          base, size, fd);
-    int err = 0;
-    err = open_device();
-    if (err)
-        return err;
-
-    if(base)
-        err = unmap_buffer(base, size, offset);
-    close(fd);
-    return err;
-}
-
-int IonAlloc::map_buffer(void **pBase, unsigned int size, unsigned int offset,
-        int fd)
-{
-    ATRACE_CALL();
-    int err = 0;
-    void *base = 0;
-    // It is a (quirky) requirement of ION to have opened the
-    // ion fd in the process that is doing the mapping
-    err = open_device();
-    if (err)
-        return err;
-
-    base = mmap(0, size, PROT_READ| PROT_WRITE,
-                MAP_SHARED, fd, 0);
-    *pBase = base;
-    if(base == MAP_FAILED) {
-        err = -errno;
-        ALOGE("ion: Failed to map memory in the client: %s",
-              strerror(errno));
-    } else {
-        ALOGD_IF(DEBUG, "ion: Mapped buffer base:%p size:%u offset:%u fd:%d",
-              base, size, offset, fd);
-    }
-    return err;
-}
-
-int IonAlloc::unmap_buffer(void *base, unsigned int size,
-        unsigned int /*offset*/)
-{
-    ATRACE_CALL();
-    ALOGD_IF(DEBUG, "ion: Unmapping buffer  base:%p size:%u", base, size);
-    int err = 0;
-    if(munmap(base, size)) {
-        err = -errno;
-        ALOGE("ion: Failed to unmap memory at %p : %s",
-              base, strerror(errno));
-    }
-    return err;
-
-}
-int IonAlloc::clean_buffer(void *base, unsigned int size, unsigned int offset,
-        int fd, int op)
-{
-    ATRACE_CALL();
-    ATRACE_INT("operation id", op);
-    struct ion_flush_data flush_data;
-    struct ion_fd_data fd_data;
-    struct ion_handle_data handle_data;
-    int err = 0;
-
-    err = open_device();
-    if (err)
-        return err;
-
-    fd_data.fd = fd;
-    if (ioctl(mIonFd, ION_IOC_IMPORT, &fd_data)) {
-        err = -errno;
-        ALOGE("%s: ION_IOC_IMPORT failed with error - %s",
-              __FUNCTION__, strerror(errno));
-        return err;
-    }
-
-    handle_data.handle = fd_data.handle;
-    flush_data.handle  = fd_data.handle;
-    flush_data.vaddr   = base;
-    // offset and length are unsigned int
-    flush_data.offset  = offset;
-    flush_data.length  = size;
-
-    struct ion_custom_data d;
-    switch(op) {
-    case CACHE_CLEAN:
-        d.cmd = ION_IOC_CLEAN_CACHES;
-        break;
-    case CACHE_INVALIDATE:
-            d.cmd = ION_IOC_INV_CACHES;
-        break;
-    case CACHE_CLEAN_AND_INVALIDATE:
-    default:
-        d.cmd = ION_IOC_CLEAN_INV_CACHES;
-    }
-
-    d.arg = (unsigned long int)&flush_data;
-
-    if(ioctl(mIonFd, ION_IOC_CUSTOM, &d)) {
-        err = -errno;
-        ALOGE("%s: ION_IOC_CLEAN_INV_CACHES failed with error - %s",
-
-              __FUNCTION__, strerror(errno));
-        ioctl(mIonFd, ION_IOC_FREE, &handle_data);
-        return err;
-    }
-    ioctl(mIonFd, ION_IOC_FREE, &handle_data);
-    return 0;
-}
-
diff --git a/libgralloc/ionalloc.h b/libgralloc/ionalloc.h
deleted file mode 100644
index 635bda5..0000000
--- a/libgralloc/ionalloc.h
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
- * Copyright (c) 2011-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 GRALLOC_IONALLOC_H
-#define GRALLOC_IONALLOC_H
-
-#include <linux/msm_ion.h>
-#include "memalloc.h"
-#include "gr.h"
-
-namespace gralloc {
-
-class IonAlloc : public IMemAlloc  {
-
-    public:
-    virtual int alloc_buffer(alloc_data& data);
-
-    virtual int free_buffer(void *base, unsigned int size,
-                            unsigned int offset, int fd);
-
-    virtual int map_buffer(void **pBase, unsigned int size,
-                           unsigned int offset, int fd);
-
-    virtual int unmap_buffer(void *base, unsigned int size,
-                             unsigned int offset);
-
-    virtual int clean_buffer(void*base, unsigned int size,
-                             unsigned int offset, int fd, int op);
-
-    IonAlloc() { mIonFd = FD_INIT; }
-
-    ~IonAlloc() { close_device(); }
-
-    private:
-    int mIonFd;
-
-    int open_device();
-
-    void close_device();
-
-    mutable Locker mLock;
-
-};
-
-}
-
-#endif /* GRALLOC_IONALLOC_H */
-
diff --git a/libgralloc/mapper.cpp b/libgralloc/mapper.cpp
deleted file mode 100644
index acf5e2c..0000000
--- a/libgralloc/mapper.cpp
+++ /dev/null
@@ -1,523 +0,0 @@
-/*
- * Copyright (C) 2008 The Android Open Source Project
- * Copyright (c) 2011-2017, The Linux Foundation. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#define ATRACE_TAG (ATRACE_TAG_GRAPHICS | ATRACE_TAG_HAL)
-#include <limits.h>
-#include <errno.h>
-#include <pthread.h>
-#include <unistd.h>
-#include <string.h>
-#include <stdarg.h>
-
-#include <sys/mman.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <sys/ioctl.h>
-
-#include <cutils/log.h>
-#include <cutils/atomic.h>
-#include <utils/Trace.h>
-
-#include <hardware/hardware.h>
-#include <hardware/gralloc.h>
-
-#include "gralloc_priv.h"
-#include "gr.h"
-#include "alloc_controller.h"
-#include "memalloc.h"
-#include <qdMetaData.h>
-
-
-using namespace gralloc;
-/*****************************************************************************/
-
-// Return the type of allocator -
-// these are used for mapping/unmapping
-static IMemAlloc* getAllocator(int flags)
-{
-    IMemAlloc* memalloc;
-    IAllocController* alloc_ctrl = IAllocController::getInstance();
-    memalloc = alloc_ctrl->getAllocator(flags);
-    return memalloc;
-}
-
-static int gralloc_map_metadata(buffer_handle_t handle) {
-    private_handle_t* hnd = (private_handle_t*)handle;
-    hnd->base_metadata = 0;
-    IMemAlloc* memalloc = getAllocator(hnd->flags) ;
-    void *mappedAddress = MAP_FAILED;
-    unsigned int size = 0;
-    if (!(hnd->flags & private_handle_t::PRIV_FLAGS_FRAMEBUFFER)) {
-        mappedAddress = MAP_FAILED;
-        size = ROUND_UP_PAGESIZE(sizeof(MetaData_t));
-        int ret = memalloc->map_buffer(&mappedAddress, size,
-                                       hnd->offset_metadata, hnd->fd_metadata);
-        if(ret || mappedAddress == MAP_FAILED) {
-            ALOGE("Could not mmap metadata for handle %p, fd=%d (%s)",
-                  hnd, hnd->fd_metadata, strerror(errno));
-            return -errno;
-        }
-        hnd->base_metadata = uint64_t(mappedAddress) + hnd->offset_metadata;
-    }
-    return 0;
-}
-
-static int gralloc_map(gralloc_module_t const* module,
-                       buffer_handle_t handle)
-{
-    ATRACE_CALL();
-    if(!module)
-        return -EINVAL;
-
-    private_handle_t* hnd = (private_handle_t*)handle;
-    unsigned int size = 0;
-    int err = 0;
-    IMemAlloc* memalloc = getAllocator(hnd->flags) ;
-    void *mappedAddress = MAP_FAILED;
-    hnd->base = 0;
-
-    // Dont map framebuffer and secure buffers
-    if (!(hnd->flags & private_handle_t::PRIV_FLAGS_FRAMEBUFFER) &&
-        !(hnd->flags & private_handle_t::PRIV_FLAGS_SECURE_BUFFER)) {
-        size = hnd->size;
-        err = memalloc->map_buffer(&mappedAddress, size,
-                                       hnd->offset, hnd->fd);
-        if(err || mappedAddress == MAP_FAILED) {
-            ALOGE("Could not mmap handle %p, fd=%d (%s)",
-                  handle, hnd->fd, strerror(errno));
-            return -errno;
-        }
-
-        hnd->base = uint64_t(mappedAddress) + hnd->offset;
-    } else {
-        // Cannot map secure buffers or framebuffers, but still need to map
-        // metadata for secure buffers.
-        // If mapping a secure buffers fails, the framework needs to get
-        // an error code.
-        err = -EACCES;
-    }
-
-    //Allow mapping of metadata for all buffers including secure ones, but not
-    //of framebuffer
-    int metadata_err = gralloc_map_metadata(handle);
-    if (!err) {
-        err = metadata_err;
-    }
-    return err;
-}
-
-static int gralloc_unmap(gralloc_module_t const* module,
-                         buffer_handle_t handle)
-{
-    ATRACE_CALL();
-    int err = -EINVAL;
-    if(!module)
-        return err;
-
-    private_handle_t* hnd = (private_handle_t*)handle;
-    IMemAlloc* memalloc = getAllocator(hnd->flags) ;
-    if(!memalloc)
-        return err;
-
-    if(hnd->base) {
-        err = memalloc->unmap_buffer((void*)hnd->base, hnd->size, hnd->offset);
-        if (err) {
-            ALOGE("Could not unmap memory at address %p, %s", (void*) hnd->base,
-                    strerror(errno));
-            return -errno;
-        }
-        hnd->base = 0;
-    }
-
-    if(hnd->base_metadata) {
-        unsigned int size = ROUND_UP_PAGESIZE(sizeof(MetaData_t));
-        err = memalloc->unmap_buffer((void*)hnd->base_metadata,
-                size, hnd->offset_metadata);
-        if (err) {
-            ALOGE("Could not unmap memory at address %p, %s",
-                    (void*) hnd->base_metadata, strerror(errno));
-            return -errno;
-        }
-        hnd->base_metadata = 0;
-    }
-
-    return 0;
-}
-
-/*****************************************************************************/
-
-static pthread_mutex_t sMapLock = PTHREAD_MUTEX_INITIALIZER;
-
-/*****************************************************************************/
-
-int gralloc_register_buffer(gralloc_module_t const* module,
-                            buffer_handle_t handle)
-{
-    ATRACE_CALL();
-    if (!module || private_handle_t::validate(handle) < 0)
-        return -EINVAL;
-
-    int err =  gralloc_map(module, handle);
-    /* Do not fail register_buffer for secure buffers*/
-    if (err == -EACCES)
-        err = 0;
-    return err;
-}
-
-int gralloc_unregister_buffer(gralloc_module_t const* module,
-                              buffer_handle_t handle)
-{
-    ATRACE_CALL();
-    if (!module || private_handle_t::validate(handle) < 0)
-        return -EINVAL;
-
-    /*
-     * If the buffer has been mapped during a lock operation, it's time
-     * to un-map it. It's an error to be here with a locked buffer.
-     * NOTE: the framebuffer is handled differently and is never unmapped.
-     * Also base and base_metadata are reset.
-     */
-    return gralloc_unmap(module, handle);
-}
-
-int terminateBuffer(gralloc_module_t const* module,
-                    private_handle_t* hnd)
-{
-    ATRACE_CALL();
-    if(!module)
-        return -EINVAL;
-
-    /*
-     * If the buffer has been mapped during a lock operation, it's time
-     * to un-map it. It's an error to be here with a locked buffer.
-     * NOTE: the framebuffer is handled differently and is never unmapped.
-     * Also base and base_metadata are reset.
-     */
-    return gralloc_unmap(module, hnd);
-}
-
-static int gralloc_map_and_invalidate (gralloc_module_t const* module,
-                                       buffer_handle_t handle, int usage)
-{
-    ATRACE_CALL();
-    if (!module || private_handle_t::validate(handle) < 0)
-        return -EINVAL;
-
-    int err = 0;
-    private_handle_t* hnd = (private_handle_t*)handle;
-    if (usage & (GRALLOC_USAGE_SW_READ_MASK | GRALLOC_USAGE_SW_WRITE_MASK)) {
-        if (hnd->base == 0) {
-            // we need to map for real
-            pthread_mutex_t* const lock = &sMapLock;
-            pthread_mutex_lock(lock);
-            err = gralloc_map(module, handle);
-            pthread_mutex_unlock(lock);
-        }
-        if (hnd->flags & private_handle_t::PRIV_FLAGS_USES_ION and
-                hnd->flags & private_handle_t::PRIV_FLAGS_CACHED) {
-            //Invalidate if CPU reads in software and there are non-CPU
-            //writers. No need to do this for the metadata buffer as it is
-            //only read/written in software.
-            if ((usage & GRALLOC_USAGE_SW_READ_MASK) and
-                    (hnd->flags & private_handle_t::PRIV_FLAGS_NON_CPU_WRITER))
-            {
-                IMemAlloc* memalloc = getAllocator(hnd->flags) ;
-                err = memalloc->clean_buffer((void*)hnd->base,
-                        hnd->size, hnd->offset, hnd->fd,
-                        CACHE_INVALIDATE);
-            }
-            //Mark the buffer to be flushed after CPU write.
-            if (usage & GRALLOC_USAGE_SW_WRITE_MASK) {
-                hnd->flags |= private_handle_t::PRIV_FLAGS_NEEDS_FLUSH;
-            }
-        }
-    }
-
-    return err;
-}
-
-int gralloc_lock(gralloc_module_t const* module,
-                 buffer_handle_t handle, int usage,
-                 int /*l*/, int /*t*/, int /*w*/, int /*h*/,
-                 void** vaddr)
-{
-    ATRACE_CALL();
-    private_handle_t* hnd = (private_handle_t*)handle;
-    int err = gralloc_map_and_invalidate(module, handle, usage);
-    if(!err)
-        *vaddr = (void*)hnd->base;
-    return err;
-}
-
-int gralloc_lock_ycbcr(gralloc_module_t const* module,
-                 buffer_handle_t handle, int usage,
-                 int /*l*/, int /*t*/, int /*w*/, int /*h*/,
-                 struct android_ycbcr *ycbcr)
-{
-    ATRACE_CALL();
-    private_handle_t* hnd = (private_handle_t*)handle;
-    int err = gralloc_map_and_invalidate(module, handle, usage);
-    if(!err)
-        err = getYUVPlaneInfo(hnd, ycbcr);
-    return err;
-}
-
-int gralloc_unlock(gralloc_module_t const* module,
-                   buffer_handle_t handle)
-{
-    ATRACE_CALL();
-    if (!module || private_handle_t::validate(handle) < 0)
-        return -EINVAL;
-
-    int err = 0;
-    private_handle_t* hnd = (private_handle_t*)handle;
-
-    IMemAlloc* memalloc = getAllocator(hnd->flags);
-    if (hnd->flags & private_handle_t::PRIV_FLAGS_NEEDS_FLUSH) {
-        err = memalloc->clean_buffer((void*)hnd->base,
-                hnd->size, hnd->offset, hnd->fd,
-                CACHE_CLEAN);
-        hnd->flags &= ~private_handle_t::PRIV_FLAGS_NEEDS_FLUSH;
-    }
-
-    return err;
-}
-
-/*****************************************************************************/
-
-int gralloc_perform(struct gralloc_module_t const* module,
-                    int operation, ... )
-{
-    int res = -EINVAL;
-    va_list args;
-    if(!module)
-        return res;
-
-    va_start(args, operation);
-    switch (operation) {
-        case GRALLOC_MODULE_PERFORM_CREATE_HANDLE_FROM_BUFFER:
-            {
-                int fd = va_arg(args, int);
-                unsigned int size = va_arg(args, unsigned int);
-                unsigned int offset = va_arg(args, unsigned int);
-                void* base = va_arg(args, void*);
-                int width = va_arg(args, int);
-                int height = va_arg(args, int);
-                int format = va_arg(args, int);
-                int alignedw = 0, alignedh = 0;
-
-                native_handle_t** handle = va_arg(args, native_handle_t**);
-                private_handle_t* hnd = (private_handle_t*)native_handle_create(
-                    private_handle_t::sNumFds, private_handle_t::sNumInts());
-                if (hnd) {
-                  hnd->magic = private_handle_t::sMagic;
-                  hnd->fd = fd;
-                  hnd->flags =  private_handle_t::PRIV_FLAGS_USES_ION;
-                  hnd->size = size;
-                  hnd->offset = offset;
-                  hnd->base = uint64_t(base) + offset;
-                  hnd->gpuaddr = 0;
-                  AdrenoMemInfo::getInstance().getAlignedWidthAndHeight(width,
-                          height, format, 0, alignedw, alignedh);
-                  hnd->width = alignedw;
-                  hnd->height = alignedh;
-                  hnd->unaligned_width = width;
-                  hnd->unaligned_height = height;
-                  hnd->format = format;
-                  *handle = (native_handle_t *)hnd;
-                  res = 0;
-                }
-                break;
-
-            }
-        case GRALLOC_MODULE_PERFORM_GET_STRIDE:
-            {
-                int width   = va_arg(args, int);
-                int format  = va_arg(args, int);
-                int *stride = va_arg(args, int *);
-                int alignedw = 0, alignedh = 0;
-                AdrenoMemInfo::getInstance().getAlignedWidthAndHeight(width,
-                        0, format, 0, alignedw, alignedh);
-                *stride = alignedw;
-                res = 0;
-            } break;
-
-        case GRALLOC_MODULE_PERFORM_GET_CUSTOM_STRIDE_FROM_HANDLE:
-            {
-                const private_handle_t* hnd =  va_arg(args, private_handle_t*);
-                int *stride = va_arg(args, int *);
-                if (private_handle_t::validate(hnd)) {
-                    return res;
-                }
-
-                int alignedw = 0, alignedh = 0;
-                AdrenoMemInfo::getInstance().getAlignedWidthAndHeight(hnd, alignedw, alignedh);
-                *stride = alignedw;
-
-                res = 0;
-            } break;
-
-        case GRALLOC_MODULE_PERFORM_GET_CUSTOM_STRIDE_AND_HEIGHT_FROM_HANDLE:
-            {
-                const private_handle_t* hnd =  va_arg(args, private_handle_t*);
-                int *stride = va_arg(args, int *);
-                int *height = va_arg(args, int *);
-                if (private_handle_t::validate(hnd)) {
-                    return res;
-                }
-
-                int alignedw = 0, alignedh = 0;
-                AdrenoMemInfo::getInstance().getAlignedWidthAndHeight(hnd, alignedw, alignedh);
-                *stride = alignedw;
-                *height = alignedh;
-
-                res = 0;
-            } break;
-
-        case GRALLOC_MODULE_PERFORM_GET_ATTRIBUTES:
-            {
-                int width   = va_arg(args, int);
-                int height  = va_arg(args, int);
-                int format  = va_arg(args, int);
-                int usage   = va_arg(args, int);
-                int *alignedWidth = va_arg(args, int *);
-                int *alignedHeight = va_arg(args, int *);
-                int *tileEnabled = va_arg(args,int *);
-                *tileEnabled = isUBwcEnabled(format, usage);
-                AdrenoMemInfo::getInstance().getAlignedWidthAndHeight(width,
-                        height, format, usage, *alignedWidth, *alignedHeight);
-                res = 0;
-            } break;
-
-        case GRALLOC_MODULE_PERFORM_GET_COLOR_SPACE_FROM_HANDLE:
-            {
-                private_handle_t* hnd =  va_arg(args, private_handle_t*);
-                int *color_space = va_arg(args, int *);
-                if (private_handle_t::validate(hnd)) {
-                    return res;
-                }
-                MetaData_t *metadata = (MetaData_t *)hnd->base_metadata;
-                if (!metadata) {
-                    break;
-#ifdef USE_COLOR_METADATA
-                } else if (metadata->operation & COLOR_METADATA) {
-                    ColorMetaData *colorMetadata = &metadata->color;
-                    res = 0;
-                    switch (colorMetadata->colorPrimaries) {
-                    case ColorPrimaries_BT709_5:
-                        *color_space = HAL_CSC_ITU_R_709;
-                        break;
-                    case ColorPrimaries_BT601_6_525:
-                        *color_space = ((colorMetadata->range) ?
-                                        HAL_CSC_ITU_R_601_FR : HAL_CSC_ITU_R_601);
-                        break;
-                    case ColorPrimaries_BT2020:
-                        *color_space = (colorMetadata->range) ?
-                            HAL_CSC_ITU_R_2020_FR : HAL_CSC_ITU_R_2020;
-                        break;
-                    default:
-                        res = -EINVAL;
-                        break;
-                    }
-#endif
-                } else if(metadata->operation & UPDATE_COLOR_SPACE) {
-                    *color_space = metadata->colorSpace;
-                    res = 0;
-                }
-            } break;
-
-        case GRALLOC_MODULE_PERFORM_GET_YUV_PLANE_INFO:
-            {
-                private_handle_t* hnd =  va_arg(args, private_handle_t*);
-                android_ycbcr* ycbcr = va_arg(args, struct android_ycbcr *);
-                if (!private_handle_t::validate(hnd)) {
-                    res = getYUVPlaneInfo(hnd, ycbcr);
-                }
-            } break;
-
-        case GRALLOC_MODULE_PERFORM_GET_MAP_SECURE_BUFFER_INFO:
-            {
-                private_handle_t* hnd =  va_arg(args, private_handle_t*);
-                int *map_secure_buffer = va_arg(args, int *);
-                if (private_handle_t::validate(hnd)) {
-                    return res;
-                }
-                MetaData_t *metadata = (MetaData_t *)hnd->base_metadata;
-                if(metadata && metadata->operation & MAP_SECURE_BUFFER) {
-                    *map_secure_buffer = metadata->mapSecureBuffer;
-                    res = 0;
-                } else {
-                    *map_secure_buffer = 0;
-                }
-            } break;
-
-        case GRALLOC_MODULE_PERFORM_GET_UBWC_FLAG:
-            {
-                private_handle_t* hnd =  va_arg(args, private_handle_t*);
-                int *flag = va_arg(args, int *);
-                if (private_handle_t::validate(hnd)) {
-                    return res;
-                }
-                *flag = hnd->flags & private_handle_t::PRIV_FLAGS_UBWC_ALIGNED;
-                MetaData_t *metadata = (MetaData_t *)hnd->base_metadata;
-                if (metadata && (metadata->operation & LINEAR_FORMAT)) {
-                    *flag = 0;
-                }
-                res = 0;
-            } break;
-
-        case GRALLOC_MODULE_PERFORM_GET_RGB_DATA_ADDRESS:
-            {
-                private_handle_t* hnd = va_arg(args, private_handle_t*);
-                void** rgb_data = va_arg(args, void**);
-                if (!private_handle_t::validate(hnd)) {
-                    res = getRgbDataAddress(hnd, rgb_data);
-                }
-            } break;
-
-        case GRALLOC_MODULE_PERFORM_GET_IGC:
-            {
-                private_handle_t* hnd = va_arg(args, private_handle_t*);
-                uint32_t *igc = va_arg(args, uint32_t *);
-                if (!private_handle_t::validate(hnd) && igc) {
-                    MetaData_t *metadata = (MetaData_t *)hnd->base_metadata;
-                    if (metadata && (metadata->operation & SET_IGC)) {
-                        *igc = metadata->igc;
-                        res = 0;
-                    }
-                }
-            } break;
-
-        case GRALLOC_MODULE_PERFORM_SET_IGC:
-            res = 0;
-            break;
-
-        case GRALLOC_MODULE_PERFORM_SET_SINGLE_BUFFER_MODE:
-            {
-                private_handle_t* hnd =  va_arg(args, private_handle_t*);
-                uint32_t *enable = va_arg(args, uint32_t*);
-                if (!private_handle_t::validate(hnd)) {
-                    setMetaData(hnd, SET_SINGLE_BUFFER_MODE, enable);
-                    res = 0;
-                }
-            } break;
-        default:
-            break;
-    }
-    va_end(args);
-    return res;
-}
diff --git a/libgralloc/memalloc.h b/libgralloc/memalloc.h
deleted file mode 100644
index 598d983..0000000
--- a/libgralloc/memalloc.h
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
- * Copyright (c) 2011-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 GRALLOC_MEMALLOC_H
-#define GRALLOC_MEMALLOC_H
-
-#include <stdlib.h>
-
-namespace gralloc {
-
-enum {
-    CACHE_CLEAN = 0x1,
-    CACHE_INVALIDATE,
-    CACHE_CLEAN_AND_INVALIDATE,
-};
-
-struct alloc_data {
-    void           *base;
-    int            fd;
-    unsigned int   offset;
-    unsigned int   size;
-    unsigned int   align;
-    uintptr_t      pHandle;
-    bool           uncached;
-    unsigned int   flags;
-    unsigned int   heapId;
-    int            allocType;
-};
-
-class IMemAlloc {
-
-    public:
-    // Allocate buffer - fill in the alloc_data
-    // structure and pass it in. Mapped address
-    // and fd are returned in the alloc_data struct
-    virtual int alloc_buffer(alloc_data& data) = 0;
-
-    // Free buffer
-    virtual int free_buffer(void *base, unsigned int size,
-                            unsigned int offset, int fd) = 0;
-
-    // Map buffer
-    virtual int map_buffer(void **pBase, unsigned int size,
-                           unsigned int offset, int fd) = 0;
-
-    // Unmap buffer
-    virtual int unmap_buffer(void *base, unsigned int size,
-                             unsigned int offset) = 0;
-
-    // Clean and invalidate
-    virtual int clean_buffer(void *base, unsigned int size,
-                             unsigned int offset, int fd, int op) = 0;
-
-    // Destructor
-    virtual ~IMemAlloc() {};
-
-    enum {
-        FD_INIT = -1,
-    };
-
-};
-
-} // end gralloc namespace
-#endif // GRALLOC_MEMALLOC_H
diff --git a/libgralloc1/gr_allocator.cpp b/libgralloc1/gr_allocator.cpp
index ee311f5..175603e 100644
--- a/libgralloc1/gr_allocator.cpp
+++ b/libgralloc1/gr_allocator.cpp
@@ -194,7 +194,11 @@
   if (format == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED ||
       format == HAL_PIXEL_FORMAT_YCbCr_420_888) {
     if (prod_usage & GRALLOC1_PRODUCER_USAGE_PRIVATE_ALLOC_UBWC) {
-      gr_format = HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC;
+      if (prod_usage & GRALLOC1_PRODUCER_USAGE_PRIVATE_10BIT_TP) {
+        gr_format = HAL_PIXEL_FORMAT_YCbCr_420_TP10_UBWC;
+      } else {
+        gr_format = HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC;
+      }
     } else if (cons_usage & GRALLOC1_CONSUMER_USAGE_VIDEO_ENCODER) {
       gr_format = HAL_PIXEL_FORMAT_NV12_ENCODEABLE;  // NV12
     } else if (cons_usage & GRALLOC1_CONSUMER_USAGE_CAMERA) {
diff --git a/libgralloc1/gr_buf_mgr.cpp b/libgralloc1/gr_buf_mgr.cpp
index 16f5635..5390fee 100644
--- a/libgralloc1/gr_buf_mgr.cpp
+++ b/libgralloc1/gr_buf_mgr.cpp
@@ -404,14 +404,6 @@
 int BufferManager::GetHandleFlags(int format, gralloc1_producer_usage_t prod_usage,
                                   gralloc1_consumer_usage_t cons_usage) {
   int flags = 0;
-  if (cons_usage & GRALLOC1_CONSUMER_USAGE_PRIVATE_EXTERNAL_ONLY) {
-    flags |= private_handle_t::PRIV_FLAGS_EXTERNAL_ONLY;
-  }
-
-  if (cons_usage & GRALLOC1_CONSUMER_USAGE_PRIVATE_INTERNAL_ONLY) {
-    flags |= private_handle_t::PRIV_FLAGS_INTERNAL_ONLY;
-  }
-
   if (cons_usage & GRALLOC1_CONSUMER_USAGE_VIDEO_ENCODER) {
     flags |= private_handle_t::PRIV_FLAGS_VIDEO_ENCODER;
   }
@@ -625,6 +617,9 @@
 
       BufferDim_t buffer_dim;
       int interlaced = 0;
+
+      *stride = hnd->width;
+      *height = hnd->height;
       if (getMetaData(hnd, GET_BUFFER_GEOMETRY, &buffer_dim) == 0) {
         *stride = buffer_dim.sliceWidth;
         *height = buffer_dim.sliceHeight;
@@ -638,9 +633,6 @@
           *stride = static_cast<int>(alignedw);
           *height = static_cast<int>(alignedh * 2);
         }
-      } else {
-        *stride = hnd->width;
-        *height = hnd->height;
       }
     } break;
 
diff --git a/libgralloc1/gralloc_priv.h b/libgralloc1/gralloc_priv.h
index 1839d2f..d8dfbf3 100644
--- a/libgralloc1/gralloc_priv.h
+++ b/libgralloc1/gralloc_priv.h
@@ -54,6 +54,10 @@
 /* Use legacy ZSL definition until we know the correct usage on gralloc1 */
 #define GRALLOC1_PRODUCER_USAGE_PRIVATE_CAMERA_ZSL  GRALLOC_USAGE_HW_CAMERA_ZSL
 
+/* TODO(user): move these to use producer private bits once 64-bit support available */
+/* This flag is used to indicate 10-bit tight pack format (e.g. TP10) */
+#define GRALLOC1_PRODUCER_USAGE_PRIVATE_10BIT_TP  0x08000000
+
 
 /* Consumer flags */
 /* TODO(user): Fix when producer and consumer flags are actually separated */
@@ -63,11 +67,8 @@
 /* This flag is used for SECURE display usecase */
 #define GRALLOC1_CONSUMER_USAGE_PRIVATE_SECURE_DISPLAY 0x00800000
 
-/* Buffer content should be displayed on a primary display only */
-#define GRALLOC1_CONSUMER_USAGE_PRIVATE_INTERNAL_ONLY  0x04000000
-
-/* Buffer content should be displayed on an external display only */
-#define GRALLOC1_CONSUMER_USAGE_PRIVATE_EXTERNAL_ONLY  0x08000000
+/* Unused flag */
+#define GRALLOC1_USAGE_PRIVATE_UNUSED1  0x04000000
 
 
 /* Legacy gralloc0.x definitions */
diff --git a/libqdutils/qdMetaData.cpp b/libqdutils/qdMetaData.cpp
index ae23b53..0837c99 100644
--- a/libqdutils/qdMetaData.cpp
+++ b/libqdutils/qdMetaData.cpp
@@ -120,11 +120,19 @@
         case SET_VT_TIMESTAMP:
             data->vtTimeStamp = *((uint64_t *)param);
             break;
-#ifdef USE_COLOR_METADATA
         case COLOR_METADATA:
+#ifdef USE_COLOR_METADATA
             data->color = *((ColorMetaData *)param);
 #endif
             break;
+        case SET_UBWC_CR_STATS_INFO: {
+             struct UBWCStats* stats = (struct UBWCStats*)param;
+             int numelems = sizeof(data->ubwcCRStats) / sizeof(struct UBWCStats);
+             for (int i = 0; i < numelems; i++) {
+                  data->ubwcCRStats[i] = stats[i];
+             }
+              break;
+          }
         default:
             ALOGE("Unknown paramType %d", paramType);
             break;
@@ -171,6 +179,8 @@
     int ret = -EINVAL;
     if (data == nullptr)
         return ret;
+    if (param == nullptr)
+        return ret;
 
     switch (paramType) {
         case GET_PP_PARAM_INTERLACED:
@@ -239,14 +249,24 @@
                 ret = 0;
             }
             break;
-#ifdef USE_COLOR_METADATA
         case GET_COLOR_METADATA:
+#ifdef USE_COLOR_METADATA
             if (data->operation & COLOR_METADATA) {
                 *((ColorMetaData *)param) = data->color;
                 ret = 0;
             }
 #endif
             break;
+        case GET_UBWC_CR_STATS_INFO:
+            if (data->operation & SET_UBWC_CR_STATS_INFO) {
+                struct UBWCStats* stats = (struct UBWCStats*)param;
+                int numelems = sizeof(data->ubwcCRStats) / sizeof(struct UBWCStats);
+                for (int i = 0; i < numelems; i++) {
+                    stats[i] = data->ubwcCRStats[i];
+                }
+                ret = 0;
+            }
+            break;
         default:
             ALOGE("Unknown paramType %d", paramType);
             break;
@@ -265,7 +285,7 @@
 
     MetaData_t *src_data = reinterpret_cast <MetaData_t *>(src->base_metadata);
     MetaData_t *dst_data = reinterpret_cast <MetaData_t *>(dst->base_metadata);
-    memcpy(src_data, dst_data, getMetaDataSize());
+    *dst_data = *src_data;
     return 0;
 }
 
@@ -279,7 +299,7 @@
         return err;
 
     MetaData_t *dst_data = reinterpret_cast <MetaData_t *>(dst->base_metadata);
-    memcpy(src_data, dst_data, getMetaDataSize());
+    *dst_data = *src_data;
     return 0;
 }
 
@@ -293,7 +313,7 @@
         return err;
 
     MetaData_t *src_data = reinterpret_cast <MetaData_t *>(src->base_metadata);
-    memcpy(src_data, dst_data, getMetaDataSize());
+    *dst_data = *src_data;
     return 0;
 }
 
@@ -305,7 +325,7 @@
     if (dst_data == nullptr)
         return err;
 
-    memcpy(src_data, dst_data, getMetaDataSize());
+    *dst_data = *src_data;
     return 0;
 }
 
diff --git a/libqservice/IQService.h b/libqservice/IQService.h
index 5e327d7..8985dd6 100644
--- a/libqservice/IQService.h
+++ b/libqservice/IQService.h
@@ -1,6 +1,6 @@
 /*
  * Copyright (C) 2010 The Android Open Source Project
- * Copyright (C) 2012-2014, 2016 The Linux Foundation. All rights reserved.
+ * Copyright (C) 2012-2014, 2016-2017 The Linux Foundation. All rights reserved.
  *
  * Not a Contribution, Apache license notifications and license are
  * retained for attribution purposes only.
@@ -93,6 +93,7 @@
         DEBUG_DRIVER_CONFIG,
         DEBUG_ROTATOR,
         DEBUG_QDCM,
+        DEBUG_SCALAR,
     };
 
     enum {
diff --git a/sdm/include/core/layer_buffer.h b/sdm/include/core/layer_buffer.h
index c86e020..c0e3305 100644
--- a/sdm/include/core/layer_buffer.h
+++ b/sdm/include/core/layer_buffer.h
@@ -31,11 +31,16 @@
 
 #include <stdint.h>
 #include <color_metadata.h>
+#include <utility>
+#include <vector>
 
 #include "sdm_types.h"
 
 namespace sdm {
 
+#define NUM_UBWC_CR_STATS_LAYERS 2
+typedef std::vector<std::pair<int, int>> UbwcCrStatsVector;
+
 /*! @brief This enum represents display layer inverse gamma correction (IGC) types.
 
   @sa Layer
@@ -268,6 +273,9 @@
                                 //!< could be modified by both client and SDM.
   uint64_t buffer_id __attribute__((aligned(8))) = 0;
                                 //!< Specifies the buffer id.
+  UbwcCrStatsVector  ubwc_crstats[NUM_UBWC_CR_STATS_LAYERS] = {};
+                                //! < UBWC Compression ratio,stats. Stored as a vector of pair of
+                                //! of (tile size, #of tiles)
 };
 
 // This enum represents buffer layout types.
diff --git a/sdm/include/private/hw_info_types.h b/sdm/include/private/hw_info_types.h
index 78dbfad..752d0c4 100644
--- a/sdm/include/private/hw_info_types.h
+++ b/sdm/include/private/hw_info_types.h
@@ -38,8 +38,6 @@
 
 const int kMaxSDELayers = 16;   // Maximum number of layers that can be handled by MDP5 hardware
                                 // in a given layer stack.
-const int kMaxBlitLayers = 32;   // Maximum number of layers that can be handled by MDP3 hardware
-                                // in a given layer stack.
 #define MAX_PLANES 4
 
 #define MAX_DETAIL_ENHANCE_CURVE 3
@@ -159,6 +157,7 @@
   uint32_t num_rgb_pipe = 0;
   uint32_t num_cursor_pipe = 0;
   uint32_t num_blending_stages = 0;
+  uint32_t num_solidfill_stages = 0;
   uint32_t num_control = 0;
   uint32_t num_mixer_to_disp = 0;
   uint32_t smp_total = 0;
@@ -462,11 +461,21 @@
   void Reset() { *this = HWPipeInfo(); }
 };
 
+struct HWSolidfillStage {
+  uint32_t z_order = kMaxSDELayers;
+  uint32_t color = 0;
+  LayerRect roi = {};
+  bool is_exclusion_rect = false;
+};
+
 struct HWLayerConfig {
   HWPipeInfo left_pipe;           // pipe for left side of output
   HWPipeInfo right_pipe;          // pipe for right side of output
   HWRotatorSession hw_rotator_session;
+  HWSolidfillStage hw_solidfill_stage;
+
   float compression = 1.0f;
+  bool use_solidfill_stage = false;
 
   void Reset() { *this = HWLayerConfig(); }
 };
diff --git a/sdm/include/private/resource_interface.h b/sdm/include/private/resource_interface.h
index e140c33..1e75298 100644
--- a/sdm/include/private/resource_interface.h
+++ b/sdm/include/private/resource_interface.h
@@ -48,7 +48,7 @@
                                           const HWPanelInfo &hw_panel_info,
                                           const HWMixerAttributes &mixer_attributes) = 0;
   virtual DisplayError Start(Handle display_ctx) = 0;
-  virtual DisplayError Stop(Handle display_ctx) = 0;
+  virtual DisplayError Stop(Handle display_ctx, HWLayers *hw_layers) = 0;
   virtual DisplayError Prepare(Handle display_ctx, HWLayers *hw_layers) = 0;
   virtual DisplayError PostPrepare(Handle display_ctx, HWLayers *hw_layers) = 0;
   virtual DisplayError Commit(Handle display_ctx, HWLayers *hw_layers) = 0;
@@ -58,8 +58,9 @@
   virtual DisplayError ValidateScaling(const LayerRect &crop, const LayerRect &dst,
                                        bool rotate90, BufferLayout layout,
                                        bool use_rotator_downscale) = 0;
-  virtual DisplayError ValidateCursorPosition(Handle display_ctx, HWLayers *hw_layers,
-                                              int x, int y) = 0;
+  virtual DisplayError ValidateAndSetCursorPosition(Handle display_ctx, HWLayers *hw_layers,
+                                                    int x, int y,
+                                                    DisplayConfigVariableInfo *fb_config) = 0;
   virtual DisplayError SetMaxBandwidthMode(HWBwModes mode) = 0;
   virtual DisplayError GetScaleLutConfig(HWScaleLutInfo *lut_info) = 0;
   virtual DisplayError SetDetailEnhancerData(Handle display_ctx,
diff --git a/sdm/include/utils/debug.h b/sdm/include/utils/debug.h
index 6f895c7..0b40e7b 100644
--- a/sdm/include/utils/debug.h
+++ b/sdm/include/utils/debug.h
@@ -63,7 +63,7 @@
   }
   static inline DebugHandler* Get() { return debug_.debug_handler_; }
   static int GetSimulationFlag();
-  static int GetHDMIResolution();
+  static bool GetExternalResolution(char *val);
   static void GetIdleTimeoutMs(uint32_t *active_ms, uint32_t *inactive_ms);
   static int GetBootAnimLayerCount();
   static bool IsRotatorDownScaleDisabled();
@@ -79,6 +79,7 @@
   static bool IsExtAnimDisabled();
   static bool IsPartialSplitDisabled();
   static DisplayError GetMixerResolution(uint32_t *width, uint32_t *height);
+  static DisplayError GetReducedConfig(uint32_t *num_vig_pipes, uint32_t *num_dma_pipes);
   static int GetExtMaxlayers();
   static bool GetProperty(const char *property_name, char *value);
   static bool SetProperty(const char *property_name, const char *value);
diff --git a/sdm/libs/core/Android.mk b/sdm/libs/core/Android.mk
index 991cfac..14df125 100644
--- a/sdm/libs/core/Android.mk
+++ b/sdm/libs/core/Android.mk
@@ -49,7 +49,7 @@
 ifneq ($(TARGET_IS_HEADLESS), true)
     LOCAL_SRC_FILES           += $(LOCAL_HW_INTF_PATH_2)/hw_info_drm.cpp \
                                  $(LOCAL_HW_INTF_PATH_2)/hw_device_drm.cpp \
-                                 $(LOCAL_HW_INTF_PATH_2)/hw_hdmi_drm.cpp \
+                                 $(LOCAL_HW_INTF_PATH_2)/hw_tv_drm.cpp \
                                  $(LOCAL_HW_INTF_PATH_2)/hw_events_drm.cpp \
                                  $(LOCAL_HW_INTF_PATH_2)/hw_scale_drm.cpp \
                                  $(LOCAL_HW_INTF_PATH_2)/hw_virtual_drm.cpp \
diff --git a/sdm/libs/core/comp_manager.cpp b/sdm/libs/core/comp_manager.cpp
index d18b5b8..4d25497 100644
--- a/sdm/libs/core/comp_manager.cpp
+++ b/sdm/libs/core/comp_manager.cpp
@@ -121,6 +121,7 @@
   registered_displays_[type] = 1;
   display_comp_ctx->is_primary_panel = hw_panel_info.is_primary_panel;
   display_comp_ctx->display_type = type;
+  display_comp_ctx->fb_config = fb_config;
   *display_ctx = display_comp_ctx;
   // New non-primary display device has been added, so move the composition mode to safe mode until
   // resources for the added display is configured properly.
@@ -207,6 +208,8 @@
     }
   }
 
+  // Update new resolution.
+  display_comp_ctx->fb_config = fb_config;
   return error;
 }
 
@@ -286,10 +289,12 @@
   }
 
   if (error != kErrorNone) {
+    resource_intf_->Stop(display_resource_ctx, hw_layers);
     DLOGE("Composition strategies exhausted for display = %d", display_comp_ctx->display_type);
+    return error;
   }
 
-  resource_intf_->Stop(display_resource_ctx);
+  error = resource_intf_->Stop(display_resource_ctx, hw_layers);
 
   return error;
 }
@@ -335,7 +340,7 @@
     DLOGE("Reconfigure failed for display = %d", display_comp_ctx->display_type);
   }
 
-  resource_intf_->Stop(display_resource_ctx);
+  resource_intf_->Stop(display_resource_ctx, hw_layers);
   if (error != kErrorNone) {
       error = resource_intf_->PostPrepare(display_resource_ctx, hw_layers);
   }
@@ -459,13 +464,13 @@
   return resource_intf_->ValidateScaling(crop, dst, rotate90, layout, true);
 }
 
-DisplayError CompManager::ValidateCursorPosition(Handle display_ctx, HWLayers *hw_layers,
+DisplayError CompManager::ValidateAndSetCursorPosition(Handle display_ctx, HWLayers *hw_layers,
                                                  int x, int y) {
   DisplayCompositionContext *display_comp_ctx =
                              reinterpret_cast<DisplayCompositionContext *>(display_ctx);
   Handle &display_resource_ctx = display_comp_ctx->display_resource_ctx;
-
-  return resource_intf_->ValidateCursorPosition(display_resource_ctx, hw_layers, x, y);
+  return resource_intf_->ValidateAndSetCursorPosition(display_resource_ctx, hw_layers, x, y,
+                                                      &display_comp_ctx->fb_config);
 }
 
 DisplayError CompManager::SetMaxBandwidthMode(HWBwModes mode) {
diff --git a/sdm/libs/core/comp_manager.h b/sdm/libs/core/comp_manager.h
index c6b8972..6cc33cf 100644
--- a/sdm/libs/core/comp_manager.h
+++ b/sdm/libs/core/comp_manager.h
@@ -66,7 +66,7 @@
   DisplayError SetMaxMixerStages(Handle display_ctx, uint32_t max_mixer_stages);
   void ControlPartialUpdate(Handle display_ctx, bool enable);
   DisplayError ValidateScaling(const LayerRect &crop, const LayerRect &dst, bool rotate90);
-  DisplayError ValidateCursorPosition(Handle display_ctx, HWLayers *hw_layers, int x, int y);
+  DisplayError ValidateAndSetCursorPosition(Handle display_ctx, HWLayers *hw_layers, int x, int y);
   bool SetDisplayState(Handle display_ctx, DisplayState state, DisplayType display_type);
   DisplayError SetMaxBandwidthMode(HWBwModes mode);
   DisplayError GetScaleLutConfig(HWScaleLutInfo *lut_info);
@@ -97,6 +97,7 @@
     // panel parameters for now.
     bool is_primary_panel = false;
     PUConstraints pu_constraints = {};
+    DisplayConfigVariableInfo fb_config = {};
   };
 
   Locker locker_;
diff --git a/sdm/libs/core/display_base.cpp b/sdm/libs/core/display_base.cpp
index f6540cd..b76c3d1 100644
--- a/sdm/libs/core/display_base.cpp
+++ b/sdm/libs/core/display_base.cpp
@@ -960,7 +960,8 @@
     return kErrorNotSupported;
   }
 
-  DisplayError error = comp_manager_->ValidateCursorPosition(display_comp_ctx_, &hw_layers_, x, y);
+  DisplayError error = comp_manager_->ValidateAndSetCursorPosition(display_comp_ctx_, &hw_layers_,
+                                                                   x, y);
   if (error == kErrorNone) {
     return hw_intf_->SetCursorPosition(&hw_layers_, x, y);
   }
@@ -1331,10 +1332,6 @@
 
       sdm_layer->input_buffer.release_fence_fd = temp;
     }
-
-    // Reset the sync fence fds of HWLayer
-    hw_layer.input_buffer.acquire_fence_fd = -1;
-    hw_layer.input_buffer.release_fence_fd = -1;
   }
 
   return;
diff --git a/sdm/libs/core/display_hdmi.cpp b/sdm/libs/core/display_hdmi.cpp
index a6c5c47..2ea2ac2 100644
--- a/sdm/libs/core/display_hdmi.cpp
+++ b/sdm/libs/core/display_hdmi.cpp
@@ -185,37 +185,33 @@
       break;
     }
   }
-  if (index < num_modes) {
-    best_index = UINT32(index);
-    for (size_t index = best_index + 1; index < num_modes; index ++) {
-      if (!attrib[index].s3d_config[s3d_mode])
-        continue;
 
-      // From the available configs, select the best
-      // Ex: 1920x1080@60Hz is better than 1920x1080@30 and 1920x1080@30 is better than 1280x720@60
+  index = 0;
+  best_index = UINT32(index);
+  for (size_t index = best_index + 1; index < num_modes; index ++) {
+    // TODO(user): Need to add support to S3D modes
+    // From the available configs, select the best
+    // Ex: 1920x1080@60Hz is better than 1920x1080@30 and 1920x1080@30 is better than 1280x720@60
+    if (attrib[index].x_pixels > attrib[best_index].x_pixels) {
+      best_index = UINT32(index);
+    } else if (attrib[index].x_pixels == attrib[best_index].x_pixels) {
       if (attrib[index].y_pixels > attrib[best_index].y_pixels) {
         best_index = UINT32(index);
       } else if (attrib[index].y_pixels == attrib[best_index].y_pixels) {
-        if (attrib[index].x_pixels > attrib[best_index].x_pixels) {
+        if (attrib[index].vsync_period_ns < attrib[best_index].vsync_period_ns) {
           best_index = UINT32(index);
-        } else if (attrib[index].x_pixels == attrib[best_index].x_pixels) {
-          if (attrib[index].vsync_period_ns < attrib[best_index].vsync_period_ns) {
-            best_index = UINT32(index);
-          }
         }
       }
     }
-  } else {
-    DLOGW("%s, could not support S3D mode from EDID info. S3D mode is %d",
-          __FUNCTION__, s3d_mode);
   }
-
+  char val[kPropertyMax]={};
   // Used for changing HDMI Resolution - override the best with user set config
-  uint32_t user_config = UINT32(Debug::GetHDMIResolution());
+  bool user_config = (Debug::GetExternalResolution(val));
+
   if (user_config) {
     uint32_t config_index = 0;
     // For the config, get the corresponding index
-    DisplayError error = hw_intf_->GetConfigIndex(user_config, &config_index);
+    DisplayError error = hw_intf_->GetConfigIndex(val, &config_index);
     if (error == kErrorNone)
       return config_index;
   }
diff --git a/sdm/libs/core/display_hdmi.h b/sdm/libs/core/display_hdmi.h
index ca09ce3..8248840 100644
--- a/sdm/libs/core/display_hdmi.h
+++ b/sdm/libs/core/display_hdmi.h
@@ -55,11 +55,13 @@
   virtual void ThermalEvent(int64_t thermal_level) { }
   virtual void CECMessage(char *message);
   virtual void IdlePowerCollapse() { }
+  virtual void PingPongTimeout() { }
 
  private:
   uint32_t GetBestConfig(HWS3DMode s3d_mode);
   void GetScanSupport();
   void SetS3DMode(LayerStack *layer_stack);
+  static const int kPropertyMax = 256;
 
   bool underscan_supported_ = false;
   HWScanSupport scan_support_;
diff --git a/sdm/libs/core/display_primary.cpp b/sdm/libs/core/display_primary.cpp
index bb467fa..52b71c7 100644
--- a/sdm/libs/core/display_primary.cpp
+++ b/sdm/libs/core/display_primary.cpp
@@ -90,32 +90,6 @@
   uint32_t new_mixer_height = 0;
   uint32_t display_width = display_attributes_.x_pixels;
   uint32_t display_height = display_attributes_.y_pixels;
-  bool needs_hv_flip = hw_panel_info_.panel_orientation.flip_horizontal &&
-                          hw_panel_info_.panel_orientation.flip_vertical;
-  LayerRect src_domain = {};
-  LayerTransform panel_transform = {};
-  DisplayConfigVariableInfo variable_info = {};
-
-  if (needs_hv_flip) {
-    DisplayBase::GetFrameBufferConfig(&variable_info);
-    src_domain.right = variable_info.x_pixels;
-    src_domain.bottom = variable_info.y_pixels;
-    panel_transform.flip_horizontal = hw_panel_info_.panel_orientation.flip_horizontal;
-    panel_transform.flip_vertical = hw_panel_info_.panel_orientation.flip_vertical;
-
-    for (Layer *layer : layer_stack->layers) {
-      // Modify destination based on panel flip
-      TransformHV(src_domain, layer->dst_rect, panel_transform, &layer->dst_rect);
-
-      if (layer->flags.solid_fill) {
-        continue;
-      }
-
-      layer->transform.flip_horizontal ^= (hw_panel_info_.panel_orientation.flip_horizontal);
-      layer->transform.flip_vertical ^= (hw_panel_info_.panel_orientation.flip_vertical);
-     // TODO(user): Check how to handle rotation, if panel has rotation.
-    }
-  }
 
   if (NeedsMixerReconfiguration(layer_stack, &new_mixer_width, &new_mixer_height)) {
     error = ReconfigureMixer(new_mixer_width, new_mixer_height);
@@ -311,6 +285,11 @@
   comp_manager_->ProcessIdleTimeout(display_comp_ctx_);
 }
 
+void DisplayPrimary::PingPongTimeout() {
+  lock_guard<recursive_mutex> obj(recursive_mutex_);
+  hw_intf_->DumpDebugData();
+}
+
 void DisplayPrimary::ThermalEvent(int64_t thermal_level) {
   lock_guard<recursive_mutex> obj(recursive_mutex_);
   comp_manager_->ProcessThermalEvent(display_comp_ctx_, thermal_level);
diff --git a/sdm/libs/core/display_primary.h b/sdm/libs/core/display_primary.h
index 314964a..e5aeabc 100644
--- a/sdm/libs/core/display_primary.h
+++ b/sdm/libs/core/display_primary.h
@@ -61,12 +61,17 @@
   virtual void ThermalEvent(int64_t thermal_level);
   virtual void CECMessage(char *message) { }
   virtual void IdlePowerCollapse();
+  virtual void PingPongTimeout();
 
  private:
   bool NeedsAVREnable();
 
-  std::vector<HWEvent> event_list_ = { HWEvent::VSYNC, HWEvent::EXIT, HWEvent::IDLE_NOTIFY,
-      HWEvent::SHOW_BLANK_EVENT, HWEvent::THERMAL_LEVEL, HWEvent::IDLE_POWER_COLLAPSE };
+  std::vector<HWEvent> event_list_ = { HWEvent::VSYNC, HWEvent::EXIT,
+                                       HWEvent::IDLE_NOTIFY,
+                                       HWEvent::SHOW_BLANK_EVENT,
+                                       HWEvent::THERMAL_LEVEL,
+                                       HWEvent::IDLE_POWER_COLLAPSE,
+                                       HWEvent::PINGPONG_TIMEOUT };
   bool avr_prop_disabled_ = false;
   bool switch_to_cmd_ = false;
   bool handle_idle_timeout_ = false;
diff --git a/sdm/libs/core/drm/hw_color_manager_drm.cpp b/sdm/libs/core/drm/hw_color_manager_drm.cpp
index 3438e77..67478c9 100644
--- a/sdm/libs/core/drm/hw_color_manager_drm.cpp
+++ b/sdm/libs/core/drm/hw_color_manager_drm.cpp
@@ -48,6 +48,9 @@
 #ifdef PP_DRM_ENABLE
 static const uint32_t kPgcDataMask = 0x3FF;
 static const uint32_t kPgcShift = 16;
+
+static const uint32_t kIgcDataMask = 0xFFF;
+static const uint32_t kIgcShift = 16;
 #endif
 
 namespace sdm {
@@ -66,6 +69,7 @@
 void HWColorManagerDrm::FreeDrmFeatureData(DRMPPFeatureInfo *feature) {
   if (feature->payload)
     free(feature->payload);
+  feature->payload = NULL;
 }
 
 uint32_t HWColorManagerDrm::GetFeatureVersion(const DRMPPFeatureInfo &feature) {
@@ -75,6 +79,8 @@
     case kFeaturePcc:
       break;
     case kFeatureIgc:
+      if (feature.version == 3)
+        version = PPFeatureVersion::kSDEIgcV30;
       break;
     case kFeaturePgc:
       if (feature.version == 1)
@@ -143,6 +149,67 @@
 DisplayError HWColorManagerDrm::GetDrmIGC(const PPFeatureInfo &in_data,
                                           DRMPPFeatureInfo *out_data) {
   DisplayError ret = kErrorNone;
+#ifdef PP_DRM_ENABLE
+  struct SDEIgcV30LUTData *sde_igc;
+  struct drm_msm_igc_lut *mdp_igc;
+  uint32_t *c0_c1_data_ptr = NULL;
+  uint32_t *c2_data_ptr = NULL;
+
+
+  if (!out_data) {
+    DLOGE("Invalid input parameter for igc");
+    return kErrorParameters;
+  }
+
+  switch (in_data.feature_version_) {
+  case PPFeatureVersion::kSDEIgcV30:
+    sde_igc = (struct SDEIgcV30LUTData *) in_data.GetConfigData();
+    break;
+  default:
+    DLOGE("Unsupported igc feature version: %d", in_data.feature_version_);
+    return kErrorParameters;
+  }
+
+  out_data->id = kFeatureIgc;
+  out_data->type = sde_drm::kPropBlob;
+  out_data->version = in_data.feature_version_;
+  out_data->payload_size = sizeof(struct drm_msm_igc_lut);
+
+  if (in_data.enable_flags_ & kOpsDisable) {
+    /* feature disable case */
+    out_data->payload = NULL;
+    return ret;
+  } else if (!(in_data.enable_flags_ & kOpsEnable)) {
+    out_data->payload = NULL;
+    return kErrorParameters;
+  }
+
+  mdp_igc = new drm_msm_igc_lut();
+  if (!mdp_igc) {
+    DLOGE("Failed to allocate memory for igc");
+    return kErrorMemory;
+  }
+
+  mdp_igc->flags = IGC_DITHER_ENABLE;
+  mdp_igc->strength = sde_igc->strength;
+
+  c0_c1_data_ptr = reinterpret_cast<uint32_t*>(sde_igc->c0_c1_data);
+  c2_data_ptr = reinterpret_cast<uint32_t*>(sde_igc->c2_data);
+
+  if (!c0_c1_data_ptr || !c2_data_ptr) {
+    DLOGE("Invaid igc data pointer");
+    delete mdp_igc;
+    out_data->payload = NULL;
+    return kErrorParameters;
+  }
+
+  for (int i = 0; i < IGC_TBL_LEN; i++) {
+    mdp_igc->c0[i] = c0_c1_data_ptr[i] & kIgcDataMask;
+    mdp_igc->c1[i] = (c0_c1_data_ptr[i] >> kIgcShift) & kIgcDataMask;
+    mdp_igc->c2[i] = c2_data_ptr[i] & kIgcDataMask;
+  }
+  out_data->payload = mdp_igc;
+#endif
   return ret;
 }
 
diff --git a/sdm/libs/core/drm/hw_device_drm.cpp b/sdm/libs/core/drm/hw_device_drm.cpp
index b244a2a..1ed9042 100644
--- a/sdm/libs/core/drm/hw_device_drm.cpp
+++ b/sdm/libs/core/drm/hw_device_drm.cpp
@@ -95,6 +95,8 @@
 using sde_drm::DRMOps;
 using sde_drm::DRMTopology;
 using sde_drm::DRMPowerMode;
+using sde_drm::DRMSecureMode;
+using sde_drm::DRMSecurityLevel;
 
 namespace sdm {
 
@@ -216,6 +218,27 @@
   }
 }
 
+HWDeviceDRM::Registry::Registry(BufferAllocator *buffer_allocator) :
+  buffer_allocator_(buffer_allocator) {
+  DRMMaster *master = nullptr;
+  DRMMaster::GetInstance(&master);
+
+  if (!master) {
+    DLOGE("Failed to acquire DRM Master instance");
+    return;
+  }
+
+  // If RMFB is ref-counted, we should immediately make a call to clean up fb_id after commit.
+  // Driver will release fb_id after its usage. Otherwise speculatively free up fb_id after 3
+  // cycles assuming driver is done with it.
+  rmfb_delay_ = master->IsRmFbRefCounted() ? 1 : 3;
+  hashmap_ = new std::unordered_map<int, uint32_t>[rmfb_delay_];
+}
+
+HWDeviceDRM::Registry::~Registry() {
+  delete [] hashmap_;
+}
+
 void HWDeviceDRM::Registry::RegisterCurrent(HWLayers *hw_layers) {
   HWLayersInfo &hw_layer_info = hw_layers->info;
   uint32_t hw_layer_count = UINT32(hw_layer_info.hw_layers.size());
@@ -276,7 +299,7 @@
     return;
   }
 
-  current_index_ = (current_index_ + 1) % kCycleDelay;
+  current_index_ = (current_index_ + 1) % rmfb_delay_;
   auto &curr_map = hashmap_[current_index_];
   for (auto &pair : curr_map) {
     uint32_t fb_id = pair.second;
@@ -290,7 +313,7 @@
 }
 
 void HWDeviceDRM::Registry::Clear() {
-  for (int i = 0; i < kCycleDelay; i++) {
+  for (int i = 0; i < rmfb_delay_; i++) {
     UnregisterNext();
   }
   current_index_ = 0;
@@ -356,6 +379,7 @@
 }
 
 DisplayError HWDeviceDRM::Deinit() {
+  PowerOff();
   delete hw_scale_;
   registry_.Clear();
   drm_mgr_intf_->DestroyAtomicReq(drm_atomic_intf_);
@@ -420,6 +444,13 @@
        topology == DRMTopology::DUAL_LM_DSCMERGE);
   display_attributes_.h_total += display_attributes_.is_device_split ? h_blanking : 0;
 
+  // If driver doesn't return panel width/height information, default to 320 dpi
+  if (INT(mm_width) <= 0 || INT(mm_height) <= 0) {
+    mm_width  = UINT32(((FLOAT(mode.hdisplay) * 25.4f) / 320.0f) + 0.5f);
+    mm_height = UINT32(((FLOAT(mode.vdisplay) * 25.4f) / 320.0f) + 0.5f);
+    DLOGW("Driver doesn't report panel physical width and height - defaulting to 320dpi");
+  }
+
   display_attributes_.x_dpi = (FLOAT(mode.hdisplay) * 25.4f) / FLOAT(mm_width);
   display_attributes_.y_dpi = (FLOAT(mode.vdisplay) * 25.4f) / FLOAT(mm_height);
 
@@ -452,6 +483,17 @@
   hw_panel_info_.max_fps = 60;
   hw_panel_info_.is_primary_panel = connector_info_.is_primary;
   hw_panel_info_.is_pluggable = 0;
+  hw_panel_info_.hdr_enabled = connector_info_.panel_hdr_prop.hdr_enabled;
+  hw_panel_info_.peak_luminance = connector_info_.panel_hdr_prop.peak_brightness;
+  hw_panel_info_.blackness_level = connector_info_.panel_hdr_prop.blackness_level;
+  hw_panel_info_.primaries.white_point[0] = connector_info_.panel_hdr_prop.display_primaries[0];
+  hw_panel_info_.primaries.white_point[1] = connector_info_.panel_hdr_prop.display_primaries[1];
+  hw_panel_info_.primaries.red[0] = connector_info_.panel_hdr_prop.display_primaries[2];
+  hw_panel_info_.primaries.red[1] = connector_info_.panel_hdr_prop.display_primaries[3];
+  hw_panel_info_.primaries.green[0] = connector_info_.panel_hdr_prop.display_primaries[4];
+  hw_panel_info_.primaries.green[1] = connector_info_.panel_hdr_prop.display_primaries[5];
+  hw_panel_info_.primaries.blue[0] = connector_info_.panel_hdr_prop.display_primaries[6];
+  hw_panel_info_.primaries.blue[1] = connector_info_.panel_hdr_prop.display_primaries[7];
 
   // no supprt for 90 rotation only flips or 180 supported
   hw_panel_info_.panel_orientation.rotation = 0;
@@ -468,8 +510,8 @@
   DLOGI("%s, Panel Interface = %s, Panel Mode = %s, Is Primary = %d", device_name_,
         interface_str_.c_str(), hw_panel_info_.mode == kModeVideo ? "Video" : "Command",
         hw_panel_info_.is_primary_panel);
-  DLOGI("Partial Update = %d, Dynamic FPS = %d", hw_panel_info_.partial_update,
-        hw_panel_info_.dynamic_fps);
+  DLOGI("Partial Update = %d, Dynamic FPS = %d, HDR Panel = %d", hw_panel_info_.partial_update,
+        hw_panel_info_.dynamic_fps, hw_panel_info_.hdr_enabled);
   DLOGI("Align: left = %d, width = %d, top = %d, height = %d", hw_panel_info_.left_align,
         hw_panel_info_.width_align, hw_panel_info_.top_align, hw_panel_info_.height_align);
   DLOGI("ROI: min_width = %d, min_height = %d, need_merge = %d", hw_panel_info_.min_roi_width,
@@ -571,7 +613,7 @@
   return kErrorNotSupported;
 }
 
-DisplayError HWDeviceDRM::GetConfigIndex(uint32_t mode, uint32_t *index) {
+DisplayError HWDeviceDRM::GetConfigIndex(char *mode, uint32_t *index) {
   return kErrorNone;
 }
 
@@ -631,6 +673,9 @@
   HWLayersInfo &hw_layer_info = hw_layers->info;
   uint32_t hw_layer_count = UINT32(hw_layer_info.hw_layers.size());
   HWQosData &qos_data = hw_layers->qos_data;
+  DRMSecurityLevel crtc_security_level = DRMSecurityLevel::SECURE_NON_SECURE;
+
+  solid_fills_.clear();
 
   // TODO(user): Once destination scalar is enabled we can always send ROIs if driver allows
   if (hw_panel_info_.partial_update) {
@@ -667,6 +712,11 @@
     HWPipeInfo *right_pipe = &hw_layers->config[i].right_pipe;
     HWRotatorSession *hw_rotator_session = &hw_layers->config[i].hw_rotator_session;
 
+    if (hw_layers->config[i].use_solidfill_stage) {
+      AddSolidfillStage(hw_layers->config[i].hw_solidfill_stage, layer.plane_alpha);
+      continue;
+    }
+
     for (uint32_t count = 0; count < 2; count++) {
       HWPipeInfo *pipe_info = (count == 0) ? left_pipe : right_pipe;
       HWRotateInfo *hw_rotate_info = &hw_rotator_session->hw_rotate_info[count];
@@ -702,6 +752,15 @@
                                   pipe_info->horizontal_decimation);
         drm_atomic_intf_->Perform(DRMOps::PLANE_SET_V_DECIMATION, pipe_id,
                                   pipe_info->vertical_decimation);
+
+        DRMSecureMode fb_secure_mode;
+        DRMSecurityLevel security_level;
+        SetSecureConfig(layer.input_buffer, &fb_secure_mode, &security_level);
+        drm_atomic_intf_->Perform(DRMOps::PLANE_SET_FB_SECURE_MODE, pipe_id, fb_secure_mode);
+        if (security_level > crtc_security_level) {
+          crtc_security_level = security_level;
+        }
+
         uint32_t config = 0;
         SetSrcConfig(layer.input_buffer, &config);
         drm_atomic_intf_->Perform(DRMOps::PLANE_SET_SRC_CONFIG, pipe_id, config);;
@@ -722,21 +781,44 @@
         }
       }
     }
+  }
 
-    drm_atomic_intf_->Perform(DRMOps::CRTC_SET_CORE_CLK, token_.crtc_id, qos_data.clock_hz);
-    drm_atomic_intf_->Perform(DRMOps::CRTC_SET_CORE_AB, token_.crtc_id, qos_data.core_ab_bps);
-    drm_atomic_intf_->Perform(DRMOps::CRTC_SET_CORE_IB, token_.crtc_id, qos_data.core_ib_bps);
-    drm_atomic_intf_->Perform(DRMOps::CRTC_SET_LLCC_AB, token_.crtc_id, qos_data.llcc_ab_bps);
-    drm_atomic_intf_->Perform(DRMOps::CRTC_SET_LLCC_IB, token_.crtc_id, qos_data.llcc_ib_bps);
-    drm_atomic_intf_->Perform(DRMOps::CRTC_SET_DRAM_AB, token_.crtc_id, qos_data.dram_ab_bps);
-    drm_atomic_intf_->Perform(DRMOps::CRTC_SET_DRAM_IB, token_.crtc_id, qos_data.dram_ib_bps);
-    drm_atomic_intf_->Perform(DRMOps::CRTC_SET_ROT_CLK, token_.crtc_id, qos_data.rot_clock_hz);
+  SetSolidfillStages();
+  drm_atomic_intf_->Perform(DRMOps::CRTC_SET_CORE_CLK, token_.crtc_id, qos_data.clock_hz);
+  drm_atomic_intf_->Perform(DRMOps::CRTC_SET_CORE_AB, token_.crtc_id, qos_data.core_ab_bps);
+  drm_atomic_intf_->Perform(DRMOps::CRTC_SET_CORE_IB, token_.crtc_id, qos_data.core_ib_bps);
+  drm_atomic_intf_->Perform(DRMOps::CRTC_SET_LLCC_AB, token_.crtc_id, qos_data.llcc_ab_bps);
+  drm_atomic_intf_->Perform(DRMOps::CRTC_SET_LLCC_IB, token_.crtc_id, qos_data.llcc_ib_bps);
+  drm_atomic_intf_->Perform(DRMOps::CRTC_SET_DRAM_AB, token_.crtc_id, qos_data.dram_ab_bps);
+  drm_atomic_intf_->Perform(DRMOps::CRTC_SET_DRAM_IB, token_.crtc_id, qos_data.dram_ib_bps);
+  drm_atomic_intf_->Perform(DRMOps::CRTC_SET_ROT_CLK, token_.crtc_id, qos_data.rot_clock_hz);
 
-    DLOGI_IF(kTagDriverConfig, "System Clock=%d Hz, Core: AB=%llu Bps, IB=%llu Bps, " \
-             "LLCC: AB=%llu Bps, IB=%llu Bps, DRAM AB=%llu Bps, IB=%llu Bps Rot Clock=%d",
-             qos_data.clock_hz, qos_data.core_ab_bps, qos_data.core_ib_bps, qos_data.llcc_ab_bps,
-             qos_data.llcc_ib_bps, qos_data.dram_ab_bps, qos_data.dram_ib_bps,
-             qos_data.rot_clock_hz);
+  DLOGI_IF(kTagDriverConfig, "System Clock=%d Hz, Core: AB=%llu Bps, IB=%llu Bps, " \
+           "LLCC: AB=%llu Bps, IB=%llu Bps, DRAM AB=%llu Bps, IB=%llu Bps Rot Clock=%d",
+           qos_data.clock_hz, qos_data.core_ab_bps, qos_data.core_ib_bps, qos_data.llcc_ab_bps,
+           qos_data.llcc_ib_bps, qos_data.dram_ab_bps, qos_data.dram_ib_bps,
+           qos_data.rot_clock_hz);
+}
+
+void HWDeviceDRM::AddSolidfillStage(const HWSolidfillStage &sf, uint32_t plane_alpha) {
+  sde_drm::DRMSolidfillStage solidfill;
+  solidfill.bounding_rect.left = UINT32(sf.roi.left);
+  solidfill.bounding_rect.top = UINT32(sf.roi.top);
+  solidfill.bounding_rect.right = UINT32(sf.roi.right);
+  solidfill.bounding_rect.bottom = UINT32(sf.roi.bottom);
+  solidfill.is_exclusion_rect  = sf.is_exclusion_rect;
+  solidfill.plane_alpha = plane_alpha;
+  solidfill.z_order = sf.z_order;
+  solidfill.color = sf.color;
+  solid_fills_.push_back(solidfill);
+  DLOGI_IF(kTagDriverConfig, "Add a solidfill stage at z_order:%d argb_color:%x plane_alpha:%x",
+           solidfill.z_order, solidfill.color, solidfill.plane_alpha);
+}
+
+void HWDeviceDRM::SetSolidfillStages() {
+  if (hw_resource_.num_solidfill_stages) {
+    drm_atomic_intf_->Perform(DRMOps::CRTC_SET_SOLIDFILL_STAGES, token_.crtc_id,
+                              reinterpret_cast<uint64_t> (&solid_fills_));
   }
 }
 
@@ -948,9 +1030,9 @@
 DisplayError HWDeviceDRM::SetPPFeatures(PPFeaturesConfig *feature_list) {
   int ret = 0;
   PPFeatureInfo *feature = NULL;
-  DRMPPFeatureInfo kernel_params = {};
 
   while (true) {
+    DRMPPFeatureInfo kernel_params = {};
     ret = feature_list->RetrieveNextFeature(&feature);
     if (ret)
       break;
@@ -1163,4 +1245,30 @@
                                      : mixer_attributes_.width;
 }
 
+void HWDeviceDRM::SetSecureConfig(const LayerBuffer &input_buffer, DRMSecureMode *fb_secure_mode,
+                                  DRMSecurityLevel *security_level) {
+  *fb_secure_mode = DRMSecureMode::NON_SECURE;
+  *security_level = DRMSecurityLevel::SECURE_NON_SECURE;
+
+  if (input_buffer.flags.secure) {
+    if (input_buffer.flags.secure_camera) {
+      // IOMMU configuration for this framebuffer mode is secure domain & requires
+      // only stage II translation, when this buffer is accessed by Display H/W.
+      // Secure and non-secure planes can be attached to this CRTC.
+      *fb_secure_mode = DRMSecureMode::SECURE_DIR_TRANSLATION;
+    } else if (input_buffer.flags.secure_display) {
+      // IOMMU configuration for this framebuffer mode is non-secure domain & requires
+      // only stage II translation, when this buffer is accessed by Display H/W.
+      // Only secure planes can be attached to this CRTC.
+      *fb_secure_mode = DRMSecureMode::NON_SECURE_DIR_TRANSLATION;
+      *security_level = DRMSecurityLevel::SECURE_ONLY;
+    } else {
+      // IOMMU configuration for this framebuffer mode is secure domain & requires both
+      // stage I and stage II translations, when this buffer is accessed by Display H/W.
+      // Secure and non-secure planes can be attached to this CRTC.
+      *fb_secure_mode = DRMSecureMode::SECURE;
+    }
+  }
+}
+
 }  // namespace sdm
diff --git a/sdm/libs/core/drm/hw_device_drm.h b/sdm/libs/core/drm/hw_device_drm.h
index 1c4f517..965ff3b 100644
--- a/sdm/libs/core/drm/hw_device_drm.h
+++ b/sdm/libs/core/drm/hw_device_drm.h
@@ -65,7 +65,7 @@
   virtual DisplayError GetHWPanelInfo(HWPanelInfo *panel_info);
   virtual DisplayError SetDisplayAttributes(uint32_t index);
   virtual DisplayError SetDisplayAttributes(const HWDisplayAttributes &display_attributes);
-  virtual DisplayError GetConfigIndex(uint32_t mode, uint32_t *index);
+  virtual DisplayError GetConfigIndex(char *mode, uint32_t *index);
   virtual DisplayError PowerOn();
   virtual DisplayError PowerOff();
   virtual DisplayError Doze();
@@ -95,6 +95,7 @@
   virtual DisplayError SetMixerAttributes(const HWMixerAttributes &mixer_attributes);
   virtual DisplayError GetMixerAttributes(HWMixerAttributes *mixer_attributes);
   virtual void InitializeConfigs();
+  virtual DisplayError DumpDebugData() { return kErrorNone; }
 
   enum {
     kHWEventVSync,
@@ -117,6 +118,8 @@
   void ResetDisplayParams();
   bool EnableHotPlugDetection(int enable);
   void UpdateMixerAttributes();
+  void SetSolidfillStages();
+  void AddSolidfillStage(const HWSolidfillStage &sf, uint32_t plane_alpha);
   void SetBlending(const LayerBlending &source, sde_drm::DRMBlendType *target);
   void SetSrcConfig(const LayerBuffer &input_buffer, uint32_t *config);
   void SetRect(const LayerRect &source, sde_drm::DRMRect *target);
@@ -124,10 +127,13 @@
   DisplayError DefaultCommit(HWLayers *hw_layers);
   DisplayError AtomicCommit(HWLayers *hw_layers);
   void SetupAtomic(HWLayers *hw_layers, bool validate);
+  void SetSecureConfig(const LayerBuffer &input_buffer, sde_drm::DRMSecureMode *fb_secure_mode,
+                       sde_drm::DRMSecurityLevel *security_level);
 
   class Registry {
    public:
-    explicit Registry(BufferAllocator *buffer_allocator) : buffer_allocator_(buffer_allocator) {}
+    explicit Registry(BufferAllocator *buffer_allocator);
+    ~Registry();
     // Call on each validate and commit to register layer buffers
     void RegisterCurrent(HWLayers *hw_layers);
     // Call at the end of draw cycle to clear the next slot for business
@@ -140,10 +146,10 @@
     uint32_t GetFbId(int fd);
 
    private:
-    static const int kCycleDelay = 3;  // N cycle delay before destroy
+    uint8_t rmfb_delay_ = 1;  // N cycle delay before destroy
     // fd to fb_id map. fd is used as key only for a single draw cycle between
     // prepare and commit. It should not be used for caching in future due to fd recycling
-    std::unordered_map<int, uint32_t> hashmap_[kCycleDelay] {};
+    std::unordered_map<int, uint32_t> *hashmap_ {};
     int current_index_ = 0;
     BufferAllocator *buffer_allocator_ = {};
   };
@@ -161,6 +167,7 @@
   HWResourceInfo hw_resource_ = {};
   HWPanelInfo hw_panel_info_ = {};
   HWDeviceType device_type_ = {};
+  HWScaleDRM *hw_scale_ = {};
   sde_drm::DRMManagerInterface *drm_mgr_intf_ = {};
   sde_drm::DRMAtomicReqInterface *drm_atomic_intf_ = {};
   sde_drm::DRMConnectorInfo connector_info_ = {};
@@ -171,7 +178,7 @@
   bool synchronous_commit_ = false;
   HWMixerAttributes mixer_attributes_ = {};
   std::string interface_str_ = "DSI";
-  HWScaleDRM *hw_scale_ = {};
+  std::vector<sde_drm::DRMSolidfillStage> solid_fills_ {};
 };
 
 }  // namespace sdm
diff --git a/sdm/libs/core/drm/hw_events_drm.cpp b/sdm/libs/core/drm/hw_events_drm.cpp
index e6c65f4..7487c8a 100644
--- a/sdm/libs/core/drm/hw_events_drm.cpp
+++ b/sdm/libs/core/drm/hw_events_drm.cpp
@@ -85,6 +85,7 @@
       case HWEvent::SHOW_BLANK_EVENT:
       case HWEvent::THERMAL_LEVEL:
       case HWEvent::IDLE_POWER_COLLAPSE:
+      case HWEvent::PINGPONG_TIMEOUT:
         break;
     }
   }
@@ -270,6 +271,7 @@
         case HWEvent::SHOW_BLANK_EVENT:
         case HWEvent::THERMAL_LEVEL:
         case HWEvent::IDLE_POWER_COLLAPSE:
+        case HWEvent::PINGPONG_TIMEOUT:
           if (poll_fd.fd >= 0 && (poll_fd.revents & POLLPRI) &&
               (Sys::pread_(poll_fd.fd, data, kMaxStringLength, 0) > 0)) {
             (this->*(event_data_list_[i]).event_parser)(data);
diff --git a/sdm/libs/core/drm/hw_hdmi_drm.cpp b/sdm/libs/core/drm/hw_hdmi_drm.cpp
deleted file mode 100644
index 27419c7..0000000
--- a/sdm/libs/core/drm/hw_hdmi_drm.cpp
+++ /dev/null
@@ -1,163 +0,0 @@
-/*
-* Copyright (c) 2017, 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.
-*/
-
-#include <drm_lib_loader.h>
-#include <drm_master.h>
-#include <drm_res_mgr.h>
-#include <stdio.h>
-#include <unistd.h>
-#include <string.h>
-#include <utils/debug.h>
-#include <utils/sys.h>
-#include <utils/formats.h>
-
-#include <vector>
-#include <map>
-#include <utility>
-
-#include "hw_hdmi_drm.h"
-
-#define __CLASS__ "HWHDMIDRM"
-
-using drm_utils::DRMMaster;
-using drm_utils::DRMResMgr;
-using drm_utils::DRMLibLoader;
-using drm_utils::DRMBuffer;
-using sde_drm::GetDRMManager;
-using sde_drm::DestroyDRMManager;
-using sde_drm::DRMDisplayType;
-using sde_drm::DRMDisplayToken;
-using sde_drm::DRMConnectorInfo;
-using sde_drm::DRMPPFeatureInfo;
-using sde_drm::DRMOps;
-using sde_drm::DRMTopology;
-
-namespace sdm {
-
-HWHDMIDRM::HWHDMIDRM(BufferSyncHandler *buffer_sync_handler, BufferAllocator *buffer_allocator,
-                     HWInfoInterface *hw_info_intf)
-  : HWDeviceDRM(buffer_sync_handler, buffer_allocator, hw_info_intf),
-  active_config_index_(0) {
-  HWDeviceDRM::device_type_ = kDeviceHDMI;
-  HWDeviceDRM::device_name_ = "HDMI Display Device";
-}
-
-// TODO(user) : split function in base class and avoid code duplicacy
-// by using base implementation for this basic stuff
-DisplayError HWHDMIDRM::Init() {
-  DisplayError error = kErrorNone;
-
-  default_mode_ = (DRMLibLoader::GetInstance()->IsLoaded() == false);
-
-  if (!default_mode_) {
-    DRMMaster *drm_master = {};
-    int dev_fd = -1;
-    DRMMaster::GetInstance(&drm_master);
-    drm_master->GetHandle(&dev_fd);
-    DRMLibLoader::GetInstance()->FuncGetDRMManager()(dev_fd, &drm_mgr_intf_);
-    if (drm_mgr_intf_->RegisterDisplay(DRMDisplayType::TV, &token_)) {
-      DLOGE("RegisterDisplay failed");
-      return kErrorResources;
-    }
-
-    drm_mgr_intf_->CreateAtomicReq(token_, &drm_atomic_intf_);
-    drm_mgr_intf_->GetConnectorInfo(token_.conn_id, &connector_info_);
-    InitializeConfigs();
-    drm_atomic_intf_->Perform(DRMOps::CRTC_SET_MODE, token_.crtc_id, &current_mode_);
-    drm_atomic_intf_->Perform(DRMOps::CRTC_SET_ACTIVE, token_.crtc_id, 1);
-
-    if (drm_atomic_intf_->Commit(true /* synchronous */)) {
-      DLOGE("Setting up CRTC %d, Connector %d for %s failed", token_.crtc_id, token_.conn_id,
-            device_name_);
-      return kErrorResources;
-    }
-
-    // Reload connector info for updated info after 1st commit
-    drm_mgr_intf_->GetConnectorInfo(token_.conn_id, &connector_info_);
-    DLOGI("Setup CRTC %d, Connector %d for %s", token_.crtc_id, token_.conn_id, device_name_);
-  }
-
-  PopulateDisplayAttributes();
-  PopulateHWPanelInfo();
-  UpdateMixerAttributes();
-
-  return error;
-}
-
-DisplayError HWHDMIDRM::GetNumDisplayAttributes(uint32_t *count) {
-  *count = connector_info_.num_modes;
-  if (*count <= 0) {
-    return kErrorHardware;
-  }
-
-  return kErrorNone;
-}
-
-DisplayError HWHDMIDRM::GetActiveConfig(uint32_t *active_config_index) {
-  *active_config_index = active_config_index_;
-  return kErrorNone;
-}
-
-DisplayError HWHDMIDRM::SetDisplayAttributes(uint32_t index) {
-  DTRACE_SCOPED();
-
-  if (index >= connector_info_.num_modes) {
-    return kErrorNotSupported;
-  }
-
-  active_config_index_ = index;
-
-  // TODO(user): fix this hard coding
-  frame_rate_ = 60;
-
-  // Get the display attributes for current active config index
-  GetDisplayAttributes(active_config_index_, &display_attributes_);
-  UpdateMixerAttributes();
-
-  return kErrorNone;
-}
-
-DisplayError HWHDMIDRM::GetConfigIndex(uint32_t mode, uint32_t *index) {
-  *index = mode;
-
-  return kErrorNone;
-}
-
-DisplayError HWHDMIDRM::Validate(HWLayers *hw_layers) {
-  HWDeviceDRM::ResetDisplayParams();
-
-  return HWDeviceDRM::Validate(hw_layers);
-}
-
-DisplayError HWHDMIDRM::Commit(HWLayers *hw_layers) {
-  return HWDeviceDRM::Commit(hw_layers);
-}
-
-}  // namespace sdm
-
diff --git a/sdm/libs/core/drm/hw_info_drm.cpp b/sdm/libs/core/drm/hw_info_drm.cpp
index 8843924..69af1bd 100644
--- a/sdm/libs/core/drm/hw_info_drm.cpp
+++ b/sdm/libs/core/drm/hw_info_drm.cpp
@@ -174,10 +174,12 @@
   hw_resource->has_dyn_bw_support = false;
   hw_resource->has_qseed3 = false;
   hw_resource->has_concurrent_writeback = false;
+  hw_resource->has_hdr = true;
 
-  // TODO(user): Deprecate
   hw_resource->hw_version = kHWMdssVersion5;
   hw_resource->hw_revision = 0;
+
+  // TODO(user): Deprecate
   hw_resource->max_mixer_width = 0;
   hw_resource->writeback_index = 0;
   hw_resource->has_bwc = false;
@@ -217,6 +219,7 @@
   DLOGI("\tLinear = %d", hw_resource->linear_factor);
   DLOGI("\tScale = %d", hw_resource->scale_factor);
   DLOGI("\tFudge_factor = %d", hw_resource->extra_fudge_factor);
+  DLOGI("\tib_fudge_factor = %d", hw_resource->ib_fudge_factor);
 
   if (hw_resource->separate_rotator || hw_resource->num_dma_pipe) {
     GetHWRotatorInfo(hw_resource);
@@ -251,6 +254,7 @@
   hw_resource->is_src_split = info.has_src_split;
   hw_resource->has_qseed3 = (info.qseed_version == sde_drm::QSEEDVersion::V3);
   hw_resource->num_blending_stages = info.max_blend_stages;
+  hw_resource->num_solidfill_stages = info.max_solidfill_stages;
   hw_resource->smart_dma_rev = (info.smart_dma_rev == sde_drm::SmartDMARevision::V2) ?
     SmartDMARevision::V2 : SmartDMARevision::V1;
   hw_resource->ib_fudge_factor = info.ib_fudge_factor;
@@ -265,6 +269,7 @@
   hw_resource->max_bandwidth_low = info.max_bandwidth_low / kKiloUnit;
   hw_resource->max_bandwidth_high = info.max_bandwidth_high / kKiloUnit;
   hw_resource->max_sde_clk = info.max_sde_clk;
+  hw_resource->hw_revision = info.hw_version;
 
   std::vector<LayerBufferFormat> sdm_format;
   for (auto &it : info.comp_ratio_rt_map) {
@@ -285,7 +290,42 @@
 void HWInfoDRM::GetHWPlanesInfo(HWResourceInfo *hw_resource) {
   DRMPlanesInfo planes;
   drm_mgr_intf_->GetPlanesInfo(&planes);
+
+  // To simulate reduced config.
+  uint32_t max_vig_pipes = 0;
+  uint32_t max_dma_pipes = 0;
+  Debug::GetReducedConfig(&max_vig_pipes, &max_dma_pipes);
+  uint32_t max_virtual_pipes = max_vig_pipes + max_dma_pipes;
+  uint32_t vig_pipe_count = 0;
+  uint32_t dma_pipe_count = 0;
+  uint32_t virtual_pipe_count = 0;
+
   for (auto &pipe_obj : planes) {
+    if (max_vig_pipes && max_dma_pipes) {
+      uint32_t master_plane_id = pipe_obj.second.master_plane_id;
+      if ((pipe_obj.second.type == DRMPlaneType::DMA) && (dma_pipe_count < max_dma_pipes)
+          && !master_plane_id) {
+        dma_pipe_count++;
+      } else if ((pipe_obj.second.type == DRMPlaneType::VIG) && (vig_pipe_count < max_vig_pipes)
+          && !master_plane_id) {
+        vig_pipe_count++;
+      } else if ((master_plane_id) && (virtual_pipe_count < max_virtual_pipes)) {
+        bool is_virtual = false;
+        for (auto &pipe_caps : hw_resource->hw_pipes) {
+          if (master_plane_id == pipe_caps.id) {
+            is_virtual = true;
+            virtual_pipe_count++;
+            break;
+          }
+        }
+        if (!is_virtual) {
+          continue;
+        }
+      } else {
+        continue;
+      }
+    }
+
     HWPipeCaps pipe_caps;
     string name = {};
     switch (pipe_obj.second.type) {
@@ -320,7 +360,8 @@
     }
     pipe_caps.id = pipe_obj.first;
     pipe_caps.master_pipe_id = pipe_obj.second.master_plane_id;
-    DLOGI("Adding %s Pipe : Id %d", name.c_str(), pipe_obj.first);
+    DLOGI("Adding %s Pipe : Id %d, master_pipe_id : Id %d",
+          name.c_str(), pipe_obj.first, pipe_obj.second.master_plane_id);
     hw_resource->hw_pipes.push_back(std::move(pipe_caps));
   }
 }
diff --git a/sdm/libs/core/drm/hw_tv_drm.cpp b/sdm/libs/core/drm/hw_tv_drm.cpp
new file mode 100644
index 0000000..0262915
--- /dev/null
+++ b/sdm/libs/core/drm/hw_tv_drm.cpp
@@ -0,0 +1,183 @@
+/*
+* Copyright (c) 2017, 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.
+*/
+
+#include "hw_tv_drm.h"
+#include <utils/debug.h>
+#include <utils/sys.h>
+#include <utils/formats.h>
+#include <drm_lib_loader.h>
+#include <drm_master.h>
+#include <drm_res_mgr.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <string>
+#include <vector>
+#include <map>
+#include <utility>
+
+
+#define __CLASS__ "HWTVDRM"
+
+using drm_utils::DRMMaster;
+using drm_utils::DRMResMgr;
+using drm_utils::DRMLibLoader;
+using drm_utils::DRMBuffer;
+using sde_drm::GetDRMManager;
+using sde_drm::DestroyDRMManager;
+using sde_drm::DRMDisplayType;
+using sde_drm::DRMDisplayToken;
+using sde_drm::DRMConnectorInfo;
+using sde_drm::DRMPPFeatureInfo;
+using sde_drm::DRMOps;
+using sde_drm::DRMTopology;
+
+namespace sdm {
+
+HWTVDRM::HWTVDRM(BufferSyncHandler *buffer_sync_handler, BufferAllocator *buffer_allocator,
+                     HWInfoInterface *hw_info_intf)
+  : HWDeviceDRM(buffer_sync_handler, buffer_allocator, hw_info_intf), active_config_index_(0) {
+  disp_type_ = DRMDisplayType::TV;
+  device_name_ = "TV Display Device";
+}
+
+// TODO(user) : split function in base class and avoid code duplicacy
+// by using base implementation for this basic stuff
+DisplayError HWTVDRM::Init() {
+  DisplayError error = kErrorNone;
+
+  default_mode_ = (DRMLibLoader::GetInstance()->IsLoaded() == false);
+
+  if (!default_mode_) {
+    DRMMaster *drm_master = {};
+    int dev_fd = -1;
+    DRMMaster::GetInstance(&drm_master);
+    drm_master->GetHandle(&dev_fd);
+    DRMLibLoader::GetInstance()->FuncGetDRMManager()(dev_fd, &drm_mgr_intf_);
+    if (drm_mgr_intf_->RegisterDisplay(DRMDisplayType::TV, &token_)) {
+      DLOGE("RegisterDisplay failed");
+      return kErrorResources;
+    }
+
+    drm_mgr_intf_->CreateAtomicReq(token_, &drm_atomic_intf_);
+    drm_mgr_intf_->GetConnectorInfo(token_.conn_id, &connector_info_);
+    InitializeConfigs();
+  }
+
+  hw_info_intf_->GetHWResourceInfo(&hw_resource_);
+
+  // TODO(user): In future, remove has_qseed3 member, add version and pass version to constructor
+  if (hw_resource_.has_qseed3) {
+    hw_scale_ = new HWScaleDRM(HWScaleDRM::Version::V2);
+  }
+
+  if (error != kErrorNone) {
+    return error;
+  }
+
+  return error;
+}
+
+DisplayError HWTVDRM::GetNumDisplayAttributes(uint32_t *count) {
+  *count = connector_info_.num_modes;
+  if (*count <= 0) {
+    return kErrorHardware;
+  }
+
+  return kErrorNone;
+}
+
+DisplayError HWTVDRM::GetActiveConfig(uint32_t *active_config_index) {
+  *active_config_index = active_config_index_;
+  return kErrorNone;
+}
+
+DisplayError HWTVDRM::SetDisplayAttributes(uint32_t index) {
+  if (index >= connector_info_.num_modes) {
+    return kErrorNotSupported;
+  }
+
+  active_config_index_ = index;
+  current_mode_ = connector_info_.modes[index];
+
+  drm_atomic_intf_->Perform(DRMOps::CRTC_SET_MODE, token_.crtc_id, &connector_info_.modes[index]);
+  drm_atomic_intf_->Perform(DRMOps::CRTC_SET_ACTIVE, token_.crtc_id, 1);
+
+  // Commit to setup pipeline with mode, which then tells us the topology etc
+  if (drm_atomic_intf_->Commit(true /* synchronous */)) {
+    DLOGE("Setting up CRTC %d, Connector %d for %s failed", token_.crtc_id,
+          token_.conn_id, device_name_);
+    return kErrorResources;
+  }
+
+  // Reload connector info for updated info after 1st commit
+  drm_mgr_intf_->GetConnectorInfo(token_.conn_id, &connector_info_);
+  DLOGI("Setup CRTC %d, Connector %d for %s", token_.crtc_id, token_.conn_id, device_name_);
+
+  frame_rate_ = display_attributes_.fps;
+  PopulateDisplayAttributes();
+  PopulateHWPanelInfo();
+  UpdateMixerAttributes();
+
+  return kErrorNone;
+}
+
+DisplayError HWTVDRM::GetConfigIndex(char *mode, uint32_t *index) {
+  uint32_t width = 0, height = 0, fps = 0, format = 0;
+  std::string str(mode);
+
+  // mode should be in width:height:fps:format
+  // TODO(user): it is not fully robust, User needs to provide in above format only
+  if (str.length() != 0) {
+    width = UINT32(stoi(str));
+    height = UINT32(stoi(str.substr(str.find(':') + 1)));
+    std::string str3 = str.substr(str.find(':') + 1);
+    fps = UINT32(stoi(str3.substr(str3.find(':')  + 1)));
+    std::string str4 = str3.substr(str3.find(':') + 1);
+    format = UINT32(stoi(str4.substr(str4.find(':') + 1)));
+  }
+
+  for (size_t idex = 0; idex < connector_info_.num_modes; idex ++) {
+    if ((height == connector_info_.modes[idex].vdisplay) &&
+        (width == connector_info_.modes[idex].hdisplay) &&
+        (fps == connector_info_.modes[idex].vrefresh)) {
+      if ((format >> 1) & (connector_info_.modes[idex].flags >> kBitYUV)) {
+        *index = UINT32(idex);
+      }
+
+      if (format & (connector_info_.modes[idex].flags >> kBitRGB)) {
+        *index = UINT32(idex);
+      }
+    }
+  }
+
+  return kErrorNone;
+}
+
+}  // namespace sdm
+
diff --git a/sdm/libs/core/drm/hw_hdmi_drm.h b/sdm/libs/core/drm/hw_tv_drm.h
similarity index 84%
rename from sdm/libs/core/drm/hw_hdmi_drm.h
rename to sdm/libs/core/drm/hw_tv_drm.h
index 7e11e5e..7991ae3 100644
--- a/sdm/libs/core/drm/hw_hdmi_drm.h
+++ b/sdm/libs/core/drm/hw_tv_drm.h
@@ -22,8 +22,8 @@
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
-#ifndef __HW_HDMI_DRM_H__
-#define __HW_HDMI_DRM_H__
+#ifndef __HW_TV_DRM_H__
+#define __HW_TV_DRM_H__
 
 #include <map>
 #include <vector>
@@ -34,9 +34,9 @@
 
 using std::vector;
 
-class HWHDMIDRM : public HWDeviceDRM {
+class HWTVDRM : public HWDeviceDRM {
  public:
-  explicit HWHDMIDRM(BufferSyncHandler *buffer_sync_handler, BufferAllocator *buffer_allocator,
+  explicit HWTVDRM(BufferSyncHandler *buffer_sync_handler, BufferAllocator *buffer_allocator,
                      HWInfoInterface *hw_info_intf);
 
  protected:
@@ -45,16 +45,17 @@
   // Requirement to call this only after the first config has been explicitly set by client
   virtual DisplayError GetActiveConfig(uint32_t *active_config);
   virtual DisplayError SetDisplayAttributes(uint32_t index);
-  virtual DisplayError GetConfigIndex(uint32_t mode, uint32_t *index);
-  virtual DisplayError Validate(HWLayers *hw_layers);
-  virtual DisplayError Commit(HWLayers *hw_layers);
+  virtual DisplayError GetConfigIndex(char *mode, uint32_t *index);
 
  private:
+  static const int kBitRGB  = 20;
+  static const int kBitYUV  = 21;
+
   uint32_t active_config_index_;
   uint32_t frame_rate_ = 0;
 };
 
 }  // namespace sdm
 
-#endif  // __HW_HDMI_DRM_H__
+#endif  // __HW_TV_DRM_H__
 
diff --git a/sdm/libs/core/drm/hw_virtual_drm.cpp b/sdm/libs/core/drm/hw_virtual_drm.cpp
index 5fe1d86..8513e82 100644
--- a/sdm/libs/core/drm/hw_virtual_drm.cpp
+++ b/sdm/libs/core/drm/hw_virtual_drm.cpp
@@ -41,7 +41,7 @@
 using sde_drm::DRMConnectorInfo;
 using sde_drm::DRMRect;
 using sde_drm::DRMOps;
-
+using sde_drm::DRMPowerMode;
 namespace sdm {
 
 HWVirtualDRM::HWVirtualDRM(BufferSyncHandler *buffer_sync_handler,
@@ -109,6 +109,15 @@
     current_mode_ = connector_info_.modes[0];
     DumpConfigs();
   }
+
+  // TODO(user): Remove this code once driver populates appropriate topology based on virtual
+  // display configuration
+  if (connector_info_.topology == sde_drm::DRMTopology::UNKNOWN) {
+    connector_info_.topology = sde_drm::DRMTopology::SINGLE_LM;
+    if (width_ > hw_resource_.max_mixer_width) {
+      connector_info_.topology = sde_drm::DRMTopology::DUAL_LM_MERGE;
+    }
+  }
 }
 
 void HWVirtualDRM::DumpConfigs() {
@@ -146,7 +155,6 @@
   return kErrorNone;
 }
 
-
 DisplayError HWVirtualDRM::SetDisplayAttributes(const HWDisplayAttributes &display_attributes) {
   if (display_attributes.x_pixels == 0 || display_attributes.y_pixels == 0) {
     return kErrorParameters;
@@ -165,6 +173,18 @@
   return kErrorNone;
 }
 
+DisplayError HWVirtualDRM::PowerOn() {
+  drm_atomic_intf_->Perform(DRMOps::CRTC_SET_ACTIVE, token_.crtc_id, 1);
+  drm_atomic_intf_->Perform(DRMOps::CONNECTOR_SET_POWER_MODE, token_.conn_id, DRMPowerMode::ON);
+  return kErrorNone;
+}
+
+DisplayError HWVirtualDRM::PowerOff() {
+  drm_atomic_intf_->Perform(DRMOps::CONNECTOR_SET_POWER_MODE, token_.conn_id, DRMPowerMode::OFF);
+  drm_atomic_intf_->Perform(DRMOps::CRTC_SET_ACTIVE, token_.crtc_id, 0);
+  return kErrorNone;
+}
+
 DisplayError HWVirtualDRM::GetPPFeaturesVersion(PPFeatureVersion *vers) {
   return kErrorNone;
 }
diff --git a/sdm/libs/core/drm/hw_virtual_drm.h b/sdm/libs/core/drm/hw_virtual_drm.h
index b63519a..afa5c71 100644
--- a/sdm/libs/core/drm/hw_virtual_drm.h
+++ b/sdm/libs/core/drm/hw_virtual_drm.h
@@ -55,6 +55,8 @@
   virtual DisplayError Commit(HWLayers *hw_layers);
   virtual DisplayError GetPPFeaturesVersion(PPFeatureVersion *vers);
   virtual DisplayError SetScaleLutConfig(HWScaleLutInfo *lut_info);
+  virtual DisplayError PowerOn();
+  virtual DisplayError PowerOff();
   void ConfigureWbConnectorFbId(uint32_t fb_id);
   void ConfigureWbConnectorDestRect();
   void DumpConfigs();
diff --git a/sdm/libs/core/fb/hw_device.cpp b/sdm/libs/core/fb/hw_device.cpp
index 773845b..4931e1b 100644
--- a/sdm/libs/core/fb/hw_device.cpp
+++ b/sdm/libs/core/fb/hw_device.cpp
@@ -146,7 +146,7 @@
   return kErrorNotSupported;
 }
 
-DisplayError HWDevice::GetConfigIndex(uint32_t mode, uint32_t *index) {
+DisplayError HWDevice::GetConfigIndex(char *mode, uint32_t *index) {
   return kErrorNone;
 }
 
@@ -1141,8 +1141,8 @@
   async_layer.pipe_ndx = left_pipe->pipe_id;
   async_layer.src.x = UINT32(left_pipe->src_roi.left);
   async_layer.src.y = UINT32(left_pipe->src_roi.top);
-  async_layer.dst.x = UINT32(x);
-  async_layer.dst.y = UINT32(y);
+  async_layer.dst.x = UINT32(left_pipe->dst_roi.left);
+  async_layer.dst.y = UINT32(left_pipe->dst_roi.top);
 
   mdp_position_update pos_update = {};
   pos_update.input_layer_cnt = 1;
@@ -1359,5 +1359,33 @@
   return kErrorNone;
 }
 
+DisplayError HWDevice::DumpDebugData() {
+  DLOGW("Pingpong timeout occurred in the driver.");
+#ifdef USER_DEBUG
+  // Save the xlogs on ping pong time out
+  std::ofstream  dst("/data/vendor/display/mdp_xlog");
+  dst << "+++ MDP:XLOG +++" << std::endl;
+  std::ifstream  src("/sys/kernel/debug/mdp/xlog/dump");
+  dst << src.rdbuf() << std::endl;
+  src.close();
+
+  dst << "+++ MDP:REG_XLOG +++" << std::endl;
+  src.open("/sys/kernel/debug/mdp/xlog/reg_xlog");
+  dst << src.rdbuf() << std::endl;
+  src.close();
+
+  dst << "+++ MDP:DBGBUS_XLOG +++" << std::endl;
+  src.open("/sys/kernel/debug/mdp/xlog/dbgbus_xlog");
+  dst << src.rdbuf() << std::endl;
+  src.close();
+
+  dst << "+++ MDP:VBIF_DBGBUS_XLOG +++" << std::endl;
+  src.open("/sys/kernel/debug/mdp/xlog/vbif_dbgbus_xlog");
+  dst << src.rdbuf() << std::endl;
+  src.close();
+#endif
+  return kErrorNone;
+}
+
 }  // namespace sdm
 
diff --git a/sdm/libs/core/fb/hw_device.h b/sdm/libs/core/fb/hw_device.h
index 2eea87b..f32c5bd 100644
--- a/sdm/libs/core/fb/hw_device.h
+++ b/sdm/libs/core/fb/hw_device.h
@@ -69,7 +69,7 @@
   virtual DisplayError GetHWPanelInfo(HWPanelInfo *panel_info);
   virtual DisplayError SetDisplayAttributes(uint32_t index);
   virtual DisplayError SetDisplayAttributes(const HWDisplayAttributes &display_attributes);
-  virtual DisplayError GetConfigIndex(uint32_t mode, uint32_t *index);
+  virtual DisplayError GetConfigIndex(char *mode, uint32_t *index);
   virtual DisplayError PowerOn();
   virtual DisplayError PowerOff();
   virtual DisplayError Doze();
@@ -97,6 +97,7 @@
   virtual DisplayError SetScaleLutConfig(HWScaleLutInfo *lut_info);
   virtual DisplayError SetMixerAttributes(const HWMixerAttributes &mixer_attributes);
   virtual DisplayError GetMixerAttributes(HWMixerAttributes *mixer_attributes);
+  virtual DisplayError DumpDebugData();
 
   enum {
     kHWEventVSync,
diff --git a/sdm/libs/core/fb/hw_events.cpp b/sdm/libs/core/fb/hw_events.cpp
index 7a1988c..d944624 100644
--- a/sdm/libs/core/fb/hw_events.cpp
+++ b/sdm/libs/core/fb/hw_events.cpp
@@ -104,6 +104,9 @@
     case HWEvent::IDLE_POWER_COLLAPSE:
       event_data->event_parser = &HWEvents::HandleIdlePowerCollapse;
       break;
+    case HWEvent::PINGPONG_TIMEOUT:
+      event_data->event_parser = &HWEvents::HandlePingPongTimeout;
+      break;
     default:
       error = kErrorParameters;
       break;
@@ -133,10 +136,14 @@
   event_list_ = event_list;
   poll_fds_.resize(event_list_.size());
   event_thread_name_ += " - " + std::to_string(fb_num_);
-  map_event_to_node_ = {{HWEvent::VSYNC, "vsync_event"}, {HWEvent::EXIT, "thread_exit"},
-    {HWEvent::IDLE_NOTIFY, "idle_notify"}, {HWEvent::SHOW_BLANK_EVENT, "show_blank_event"},
-    {HWEvent::CEC_READ_MESSAGE, "cec/rd_msg"}, {HWEvent::THERMAL_LEVEL, "msm_fb_thermal_level"},
-    {HWEvent::IDLE_POWER_COLLAPSE, "idle_power_collapse"}};
+  map_event_to_node_ = {{HWEvent::VSYNC, "vsync_event"},
+                        {HWEvent::EXIT, "thread_exit"},
+                        {HWEvent::IDLE_NOTIFY, "idle_notify"},
+                        {HWEvent::SHOW_BLANK_EVENT, "show_blank_event"},
+                        {HWEvent::CEC_READ_MESSAGE, "cec/rd_msg"},
+                        {HWEvent::THERMAL_LEVEL, "msm_fb_thermal_level"},
+                        {HWEvent::IDLE_POWER_COLLAPSE, "idle_power_collapse"},
+                        {HWEvent::PINGPONG_TIMEOUT, "pingpong_timeout"}};
 
   PopulateHWEventData();
 
@@ -224,6 +231,10 @@
   event_handler_->IdleTimeout();
 }
 
+void HWEvents::HandlePingPongTimeout(char *data) {
+  event_handler_->PingPongTimeout();
+}
+
 void HWEvents::HandleThermal(char *data) {
   int64_t thermal_level = 0;
   if (!strncmp(data, "thermal_level=", strlen("thermal_level="))) {
diff --git a/sdm/libs/core/fb/hw_events.h b/sdm/libs/core/fb/hw_events.h
index 0fa86fb..8ffd6d5 100644
--- a/sdm/libs/core/fb/hw_events.h
+++ b/sdm/libs/core/fb/hw_events.h
@@ -68,6 +68,7 @@
   void HandleCECMessage(char *data);
   void HandleThreadExit(char *data) { }
   void HandleIdlePowerCollapse(char *data);
+  void HandlePingPongTimeout(char *data);
   void PopulateHWEventData();
   DisplayError SetEventParser(HWEvent event_type, HWEventData *event_data);
   pollfd InitializePollFd(HWEventData *event_data);
diff --git a/sdm/libs/core/fb/hw_hdmi.cpp b/sdm/libs/core/fb/hw_hdmi.cpp
index 334a043..0602b12 100644
--- a/sdm/libs/core/fb/hw_hdmi.cpp
+++ b/sdm/libs/core/fb/hw_hdmi.cpp
@@ -38,6 +38,7 @@
 #include <utils/sys.h>
 #include <utils/formats.h>
 
+#include <string>
 #include <vector>
 #include <map>
 #include <utility>
@@ -407,17 +408,20 @@
   return kErrorNone;
 }
 
-DisplayError HWHDMI::GetConfigIndex(uint32_t mode, uint32_t *index) {
+DisplayError HWHDMI::GetConfigIndex(char *mode, uint32_t *index) {
+  std::string str(mode);
+  uint32_t value = UINT32(stoi(str));
+
   // Check if the mode is valid and return corresponding index
   for (uint32_t i = 0; i < hdmi_modes_.size(); i++) {
-    if (hdmi_modes_[i] == mode) {
+    if (hdmi_modes_[i] == value) {
       *index = i;
-      DLOGI("Index = %d for config = %d", *index, mode);
+      DLOGI("Index = %d for config = %d", *index, value);
       return kErrorNone;
     }
   }
 
-  DLOGE("Config = %d not supported", mode);
+  DLOGE("Config = %d not supported", value);
   return kErrorNotSupported;
 }
 
@@ -864,7 +868,9 @@
     return kErrorNotSupported;
   }
 
-  GetConfigIndex(dst->video_format, config_index);
+  char mode_val[kVideoFormatArrayMax]={};
+  snprintf(mode_val, sizeof(mode_val), "%d", dst->video_format);
+  GetConfigIndex(mode_val, config_index);
 
   data->hor_front_porch = dst->front_porch_h;
   data->hor_back_porch = dst->back_porch_h;
diff --git a/sdm/libs/core/fb/hw_hdmi.h b/sdm/libs/core/fb/hw_hdmi.h
index 625782e..83025fa 100644
--- a/sdm/libs/core/fb/hw_hdmi.h
+++ b/sdm/libs/core/fb/hw_hdmi.h
@@ -83,7 +83,7 @@
   virtual DisplayError GetMaxCEAFormat(uint32_t *max_cea_format);
   virtual DisplayError OnMinHdcpEncryptionLevelChange(uint32_t min_enc_level);
   virtual DisplayError SetDisplayAttributes(uint32_t index);
-  virtual DisplayError GetConfigIndex(uint32_t mode, uint32_t *index);
+  virtual DisplayError GetConfigIndex(char *mode, uint32_t *index);
   virtual DisplayError Validate(HWLayers *hw_layers);
   virtual DisplayError Commit(HWLayers *hw_layers);
   virtual DisplayError SetS3DMode(HWS3DMode s3d_mode);
@@ -109,6 +109,7 @@
   DisplayError GetDynamicFrameRateMode(uint32_t refresh_rate, uint32_t*mode,
                                        DynamicFPSData *data, uint32_t *config_index);
   static const int kThresholdRefreshRate = 1000;
+  static const int kVideoFormatArrayMax = 8;
   vector<uint32_t> hdmi_modes_;
   // Holds the hdmi timing information. Ex: resolution, fps etc.,
   vector<msm_hdmi_mode_timing_info> supported_video_modes_;
diff --git a/sdm/libs/core/fb/hw_primary.cpp b/sdm/libs/core/fb/hw_primary.cpp
index 8102e5f..5ee8121 100644
--- a/sdm/libs/core/fb/hw_primary.cpp
+++ b/sdm/libs/core/fb/hw_primary.cpp
@@ -329,7 +329,7 @@
   return kErrorNone;
 }
 
-DisplayError HWPrimary::GetConfigIndex(uint32_t mode, uint32_t *index) {
+DisplayError HWPrimary::GetConfigIndex(char *mode, uint32_t *index) {
   return HWDevice::GetConfigIndex(mode, index);
 }
 
diff --git a/sdm/libs/core/fb/hw_primary.h b/sdm/libs/core/fb/hw_primary.h
index 38b3b9a..69b5445 100644
--- a/sdm/libs/core/fb/hw_primary.h
+++ b/sdm/libs/core/fb/hw_primary.h
@@ -44,7 +44,7 @@
   virtual DisplayError GetDisplayAttributes(uint32_t index,
                                             HWDisplayAttributes *display_attributes);
   virtual DisplayError SetDisplayAttributes(uint32_t index);
-  virtual DisplayError GetConfigIndex(uint32_t mode, uint32_t *index);
+  virtual DisplayError GetConfigIndex(char *mode, uint32_t *index);
   virtual DisplayError PowerOff();
   virtual DisplayError Doze();
   virtual DisplayError DozeSuspend();
diff --git a/sdm/libs/core/hw_events_interface.h b/sdm/libs/core/hw_events_interface.h
index 6f4cebd..090ff71 100644
--- a/sdm/libs/core/hw_events_interface.h
+++ b/sdm/libs/core/hw_events_interface.h
@@ -43,6 +43,7 @@
   SHOW_BLANK_EVENT,
   THERMAL_LEVEL,
   IDLE_POWER_COLLAPSE,
+  PINGPONG_TIMEOUT,
 };
 
 class HWEventsInterface {
diff --git a/sdm/libs/core/hw_interface.cpp b/sdm/libs/core/hw_interface.cpp
index f05aa0c..cfaf72b 100644
--- a/sdm/libs/core/hw_interface.cpp
+++ b/sdm/libs/core/hw_interface.cpp
@@ -38,7 +38,7 @@
 #ifdef COMPILE_DRM
 #include "drm/hw_device_drm.h"
 #include "drm/hw_virtual_drm.h"
-#include "drm/hw_hdmi_drm.h"
+#include "drm/hw_tv_drm.h"
 #endif
 
 #define __CLASS__ "HWInterface"
@@ -67,7 +67,7 @@
         hw = new HWHDMI(buffer_sync_handler, hw_info_intf);
       } else {
 #ifdef COMPILE_DRM
-        hw = new HWHDMIDRM(buffer_sync_handler, buffer_allocator, hw_info_intf);
+        hw = new HWTVDRM(buffer_sync_handler, buffer_allocator, hw_info_intf);
 #endif
       }
       break;
diff --git a/sdm/libs/core/hw_interface.h b/sdm/libs/core/hw_interface.h
index 5dbeb11..6774159 100644
--- a/sdm/libs/core/hw_interface.h
+++ b/sdm/libs/core/hw_interface.h
@@ -61,6 +61,7 @@
   virtual void ThermalEvent(int64_t thermal_level) = 0;
   virtual void CECMessage(char *message) = 0;
   virtual void IdlePowerCollapse() = 0;
+  virtual void PingPongTimeout() = 0;
 
  protected:
   virtual ~HWEventHandler() { }
@@ -82,7 +83,7 @@
   virtual DisplayError GetHWPanelInfo(HWPanelInfo *panel_info) = 0;
   virtual DisplayError SetDisplayAttributes(uint32_t index) = 0;
   virtual DisplayError SetDisplayAttributes(const HWDisplayAttributes &display_attributes) = 0;
-  virtual DisplayError GetConfigIndex(uint32_t mode, uint32_t *index) = 0;
+  virtual DisplayError GetConfigIndex(char *mode, uint32_t *index) = 0;
   virtual DisplayError PowerOn() = 0;
   virtual DisplayError PowerOff() = 0;
   virtual DisplayError Doze() = 0;
@@ -110,6 +111,7 @@
   virtual DisplayError SetScaleLutConfig(HWScaleLutInfo *lut_info) = 0;
   virtual DisplayError SetMixerAttributes(const HWMixerAttributes &mixer_attributes) = 0;
   virtual DisplayError GetMixerAttributes(HWMixerAttributes *mixer_attributes) = 0;
+  virtual DisplayError DumpDebugData() = 0;
 
  protected:
   virtual ~HWInterface() { }
diff --git a/sdm/libs/core/resource_default.cpp b/sdm/libs/core/resource_default.cpp
index 2d74941..f8909f4 100644
--- a/sdm/libs/core/resource_default.cpp
+++ b/sdm/libs/core/resource_default.cpp
@@ -212,7 +212,7 @@
   return kErrorNone;
 }
 
-DisplayError ResourceDefault::Stop(Handle display_ctx) {
+DisplayError ResourceDefault::Stop(Handle display_ctx, HWLayers *hw_layers) {
   locker_.Unlock();
 
   return kErrorNone;
@@ -923,8 +923,9 @@
   return kErrorNone;
 }
 
-DisplayError ResourceDefault::ValidateCursorPosition(Handle display_ctx, HWLayers *hw_layers,
-                                                     int x, int y) {
+DisplayError ResourceDefault::ValidateAndSetCursorPosition(Handle display_ctx, HWLayers *hw_layers,
+                                                           int x, int y,
+                                                           DisplayConfigVariableInfo *fb_config) {
   return kErrorNotSupported;
 }
 
diff --git a/sdm/libs/core/resource_default.h b/sdm/libs/core/resource_default.h
index f835410..a67eb09 100644
--- a/sdm/libs/core/resource_default.h
+++ b/sdm/libs/core/resource_default.h
@@ -50,7 +50,7 @@
                                           const HWPanelInfo &hw_panel_info,
                                           const HWMixerAttributes &mixer_attributes);
   virtual DisplayError Start(Handle display_ctx);
-  virtual DisplayError Stop(Handle display_ctx);
+  virtual DisplayError Stop(Handle display_ctx, HWLayers *hw_layers);
   virtual DisplayError Prepare(Handle display_ctx, HWLayers *hw_layers);
   virtual DisplayError PostPrepare(Handle display_ctx, HWLayers *hw_layers);
   virtual DisplayError Commit(Handle display_ctx, HWLayers *hw_layers);
@@ -60,7 +60,8 @@
   virtual DisplayError ValidateScaling(const LayerRect &crop, const LayerRect &dst, bool rotate90,
                                        BufferLayout layout, bool use_rotator_downscale);
   DisplayError ValidateCursorConfig(Handle display_ctx, const Layer *layer, bool is_top);
-  DisplayError ValidateCursorPosition(Handle display_ctx, HWLayers *hw_layers, int x, int y);
+  DisplayError ValidateAndSetCursorPosition(Handle display_ctx, HWLayers *hw_layers, int x, int y,
+                                            DisplayConfigVariableInfo *fb_config);
   DisplayError SetMaxBandwidthMode(HWBwModes mode);
   virtual DisplayError SetDetailEnhancerData(Handle display_ctx,
                                              const DisplayDetailEnhancerData &de_data);
diff --git a/sdm/libs/hwc/Android.mk b/sdm/libs/hwc/Android.mk
deleted file mode 100644
index a2142e3..0000000
--- a/sdm/libs/hwc/Android.mk
+++ /dev/null
@@ -1,39 +0,0 @@
-LOCAL_PATH := $(call my-dir)
-include $(CLEAR_VARS)
-include $(LOCAL_PATH)/../../../common.mk
-ifeq ($(use_hwc2),false)
-
-LOCAL_MODULE                  := hwcomposer.$(TARGET_BOARD_PLATFORM)
-LOCAL_VENDOR_MODULE           := true
-LOCAL_MODULE_RELATIVE_PATH    := hw
-LOCAL_MODULE_TAGS             := optional
-LOCAL_C_INCLUDES              := $(common_includes)
-LOCAL_HEADER_LIBRARIES        := display_headers
-
-LOCAL_CFLAGS                  := $(common_flags) -Wno-missing-field-initializers -Wno-unused-parameter \
-                                 -std=c++11 -fcolor-diagnostics -Wno-sign-conversion -DLOG_TAG=\"SDM\"
-LOCAL_CLANG                   := true
-
-LOCAL_SHARED_LIBRARIES        := libsdmcore libqservice libbinder libhardware libhardware_legacy \
-                                 libutils libcutils libsync libmemalloc libqdutils libdl \
-                                 libpowermanager libsdmutils libgpu_tonemapper  libc++ liblog \
-                                 libdrmutils libui
-
-LOCAL_SRC_FILES               := hwc_session.cpp \
-                                 hwc_display.cpp \
-                                 hwc_display_null.cpp \
-                                 hwc_display_primary.cpp \
-                                 hwc_display_external.cpp \
-                                 hwc_display_virtual.cpp \
-                                 hwc_debugger.cpp \
-                                 hwc_buffer_allocator.cpp \
-                                 hwc_buffer_sync_handler.cpp \
-                                 hwc_color_manager.cpp \
-                                 blit_engine_c2d.cpp \
-                                 cpuhint.cpp \
-                                 hwc_tonemapper.cpp \
-                                 hwc_socket_handler.cpp \
-                                 hwc_display_external_test.cpp
-
-include $(BUILD_SHARED_LIBRARY)
-endif
diff --git a/sdm/libs/hwc/blit_engine.h b/sdm/libs/hwc/blit_engine.h
deleted file mode 100644
index 6fa9733..0000000
--- a/sdm/libs/hwc/blit_engine.h
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
-* Copyright (c) 2015, 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.
-*/
-
-/*! @file blit_engine.h
-  @brief Interface file for Blit based compositior.
-
-  @details The client can use this interface to get the blit composition done
-
-*/
-
-#ifndef __BLIT_ENGINE_H__
-#define __BLIT_ENGINE_H__
-
-namespace sdm {
-
-/*! @brief Blit Engine implemented by the client
-
-  @details This class declares prototype for BlitEngine Interface which must be
-  implemented by the client. HWC will use this interface to use a Blit engine to get the
-  composition done.
-
-*/
-class BlitEngine {
- public:
-  BlitEngine() { }
-  virtual ~BlitEngine() { }
-
-  virtual int Init() = 0;
-  virtual void DeInit() = 0;
-  virtual int Prepare(LayerStack *layer_stack) = 0;
-  virtual int PreCommit(hwc_display_contents_1_t *content_list, LayerStack *layer_stack) = 0;
-  virtual int Commit(hwc_display_contents_1_t *content_list, LayerStack *layer_stack) = 0;
-  virtual void PostCommit(LayerStack *layer_stack) = 0;
-  virtual bool BlitActive() = 0;
-  virtual void SetFrameDumpConfig(uint32_t count) = 0;
-};
-
-}  // namespace sdm
-
-#endif  // __BLIT_ENGINE_H__
diff --git a/sdm/libs/hwc/blit_engine_c2d.cpp b/sdm/libs/hwc/blit_engine_c2d.cpp
deleted file mode 100644
index 4efe2f1..0000000
--- a/sdm/libs/hwc/blit_engine_c2d.cpp
+++ /dev/null
@@ -1,608 +0,0 @@
-/* Copyright (c) 2012-2016, 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.
-
-* Portions formerly licensed under Apache License, Version 2.0, are re licensed
-* under section 4 of Apache License, Version 2.0.
-
-* Copyright (C) 2010 The Android Open Source Project
-
-* Not a Contribution.
-
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-
-* http://www.apache.org/licenses/LICENSE-2.0
-
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-
-#include <hardware/hardware.h>
-#include <sync/sync.h>
-#include <copybit.h>
-#include <memalloc.h>
-#include <alloc_controller.h>
-#include <gr.h>
-
-#include <utils/constants.h>
-#include <utils/rect.h>
-#include <utils/formats.h>
-#include <algorithm>
-
-#include "blit_engine_c2d.h"
-#include "hwc_debugger.h"
-
-#define __CLASS__ "BlitEngineC2D"
-
-// TODO(user): Remove pragma after fixing sign conversion errors
-#if defined(__clang__)
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wsign-conversion"
-#endif
-
-namespace sdm {
-
-
-BlitEngineC2d::RegionIterator::RegionIterator(LayerRectArray rect) {
-  rect_array = rect;
-  r.end = INT(rect.count);
-  r.current = 0;
-  this->next = iterate;
-}
-
-int BlitEngineC2d::RegionIterator::iterate(copybit_region_t const *self, copybit_rect_t *rect) {
-  if (!self || !rect) {
-    DLOGE("iterate invalid parameters");
-    return 0;
-  }
-
-  RegionIterator const *me = static_cast<RegionIterator const*>(self);
-  if (me->r.current != me->r.end) {
-    rect->l = INT(me->rect_array.rect[me->r.current].left);
-    rect->t = INT(me->rect_array.rect[me->r.current].top);
-    rect->r = INT(me->rect_array.rect[me->r.current].right);
-    rect->b = INT(me->rect_array.rect[me->r.current].bottom);
-    me->r.current++;
-    return 1;
-  }
-  return 0;
-}
-
-BlitEngineC2d::BlitEngineC2d() {
-  for (uint32_t i = 0; i < kNumBlitTargetBuffers; i++) {
-    blit_target_buffer_[i] = NULL;
-    release_fence_fd_[i] = -1;
-  }
-}
-
-BlitEngineC2d::~BlitEngineC2d() {
-  if (blit_engine_c2d_) {
-    copybit_close(blit_engine_c2d_);
-    blit_engine_c2d_ = NULL;
-  }
-  FreeBlitTargetBuffers();
-}
-
-int BlitEngineC2d::Init() {
-  hw_module_t const *module;
-  if (hw_get_module("copybit", &module) == 0) {
-    if (copybit_open(module, &blit_engine_c2d_) < 0) {
-      DLOGI("CopyBitC2D Open failed.");
-      return -1;
-    }
-    DLOGI("Opened Copybit Module");
-  } else {
-    DLOGI("Copybit HW Module not found");
-    return -1;
-  }
-
-  return 0;
-}
-
-void BlitEngineC2d::DeInit() {
-  FreeBlitTargetBuffers();
-  if (blit_engine_c2d_) {
-    copybit_close(blit_engine_c2d_);
-    blit_engine_c2d_ = NULL;
-  }
-}
-
-int BlitEngineC2d::AllocateBlitTargetBuffers(uint32_t width, uint32_t height, uint32_t format,
-                                             uint32_t usage) {
-  int status = 0;
-  if (width <= 0 || height <= 0) {
-    return false;
-  }
-
-  if (blit_target_buffer_[0]) {
-    // Free and reallocate the buffers if the w/h changes
-    if (INT(width) != blit_target_buffer_[0]->width ||
-        INT(height) != blit_target_buffer_[0]->height) {
-      FreeBlitTargetBuffers();
-    }
-  }
-
-  for (uint32_t i = 0; i < kNumBlitTargetBuffers; i++) {
-    if (blit_target_buffer_[i] == NULL) {
-      status = alloc_buffer(&blit_target_buffer_[i], width, height, format, usage);
-    }
-    if (status < 0) {
-      DLOGE("Allocation of Blit target Buffer failed");
-      FreeBlitTargetBuffers();
-      break;
-    }
-  }
-
-  return status;
-}
-
-void BlitEngineC2d::FreeBlitTargetBuffers() {
-  for (uint32_t i = 0; i < kNumBlitTargetBuffers; i++) {
-    private_handle_t **target_buffer = &blit_target_buffer_[i];
-    if (*target_buffer) {
-      // Free the valid fence
-      if (release_fence_fd_[i] >= 0) {
-        close(release_fence_fd_[i]);
-        release_fence_fd_[i] = -1;
-      }
-      free_buffer(*target_buffer);
-      *target_buffer = NULL;
-    }
-  }
-}
-
-int BlitEngineC2d::ClearTargetBuffer(private_handle_t* hnd, const LayerRect& rect) {
-  int status = 0;
-  copybit_rect_t clear_rect = {INT(rect.left), INT(rect.top), INT(rect.right), INT(rect.bottom)};
-
-  copybit_image_t buffer;
-  buffer.w = ALIGN((hnd->width), 32);
-  buffer.h = hnd->height;
-  buffer.format = hnd->format;
-  buffer.base = reinterpret_cast<void *>(hnd->base);
-  buffer.handle = reinterpret_cast<native_handle_t *>(hnd);
-  int dst_format_mode = COPYBIT_LINEAR;
-  if (hnd->flags & private_handle_t::PRIV_FLAGS_UBWC_ALIGNED) {
-    dst_format_mode = COPYBIT_UBWC_COMPRESSED;
-  }
-  blit_engine_c2d_->set_parameter(blit_engine_c2d_, COPYBIT_DST_FORMAT_MODE, dst_format_mode);
-
-  status = blit_engine_c2d_->clear(blit_engine_c2d_, &buffer, &clear_rect);
-  return status;
-}
-
-void BlitEngineC2d::PostCommit(LayerStack *layer_stack) {
-  int fence_fd = -1;
-  uint32_t count = 0;
-  int fd = -1;
-
-  for (uint32_t i = blit_target_start_index_-2; (i > 0) && (count < num_blit_target_); i--) {
-    Layer *layer = layer_stack->layers.at(i);
-    LayerBuffer &layer_buffer = layer->input_buffer;
-    if (layer->composition == kCompositionBlit) {
-      int index = blit_target_start_index_ + count;
-      layer_buffer.release_fence_fd =
-        layer_stack->layers.at(index)->input_buffer.release_fence_fd;
-      fence_fd = layer_buffer.release_fence_fd;
-      close(layer_buffer.acquire_fence_fd);
-      layer_buffer.acquire_fence_fd = -1;
-      layer_stack->layers.at(index)->input_buffer.release_fence_fd = -1;
-      fd = layer_stack->layers.at(index)->input_buffer.acquire_fence_fd;
-      layer_stack->layers.at(index)->input_buffer.acquire_fence_fd = -1;
-      count++;
-    }
-  }
-
-  if (fd >= 0) {
-    // Close the C2D fence FD
-    close(fd);
-  }
-  SetReleaseFence(fence_fd);
-}
-
-// Sync wait to close the previous fd
-void BlitEngineC2d::SetReleaseFence(int fd) {
-  if (release_fence_fd_[current_blit_target_index_] >= 0) {
-    int ret = -1;
-    ret = sync_wait(release_fence_fd_[current_blit_target_index_], 1000);
-    if (ret < 0) {
-      DLOGE("sync_wait error! errno = %d, err str = %s", errno, strerror(errno));
-    }
-    close(release_fence_fd_[current_blit_target_index_]);
-  }
-  release_fence_fd_[current_blit_target_index_] = dup(fd);
-}
-
-bool BlitEngineC2d::BlitActive() {
-  return blit_active_;
-}
-
-void BlitEngineC2d::SetFrameDumpConfig(uint32_t count) {
-  dump_frame_count_ = count;
-  dump_frame_index_ = 0;
-}
-
-int BlitEngineC2d::Prepare(LayerStack *layer_stack) {
-  blit_target_start_index_ = 0;
-
-  uint32_t layer_count = UINT32(layer_stack->layers.size());
-  uint32_t gpu_target_index = layer_count - 1;  // default assumption
-  uint32_t i = 0;
-
-  for (; i < layer_count; i++) {
-    Layer *layer = layer_stack->layers.at(i);
-
-    // No 10 bit support for C2D
-    if (Is10BitFormat(layer->input_buffer.format)) {
-      return -1;
-    }
-
-    if (layer->composition == kCompositionGPUTarget) {
-      // Need FBT size for allocating buffers
-      gpu_target_index = i;
-      break;
-    }
-  }
-
-  if ((layer_count - 1) == gpu_target_index) {
-    // No blit target layer
-    return -1;
-  }
-
-  blit_target_start_index_ = ++i;
-  num_blit_target_ = layer_count - blit_target_start_index_;
-
-  LayerBuffer &layer_buffer = layer_stack->layers.at(gpu_target_index)->input_buffer;
-  int fbwidth = INT(layer_buffer.unaligned_width);
-  int fbheight = INT(layer_buffer.unaligned_height);
-  if ((fbwidth < 0) || (fbheight < 0)) {
-    return -1;
-  }
-
-  current_blit_target_index_ = (current_blit_target_index_ + 1) % kNumBlitTargetBuffers;
-  int k = blit_target_start_index_;
-
-  for (uint32_t j = 0; j < num_blit_target_; j++, k++) {
-    Layer *layer = layer_stack->layers.at(k);
-    LayerBuffer &layer_buffer = layer->input_buffer;
-    int aligned_w = 0;
-    int aligned_h = 0;
-
-    // Set the buffer height and width
-    AdrenoMemInfo::getInstance().getAlignedWidthAndHeight(fbwidth, fbheight/3,
-                   INT(HAL_PIXEL_FORMAT_RGBA_8888), 0, aligned_w, aligned_h);
-    layer_buffer.width = aligned_w;
-    layer_buffer.height = aligned_h;
-    layer_buffer.unaligned_width = fbwidth;
-    layer_buffer.unaligned_height = fbheight/3;
-
-    layer->plane_alpha = 0xFF;
-    layer->blending = kBlendingOpaque;
-    layer->composition = kCompositionBlitTarget;
-    layer->frame_rate = layer_stack->layers.at(gpu_target_index)->frame_rate;
-  }
-
-  return 0;
-}
-
-int BlitEngineC2d::PreCommit(hwc_display_contents_1_t *content_list, LayerStack *layer_stack) {
-  int status = 0;
-  uint32_t num_app_layers = (uint32_t) content_list->numHwLayers-1;
-  int target_width = 0;
-  int target_height = 0;
-  int target_aligned_width = 0;
-  int target_aligned_height = 0;
-  uint32_t processed_blit = 0;
-  LayerRect dst_rects[kMaxBlitTargetLayers];
-  bool blit_needed = false;
-  uint32_t usage = 0;
-
-  if (!num_app_layers) {
-    return -1;
-  }
-
-  for (uint32_t i = num_app_layers-1; (i > 0) && (processed_blit < num_blit_target_); i--) {
-    Layer *layer = layer_stack->layers.at(i);
-    if (layer->composition != kCompositionBlit) {
-      continue;
-    }
-    blit_needed = true;
-    layer_stack->flags.attributes_changed = true;
-
-    Layer *blit_layer = layer_stack->layers.at(blit_target_start_index_ + processed_blit);
-    LayerRect &blit_src_rect = blit_layer->src_rect;
-    int width = INT(layer->dst_rect.right - layer->dst_rect.left);
-    int height = INT(layer->dst_rect.bottom - layer->dst_rect.top);
-    int aligned_w = 0;
-    int aligned_h = 0;
-    usage = GRALLOC_USAGE_PRIVATE_IOMMU_HEAP | GRALLOC_USAGE_HW_TEXTURE;
-    if (blit_engine_c2d_->get(blit_engine_c2d_, COPYBIT_UBWC_SUPPORT) > 0) {
-      usage |= GRALLOC_USAGE_PRIVATE_ALLOC_UBWC;
-    }
-    // TODO(user): FrameBuffer is assumed to be RGBA
-    target_width = std::max(target_width, width);
-    target_height += height;
-
-    AdrenoMemInfo::getInstance().getAlignedWidthAndHeight(width, height,
-                                 INT(HAL_PIXEL_FORMAT_RGBA_8888), usage, aligned_w, aligned_h);
-
-    target_aligned_width = std::max(target_aligned_width, aligned_w);
-    target_aligned_height += aligned_h;
-
-    // Left will be zero always
-    dst_rects[processed_blit].top = FLOAT(target_aligned_height - aligned_h);
-    dst_rects[processed_blit].right = dst_rects[processed_blit].left +
-                                      (layer->dst_rect.right - layer->dst_rect.left);
-    dst_rects[processed_blit].bottom = (dst_rects[processed_blit].top +
-                                      (layer->dst_rect.bottom - layer->dst_rect.top));
-    blit_src_rect = dst_rects[processed_blit];
-    processed_blit++;
-  }
-
-  // Allocate a single buffer of RGBA8888 format
-  if (blit_needed && (AllocateBlitTargetBuffers(target_width, target_height,
-                                                HAL_PIXEL_FORMAT_RGBA_8888, usage) < 0)) {
-      status = -1;
-      return status;
-  }
-
-  if (blit_needed) {
-    for (uint32_t j = 0; j < num_blit_target_; j++) {
-      Layer *layer = layer_stack->layers.at(j + content_list->numHwLayers);
-      private_handle_t *target_buffer = blit_target_buffer_[current_blit_target_index_];
-      // Set the fd information
-        layer->input_buffer.width = target_aligned_width;
-        layer->input_buffer.height = target_aligned_height;
-        layer->input_buffer.unaligned_width = target_width;
-        layer->input_buffer.unaligned_height = target_height;
-      if (target_buffer->flags & private_handle_t::PRIV_FLAGS_UBWC_ALIGNED) {
-          layer->input_buffer.format = kFormatRGBA8888Ubwc;
-      }
-      layer->input_buffer.planes[0].fd = target_buffer->fd;
-      layer->input_buffer.planes[0].offset = 0;
-      layer->input_buffer.planes[0].stride = target_buffer->width;
-    }
-  }
-
-  return status;
-}
-
-int BlitEngineC2d::Commit(hwc_display_contents_1_t *content_list, LayerStack *layer_stack) {
-  int fd = -1;
-  int status = 0;
-  bool hybrid_present = false;
-  uint32_t num_app_layers = (uint32_t) content_list->numHwLayers-1;
-  private_handle_t *target_buffer = blit_target_buffer_[current_blit_target_index_];
-  blit_active_ = false;
-
-  if (!num_app_layers) {
-    return -1;
-  }
-
-  // if not Blit Targets return
-  for (uint32_t i = 0; i < num_app_layers; i++) {
-    Layer *layer = layer_stack->layers.at(i);
-    if (layer->composition == kCompositionHybrid || layer->composition == kCompositionBlit) {
-      hybrid_present = true;
-    }
-  }
-
-  if (!hybrid_present) {
-    return status;
-  }
-
-  // Clear blit target buffer
-  LayerRect clear_rect;
-  clear_rect.left =  0;
-  clear_rect.top = 0;
-  clear_rect.right = FLOAT(target_buffer->width);
-  clear_rect.bottom = FLOAT(target_buffer->height);
-  ClearTargetBuffer(target_buffer, clear_rect);
-
-  int copybit_layer_count = 0;
-  uint32_t processed_blit = 0;
-  for (uint32_t i = num_app_layers-1; (i > 0) && (processed_blit < num_blit_target_) &&
-      (status == 0); i--) {
-    Layer *layer = layer_stack->layers.at(i);
-    if (layer->composition != kCompositionBlit) {
-      continue;
-    }
-
-    for (uint32_t k = 0; k <= i; k++) {
-      Layer *bottom_layer = layer_stack->layers.at(k);
-      LayerBuffer &layer_buffer = bottom_layer->input_buffer;
-      // if layer below the blit layer does not intersect, ignore that layer
-      LayerRect inter_sect = Intersection(layer->dst_rect, bottom_layer->dst_rect);
-      if (bottom_layer->composition != kCompositionHybrid && !IsValid(inter_sect)) {
-        continue;
-      }
-      if (bottom_layer->composition == kCompositionGPU ||
-          bottom_layer->composition == kCompositionSDE ||
-          bottom_layer->composition == kCompositionGPUTarget) {
-        continue;
-      }
-
-      // For each layer marked as Hybrid, wait for acquire fence and then blit using the C2D
-      if (layer_buffer.acquire_fence_fd >= 0) {
-        // Wait for acquire fence on the App buffers.
-        if (sync_wait(layer_buffer.acquire_fence_fd, 1000) < 0) {
-          DLOGE("sync_wait error!! error no = %d err str = %s", errno, strerror(errno));
-        }
-        layer_buffer.acquire_fence_fd = -1;
-      }
-      hwc_layer_1_t *hwc_layer = &content_list->hwLayers[k];
-      LayerRect &src_rect = bottom_layer->blit_regions.at(processed_blit);
-      Layer *blit_layer = layer_stack->layers.at(blit_target_start_index_ + processed_blit);
-      LayerRect dest_rect = blit_layer->src_rect;
-      int ret_val = DrawRectUsingCopybit(hwc_layer, bottom_layer, src_rect, dest_rect);
-      copybit_layer_count++;
-      if (ret_val < 0) {
-        copybit_layer_count = 0;
-        DLOGE("DrawRectUsingCopyBit failed");
-        status = -1;
-        break;
-      }
-    }
-    processed_blit++;
-  }
-
-  if (copybit_layer_count) {
-    blit_active_ = true;
-    blit_engine_c2d_->flush_get_fence(blit_engine_c2d_, &fd);
-  }
-
-  if (blit_active_) {
-    // dump the render buffer
-    DumpBlitTargetBuffer(fd);
-
-    // Set the fd to the LayerStack BlitTargets fd
-    uint32_t layer_count = UINT32(layer_stack->layers.size());
-    for (uint32_t k = blit_target_start_index_; k < layer_count; k++) {
-      Layer *layer = layer_stack->layers.at(k);
-      LayerBuffer &layer_buffer = layer->input_buffer;
-      layer_buffer.acquire_fence_fd = fd;
-    }
-  }
-
-  return status;
-}
-
-int BlitEngineC2d::DrawRectUsingCopybit(hwc_layer_1_t *hwc_layer, Layer *layer,
-                                        LayerRect blit_rect, LayerRect blit_dest_Rect) {
-  private_handle_t *target_buffer = blit_target_buffer_[current_blit_target_index_];
-  const private_handle_t *hnd = static_cast<const private_handle_t *>(hwc_layer->handle);
-  LayerBuffer &layer_buffer = layer->input_buffer;
-
-  // Set the Copybit Source
-  copybit_image_t src;
-  src.handle = const_cast<native_handle_t *>(hwc_layer->handle);
-  src.w = hnd->width;
-  src.h = hnd->height;
-  src.base = reinterpret_cast<void *>(hnd->base);
-  src.format = hnd->format;
-  src.horiz_padding = 0;
-  src.vert_padding = 0;
-
-  // Copybit source rect
-  copybit_rect_t src_rect = {INT(blit_rect.left), INT(blit_rect.top), INT(blit_rect.right),
-                            INT(blit_rect.bottom)};
-
-  // Copybit destination rect
-  copybit_rect_t dst_rect = {INT(blit_dest_Rect.left), INT(blit_dest_Rect.top),
-                            INT(blit_dest_Rect.right), INT(blit_dest_Rect.bottom)};
-
-  // Copybit destination buffer
-  copybit_image_t dst;
-  dst.handle = static_cast<native_handle_t *>(target_buffer);
-  dst.w = ALIGN(target_buffer->width, 32);
-  dst.h = ALIGN((target_buffer->height), 32);
-  dst.base = reinterpret_cast<void *>(target_buffer->base);
-  dst.format = target_buffer->format;
-
-  // Copybit region is the destRect
-  LayerRect region_rect;
-  region_rect.left = FLOAT(dst_rect.l);
-  region_rect.top = FLOAT(dst_rect.t);
-  region_rect.right = FLOAT(dst_rect.r);
-  region_rect.bottom = FLOAT(dst_rect.b);
-
-  LayerRectArray region;
-  region.count = 1;
-  region.rect  = &region_rect;
-  RegionIterator copybitRegion(region);
-  int acquireFd = layer_buffer.acquire_fence_fd;
-
-  // FRAMEBUFFER_WIDTH/HEIGHT for c2d is the target buffer w/h
-  blit_engine_c2d_->set_parameter(blit_engine_c2d_, COPYBIT_FRAMEBUFFER_WIDTH,
-                                  target_buffer->width);
-  blit_engine_c2d_->set_parameter(blit_engine_c2d_, COPYBIT_FRAMEBUFFER_HEIGHT,
-                                  target_buffer->height);
-  int transform = 0;
-  if (layer->transform.rotation != 0.0f) transform |= COPYBIT_TRANSFORM_ROT_90;
-  if (layer->transform.flip_horizontal) transform |= COPYBIT_TRANSFORM_FLIP_H;
-  if (layer->transform.flip_vertical) transform |= COPYBIT_TRANSFORM_FLIP_V;
-  blit_engine_c2d_->set_parameter(blit_engine_c2d_, COPYBIT_TRANSFORM, transform);
-  blit_engine_c2d_->set_parameter(blit_engine_c2d_, COPYBIT_PLANE_ALPHA, hwc_layer->planeAlpha);
-  blit_engine_c2d_->set_parameter(blit_engine_c2d_, COPYBIT_BLEND_MODE, hwc_layer->blending);
-  blit_engine_c2d_->set_parameter(blit_engine_c2d_, COPYBIT_DITHER,
-    (dst.format == HAL_PIXEL_FORMAT_RGB_565) ? COPYBIT_ENABLE : COPYBIT_DISABLE);
-
-  int src_format_mode = COPYBIT_LINEAR;
-  if (hnd->flags & private_handle_t::PRIV_FLAGS_UBWC_ALIGNED) {
-    src_format_mode = COPYBIT_UBWC_COMPRESSED;
-  }
-  blit_engine_c2d_->set_parameter(blit_engine_c2d_, COPYBIT_SRC_FORMAT_MODE, src_format_mode);
-
-  blit_engine_c2d_->set_sync(blit_engine_c2d_, acquireFd);
-  int err = blit_engine_c2d_->stretch(blit_engine_c2d_, &dst, &src, &dst_rect, &src_rect,
-                                      &copybitRegion);
-
-  if (err < 0) {
-    DLOGE("copybit stretch failed");
-  }
-
-  return err;
-}
-
-void BlitEngineC2d::DumpBlitTargetBuffer(int fd) {
-  if (!dump_frame_count_) {
-    return;
-  }
-
-  private_handle_t *target_buffer = blit_target_buffer_[current_blit_target_index_];
-
-  if (fd >= 0) {
-    int error = sync_wait(fd, 1000);
-    if (error < 0) {
-      DLOGW("sync_wait error errno = %d, desc = %s", errno, strerror(errno));
-      return;
-    }
-  }
-
-  char dump_file_name[PATH_MAX];
-  size_t result = 0;
-  snprintf(dump_file_name, sizeof(dump_file_name), "/data/misc/display/frame_dump_primary"
-           "/blit_target_%d.raw", (dump_frame_index_));
-  FILE* fp = fopen(dump_file_name, "w+");
-  if (fp) {
-    result = fwrite(reinterpret_cast<void *>(target_buffer->base), target_buffer->size, 1, fp);
-    fclose(fp);
-  }
-  dump_frame_count_--;
-  dump_frame_index_++;
-}
-
-}  // namespace sdm
-#if defined(__clang__)
-#pragma clang diagnostic pop
-#endif
-
diff --git a/sdm/libs/hwc/blit_engine_c2d.h b/sdm/libs/hwc/blit_engine_c2d.h
deleted file mode 100644
index 6536d44..0000000
--- a/sdm/libs/hwc/blit_engine_c2d.h
+++ /dev/null
@@ -1,121 +0,0 @@
-/* Copyright (c) 2012 - 2016, 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.
-
-* Portions formerly licensed under Apache License, Version 2.0, are re licensed
-* under section 4 of Apache License, Version 2.0.
-
-* Copyright (C) 2010 The Android Open Source Project
-
-* Not a Contribution.
-
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-
-* http://www.apache.org/licenses/LICENSE-2.0
-
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-
-/*! @file blit_engine.h
-  @brief Interface file for Blit based compositior.
-
-  @details The client can use this interface to get the blit composition done
-
-*/
-
-#include <hardware/hwcomposer.h>
-#include <core/layer_stack.h>
-#include <copybit.h>
-#include "blit_engine.h"
-
-#ifndef __BLIT_ENGINE_C2D_H__
-#define __BLIT_ENGINE_C2D_H__
-
-namespace sdm {
-
-// C2D Blit implemented by the client
-// This class implements the BlitEngine Interface which is used to get the
-// Blit composition using C2D
-class BlitEngineC2d : public BlitEngine {
- public:
-  BlitEngineC2d();
-  virtual ~BlitEngineC2d();
-
-  virtual int Init();
-  virtual void DeInit();
-  virtual int Prepare(LayerStack *layer_stack);
-  virtual int PreCommit(hwc_display_contents_1_t *content_list, LayerStack *layer_stack);
-  virtual int Commit(hwc_display_contents_1_t *content_list, LayerStack *layer_stack);
-  virtual void PostCommit(LayerStack *layer_stack);
-  virtual bool BlitActive();
-  virtual void SetFrameDumpConfig(uint32_t count);
-
-
- private:
-  static const uint32_t kNumBlitTargetBuffers = 3;
-
-  struct Range {
-    int current;
-    int end;
-  };
-
-  struct RegionIterator : public copybit_region_t {
-    explicit RegionIterator(LayerRectArray rect);
-   private:
-    static int iterate(copybit_region_t const *self, copybit_rect_t *rect);
-    LayerRectArray rect_array;
-    mutable Range r;
-  };
-
-  int AllocateBlitTargetBuffers(uint32_t width, uint32_t height, uint32_t format, uint32_t usage);
-  void FreeBlitTargetBuffers();
-  int ClearTargetBuffer(private_handle_t* hnd, const LayerRect& rect);
-  int DrawRectUsingCopybit(hwc_layer_1_t *hwc_layer, Layer *layer, LayerRect blit_rect,
-                           LayerRect blit_dest_Rect);
-  void SetReleaseFence(int fence_fd);
-  void DumpBlitTargetBuffer(int fd);
-
-  copybit_device_t *blit_engine_c2d_ = NULL;
-  private_handle_t *blit_target_buffer_[kNumBlitTargetBuffers];
-  uint32_t current_blit_target_index_ = 0;
-  int release_fence_fd_[kNumBlitTargetBuffers];
-  uint32_t num_blit_target_ = 0;
-  int blit_target_start_index_ = 0;
-  bool blit_active_ = false;
-  uint32_t dump_frame_count_ = 0;
-  uint32_t dump_frame_index_ = 0;
-};
-
-}  // namespace sdm
-
-#endif  // __BLIT_ENGINE_C2D_H__
diff --git a/sdm/libs/hwc/hwc_buffer_allocator.cpp b/sdm/libs/hwc/hwc_buffer_allocator.cpp
deleted file mode 100644
index 25f366f..0000000
--- a/sdm/libs/hwc/hwc_buffer_allocator.cpp
+++ /dev/null
@@ -1,330 +0,0 @@
-/*
-* Copyright (c) 2015 - 2017, 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.
-*/
-
-#include <gralloc_priv.h>
-#include <memalloc.h>
-#include <gr.h>
-#include <alloc_controller.h>
-#include <utils/constants.h>
-#include <utils/debug.h>
-#include <core/buffer_allocator.h>
-
-#include "hwc_debugger.h"
-#include "hwc_buffer_allocator.h"
-
-#define __CLASS__ "HWCBufferAllocator"
-
-namespace sdm {
-
-HWCBufferAllocator::HWCBufferAllocator() {
-  alloc_controller_ = gralloc::IAllocController::getInstance();
-}
-
-DisplayError HWCBufferAllocator::AllocateBuffer(BufferInfo *buffer_info) {
-  gralloc::alloc_data data;
-
-  const BufferConfig &buffer_config = buffer_info->buffer_config;
-  AllocatedBufferInfo *alloc_buffer_info = &buffer_info->alloc_buffer_info;
-  MetaBufferInfo *meta_buffer_info = new MetaBufferInfo();
-
-  if (!meta_buffer_info) {
-    return kErrorMemory;
-  }
-
-  int alloc_flags = INT(GRALLOC_USAGE_PRIVATE_IOMMU_HEAP);
-  int error = 0;
-
-  int width = INT(buffer_config.width);
-  int height = INT(buffer_config.height);
-  int format;
-
-  if (buffer_config.secure_camera) {
-    alloc_flags = GRALLOC_USAGE_HW_CAMERA_WRITE;
-    alloc_flags |= (GRALLOC_USAGE_PROTECTED | GRALLOC_USAGE_HW_COMPOSER);
-    data.align = SZ_2M;
-  } else if (buffer_config.secure) {
-    alloc_flags = INT(GRALLOC_USAGE_PRIVATE_MM_HEAP);
-    alloc_flags |= INT(GRALLOC_USAGE_PROTECTED);
-    data.align = SECURE_ALIGN;
-  } else {
-    data.align = UINT32(getpagesize());
-  }
-
-  if (buffer_config.cache == false) {
-    // Allocate uncached buffers
-    alloc_flags |= GRALLOC_USAGE_PRIVATE_UNCACHED;
-  }
-
-  error = SetBufferInfo(buffer_config.format, &format, &alloc_flags);
-  if (error != 0) {
-    delete meta_buffer_info;
-    return kErrorParameters;
-  }
-
-  int aligned_width = 0, aligned_height = 0;
-  uint32_t buffer_size = getBufferSizeAndDimensions(width, height, format, alloc_flags,
-                                                    aligned_width, aligned_height);
-
-  buffer_size = ROUND_UP(buffer_size, data.align) * buffer_config.buffer_count;
-
-  data.base = 0;
-  data.fd = -1;
-  data.offset = 0;
-  data.size = buffer_size;
-  data.uncached = !buffer_config.cache;
-
-  error = alloc_controller_->allocate(data, alloc_flags);
-  if (error != 0) {
-    DLOGE("Error allocating memory size %d uncached %d", data.size, data.uncached);
-    delete meta_buffer_info;
-    return kErrorMemory;
-  }
-
-  alloc_buffer_info->fd = data.fd;
-  // TODO(user): define stride for all planes and fix stride in bytes
-  alloc_buffer_info->stride = UINT32(aligned_width);
-  alloc_buffer_info->aligned_width = UINT32(aligned_width);
-  alloc_buffer_info->aligned_height = UINT32(aligned_height);
-  alloc_buffer_info->size = buffer_size;
-
-  meta_buffer_info->base_addr = data.base;
-  meta_buffer_info->alloc_type = data.allocType;
-
-  buffer_info->private_data = meta_buffer_info;
-
-  return kErrorNone;
-}
-
-DisplayError HWCBufferAllocator::FreeBuffer(BufferInfo *buffer_info) {
-  int ret = 0;
-  AllocatedBufferInfo *alloc_buffer_info = &buffer_info->alloc_buffer_info;
-
-  // Deallocate the buffer, only if the buffer fd is valid.
-  if (alloc_buffer_info->fd > 0) {
-    MetaBufferInfo *meta_buffer_info = static_cast<MetaBufferInfo *> (buffer_info->private_data);
-    gralloc::IMemAlloc *memalloc = alloc_controller_->getAllocator(meta_buffer_info->alloc_type);
-    if (memalloc == NULL) {
-      DLOGE("Memalloc handle is NULL, alloc type %d", meta_buffer_info->alloc_type);
-      return kErrorResources;
-    }
-
-    ret = memalloc->free_buffer(meta_buffer_info->base_addr, alloc_buffer_info->size, 0,
-                                alloc_buffer_info->fd);
-    if (ret != 0) {
-      DLOGE("Error freeing buffer base_addr %p size %d fd %d", meta_buffer_info->base_addr,
-            alloc_buffer_info->size, alloc_buffer_info->fd);
-      return kErrorMemory;
-    }
-
-    alloc_buffer_info->fd = -1;
-    alloc_buffer_info->stride = 0;
-    alloc_buffer_info->aligned_width = 0;
-    alloc_buffer_info->aligned_height = 0;
-    alloc_buffer_info->size = 0;
-
-    meta_buffer_info->base_addr = NULL;
-    meta_buffer_info->alloc_type = 0;
-
-    delete meta_buffer_info;
-    meta_buffer_info = NULL;
-  }
-
-  return kErrorNone;
-}
-
-uint32_t HWCBufferAllocator::GetBufferSize(BufferInfo *buffer_info) {
-  uint32_t align = UINT32(getpagesize());
-
-  const BufferConfig &buffer_config = buffer_info->buffer_config;
-
-  int alloc_flags = INT(GRALLOC_USAGE_PRIVATE_IOMMU_HEAP);
-
-  int width = INT(buffer_config.width);
-  int height = INT(buffer_config.height);
-  int format;
-
-  if (buffer_config.secure_camera) {
-    alloc_flags = GRALLOC_USAGE_HW_CAMERA_WRITE;
-    alloc_flags |= (GRALLOC_USAGE_PROTECTED | GRALLOC_USAGE_HW_COMPOSER);
-    align = SZ_2M;
-  } else if (buffer_config.secure) {
-    alloc_flags = INT(GRALLOC_USAGE_PRIVATE_MM_HEAP);
-    alloc_flags |= INT(GRALLOC_USAGE_PROTECTED);
-    align = SECURE_ALIGN;
-  }
-
-  if (buffer_config.cache == false) {
-    // Allocate uncached buffers
-    alloc_flags |= GRALLOC_USAGE_PRIVATE_UNCACHED;
-  }
-
-  if (SetBufferInfo(buffer_config.format, &format, &alloc_flags) < 0) {
-    return 0;
-  }
-
-  int aligned_width = 0;
-  int aligned_height = 0;
-  uint32_t buffer_size = getBufferSizeAndDimensions(width, height, format, alloc_flags,
-                                                    aligned_width, aligned_height);
-
-  buffer_size = ROUND_UP(buffer_size, align) * buffer_config.buffer_count;
-
-  return buffer_size;
-}
-
-int HWCBufferAllocator::SetBufferInfo(LayerBufferFormat format, int *target, int *flags) {
-  switch (format) {
-  case kFormatRGBA8888:                 *target = HAL_PIXEL_FORMAT_RGBA_8888;             break;
-  case kFormatRGBX8888:                 *target = HAL_PIXEL_FORMAT_RGBX_8888;             break;
-  case kFormatRGB888:                   *target = HAL_PIXEL_FORMAT_RGB_888;               break;
-  case kFormatRGB565:                   *target = HAL_PIXEL_FORMAT_RGB_565;               break;
-  case kFormatBGR565:                   *target = HAL_PIXEL_FORMAT_BGR_565;               break;
-  case kFormatBGRA8888:                 *target = HAL_PIXEL_FORMAT_BGRA_8888;             break;
-  case kFormatYCrCb420PlanarStride16:   *target = HAL_PIXEL_FORMAT_YV12;                  break;
-  case kFormatYCrCb420SemiPlanar:       *target = HAL_PIXEL_FORMAT_YCrCb_420_SP;          break;
-  case kFormatYCbCr420SemiPlanar:       *target = HAL_PIXEL_FORMAT_YCbCr_420_SP;          break;
-  case kFormatYCbCr422H2V1Packed:       *target = HAL_PIXEL_FORMAT_YCbCr_422_I;           break;
-  case kFormatCbYCrY422H2V1Packed:      *target = HAL_PIXEL_FORMAT_CbYCrY_422_I;          break;
-  case kFormatYCbCr422H2V1SemiPlanar:   *target = HAL_PIXEL_FORMAT_YCbCr_422_SP;          break;
-  case kFormatYCbCr420SemiPlanarVenus:  *target = HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS;    break;
-  case kFormatYCrCb420SemiPlanarVenus:  *target = HAL_PIXEL_FORMAT_YCrCb_420_SP_VENUS;    break;
-  case kFormatYCbCr420SPVenusUbwc:
-    *target = HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC;
-    *flags |= GRALLOC_USAGE_PRIVATE_ALLOC_UBWC;
-    break;
-  case kFormatRGBA5551:                 *target = HAL_PIXEL_FORMAT_RGBA_5551;             break;
-  case kFormatRGBA4444:                 *target = HAL_PIXEL_FORMAT_RGBA_4444;             break;
-  case kFormatRGBA1010102:              *target = HAL_PIXEL_FORMAT_RGBA_1010102;          break;
-  case kFormatARGB2101010:              *target = HAL_PIXEL_FORMAT_ARGB_2101010;          break;
-  case kFormatRGBX1010102:              *target = HAL_PIXEL_FORMAT_RGBX_1010102;          break;
-  case kFormatXRGB2101010:              *target = HAL_PIXEL_FORMAT_XRGB_2101010;          break;
-  case kFormatBGRA1010102:              *target = HAL_PIXEL_FORMAT_BGRA_1010102;          break;
-  case kFormatABGR2101010:              *target = HAL_PIXEL_FORMAT_ABGR_2101010;          break;
-  case kFormatBGRX1010102:              *target = HAL_PIXEL_FORMAT_BGRX_1010102;          break;
-  case kFormatXBGR2101010:              *target = HAL_PIXEL_FORMAT_XBGR_2101010;          break;
-  case kFormatYCbCr420P010:             *target = HAL_PIXEL_FORMAT_YCbCr_420_P010;        break;
-  case kFormatYCbCr420TP10Ubwc:
-    *target = HAL_PIXEL_FORMAT_YCbCr_420_TP10_UBWC;
-    *flags |= GRALLOC_USAGE_PRIVATE_ALLOC_UBWC;
-    break;
-  case kFormatYCbCr420P010Ubwc:
-    *target = HAL_PIXEL_FORMAT_YCbCr_420_P010_UBWC;
-    *flags |= GRALLOC_USAGE_PRIVATE_ALLOC_UBWC;
-    break;
-  case kFormatRGBA8888Ubwc:
-    *target = HAL_PIXEL_FORMAT_RGBA_8888;
-    *flags |= GRALLOC_USAGE_PRIVATE_ALLOC_UBWC;
-    break;
-  case kFormatRGBX8888Ubwc:
-    *target = HAL_PIXEL_FORMAT_RGBX_8888;
-    *flags |= GRALLOC_USAGE_PRIVATE_ALLOC_UBWC;
-    break;
-  case kFormatBGR565Ubwc:
-    *target = HAL_PIXEL_FORMAT_BGR_565;
-    *flags |= GRALLOC_USAGE_PRIVATE_ALLOC_UBWC;
-    break;
-  case kFormatRGBA1010102Ubwc:
-    *target = HAL_PIXEL_FORMAT_RGBA_1010102;
-    *flags |= GRALLOC_USAGE_PRIVATE_ALLOC_UBWC;
-    break;
-  case kFormatRGBX1010102Ubwc:
-    *target = HAL_PIXEL_FORMAT_RGBX_1010102;
-    *flags |= GRALLOC_USAGE_PRIVATE_ALLOC_UBWC;
-    break;
-  default:
-    DLOGE("Unsupported format = 0x%x", format);
-    return -EINVAL;
-  }
-
-  return 0;
-}
-
-DisplayError HWCBufferAllocator::GetAllocatedBufferInfo(const BufferConfig &buffer_config,
-                                 AllocatedBufferInfo *allocated_buffer_info) {
-  int width = INT(buffer_config.width);
-  int height = INT(buffer_config.height);
-  int alloc_flags = INT(GRALLOC_USAGE_PRIVATE_IOMMU_HEAP);
-
-  if (buffer_config.secure) {
-    alloc_flags = INT(GRALLOC_USAGE_PRIVATE_MM_HEAP);
-    alloc_flags |= INT(GRALLOC_USAGE_PROTECTED);
-  }
-
-  if (buffer_config.cache == false) {
-    // Allocate uncached buffers
-    alloc_flags |= GRALLOC_USAGE_PRIVATE_UNCACHED;
-  }
-
-  int format;
-  int error = SetBufferInfo(buffer_config.format, &format, &alloc_flags);
-  if (error) {
-    DLOGE("Failed: format = %d or width = %d height = %d", buffer_config.format, width, height);
-    return kErrorNotSupported;
-  }
-
-  int width_aligned = 0, height_aligned = 0;
-  uint32_t buffer_size = 0;
-  buffer_size = getBufferSizeAndDimensions(width, height, format, alloc_flags,
-                                           width_aligned, height_aligned);
-
-  allocated_buffer_info->stride = UINT32(width_aligned);
-  allocated_buffer_info->aligned_width = UINT32(width_aligned);
-  allocated_buffer_info->aligned_height = UINT32(height_aligned);
-  allocated_buffer_info->size = UINT32(buffer_size);
-  allocated_buffer_info->format = buffer_config.format;
-
-  return kErrorNone;
-}
-
-DisplayError HWCBufferAllocator::GetBufferLayout(const AllocatedBufferInfo &buf_info,
-                                                 uint32_t stride[4], uint32_t offset[4],
-                                                 uint32_t *num_planes) {
-  private_handle_t hnd(-1, 0, 0, 0, 0, 0, 0);
-  int format = HAL_PIXEL_FORMAT_RGBA_8888;
-  int flags = 0;
-
-  SetBufferInfo(buf_info.format, &format, &flags);
-  // Setup only the required stuff, skip rest
-  hnd.format = format;
-  hnd.width = buf_info.aligned_width;
-  hnd.height = buf_info.aligned_height;
-  if (flags & GRALLOC_USAGE_PRIVATE_ALLOC_UBWC) {
-    hnd.flags = private_handle_t::PRIV_FLAGS_UBWC_ALIGNED;
-  }
-
-  int ret = getBufferLayout(&hnd, stride, offset, num_planes);
-  if (ret < 0) {
-    DLOGE("getBufferLayout failed");
-    return kErrorParameters;
-  }
-
-  return kErrorNone;
-}
-
-}  // namespace sdm
diff --git a/sdm/libs/hwc/hwc_buffer_allocator.h b/sdm/libs/hwc/hwc_buffer_allocator.h
deleted file mode 100644
index a8cf462..0000000
--- a/sdm/libs/hwc/hwc_buffer_allocator.h
+++ /dev/null
@@ -1,70 +0,0 @@
-/*
-* Copyright (c) 2015-2016, 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_BUFFER_ALLOCATOR_H__
-#define __HWC_BUFFER_ALLOCATOR_H__
-
-#include <sys/mman.h>
-#include <fcntl.h>
-
-namespace gralloc {
-
-class IAllocController;
-
-}  // namespace gralloc
-
-namespace sdm {
-
-class HWCBufferAllocator : public BufferAllocator {
- public:
-  HWCBufferAllocator();
-
-  DisplayError AllocateBuffer(BufferInfo *buffer_info);
-  DisplayError FreeBuffer(BufferInfo *buffer_info);
-  uint32_t GetBufferSize(BufferInfo *buffer_info);
-  DisplayError GetAllocatedBufferInfo(const BufferConfig &buffer_config,
-                                      AllocatedBufferInfo *allocated_buffer_info);
-  DisplayError GetBufferLayout(const AllocatedBufferInfo &buf_info,
-                               uint32_t stride[4], uint32_t offset[4],
-                               uint32_t *num_planes);
-  int SetBufferInfo(LayerBufferFormat format, int *target, int *flags);
-
- private:
-  struct MetaBufferInfo {
-    int alloc_type;              //!< Specifies allocation type set by the buffer allocator.
-    void *base_addr;             //!< Specifies the base address of the allocated output buffer.
-  };
-
-  gralloc::IAllocController *alloc_controller_;
-};
-
-}  // namespace sdm
-#endif  // __HWC_BUFFER_ALLOCATOR_H__
-
diff --git a/sdm/libs/hwc/hwc_color_manager.cpp b/sdm/libs/hwc/hwc_color_manager.cpp
deleted file mode 100644
index 471ca49..0000000
--- a/sdm/libs/hwc/hwc_color_manager.cpp
+++ /dev/null
@@ -1,652 +0,0 @@
-/*
-* Copyright (c) 2015 - 2016, 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.
-*/
-
-#include <dlfcn.h>
-#include <powermanager/IPowerManager.h>
-#include <cutils/sockets.h>
-#include <cutils/native_handle.h>
-#include <utils/String16.h>
-#include <binder/Parcel.h>
-#include <gralloc_priv.h>
-#include <hardware/hwcomposer.h>
-#include <hardware/hwcomposer_defs.h>
-#include <QService.h>
-
-#include <core/dump_interface.h>
-#include <utils/constants.h>
-#include <utils/debug.h>
-#include <core/buffer_allocator.h>
-#include <private/color_params.h>
-#include "hwc_buffer_allocator.h"
-#include "hwc_buffer_sync_handler.h"
-#include "hwc_session.h"
-#include "hwc_debugger.h"
-
-#define __CLASS__ "HWCColorManager"
-
-namespace sdm {
-
-uint32_t HWCColorManager::Get8BitsARGBColorValue(const PPColorFillParams &params) {
-  uint32_t argb_color = ((params.color.r << 16) & 0xff0000) | ((params.color.g << 8) & 0xff00) |
-                        ((params.color.b) & 0xff);
-  return argb_color;
-}
-
-int HWCColorManager::CreatePayloadFromParcel(const android::Parcel &in, uint32_t *disp_id,
-                                             PPDisplayAPIPayload *sink) {
-  int ret = 0;
-  uint32_t id(0);
-  uint32_t size(0);
-
-  id = UINT32(in.readInt32());
-  size = UINT32(in.readInt32());
-  if (size > 0 && size == in.dataAvail()) {
-    const void *data = in.readInplace(size);
-    const uint8_t *temp = reinterpret_cast<const uint8_t *>(data);
-
-    sink->size = size;
-    sink->payload = const_cast<uint8_t *>(temp);
-    *disp_id = id;
-  } else {
-    DLOGW("Failing size checking, size = %d", size);
-    ret = -EINVAL;
-  }
-
-  return ret;
-}
-
-void HWCColorManager::MarshallStructIntoParcel(const PPDisplayAPIPayload &data,
-                                               android::Parcel *out_parcel) {
-  out_parcel->writeInt32(INT32(data.size));
-  if (data.payload)
-    out_parcel->write(data.payload, data.size);
-}
-
-HWCColorManager *HWCColorManager::CreateColorManager() {
-  HWCColorManager *color_mgr = new HWCColorManager();
-
-  if (color_mgr) {
-    // Load display API interface library. And retrieve color API function tables.
-    DynLib &color_apis_lib = color_mgr->color_apis_lib_;
-    if (color_apis_lib.Open(DISPLAY_API_INTERFACE_LIBRARY_NAME)) {
-      if (!color_apis_lib.Sym(DISPLAY_API_FUNC_TABLES, &color_mgr->color_apis_)) {
-        DLOGE("Fail to retrieve = %s from %s", DISPLAY_API_FUNC_TABLES,
-              DISPLAY_API_INTERFACE_LIBRARY_NAME);
-        delete color_mgr;
-        return NULL;
-      }
-    } else {
-      DLOGW("Unable to load = %s", DISPLAY_API_INTERFACE_LIBRARY_NAME);
-      delete color_mgr;
-      return NULL;
-    }
-    DLOGI("Successfully loaded %s", DISPLAY_API_INTERFACE_LIBRARY_NAME);
-
-    // Load diagclient library and invokes its entry point to pass in display APIs.
-    DynLib &diag_client_lib = color_mgr->diag_client_lib_;
-    if (diag_client_lib.Open(QDCM_DIAG_CLIENT_LIBRARY_NAME)) {
-      if (!diag_client_lib.Sym(INIT_QDCM_DIAG_CLIENT_NAME,
-                               reinterpret_cast<void **>(&color_mgr->qdcm_diag_init_)) ||
-        !diag_client_lib.Sym(DEINIT_QDCM_DIAG_CLIENT_NAME,
-                               reinterpret_cast<void **>(&color_mgr->qdcm_diag_deinit_))) {
-        DLOGE("Fail to retrieve = %s from %s", INIT_QDCM_DIAG_CLIENT_NAME,
-              QDCM_DIAG_CLIENT_LIBRARY_NAME);
-      } else {
-        // invoke Diag Client entry point to initialize.
-        color_mgr->qdcm_diag_init_(color_mgr->color_apis_);
-        DLOGI("Successfully loaded %s and %s and diag_init'ed", DISPLAY_API_INTERFACE_LIBRARY_NAME,
-              QDCM_DIAG_CLIENT_LIBRARY_NAME);
-      }
-    } else {
-      DLOGW("Unable to load = %s", QDCM_DIAG_CLIENT_LIBRARY_NAME);
-      // only QDCM Diag client failed to be loaded and system still should function.
-    }
-  } else {
-    DLOGE("Unable to create HWCColorManager");
-    return NULL;
-  }
-
-  return color_mgr;
-}
-
-HWCColorManager::~HWCColorManager() {
-}
-
-void HWCColorManager::DestroyColorManager() {
-  if (qdcm_mode_mgr_) {
-    delete qdcm_mode_mgr_;
-  }
-  if (qdcm_diag_deinit_) {
-    qdcm_diag_deinit_();
-  }
-  delete this;
-}
-
-int HWCColorManager::EnableQDCMMode(bool enable, HWCDisplay *hwc_display) {
-  int ret = 0;
-
-  if (!qdcm_mode_mgr_) {
-    qdcm_mode_mgr_ = HWCQDCMModeManager::CreateQDCMModeMgr();
-    if (!qdcm_mode_mgr_) {
-      DLOGE("Unable to create QDCM operating mode manager.");
-      ret = -EFAULT;
-    }
-  }
-
-  if (qdcm_mode_mgr_) {
-    ret = qdcm_mode_mgr_->EnableQDCMMode(enable, hwc_display);
-  }
-
-  return ret;
-}
-
-bool HWCColorManager::SolidFillLayersPrepare(hwc_display_contents_1_t **displays,
-                                             HWCDisplay *hwc_display) {
-  SCOPE_LOCK(locker_);
-
-  // Query HWCColorManager if QDCM tool requesting SOLID_FILL mode.
-  uint32_t solid_fill_color = Get8BitsARGBColorValue(solid_fill_params_);
-  hwc_display_contents_1_t *layer_list = displays[HWC_DISPLAY_PRIMARY];
-
-  if (solid_fill_enable_ && solid_fill_layers_ && layer_list) {
-    // 1. shallow copy HWC_FRAMEBUFFER_TARGET layer info solid fill layer list.
-    solid_fill_layers_->hwLayers[1] = layer_list->hwLayers[layer_list->numHwLayers - 1];
-
-    // 2. continue the prepare<> on solid_fill_layers.
-    hwc_display->Perform(HWCDisplayPrimary::SET_QDCM_SOLID_FILL_INFO, solid_fill_color);
-    hwc_display->Prepare(solid_fill_layers_);  // RECT info included.
-
-    // 3. Set HWC_OVERLAY to all SF layers before returning to framework.
-    for (size_t i = 0; i < (layer_list->numHwLayers - 1); i++) {
-      hwc_layer_1_t *layer = &layer_list->hwLayers[i];
-      layer->compositionType = HWC_OVERLAY;
-    }
-
-    return true;
-  } else if (!solid_fill_enable_) {
-    hwc_display->Perform(HWCDisplayPrimary::UNSET_QDCM_SOLID_FILL_INFO, 0);
-  }
-
-  return false;
-}
-
-bool HWCColorManager::SolidFillLayersSet(hwc_display_contents_1_t **displays,
-                                         HWCDisplay *hwc_display) {
-  // Query HWCColorManager if QDCM tool requesting SOLID_FILL mode.
-  SCOPE_LOCK(locker_);
-  hwc_display_contents_1_t *layer_list = displays[HWC_DISPLAY_PRIMARY];
-  if (solid_fill_enable_ && solid_fill_layers_ && layer_list) {
-    hwc_display->Commit(solid_fill_layers_);
-
-    // SurfaceFlinger layer stack is dropped in solid fill case and replaced with local layer stack
-    // Close acquire fence fds associated with SF layer stack
-    // Close release/retire fence fds returned along with local layer stack
-    for (size_t i = 0; i < (layer_list->numHwLayers - 1); i++) {
-      int &fence_fd = layer_list->hwLayers[i].acquireFenceFd;
-      if (fence_fd >= 0) {
-        close(fence_fd);
-        fence_fd = -1;
-      }
-    }
-
-    for (size_t i = 0; i < (solid_fill_layers_->numHwLayers - 1); i++) {
-      int &fence_fd = solid_fill_layers_->hwLayers[i].releaseFenceFd;
-      if (fence_fd >= 0) {
-        close(fence_fd);
-        fence_fd = -1;
-      }
-    }
-    if (solid_fill_layers_->retireFenceFd >= 0) {
-      close(solid_fill_layers_->retireFenceFd);
-      solid_fill_layers_->retireFenceFd = -1;
-    }
-
-    return true;
-  }
-
-  return false;
-}
-
-int HWCColorManager::CreateSolidFillLayers(HWCDisplay *hwc_display) {
-  int ret = 0;
-
-  if (!solid_fill_layers_) {
-    uint32_t size = sizeof(hwc_display_contents_1) + kNumSolidFillLayers * sizeof(hwc_layer_1_t);
-    uint32_t primary_width = 0;
-    uint32_t primary_height = 0;
-
-    hwc_display->GetMixerResolution(&primary_width, &primary_height);
-    uint8_t *buf = new uint8_t[size]();
-    // handle for solid fill layer with fd = -1.
-    private_handle_t *handle =
-        new private_handle_t(-1, 0, private_handle_t::PRIV_FLAGS_FRAMEBUFFER, BUFFER_TYPE_UI,
-                             HAL_PIXEL_FORMAT_RGBA_8888, INT32(primary_width),
-                             INT32(primary_height));
-
-    if (!buf || !handle) {
-      DLOGE("Failed to allocate memory.");
-      if (buf)
-        delete[] buf;
-      if (handle)
-        delete handle;
-
-      return -ENOMEM;
-    }
-
-    solid_fill_layers_ = reinterpret_cast<hwc_display_contents_1 *>(buf);
-    hwc_layer_1_t &layer = solid_fill_layers_->hwLayers[0];
-    layer.handle = handle;
-  }
-
-  solid_fill_layers_->flags = HWC_GEOMETRY_CHANGED;
-  solid_fill_layers_->numHwLayers = kNumSolidFillLayers;
-  solid_fill_layers_->retireFenceFd = -1;
-  solid_fill_layers_->outbuf = NULL;
-  solid_fill_layers_->outbufAcquireFenceFd = -1;
-
-  hwc_layer_1_t &layer = solid_fill_layers_->hwLayers[0];
-  hwc_rect_t solid_fill_rect = {
-      INT(solid_fill_params_.rect.x),
-      INT(solid_fill_params_.rect.y),
-      solid_fill_params_.rect.x + INT(solid_fill_params_.rect.width),
-      solid_fill_params_.rect.y + INT(solid_fill_params_.rect.height),
-  };
-
-  layer.compositionType = HWC_FRAMEBUFFER;
-  layer.blending = HWC_BLENDING_PREMULT;
-  layer.sourceCropf.left = solid_fill_params_.rect.x;
-  layer.sourceCropf.top = solid_fill_params_.rect.y;
-  layer.sourceCropf.right = UINT32(solid_fill_params_.rect.x) + solid_fill_params_.rect.width;
-  layer.sourceCropf.bottom = UINT32(solid_fill_params_.rect.y) + solid_fill_params_.rect.height;
-  layer.acquireFenceFd = -1;
-  layer.releaseFenceFd = -1;
-  layer.flags = 0;
-  layer.transform = 0;
-  layer.hints = 0;
-  layer.planeAlpha = 0xff;
-  layer.displayFrame = solid_fill_rect;
-  layer.visibleRegionScreen.numRects = 1;
-  layer.visibleRegionScreen.rects = &layer.displayFrame;
-  layer.surfaceDamage.numRects = 0;
-
-  return ret;
-}
-
-void HWCColorManager::DestroySolidFillLayers() {
-  if (solid_fill_layers_) {
-    hwc_layer_1_t &layer = solid_fill_layers_->hwLayers[0];
-    uint8_t *buf = reinterpret_cast<uint8_t *>(solid_fill_layers_);
-    private_handle_t const *hnd = reinterpret_cast<private_handle_t const *>(layer.handle);
-
-    if (hnd)
-        delete hnd;
-
-    if (buf)
-        delete[] buf;
-
-    solid_fill_layers_ = NULL;
-  }
-}
-
-int HWCColorManager::SetSolidFill(const void *params, bool enable, HWCDisplay *hwc_display) {
-  SCOPE_LOCK(locker_);
-  int ret = 0;
-
-  if (params) {
-    solid_fill_params_ = *reinterpret_cast<const PPColorFillParams *>(params);
-  } else {
-    solid_fill_params_ = PPColorFillParams();
-  }
-
-  if (enable) {
-    // will create solid fill layers for rendering if not present.
-    ret = CreateSolidFillLayers(hwc_display);
-  } else {
-    DestroySolidFillLayers();
-  }
-  solid_fill_enable_ = enable;
-
-  return ret;
-}
-
-int HWCColorManager::SetFrameCapture(void *params, bool enable, HWCDisplay *hwc_display) {
-  SCOPE_LOCK(locker_);
-  int ret = 0;
-
-  PPFrameCaptureData *frame_capture_data = reinterpret_cast<PPFrameCaptureData*>(params);
-
-  if (enable) {
-    std::memset(&buffer_info, 0x00, sizeof(buffer_info));
-    hwc_display->GetPanelResolution(&buffer_info.buffer_config.width,
-                                    &buffer_info.buffer_config.height);
-    if (frame_capture_data->input_params.out_pix_format == PP_PIXEL_FORMAT_RGB_888) {
-      buffer_info.buffer_config.format = kFormatRGB888;
-    } else if (frame_capture_data->input_params.out_pix_format == PP_PIXEL_FORMAT_RGB_2101010) {
-      buffer_info.buffer_config.format = kFormatRGBA1010102;
-    } else {
-      DLOGE("Pixel-format: %d NOT support.", frame_capture_data->input_params.out_pix_format);
-      return -EFAULT;
-    }
-
-    buffer_info.buffer_config.buffer_count = 1;
-    buffer_info.alloc_buffer_info.fd = -1;
-    buffer_info.alloc_buffer_info.stride = 0;
-    buffer_info.alloc_buffer_info.size = 0;
-
-    buffer_allocator_ = new HWCBufferAllocator();
-    if (buffer_allocator_ == NULL) {
-      DLOGE("Memory allocation for buffer_allocator_ FAILED");
-      return -ENOMEM;
-    }
-
-    ret = buffer_allocator_->AllocateBuffer(&buffer_info);
-    if (ret != 0) {
-      DLOGE("Buffer allocation failed. ret: %d", ret);
-      delete buffer_allocator_;
-      buffer_allocator_ = NULL;
-      return -ENOMEM;
-    } else {
-      void *buffer = mmap(NULL, buffer_info.alloc_buffer_info.size,
-                          PROT_READ|PROT_WRITE,
-                          MAP_SHARED, buffer_info.alloc_buffer_info.fd, 0);
-
-      if (buffer == MAP_FAILED) {
-        DLOGE("mmap failed. err = %d", errno);
-        frame_capture_data->buffer = NULL;
-        ret = buffer_allocator_->FreeBuffer(&buffer_info);
-        delete buffer_allocator_;
-        buffer_allocator_ = NULL;
-        return -EFAULT;
-      } else {
-        frame_capture_data->buffer = reinterpret_cast<uint8_t *>(buffer);
-        frame_capture_data->buffer_stride = buffer_info.alloc_buffer_info.aligned_width;
-        frame_capture_data->buffer_size = buffer_info.alloc_buffer_info.size;
-      }
-      ret = hwc_display->FrameCaptureAsync(buffer_info, 1);
-      if (ret < 0) {
-        DLOGE("FrameCaptureAsync failed. ret = %d", ret);
-      }
-    }
-  } else {
-    ret = hwc_display->GetFrameCaptureStatus();
-    if (!ret) {
-      if (frame_capture_data->buffer != NULL) {
-        if (munmap(frame_capture_data->buffer, buffer_info.alloc_buffer_info.size) != 0) {
-          DLOGE("munmap failed. err = %d", errno);
-        }
-      }
-      if (buffer_allocator_ != NULL) {
-        std::memset(frame_capture_data, 0x00, sizeof(PPFrameCaptureData));
-        ret = buffer_allocator_->FreeBuffer(&buffer_info);
-        if (ret != 0) {
-          DLOGE("FreeBuffer failed. ret = %d", ret);
-        }
-        delete buffer_allocator_;
-        buffer_allocator_ = NULL;
-      }
-    } else {
-      DLOGE("GetFrameCaptureStatus failed. ret = %d", ret);
-    }
-  }
-  return ret;
-}
-
-int HWCColorManager::SetHWDetailedEnhancerConfig(void *params, HWCDisplay *hwc_display) {
-  int err = -1;
-  DisplayDetailEnhancerData de_data;
-
-  PPDETuningCfgData *de_tuning_cfg_data = reinterpret_cast<PPDETuningCfgData*>(params);
-  if (de_tuning_cfg_data->cfg_pending == true) {
-    if (!de_tuning_cfg_data->cfg_en) {
-      de_data.override_flags = kOverrideDEEnable;
-      de_data.enable = 0;
-    } else {
-      de_data.override_flags = kOverrideDEEnable;
-      de_data.enable = 1;
-
-      if (de_tuning_cfg_data->params.flags & kDeTuningFlagSharpFactor) {
-        de_data.override_flags |= kOverrideDESharpen1;
-        de_data.sharp_factor = de_tuning_cfg_data->params.sharp_factor;
-      }
-
-      if (de_tuning_cfg_data->params.flags & kDeTuningFlagClip) {
-        de_data.override_flags |= kOverrideDEClip;
-        de_data.clip = de_tuning_cfg_data->params.clip;
-      }
-
-      if (de_tuning_cfg_data->params.flags & kDeTuningFlagThrQuiet) {
-        de_data.override_flags |= kOverrideDEThrQuiet;
-        de_data.thr_quiet = de_tuning_cfg_data->params.thr_quiet;
-      }
-
-      if (de_tuning_cfg_data->params.flags & kDeTuningFlagThrDieout) {
-        de_data.override_flags |= kOverrideDEThrDieout;
-        de_data.thr_dieout = de_tuning_cfg_data->params.thr_dieout;
-      }
-
-      if (de_tuning_cfg_data->params.flags & kDeTuningFlagThrLow) {
-        de_data.override_flags |= kOverrideDEThrLow;
-        de_data.thr_low = de_tuning_cfg_data->params.thr_low;
-      }
-
-      if (de_tuning_cfg_data->params.flags & kDeTuningFlagThrHigh) {
-        de_data.override_flags |= kOverrideDEThrHigh;
-        de_data.thr_high = de_tuning_cfg_data->params.thr_high;
-      }
-
-      if (de_tuning_cfg_data->params.flags & kDeTuningFlagContentQualLevel) {
-        switch (de_tuning_cfg_data->params.quality) {
-          case kDeContentQualLow:
-            de_data.quality_level = kContentQualityLow;
-            break;
-          case kDeContentQualMedium:
-            de_data.quality_level = kContentQualityMedium;
-            break;
-          case kDeContentQualHigh:
-            de_data.quality_level = kContentQualityHigh;
-            break;
-          case kDeContentQualUnknown:
-          default:
-            de_data.quality_level = kContentQualityUnknown;
-            break;
-        }
-      }
-    }
-    err = hwc_display->SetDetailEnhancerConfig(de_data);
-    if (err) {
-      DLOGW("SetDetailEnhancerConfig failed. err = %d", err);
-    }
-    de_tuning_cfg_data->cfg_pending = false;
-  }
-  return err;
-}
-
-void HWCColorManager::SetColorModeDetailEnhancer(HWCDisplay *hwc_display) {
-  SCOPE_LOCK(locker_);
-  int err = -1;
-  PPPendingParams pending_action;
-  PPDisplayAPIPayload req_payload;
-
-  pending_action.action = kGetDetailedEnhancerData;
-  pending_action.params = NULL;
-
-  if (hwc_display) {
-    err = hwc_display->ColorSVCRequestRoute(req_payload, NULL, &pending_action);
-    if (!err && pending_action.action == kConfigureDetailedEnhancer) {
-      err = SetHWDetailedEnhancerConfig(pending_action.params, hwc_display);
-    }
-  }
-  return;
-}
-
-int HWCColorManager::SetDetailedEnhancer(void *params, HWCDisplay *hwc_display) {
-  SCOPE_LOCK(locker_);
-  int err = -1;
-  err = SetHWDetailedEnhancerConfig(params, hwc_display);
-  return err;
-}
-
-const HWCQDCMModeManager::ActiveFeatureCMD HWCQDCMModeManager::kActiveFeatureCMD[] = {
-    HWCQDCMModeManager::ActiveFeatureCMD("cabl:on", "cabl:off", "cabl:status", "running"),
-    HWCQDCMModeManager::ActiveFeatureCMD("ad:on", "ad:off", "ad:query:status", "running"),
-    HWCQDCMModeManager::ActiveFeatureCMD("svi:on", "svi:off", "svi:status", "running"),
-};
-
-const char *const HWCQDCMModeManager::kSocketName = "pps";
-const char *const HWCQDCMModeManager::kTagName = "surfaceflinger";
-const char *const HWCQDCMModeManager::kPackageName = "colormanager";
-
-HWCQDCMModeManager *HWCQDCMModeManager::CreateQDCMModeMgr() {
-  HWCQDCMModeManager *mode_mgr = new HWCQDCMModeManager();
-
-  if (!mode_mgr) {
-    DLOGW("No memory to create HWCQDCMModeManager.");
-    return NULL;
-  } else {
-    mode_mgr->socket_fd_ =
-        ::socket_local_client(kSocketName, ANDROID_SOCKET_NAMESPACE_RESERVED, SOCK_STREAM);
-    if (mode_mgr->socket_fd_ < 0) {
-      // it should not be disastrous and we still can grab wakelock in QDCM mode.
-      DLOGW("Unable to connect to dpps socket!");
-    }
-
-    // retrieve system GPU idle timeout value for later to recover.
-    mode_mgr->entry_timeout_ = UINT32(HWCDebugHandler::GetIdleTimeoutMs());
-
-    // acquire the binder handle to Android system PowerManager for later use.
-    android::sp<android::IBinder> binder =
-        android::defaultServiceManager()->checkService(android::String16("power"));
-    if (binder == NULL) {
-      DLOGW("Application can't connect to  power manager service");
-      delete mode_mgr;
-      mode_mgr = NULL;
-    } else {
-      mode_mgr->power_mgr_ = android::interface_cast<android::IPowerManager>(binder);
-    }
-  }
-
-  return mode_mgr;
-}
-
-HWCQDCMModeManager::~HWCQDCMModeManager() {
-  if (socket_fd_ >= 0)
-    ::close(socket_fd_);
-}
-
-int HWCQDCMModeManager::AcquireAndroidWakeLock(bool enable) {
-  int ret = 0;
-
-  if (enable) {
-    if (wakelock_token_ == NULL) {
-      android::sp<android::IBinder> binder = new android::BBinder();
-      android::status_t status = power_mgr_->acquireWakeLock(
-          (kFullWakeLock | kAcquireCauseWakeup | kONAfterRelease), binder,
-          android::String16(kTagName), android::String16(kPackageName));
-      if (status == android::NO_ERROR) {
-        wakelock_token_ = binder;
-      }
-    }
-  } else {
-    if (wakelock_token_ != NULL && power_mgr_ != NULL) {
-      power_mgr_->releaseWakeLock(wakelock_token_, 0);
-      wakelock_token_.clear();
-      wakelock_token_ = NULL;
-    }
-  }
-
-  return ret;
-}
-
-int HWCQDCMModeManager::EnableActiveFeatures(bool enable,
-                                             const HWCQDCMModeManager::ActiveFeatureCMD &cmds,
-                                             bool *was_running) {
-  int ret = 0;
-  ssize_t size = 0;
-  char response[kSocketCMDMaxLength] = {
-      0,
-  };
-
-  if (socket_fd_ < 0) {
-    DLOGW("No socket connection available!");
-    return -EFAULT;
-  }
-
-  if (!enable) {  // if client requesting to disable it.
-    // query CABL status, if off, no action. keep the status.
-    size = ::write(socket_fd_, cmds.cmd_query_status, strlen(cmds.cmd_query_status));
-    if (size < 0) {
-      DLOGW("Unable to send data over socket %s", ::strerror(errno));
-      ret = -EFAULT;
-    } else {
-      size = ::read(socket_fd_, response, kSocketCMDMaxLength);
-      if (size < 0) {
-        DLOGW("Unable to read data over socket %s", ::strerror(errno));
-        ret = -EFAULT;
-      } else if (!strncmp(response, cmds.running, strlen(cmds.running))) {
-        *was_running = true;
-      }
-    }
-
-    if (*was_running) {  // if was running, it's requested to disable it.
-      size = ::write(socket_fd_, cmds.cmd_off, strlen(cmds.cmd_off));
-      if (size < 0) {
-        DLOGW("Unable to send data over socket %s", ::strerror(errno));
-        ret = -EFAULT;
-      }
-    }
-  } else {  // if was running, need enable it back.
-    if (*was_running) {
-      size = ::write(socket_fd_, cmds.cmd_on, strlen(cmds.cmd_on));
-      if (size < 0) {
-        DLOGW("Unable to send data over socket %s", ::strerror(errno));
-        ret = -EFAULT;
-      }
-    }
-  }
-
-  return ret;
-}
-
-int HWCQDCMModeManager::EnableQDCMMode(bool enable, HWCDisplay *hwc_display) {
-  int ret = 0;
-
-  ret = EnableActiveFeatures((enable ? false : true), kActiveFeatureCMD[kCABLFeature],
-                             &cabl_was_running_);
-  ret = AcquireAndroidWakeLock(enable);
-
-  // if enter QDCM mode, disable GPU fallback idle timeout.
-  if (hwc_display) {
-    uint32_t timeout = enable ? 0 : entry_timeout_;
-    hwc_display->SetIdleTimeoutMs(timeout);
-  }
-
-  return ret;
-}
-
-}  // namespace sdm
diff --git a/sdm/libs/hwc/hwc_color_manager.h b/sdm/libs/hwc/hwc_color_manager.h
deleted file mode 100644
index 20d2b39..0000000
--- a/sdm/libs/hwc/hwc_color_manager.h
+++ /dev/null
@@ -1,149 +0,0 @@
-/* Copyright (c) 2015-2017, The Linux Foundataion. 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_COLOR_MANAGER_H__
-#define __HWC_COLOR_MANAGER_H__
-
-#include <stdlib.h>
-#include <binder/Parcel.h>
-#include <powermanager/IPowerManager.h>
-#include <binder/BinderService.h>
-#include <core/sdm_types.h>
-#include <utils/locker.h>
-#include <utils/sys.h>
-
-namespace sdm {
-
-// This macro defines name for display APIs interface wrapper library.
-// This macro shall be used to load library using dlopen().
-#define DISPLAY_API_INTERFACE_LIBRARY_NAME "libsdm-disp-vndapis.so"
-
-// This macro defines variable name of display color APIs function tables
-// This macro shall be used to specify name of the variable in dlsym().
-#define DISPLAY_API_FUNC_TABLES "display_color_apis_ftables"
-#define QDCM_DIAG_CLIENT_LIBRARY_NAME "libsdm-diag.so"
-#define INIT_QDCM_DIAG_CLIENT_NAME "QDCMDiagInit"
-#define DEINIT_QDCM_DIAG_CLIENT_NAME "QDCMDiagDeInit"
-
-typedef int (*QDCMDiagInit)(void *ftables);
-
-typedef int (*QDCMDiagDeInit)(void);
-
-// Class to encapsulte all details of managing QDCM operating mode.
-class HWCQDCMModeManager {
- public:
-  static const uint32_t kSocketCMDMaxLength = 4096;
-  static const uint32_t kFullWakeLock = 0x0000001a;
-  static const uint32_t kAcquireCauseWakeup = 0x10000000;
-  static const uint32_t kONAfterRelease = 0x20000000;
-  enum ActiveFeatureID {
-    kCABLFeature,
-    kADFeature,
-    kSVIFeature,
-    kMaxNumActiveFeature,
-  };
-
-  struct ActiveFeatureCMD {
-    const char *cmd_on = NULL;
-    const char *cmd_off = NULL;
-    const char *cmd_query_status = NULL;
-    const char *running = NULL;
-    ActiveFeatureCMD(const char *arg1, const char *arg2, const char *arg3, const char *arg4)
-        : cmd_on(arg1), cmd_off(arg2), cmd_query_status(arg3), running(arg4) {}
-  };
-
-  static const ActiveFeatureCMD kActiveFeatureCMD[kMaxNumActiveFeature];
-
- public:
-  static HWCQDCMModeManager *CreateQDCMModeMgr();
-  ~HWCQDCMModeManager();
-  int EnableQDCMMode(bool enable, HWCDisplay *hwc_display);
-
- protected:
-  bool SendSocketCmd();
-  int AcquireAndroidWakeLock(bool enable);
-  int EnableActiveFeatures(bool enable);
-  int EnableActiveFeatures(bool enable, const ActiveFeatureCMD &cmds, bool *was_running);
-
- private:
-  bool cabl_was_running_ = false;
-  int socket_fd_ = -1;
-  android::sp<android::IBinder> wakelock_token_ = NULL;
-  android::sp<android::IPowerManager> power_mgr_ = NULL;
-  uint32_t entry_timeout_ = 0;
-  static const char *const kSocketName;
-  static const char *const kTagName;
-  static const char *const kPackageName;
-};
-
-// Class to encapsulte all HWC/OS specific behaviours for ColorManager.
-class HWCColorManager {
- public:
-  static const int kNumSolidFillLayers = 2;
-  static HWCColorManager *CreateColorManager();
-  static int CreatePayloadFromParcel(const android::Parcel &in, uint32_t *disp_id,
-                                     PPDisplayAPIPayload *sink);
-  static void MarshallStructIntoParcel(const PPDisplayAPIPayload &data,
-                                       android::Parcel *out_parcel);
-
-  ~HWCColorManager();
-  void DestroyColorManager();
-  int EnableQDCMMode(bool enable, HWCDisplay *hwc_display);
-  int SetSolidFill(const void *params, bool enable, HWCDisplay *hwc_display);
-  bool SolidFillLayersPrepare(hwc_display_contents_1_t **displays, HWCDisplay *hwc_display);
-  bool SolidFillLayersSet(hwc_display_contents_1_t **displays, HWCDisplay *hwc_display);
-  int SetFrameCapture(void *params, bool enable, HWCDisplay *hwc_display);
-  int SetDetailedEnhancer(void *params, HWCDisplay *hwc_display);
-  void SetColorModeDetailEnhancer(HWCDisplay *hwc_display);
-  int SetHWDetailedEnhancerConfig(void *params, HWCDisplay *hwc_display);
-
- protected:
-  int CreateSolidFillLayers(HWCDisplay *hwc_display);
-  void DestroySolidFillLayers();
-  static uint32_t Get8BitsARGBColorValue(const PPColorFillParams &params);
-
- private:
-  DynLib color_apis_lib_;
-  DynLib diag_client_lib_;
-  void *color_apis_ = NULL;
-  QDCMDiagInit qdcm_diag_init_ = NULL;
-  QDCMDiagDeInit qdcm_diag_deinit_ = NULL;
-  HWCQDCMModeManager *qdcm_mode_mgr_ = NULL;
-
-  bool solid_fill_enable_ = false;
-  PPColorFillParams solid_fill_params_;
-  hwc_display_contents_1_t *solid_fill_layers_ = NULL;
-  HWCBufferAllocator *buffer_allocator_ = NULL;
-  BufferInfo buffer_info;
-  Locker locker_;
-};
-
-}  // namespace sdm
-
-#endif  // __HWC_COLOR_MANAGER_H__
diff --git a/sdm/libs/hwc/hwc_display.cpp b/sdm/libs/hwc/hwc_display.cpp
deleted file mode 100644
index 2c5c885..0000000
--- a/sdm/libs/hwc/hwc_display.cpp
+++ /dev/null
@@ -1,1536 +0,0 @@
-/*
-* Copyright (c) 2014 - 2017, 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.
-*/
-
-#include <math.h>
-#include <errno.h>
-#include <gralloc_priv.h>
-#include <gr.h>
-#include <utils/constants.h>
-#include <utils/formats.h>
-#include <utils/rect.h>
-#include <utils/debug.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <sync/sync.h>
-#include <cutils/properties.h>
-#include <qd_utils.h>
-#include <map>
-#include <utility>
-#include <vector>
-#include <string>
-
-#include "blit_engine_c2d.h"
-#include "hwc_debugger.h"
-#include "hwc_display.h"
-#include "hwc_tonemapper.h"
-
-#ifdef QTI_BSP
-#include <hardware/display_defs.h>
-#endif
-
-#define __CLASS__ "HWCDisplay"
-
-namespace sdm {
-
-void HWCColorMode::Init() {
-  int ret = PopulateColorModes();
-  if (ret != 0) {
-    DLOGW("Failed!!");
-  }
-  return;
-}
-
-int HWCColorMode::SetColorMode(const std::string &color_mode) {
-  if (color_modes_.empty()) {
-    DLOGW("No Color Modes supported");
-    return -1;
-  }
-
-  std::vector<std::string>::iterator it = std::find(color_modes_.begin(), color_modes_.end(),
-                                                    color_mode);
-  if (it == color_modes_.end()) {
-    DLOGE("Invalid colorMode request: %s", color_mode.c_str());
-    return -1;
-  }
-
-  DisplayError error = display_intf_->SetColorMode(color_mode);
-  if (error != kErrorNone) {
-    DLOGE("Failed to set color_mode = %s", color_mode.c_str());
-    return -1;
-  }
-  current_color_mode_ = color_mode;
-
-  return 0;
-}
-
-const std::vector<std::string> &HWCColorMode::GetColorModes() {
-  return color_modes_;
-}
-
-int HWCColorMode::SetColorTransform(uint32_t matrix_count, const float *matrix) {
-  if (matrix_count > kColorTransformMatrixCount) {
-    DLOGE("Transform matrix count = %d, exceeds max = %d", matrix_count,
-          kColorTransformMatrixCount);
-    return -1;
-  }
-
-  double color_matrix[kColorTransformMatrixCount] = {0};
-  CopyColorTransformMatrix(matrix, color_matrix);
-  DisplayError error = display_intf_->SetColorTransform(matrix_count, color_matrix);
-  if (error != kErrorNone) {
-    DLOGE("Failed!");
-    return -1;
-  }
-
-  return 0;
-}
-
-int HWCColorMode::PopulateColorModes() {
-  uint32_t color_mode_count = 0;
-  DisplayError error = display_intf_->GetColorModeCount(&color_mode_count);
-  if (error != kErrorNone || (color_mode_count == 0)) {
-    return -1;
-  }
-
-  DLOGI("Color Mode count = %d", color_mode_count);
-
-  color_modes_.resize(color_mode_count);
-
-  // SDM returns modes which is string
-  error = display_intf_->GetColorModes(&color_mode_count, &color_modes_);
-  if (error != kErrorNone) {
-    DLOGE("GetColorModes Failed for count = %d", color_mode_count);
-    return -1;
-  }
-
-  return 0;
-}
-
-HWCDisplay::HWCDisplay(CoreInterface *core_intf, hwc_procs_t const **hwc_procs, DisplayType type,
-                       int id, bool needs_blit, qService::QService *qservice,
-                       DisplayClass display_class)
-  : core_intf_(core_intf), hwc_procs_(hwc_procs), type_(type), id_(id), needs_blit_(needs_blit),
-    qservice_(qservice), display_class_(display_class) {
-}
-
-int HWCDisplay::Init() {
-  DisplayError error = core_intf_->CreateDisplay(type_, this, &display_intf_);
-  if (error != kErrorNone) {
-    DLOGE("Display create failed. Error = %d display_type %d event_handler %p disp_intf %p",
-      error, type_, this, &display_intf_);
-    return -EINVAL;
-  }
-
-  HWCDebugHandler::Get()->GetProperty("sys.hwc_disable_hdr", &disable_hdr_handling_);
-  if (disable_hdr_handling_) {
-    DLOGI("HDR Handling disabled");
-  }
-
-  int property_swap_interval = 1;
-  HWCDebugHandler::Get()->GetProperty("debug.egl.swapinterval", &property_swap_interval);
-  if (property_swap_interval == 0) {
-    swap_interval_zero_ = true;
-  }
-
-  int blit_enabled = 0;
-  HWCDebugHandler::Get()->GetProperty("persist.hwc.blit.comp", &blit_enabled);
-  if (needs_blit_ && blit_enabled) {
-    blit_engine_ = new BlitEngineC2d();
-    if (!blit_engine_) {
-      DLOGI("Create Blit Engine C2D failed");
-    } else {
-      if (blit_engine_->Init() < 0) {
-        DLOGI("Blit Engine Init failed, Blit Composition will not be used!!");
-        delete blit_engine_;
-        blit_engine_ = NULL;
-      }
-    }
-  }
-
-  tone_mapper_ = new HWCToneMapper();
-
-  display_intf_->GetRefreshRateRange(&min_refresh_rate_, &max_refresh_rate_);
-  current_refresh_rate_ = max_refresh_rate_;
-
-  s3d_format_hwc_to_sdm_.insert(std::pair<int, LayerBufferS3DFormat>(HAL_NO_3D, kS3dFormatNone));
-  s3d_format_hwc_to_sdm_.insert(std::pair<int, LayerBufferS3DFormat>(HAL_3D_SIDE_BY_SIDE_L_R,
-                                kS3dFormatLeftRight));
-  s3d_format_hwc_to_sdm_.insert(std::pair<int, LayerBufferS3DFormat>(HAL_3D_SIDE_BY_SIDE_R_L,
-                                kS3dFormatRightLeft));
-  s3d_format_hwc_to_sdm_.insert(std::pair<int, LayerBufferS3DFormat>(HAL_3D_TOP_BOTTOM,
-                                kS3dFormatTopBottom));
-
-  disable_animation_ = Debug::IsExtAnimDisabled();
-
-  return 0;
-}
-
-int HWCDisplay::Deinit() {
-  DisplayError error = core_intf_->DestroyDisplay(display_intf_);
-  if (error != kErrorNone) {
-    DLOGE("Display destroy failed. Error = %d", error);
-    return -EINVAL;
-  }
-
-  if (blit_engine_) {
-    blit_engine_->DeInit();
-    delete blit_engine_;
-    blit_engine_ = NULL;
-  }
-
-  delete tone_mapper_;
-  tone_mapper_ = NULL;
-
-  return 0;
-}
-
-int HWCDisplay::EventControl(int event, int enable) {
-  DisplayError error = kErrorNone;
-
-  if (shutdown_pending_) {
-    return 0;
-  }
-
-  switch (event) {
-  case HWC_EVENT_VSYNC:
-    error = display_intf_->SetVSyncState(enable);
-    break;
-  default:
-    DLOGW("Unsupported event = %d", event);
-  }
-
-  if (error != kErrorNone) {
-    if (error == kErrorShutDown) {
-      shutdown_pending_ = true;
-      return 0;
-    }
-    DLOGE("Failed. event = %d, enable = %d, error = %d", event, enable, error);
-    return -EINVAL;
-  }
-
-  return 0;
-}
-
-int HWCDisplay::SetPowerMode(int mode) {
-  DLOGI("display = %d, mode = %d", id_, mode);
-  DisplayState state = kStateOff;
-  bool flush_on_error = flush_on_error_;
-
-  if (shutdown_pending_) {
-    return 0;
-  }
-
-  switch (mode) {
-  case HWC_POWER_MODE_OFF:
-    // During power off, all of the buffers are released.
-    // Do not flush until a buffer is successfully submitted again.
-    flush_on_error = false;
-    state = kStateOff;
-    tone_mapper_->Terminate();
-    break;
-
-  case HWC_POWER_MODE_NORMAL:
-    state = kStateOn;
-    last_power_mode_ = HWC_POWER_MODE_NORMAL;
-    break;
-
-  case HWC_POWER_MODE_DOZE:
-    state = kStateDoze;
-    last_power_mode_ = HWC_POWER_MODE_DOZE;
-    break;
-
-  case HWC_POWER_MODE_DOZE_SUSPEND:
-    state = kStateDozeSuspend;
-    last_power_mode_ = HWC_POWER_MODE_DOZE_SUSPEND;
-    break;
-
-  default:
-    return -EINVAL;
-  }
-
-  DisplayError error = display_intf_->SetDisplayState(state);
-  if (error == kErrorNone) {
-    flush_on_error_ = flush_on_error;
-  } else {
-    if (error == kErrorShutDown) {
-      shutdown_pending_ = true;
-      return 0;
-    }
-    DLOGE("Set state failed. Error = %d", error);
-    return -EINVAL;
-  }
-
-  return 0;
-}
-
-int HWCDisplay::GetDisplayConfigs(uint32_t *configs, size_t *num_configs) {
-  if (*num_configs > 0) {
-    configs[0] = 0;
-    *num_configs = 1;
-  }
-
-  return 0;
-}
-
-int HWCDisplay::GetDisplayAttributes(uint32_t config, const uint32_t *display_attributes,
-                                     int32_t *values) {
-  DisplayConfigVariableInfo variable_config;
-  DisplayError error = display_intf_->GetFrameBufferConfig(&variable_config);
-  if (error != kErrorNone) {
-    DLOGV("Get variable config failed. Error = %d", error);
-    return -EINVAL;
-  }
-
-  for (int i = 0; display_attributes[i] != HWC_DISPLAY_NO_ATTRIBUTE; i++) {
-    switch (display_attributes[i]) {
-    case HWC_DISPLAY_VSYNC_PERIOD:
-      values[i] = INT32(variable_config.vsync_period_ns);
-      break;
-    case HWC_DISPLAY_WIDTH:
-      values[i] = INT32(variable_config.x_pixels);
-      break;
-    case HWC_DISPLAY_HEIGHT:
-      values[i] = INT32(variable_config.y_pixels);
-      break;
-    case HWC_DISPLAY_DPI_X:
-      values[i] = INT32(variable_config.x_dpi * 1000.0f);
-      break;
-    case HWC_DISPLAY_DPI_Y:
-      values[i] = INT32(variable_config.y_dpi * 1000.0f);
-      break;
-    default:
-      DLOGW("Spurious attribute type = %d", display_attributes[i]);
-      return -EINVAL;
-    }
-  }
-
-  return 0;
-}
-
-int HWCDisplay::GetActiveConfig() {
-  return 0;
-}
-
-int HWCDisplay::SetActiveConfig(int index) {
-  return -1;
-}
-
-DisplayError HWCDisplay::SetMixerResolution(uint32_t width, uint32_t height) {
-  return kErrorNotSupported;
-}
-
-void HWCDisplay::SetFrameDumpConfig(uint32_t count, uint32_t bit_mask_layer_type) {
-  dump_frame_count_ = count;
-  dump_frame_index_ = 0;
-  dump_input_layers_ = ((bit_mask_layer_type & (1 << INPUT_LAYER_DUMP)) != 0);
-
-  if (blit_engine_) {
-    blit_engine_->SetFrameDumpConfig(count);
-  }
-
-  if (tone_mapper_) {
-    tone_mapper_->SetFrameDumpConfig(count);
-  }
-
-  DLOGI("num_frame_dump %d, input_layer_dump_enable %d", dump_frame_count_, dump_input_layers_);
-}
-
-uint32_t HWCDisplay::GetLastPowerMode() {
-  return last_power_mode_;
-}
-
-DisplayError HWCDisplay::VSync(const DisplayEventVSync &vsync) {
-  const hwc_procs_t *hwc_procs = *hwc_procs_;
-
-  if (!hwc_procs) {
-    return kErrorParameters;
-  }
-
-  hwc_procs->vsync(hwc_procs, id_, vsync.timestamp);
-
-  return kErrorNone;
-}
-
-DisplayError HWCDisplay::Refresh() {
-  return kErrorNotSupported;
-}
-
-DisplayError HWCDisplay::CECMessage(char *message) {
-  if (qservice_) {
-    qservice_->onCECMessageReceived(message, 0);
-  } else {
-    DLOGW("Qservice instance not available.");
-  }
-
-  return kErrorNone;
-}
-
-int HWCDisplay::AllocateLayerStack(hwc_display_contents_1_t *content_list) {
-  if (!content_list || !content_list->numHwLayers) {
-    DLOGW("Invalid content list");
-    return -EINVAL;
-  }
-
-  size_t num_hw_layers = content_list->numHwLayers;
-  uint32_t blit_target_count = 0;
-
-  if (blit_engine_) {
-    blit_target_count = kMaxBlitTargetLayers;
-  }
-
-  FreeLayerStack();
-
-  for (size_t i = 0; i < num_hw_layers + blit_target_count; i++) {
-    Layer *layer = new Layer();
-    layer_stack_.layers.push_back(layer);
-  }
-
-  return 0;
-}
-
-void HWCDisplay::FreeLayerStack() {
-  for (Layer *layer : layer_stack_.layers) {
-    delete layer;
-  }
-  layer_stack_ = {};
-}
-
-int HWCDisplay::PrepareLayerParams(hwc_layer_1_t *hwc_layer, Layer* layer) {
-  const private_handle_t *pvt_handle = static_cast<const private_handle_t *>(hwc_layer->handle);
-
-  LayerBuffer &layer_buffer = layer->input_buffer;
-
-  if (pvt_handle) {
-    layer_buffer.planes[0].fd = pvt_handle->fd;
-    layer_buffer.format = GetSDMFormat(pvt_handle->format, pvt_handle->flags);
-    int aligned_width, aligned_height;
-    int unaligned_width, unaligned_height;
-
-    AdrenoMemInfo::getInstance().getAlignedWidthAndHeight(pvt_handle, aligned_width,
-                                                          aligned_height);
-    AdrenoMemInfo::getInstance().getUnalignedWidthAndHeight(pvt_handle, unaligned_width,
-                                                            unaligned_height);
-
-    layer_buffer.width = UINT32(aligned_width);
-    layer_buffer.height = UINT32(aligned_height);
-    layer_buffer.unaligned_width = UINT32(unaligned_width);
-    layer_buffer.unaligned_height = UINT32(unaligned_height);
-
-    if (SetMetaData(pvt_handle, layer) != kErrorNone) {
-      return -EINVAL;
-    }
-
-    if (pvt_handle->bufferType == BUFFER_TYPE_VIDEO) {
-      layer_stack_.flags.video_present = true;
-      layer_buffer.flags.video = true;
-    }
-    // TZ Protected Buffer - L1
-    if (pvt_handle->flags & private_handle_t::PRIV_FLAGS_SECURE_BUFFER) {
-      layer_stack_.flags.secure_present = true;
-      layer_buffer.flags.secure = true;
-      if (pvt_handle->flags & private_handle_t::PRIV_FLAGS_CAMERA_WRITE) {
-        layer_buffer.flags.secure_camera = true;
-      }
-    }
-    // Gralloc Usage Protected Buffer - L3 - which needs to be treated as Secure & avoid fallback
-    if (pvt_handle->flags & private_handle_t::PRIV_FLAGS_PROTECTED_BUFFER) {
-      layer_stack_.flags.secure_present = true;
-    }
-    if (pvt_handle->flags & private_handle_t::PRIV_FLAGS_SECURE_DISPLAY) {
-      layer_buffer.flags.secure_display = true;
-    }
-
-    // check if this is special solid_fill layer without input_buffer.
-    if (solid_fill_enable_ && pvt_handle->fd == -1) {
-      layer->flags.solid_fill = true;
-      layer->solid_fill_color = solid_fill_color_;
-    }
-  } else {
-    // for FBT layer
-    if (hwc_layer->compositionType == HWC_FRAMEBUFFER_TARGET) {
-      uint32_t x_pixels;
-      uint32_t y_pixels;
-      int aligned_width;
-      int aligned_height;
-      int usage = GRALLOC_USAGE_HW_FB;
-      int format = HAL_PIXEL_FORMAT_RGBA_8888;
-      int ubwc_enabled = 0;
-      int flags = 0;
-      HWCDebugHandler::Get()->GetProperty("debug.gralloc.enable_fb_ubwc", &ubwc_enabled);
-      bool linear = layer_stack_.output_buffer && !IsUBWCFormat(layer_stack_.output_buffer->format);
-      if ((ubwc_enabled == 1) && !linear) {
-        usage |= GRALLOC_USAGE_PRIVATE_ALLOC_UBWC;
-        flags |= private_handle_t::PRIV_FLAGS_UBWC_ALIGNED;
-      }
-
-      GetFrameBufferResolution(&x_pixels, &y_pixels);
-
-      AdrenoMemInfo::getInstance().getAlignedWidthAndHeight(INT(x_pixels), INT(y_pixels), format,
-                                                            usage, aligned_width, aligned_height);
-      layer_buffer.width = UINT32(aligned_width);
-      layer_buffer.height = UINT32(aligned_height);
-      layer_buffer.unaligned_width = x_pixels;
-      layer_buffer.unaligned_height = y_pixels;
-      layer_buffer.format = GetSDMFormat(format, flags);
-    }
-  }
-
-  return 0;
-}
-
-void HWCDisplay::CommitLayerParams(hwc_layer_1_t *hwc_layer, Layer *layer) {
-  const private_handle_t *pvt_handle = static_cast<const private_handle_t *>(hwc_layer->handle);
-  LayerBuffer &layer_buffer = layer->input_buffer;
-
-  if (pvt_handle) {
-    layer_buffer.planes[0].fd = pvt_handle->fd;
-    layer_buffer.planes[0].offset = pvt_handle->offset;
-    layer_buffer.planes[0].stride = UINT32(pvt_handle->width);
-    layer_buffer.size = pvt_handle->size;
-  }
-
-  // if swapinterval property is set to 0 then close and reset the acquireFd
-  if (swap_interval_zero_ && hwc_layer->acquireFenceFd >= 0) {
-    close(hwc_layer->acquireFenceFd);
-    hwc_layer->acquireFenceFd = -1;
-  }
-  layer_buffer.acquire_fence_fd = hwc_layer->acquireFenceFd;
-}
-
-int HWCDisplay::PrePrepareLayerStack(hwc_display_contents_1_t *content_list) {
-  if (shutdown_pending_) {
-    return 0;
-  }
-
-  size_t num_hw_layers = content_list->numHwLayers;
-
-  use_blit_comp_ = false;
-  metadata_refresh_rate_ = 0;
-  display_rect_ = LayerRect();
-
-  // Configure each layer
-  for (size_t i = 0; i < num_hw_layers; i++) {
-    hwc_layer_1_t &hwc_layer = content_list->hwLayers[i];
-
-    const private_handle_t *pvt_handle = static_cast<const private_handle_t *>(hwc_layer.handle);
-    Layer *layer = layer_stack_.layers.at(i);
-    int ret = PrepareLayerParams(&content_list->hwLayers[i], layer);
-
-    if (ret != kErrorNone) {
-      return ret;
-    }
-
-    layer->flags.skip = ((hwc_layer.flags & HWC_SKIP_LAYER) > 0);
-    layer->flags.solid_fill = (hwc_layer.flags & kDimLayer) || solid_fill_enable_;
-    if (layer->flags.skip || layer->flags.solid_fill) {
-      layer->dirty_regions.clear();
-    }
-
-    hwc_rect_t scaled_display_frame = hwc_layer.displayFrame;
-    ApplyScanAdjustment(&scaled_display_frame);
-
-    SetRect(scaled_display_frame, &layer->dst_rect);
-    if (pvt_handle) {
-        bool NonIntegralSourceCrop =  IsNonIntegralSourceCrop(hwc_layer.sourceCropf);
-        bool secure = (pvt_handle->flags & private_handle_t::PRIV_FLAGS_SECURE_BUFFER) ||
-                (pvt_handle->flags & private_handle_t::PRIV_FLAGS_PROTECTED_BUFFER) ||
-                (pvt_handle->flags & private_handle_t::PRIV_FLAGS_SECURE_DISPLAY);
-        if (NonIntegralSourceCrop && (!secure && pvt_handle->bufferType != BUFFER_TYPE_VIDEO)) {
-            layer->flags.skip = true;
-        }
-    }
-    SetRect(hwc_layer.sourceCropf, &layer->src_rect);
-
-    uint32_t num_visible_rects = UINT32(hwc_layer.visibleRegionScreen.numRects);
-    uint32_t num_dirty_rects = UINT32(hwc_layer.surfaceDamage.numRects);
-
-    for (uint32_t j = 0; j < num_visible_rects; j++) {
-      LayerRect visible_rect = {};
-      SetRect(hwc_layer.visibleRegionScreen.rects[j], &visible_rect);
-      layer->visible_regions.push_back(visible_rect);
-    }
-
-    for (uint32_t j = 0; j < num_dirty_rects; j++) {
-      LayerRect dirty_rect = {};
-      SetRect(hwc_layer.surfaceDamage.rects[j], &dirty_rect);
-      layer->dirty_regions.push_back(dirty_rect);
-    }
-
-    if (blit_engine_) {
-      for (uint32_t j = 0; j < kMaxBlitTargetLayers; j++) {
-        LayerRect blit_rect = {};
-        layer->blit_regions.push_back(blit_rect);
-      }
-    }
-
-    SetComposition(hwc_layer.compositionType, &layer->composition);
-    if (hwc_layer.compositionType != HWC_FRAMEBUFFER_TARGET) {
-      display_rect_ = Union(display_rect_, layer->dst_rect);
-    }
-
-    // For dim layers, SurfaceFlinger
-    //    - converts planeAlpha to per pixel alpha,
-    //    - sets appropriate RGB color,
-    //    - sets planeAlpha to 0xff,
-    //    - blending to Premultiplied.
-    // This can be achieved at hardware by
-    //    - solid fill ARGB to appropriate value,
-    //    - incoming planeAlpha,
-    //    - blending to Coverage.
-    if (hwc_layer.flags & kDimLayer) {
-      layer->input_buffer.format = kFormatARGB8888;
-      layer->solid_fill_color = 0xff000000;
-#ifdef QTI_BSP
-      // Get ARGB color from HWC Dim Layer color
-      uint32_t a = UINT32(hwc_layer.color.a) << 24;
-      uint32_t r = UINT32(hwc_layer.color.r) << 16;
-      uint32_t g = UINT32(hwc_layer.color.g) << 8;
-      uint32_t b = UINT32(hwc_layer.color.b);
-      layer->solid_fill_color = a | r | g | b;
-#endif
-      SetBlending(HWC_BLENDING_COVERAGE, &layer->blending);
-    } else {
-      SetBlending(hwc_layer.blending, &layer->blending);
-      LayerTransform &layer_transform = layer->transform;
-      uint32_t &hwc_transform = hwc_layer.transform;
-      layer_transform.flip_horizontal = ((hwc_transform & HWC_TRANSFORM_FLIP_H) > 0);
-      layer_transform.flip_vertical = ((hwc_transform & HWC_TRANSFORM_FLIP_V) > 0);
-      layer_transform.rotation = ((hwc_transform & HWC_TRANSFORM_ROT_90) ? 90.0f : 0.0f);
-    }
-
-    // TODO(user): Remove below block.
-    // For solid fill, only dest rect need to be specified.
-    if (layer->flags.solid_fill) {
-      LayerBuffer &input_buffer = layer->input_buffer;
-      input_buffer.width = UINT32(layer->dst_rect.right - layer->dst_rect.left);
-      input_buffer.height = UINT32(layer->dst_rect.bottom - layer->dst_rect.top);
-      input_buffer.unaligned_width = input_buffer.width;
-      input_buffer.unaligned_height = input_buffer.height;
-      layer->src_rect.left = 0;
-      layer->src_rect.top = 0;
-      layer->src_rect.right = input_buffer.width;
-      layer->src_rect.bottom = input_buffer.height;
-    }
-
-    layer->plane_alpha = hwc_layer.planeAlpha;
-    layer->flags.cursor = ((hwc_layer.flags & HWC_IS_CURSOR_LAYER) > 0);
-    layer->flags.updating = true;
-
-    if (num_hw_layers <= kMaxLayerCount) {
-      layer->flags.updating = IsLayerUpdating(content_list, layer);
-    }
-#ifdef QTI_BSP
-    if (hwc_layer.flags & HWC_SCREENSHOT_ANIMATOR_LAYER) {
-      layer_stack_.flags.animating = true;
-    }
-#endif
-    if (layer->flags.skip) {
-      layer_stack_.flags.skip_present = true;
-    }
-
-    if (layer->flags.cursor) {
-      layer_stack_.flags.cursor_present = true;
-    }
-
-    PrepareDynamicRefreshRate(layer);
-
-    layer->input_buffer.buffer_id = reinterpret_cast<uint64_t>(hwc_layer.handle);
-  }
-
-  // Prepare the Blit Target
-  if (blit_engine_) {
-  // TODO(user): Fix this to enable BLIT
-#if 0
-    int ret = blit_engine_->Prepare(&layer_stack_);
-    if (ret) {
-      // Blit engine cannot handle this layer stack, hence set the layer stack
-      // count to num_hw_layers
-      layer_stack_.layer_count -= kMaxBlitTargetLayers;
-    } else {
-      use_blit_comp_ = true;
-    }
-#endif
-  }
-
-  // Configure layer stack
-  layer_stack_.flags.geometry_changed = ((content_list->flags & HWC_GEOMETRY_CHANGED) > 0);
-
-  return 0;
-}
-
-void HWCDisplay::SetLayerS3DMode(const LayerBufferS3DFormat &source, uint32_t *target) {
-#ifdef QTI_BSP
-    switch (source) {
-    case kS3dFormatNone: *target = HWC_S3DMODE_NONE; break;
-    case kS3dFormatLeftRight: *target = HWC_S3DMODE_LR; break;
-    case kS3dFormatRightLeft: *target = HWC_S3DMODE_RL; break;
-    case kS3dFormatTopBottom: *target = HWC_S3DMODE_TB; break;
-    case kS3dFormatFramePacking: *target = HWC_S3DMODE_FP; break;
-    default: *target = HWC_S3DMODE_MAX; break;
-    }
-#endif
-}
-
-int HWCDisplay::PrepareLayerStack(hwc_display_contents_1_t *content_list) {
-  if (shutdown_pending_) {
-    return 0;
-  }
-
-  size_t num_hw_layers = content_list->numHwLayers;
-
-  if (!skip_prepare_cnt) {
-    DisplayError error = display_intf_->Prepare(&layer_stack_);
-    if (error != kErrorNone) {
-      if (error == kErrorShutDown) {
-        shutdown_pending_ = true;
-      } else if ((error != kErrorPermission) && (error != kErrorNoAppLayers)) {
-        DLOGE("Prepare failed. Error = %d", error);
-        // To prevent surfaceflinger infinite wait, flush the previous frame during Commit()
-        // so that previous buffer and fences are released, and override the error.
-        flush_ = true;
-      } else {
-        DLOGV("Prepare failed for Display = %d Error = %d", type_, error);
-      }
-      return 0;
-    }
-  } else {
-    // Skip is not set
-    MarkLayersForGPUBypass(content_list);
-    skip_prepare_cnt = skip_prepare_cnt - 1;
-    DLOGI("SecureDisplay %s, Skip Prepare/Commit and Flush", secure_display_active_ ? "Starting" :
-          "Stopping");
-    flush_ = true;
-  }
-
-  for (size_t i = 0; i < num_hw_layers; i++) {
-    hwc_layer_1_t &hwc_layer = content_list->hwLayers[i];
-    Layer *layer = layer_stack_.layers.at(i);
-    LayerComposition composition = layer->composition;
-    private_handle_t* pvt_handle  = static_cast<private_handle_t*>
-      (const_cast<native_handle_t*>(hwc_layer.handle));
-    MetaData_t *meta_data = pvt_handle ?
-      reinterpret_cast<MetaData_t *>(pvt_handle->base_metadata) : NULL;
-
-    if ((composition == kCompositionSDE) || (composition == kCompositionHybrid) ||
-        (composition == kCompositionBlit)) {
-      hwc_layer.hints |= HWC_HINT_CLEAR_FB;
-    }
-    SetComposition(composition, &hwc_layer.compositionType);
-
-    if (meta_data != NULL) {
-      if (composition == kCompositionGPUS3D) {
-        // Align HWC and client's dispaly ID in case of HDMI as primary
-        meta_data->s3dComp.displayId =
-          display_intf_->IsPrimaryDisplay() ? HWC_DISPLAY_PRIMARY: id_;
-        SetLayerS3DMode(layer->input_buffer.s3d_format,
-            &meta_data->s3dComp.s3dMode);
-      }
-    }
-  }
-
-  return 0;
-}
-
-int HWCDisplay::CommitLayerStack(hwc_display_contents_1_t *content_list) {
-  if (!content_list || !content_list->numHwLayers) {
-    DLOGW("Invalid content list");
-    return -EINVAL;
-  }
-
-  if (shutdown_pending_) {
-    return 0;
-  }
-
-  int status = 0;
-
-  size_t num_hw_layers = content_list->numHwLayers;
-
-  DumpInputBuffers(content_list);
-
-  if (!flush_) {
-    for (size_t i = 0; i < num_hw_layers; i++) {
-      CommitLayerParams(&content_list->hwLayers[i], layer_stack_.layers.at(i));
-    }
-
-    if (use_blit_comp_) {
-      status = blit_engine_->PreCommit(content_list, &layer_stack_);
-      if (status == 0) {
-        status = blit_engine_->Commit(content_list, &layer_stack_);
-        if (status != 0) {
-          DLOGE("Blit Comp Failed!");
-        }
-      }
-    }
-
-    if (layer_stack_.flags.hdr_present) {
-      status = tone_mapper_->HandleToneMap(content_list, &layer_stack_);
-      if (status != 0) {
-        DLOGE("Error handling HDR in ToneMapper");
-      }
-    } else {
-      tone_mapper_->Terminate();
-    }
-
-    DisplayError error = kErrorUndefined;
-    if (status == 0) {
-      error = display_intf_->Commit(&layer_stack_);
-      status = 0;
-    }
-
-    if (error == kErrorNone) {
-      // A commit is successfully submitted, start flushing on failure now onwards.
-      flush_on_error_ = true;
-    } else {
-      if (error == kErrorShutDown) {
-        shutdown_pending_ = true;
-        return status;
-      } else if (error != kErrorPermission) {
-        DLOGE("Commit failed. Error = %d", error);
-        // To prevent surfaceflinger infinite wait, flush the previous frame during Commit()
-        // so that previous buffer and fences are released, and override the error.
-        flush_ = true;
-      } else {
-        DLOGI("Commit failed for Display = %d Error = %d", type_, error);
-      }
-    }
-  }
-
-  return status;
-}
-
-int HWCDisplay::PostCommitLayerStack(hwc_display_contents_1_t *content_list) {
-  size_t num_hw_layers = content_list->numHwLayers;
-  int status = 0;
-
-  // Do no call flush on errors, if a successful buffer is never submitted.
-  if (flush_ && flush_on_error_) {
-    display_intf_->Flush();
-  }
-
-
-  if (tone_mapper_ && tone_mapper_->IsActive()) {
-     tone_mapper_->PostCommit(&layer_stack_);
-  }
-
-  // Set the release fence fd to the blit engine
-  if (use_blit_comp_ && blit_engine_->BlitActive()) {
-    blit_engine_->PostCommit(&layer_stack_);
-  }
-
-  for (size_t i = 0; i < num_hw_layers; i++) {
-    hwc_layer_1_t &hwc_layer = content_list->hwLayers[i];
-    Layer *layer = layer_stack_.layers.at(i);
-    LayerBuffer &layer_buffer = layer->input_buffer;
-
-    if (!flush_) {
-      // If swapinterval property is set to 0 or for single buffer layers, do not update f/w
-      // release fences and discard fences from driver
-      if (swap_interval_zero_ || layer->flags.single_buffer) {
-        hwc_layer.releaseFenceFd = -1;
-        close(layer_buffer.release_fence_fd);
-        layer_buffer.release_fence_fd = -1;
-      } else if (layer->composition != kCompositionGPU) {
-        hwc_layer.releaseFenceFd = layer_buffer.release_fence_fd;
-      }
-
-      // During animation on external/virtual display, SDM will use the cached
-      // framebuffer layer throughout animation and do not allow framework to do eglswapbuffer on
-      // framebuffer target. So graphics doesn't close the release fence fd of framebuffer target,
-      // Hence close the release fencefd of framebuffer target here.
-      if (disable_animation_) {
-        if (layer->composition == kCompositionGPUTarget && animating_) {
-          close(hwc_layer.releaseFenceFd);
-          hwc_layer.releaseFenceFd = -1;
-        }
-      }
-    }
-
-    if (hwc_layer.acquireFenceFd >= 0) {
-      close(hwc_layer.acquireFenceFd);
-      hwc_layer.acquireFenceFd = -1;
-    }
-  }
-
-  if (!flush_) {
-    animating_ = layer_stack_.flags.animating;
-    // if swapinterval property is set to 0 then close and reset the list retire fence
-    if (swap_interval_zero_) {
-      close(layer_stack_.retire_fence_fd);
-      layer_stack_.retire_fence_fd = -1;
-    }
-    content_list->retireFenceFd = layer_stack_.retire_fence_fd;
-
-    if (dump_frame_count_) {
-      dump_frame_count_--;
-      dump_frame_index_++;
-    }
-  }
-
-  flush_ = false;
-
-  return status;
-}
-
-bool HWCDisplay::IsLayerUpdating(hwc_display_contents_1_t *content_list, const Layer *layer) {
-  // Layer should be considered updating if
-  //   a) layer is in single buffer mode, or
-  //   b) valid dirty_regions(android specific hint for updating status), or
-  //   c) layer stack geometry has changed
-  return (layer->flags.single_buffer || IsSurfaceUpdated(layer->dirty_regions) ||
-         (layer_stack_.flags.geometry_changed));
-}
-
-bool HWCDisplay::IsNonIntegralSourceCrop(const hwc_frect_t &source) {
-     if ((source.left != roundf(source.left)) ||
-         (source.top != roundf(source.top)) ||
-         (source.right != roundf(source.right)) ||
-         (source.bottom != roundf(source.bottom))) {
-         return true;
-     } else {
-         return false;
-     }
-}
-
-void HWCDisplay::SetRect(const hwc_rect_t &source, LayerRect *target) {
-  target->left = FLOAT(source.left);
-  target->top = FLOAT(source.top);
-  target->right = FLOAT(source.right);
-  target->bottom = FLOAT(source.bottom);
-}
-
-void HWCDisplay::SetRect(const hwc_frect_t &source, LayerRect *target) {
-  target->left = floorf(source.left);
-  target->top = floorf(source.top);
-  target->right = ceilf(source.right);
-  target->bottom = ceilf(source.bottom);
-}
-
-void HWCDisplay::SetComposition(const int32_t &source, LayerComposition *target) {
-  switch (source) {
-  case HWC_FRAMEBUFFER_TARGET:  *target = kCompositionGPUTarget;  break;
-  default:                      *target = kCompositionGPU;        break;
-  }
-}
-
-void HWCDisplay::SetComposition(const LayerComposition &source, int32_t *target) {
-  switch (source) {
-  case kCompositionGPUTarget:   *target = HWC_FRAMEBUFFER_TARGET; break;
-  case kCompositionGPU:         *target = HWC_FRAMEBUFFER;        break;
-  case kCompositionGPUS3D:      *target = HWC_FRAMEBUFFER;        break;
-  case kCompositionCursor:      *target = HWC_CURSOR_OVERLAY;     break;
-  default:                      *target = HWC_OVERLAY;            break;
-  }
-}
-
-void HWCDisplay::SetBlending(const int32_t &source, LayerBlending *target) {
-  switch (source) {
-  case HWC_BLENDING_PREMULT:    *target = kBlendingPremultiplied;   break;
-  case HWC_BLENDING_COVERAGE:   *target = kBlendingCoverage;        break;
-  default:                      *target = kBlendingOpaque;          break;
-  }
-}
-
-void HWCDisplay::SetIdleTimeoutMs(uint32_t timeout_ms) {
-  return;
-}
-
-DisplayError HWCDisplay::SetMaxMixerStages(uint32_t max_mixer_stages) {
-  DisplayError error = kErrorNone;
-
-  if (display_intf_) {
-    error = display_intf_->SetMaxMixerStages(max_mixer_stages);
-  }
-
-  return error;
-}
-
-LayerBufferFormat HWCDisplay::GetSDMFormat(const int32_t &source, const int flags) {
-  LayerBufferFormat format = kFormatInvalid;
-  if (flags & private_handle_t::PRIV_FLAGS_UBWC_ALIGNED) {
-    switch (source) {
-    case HAL_PIXEL_FORMAT_RGBA_8888:           format = kFormatRGBA8888Ubwc;            break;
-    case HAL_PIXEL_FORMAT_RGBX_8888:           format = kFormatRGBX8888Ubwc;            break;
-    case HAL_PIXEL_FORMAT_BGR_565:             format = kFormatBGR565Ubwc;              break;
-    case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
-    case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC:
-    case HAL_PIXEL_FORMAT_NV12_ENCODEABLE:     format = kFormatYCbCr420SPVenusUbwc;     break;
-    case HAL_PIXEL_FORMAT_RGBA_1010102:        format = kFormatRGBA1010102Ubwc;         break;
-    case HAL_PIXEL_FORMAT_RGBX_1010102:        format = kFormatRGBX1010102Ubwc;         break;
-    case HAL_PIXEL_FORMAT_YCbCr_420_TP10_UBWC: format = kFormatYCbCr420TP10Ubwc;        break;
-    case HAL_PIXEL_FORMAT_YCbCr_420_P010_UBWC: format = kFormatYCbCr420P010Ubwc;        break;
-    default:
-      DLOGE("Unsupported format type for UBWC %d", source);
-      return kFormatInvalid;
-    }
-    return format;
-  }
-
-  switch (source) {
-  case HAL_PIXEL_FORMAT_RGBA_8888:                format = kFormatRGBA8888;                 break;
-  case HAL_PIXEL_FORMAT_RGBA_5551:                format = kFormatRGBA5551;                 break;
-  case HAL_PIXEL_FORMAT_RGBA_4444:                format = kFormatRGBA4444;                 break;
-  case HAL_PIXEL_FORMAT_BGRA_8888:                format = kFormatBGRA8888;                 break;
-  case HAL_PIXEL_FORMAT_RGBX_8888:                format = kFormatRGBX8888;                 break;
-  case HAL_PIXEL_FORMAT_BGRX_8888:                format = kFormatBGRX8888;                 break;
-  case HAL_PIXEL_FORMAT_RGB_888:                  format = kFormatRGB888;                   break;
-  case HAL_PIXEL_FORMAT_RGB_565:                  format = kFormatRGB565;                   break;
-  case HAL_PIXEL_FORMAT_BGR_565:                  format = kFormatBGR565;                   break;
-  case HAL_PIXEL_FORMAT_NV12_ENCODEABLE:
-  case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:       format = kFormatYCbCr420SemiPlanarVenus;  break;
-  case HAL_PIXEL_FORMAT_YCrCb_420_SP_VENUS:       format = kFormatYCrCb420SemiPlanarVenus;  break;
-  case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC:  format = kFormatYCbCr420SPVenusUbwc;      break;
-  case HAL_PIXEL_FORMAT_YV12:                     format = kFormatYCrCb420PlanarStride16;   break;
-  case HAL_PIXEL_FORMAT_YCrCb_420_SP:             format = kFormatYCrCb420SemiPlanar;       break;
-  case HAL_PIXEL_FORMAT_YCbCr_420_SP:             format = kFormatYCbCr420SemiPlanar;       break;
-  case HAL_PIXEL_FORMAT_YCbCr_422_SP:             format = kFormatYCbCr422H2V1SemiPlanar;   break;
-  case HAL_PIXEL_FORMAT_YCbCr_422_I:              format = kFormatYCbCr422H2V1Packed;       break;
-  case HAL_PIXEL_FORMAT_CbYCrY_422_I:             format = kFormatCbYCrY422H2V1Packed;      break;
-  case HAL_PIXEL_FORMAT_RGBA_1010102:             format = kFormatRGBA1010102;              break;
-  case HAL_PIXEL_FORMAT_ARGB_2101010:             format = kFormatARGB2101010;              break;
-  case HAL_PIXEL_FORMAT_RGBX_1010102:             format = kFormatRGBX1010102;              break;
-  case HAL_PIXEL_FORMAT_XRGB_2101010:             format = kFormatXRGB2101010;              break;
-  case HAL_PIXEL_FORMAT_BGRA_1010102:             format = kFormatBGRA1010102;              break;
-  case HAL_PIXEL_FORMAT_ABGR_2101010:             format = kFormatABGR2101010;              break;
-  case HAL_PIXEL_FORMAT_BGRX_1010102:             format = kFormatBGRX1010102;              break;
-  case HAL_PIXEL_FORMAT_XBGR_2101010:             format = kFormatXBGR2101010;              break;
-  case HAL_PIXEL_FORMAT_YCbCr_420_P010:           format = kFormatYCbCr420P010;             break;
-  case HAL_PIXEL_FORMAT_YCbCr_420_TP10_UBWC:      format = kFormatYCbCr420TP10Ubwc;         break;
-  case HAL_PIXEL_FORMAT_YCbCr_420_P010_UBWC:      format = kFormatYCbCr420P010Ubwc;         break;
-  default:
-    DLOGW("Unsupported format type = %d", source);
-    return kFormatInvalid;
-  }
-
-  return format;
-}
-
-void HWCDisplay::DumpInputBuffers(hwc_display_contents_1_t *content_list) {
-  size_t num_hw_layers = content_list->numHwLayers;
-  char dir_path[PATH_MAX];
-
-  if (!dump_frame_count_ || flush_ || !dump_input_layers_) {
-    return;
-  }
-
-  snprintf(dir_path, sizeof(dir_path), "/data/misc/display/frame_dump_%s", GetDisplayString());
-
-  if (mkdir(dir_path, 0777) != 0 && errno != EEXIST) {
-    DLOGW("Failed to create %s directory errno = %d, desc = %s", dir_path, errno, strerror(errno));
-    return;
-  }
-
-  // if directory exists already, need to explicitly change the permission.
-  if (errno == EEXIST && chmod(dir_path, 0777) != 0) {
-    DLOGW("Failed to change permissions on %s directory", dir_path);
-    return;
-  }
-
-  for (uint32_t i = 0; i < num_hw_layers; i++) {
-    hwc_layer_1_t &hwc_layer = content_list->hwLayers[i];
-    const private_handle_t *pvt_handle = static_cast<const private_handle_t *>(hwc_layer.handle);
-
-    if (hwc_layer.acquireFenceFd >= 0) {
-      int error = sync_wait(hwc_layer.acquireFenceFd, 1000);
-      if (error < 0) {
-        DLOGW("sync_wait error errno = %d, desc = %s", errno, strerror(errno));
-        return;
-      }
-    }
-
-    if (pvt_handle && pvt_handle->base) {
-      char dump_file_name[PATH_MAX];
-      size_t result = 0;
-
-      snprintf(dump_file_name, sizeof(dump_file_name), "%s/input_layer%d_%dx%d_%s_frame%d.raw",
-               dir_path, i, pvt_handle->width, pvt_handle->height,
-               qdutils::GetHALPixelFormatString(pvt_handle->format), dump_frame_index_);
-
-      FILE* fp = fopen(dump_file_name, "w+");
-      if (fp) {
-        result = fwrite(reinterpret_cast<void *>(pvt_handle->base), pvt_handle->size, 1, fp);
-        fclose(fp);
-      }
-
-      DLOGI("Frame Dump %s: is %s", dump_file_name, result ? "Successful" : "Failed");
-    }
-  }
-}
-
-void HWCDisplay::DumpOutputBuffer(const BufferInfo& buffer_info, void *base, int fence) {
-  char dir_path[PATH_MAX];
-
-  snprintf(dir_path, sizeof(dir_path), "/data/misc/display/frame_dump_%s", GetDisplayString());
-
-  if (mkdir(dir_path, 777) != 0 && errno != EEXIST) {
-    DLOGW("Failed to create %s directory errno = %d, desc = %s", dir_path, errno, strerror(errno));
-    return;
-  }
-
-  // if directory exists already, need to explicitly change the permission.
-  if (errno == EEXIST && chmod(dir_path, 0777) != 0) {
-    DLOGW("Failed to change permissions on %s directory", dir_path);
-    return;
-  }
-
-  if (base) {
-    char dump_file_name[PATH_MAX];
-    size_t result = 0;
-
-    if (fence >= 0) {
-      int error = sync_wait(fence, 1000);
-      if (error < 0) {
-        DLOGW("sync_wait error errno = %d, desc = %s", errno,  strerror(errno));
-        return;
-      }
-    }
-
-    snprintf(dump_file_name, sizeof(dump_file_name), "%s/output_layer_%dx%d_%s_frame%d.raw",
-             dir_path, buffer_info.alloc_buffer_info.aligned_width,
-             buffer_info.alloc_buffer_info.aligned_height,
-             GetFormatString(buffer_info.buffer_config.format), dump_frame_index_);
-
-    FILE* fp = fopen(dump_file_name, "w+");
-    if (fp) {
-      result = fwrite(base, buffer_info.alloc_buffer_info.size, 1, fp);
-      fclose(fp);
-    }
-
-    DLOGI("Frame Dump of %s is %s", dump_file_name, result ? "Successful" : "Failed");
-  }
-}
-
-const char *HWCDisplay::GetDisplayString() {
-  switch (type_) {
-  case kPrimary:
-    return "primary";
-  case kHDMI:
-    return "hdmi";
-  case kVirtual:
-    return "virtual";
-  default:
-    return "invalid";
-  }
-}
-
-int HWCDisplay::SetFrameBufferResolution(uint32_t x_pixels, uint32_t y_pixels) {
-  DisplayConfigVariableInfo fb_config;
-  DisplayError error = display_intf_->GetFrameBufferConfig(&fb_config);
-  if (error != kErrorNone) {
-    DLOGV("Get frame buffer config failed. Error = %d", error);
-    return -EINVAL;
-  }
-
-  fb_config.x_pixels = x_pixels;
-  fb_config.y_pixels = y_pixels;
-
-  error = display_intf_->SetFrameBufferConfig(fb_config);
-  if (error != kErrorNone) {
-    DLOGV("Set frame buffer config failed. Error = %d", error);
-    return -EINVAL;
-  }
-
-  DLOGI("New framebuffer resolution (%dx%d)", x_pixels, y_pixels);
-
-  return 0;
-}
-
-void HWCDisplay::GetFrameBufferResolution(uint32_t *x_pixels, uint32_t *y_pixels) {
-  DisplayConfigVariableInfo fb_config;
-  display_intf_->GetFrameBufferConfig(&fb_config);
-
-  *x_pixels = fb_config.x_pixels;
-  *y_pixels = fb_config.y_pixels;
-}
-
-DisplayError HWCDisplay::GetMixerResolution(uint32_t *x_pixels, uint32_t *y_pixels) {
-  return display_intf_->GetMixerResolution(x_pixels, y_pixels);
-}
-
-
-void HWCDisplay::GetPanelResolution(uint32_t *x_pixels, uint32_t *y_pixels) {
-  DisplayConfigVariableInfo display_config;
-  uint32_t active_index = 0;
-
-  display_intf_->GetActiveConfig(&active_index);
-  display_intf_->GetConfig(active_index, &display_config);
-
-  *x_pixels = display_config.x_pixels;
-  *y_pixels = display_config.y_pixels;
-}
-
-int HWCDisplay::SetDisplayStatus(uint32_t display_status) {
-  int status = 0;
-  const hwc_procs_t *hwc_procs = *hwc_procs_;
-
-  switch (display_status) {
-  case kDisplayStatusResume:
-    display_paused_ = false;
-  case kDisplayStatusOnline:
-    status = SetPowerMode(HWC_POWER_MODE_NORMAL);
-    break;
-  case kDisplayStatusPause:
-    display_paused_ = true;
-  case kDisplayStatusOffline:
-    status = SetPowerMode(HWC_POWER_MODE_OFF);
-    break;
-  default:
-    DLOGW("Invalid display status %d", display_status);
-    return -EINVAL;
-  }
-
-  if (display_status == kDisplayStatusResume ||
-      display_status == kDisplayStatusPause) {
-    hwc_procs->invalidate(hwc_procs);
-  }
-
-  return status;
-}
-
-int HWCDisplay::SetCursorPosition(int x, int y) {
-  DisplayError error = kErrorNone;
-
-  if (shutdown_pending_) {
-    return 0;
-  }
-
-  error = display_intf_->SetCursorPosition(x, y);
-  if (error != kErrorNone) {
-    if (error == kErrorShutDown) {
-      shutdown_pending_ = true;
-      return 0;
-    }
-    DLOGE("Failed for x = %d y = %d, Error = %d", x, y, error);
-    return -1;
-  }
-
-  return 0;
-}
-
-int HWCDisplay::OnMinHdcpEncryptionLevelChange(uint32_t min_enc_level) {
-  DisplayError error = display_intf_->OnMinHdcpEncryptionLevelChange(min_enc_level);
-  if (error != kErrorNone) {
-    DLOGE("Failed. Error = %d", error);
-    return -1;
-  }
-
-  return 0;
-}
-
-void HWCDisplay::MarkLayersForGPUBypass(hwc_display_contents_1_t *content_list) {
-  for (size_t i = 0 ; i < (content_list->numHwLayers - 1); i++) {
-    hwc_layer_1_t *layer = &content_list->hwLayers[i];
-    layer->compositionType = HWC_OVERLAY;
-  }
-}
-
-void HWCDisplay::ApplyScanAdjustment(hwc_rect_t *display_frame) {
-}
-
-DisplayError HWCDisplay::SetCSC(const MetaData_t *meta_data, ColorMetaData *color_metadata) {
-  if (meta_data->operation & COLOR_METADATA) {
-#ifdef USE_COLOR_METADATA
-    *color_metadata = meta_data->color;
-#endif
-  } else if (meta_data->operation & UPDATE_COLOR_SPACE) {
-    ColorSpace_t csc = meta_data->colorSpace;
-    color_metadata->range = Range_Limited;
-
-    if (csc == ITU_R_601_FR || csc == ITU_R_2020_FR) {
-      color_metadata->range = Range_Full;
-    }
-
-    switch (csc) {
-    case ITU_R_601:
-    case ITU_R_601_FR:
-      // display driver uses 601 irrespective of 525 or 625
-      color_metadata->colorPrimaries = ColorPrimaries_BT601_6_525;
-      break;
-    case ITU_R_709:
-      color_metadata->colorPrimaries = ColorPrimaries_BT709_5;
-      break;
-    case ITU_R_2020:
-    case ITU_R_2020_FR:
-      color_metadata->colorPrimaries = ColorPrimaries_BT2020;
-      break;
-    default:
-      DLOGE("Unsupported CSC: %d", csc);
-      return kErrorNotSupported;
-    }
-  }
-
-  return kErrorNone;
-}
-
-DisplayError HWCDisplay::SetIGC(IGC_t source, LayerIGC *target) {
-  switch (source) {
-  case IGC_NotSpecified:    *target = kIGCNotSpecified; break;
-  case IGC_sRGB:            *target = kIGCsRGB;   break;
-  default:
-    DLOGE("Unsupported IGC: %d", source);
-    return kErrorNotSupported;
-  }
-
-  return kErrorNone;
-}
-
-DisplayError HWCDisplay::SetMetaData(const private_handle_t *pvt_handle, Layer *layer) {
-  const MetaData_t *meta_data = reinterpret_cast<MetaData_t *>(pvt_handle->base_metadata);
-  LayerBuffer &layer_buffer = layer->input_buffer;
-
-  if (!meta_data) {
-    return kErrorNone;
-  }
-
-  if (SetCSC(meta_data, &layer_buffer.color_metadata) != kErrorNone) {
-    return kErrorNotSupported;
-  }
-
-  bool hdr_layer = layer_buffer.color_metadata.colorPrimaries == ColorPrimaries_BT2020 &&
-                   (layer_buffer.color_metadata.transfer == Transfer_SMPTE_ST2084 ||
-                   layer_buffer.color_metadata.transfer == Transfer_HLG);
-  if (hdr_layer && !disable_hdr_handling_) {
-    // dont honor HDR when its handling is disabled
-    layer_buffer.flags.hdr = true;
-    layer_stack_.flags.hdr_present = true;
-  }
-
-  if (meta_data->operation & SET_IGC) {
-    if (SetIGC(meta_data->igc, &layer_buffer.igc) != kErrorNone) {
-      return kErrorNotSupported;
-    }
-  }
-
-  if (meta_data->operation & UPDATE_REFRESH_RATE) {
-    layer->frame_rate = RoundToStandardFPS(meta_data->refreshrate);
-  }
-
-  if ((meta_data->operation & PP_PARAM_INTERLACED) && meta_data->interlaced) {
-    layer_buffer.flags.interlace = true;
-  }
-
-  if (meta_data->operation & LINEAR_FORMAT) {
-    layer_buffer.format = GetSDMFormat(INT32(meta_data->linearFormat), 0);
-  }
-
-  if (meta_data->operation & SET_SINGLE_BUFFER_MODE) {
-    layer->flags.single_buffer = meta_data->isSingleBufferMode;
-    // Graphics can set this operation on all types of layers including FB and set the actual value
-    // to 0. To protect against SET operations of 0 value, we need to do a logical OR.
-    layer_stack_.flags.single_buffered_layer_present |= meta_data->isSingleBufferMode;
-  }
-
-  if (meta_data->operation & S3D_FORMAT) {
-    std::map<int, LayerBufferS3DFormat>::iterator it =
-        s3d_format_hwc_to_sdm_.find(INT32(meta_data->s3dFormat));
-    if (it != s3d_format_hwc_to_sdm_.end()) {
-      layer->input_buffer.s3d_format = it->second;
-    } else {
-      DLOGW("Invalid S3D format %d", meta_data->s3dFormat);
-    }
-  }
-
-  return kErrorNone;
-}
-
-int HWCDisplay::SetPanelBrightness(int level) {
-  int ret = 0;
-  if (display_intf_)
-    ret = display_intf_->SetPanelBrightness(level);
-  else
-    ret = -EINVAL;
-
-  return ret;
-}
-
-int HWCDisplay::GetPanelBrightness(int *level) {
-  return display_intf_->GetPanelBrightness(level);
-}
-
-int HWCDisplay::CachePanelBrightness(int level) {
-  int ret = 0;
-  if (display_intf_)
-    ret = display_intf_->CachePanelBrightness(level);
-  else
-    ret = -EINVAL;
-
-  return ret;
-}
-
-int HWCDisplay::ToggleScreenUpdates(bool enable) {
-  const hwc_procs_t *hwc_procs = *hwc_procs_;
-  display_paused_ = enable ? false : true;
-  hwc_procs->invalidate(hwc_procs);
-  return 0;
-}
-
-int HWCDisplay::ColorSVCRequestRoute(const PPDisplayAPIPayload &in_payload,
-                                     PPDisplayAPIPayload *out_payload,
-                                     PPPendingParams *pending_action) {
-  int ret = 0;
-
-  if (display_intf_)
-    ret = display_intf_->ColorSVCRequestRoute(in_payload, out_payload, pending_action);
-  else
-    ret = -EINVAL;
-
-  return ret;
-}
-
-int HWCDisplay::GetVisibleDisplayRect(hwc_rect_t* visible_rect) {
-  if (!IsValid(display_rect_)) {
-    return -EINVAL;
-  }
-
-  visible_rect->left = INT(display_rect_.left);
-  visible_rect->top = INT(display_rect_.top);
-  visible_rect->right = INT(display_rect_.right);
-  visible_rect->bottom = INT(display_rect_.bottom);
-  DLOGI("Dpy = %d Visible Display Rect(%d %d %d %d)", visible_rect->left, visible_rect->top,
-        visible_rect->right, visible_rect->bottom);
-
-  return 0;
-}
-
-void HWCDisplay::SetSecureDisplay(bool secure_display_active, bool force_flush) {
-  secure_display_active_ = secure_display_active;
-  return;
-}
-
-int HWCDisplay::SetActiveDisplayConfig(int config) {
-  return display_intf_->SetActiveConfig(UINT32(config)) == kErrorNone ? 0 : -1;
-}
-
-int HWCDisplay::GetActiveDisplayConfig(uint32_t *config) {
-  return display_intf_->GetActiveConfig(config) == kErrorNone ? 0 : -1;
-}
-
-int HWCDisplay::GetDisplayConfigCount(uint32_t *count) {
-  return display_intf_->GetNumVariableInfoConfigs(count) == kErrorNone ? 0 : -1;
-}
-
-int HWCDisplay::GetDisplayAttributesForConfig(int config,
-                                            DisplayConfigVariableInfo *display_attributes) {
-  return display_intf_->GetConfig(UINT32(config), display_attributes) == kErrorNone ? 0 : -1;
-}
-
-int HWCDisplay::GetDisplayFixedConfig(DisplayConfigFixedInfo *fixed_info) {
-  return display_intf_->GetConfig(fixed_info) == kErrorNone ? 0 : -1;
-}
-
-// TODO(user): HWC needs to know updating for dyn_fps, cpu hint features,
-// once the features are moved to SDM, the two functions below can be removed.
-uint32_t HWCDisplay::GetUpdatingLayersCount(uint32_t app_layer_count) {
-  uint32_t updating_count = 0;
-
-  for (uint i = 0; i < app_layer_count; i++) {
-    Layer *layer = layer_stack_.layers.at(i);
-    if (layer->flags.updating) {
-      updating_count++;
-    }
-  }
-
-  return updating_count;
-}
-
-bool HWCDisplay::SingleVideoLayerUpdating(uint32_t app_layer_count) {
-  uint32_t updating_count = 0;
-
-  for (uint i = 0; i < app_layer_count; i++) {
-    Layer *layer = layer_stack_.layers[i];
-    // TODO(user): disable DRC feature in S3D playbacl case.S3D video
-    // need play in dedicate resolution and fps, if DRC switch the
-    // mode to an non S3D supported mode, it would break S3D playback.
-    // Need figure out a way to make S3D and DRC co-exist.
-    if (layer->flags.updating && (layer->input_buffer.flags.video == true) &&
-       (layer->input_buffer.s3d_format == kS3dFormatNone)) {
-      updating_count++;
-    }
-  }
-
-  return (updating_count == 1);
-}
-
-uint32_t HWCDisplay::RoundToStandardFPS(float fps) {
-  static const uint32_t standard_fps[4] = {30, 24, 48, 60};
-  uint32_t frame_rate = (uint32_t)(fps);
-
-  int count = INT(sizeof(standard_fps) / sizeof(standard_fps[0]));
-  for (int i = 0; i < count; i++) {
-    if ((standard_fps[i] - frame_rate) < 2) {
-      // Most likely used for video, the fps can fluctuate
-      // Ex: b/w 29 and 30 for 30 fps clip
-      return standard_fps[i];
-    }
-  }
-
-  return frame_rate;
-}
-
-uint32_t HWCDisplay::SanitizeRefreshRate(uint32_t req_refresh_rate) {
-  uint32_t refresh_rate = req_refresh_rate;
-
-  if (refresh_rate < min_refresh_rate_) {
-    // Pick the next multiple of request which is within the range
-    refresh_rate = (((min_refresh_rate_ / refresh_rate) +
-                     ((min_refresh_rate_ % refresh_rate) ? 1 : 0)) * refresh_rate);
-  }
-
-  if (refresh_rate > max_refresh_rate_) {
-    refresh_rate = max_refresh_rate_;
-  }
-
-  return refresh_rate;
-}
-
-DisplayClass HWCDisplay::GetDisplayClass() {
-  return display_class_;
-}
-
-void HWCDisplay::PrepareDynamicRefreshRate(Layer *layer) {
-  if (layer->frame_rate > metadata_refresh_rate_) {
-    metadata_refresh_rate_ = SanitizeRefreshRate(layer->frame_rate);
-  } else {
-    layer->frame_rate = current_refresh_rate_;
-  }
-}
-
-bool HWCDisplay::IsSurfaceUpdated(const std::vector<LayerRect> &dirty_regions) {
-  // based on dirty_regions determine if its updating
-  // dirty_rect count = 0 - whole layer - updating.
-  // dirty_rect count = 1 or more valid rects - updating.
-  // dirty_rect count = 1 with (0,0,0,0) - not updating.
-  return (dirty_regions.empty() || IsValid(dirty_regions.at(0)));
-}
-
-int HWCDisplay::GetDisplayPort(DisplayPort *port) {
-  return display_intf_->GetDisplayPort(port) == kErrorNone ? 0 : -1;
-}
-
-
-}  // namespace sdm
diff --git a/sdm/libs/hwc/hwc_display.h b/sdm/libs/hwc/hwc_display.h
deleted file mode 100644
index b0a40d5..0000000
--- a/sdm/libs/hwc/hwc_display.h
+++ /dev/null
@@ -1,266 +0,0 @@
-/*
-* Copyright (c) 2014 - 2017, 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_DISPLAY_H__
-#define __HWC_DISPLAY_H__
-
-#include <hardware/hwcomposer.h>
-#include <core/core_interface.h>
-#include <qdMetaData.h>
-#include <QService.h>
-#include <private/color_params.h>
-#include <map>
-#include <vector>
-#include <string>
-
-namespace sdm {
-
-class BlitEngine;
-class HWCToneMapper;
-
-// Subclasses set this to their type. This has to be different from DisplayType.
-// This is to avoid RTTI and dynamic_cast
-enum DisplayClass {
-  DISPLAY_CLASS_PRIMARY,
-  DISPLAY_CLASS_EXTERNAL,
-  DISPLAY_CLASS_VIRTUAL,
-  DISPLAY_CLASS_NULL
-};
-
-class HWCColorMode {
- public:
-  explicit HWCColorMode(DisplayInterface *display_intf) : display_intf_(display_intf) {}
-  ~HWCColorMode() {}
-  void Init();
-  void DeInit() {}
-  int SetColorMode(const std::string &color_mode);
-  const std::vector<std::string> &GetColorModes();
-  int SetColorTransform(uint32_t matrix_count, const float *matrix);
-
- private:
-  static const uint32_t kColorTransformMatrixCount = 16;
-  template <class T>
-  void CopyColorTransformMatrix(const T *input_matrix, double *output_matrix) {
-    for (uint32_t i = 0; i < kColorTransformMatrixCount; i++) {
-      output_matrix[i] = static_cast<double>(input_matrix[i]);
-    }
-  }
-  int PopulateColorModes();
-  DisplayInterface *display_intf_ = NULL;
-  std::vector<std::string> color_modes_ = {};
-  std::string current_color_mode_ = {};
-};
-
-class HWCDisplay : public DisplayEventHandler {
- public:
-  enum {
-    SET_METADATA_DYN_REFRESH_RATE,
-    SET_BINDER_DYN_REFRESH_RATE,
-    SET_DISPLAY_MODE,
-    SET_QDCM_SOLID_FILL_INFO,
-    UNSET_QDCM_SOLID_FILL_INFO,
-  };
-
-  virtual ~HWCDisplay() { }
-  virtual int Init();
-  virtual int Deinit();
-  virtual int Prepare(hwc_display_contents_1_t *content_list) = 0;
-  virtual int Commit(hwc_display_contents_1_t *content_list) = 0;
-  virtual int EventControl(int event, int enable);
-  virtual int SetPowerMode(int mode);
-
-  // Framebuffer configurations
-  virtual int GetDisplayConfigs(uint32_t *configs, size_t *num_configs);
-  virtual int GetDisplayAttributes(uint32_t config, const uint32_t *display_attributes,
-                                   int32_t *values);
-  virtual int GetActiveConfig();
-  virtual int SetActiveConfig(int index);
-
-  virtual void SetIdleTimeoutMs(uint32_t timeout_ms);
-  virtual void SetFrameDumpConfig(uint32_t count, uint32_t bit_mask_layer_type);
-  virtual DisplayError SetMaxMixerStages(uint32_t max_mixer_stages);
-  virtual DisplayError ControlPartialUpdate(bool enable, uint32_t *pending) {
-    return kErrorNotSupported;
-  }
-  virtual uint32_t GetLastPowerMode();
-  virtual int SetFrameBufferResolution(uint32_t x_pixels, uint32_t y_pixels);
-  virtual void GetFrameBufferResolution(uint32_t *x_pixels, uint32_t *y_pixels);
-  virtual int SetDisplayStatus(uint32_t display_status);
-  virtual int OnMinHdcpEncryptionLevelChange(uint32_t min_enc_level);
-  virtual int Perform(uint32_t operation, ...);
-  virtual int SetCursorPosition(int x, int y);
-  virtual void SetSecureDisplay(bool secure_display_active, bool force_flush);
-  virtual DisplayError SetMixerResolution(uint32_t width, uint32_t height);
-  virtual DisplayError GetMixerResolution(uint32_t *width, uint32_t *height);
-  virtual void GetPanelResolution(uint32_t *width, uint32_t *height);
-
-  // Captures frame output in the buffer specified by output_buffer_info. The API is
-  // non-blocking and the client is expected to check operation status later on.
-  // Returns -1 if the input is invalid.
-  virtual int FrameCaptureAsync(const BufferInfo& output_buffer_info, bool post_processed) {
-    return -1;
-  }
-  // Returns the status of frame capture operation requested with FrameCaptureAsync().
-  // -EAGAIN : No status obtain yet, call API again after another frame.
-  // < 0 : Operation happened but failed.
-  // 0 : Success.
-  virtual int GetFrameCaptureStatus() { return -EAGAIN; }
-
-  virtual DisplayError SetDetailEnhancerConfig(const DisplayDetailEnhancerData &de_data) {
-    return kErrorNotSupported;
-  }
-
-  // Display Configurations
-  virtual int SetActiveDisplayConfig(int config);
-  virtual int GetActiveDisplayConfig(uint32_t *config);
-  virtual int GetDisplayConfigCount(uint32_t *count);
-  virtual int GetDisplayAttributesForConfig(int config,
-                                            DisplayConfigVariableInfo *display_attributes);
-  virtual int GetDisplayFixedConfig(DisplayConfigFixedInfo *fixed_info);
-
-  int SetPanelBrightness(int level);
-  int GetPanelBrightness(int *level);
-  int CachePanelBrightness(int level);
-  int ToggleScreenUpdates(bool enable);
-  int ColorSVCRequestRoute(const PPDisplayAPIPayload &in_payload,
-                           PPDisplayAPIPayload *out_payload,
-                           PPPendingParams *pending_action);
-  int GetVisibleDisplayRect(hwc_rect_t* rect);
-  DisplayClass GetDisplayClass();
-  int GetDisplayPort(DisplayPort *port);
-
- protected:
-  enum DisplayStatus {
-    kDisplayStatusOffline = 0,
-    kDisplayStatusOnline,
-    kDisplayStatusPause,
-    kDisplayStatusResume,
-  };
-
-  // Dim layer flag set by SurfaceFlinger service.
-  static const uint32_t kDimLayer = 0x80000000;
-
-  // Maximum number of layers supported by display manager.
-  static const uint32_t kMaxLayerCount = 32;
-
-  HWCDisplay(CoreInterface *core_intf, hwc_procs_t const **hwc_procs, DisplayType type, int id,
-             bool needs_blit, qService::QService *qservice, DisplayClass display_class);
-
-  // DisplayEventHandler methods
-  virtual DisplayError VSync(const DisplayEventVSync &vsync);
-  virtual DisplayError Refresh();
-  virtual DisplayError CECMessage(char *message);
-
-  int AllocateLayerStack(hwc_display_contents_1_t *content_list);
-  void FreeLayerStack();
-  virtual int PrePrepareLayerStack(hwc_display_contents_1_t *content_list);
-  virtual int PrepareLayerStack(hwc_display_contents_1_t *content_list);
-  virtual int CommitLayerStack(hwc_display_contents_1_t *content_list);
-  virtual int PostCommitLayerStack(hwc_display_contents_1_t *content_list);
-  virtual void DumpOutputBuffer(const BufferInfo& buffer_info, void *base, int fence);
-  virtual uint32_t RoundToStandardFPS(float fps);
-  virtual uint32_t SanitizeRefreshRate(uint32_t req_refresh_rate);
-  virtual void PrepareDynamicRefreshRate(Layer *layer);
-  virtual DisplayError DisablePartialUpdateOneFrame() {
-    return kErrorNotSupported;
-  }
-  inline void SetRect(const hwc_rect_t &source, LayerRect *target);
-  inline void SetRect(const hwc_frect_t &source, LayerRect *target);
-  inline void SetComposition(const int32_t &source, LayerComposition *target);
-  inline void SetComposition(const LayerComposition &source, int32_t *target);
-  inline void SetBlending(const int32_t &source, LayerBlending *target);
-  int SetFormat(const int32_t &source, const int flags, LayerBufferFormat *target);
-  void SetLayerS3DMode(const LayerBufferS3DFormat &source, uint32_t *target);
-  LayerBufferFormat GetSDMFormat(const int32_t &source, const int flags);
-  const char *GetDisplayString();
-  void MarkLayersForGPUBypass(hwc_display_contents_1_t *content_list);
-  virtual void ApplyScanAdjustment(hwc_rect_t *display_frame);
-  DisplayError SetCSC(const MetaData_t *meta_data, ColorMetaData *color_metadata);
-  DisplayError SetIGC(IGC_t source, LayerIGC *target);
-  DisplayError SetMetaData(const private_handle_t *pvt_handle, Layer *layer);
-  bool NeedsFrameBufferRefresh(hwc_display_contents_1_t *content_list);
-  bool IsLayerUpdating(hwc_display_contents_1_t *content_list, const Layer *layer);
-  bool IsNonIntegralSourceCrop(const hwc_frect_t &source);
-  uint32_t GetUpdatingLayersCount(uint32_t app_layer_count);
-  bool SingleVideoLayerUpdating(uint32_t app_layer_count);
-  bool IsSurfaceUpdated(const std::vector<LayerRect> &dirty_regions);
-
-  enum {
-    INPUT_LAYER_DUMP,
-    OUTPUT_LAYER_DUMP,
-  };
-
-  CoreInterface *core_intf_;
-  hwc_procs_t const **hwc_procs_;
-  DisplayType type_;
-  int id_;
-  bool needs_blit_ = false;
-  DisplayInterface *display_intf_ = NULL;
-  LayerStack layer_stack_;
-  bool flush_on_error_ = false;
-  bool flush_ = false;
-  uint32_t dump_frame_count_ = 0;
-  uint32_t dump_frame_index_ = 0;
-  bool dump_input_layers_ = false;
-  uint32_t last_power_mode_;
-  bool swap_interval_zero_ = false;
-  bool display_paused_ = false;
-  uint32_t min_refresh_rate_ = 0;
-  uint32_t max_refresh_rate_ = 0;
-  uint32_t current_refresh_rate_ = 0;
-  bool use_metadata_refresh_rate_ = false;
-  uint32_t metadata_refresh_rate_ = 0;
-  uint32_t force_refresh_rate_ = 0;
-  bool boot_animation_completed_ = false;
-  bool shutdown_pending_ = false;
-  bool use_blit_comp_ = false;
-  bool secure_display_active_ = false;
-  uint32_t skip_prepare_cnt = 0;
-  bool solid_fill_enable_ = false;
-  bool disable_animation_ = false;
-  uint32_t solid_fill_color_ = 0;
-  LayerRect display_rect_;
-  std::map<int, LayerBufferS3DFormat> s3d_format_hwc_to_sdm_;
-  bool animating_ = false;
-  HWCToneMapper *tone_mapper_ = NULL;
-  HWCColorMode *color_mode_ = NULL;
-  int disable_hdr_handling_ = 0;  // disables HDR handling.
-
- private:
-  void DumpInputBuffers(hwc_display_contents_1_t *content_list);
-  int PrepareLayerParams(hwc_layer_1_t *hwc_layer, Layer *layer);
-  void CommitLayerParams(hwc_layer_1_t *hwc_layer, Layer *layer);
-  BlitEngine *blit_engine_ = NULL;
-  qService::QService *qservice_ = NULL;
-  DisplayClass display_class_;
-};
-
-inline int HWCDisplay::Perform(uint32_t operation, ...) {
-  return 0;
-}
-
-}  // namespace sdm
-
-#endif  // __HWC_DISPLAY_H__
-
diff --git a/sdm/libs/hwc/hwc_display_external.cpp b/sdm/libs/hwc/hwc_display_external.cpp
deleted file mode 100644
index da216f7..0000000
--- a/sdm/libs/hwc/hwc_display_external.cpp
+++ /dev/null
@@ -1,335 +0,0 @@
-/*
-* Copyright (c) 2014 - 2016, 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.
-*/
-
-#include <cutils/properties.h>
-#include <utils/constants.h>
-#include <utils/debug.h>
-#include <algorithm>
-
-#include "hwc_display_external.h"
-#include "hwc_debugger.h"
-
-#define __CLASS__ "HWCDisplayExternal"
-
-namespace sdm {
-
-int HWCDisplayExternal::Create(CoreInterface *core_intf, hwc_procs_t const **hwc_procs,
-                               qService::QService *qservice, HWCDisplay **hwc_display) {
-  return Create(core_intf, hwc_procs, 0, 0, qservice, false, hwc_display);
-}
-
-int HWCDisplayExternal::Create(CoreInterface *core_intf, hwc_procs_t const **hwc_procs,
-                               uint32_t primary_width, uint32_t primary_height,
-                               qService::QService *qservice, bool use_primary_res,
-                               HWCDisplay **hwc_display) {
-  uint32_t external_width = 0;
-  uint32_t external_height = 0;
-  int drc_enabled = 0;
-  int drc_reset_fps_enabled = 0;
-  DisplayError error = kErrorNone;
-
-  HWCDisplay *hwc_display_external = new HWCDisplayExternal(core_intf, hwc_procs, qservice);
-  int status = hwc_display_external->Init();
-  if (status) {
-    delete hwc_display_external;
-    return status;
-  }
-
-  error = hwc_display_external->GetMixerResolution(&external_width, &external_height);
-  if (error != kErrorNone) {
-    return -EINVAL;
-  }
-
-  if (primary_width && primary_height) {
-    // use_primary_res means HWCDisplayExternal should directly set framebuffer resolution to the
-    // provided primary_width and primary_height
-    if (use_primary_res) {
-      external_width = primary_width;
-      external_height = primary_height;
-    } else {
-      int downscale_enabled = 0;
-      HWCDebugHandler::Get()->GetProperty("sdm.debug.downscale_external", &downscale_enabled);
-      if (downscale_enabled) {
-        GetDownscaleResolution(primary_width, primary_height, &external_width, &external_height);
-      }
-    }
-  }
-
-  status = hwc_display_external->SetFrameBufferResolution(external_width, external_height);
-  if (status) {
-    Destroy(hwc_display_external);
-    return status;
-  }
-
-  HWCDebugHandler::Get()->GetProperty("sdm.hdmi.drc_enabled", &(drc_enabled));
-  reinterpret_cast<HWCDisplayExternal *>(hwc_display_external)->drc_enabled_ = drc_enabled;
-
-  HWCDebugHandler::Get()->GetProperty("sdm.hdmi.drc_reset_fps", &(drc_reset_fps_enabled));
-  reinterpret_cast<HWCDisplayExternal *>(hwc_display_external)->drc_reset_fps_enabled_ =
-                                                                drc_reset_fps_enabled;
-
-  *hwc_display = hwc_display_external;
-
-  return status;
-}
-
-void HWCDisplayExternal::Destroy(HWCDisplay *hwc_display) {
-  hwc_display->Deinit();
-  delete hwc_display;
-}
-
-HWCDisplayExternal::HWCDisplayExternal(CoreInterface *core_intf, hwc_procs_t const **hwc_procs,
-                                       qService::QService *qservice)
-  : HWCDisplay(core_intf, hwc_procs, kHDMI, HWC_DISPLAY_EXTERNAL, false, qservice,
-               DISPLAY_CLASS_EXTERNAL) {
-}
-
-int HWCDisplayExternal::Prepare(hwc_display_contents_1_t *content_list) {
-  int status = 0;
-  DisplayError error = kErrorNone;
-
-  if (secure_display_active_) {
-    MarkLayersForGPUBypass(content_list);
-    return status;
-  }
-
-  status = AllocateLayerStack(content_list);
-  if (status) {
-    return status;
-  }
-
-  status = PrePrepareLayerStack(content_list);
-  if (status) {
-    return status;
-  }
-
-  if (content_list->numHwLayers <= 1) {
-    flush_ = true;
-    return 0;
-  }
-
-  bool one_video_updating_layer = SingleVideoLayerUpdating(UINT32(content_list->numHwLayers - 1));
-
-  uint32_t refresh_rate = GetOptimalRefreshRate(one_video_updating_layer);
-  bool final_rate = force_refresh_rate_ ? true : false;
-  error = display_intf_->SetRefreshRate(refresh_rate, final_rate);
-  if (error == kErrorNone) {
-    // On success, set current refresh rate to new refresh rate
-    current_refresh_rate_ = refresh_rate;
-  }
-
-  status = PrepareLayerStack(content_list);
-  if (status) {
-    return status;
-  }
-
-  return 0;
-}
-
-int HWCDisplayExternal::Commit(hwc_display_contents_1_t *content_list) {
-  int status = 0;
-
-  if (secure_display_active_) {
-    return status;
-  }
-
-  status = HWCDisplay::CommitLayerStack(content_list);
-  if (status) {
-    return status;
-  }
-
-  status = HWCDisplay::PostCommitLayerStack(content_list);
-  if (status) {
-    return status;
-  }
-
-  return 0;
-}
-
-void HWCDisplayExternal::ApplyScanAdjustment(hwc_rect_t *display_frame) {
-  if (display_intf_->IsUnderscanSupported()) {
-    return;
-  }
-
-  // Read user defined width and height ratio
-  int width = 0, height = 0;
-  HWCDebugHandler::Get()->GetProperty("sdm.external_action_safe_width", &width);
-  float width_ratio = FLOAT(width) / 100.0f;
-  HWCDebugHandler::Get()->GetProperty("sdm.external_action_safe_height", &height);
-  float height_ratio = FLOAT(height) / 100.0f;
-
-  if (width_ratio == 0.0f ||  height_ratio == 0.0f) {
-    return;
-  }
-
-  uint32_t mixer_width = 0;
-  uint32_t mixer_height = 0;
-  GetMixerResolution(&mixer_width, &mixer_height);
-
-  if (mixer_width == 0 || mixer_height == 0) {
-    DLOGV("Invalid mixer dimensions (%d, %d)", mixer_width, mixer_height);
-    return;
-  }
-
-  uint32_t new_mixer_width = UINT32(mixer_width * FLOAT(1.0f - width_ratio));
-  uint32_t new_mixer_height = UINT32(mixer_height * FLOAT(1.0f - height_ratio));
-
-  int x_offset = INT((FLOAT(mixer_width) * width_ratio) / 2.0f);
-  int y_offset = INT((FLOAT(mixer_height) * height_ratio) / 2.0f);
-
-  display_frame->left = (display_frame->left * INT32(new_mixer_width) / INT32(mixer_width))
-                        + x_offset;
-  display_frame->top = (display_frame->top * INT32(new_mixer_height) / INT32(mixer_height)) +
-                       y_offset;
-  display_frame->right = ((display_frame->right * INT32(new_mixer_width)) / INT32(mixer_width)) +
-                         x_offset;
-  display_frame->bottom = ((display_frame->bottom * INT32(new_mixer_height)) / INT32(mixer_height))
-                          + y_offset;
-}
-
-void HWCDisplayExternal::SetSecureDisplay(bool secure_display_active, bool force_flush) {
-  if (secure_display_active_ != secure_display_active) {
-    secure_display_active_ = secure_display_active;
-
-    if (secure_display_active_) {
-      DisplayError error = display_intf_->Flush();
-      if (error != kErrorNone) {
-        DLOGE("Flush failed. Error = %d", error);
-      }
-    }
-  }
-  return;
-}
-
-static void AdjustSourceResolution(uint32_t dst_width, uint32_t dst_height, uint32_t *src_width,
-                                   uint32_t *src_height) {
-  *src_height = (dst_width * (*src_height)) / (*src_width);
-  *src_width = dst_width;
-}
-
-void HWCDisplayExternal::GetDownscaleResolution(uint32_t primary_width, uint32_t primary_height,
-                                        uint32_t *non_primary_width, uint32_t *non_primary_height) {
-  uint32_t primary_area = primary_width * primary_height;
-  uint32_t non_primary_area = (*non_primary_width) * (*non_primary_height);
-
-  if (primary_area > non_primary_area) {
-    if (primary_height > primary_width) {
-      std::swap(primary_height, primary_width);
-    }
-    AdjustSourceResolution(primary_width, primary_height, non_primary_width, non_primary_height);
-  }
-}
-
-uint32_t HWCDisplayExternal::RoundToStandardFPS(float fps) {
-  static const uint32_t standard_fps[] = {23976, 24000, 25000, 29970, 30000, 50000, 59940, 60000};
-  static const uint32_t mapping_fps[] = {59940, 60000, 60000, 59940, 60000, 50000, 59940, 60000};
-  uint32_t frame_rate = (uint32_t)(fps * 1000);
-
-  // process non valid
-  if (frame_rate == 0) {
-    return current_refresh_rate_;
-  }
-
-  int count = INT(sizeof(standard_fps) / sizeof(standard_fps[0]));
-  for (int i = 0; i < count; i++) {
-    // Most likely used for video, the fps for frames should be stable from video side.
-    if (standard_fps[i] > frame_rate) {
-      if (i > 0) {
-        if ((standard_fps[i] - frame_rate) > (frame_rate - standard_fps[i-1])) {
-          return mapping_fps[i-1];
-        } else {
-          return mapping_fps[i];
-        }
-      } else {
-        return mapping_fps[i];
-      }
-    }
-  }
-
-  return standard_fps[count - 1];
-}
-
-void HWCDisplayExternal::PrepareDynamicRefreshRate(Layer *layer) {
-  if (layer->input_buffer.flags.video) {
-    if (layer->frame_rate != 0) {
-      metadata_refresh_rate_ = SanitizeRefreshRate(layer->frame_rate);
-    } else {
-      metadata_refresh_rate_ = current_refresh_rate_;
-    }
-    layer->frame_rate = current_refresh_rate_;
-  } else if (!layer->frame_rate) {
-    layer->frame_rate = current_refresh_rate_;
-  }
-}
-
-void HWCDisplayExternal::ForceRefreshRate(uint32_t refresh_rate) {
-  if ((refresh_rate && (refresh_rate < min_refresh_rate_ || refresh_rate > max_refresh_rate_)) ||
-       force_refresh_rate_ == refresh_rate) {
-    // Cannot honor force refresh rate, as its beyond the range or new request is same
-    return;
-  }
-
-  force_refresh_rate_ = refresh_rate;
-}
-
-uint32_t HWCDisplayExternal::GetOptimalRefreshRate(bool one_updating_layer) {
-  if (force_refresh_rate_) {
-    return force_refresh_rate_;
-  } else if (one_updating_layer && drc_enabled_) {
-    return metadata_refresh_rate_;
-  }
-
-  if (drc_reset_fps_enabled_) {
-    DisplayConfigVariableInfo fb_config;
-    display_intf_->GetFrameBufferConfig(&fb_config);
-    return (fb_config.fps * 1000);
-  }
-
-  return current_refresh_rate_;
-}
-
-int HWCDisplayExternal::Perform(uint32_t operation, ...) {
-  va_list args;
-  va_start(args, operation);
-  int val = va_arg(args, int32_t);
-  va_end(args);
-  switch (operation) {
-    case SET_BINDER_DYN_REFRESH_RATE:
-      ForceRefreshRate(UINT32(val));
-      break;
-    default:
-      DLOGW("Invalid operation %d", operation);
-      return -EINVAL;
-  }
-
-  return 0;
-}
-
-}  // namespace sdm
-
diff --git a/sdm/libs/hwc/hwc_display_external.h b/sdm/libs/hwc/hwc_display_external.h
deleted file mode 100644
index c5ac3d7..0000000
--- a/sdm/libs/hwc/hwc_display_external.h
+++ /dev/null
@@ -1,64 +0,0 @@
-/*
-* Copyright (c) 2014, 2016, 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_DISPLAY_EXTERNAL_H__
-#define __HWC_DISPLAY_EXTERNAL_H__
-
-#include "hwc_display.h"
-
-namespace sdm {
-
-class HWCDisplayExternal : public HWCDisplay {
- public:
-  static int Create(CoreInterface *core_intf, hwc_procs_t const **hwc_procs, uint32_t primary_width,
-                    uint32_t primary_height, qService::QService *qservice, bool use_primary_res,
-                    HWCDisplay **hwc_display);
-  static int Create(CoreInterface *core_intf, hwc_procs_t const **hwc_procs,
-                    qService::QService *qservice, HWCDisplay **hwc_display);
-  static void Destroy(HWCDisplay *hwc_display);
-  virtual int Prepare(hwc_display_contents_1_t *content_list);
-  virtual int Commit(hwc_display_contents_1_t *content_list);
-  virtual void SetSecureDisplay(bool secure_display_active, bool force_flush);
-  virtual int Perform(uint32_t operation, ...);
-
- protected:
-  virtual uint32_t RoundToStandardFPS(float fps);
-  virtual void PrepareDynamicRefreshRate(Layer *layer);
-  int drc_enabled_ = 0;
-  int drc_reset_fps_enabled_ = 0;
-
- private:
-  HWCDisplayExternal(CoreInterface *core_intf, hwc_procs_t const **hwc_procs,
-                     qService::QService *qservice);
-  void ApplyScanAdjustment(hwc_rect_t *display_frame);
-  static void GetDownscaleResolution(uint32_t primary_width, uint32_t primary_height,
-                                     uint32_t *virtual_width, uint32_t *virtual_height);
-  void ForceRefreshRate(uint32_t refresh_rate);
-  uint32_t GetOptimalRefreshRate(bool one_updating_layer);
-};
-
-}  // namespace sdm
-
-#endif  // __HWC_DISPLAY_EXTERNAL_H__
-
diff --git a/sdm/libs/hwc/hwc_display_external_test.cpp b/sdm/libs/hwc/hwc_display_external_test.cpp
deleted file mode 100644
index e629cd6..0000000
--- a/sdm/libs/hwc/hwc_display_external_test.cpp
+++ /dev/null
@@ -1,764 +0,0 @@
-/*
-* Copyright (c) 2017, 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.
-*/
-
-#include <cutils/properties.h>
-#include <sys/mman.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <utils/constants.h>
-#include <utils/debug.h>
-#include <utils/formats.h>
-#include <algorithm>
-#include <array>
-#include <sstream>
-#include <string>
-#include <fstream>
-
-#include "hwc_display_external_test.h"
-#include "hwc_debugger.h"
-
-#define __CLASS__ "HWCDisplayExternalTest"
-
-namespace sdm {
-
-using std::array;
-
-int HWCDisplayExternalTest::Create(CoreInterface *core_intf, hwc_procs_t const **hwc_procs,
-                                   qService::QService *qservice, uint32_t panel_bpp,
-                                   uint32_t pattern_type, HWCDisplay **hwc_display) {
-  HWCDisplay *hwc_external_test = new HWCDisplayExternalTest(core_intf, hwc_procs, qservice,
-                                                             panel_bpp, pattern_type);
-
-  int status = static_cast<HWCDisplayExternalTest *>(hwc_external_test)->Init();
-  if (status) {
-    delete hwc_external_test;
-    return status;
-  }
-
-  *hwc_display = hwc_external_test;
-
-  DLOGI("panel_bpp %d, pattern_type %d", panel_bpp, pattern_type);
-
-  return status;
-}
-
-void HWCDisplayExternalTest::Destroy(HWCDisplay *hwc_display) {
-  static_cast<HWCDisplayExternalTest *>(hwc_display)->Deinit();
-
-  delete hwc_display;
-}
-
-HWCDisplayExternalTest::HWCDisplayExternalTest(CoreInterface *core_intf,
-                                               hwc_procs_t const **hwc_procs,
-                                               qService::QService *qservice, uint32_t panel_bpp,
-                                               uint32_t pattern_type)
-  : HWCDisplay(core_intf, hwc_procs, kHDMI, HWC_DISPLAY_EXTERNAL, false, qservice,
-               DISPLAY_CLASS_EXTERNAL), panel_bpp_(panel_bpp), pattern_type_(pattern_type) {
-}
-
-int HWCDisplayExternalTest::Init() {
-  uint32_t external_width = 0;
-  uint32_t external_height = 0;
-
-  int status = HWCDisplay::Init();
-  if (status) {
-    return status;
-  }
-
-  buffer_allocator_ = new HWCBufferAllocator();
-
-  status = CreateLayerStack();
-  if (status) {
-    Deinit();
-    return status;
-  }
-
-  DisplayError error = HWCDisplay::GetMixerResolution(&external_width, &external_height);
-  if (error != kErrorNone) {
-    Deinit();
-    return -EINVAL;
-  }
-
-  status = HWCDisplay::SetFrameBufferResolution(external_width, external_height);
-  if (status) {
-    Deinit();
-    return status;
-  }
-
-  return status;
-}
-
-int HWCDisplayExternalTest::Deinit() {
-  DestroyLayerStack();
-
-  delete buffer_allocator_;
-  buffer_allocator_ = NULL;
-
-  return HWCDisplay::Deinit();
-}
-
-
-int HWCDisplayExternalTest::Prepare(hwc_display_contents_1_t *content_list) {
-  int status = 0;
-
-  if (secure_display_active_) {
-    MarkLayersForGPUBypass(content_list);
-    return status;
-  }
-
-  if (!content_list || !content_list->numHwLayers) {
-    DLOGW("Invalid content list");
-    return -EINVAL;
-  }
-
-  if (shutdown_pending_) {
-    return 0;
-  }
-
-  DisplayError error = display_intf_->Prepare(&layer_stack_);
-  if (error != kErrorNone) {
-    if (error == kErrorShutDown) {
-      shutdown_pending_ = true;
-    } else if (error != kErrorPermission) {
-      DLOGE("Prepare failed. Error = %d", error);
-      // To prevent surfaceflinger infinite wait, flush the previous frame during Commit()
-      // so that previous buffer and fences are released, and override the error.
-      flush_ = true;
-    }
-  }
-
-  MarkLayersForGPUBypass(content_list);
-
-  return 0;
-}
-
-int HWCDisplayExternalTest::Commit(hwc_display_contents_1_t *content_list) {
-  int status = 0;
-
-  if (secure_display_active_) {
-    return status;
-  }
-
-  if (!content_list || !content_list->numHwLayers) {
-    DLOGW("Invalid content list");
-    return -EINVAL;
-  }
-
-  if (shutdown_pending_) {
-    return 0;
-  }
-
-  DumpInputBuffer();
-
-  if (!flush_) {
-    DisplayError error = kErrorUndefined;
-
-    error = display_intf_->Commit(&layer_stack_);
-    if (error == kErrorNone) {
-      // A commit is successfully submitted, start flushing on failure now onwards.
-      flush_on_error_ = true;
-    } else {
-      if (error == kErrorShutDown) {
-        shutdown_pending_ = true;
-        return status;
-      } else if (error != kErrorPermission) {
-        DLOGE("Commit failed. Error = %d", error);
-        // To prevent surfaceflinger infinite wait, flush the previous frame during Commit()
-        // so that previous buffer and fences are released, and override the error.
-        flush_ = true;
-      }
-    }
-  }
-
-  return PostCommit(content_list);
-}
-
-void HWCDisplayExternalTest::SetSecureDisplay(bool secure_display_active, bool force_flush) {
-  if (secure_display_active_ != secure_display_active) {
-    secure_display_active_ = secure_display_active;
-
-    if (secure_display_active_) {
-      DisplayError error = display_intf_->Flush();
-      if (error != kErrorNone) {
-        DLOGE("Flush failed. Error = %d", error);
-      }
-    }
-  }
-  return;
-}
-
-int HWCDisplayExternalTest::Perform(uint32_t operation, ...) {
-  return 0;
-}
-
-void HWCDisplayExternalTest::DumpInputBuffer() {
-  if (!dump_frame_count_ || flush_ || !dump_input_layers_) {
-    return;
-  }
-
-  const char *dir_path = "/data/misc/display/frame_dump_external";
-  uint32_t width = buffer_info_.alloc_buffer_info.aligned_width;
-  uint32_t height = buffer_info_.alloc_buffer_info.aligned_height;
-  string format_str = GetFormatString(buffer_info_.buffer_config.format);
-
-  char *buffer = reinterpret_cast<char *>(mmap(NULL, buffer_info_.alloc_buffer_info.size,
-                                                PROT_READ|PROT_WRITE, MAP_SHARED,
-                                                buffer_info_.alloc_buffer_info.fd, 0));
-  if (buffer == MAP_FAILED) {
-    DLOGW("mmap failed. err = %d", errno);
-    return;
-  }
-
-  if (mkdir(dir_path, 0777) != 0 && errno != EEXIST) {
-    DLOGW("Failed to create %s directory errno = %d, desc = %s", dir_path, errno, strerror(errno));
-    return;
-  }
-
-  // if directory exists already, need to explicitly change the permission.
-  if (errno == EEXIST && chmod(dir_path, 0777) != 0) {
-    DLOGW("Failed to change permissions on %s directory", dir_path);
-    return;
-  }
-
-  if (buffer) {
-    std::stringstream dump_file_name;
-    dump_file_name << dir_path;
-    dump_file_name << "/input_layer_" << width << "x" << height << "_" << format_str << ".raw";
-
-    std::fstream fs;
-    fs.open(dump_file_name.str().c_str(), std::fstream::in | std::fstream::out | std::fstream::app);
-    if (!fs.is_open()) {
-      DLOGI("File open failed %s", dump_file_name.str().c_str());
-      return;
-    }
-
-    fs.write(buffer, (std::streamsize)buffer_info_.alloc_buffer_info.size);
-    fs.close();
-
-    DLOGI("Frame Dump %s: is successful", dump_file_name.str().c_str());
-  }
-
-  // Dump only once as the content is going to be same for all draw cycles
-  if (dump_frame_count_) {
-    dump_frame_count_ = 0;
-  }
-
-  if (munmap(buffer, buffer_info_.alloc_buffer_info.size) != 0) {
-    DLOGW("munmap failed. err = %d", errno);
-    return;
-  }
-}
-
-void HWCDisplayExternalTest::CalcCRC(uint32_t color_val, std::bitset<16> *crc_data) {
-  std::bitset<16> color = {};
-  std::bitset<16> temp_crc = {};
-
-  switch (panel_bpp_) {
-    case kDisplayBpp18:
-      color = (color_val & 0xFC) << 8;
-      break;
-    case kDisplayBpp24:
-      color = color_val << 8;
-      break;
-    case kDisplayBpp30:
-      color = color_val << 6;
-      break;
-    default:
-      return;
-  }
-
-  temp_crc[15] = (*crc_data)[0] ^ (*crc_data)[1] ^ (*crc_data)[2] ^ (*crc_data)[3] ^
-                 (*crc_data)[4] ^ (*crc_data)[5] ^ (*crc_data)[6] ^ (*crc_data)[7] ^
-                 (*crc_data)[8] ^ (*crc_data)[9] ^ (*crc_data)[10] ^ (*crc_data)[11] ^
-                 (*crc_data)[12] ^ (*crc_data)[14] ^ (*crc_data)[15] ^ color[0] ^ color[1] ^
-                 color[2] ^ color[3] ^ color[4] ^ color[5] ^ color[6] ^ color[7] ^ color[8] ^
-                 color[9] ^ color[10] ^ color[11] ^ color[12] ^ color[14] ^ color[15];
-
-  temp_crc[14] = (*crc_data)[12] ^ (*crc_data)[13] ^ color[12] ^ color[13];
-  temp_crc[13] = (*crc_data)[11] ^ (*crc_data)[12] ^ color[11] ^ color[12];
-  temp_crc[12] = (*crc_data)[10] ^ (*crc_data)[11] ^ color[10] ^ color[11];
-  temp_crc[11] = (*crc_data)[9] ^ (*crc_data)[10] ^ color[9] ^ color[10];
-  temp_crc[10] = (*crc_data)[8] ^ (*crc_data)[9] ^ color[8] ^ color[9];
-  temp_crc[9] = (*crc_data)[7] ^ (*crc_data)[8] ^ color[7] ^ color[8];
-  temp_crc[8] = (*crc_data)[6] ^ (*crc_data)[7] ^ color[6] ^ color[7];
-  temp_crc[7] = (*crc_data)[5] ^ (*crc_data)[6] ^ color[5] ^ color[6];
-  temp_crc[6] = (*crc_data)[4] ^ (*crc_data)[5] ^ color[4] ^ color[5];
-  temp_crc[5] = (*crc_data)[3] ^ (*crc_data)[4] ^ color[3] ^ color[4];
-  temp_crc[4] = (*crc_data)[2] ^ (*crc_data)[3] ^ color[2] ^ color[3];
-  temp_crc[3] = (*crc_data)[1] ^ (*crc_data)[2] ^ (*crc_data)[15] ^ color[1] ^ color[2] ^ color[15];
-  temp_crc[2] = (*crc_data)[0] ^ (*crc_data)[1] ^ (*crc_data)[14] ^ color[0] ^ color[1] ^ color[14];
-
-  temp_crc[1] = (*crc_data)[1] ^ (*crc_data)[2] ^ (*crc_data)[3] ^ (*crc_data)[4] ^ (*crc_data)[5] ^
-                (*crc_data)[6] ^ (*crc_data)[7] ^ (*crc_data)[8] ^ (*crc_data)[9] ^
-                (*crc_data)[10] ^ (*crc_data)[11] ^ (*crc_data)[12] ^ (*crc_data)[13] ^
-                (*crc_data)[14] ^ color[1] ^ color[2] ^ color[3] ^ color[4] ^ color[5] ^ color[6] ^
-                color[7] ^ color[8] ^ color[9] ^ color[10] ^ color[11] ^ color[12] ^ color[13] ^
-                color[14];
-
-  temp_crc[0] = (*crc_data)[0] ^ (*crc_data)[1] ^ (*crc_data)[2] ^ (*crc_data)[3] ^ (*crc_data)[4] ^
-                (*crc_data)[5] ^ (*crc_data)[6] ^ (*crc_data)[7] ^ (*crc_data)[8] ^ (*crc_data)[9] ^
-                (*crc_data)[10] ^ (*crc_data)[11] ^ (*crc_data)[12] ^ (*crc_data)[13] ^
-                (*crc_data)[15] ^ color[0] ^ color[1] ^ color[2] ^ color[3] ^ color[4] ^ color[5] ^
-                color[6] ^ color[7] ^ color[8] ^ color[9] ^ color[10] ^ color[11] ^ color[12] ^
-                color[13] ^ color[15];
-
-  (*crc_data) = temp_crc;
-}
-
-int HWCDisplayExternalTest::FillBuffer() {
-  uint8_t *buffer = reinterpret_cast<uint8_t *>(mmap(NULL, buffer_info_.alloc_buffer_info.size,
-                                                PROT_READ|PROT_WRITE, MAP_SHARED,
-                                                buffer_info_.alloc_buffer_info.fd, 0));
-  if (buffer == MAP_FAILED) {
-    DLOGE("mmap failed. err = %d", errno);
-    return -EFAULT;
-  }
-
-  switch (pattern_type_) {
-    case kPatternColorRamp:
-      GenerateColorRamp(buffer);
-      break;
-    case kPatternBWVertical:
-      GenerateBWVertical(buffer);
-      break;
-    case kPatternColorSquare:
-      GenerateColorSquare(buffer);
-      break;
-    default:
-      DLOGW("Invalid Pattern type %d", pattern_type_);
-      return -EINVAL;
-  }
-
-  if (munmap(buffer, buffer_info_.alloc_buffer_info.size) != 0) {
-    DLOGE("munmap failed. err = %d", errno);
-    return -EFAULT;
-  }
-
-  return 0;
-}
-
-int HWCDisplayExternalTest::GetStride(LayerBufferFormat format, uint32_t width, uint32_t *stride) {
-  switch (format) {
-  case kFormatRGBA8888:
-  case kFormatRGBA1010102:
-    *stride = width * 4;
-    break;
-  case kFormatRGB888:
-    *stride = width * 3;
-    break;
-  default:
-    DLOGE("Unsupported format type %d", format);
-    return -EINVAL;
-  }
-
-  return 0;
-}
-
-void HWCDisplayExternalTest::PixelCopy(uint32_t red, uint32_t green, uint32_t blue, uint32_t alpha,
-                                       uint8_t **buffer) {
-  LayerBufferFormat format = buffer_info_.buffer_config.format;
-
-  switch (format) {
-    case kFormatRGBA8888:
-      *(*buffer)++ = UINT8(red & 0xFF);
-      *(*buffer)++ = UINT8(green & 0xFF);
-      *(*buffer)++ = UINT8(blue & 0xFF);
-      *(*buffer)++ = UINT8(alpha & 0xFF);
-      break;
-    case kFormatRGB888:
-      *(*buffer)++ = UINT8(red & 0xFF);
-      *(*buffer)++ = UINT8(green & 0xFF);
-      *(*buffer)++ = UINT8(blue & 0xFF);
-      break;
-    case kFormatRGBA1010102:
-      // Lower 8 bits of red
-      *(*buffer)++ = UINT8(red & 0xFF);
-
-      // Upper 2 bits of Red + Lower 6 bits of green
-      *(*buffer)++ = UINT8(((green & 0x3F) << 2) | ((red >> 0x8) & 0x3));
-
-      // Upper 4 bits of green + Lower 4 bits of blue
-      *(*buffer)++ = UINT8(((blue & 0xF) << 4) | ((green >> 6) & 0xF));
-
-      // Upper 6 bits of blue + Lower 2 bits of alpha
-      *(*buffer)++ = UINT8(((alpha & 0x3) << 6) | ((blue >> 4) & 0x3F));
-      break;
-    default:
-      DLOGW("format not supported format = %d", format);
-      break;
-  }
-}
-
-void HWCDisplayExternalTest::GenerateColorRamp(uint8_t *buffer) {
-  uint32_t width = buffer_info_.buffer_config.width;
-  uint32_t height = buffer_info_.buffer_config.height;
-  LayerBufferFormat format = buffer_info_.buffer_config.format;
-  uint32_t aligned_width = buffer_info_.alloc_buffer_info.aligned_width;
-  uint32_t buffer_stride = 0;
-
-  uint32_t color_ramp = 0;
-  uint32_t start_color_val = 0;
-  uint32_t step_size = 1;
-  uint32_t ramp_width = 0;
-  uint32_t ramp_height = 0;
-  uint32_t shift_by = 0;
-
-  std::bitset<16> crc_red = {};
-  std::bitset<16> crc_green = {};
-  std::bitset<16> crc_blue = {};
-
-  switch (panel_bpp_) {
-    case kDisplayBpp18:
-      ramp_height = 64;
-      ramp_width = 64;
-      shift_by = 2;
-      break;
-    case kDisplayBpp24:
-      ramp_height = 64;
-      ramp_width = 256;
-      break;
-    case kDisplayBpp30:
-      ramp_height = 32;
-      ramp_width = 256;
-      start_color_val = 0x180;
-      break;
-    default:
-      return;
-  }
-
-  GetStride(format, aligned_width, &buffer_stride);
-
-  for (uint32_t loop_height = 0; loop_height < height; loop_height++) {
-    uint32_t color_value = start_color_val;
-    uint8_t *temp = buffer + (loop_height * buffer_stride);
-
-    for (uint32_t loop_width = 0; loop_width < width; loop_width++) {
-      if (color_ramp == kColorRedRamp) {
-        PixelCopy(color_value, 0, 0, 0, &temp);
-        CalcCRC(color_value, &crc_red);
-        CalcCRC(0, &crc_green);
-        CalcCRC(0, &crc_blue);
-      }
-      if (color_ramp == kColorGreenRamp) {
-        PixelCopy(0, color_value, 0, 0, &temp);
-        CalcCRC(0, &crc_red);
-        CalcCRC(color_value, &crc_green);
-        CalcCRC(0, &crc_blue);
-      }
-      if (color_ramp == kColorBlueRamp) {
-        PixelCopy(0, 0, color_value, 0, &temp);
-        CalcCRC(0, &crc_red);
-        CalcCRC(0, &crc_green);
-        CalcCRC(color_value, &crc_blue);
-      }
-      if (color_ramp == kColorWhiteRamp) {
-        PixelCopy(color_value, color_value, color_value, 0, &temp);
-        CalcCRC(color_value, &crc_red);
-        CalcCRC(color_value, &crc_green);
-        CalcCRC(color_value, &crc_blue);
-      }
-
-      color_value = (start_color_val + (((loop_width + 1) % ramp_width) * step_size)) << shift_by;
-    }
-
-    if (panel_bpp_ == kDisplayBpp30 && ((loop_height + 1) % ramp_height) == 0) {
-      if (start_color_val == 0x180) {
-        start_color_val = 0;
-        step_size = 4;
-      } else {
-        start_color_val = 0x180;
-        step_size = 1;
-        color_ramp = (color_ramp + 1) % 4;
-      }
-      continue;
-    }
-
-    if (((loop_height + 1) % ramp_height) == 0) {
-      color_ramp = (color_ramp + 1) % 4;
-    }
-  }
-
-  DLOGI("CRC red %x", crc_red.to_ulong());
-  DLOGI("CRC green %x", crc_green.to_ulong());
-  DLOGI("CRC blue %x", crc_blue.to_ulong());
-}
-
-void HWCDisplayExternalTest::GenerateBWVertical(uint8_t *buffer) {
-  uint32_t width = buffer_info_.buffer_config.width;
-  uint32_t height = buffer_info_.buffer_config.height;
-  LayerBufferFormat format = buffer_info_.buffer_config.format;
-  uint32_t aligned_width = buffer_info_.alloc_buffer_info.aligned_width;
-  uint32_t buffer_stride = 0;
-  uint32_t bits_per_component = panel_bpp_ / 3;
-  uint32_t max_color_val = (1 << bits_per_component) - 1;
-
-  std::bitset<16> crc_red = {};
-  std::bitset<16> crc_green = {};
-  std::bitset<16> crc_blue = {};
-
-  if (panel_bpp_ == kDisplayBpp18) {
-    max_color_val <<= 2;
-  }
-
-  GetStride(format, aligned_width, &buffer_stride);
-
-  for (uint32_t loop_height = 0; loop_height < height; loop_height++) {
-    uint32_t color = 0;
-    uint8_t *temp = buffer + (loop_height * buffer_stride);
-
-    for (uint32_t loop_width = 0; loop_width < width; loop_width++) {
-      if (color == kColorBlack) {
-        PixelCopy(0, 0, 0, 0, &temp);
-        CalcCRC(0, &crc_red);
-        CalcCRC(0, &crc_green);
-        CalcCRC(0, &crc_blue);
-      }
-      if (color == kColorWhite) {
-        PixelCopy(max_color_val, max_color_val, max_color_val, 0, &temp);
-        CalcCRC(max_color_val, &crc_red);
-        CalcCRC(max_color_val, &crc_green);
-        CalcCRC(max_color_val, &crc_blue);
-      }
-
-      color = (color + 1) % 2;
-    }
-  }
-
-  DLOGI("CRC red %x", crc_red.to_ulong());
-  DLOGI("CRC green %x", crc_green.to_ulong());
-  DLOGI("CRC blue %x", crc_blue.to_ulong());
-}
-
-void HWCDisplayExternalTest::GenerateColorSquare(uint8_t *buffer) {
-  uint32_t width = buffer_info_.buffer_config.width;
-  uint32_t height = buffer_info_.buffer_config.height;
-  LayerBufferFormat format = buffer_info_.buffer_config.format;
-  uint32_t aligned_width = buffer_info_.alloc_buffer_info.aligned_width;
-  uint32_t buffer_stride = 0;
-  uint32_t max_color_val = 0;
-  uint32_t min_color_val = 0;
-
-  std::bitset<16> crc_red = {};
-  std::bitset<16> crc_green = {};
-  std::bitset<16> crc_blue = {};
-
-  switch (panel_bpp_) {
-    case kDisplayBpp18:
-      max_color_val = 63 << 2;  // CEA Dynamic range for 18bpp 0 - 63
-      min_color_val = 0;
-      break;
-    case kDisplayBpp24:
-      max_color_val = 235;  // CEA Dynamic range for 24bpp 16 - 235
-      min_color_val = 16;
-      break;
-    case kDisplayBpp30:
-      max_color_val = 940;  // CEA Dynamic range for 30bpp 64 - 940
-      min_color_val = 64;
-      break;
-    default:
-      return;
-  }
-
-  array<array<uint32_t, 3>, 8> colors = {{
-    {{max_color_val, max_color_val, max_color_val}},  // White Color
-    {{max_color_val, max_color_val, min_color_val}},  // Yellow Color
-    {{min_color_val, max_color_val, max_color_val}},  // Cyan Color
-    {{min_color_val, max_color_val, min_color_val}},  // Green Color
-    {{max_color_val, min_color_val, max_color_val}},  // Megenta Color
-    {{max_color_val, min_color_val, min_color_val}},  // Red Color
-    {{min_color_val, min_color_val, max_color_val}},  // Blue Color
-    {{min_color_val, min_color_val, min_color_val}},  // Black Color
-  }};
-
-  GetStride(format, aligned_width, &buffer_stride);
-
-  for (uint32_t loop_height = 0; loop_height < height; loop_height++) {
-    uint32_t color = 0;
-    uint8_t *temp = buffer + (loop_height * buffer_stride);
-
-    for (uint32_t loop_width = 0; loop_width < width; loop_width++) {
-      PixelCopy(colors[color][0], colors[color][1], colors[color][2], 0, &temp);
-      CalcCRC(colors[color][0], &crc_red);
-      CalcCRC(colors[color][1], &crc_green);
-      CalcCRC(colors[color][2], &crc_blue);
-
-      if (((loop_width + 1) % 64) == 0) {
-        color = (color + 1) % colors.size();
-      }
-    }
-
-    if (((loop_height + 1) % 64) == 0) {
-      std::reverse(colors.begin(), (colors.end() - 1));
-    }
-  }
-
-  DLOGI("CRC red %x", crc_red.to_ulong());
-  DLOGI("CRC green %x", crc_green.to_ulong());
-  DLOGI("CRC blue %x", crc_blue.to_ulong());
-}
-
-int HWCDisplayExternalTest::InitLayer(Layer *layer) {
-  uint32_t active_config = 0;
-  DisplayConfigVariableInfo var_info = {};
-
-  GetActiveDisplayConfig(&active_config);
-
-  GetDisplayAttributesForConfig(INT32(active_config), &var_info);
-
-  layer->flags.updating = 1;
-  layer->src_rect = LayerRect(0, 0, var_info.x_pixels, var_info.y_pixels);
-  layer->dst_rect = layer->src_rect;
-  layer->frame_rate = var_info.fps;
-  layer->blending = kBlendingPremultiplied;
-
-  layer->input_buffer.unaligned_width = var_info.x_pixels;
-  layer->input_buffer.unaligned_height = var_info.y_pixels;
-  buffer_info_.buffer_config.format = kFormatRGBA8888;
-
-  if (layer->composition != kCompositionGPUTarget) {
-    buffer_info_.buffer_config.width = var_info.x_pixels;
-    buffer_info_.buffer_config.height = var_info.y_pixels;
-    switch (panel_bpp_) {
-      case kDisplayBpp18:
-      case kDisplayBpp24:
-        buffer_info_.buffer_config.format = kFormatRGB888;
-        break;
-      case kDisplayBpp30:
-        buffer_info_.buffer_config.format = kFormatRGBA1010102;
-        break;
-      default:
-        DLOGW("panel bpp not supported %d", panel_bpp_);
-        return -EINVAL;
-    }
-    buffer_info_.buffer_config.buffer_count = 1;
-
-    int ret = buffer_allocator_->AllocateBuffer(&buffer_info_);
-    if (ret != 0) {
-      DLOGE("Buffer allocation failed. ret: %d", ret);
-      return -ENOMEM;
-    }
-
-    ret = FillBuffer();
-    if (ret != 0) {
-      buffer_allocator_->FreeBuffer(&buffer_info_);
-      return ret;
-    }
-
-    layer->input_buffer.width = buffer_info_.alloc_buffer_info.aligned_width;
-    layer->input_buffer.height = buffer_info_.alloc_buffer_info.aligned_height;
-    layer->input_buffer.size = buffer_info_.alloc_buffer_info.size;
-    layer->input_buffer.planes[0].fd = buffer_info_.alloc_buffer_info.fd;
-    layer->input_buffer.planes[0].stride = buffer_info_.alloc_buffer_info.stride;
-    layer->input_buffer.format = buffer_info_.buffer_config.format;
-
-    DLOGI("Input buffer WxH %dx%d format %s size %d fd %d stride %d", layer->input_buffer.width,
-          layer->input_buffer.height, GetFormatString(layer->input_buffer.format),
-          layer->input_buffer.size, layer->input_buffer.planes[0].fd,
-          layer->input_buffer.planes[0].stride);
-  }
-
-  return 0;
-}
-
-int HWCDisplayExternalTest::DeinitLayer(Layer *layer) {
-  if (layer->composition != kCompositionGPUTarget) {
-    int ret = buffer_allocator_->FreeBuffer(&buffer_info_);
-    if (ret != 0) {
-      DLOGE("Buffer deallocation failed. ret: %d", ret);
-      return -ENOMEM;
-    }
-  }
-
-  return 0;
-}
-
-int HWCDisplayExternalTest::CreateLayerStack() {
-  for (uint32_t i = 0; i < (kTestLayerCnt + 1 /* one dummy gpu_target layer */); i++) {
-    Layer *layer = new Layer();
-
-    if (i == kTestLayerCnt) {
-      layer->composition = kCompositionGPUTarget;
-    }
-
-    int ret = InitLayer(layer);
-    if (ret != 0) {
-      delete layer;
-      return ret;
-    }
-    layer_stack_.layers.push_back(layer);
-  }
-
-  return 0;
-}
-
-int HWCDisplayExternalTest::DestroyLayerStack() {
-  for (uint32_t i = 0; i < UINT32(layer_stack_.layers.size()); i++) {
-    Layer *layer = layer_stack_.layers.at(i);
-    int ret = DeinitLayer(layer);
-    if (ret != 0) {
-      return ret;
-    }
-
-    delete layer;
-  }
-
-  layer_stack_.layers = {};
-
-  return 0;
-}
-
-int HWCDisplayExternalTest::PostCommit(hwc_display_contents_1_t *content_list) {
-  int status = 0;
-
-  // Do no call flush on errors, if a successful buffer is never submitted.
-  if (flush_ && flush_on_error_) {
-    display_intf_->Flush();
-  }
-
-  if (!flush_) {
-    for (size_t i = 0; i < layer_stack_.layers.size(); i++) {
-      Layer *layer = layer_stack_.layers.at(i);
-      LayerBuffer &layer_buffer = layer->input_buffer;
-
-      close(layer_buffer.release_fence_fd);
-      layer_buffer.release_fence_fd = -1;
-    }
-
-    close(layer_stack_.retire_fence_fd);
-    layer_stack_.retire_fence_fd = -1;
-    content_list->retireFenceFd = -1;
-  }
-
-  flush_ = false;
-
-  return status;
-}
-
-}  // namespace sdm
-
diff --git a/sdm/libs/hwc/hwc_display_external_test.h b/sdm/libs/hwc/hwc_display_external_test.h
deleted file mode 100644
index 050823e..0000000
--- a/sdm/libs/hwc/hwc_display_external_test.h
+++ /dev/null
@@ -1,102 +0,0 @@
-/*
-* Copyright (c) 2017, 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_DISPLAY_EXTERNAL_TEST_H__
-#define __HWC_DISPLAY_EXTERNAL_TEST_H__
-
-#include<bitset>
-
-#include "hwc_display.h"
-#include "hwc_buffer_allocator.h"
-
-namespace sdm {
-
-class HWCDisplayExternalTest : public HWCDisplay {
- public:
-  static int Create(CoreInterface *core_intf, hwc_procs_t const **hwc_procs,
-                     qService::QService *qservice,  uint32_t panel_bpp, uint32_t pattern_type,
-                     HWCDisplay **hwc_display);
-  static void Destroy(HWCDisplay *hwc_display);
-  virtual int Prepare(hwc_display_contents_1_t *content_list);
-  virtual int Commit(hwc_display_contents_1_t *content_list);
-  virtual void SetSecureDisplay(bool secure_display_active, bool force_flush);
-  virtual int Perform(uint32_t operation, ...);
-
- protected:
-  HWCBufferAllocator *buffer_allocator_ = NULL;
-  BufferInfo buffer_info_ = {};
-  uint32_t panel_bpp_ = 0;
-  uint32_t pattern_type_ = 0;
-
-  enum ColorPatternType {
-    kPatternNone = 0,
-    kPatternColorRamp,
-    kPatternBWVertical,
-    kPatternColorSquare,
-  };
-
-  enum DisplayBpp {
-    kDisplayBpp18 = 18,
-    kDisplayBpp24 = 24,
-    kDisplayBpp30 = 30,
-  };
-
-  enum ColorRamp {
-    kColorRedRamp = 0,
-    kColorGreenRamp = 1,
-    kColorBlueRamp = 2,
-    kColorWhiteRamp = 3,
-  };
-
-  enum Colors {
-    kColorBlack = 0,
-    kColorWhite = 1,
-  };
-
- private:
-  HWCDisplayExternalTest(CoreInterface *core_intf, hwc_procs_t const **hwc_procs,
-                         qService::QService *qservice, uint32_t panel_bpp, uint32_t pattern_type);
-  int Init();
-  int Deinit();
-  void DumpInputBuffer();
-  void CalcCRC(uint32_t color_value, std::bitset<16> *crc_data);
-  int FillBuffer();
-  int GetStride(LayerBufferFormat format, uint32_t width, uint32_t *stride);
-  void PixelCopy(uint32_t red, uint32_t green, uint32_t blue, uint32_t alpha, uint8_t **buffer);
-  void GenerateColorRamp(uint8_t *buffer);
-  void GenerateBWVertical(uint8_t *buffer);
-  void GenerateColorSquare(uint8_t *buffer);
-  int InitLayer(Layer *layer);
-  int DeinitLayer(Layer *layer);
-  int CreateLayerStack();
-  int DestroyLayerStack();
-  int PostCommit(hwc_display_contents_1_t *content_list);
-
-  static const uint32_t kTestLayerCnt = 1;
-};
-
-}  // namespace sdm
-
-#endif  // __HWC_DISPLAY_EXTERNAL_TEST_H__
-
diff --git a/sdm/libs/hwc/hwc_display_null.cpp b/sdm/libs/hwc/hwc_display_null.cpp
deleted file mode 100644
index 649f40c..0000000
--- a/sdm/libs/hwc/hwc_display_null.cpp
+++ /dev/null
@@ -1,120 +0,0 @@
-/*
-* Copyright (c) 2016, 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.
-*/
-
-#include <hardware/hwcomposer_defs.h>
-#include <utils/constants.h>
-#include <utils/debug.h>
-#include "hwc_display_null.h"
-
-#define __CLASS__ "HWCDisplayNull"
-
-namespace sdm {
-
-int HWCDisplayNull::Create(CoreInterface *core_intf, hwc_procs_t const **hwc_procs,
-                           HWCDisplay **hwc_display) {
-  int status;
-
-  DLOGI("Null display is being created");
-  HWCDisplayNull *hwc_display_null = new HWCDisplayNull(core_intf, hwc_procs);
-
-  status = hwc_display_null->Init();
-  if (status) {
-    delete hwc_display_null;
-    return status;
-  }
-
-  *hwc_display = hwc_display_null;
-
-  return 0;
-}
-
-void HWCDisplayNull::Destroy(HWCDisplay *hwc_display) {
-  DLOGI("Null display is being destroyed");
-  hwc_display->Deinit();
-  delete hwc_display;
-}
-
-// We pass the display type as HWC_DISPLAY_PRIMARY to HWCDisplay, but since we override
-// and don't chain to HWCDisplay::Init(), that type does not actually get used.
-HWCDisplayNull::HWCDisplayNull(CoreInterface *core_intf, hwc_procs_t const **hwc_procs)
-  : HWCDisplay(core_intf, hwc_procs, kPrimary, HWC_DISPLAY_PRIMARY, false, NULL,
-               DISPLAY_CLASS_NULL) {
-}
-
-int HWCDisplayNull::Init() {
-  // Don't call HWCDisplay::Init() for null display, we don't want the chain of
-  // DisplayPrimary / HWPrimary etc objects to be created.
-  return 0;
-}
-
-int HWCDisplayNull::Deinit() {
-  return 0;
-}
-
-int HWCDisplayNull::Prepare(hwc_display_contents_1_t *content_list) {
-  for (size_t i = 0; i < content_list->numHwLayers; i++) {
-    if (content_list->hwLayers[i].compositionType == HWC_FRAMEBUFFER_TARGET ||
-        content_list->hwLayers[i].compositionType == HWC_BACKGROUND) {
-      continue;
-    }
-
-    content_list->hwLayers[i].compositionType = HWC_OVERLAY;
-  }
-
-  return 0;
-}
-
-int HWCDisplayNull::Commit(hwc_display_contents_1_t *content_list) {
-  // HWCSession::Commit (from where this is called) already closes all the acquire
-  // fences once we return from here. So no need to close acquire fences here.
-  for (size_t i = 0; i < content_list->numHwLayers; i++) {
-    content_list->hwLayers[i].releaseFenceFd = -1;
-  }
-
-  return 0;
-}
-
-#define NULL_DISPLAY_FPS 60
-
-int HWCDisplayNull::GetDisplayAttributes(uint32_t config, const uint32_t *display_attributes,
-                                         int32_t *values) {
-  for (int i = 0; display_attributes[i] != HWC_DISPLAY_NO_ATTRIBUTE; i++) {
-    // We fake display resolution as 1080P by default, though it can be overriden through a call to
-    // SetResolution(), and DPI as 160, though what the DPI value does is not clear
-    switch (display_attributes[i]) {
-    case HWC_DISPLAY_VSYNC_PERIOD:
-      values[i] = INT32(1000000000L / NULL_DISPLAY_FPS);
-      break;
-    case HWC_DISPLAY_WIDTH:
-      values[i] = static_cast<int32_t>(x_res_);
-      break;
-    case HWC_DISPLAY_HEIGHT:
-      values[i] = static_cast<int32_t>(y_res_);
-      break;
-    }
-  }
-  return 0;
-}
-
-}  // namespace sdm
diff --git a/sdm/libs/hwc/hwc_display_null.h b/sdm/libs/hwc/hwc_display_null.h
deleted file mode 100644
index f1e0e5e..0000000
--- a/sdm/libs/hwc/hwc_display_null.h
+++ /dev/null
@@ -1,106 +0,0 @@
-/*
-* Copyright (c) 2016, 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_DISPLAY_NULL_H__
-#define __HWC_DISPLAY_NULL_H__
-
-#include <qdMetaData.h>
-#include <gralloc_priv.h>
-#include "hwc_display.h"
-
-namespace sdm {
-
-class HWCDisplayNull : public HWCDisplay {
- public:
-  static int Create(CoreInterface *core_intf, hwc_procs_t const **hwc_procs,
-                    HWCDisplay **hwc_display);
-  static void Destroy(HWCDisplay *hwc_display);
-  virtual int Init();
-  virtual int Deinit();
-  virtual int Prepare(hwc_display_contents_1_t *content_list);
-  virtual int Commit(hwc_display_contents_1_t *content_list);
-  virtual int EventControl(int event, int enable) { return 0; }
-  virtual int SetPowerMode(int mode) { return 0; }
-
-  // Framebuffer configurations
-  virtual int GetDisplayConfigs(uint32_t *configs, size_t *num_configs) {
-    return HWCDisplay::GetDisplayConfigs(configs, num_configs);
-  }
-
-  virtual int GetDisplayAttributes(uint32_t config, const uint32_t *display_attributes,
-                                   int32_t *values);
-  virtual int GetActiveConfig() { return 0; }
-  virtual int SetActiveConfig(int index) { return -1; }
-
-  virtual void SetIdleTimeoutMs(uint32_t timeout_ms) { return; }
-  virtual void SetFrameDumpConfig(uint32_t count, uint32_t bit_mask_layer_type) { return; }
-  virtual DisplayError SetMaxMixerStages(uint32_t max_mixer_stages) { return kErrorNone; }
-  virtual DisplayError ControlPartialUpdate(bool enable, uint32_t *pending) { return kErrorNone; }
-  virtual uint32_t GetLastPowerMode() { return 0; }
-  virtual int SetFrameBufferResolution(uint32_t x_pixels, uint32_t y_pixels) { return 0; }
-
-  virtual void GetFrameBufferResolution(uint32_t *x_pixels, uint32_t *y_pixels) {
-    *x_pixels = x_res_;
-    *y_pixels = y_res_;
-  }
-
-  virtual void GetPanelResolution(uint32_t *x_pixels, uint32_t *y_pixels) {
-    *x_pixels = x_res_;
-    *y_pixels = y_res_;
-  }
-
-  virtual int SetDisplayStatus(uint32_t display_status) { return 0; }
-  virtual int OnMinHdcpEncryptionLevelChange(uint32_t min_enc_level) { return 0; }
-  virtual int Perform(uint32_t operation, ...) { return 0; }
-  virtual int SetCursorPosition(int x, int y) { return 0; }
-  virtual void SetSecureDisplay(bool secure_display_active, bool force_flush) { return; }
-
-  // Display Configurations
-  virtual int SetActiveDisplayConfig(int config) { return 0; }
-  virtual int GetActiveDisplayConfig(uint32_t *config) { return -1; }
-  virtual int GetDisplayConfigCount(uint32_t *count) { return -1; }
-  virtual int GetDisplayAttributesForConfig(int config,
-                                            DisplayConfigVariableInfo *display_attributes) {
-    return -1;
-  }
-  virtual bool IsValidContentList(hwc_display_contents_1_t *content_list) {
-    return true;
-  }
-
-  void SetResolution(uint32_t x_res, uint32_t y_res) {
-    x_res_ = x_res;
-    y_res_ = y_res;
-  }
-
-
- private:
-  HWCDisplayNull(CoreInterface *core_intf, hwc_procs_t const **hwc_procs);
-  uint32_t x_res_ = 1920;
-  uint32_t y_res_ = 1080;
-};
-
-}  // namespace sdm
-
-#endif  // __HWC_DISPLAY_NULL_H__
-
diff --git a/sdm/libs/hwc/hwc_display_primary.cpp b/sdm/libs/hwc/hwc_display_primary.cpp
deleted file mode 100644
index 8d6f31b..0000000
--- a/sdm/libs/hwc/hwc_display_primary.cpp
+++ /dev/null
@@ -1,563 +0,0 @@
-/*
-* Copyright (c) 2014 - 2017, 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.
-*/
-
-#include <cutils/properties.h>
-#include <sync/sync.h>
-#include <utils/constants.h>
-#include <utils/debug.h>
-#include <stdarg.h>
-#include <sys/mman.h>
-
-#include <gr.h>
-#include "hwc_display_primary.h"
-#include "hwc_debugger.h"
-
-#define __CLASS__ "HWCDisplayPrimary"
-
-namespace sdm {
-
-int HWCDisplayPrimary::Create(CoreInterface *core_intf, BufferAllocator *buffer_allocator,
-                              hwc_procs_t const **hwc_procs, qService::QService *qservice,
-                              HWCDisplay **hwc_display) {
-  int status = 0;
-  uint32_t primary_width = 0;
-  uint32_t primary_height = 0;
-
-  HWCDisplay *hwc_display_primary = new HWCDisplayPrimary(core_intf, buffer_allocator,
-                                                          hwc_procs, qservice);
-  status = hwc_display_primary->Init();
-  if (status) {
-    delete hwc_display_primary;
-    return status;
-  }
-
-  hwc_display_primary->GetMixerResolution(&primary_width, &primary_height);
-  int width = 0, height = 0;
-  HWCDebugHandler::Get()->GetProperty("sdm.fb_size_width", &width);
-  HWCDebugHandler::Get()->GetProperty("sdm.fb_size_height", &height);
-  if (width > 0 && height > 0) {
-    primary_width = UINT32(width);
-    primary_height = UINT32(height);
-  }
-
-  status = hwc_display_primary->SetFrameBufferResolution(primary_width, primary_height);
-  if (status) {
-    Destroy(hwc_display_primary);
-    return status;
-  }
-
-  *hwc_display = hwc_display_primary;
-
-  return status;
-}
-
-void HWCDisplayPrimary::Destroy(HWCDisplay *hwc_display) {
-  hwc_display->Deinit();
-  delete hwc_display;
-}
-
-HWCDisplayPrimary::HWCDisplayPrimary(CoreInterface *core_intf,
-                                     BufferAllocator *buffer_allocator,
-                                     hwc_procs_t const **hwc_procs,
-                                     qService::QService *qservice)
-  : HWCDisplay(core_intf, hwc_procs, kPrimary, HWC_DISPLAY_PRIMARY, true, qservice,
-               DISPLAY_CLASS_PRIMARY), buffer_allocator_(buffer_allocator) {
-}
-
-int HWCDisplayPrimary::Init() {
-  cpu_hint_.Init(static_cast<HWCDebugHandler*>(HWCDebugHandler::Get()));
-
-  use_metadata_refresh_rate_ = true;
-  int disable_metadata_dynfps = 0;
-  HWCDebugHandler::Get()->GetProperty("persist.metadata_dynfps.disable", &disable_metadata_dynfps);
-  if (disable_metadata_dynfps) {
-    use_metadata_refresh_rate_ = false;
-  }
-
-  int status = HWCDisplay::Init();
-  if (status) {
-    return status;
-  }
-  color_mode_ = new HWCColorMode(display_intf_);
-  color_mode_->Init();
-
-  return status;
-}
-
-int HWCDisplayPrimary::Deinit() {
-  color_mode_->DeInit();
-  delete color_mode_;
-  color_mode_ = NULL;
-
-  return HWCDisplay::Deinit();
-}
-
-
-void HWCDisplayPrimary::ProcessBootAnimCompleted(hwc_display_contents_1_t *list) {
-  uint32_t numBootUpLayers = 0;
-
-  numBootUpLayers = static_cast<uint32_t>(Debug::GetBootAnimLayerCount());
-
-  if (numBootUpLayers == 0) {
-    numBootUpLayers = 2;
-  }
-  /* All other checks namely "init.svc.bootanim" or
-  * HWC_GEOMETRY_CHANGED fail in correctly identifying the
-  * exact bootup transition to homescreen
-  */
-  char cryptoState[PROPERTY_VALUE_MAX];
-  char voldDecryptState[PROPERTY_VALUE_MAX];
-  bool isEncrypted = false;
-  bool main_class_services_started = false;
-  if (property_get("ro.crypto.state", cryptoState, "unencrypted")) {
-    if (!strcmp(cryptoState, "encrypted")) {
-      isEncrypted = true;
-      if (property_get("vold.decrypt", voldDecryptState, "") &&
-            !strcmp(voldDecryptState, "trigger_restart_framework"))
-        main_class_services_started = true;
-    }
-  }
-  if ((!isEncrypted ||(isEncrypted && main_class_services_started)) &&
-    (list->numHwLayers > numBootUpLayers)) {
-    boot_animation_completed_ = true;
-    // Applying default mode after bootanimation is finished And
-    // If Data is Encrypted, it is ready for access.
-    if (display_intf_)
-      display_intf_->ApplyDefaultDisplayMode();
-  }
-}
-
-int HWCDisplayPrimary::Prepare(hwc_display_contents_1_t *content_list) {
-  int status = 0;
-  DisplayError error = kErrorNone;
-
-  if (!boot_animation_completed_)
-    ProcessBootAnimCompleted(content_list);
-
-  if (display_paused_) {
-    MarkLayersForGPUBypass(content_list);
-    return status;
-  }
-
-  status = AllocateLayerStack(content_list);
-  if (status) {
-    return status;
-  }
-
-  status = PrePrepareLayerStack(content_list);
-  if (status) {
-    return status;
-  }
-
-  bool pending_output_dump = dump_frame_count_ && dump_output_to_file_;
-
-  if (frame_capture_buffer_queued_ || pending_output_dump) {
-    // RHS values were set in FrameCaptureAsync() called from a binder thread. They are picked up
-    // here in a subsequent draw round.
-    layer_stack_.output_buffer = &output_buffer_;
-    layer_stack_.flags.post_processed_output = post_processed_output_;
-  }
-
-  uint32_t num_updating_layers = GetUpdatingLayersCount(UINT32(content_list->numHwLayers - 1));
-  bool one_updating_layer = (num_updating_layers == 1);
-
-  if (num_updating_layers != 0) {
-    ToggleCPUHint(one_updating_layer);
-  }
-
-  uint32_t refresh_rate = GetOptimalRefreshRate(one_updating_layer);
-  bool final_rate = force_refresh_rate_ ? true : false;
-  error = display_intf_->SetRefreshRate(refresh_rate, final_rate);
-  if (error == kErrorNone) {
-    // On success, set current refresh rate to new refresh rate
-    current_refresh_rate_ = refresh_rate;
-  }
-
-  if (content_list->numHwLayers <= 1) {
-    flush_ = true;
-  }
-
-  status = PrepareLayerStack(content_list);
-  if (status) {
-    return status;
-  }
-
-  return 0;
-}
-
-int HWCDisplayPrimary::Commit(hwc_display_contents_1_t *content_list) {
-  int status = 0;
-
-  DisplayConfigFixedInfo display_config;
-  display_intf_->GetConfig(&display_config);
-  if (content_list->numHwLayers <= 1 && display_config.is_cmdmode) {
-    DLOGV("Skipping null commit on cmd mode panel");
-    flush_ = false;
-    return 0;
-  }
-
-  if (display_paused_) {
-    if (content_list->outbufAcquireFenceFd >= 0) {
-      // If we do not handle the frame set retireFenceFd to outbufAcquireFenceFd,
-      // which will make sure the framework waits on it and closes it.
-      content_list->retireFenceFd = dup(content_list->outbufAcquireFenceFd);
-      close(content_list->outbufAcquireFenceFd);
-      content_list->outbufAcquireFenceFd = -1;
-    }
-
-    DisplayError error = display_intf_->Flush();
-    if (error != kErrorNone) {
-      DLOGE("Flush failed. Error = %d", error);
-    }
-    return status;
-  }
-
-  status = HWCDisplay::CommitLayerStack(content_list);
-  if (status) {
-    return status;
-  }
-
-  HandleFrameOutput();
-
-  status = HWCDisplay::PostCommitLayerStack(content_list);
-  if (status) {
-    return status;
-  }
-
-  return 0;
-}
-
-int HWCDisplayPrimary::Perform(uint32_t operation, ...) {
-  va_list args;
-  va_start(args, operation);
-  int val = va_arg(args, int32_t);
-  va_end(args);
-  switch (operation) {
-    case SET_METADATA_DYN_REFRESH_RATE:
-      SetMetaDataRefreshRateFlag(val);
-      break;
-    case SET_BINDER_DYN_REFRESH_RATE:
-      ForceRefreshRate(UINT32(val));
-      break;
-    case SET_DISPLAY_MODE:
-      SetDisplayMode(UINT32(val));
-      break;
-    case SET_QDCM_SOLID_FILL_INFO:
-      SetQDCMSolidFillInfo(true, UINT32(val));
-      break;
-    case UNSET_QDCM_SOLID_FILL_INFO:
-      SetQDCMSolidFillInfo(false, UINT32(val));
-      break;
-    default:
-      DLOGW("Invalid operation %d", operation);
-      return -EINVAL;
-  }
-
-  return 0;
-}
-
-DisplayError HWCDisplayPrimary::SetDisplayMode(uint32_t mode) {
-  DisplayError error = kErrorNone;
-
-  if (display_intf_) {
-    error = display_intf_->SetDisplayMode(mode);
-  }
-
-  return error;
-}
-
-void HWCDisplayPrimary::SetMetaDataRefreshRateFlag(bool enable) {
-  int disable_metadata_dynfps = 0;
-
-  HWCDebugHandler::Get()->GetProperty("persist.metadata_dynfps.disable", &disable_metadata_dynfps);
-  if (disable_metadata_dynfps) {
-    return;
-  }
-  use_metadata_refresh_rate_ = enable;
-}
-
-void HWCDisplayPrimary::SetQDCMSolidFillInfo(bool enable, uint32_t color) {
-  solid_fill_enable_ = enable;
-  solid_fill_color_  = color;
-}
-
-void HWCDisplayPrimary::ToggleCPUHint(bool set) {
-  if (set) {
-    cpu_hint_.Set();
-  } else {
-    cpu_hint_.Reset();
-  }
-}
-
-void HWCDisplayPrimary::SetSecureDisplay(bool secure_display_active, bool force_flush) {
-  if (secure_display_active_ != secure_display_active) {
-    // Skip Prepare and call Flush for null commit
-    DLOGI("SecureDisplay state changed from %d to %d Needs Flush!!", secure_display_active_,
-           secure_display_active);
-    secure_display_active_ = secure_display_active;
-    skip_prepare_cnt = 1;
-
-    // Issue two null commits for command mode panels when external displays are connected.
-    // Two null commits are required to handle non secure to secure transitions at 30fps.
-    // TODO(user): Need two null commits on video mode also to handle transition cases of
-    // primary at higher fps (ex60) and external at lower fps.
-
-    // Avoid flush for command mode panels when no external displays are connected.
-    // This is to avoid flicker/blink on primary during transitions.
-    DisplayConfigFixedInfo display_config;
-    display_intf_->GetConfig(&display_config);
-    if (display_config.is_cmdmode) {
-      if (force_flush) {
-        DLOGI("Issue two null commits for command mode panels");
-        skip_prepare_cnt = 2;
-      } else {
-        DLOGI("Avoid flush for command mode panel when no external displays are connected");
-        skip_prepare_cnt = 0;
-      }
-    }
-  }
-}
-
-void HWCDisplayPrimary::ForceRefreshRate(uint32_t refresh_rate) {
-  if ((refresh_rate && (refresh_rate < min_refresh_rate_ || refresh_rate > max_refresh_rate_)) ||
-       force_refresh_rate_ == refresh_rate) {
-    // Cannot honor force refresh rate, as its beyond the range or new request is same
-    return;
-  }
-
-  const hwc_procs_t *hwc_procs = *hwc_procs_;
-  force_refresh_rate_ = refresh_rate;
-
-  hwc_procs->invalidate(hwc_procs);
-
-  return;
-}
-
-uint32_t HWCDisplayPrimary::GetOptimalRefreshRate(bool one_updating_layer) {
-  if (force_refresh_rate_) {
-    return force_refresh_rate_;
-  } else if (use_metadata_refresh_rate_ && one_updating_layer && metadata_refresh_rate_) {
-    return metadata_refresh_rate_;
-  }
-
-  return max_refresh_rate_;
-}
-
-DisplayError HWCDisplayPrimary::Refresh() {
-  const hwc_procs_t *hwc_procs = *hwc_procs_;
-  DisplayError error = kErrorNone;
-
-  if (!hwc_procs) {
-    return kErrorParameters;
-  }
-
-  hwc_procs->invalidate(hwc_procs);
-
-  return error;
-}
-
-void HWCDisplayPrimary::SetIdleTimeoutMs(uint32_t timeout_ms) {
-  display_intf_->SetIdleTimeoutMs(timeout_ms);
-}
-
-static void SetLayerBuffer(const BufferInfo& output_buffer_info, LayerBuffer *output_buffer) {
-  const BufferConfig& buffer_config = output_buffer_info.buffer_config;
-  const AllocatedBufferInfo &alloc_buffer_info = output_buffer_info.alloc_buffer_info;
-
-  output_buffer->width = alloc_buffer_info.aligned_width;
-  output_buffer->height = alloc_buffer_info.aligned_height;
-  output_buffer->unaligned_width = buffer_config.width;
-  output_buffer->unaligned_height = buffer_config.height;
-  output_buffer->format = buffer_config.format;
-  output_buffer->planes[0].fd = alloc_buffer_info.fd;
-  output_buffer->planes[0].stride = alloc_buffer_info.stride;
-}
-
-void HWCDisplayPrimary::HandleFrameOutput() {
-  if (frame_capture_buffer_queued_) {
-    HandleFrameCapture();
-  } else if (dump_output_to_file_) {
-    HandleFrameDump();
-  }
-}
-
-void HWCDisplayPrimary::HandleFrameCapture() {
-  if (output_buffer_.release_fence_fd >= 0) {
-    frame_capture_status_ = sync_wait(output_buffer_.release_fence_fd, 1000);
-    ::close(output_buffer_.release_fence_fd);
-    output_buffer_.release_fence_fd = -1;
-  }
-
-  frame_capture_buffer_queued_ = false;
-  post_processed_output_ = false;
-  output_buffer_ = {};
-}
-
-void HWCDisplayPrimary::HandleFrameDump() {
-  if (dump_frame_count_ && output_buffer_.release_fence_fd >= 0) {
-    int ret = sync_wait(output_buffer_.release_fence_fd, 1000);
-    ::close(output_buffer_.release_fence_fd);
-    output_buffer_.release_fence_fd = -1;
-    if (ret < 0) {
-      DLOGE("sync_wait error errno = %d, desc = %s", errno,  strerror(errno));
-    } else {
-      DumpOutputBuffer(output_buffer_info_, output_buffer_base_, layer_stack_.retire_fence_fd);
-    }
-  }
-
-  if (0 == dump_frame_count_) {
-    dump_output_to_file_ = false;
-    // Unmap and Free buffer
-    if (munmap(output_buffer_base_, output_buffer_info_.alloc_buffer_info.size) != 0) {
-      DLOGE("unmap failed with err %d", errno);
-    }
-    if (buffer_allocator_->FreeBuffer(&output_buffer_info_) != 0) {
-      DLOGE("FreeBuffer failed");
-    }
-
-    post_processed_output_ = false;
-    output_buffer_ = {};
-    output_buffer_info_ = {};
-    output_buffer_base_ = nullptr;
-  }
-}
-
-void HWCDisplayPrimary::SetFrameDumpConfig(uint32_t count, uint32_t bit_mask_layer_type) {
-  HWCDisplay::SetFrameDumpConfig(count, bit_mask_layer_type);
-  dump_output_to_file_ = bit_mask_layer_type & (1 << OUTPUT_LAYER_DUMP);
-  DLOGI("output_layer_dump_enable %d", dump_output_to_file_);
-
-  if (!count || !dump_output_to_file_) {
-    return;
-  }
-
-  // Allocate and map output buffer
-  output_buffer_info_ = {};
-  // Since we dump DSPP output use Panel resolution.
-  GetPanelResolution(&output_buffer_info_.buffer_config.width,
-                     &output_buffer_info_.buffer_config.height);
-  output_buffer_info_.buffer_config.format = kFormatRGB888;
-  output_buffer_info_.buffer_config.buffer_count = 1;
-  if (buffer_allocator_->AllocateBuffer(&output_buffer_info_) != 0) {
-    DLOGE("Buffer allocation failed");
-    output_buffer_info_ = {};
-    return;
-  }
-
-  void *buffer = mmap(NULL, output_buffer_info_.alloc_buffer_info.size,
-                      PROT_READ | PROT_WRITE,
-                      MAP_SHARED, output_buffer_info_.alloc_buffer_info.fd, 0);
-
-  if (buffer == MAP_FAILED) {
-    DLOGE("mmap failed with err %d", errno);
-    buffer_allocator_->FreeBuffer(&output_buffer_info_);
-    output_buffer_info_ = {};
-    return;
-  }
-
-  output_buffer_base_ = buffer;
-  post_processed_output_ = true;
-  DisablePartialUpdateOneFrame();
-}
-
-int HWCDisplayPrimary::FrameCaptureAsync(const BufferInfo& output_buffer_info,
-                                         bool post_processed_output) {
-  // Note: This function is called in context of a binder thread and a lock is already held
-  if (output_buffer_info.alloc_buffer_info.fd < 0) {
-    DLOGE("Invalid fd %d", output_buffer_info.alloc_buffer_info.fd);
-    return -1;
-  }
-
-  auto panel_width = 0u;
-  auto panel_height = 0u;
-  auto fb_width = 0u;
-  auto fb_height = 0u;
-
-  GetPanelResolution(&panel_width, &panel_height);
-  GetFrameBufferResolution(&fb_width, &fb_height);
-
-  if (post_processed_output && (output_buffer_info.buffer_config.width < panel_width ||
-                                output_buffer_info.buffer_config.height < panel_height)) {
-    DLOGE("Buffer dimensions should not be less than panel resolution");
-    return -1;
-  } else if (!post_processed_output && (output_buffer_info.buffer_config.width < fb_width ||
-                                        output_buffer_info.buffer_config.height < fb_height)) {
-    DLOGE("Buffer dimensions should not be less than FB resolution");
-    return -1;
-  }
-
-  SetLayerBuffer(output_buffer_info, &output_buffer_);
-  post_processed_output_ = post_processed_output;
-  frame_capture_buffer_queued_ = true;
-  // Status is only cleared on a new call to dump and remains valid otherwise
-  frame_capture_status_ = -EAGAIN;
-  DisablePartialUpdateOneFrame();
-
-  return 0;
-}
-
-DisplayError HWCDisplayPrimary::SetDetailEnhancerConfig(
-                                    const DisplayDetailEnhancerData &de_data) {
-  DisplayError error = kErrorNotSupported;
-  if (display_intf_) {
-    error = display_intf_->SetDetailEnhancerData(de_data);
-  }
-  return error;
-}
-
-DisplayError HWCDisplayPrimary::ControlPartialUpdate(bool enable, uint32_t *pending) {
-  DisplayError error = kErrorNone;
-
-  if (display_intf_) {
-    error = display_intf_->ControlPartialUpdate(enable, pending);
-  }
-
-  return error;
-}
-
-DisplayError HWCDisplayPrimary::DisablePartialUpdateOneFrame() {
-  DisplayError error = kErrorNone;
-
-  if (display_intf_) {
-    error = display_intf_->DisablePartialUpdateOneFrame();
-  }
-
-  return error;
-}
-
-DisplayError HWCDisplayPrimary::SetMixerResolution(uint32_t width, uint32_t height) {
-  return display_intf_->SetMixerResolution(width, height);
-}
-
-DisplayError HWCDisplayPrimary::GetMixerResolution(uint32_t *width, uint32_t *height) {
-  return display_intf_->GetMixerResolution(width, height);
-}
-
-}  // namespace sdm
-
diff --git a/sdm/libs/hwc/hwc_display_primary.h b/sdm/libs/hwc/hwc_display_primary.h
deleted file mode 100644
index e937980..0000000
--- a/sdm/libs/hwc/hwc_display_primary.h
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
-* Copyright (c) 2014-2016, 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_DISPLAY_PRIMARY_H__
-#define __HWC_DISPLAY_PRIMARY_H__
-
-#include "cpuhint.h"
-#include "hwc_display.h"
-
-namespace sdm {
-
-class HWCDisplayPrimary : public HWCDisplay {
- public:
-  static int Create(CoreInterface *core_intf, BufferAllocator *buffer_allocator,
-                    hwc_procs_t const **hwc_procs, qService::QService *qservice,
-                    HWCDisplay **hwc_display);
-  static void Destroy(HWCDisplay *hwc_display);
-  virtual int Init();
-  virtual int Deinit();
-  virtual int Prepare(hwc_display_contents_1_t *content_list);
-  virtual int Commit(hwc_display_contents_1_t *content_list);
-  virtual int Perform(uint32_t operation, ...);
-  virtual void SetSecureDisplay(bool secure_display_active, bool force_flush);
-  virtual DisplayError Refresh();
-  virtual void SetIdleTimeoutMs(uint32_t timeout_ms);
-  virtual void SetFrameDumpConfig(uint32_t count, uint32_t bit_mask_layer_type);
-  virtual int FrameCaptureAsync(const BufferInfo& output_buffer_info, bool post_processed);
-  virtual int GetFrameCaptureStatus() { return frame_capture_status_; }
-  virtual DisplayError SetDetailEnhancerConfig(const DisplayDetailEnhancerData &de_data);
-  virtual DisplayError ControlPartialUpdate(bool enable, uint32_t *pending);
-
- private:
-  HWCDisplayPrimary(CoreInterface *core_intf, BufferAllocator *buffer_allocator,
-                    hwc_procs_t const **hwc_procs, qService::QService *qservice);
-  void SetMetaDataRefreshRateFlag(bool enable);
-  virtual DisplayError SetDisplayMode(uint32_t mode);
-  virtual DisplayError DisablePartialUpdateOneFrame();
-  void ProcessBootAnimCompleted(hwc_display_contents_1_t *content_list);
-  void SetQDCMSolidFillInfo(bool enable, uint32_t color);
-  void ToggleCPUHint(bool set);
-  void ForceRefreshRate(uint32_t refresh_rate);
-  uint32_t GetOptimalRefreshRate(bool one_updating_layer);
-  void HandleFrameOutput();
-  void HandleFrameCapture();
-  void HandleFrameDump();
-  DisplayError SetMixerResolution(uint32_t width, uint32_t height);
-  DisplayError GetMixerResolution(uint32_t *width, uint32_t *height);
-
-  BufferAllocator *buffer_allocator_ = nullptr;
-  CPUHint cpu_hint_;
-
-  // Primary output buffer configuration
-  LayerBuffer output_buffer_ = {};
-  bool post_processed_output_ = false;
-
-  // Members for 1 frame capture in a client provided buffer
-  bool frame_capture_buffer_queued_ = false;
-  int frame_capture_status_ = -EAGAIN;
-
-  // Members for N frame output dump to file
-  bool dump_output_to_file_ = false;
-  BufferInfo output_buffer_info_ = {};
-  void *output_buffer_base_ = nullptr;
-};
-
-}  // namespace sdm
-
-#endif  // __HWC_DISPLAY_PRIMARY_H__
-
diff --git a/sdm/libs/hwc/hwc_display_virtual.cpp b/sdm/libs/hwc/hwc_display_virtual.cpp
deleted file mode 100644
index 0279fc2..0000000
--- a/sdm/libs/hwc/hwc_display_virtual.cpp
+++ /dev/null
@@ -1,334 +0,0 @@
-/*
-* Copyright (c) 2014 - 2016, 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.
-*/
-
-#include <utils/constants.h>
-#include <utils/debug.h>
-#include <sync/sync.h>
-#include <stdarg.h>
-#include <gr.h>
-
-#include "hwc_display_virtual.h"
-#include "hwc_debugger.h"
-
-#define __CLASS__ "HWCDisplayVirtual"
-
-namespace sdm {
-
-int HWCDisplayVirtual::Create(CoreInterface *core_intf, hwc_procs_t const **hwc_procs,
-                              uint32_t primary_width, uint32_t primary_height,
-                              hwc_display_contents_1_t *content_list,
-                              HWCDisplay **hwc_display) {
-  int status = 0;
-  HWCDisplayVirtual *hwc_display_virtual = new HWCDisplayVirtual(core_intf, hwc_procs);
-  uint32_t virtual_width = 0, virtual_height = 0;
-
-  status = hwc_display_virtual->Init();
-  if (status) {
-    delete hwc_display_virtual;
-    return status;
-  }
-
-  status = hwc_display_virtual->SetPowerMode(HWC_POWER_MODE_NORMAL);
-  if (status) {
-    Destroy(hwc_display_virtual);
-    return status;
-  }
-
-  // TODO(user): Need to update resolution(and not aligned resolution) on writeback.
-  status = hwc_display_virtual->SetOutputSliceFromMetadata(content_list);
-  if (status) {
-    Destroy(hwc_display_virtual);
-    return status;
-  }
-
-  hwc_display_virtual->GetMixerResolution(&virtual_width, &virtual_height);
-
-  if (content_list->numHwLayers < 1) {
-    Destroy(hwc_display_virtual);
-    return -1;
-  }
-
-  hwc_layer_1_t &fb_layer = content_list->hwLayers[content_list->numHwLayers-1];
-  int fb_width = fb_layer.displayFrame.right - fb_layer.displayFrame.left;
-  int fb_height = fb_layer.displayFrame.bottom - fb_layer.displayFrame.top;
-
-  status = hwc_display_virtual->SetFrameBufferResolution(UINT32(fb_width), UINT32(fb_height));
-
-  if (status) {
-    Destroy(hwc_display_virtual);
-    return status;
-  }
-
-  *hwc_display = static_cast<HWCDisplay *>(hwc_display_virtual);
-
-  return 0;
-}
-
-void HWCDisplayVirtual::Destroy(HWCDisplay *hwc_display) {
-  hwc_display->Deinit();
-  delete hwc_display;
-}
-
-HWCDisplayVirtual::HWCDisplayVirtual(CoreInterface *core_intf, hwc_procs_t const **hwc_procs)
-  : HWCDisplay(core_intf, hwc_procs, kVirtual, HWC_DISPLAY_VIRTUAL, false, NULL,
-               DISPLAY_CLASS_VIRTUAL) {
-}
-
-int HWCDisplayVirtual::Init() {
-  output_buffer_ = new LayerBuffer();
-  if (!output_buffer_) {
-    return -ENOMEM;
-  }
-
-  return HWCDisplay::Init();
-}
-
-int HWCDisplayVirtual::Deinit() {
-  int status = 0;
-
-  status = HWCDisplay::Deinit();
-  if (status) {
-    return status;
-  }
-
-  if (output_buffer_) {
-    delete output_buffer_;
-    output_buffer_ = NULL;
-  }
-
-  return status;
-}
-
-int HWCDisplayVirtual::Prepare(hwc_display_contents_1_t *content_list) {
-  int status = 0;
-
-  status = SetOutputSliceFromMetadata(content_list);
-  if (status) {
-    return status;
-  }
-
-  if (display_paused_) {
-    MarkLayersForGPUBypass(content_list);
-    return status;
-  }
-
-  status = AllocateLayerStack(content_list);
-  if (status) {
-    return status;
-  }
-
-  status = SetOutputBuffer(content_list);
-  if (status) {
-    return status;
-  }
-
-  status = PrePrepareLayerStack(content_list);
-  if (status) {
-    return status;
-  }
-
-  status = PrepareLayerStack(content_list);
-  if (status) {
-    return status;
-  }
-
-  return 0;
-}
-
-int HWCDisplayVirtual::Commit(hwc_display_contents_1_t *content_list) {
-  int status = 0;
-  if (display_paused_) {
-    DisplayError error = display_intf_->Flush();
-    if (error != kErrorNone) {
-      DLOGE("Flush failed. Error = %d", error);
-    }
-    return status;
-  }
-
-  CommitOutputBufferParams(content_list);
-
-  status = HWCDisplay::CommitLayerStack(content_list);
-  if (status) {
-    return status;
-  }
-
-  if (dump_frame_count_ && !flush_ && dump_output_layer_) {
-    const private_handle_t *output_handle = (const private_handle_t *)(content_list->outbuf);
-    if (output_handle && output_handle->base) {
-      BufferInfo buffer_info;
-      buffer_info.buffer_config.width = static_cast<uint32_t>(output_handle->width);
-      buffer_info.buffer_config.height = static_cast<uint32_t>(output_handle->height);
-      buffer_info.buffer_config.format = GetSDMFormat(output_handle->format, output_handle->flags);
-      buffer_info.alloc_buffer_info.size = static_cast<uint32_t>(output_handle->size);
-      DumpOutputBuffer(buffer_info, reinterpret_cast<void *>(output_handle->base),
-                       layer_stack_.retire_fence_fd);
-    }
-  }
-
-  status = HWCDisplay::PostCommitLayerStack(content_list);
-  if (status) {
-    return status;
-  }
-
-  return 0;
-}
-
-int HWCDisplayVirtual::SetOutputSliceFromMetadata(hwc_display_contents_1_t *content_list) {
-  const private_handle_t *output_handle =
-        static_cast<const private_handle_t *>(content_list->outbuf);
-  DisplayError error = kErrorNone;
-  int status = 0;
-
-  if (output_handle) {
-    int output_handle_format = output_handle->format;
-    if (output_handle_format == HAL_PIXEL_FORMAT_RGBA_8888) {
-      output_handle_format = HAL_PIXEL_FORMAT_RGBX_8888;
-    }
-
-    LayerBufferFormat format = GetSDMFormat(output_handle_format, output_handle->flags);
-    if (format == kFormatInvalid) {
-      return -EINVAL;
-    }
-
-    int active_width;
-    int active_height;
-
-    AdrenoMemInfo::getInstance().getAlignedWidthAndHeight(output_handle, active_width,
-                                                          active_height);
-
-    if ((active_width != INT(output_buffer_->width)) ||
-        (active_height!= INT(output_buffer_->height)) ||
-        (format != output_buffer_->format)) {
-      // Populate virtual display attributes based on displayFrame of FBT.
-      // For DRC, use width and height populated in metadata (unaligned values)
-      // for setting attributes of virtual display. This is needed because if
-      // we use aligned width and height, scaling will be required for FBT layer.
-      DisplayConfigVariableInfo variable_info;
-      hwc_layer_1_t &fbt_layer = content_list->hwLayers[content_list->numHwLayers-1];
-      hwc_rect_t &frame = fbt_layer.displayFrame;
-      int fbt_width = frame.right - frame.left;
-      int fbt_height = frame.bottom - frame.top;
-      const MetaData_t *meta_data = reinterpret_cast<MetaData_t *>(output_handle->base_metadata);
-      if (meta_data && meta_data->operation & UPDATE_BUFFER_GEOMETRY) {
-        variable_info.x_pixels = UINT32(meta_data->bufferDim.sliceWidth);
-        variable_info.y_pixels = UINT32(meta_data->bufferDim.sliceHeight);
-      } else {
-        variable_info.x_pixels = UINT32(fbt_width);
-        variable_info.y_pixels = UINT32(fbt_height);
-      }
-      // TODO(user): Need to get the framerate of primary display and update it.
-      variable_info.fps = 60;
-
-      error = display_intf_->SetActiveConfig(&variable_info);
-      if (error != kErrorNone) {
-        return -EINVAL;
-      }
-
-      status = SetOutputBuffer(content_list);
-      if (status) {
-        return status;
-      }
-    }
-  }
-
-  return 0;
-}
-
-int HWCDisplayVirtual::SetOutputBuffer(hwc_display_contents_1_t *content_list) {
-  const private_handle_t *output_handle =
-        static_cast<const private_handle_t *>(content_list->outbuf);
-
-  if (output_handle) {
-    int output_handle_format = output_handle->format;
-
-    if (output_handle_format == HAL_PIXEL_FORMAT_RGBA_8888) {
-      output_handle_format = HAL_PIXEL_FORMAT_RGBX_8888;
-    }
-
-    output_buffer_->format = GetSDMFormat(output_handle_format, output_handle->flags);
-
-    if (output_buffer_->format == kFormatInvalid) {
-      return -EINVAL;
-    }
-
-    int aligned_width, aligned_height;
-    int unaligned_width, unaligned_height;
-
-    AdrenoMemInfo::getInstance().getAlignedWidthAndHeight(output_handle, aligned_width,
-                                                          aligned_height);
-    AdrenoMemInfo::getInstance().getUnalignedWidthAndHeight(output_handle, unaligned_width,
-                                                            unaligned_height);
-
-    output_buffer_->width = UINT32(aligned_width);
-    output_buffer_->height = UINT32(aligned_height);
-    output_buffer_->unaligned_width = UINT32(unaligned_width);
-    output_buffer_->unaligned_height = UINT32(unaligned_height);
-    output_buffer_->flags.secure = 0;
-    output_buffer_->flags.video = 0;
-
-    const MetaData_t *meta_data = reinterpret_cast<MetaData_t *>(output_handle->base_metadata);
-    if (meta_data && SetCSC(meta_data, &output_buffer_->color_metadata) != kErrorNone) {
-      return kErrorNotSupported;
-    }
-
-    // TZ Protected Buffer - L1
-    if (output_handle->flags & private_handle_t::PRIV_FLAGS_SECURE_BUFFER) {
-      output_buffer_->flags.secure = 1;
-    }
-  }
-
-  layer_stack_.output_buffer = output_buffer_;
-
-  return 0;
-}
-
-void HWCDisplayVirtual::CommitOutputBufferParams(hwc_display_contents_1_t *content_list) {
-  const private_handle_t *output_handle =
-        static_cast<const private_handle_t *>(content_list->outbuf);
-
-  // Fill output buffer parameters (width, height, format, plane information, fence)
-  output_buffer_->acquire_fence_fd = content_list->outbufAcquireFenceFd;
-
-  if (output_handle) {
-    // ToDo: Need to extend for non-RGB formats
-    output_buffer_->planes[0].fd = output_handle->fd;
-    output_buffer_->planes[0].offset = output_handle->offset;
-    output_buffer_->planes[0].stride = UINT32(output_handle->width);
-  }
-}
-
-void HWCDisplayVirtual::SetFrameDumpConfig(uint32_t count, uint32_t bit_mask_layer_type) {
-  HWCDisplay::SetFrameDumpConfig(count, bit_mask_layer_type);
-  dump_output_layer_ = ((bit_mask_layer_type & (1 << OUTPUT_LAYER_DUMP)) != 0);
-
-  DLOGI("output_layer_dump_enable %d", dump_output_layer_);
-}
-
-}  // namespace sdm
-
diff --git a/sdm/libs/hwc/hwc_display_virtual.h b/sdm/libs/hwc/hwc_display_virtual.h
deleted file mode 100644
index 77e16d5..0000000
--- a/sdm/libs/hwc/hwc_display_virtual.h
+++ /dev/null
@@ -1,64 +0,0 @@
-/*
-* Copyright (c) 2014,2016 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_DISPLAY_VIRTUAL_H__
-#define __HWC_DISPLAY_VIRTUAL_H__
-
-#include <qdMetaData.h>
-#include <gralloc_priv.h>
-#include "hwc_display.h"
-
-namespace sdm {
-
-class HWCDisplayVirtual : public HWCDisplay {
- public:
-  static int Create(CoreInterface *core_intf, hwc_procs_t const **hwc_procs,
-                    uint32_t primary_width, uint32_t primary_height,
-                    hwc_display_contents_1_t *content_list, HWCDisplay **hwc_display);
-  static void Destroy(HWCDisplay *hwc_display);
-  static bool IsValidContentList(hwc_display_contents_1_t *content_list);
-  virtual int Init();
-  virtual int Deinit();
-  virtual int Prepare(hwc_display_contents_1_t *content_list);
-  virtual int Commit(hwc_display_contents_1_t *content_list);
-  virtual void SetFrameDumpConfig(uint32_t count, uint32_t bit_mask_layer_type);
-
- private:
-  HWCDisplayVirtual(CoreInterface *core_intf, hwc_procs_t const **hwc_procs);
-  int SetOutputBuffer(hwc_display_contents_1_t *content_list);
-  int SetOutputSliceFromMetadata(hwc_display_contents_1_t *content_list);
-  void CommitOutputBufferParams(hwc_display_contents_1_t *content_list);
-
-  bool dump_output_layer_ = false;
-  LayerBuffer *output_buffer_ = NULL;
-};
-
-inline bool HWCDisplayVirtual::IsValidContentList(hwc_display_contents_1_t *content_list) {
-  return (content_list && content_list->numHwLayers > 0 && content_list->outbuf);
-}
-
-}  // namespace sdm
-
-#endif  // __HWC_DISPLAY_VIRTUAL_H__
-
diff --git a/sdm/libs/hwc/hwc_session.cpp b/sdm/libs/hwc/hwc_session.cpp
deleted file mode 100644
index 98e14ee..0000000
--- a/sdm/libs/hwc/hwc_session.cpp
+++ /dev/null
@@ -1,1743 +0,0 @@
-/*
-* Copyright (c) 2014 - 2017, 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.
-*/
-
-#include <core/dump_interface.h>
-#include <core/buffer_allocator.h>
-#include <private/color_params.h>
-#include <utils/constants.h>
-#include <utils/String16.h>
-#include <cutils/properties.h>
-#include <hardware_legacy/uevent.h>
-#include <sys/resource.h>
-#include <sys/prctl.h>
-#include <binder/Parcel.h>
-#include <QService.h>
-#include <gr.h>
-#include <gralloc_priv.h>
-#include <display_config.h>
-#include <utils/debug.h>
-#include <sync/sync.h>
-#include <profiler.h>
-#include <bitset>
-#include <vector>
-
-#include "hwc_buffer_allocator.h"
-#include "hwc_buffer_sync_handler.h"
-#include "hwc_session.h"
-#include "hwc_debugger.h"
-#include "hwc_display_null.h"
-#include "hwc_display_primary.h"
-#include "hwc_display_virtual.h"
-#include "hwc_display_external_test.h"
-#include "qd_utils.h"
-
-#define __CLASS__ "HWCSession"
-
-#define HWC_UEVENT_SWITCH_HDMI "change@/devices/virtual/switch/hdmi"
-#define HWC_UEVENT_GRAPHICS_FB0 "change@/devices/virtual/graphics/fb0"
-
-static sdm::HWCSession::HWCModuleMethods g_hwc_module_methods;
-
-hwc_module_t HAL_MODULE_INFO_SYM = {
-  .common = {
-    .tag = HARDWARE_MODULE_TAG,
-    .version_major = 2,
-    .version_minor = 0,
-    .id = HWC_HARDWARE_MODULE_ID,
-    .name = "QTI Hardware Composer Module",
-    .author = "CodeAurora Forum",
-    .methods = &g_hwc_module_methods,
-    .dso = 0,
-    .reserved = {0},
-  }
-};
-
-namespace sdm {
-
-Locker HWCSession::locker_;
-
-static void Invalidate(const struct hwc_procs *procs) {
-}
-
-static void VSync(const struct hwc_procs* procs, int disp, int64_t timestamp) {
-}
-
-static void Hotplug(const struct hwc_procs* procs, int disp, int connected) {
-}
-
-HWCSession::HWCSession(const hw_module_t *module) {
-  // By default, drop any events. Calls will be routed to SurfaceFlinger after registerProcs.
-  hwc_procs_default_.invalidate = Invalidate;
-  hwc_procs_default_.vsync = VSync;
-  hwc_procs_default_.hotplug = Hotplug;
-
-  hwc_composer_device_1_t::common.tag = HARDWARE_DEVICE_TAG;
-  hwc_composer_device_1_t::common.version = HWC_DEVICE_API_VERSION_1_5;
-  hwc_composer_device_1_t::common.module = const_cast<hw_module_t*>(module);
-  hwc_composer_device_1_t::common.close = Close;
-  hwc_composer_device_1_t::prepare = Prepare;
-  hwc_composer_device_1_t::set = Set;
-  hwc_composer_device_1_t::eventControl = EventControl;
-  hwc_composer_device_1_t::setPowerMode = SetPowerMode;
-  hwc_composer_device_1_t::query = Query;
-  hwc_composer_device_1_t::registerProcs = RegisterProcs;
-  hwc_composer_device_1_t::dump = Dump;
-  hwc_composer_device_1_t::getDisplayConfigs = GetDisplayConfigs;
-  hwc_composer_device_1_t::getDisplayAttributes = GetDisplayAttributes;
-  hwc_composer_device_1_t::getActiveConfig = GetActiveConfig;
-  hwc_composer_device_1_t::setActiveConfig = SetActiveConfig;
-  hwc_composer_device_1_t::setCursorPositionAsync = SetCursorPositionAsync;
-}
-
-int HWCSession::Init() {
-  int status = -EINVAL;
-  const char *qservice_name = "display.qservice";
-
-  // Start QService and connect to it.
-  qService::QService::init();
-  android::sp<qService::IQService> iqservice = android::interface_cast<qService::IQService>(
-                android::defaultServiceManager()->getService(android::String16(qservice_name)));
-
-  if (iqservice.get()) {
-    iqservice->connect(android::sp<qClient::IQClient>(this));
-    qservice_ = reinterpret_cast<qService::QService* >(iqservice.get());
-  } else {
-    DLOGE("Failed to acquire %s", qservice_name);
-    return -EINVAL;
-  }
-
-  DisplayError error = CoreInterface::CreateCore(HWCDebugHandler::Get(), &buffer_allocator_,
-                                                 &buffer_sync_handler_, &socket_handler_,
-                                                 &core_intf_);
-  if (error != kErrorNone) {
-    DLOGE("Display core initialization failed. Error = %d", error);
-    return -EINVAL;
-  }
-
-  SCOPE_LOCK(uevent_locker_);
-
-  if (pthread_create(&uevent_thread_, NULL, &HWCUeventThread, this) < 0) {
-    DLOGE("Failed to start = %s, error = %s", uevent_thread_name_, strerror(errno));
-    CoreInterface::DestroyCore();
-    return -errno;
-  }
-
-  // Wait for uevent_init() to happen and let the uevent thread wait for uevents, so that hdmi
-  // connect/disconnect events won't be missed
-  uevent_locker_.Wait();
-
-  // Read which display is first, and create it and store it in primary slot
-  HWDisplayInterfaceInfo hw_disp_info;
-  error = core_intf_->GetFirstDisplayInterfaceType(&hw_disp_info);
-  if (error == kErrorNone) {
-    if (hw_disp_info.type == kHDMI) {
-      // HDMI is primary display. If already connected, then create it and store in
-      // primary display slot. If not connected, create a NULL display for now.
-      HWCDebugHandler::Get()->SetProperty("persist.sys.is_hdmi_primary", "1");
-      is_hdmi_primary_ = true;
-      if (hw_disp_info.is_connected) {
-        status = CreateExternalDisplay(HWC_DISPLAY_PRIMARY, 0, 0, false);
-        is_hdmi_yuv_ = IsDisplayYUV(HWC_DISPLAY_PRIMARY);
-      } else {
-        // NullDisplay simply closes all its fences, and advertizes a standard
-        // resolution to SurfaceFlinger
-        status = HWCDisplayNull::Create(core_intf_, &hwc_procs_,
-                                        &hwc_display_[HWC_DISPLAY_PRIMARY]);
-      }
-    } else {
-      // Create and power on primary display
-      status = HWCDisplayPrimary::Create(core_intf_, &buffer_allocator_, &hwc_procs_, qservice_,
-                                         &hwc_display_[HWC_DISPLAY_PRIMARY]);
-    }
-  } else {
-    // Create and power on primary display
-    status = HWCDisplayPrimary::Create(core_intf_, &buffer_allocator_, &hwc_procs_, qservice_,
-                                       &hwc_display_[HWC_DISPLAY_PRIMARY]);
-  }
-
-  if (status) {
-    CoreInterface::DestroyCore();
-    uevent_thread_exit_ = true;
-    pthread_join(uevent_thread_, NULL);
-    return status;
-  }
-
-  color_mgr_ = HWCColorManager::CreateColorManager();
-  if (!color_mgr_) {
-    DLOGW("Failed to load HWCColorManager.");
-  }
-
-  connected_displays_[HWC_DISPLAY_PRIMARY] = 1;
-  struct rlimit fd_limit = {};
-  getrlimit(RLIMIT_NOFILE, &fd_limit);
-  fd_limit.rlim_cur = fd_limit.rlim_cur * 2;
-  auto err = setrlimit(RLIMIT_NOFILE, &fd_limit);
-  if (err) {
-    DLOGW("Unable to increase fd limit -  err: %d, %s", errno, strerror(errno));
-  }
-  return 0;
-}
-
-int HWCSession::Deinit() {
-  HWCDisplayPrimary::Destroy(hwc_display_[HWC_DISPLAY_PRIMARY]);
-  hwc_display_[HWC_DISPLAY_PRIMARY] = 0;
-  if (color_mgr_) {
-    color_mgr_->DestroyColorManager();
-  }
-  uevent_thread_exit_ = true;
-  pthread_join(uevent_thread_, NULL);
-
-  DisplayError error = CoreInterface::DestroyCore();
-  if (error != kErrorNone) {
-    DLOGE("Display core de-initialization failed. Error = %d", error);
-  }
-
-  connected_displays_[HWC_DISPLAY_PRIMARY] = 0;
-  return 0;
-}
-
-int HWCSession::Open(const hw_module_t *module, const char *name, hw_device_t **device) {
-  SEQUENCE_WAIT_SCOPE_LOCK(locker_);
-
-  if (!module || !name || !device) {
-    DLOGE("Invalid parameters.");
-    return -EINVAL;
-  }
-
-  if (!strcmp(name, HWC_HARDWARE_COMPOSER)) {
-    HWCSession *hwc_session = new HWCSession(module);
-    if (!hwc_session) {
-      return -ENOMEM;
-    }
-
-    int status = hwc_session->Init();
-    if (status != 0) {
-      delete hwc_session;
-      return status;
-    }
-
-    hwc_composer_device_1_t *composer_device = hwc_session;
-    *device = reinterpret_cast<hw_device_t *>(composer_device);
-  }
-
-  return 0;
-}
-
-int HWCSession::Close(hw_device_t *device) {
-  SEQUENCE_WAIT_SCOPE_LOCK(locker_);
-
-  if (!device) {
-    return -EINVAL;
-  }
-
-  hwc_composer_device_1_t *composer_device = reinterpret_cast<hwc_composer_device_1_t *>(device);
-  HWCSession *hwc_session = static_cast<HWCSession *>(composer_device);
-
-  hwc_session->Deinit();
-  delete hwc_session;
-
-  return 0;
-}
-
-int HWCSession::Prepare(hwc_composer_device_1 *device, size_t num_displays,
-                        hwc_display_contents_1_t **displays) {
-  DTRACE_SCOPED();
-
-  if (!device || !displays || num_displays > HWC_NUM_DISPLAY_TYPES) {
-    return -EINVAL;
-  }
-
-  HWCSession *hwc_session = static_cast<HWCSession *>(device);
-  hwc_procs_t const *hwc_procs = NULL;
-  bool hotplug_connect = false;
-
-  // Hold mutex only in this scope.
-  {
-    SEQUENCE_ENTRY_SCOPE_LOCK(locker_);
-
-    hwc_procs = hwc_session->hwc_procs_;
-
-    if (hwc_session->reset_panel_) {
-      DLOGW("panel is in bad state, resetting the panel");
-      hwc_session->ResetPanel();
-    }
-
-    if (hwc_session->need_invalidate_) {
-      hwc_session->AsyncRefresh();
-      hwc_session->need_invalidate_ = false;
-    }
-
-    hwc_session->HandleSecureDisplaySession(displays);
-
-    if (hwc_session->color_mgr_) {
-      HWCDisplay *primary_display = hwc_session->hwc_display_[HWC_DISPLAY_PRIMARY];
-      if (primary_display && !hwc_session->is_hdmi_primary_) {
-        int ret = hwc_session->color_mgr_->SolidFillLayersPrepare(displays, primary_display);
-        if (ret)
-          return 0;
-      }
-    }
-
-    for (ssize_t dpy = static_cast<ssize_t>(num_displays - 1); dpy >= 0; dpy--) {
-      hwc_display_contents_1_t *content_list = displays[dpy];
-      // If external display is connected, ignore virtual display content list.
-      // If virtual display content list is valid, connect virtual display if not connected.
-      // If virtual display content list is invalid, disconnect virtual display if connected.
-      // If external display connection is pending, connect external display when virtual
-      // display is destroyed.
-      // If HDMI is primary and the output format is YUV then ignore the virtual display
-      // content list.
-      if (dpy == HWC_DISPLAY_VIRTUAL) {
-        if (hwc_session->hwc_display_[HWC_DISPLAY_EXTERNAL] ||
-                (hwc_session->is_hdmi_primary_ && hwc_session->is_hdmi_yuv_)) {
-          continue;
-        }
-
-        bool valid_content = HWCDisplayVirtual::IsValidContentList(content_list);
-        bool connected = (hwc_session->hwc_display_[HWC_DISPLAY_VIRTUAL] != NULL);
-
-        if (valid_content && !connected) {
-          hwc_session->ConnectDisplay(HWC_DISPLAY_VIRTUAL, content_list);
-        } else if (!valid_content && connected) {
-          hwc_session->DisconnectDisplay(HWC_DISPLAY_VIRTUAL);
-
-          if (hwc_session->external_pending_connect_) {
-            DLOGI("Process pending external display connection");
-            hwc_session->ConnectDisplay(HWC_DISPLAY_EXTERNAL, NULL);
-            hwc_session->external_pending_connect_ = false;
-            hotplug_connect = true;
-          }
-        }
-      }
-
-      if (hwc_session->hwc_display_[dpy]) {
-        if (!content_list) {
-          DLOGI("Display[%d] connected. content_list is null", dpy);
-        } else if (!content_list->numHwLayers) {
-          DLOGE("Display[%d] connected. numHwLayers is zero", dpy);
-        } else {
-          hwc_session->hwc_display_[dpy]->Prepare(content_list);
-        }
-      }
-    }
-  }
-
-  if (hotplug_connect) {
-    // notify client
-    hwc_procs->hotplug(hwc_procs, HWC_DISPLAY_EXTERNAL, true);
-  }
-  // Return 0, else client will go into bad state
-  return 0;
-}
-
-int HWCSession::GetVsyncPeriod(int disp) {
-  SCOPE_LOCK(locker_);
-  // default value
-  int32_t vsync_period = 1000000000l / 60;
-  const uint32_t attribute = HWC_DISPLAY_VSYNC_PERIOD;
-
-  if (hwc_display_[disp]) {
-    hwc_display_[disp]->GetDisplayAttributes(0, &attribute, &vsync_period);
-  }
-
-  return vsync_period;
-}
-
-int HWCSession::Set(hwc_composer_device_1 *device, size_t num_displays,
-                    hwc_display_contents_1_t **displays) {
-  DTRACE_SCOPED();
-
-  SEQUENCE_EXIT_SCOPE_LOCK(locker_);
-
-  if (!device || !displays || num_displays > HWC_NUM_DISPLAY_TYPES) {
-    return -EINVAL;
-  }
-
-  HWCSession *hwc_session = static_cast<HWCSession *>(device);
-
-  if (hwc_session->color_mgr_) {
-    HWCDisplay *primary_display = hwc_session->hwc_display_[HWC_DISPLAY_PRIMARY];
-    if (primary_display) {
-      int ret = hwc_session->color_mgr_->SolidFillLayersSet(displays, primary_display);
-      if (ret)
-        return 0;
-      hwc_session->color_mgr_->SetColorModeDetailEnhancer(primary_display);
-    }
-  }
-
-  for (size_t dpy = 0; dpy < num_displays; dpy++) {
-    hwc_display_contents_1_t *content_list = displays[dpy];
-
-    // Drop virtual display composition if virtual display object could not be created
-    // due to HDMI concurrency.
-    if (dpy == HWC_DISPLAY_VIRTUAL && !hwc_session->hwc_display_[HWC_DISPLAY_VIRTUAL]) {
-      CloseAcquireFds(content_list);
-      if (content_list) {
-        content_list->retireFenceFd = -1;
-      }
-
-      continue;
-    }
-
-    if (hwc_session->hwc_display_[dpy]) {
-      hwc_session->hwc_display_[dpy]->Commit(content_list);
-    }
-    CloseAcquireFds(content_list);
-  }
-
-  if (hwc_session->new_bw_mode_) {
-    hwc_display_contents_1_t *content_list = displays[HWC_DISPLAY_PRIMARY];
-    hwc_session->new_bw_mode_ = false;
-    if (hwc_session->bw_mode_release_fd_ >= 0) {
-      close(hwc_session->bw_mode_release_fd_);
-    }
-    hwc_session->bw_mode_release_fd_ = dup(content_list->retireFenceFd);
-  }
-
-  locker_.Signal();
-
-  // This is only indicative of how many times SurfaceFlinger posts
-  // frames to the display.
-  CALC_FPS();
-
-  // Return 0, else client will go into bad state
-  return 0;
-}
-
-void HWCSession::CloseAcquireFds(hwc_display_contents_1_t *content_list) {
-  if (content_list) {
-    for (size_t i = 0; i < content_list->numHwLayers; i++) {
-      int &acquireFenceFd = content_list->hwLayers[i].acquireFenceFd;
-      if (acquireFenceFd >= 0) {
-        close(acquireFenceFd);
-        acquireFenceFd = -1;
-      }
-    }
-
-    int &outbufAcquireFenceFd = content_list->outbufAcquireFenceFd;
-    if (outbufAcquireFenceFd >= 0) {
-      close(outbufAcquireFenceFd);
-      outbufAcquireFenceFd = -1;
-    }
-  }
-}
-
-bool HWCSession::IsDisplayYUV(int disp) {
-  int error = -EINVAL;
-  bool is_yuv = false;
-  DisplayConfigVariableInfo attributes = {};
-
-  if (disp < 0 || disp >= HWC_NUM_DISPLAY_TYPES || !hwc_display_[disp]) {
-    DLOGE("Invalid input parameters. Display = %d", disp);
-    return is_yuv;
-  }
-
-  uint32_t active_config = 0;
-  error = hwc_display_[disp]->GetActiveDisplayConfig(&active_config);
-  if (!error) {
-    error = hwc_display_[disp]->GetDisplayAttributesForConfig(INT(active_config), &attributes);
-    if (error == 0) {
-      is_yuv = attributes.is_yuv;
-    } else {
-      DLOGW("Error querying display attributes. Display = %d, Config = %d", disp, active_config);
-    }
-  }
-
-  return is_yuv;
-}
-
-int HWCSession::EventControl(hwc_composer_device_1 *device, int disp, int event, int enable) {
-  SCOPE_LOCK(locker_);
-
-  if (!device) {
-    return -EINVAL;
-  }
-
-  HWCSession *hwc_session = static_cast<HWCSession *>(device);
-  int status = -EINVAL;
-  if (hwc_session->hwc_display_[disp]) {
-    status = hwc_session->hwc_display_[disp]->EventControl(event, enable);
-  }
-
-  return status;
-}
-
-int HWCSession::SetPowerMode(hwc_composer_device_1 *device, int disp, int mode) {
-  SEQUENCE_WAIT_SCOPE_LOCK(locker_);
-
-  if (!device) {
-    return -EINVAL;
-  }
-
-  HWCSession *hwc_session = static_cast<HWCSession *>(device);
-  int status = -EINVAL;
-  if (hwc_session->hwc_display_[disp]) {
-    status = hwc_session->hwc_display_[disp]->SetPowerMode(mode);
-  }
-
-  return status;
-}
-
-int HWCSession::Query(hwc_composer_device_1 *device, int param, int *value) {
-  SCOPE_LOCK(locker_);
-
-  if (!device || !value) {
-    return -EINVAL;
-  }
-
-  int status = 0;
-
-  switch (param) {
-  case HWC_BACKGROUND_LAYER_SUPPORTED:
-    value[0] = 1;
-    break;
-
-  default:
-    status = -EINVAL;
-  }
-
-  return status;
-}
-
-void HWCSession::RegisterProcs(hwc_composer_device_1 *device, hwc_procs_t const *procs) {
-  SCOPE_LOCK(locker_);
-
-  if (!device || !procs) {
-    return;
-  }
-
-  HWCSession *hwc_session = static_cast<HWCSession *>(device);
-  hwc_session->hwc_procs_ = procs;
-}
-
-void HWCSession::Dump(hwc_composer_device_1 *device, char *buffer, int length) {
-  SEQUENCE_WAIT_SCOPE_LOCK(locker_);
-
-  if (!device || !buffer || !length) {
-    return;
-  }
-
-  DumpInterface::GetDump(buffer, UINT32(length));
-}
-
-int HWCSession::GetDisplayConfigs(hwc_composer_device_1 *device, int disp, uint32_t *configs,
-                                  size_t *num_configs) {
-  SCOPE_LOCK(locker_);
-
-  if (!device || !configs || !num_configs) {
-    return -EINVAL;
-  }
-
-  if (disp < HWC_DISPLAY_PRIMARY || disp >  HWC_NUM_PHYSICAL_DISPLAY_TYPES) {
-    return -EINVAL;
-  }
-
-  HWCSession *hwc_session = static_cast<HWCSession *>(device);
-  int status = -EINVAL;
-  if (hwc_session->hwc_display_[disp]) {
-    status = hwc_session->hwc_display_[disp]->GetDisplayConfigs(configs, num_configs);
-  }
-
-  return status;
-}
-
-int HWCSession::GetDisplayAttributes(hwc_composer_device_1 *device, int disp, uint32_t config,
-                                     const uint32_t *display_attributes, int32_t *values) {
-  SCOPE_LOCK(locker_);
-
-  if (!device || !display_attributes || !values) {
-    return -EINVAL;
-  }
-
-  if (disp < HWC_DISPLAY_PRIMARY || disp >  HWC_NUM_PHYSICAL_DISPLAY_TYPES) {
-    return -EINVAL;
-  }
-
-  HWCSession *hwc_session = static_cast<HWCSession *>(device);
-  int status = -EINVAL;
-  if (hwc_session->hwc_display_[disp]) {
-    status = hwc_session->hwc_display_[disp]->GetDisplayAttributes(config, display_attributes,
-                                                                   values);
-  }
-
-  return status;
-}
-
-int HWCSession::GetActiveConfig(hwc_composer_device_1 *device, int disp) {
-  SCOPE_LOCK(locker_);
-
-  if (!device) {
-    return -EINVAL;
-  }
-
-  if (disp < HWC_DISPLAY_PRIMARY || disp >  HWC_NUM_PHYSICAL_DISPLAY_TYPES) {
-    return -EINVAL;
-  }
-
-  HWCSession *hwc_session = static_cast<HWCSession *>(device);
-  int active_config = -1;
-  if (hwc_session->hwc_display_[disp]) {
-    active_config = hwc_session->hwc_display_[disp]->GetActiveConfig();
-  }
-
-  return active_config;
-}
-
-int HWCSession::SetActiveConfig(hwc_composer_device_1 *device, int disp, int index) {
-  SEQUENCE_WAIT_SCOPE_LOCK(locker_);
-
-  if (!device) {
-    return -EINVAL;
-  }
-
-  if (disp < HWC_DISPLAY_PRIMARY || disp >  HWC_NUM_PHYSICAL_DISPLAY_TYPES) {
-    return -EINVAL;
-  }
-
-  HWCSession *hwc_session = static_cast<HWCSession *>(device);
-  int status = -EINVAL;
-
-  if (hwc_session->hwc_display_[disp]) {
-    status = hwc_session->hwc_display_[disp]->SetActiveConfig(index);
-  }
-
-  return status;
-}
-
-int HWCSession::SetCursorPositionAsync(hwc_composer_device_1 *device, int disp, int x, int y) {
-  DTRACE_SCOPED();
-
-  SCOPE_LOCK(locker_);
-
-  if (!device || (disp < HWC_DISPLAY_PRIMARY) || (disp > HWC_DISPLAY_VIRTUAL)) {
-    return -EINVAL;
-  }
-
-  int status = -EINVAL;
-  HWCSession *hwc_session = static_cast<HWCSession *>(device);
-  if (hwc_session->hwc_display_[disp]) {
-    status = hwc_session->hwc_display_[disp]->SetCursorPosition(x, y);
-  }
-
-  return status;
-}
-
-int HWCSession::ConnectDisplay(int disp, hwc_display_contents_1_t *content_list) {
-  DLOGI("Display = %d", disp);
-
-  int status = 0;
-  uint32_t primary_width = 0;
-  uint32_t primary_height = 0;
-
-  hwc_display_[HWC_DISPLAY_PRIMARY]->GetFrameBufferResolution(&primary_width, &primary_height);
-
-  if (disp == HWC_DISPLAY_EXTERNAL) {
-    status = CreateExternalDisplay(disp, primary_width, primary_height, false);
-    connected_displays_[HWC_DISPLAY_EXTERNAL] = 1;
-  } else if (disp == HWC_DISPLAY_VIRTUAL) {
-    status = HWCDisplayVirtual::Create(core_intf_, &hwc_procs_, primary_width, primary_height,
-                                       content_list, &hwc_display_[disp]);
-    connected_displays_[HWC_DISPLAY_VIRTUAL] = 1;
-  } else {
-    DLOGE("Invalid display type");
-    return -1;
-  }
-
-  if (!status) {
-    hwc_display_[disp]->SetSecureDisplay(secure_display_active_, true);
-  }
-
-  return status;
-}
-
-int HWCSession::DisconnectDisplay(int disp) {
-  DLOGI("Display = %d", disp);
-
-  if (disp == HWC_DISPLAY_EXTERNAL) {
-    HWCDisplayExternal::Destroy(hwc_display_[disp]);
-    connected_displays_[HWC_DISPLAY_EXTERNAL] = 0;
-  } else if (disp == HWC_DISPLAY_VIRTUAL) {
-    HWCDisplayVirtual::Destroy(hwc_display_[disp]);
-    connected_displays_[HWC_DISPLAY_VIRTUAL] = 0;
-  } else {
-    DLOGE("Invalid display type");
-    return -1;
-  }
-
-  hwc_display_[disp] = NULL;
-
-  return 0;
-}
-
-static void PostRefresh(hwc_procs_t const *hwc_procs) {
-  hwc_procs->invalidate(hwc_procs);
-}
-
-void HWCSession::AsyncRefresh() {
-  future_ = std::async(PostRefresh, hwc_procs_);
-}
-
-android::status_t HWCSession::notifyCallback(uint32_t command, const android::Parcel *input_parcel,
-                                             android::Parcel *output_parcel) {
-  SEQUENCE_WAIT_SCOPE_LOCK(locker_);
-
-  android::status_t status = 0;
-
-  switch (command) {
-  case qService::IQService::DYNAMIC_DEBUG:
-    DynamicDebug(input_parcel);
-    break;
-
-  case qService::IQService::SCREEN_REFRESH:
-    AsyncRefresh();
-    break;
-
-  case qService::IQService::SET_IDLE_TIMEOUT:
-    if (hwc_display_[HWC_DISPLAY_PRIMARY]) {
-      uint32_t timeout = UINT32(input_parcel->readInt32());
-      hwc_display_[HWC_DISPLAY_PRIMARY]->SetIdleTimeoutMs(timeout);
-    }
-    break;
-
-  case qService::IQService::SET_FRAME_DUMP_CONFIG:
-    SetFrameDumpConfig(input_parcel);
-    break;
-
-  case qService::IQService::SET_MAX_PIPES_PER_MIXER:
-    status = SetMaxMixerStages(input_parcel);
-    break;
-
-  case qService::IQService::SET_DISPLAY_MODE:
-    status = SetDisplayMode(input_parcel);
-    break;
-
-  case qService::IQService::SET_SECONDARY_DISPLAY_STATUS:
-    status = SetSecondaryDisplayStatus(input_parcel, output_parcel);
-    break;
-
-  case qService::IQService::CONFIGURE_DYN_REFRESH_RATE:
-    status = ConfigureRefreshRate(input_parcel);
-    break;
-
-  case qService::IQService::SET_VIEW_FRAME:
-    break;
-
-  case qService::IQService::TOGGLE_SCREEN_UPDATES:
-    status = ToggleScreenUpdates(input_parcel, output_parcel);
-    break;
-
-  case qService::IQService::QDCM_SVC_CMDS:
-    status = QdcmCMDHandler(input_parcel, output_parcel);
-    break;
-
-  case qService::IQService::MIN_HDCP_ENCRYPTION_LEVEL_CHANGED:
-    status = OnMinHdcpEncryptionLevelChange(input_parcel, output_parcel);
-    break;
-
-  case qService::IQService::CONTROL_PARTIAL_UPDATE:
-    status = ControlPartialUpdate(input_parcel, output_parcel);
-    break;
-
-  case qService::IQService::SET_ACTIVE_CONFIG:
-    status = HandleSetActiveDisplayConfig(input_parcel, output_parcel);
-    break;
-
-  case qService::IQService::GET_ACTIVE_CONFIG:
-    status = HandleGetActiveDisplayConfig(input_parcel, output_parcel);
-    break;
-
-  case qService::IQService::GET_CONFIG_COUNT:
-    status = HandleGetDisplayConfigCount(input_parcel, output_parcel);
-    break;
-
-  case qService::IQService::GET_DISPLAY_ATTRIBUTES_FOR_CONFIG:
-    status = HandleGetDisplayAttributesForConfig(input_parcel, output_parcel);
-    break;
-
-  case qService::IQService::GET_PANEL_BRIGHTNESS:
-    status = GetPanelBrightness(input_parcel, output_parcel);
-    break;
-
-  case qService::IQService::SET_PANEL_BRIGHTNESS:
-    status = SetPanelBrightness(input_parcel, output_parcel);
-    break;
-
-  case qService::IQService::GET_DISPLAY_VISIBLE_REGION:
-    status = GetVisibleDisplayRect(input_parcel, output_parcel);
-    break;
-
-  case qService::IQService::SET_CAMERA_STATUS:
-    status = SetDynamicBWForCamera(input_parcel, output_parcel);
-    break;
-
-  case qService::IQService::GET_BW_TRANSACTION_STATUS:
-    status = GetBWTransactionStatus(input_parcel, output_parcel);
-    break;
-
-  case qService::IQService::SET_LAYER_MIXER_RESOLUTION:
-    status = SetMixerResolution(input_parcel);
-    break;
-
-  case qService::IQService::GET_HDR_CAPABILITIES:
-    status = GetHdrCapabilities(input_parcel, output_parcel);
-    break;
-
-  default:
-    DLOGW("QService command = %d is not supported", command);
-    return -EINVAL;
-  }
-
-  return status;
-}
-
-android::status_t HWCSession::ToggleScreenUpdates(const android::Parcel *input_parcel,
-                                                  android::Parcel *output_parcel) {
-  int input = input_parcel->readInt32();
-  int error = android::BAD_VALUE;
-
-  if (hwc_display_[HWC_DISPLAY_PRIMARY] && (input <= 1) && (input >= 0)) {
-    error = hwc_display_[HWC_DISPLAY_PRIMARY]->ToggleScreenUpdates(input == 1);
-    if (error != 0) {
-      DLOGE("Failed to toggle screen updates = %d. Error = %d", input, error);
-    }
-  }
-  output_parcel->writeInt32(error);
-
-  return error;
-}
-
-android::status_t HWCSession::SetPanelBrightness(const android::Parcel *input_parcel,
-                                                 android::Parcel *output_parcel) {
-  int level = input_parcel->readInt32();
-  int error = android::BAD_VALUE;
-
-  if (hwc_display_[HWC_DISPLAY_PRIMARY]) {
-    error = hwc_display_[HWC_DISPLAY_PRIMARY]->SetPanelBrightness(level);
-    if (error != 0) {
-      DLOGE("Failed to set the panel brightness = %d. Error = %d", level, error);
-    }
-  }
-  output_parcel->writeInt32(error);
-
-  return error;
-}
-
-android::status_t HWCSession::GetPanelBrightness(const android::Parcel *input_parcel,
-                                                 android::Parcel *output_parcel) {
-  int error = android::BAD_VALUE;
-  int ret = error;
-
-  if (hwc_display_[HWC_DISPLAY_PRIMARY]) {
-    error = hwc_display_[HWC_DISPLAY_PRIMARY]->GetPanelBrightness(&ret);
-    if (error != 0) {
-      ret = error;
-      DLOGE("Failed to get the panel brightness. Error = %d", error);
-    }
-  }
-  output_parcel->writeInt32(ret);
-
-  return error;
-}
-
-android::status_t HWCSession::ControlPartialUpdate(const android::Parcel *input_parcel,
-                                                   android::Parcel *output_parcel) {
-  DisplayError error = kErrorNone;
-  int ret = 0;
-  uint32_t disp_id = UINT32(input_parcel->readInt32());
-  uint32_t enable = UINT32(input_parcel->readInt32());
-
-  if (disp_id != HWC_DISPLAY_PRIMARY) {
-    DLOGW("CONTROL_PARTIAL_UPDATE is not applicable for display = %d", disp_id);
-    ret = -EINVAL;
-    output_parcel->writeInt32(ret);
-    return ret;
-  }
-
-  if (!hwc_display_[HWC_DISPLAY_PRIMARY]) {
-    DLOGE("primary display object is not instantiated");
-    ret = -EINVAL;
-    output_parcel->writeInt32(ret);
-    return ret;
-  }
-
-  uint32_t pending = 0;
-  error = hwc_display_[HWC_DISPLAY_PRIMARY]->ControlPartialUpdate(enable, &pending);
-
-  if (error == kErrorNone) {
-    if (!pending) {
-      output_parcel->writeInt32(ret);
-      return ret;
-    }
-  } else if (error == kErrorNotSupported) {
-    output_parcel->writeInt32(ret);
-    return ret;
-  } else {
-    ret = -EINVAL;
-    output_parcel->writeInt32(ret);
-    return ret;
-  }
-
-  AsyncRefresh();
-
-  // Wait until partial update control is complete
-  ret = locker_.WaitFinite(kPartialUpdateControlTimeoutMs);
-
-  output_parcel->writeInt32(ret);
-
-  return ret;
-}
-
-android::status_t HWCSession::HandleSetActiveDisplayConfig(const android::Parcel *input_parcel,
-                                                           android::Parcel *output_parcel) {
-  int config = input_parcel->readInt32();
-  int dpy = input_parcel->readInt32();
-  int error = android::BAD_VALUE;
-
-  if (dpy > HWC_DISPLAY_VIRTUAL) {
-    return android::BAD_VALUE;
-  }
-
-  if (hwc_display_[dpy]) {
-    error = hwc_display_[dpy]->SetActiveDisplayConfig(config);
-    if (error == 0) {
-      AsyncRefresh();
-    }
-  }
-
-  return error;
-}
-
-android::status_t HWCSession::HandleGetActiveDisplayConfig(const android::Parcel *input_parcel,
-                                                           android::Parcel *output_parcel) {
-  int dpy = input_parcel->readInt32();
-  int error = android::BAD_VALUE;
-
-  if (dpy > HWC_DISPLAY_VIRTUAL) {
-    return android::BAD_VALUE;
-  }
-
-  if (hwc_display_[dpy]) {
-    uint32_t config = 0;
-    error = hwc_display_[dpy]->GetActiveDisplayConfig(&config);
-    if (error == 0) {
-      output_parcel->writeInt32(INT(config));
-    }
-  }
-
-  return error;
-}
-
-android::status_t HWCSession::HandleGetDisplayConfigCount(const android::Parcel *input_parcel,
-                                                          android::Parcel *output_parcel) {
-  int dpy = input_parcel->readInt32();
-  int error = android::BAD_VALUE;
-
-  if (dpy > HWC_DISPLAY_VIRTUAL) {
-    return android::BAD_VALUE;
-  }
-
-  uint32_t count = 0;
-  if (hwc_display_[dpy]) {
-    error = hwc_display_[dpy]->GetDisplayConfigCount(&count);
-    if (error == 0) {
-      output_parcel->writeInt32(INT(count));
-    }
-  }
-
-  return error;
-}
-
-android::status_t HWCSession::SetDisplayPort(DisplayPort sdm_disp_port, int *hwc_disp_port) {
-  if (!hwc_disp_port) {
-    return -EINVAL;
-  }
-
-  switch (sdm_disp_port) {
-    case kPortDSI:
-      *hwc_disp_port = qdutils::DISPLAY_PORT_DSI;
-      break;
-    case kPortDTV:
-      *hwc_disp_port = qdutils::DISPLAY_PORT_DTV;
-      break;
-    case kPortLVDS:
-      *hwc_disp_port = qdutils::DISPLAY_PORT_LVDS;
-      break;
-    case kPortEDP:
-      *hwc_disp_port = qdutils::DISPLAY_PORT_EDP;
-      break;
-    case kPortWriteBack:
-      *hwc_disp_port = qdutils::DISPLAY_PORT_WRITEBACK;
-      break;
-    case kPortDP:
-      *hwc_disp_port = qdutils::DISPLAY_PORT_DP;
-      break;
-    case kPortDefault:
-      *hwc_disp_port = qdutils::DISPLAY_PORT_DEFAULT;
-      break;
-    default:
-      DLOGE("Invalid sdm display port %d", sdm_disp_port);
-      return -EINVAL;
-  }
-
-  return 0;
-}
-
-android::status_t HWCSession::HandleGetDisplayAttributesForConfig(const android::Parcel
-                                                                  *input_parcel,
-                                                                  android::Parcel *output_parcel) {
-  int config = input_parcel->readInt32();
-  int dpy = input_parcel->readInt32();
-  int error = android::BAD_VALUE;
-  DisplayConfigVariableInfo display_attributes;
-  DisplayPort sdm_disp_port = kPortDefault;
-  int hwc_disp_port = qdutils::DISPLAY_PORT_DEFAULT;
-
-  if (dpy > HWC_DISPLAY_VIRTUAL) {
-    return android::BAD_VALUE;
-  }
-
-  if (hwc_display_[dpy]) {
-    error = hwc_display_[dpy]->GetDisplayAttributesForConfig(config, &display_attributes);
-    if (error == 0) {
-      hwc_display_[dpy]->GetDisplayPort(&sdm_disp_port);
-
-      SetDisplayPort(sdm_disp_port, &hwc_disp_port);
-
-      output_parcel->writeInt32(INT(display_attributes.vsync_period_ns));
-      output_parcel->writeInt32(INT(display_attributes.x_pixels));
-      output_parcel->writeInt32(INT(display_attributes.y_pixels));
-      output_parcel->writeFloat(display_attributes.x_dpi);
-      output_parcel->writeFloat(display_attributes.y_dpi);
-      output_parcel->writeInt32(hwc_disp_port);
-      output_parcel->writeInt32(display_attributes.is_yuv);
-    }
-  }
-
-  return error;
-}
-
-android::status_t HWCSession::SetSecondaryDisplayStatus(const android::Parcel *input_parcel,
-                                                        android::Parcel *output_parcel) {
-  int ret = -EINVAL;
-
-  uint32_t display_id = UINT32(input_parcel->readInt32());
-  uint32_t display_status = UINT32(input_parcel->readInt32());
-
-  DLOGI("Display = %d, Status = %d", display_id, display_status);
-
-  if (display_id >= HWC_NUM_DISPLAY_TYPES) {
-    DLOGE("Invalid display_id");
-  } else if (display_id == HWC_DISPLAY_PRIMARY) {
-    DLOGE("Not supported for this display");
-  } else if (!hwc_display_[display_id]) {
-    DLOGW("Display is not connected");
-  } else {
-    ret = hwc_display_[display_id]->SetDisplayStatus(display_status);
-  }
-
-  output_parcel->writeInt32(ret);
-
-  return ret;
-}
-
-android::status_t HWCSession::ConfigureRefreshRate(const android::Parcel *input_parcel) {
-  uint32_t operation = UINT32(input_parcel->readInt32());
-  switch (operation) {
-    case qdutils::DISABLE_METADATA_DYN_REFRESH_RATE:
-      return hwc_display_[HWC_DISPLAY_PRIMARY]->Perform(
-          HWCDisplayPrimary::SET_METADATA_DYN_REFRESH_RATE, false);
-    case qdutils::ENABLE_METADATA_DYN_REFRESH_RATE:
-      return hwc_display_[HWC_DISPLAY_PRIMARY]->Perform(
-          HWCDisplayPrimary::SET_METADATA_DYN_REFRESH_RATE, true);
-    case qdutils::SET_BINDER_DYN_REFRESH_RATE:
-      {
-        uint32_t refresh_rate = UINT32(input_parcel->readInt32());
-        return hwc_display_[HWC_DISPLAY_PRIMARY]->Perform(
-            HWCDisplayPrimary::SET_BINDER_DYN_REFRESH_RATE,
-            refresh_rate);
-      }
-    default:
-      DLOGW("Invalid operation %d", operation);
-      return -EINVAL;
-  }
-
-  return 0;
-}
-
-android::status_t HWCSession::SetDisplayMode(const android::Parcel *input_parcel) {
-  uint32_t mode = UINT32(input_parcel->readInt32());
-  return hwc_display_[HWC_DISPLAY_PRIMARY]->Perform(HWCDisplayPrimary::SET_DISPLAY_MODE, mode);
-}
-
-android::status_t HWCSession::SetMaxMixerStages(const android::Parcel *input_parcel) {
-  DisplayError error = kErrorNone;
-  std::bitset<32> bit_mask_display_type = UINT32(input_parcel->readInt32());
-  uint32_t max_mixer_stages = UINT32(input_parcel->readInt32());
-
-  if (bit_mask_display_type[HWC_DISPLAY_PRIMARY]) {
-    if (hwc_display_[HWC_DISPLAY_PRIMARY]) {
-      error = hwc_display_[HWC_DISPLAY_PRIMARY]->SetMaxMixerStages(max_mixer_stages);
-      if (error != kErrorNone) {
-        return -EINVAL;
-      }
-    }
-  }
-
-  if (bit_mask_display_type[HWC_DISPLAY_EXTERNAL]) {
-    if (hwc_display_[HWC_DISPLAY_EXTERNAL]) {
-      error = hwc_display_[HWC_DISPLAY_EXTERNAL]->SetMaxMixerStages(max_mixer_stages);
-      if (error != kErrorNone) {
-        return -EINVAL;
-      }
-    }
-  }
-
-  if (bit_mask_display_type[HWC_DISPLAY_VIRTUAL]) {
-    if (hwc_display_[HWC_DISPLAY_VIRTUAL]) {
-      error = hwc_display_[HWC_DISPLAY_VIRTUAL]->SetMaxMixerStages(max_mixer_stages);
-      if (error != kErrorNone) {
-        return -EINVAL;
-      }
-    }
-  }
-
-  return 0;
-}
-
-android::status_t HWCSession::SetDynamicBWForCamera(const android::Parcel *input_parcel,
-                                                    android::Parcel *output_parcel) {
-  DisplayError error = kErrorNone;
-  uint32_t camera_status = UINT32(input_parcel->readInt32());
-  HWBwModes mode = camera_status > 0 ? kBwCamera : kBwDefault;
-
-  // trigger invalidate to apply new bw caps.
-  AsyncRefresh();
-
-    error = core_intf_->SetMaxBandwidthMode(mode);
-  if (error != kErrorNone) {
-      return -EINVAL;
-  }
-
-  new_bw_mode_ = true;
-  need_invalidate_ = true;
-
-  return 0;
-}
-
-android::status_t HWCSession::GetBWTransactionStatus(const android::Parcel *input_parcel,
-                                                     android::Parcel *output_parcel)  {
-  bool state = true;
-
-  if (hwc_display_[HWC_DISPLAY_PRIMARY]) {
-    if (sync_wait(bw_mode_release_fd_, 0) < 0) {
-      DLOGI("bw_transaction_release_fd is not yet signalled: err= %s", strerror(errno));
-      state = false;
-    }
-    output_parcel->writeInt32(state);
-  }
-
-  return 0;
-}
-
-void HWCSession::SetFrameDumpConfig(const android::Parcel *input_parcel) {
-  uint32_t frame_dump_count = UINT32(input_parcel->readInt32());
-  std::bitset<32> bit_mask_display_type = UINT32(input_parcel->readInt32());
-  uint32_t bit_mask_layer_type = UINT32(input_parcel->readInt32());
-
-  if (bit_mask_display_type[HWC_DISPLAY_PRIMARY]) {
-    if (hwc_display_[HWC_DISPLAY_PRIMARY]) {
-      hwc_display_[HWC_DISPLAY_PRIMARY]->SetFrameDumpConfig(frame_dump_count, bit_mask_layer_type);
-    }
-  }
-
-  if (bit_mask_display_type[HWC_DISPLAY_EXTERNAL]) {
-    if (hwc_display_[HWC_DISPLAY_EXTERNAL]) {
-      hwc_display_[HWC_DISPLAY_EXTERNAL]->SetFrameDumpConfig(frame_dump_count, bit_mask_layer_type);
-    }
-  }
-
-  if (bit_mask_display_type[HWC_DISPLAY_VIRTUAL]) {
-    if (hwc_display_[HWC_DISPLAY_VIRTUAL]) {
-      hwc_display_[HWC_DISPLAY_VIRTUAL]->SetFrameDumpConfig(frame_dump_count, bit_mask_layer_type);
-    }
-  }
-}
-
-android::status_t HWCSession::SetMixerResolution(const android::Parcel *input_parcel) {
-  DisplayError error = kErrorNone;
-  uint32_t dpy = UINT32(input_parcel->readInt32());
-
-  if (dpy != HWC_DISPLAY_PRIMARY) {
-    DLOGI("Resoulution change not supported for this display %d", dpy);
-    return -EINVAL;
-  }
-
-  if (!hwc_display_[HWC_DISPLAY_PRIMARY]) {
-    DLOGI("Primary display is not initialized");
-    return -EINVAL;
-  }
-
-  uint32_t width = UINT32(input_parcel->readInt32());
-  uint32_t height = UINT32(input_parcel->readInt32());
-
-  error = hwc_display_[HWC_DISPLAY_PRIMARY]->SetMixerResolution(width, height);
-  if (error != kErrorNone) {
-    return -EINVAL;
-  }
-
-  return 0;
-}
-
-android::status_t HWCSession::GetHdrCapabilities(const android::Parcel *input_parcel,
-                                                 android::Parcel *output_parcel) {
-  uint32_t display_id = UINT32(input_parcel->readInt32());
-  if (display_id >= HWC_NUM_DISPLAY_TYPES) {
-    DLOGE("Invalid display id = %d", display_id);
-    return -EINVAL;
-  }
-
-  if (hwc_display_[display_id] == NULL) {
-    DLOGW("Display = %d not initialized", display_id);
-    return -EINVAL;
-  }
-
-  DisplayConfigFixedInfo fixed_info = {};
-  int ret = hwc_display_[display_id]->GetDisplayFixedConfig(&fixed_info);
-  if (ret) {
-    DLOGE("Failed");
-    return ret;
-  }
-
-  if (!fixed_info.hdr_supported) {
-    DLOGI("HDR is not supported");
-    return 0;
-  }
-
-  std::vector<int32_t> supported_hdr_types;
-  // Only HDR10 supported now, in future add other supported HDR formats(HLG, DolbyVision)
-  supported_hdr_types.push_back(HAL_HDR_HDR10);
-
-  static const float kLuminanceFactor = 10000.0;
-  // luminance is expressed in the unit of 0.0001 cd/m2, convert it to 1cd/m2.
-  float max_luminance = FLOAT(fixed_info.max_luminance)/kLuminanceFactor;
-  float max_average_luminance = FLOAT(fixed_info.average_luminance)/kLuminanceFactor;
-  float min_luminance = FLOAT(fixed_info.min_luminance)/kLuminanceFactor;
-
-  if (output_parcel != nullptr) {
-    output_parcel->writeInt32Vector(supported_hdr_types);
-    output_parcel->writeFloat(max_luminance);
-    output_parcel->writeFloat(max_average_luminance);
-    output_parcel->writeFloat(min_luminance);
-  }
-
-  return 0;
-}
-
-void HWCSession::DynamicDebug(const android::Parcel *input_parcel) {
-  int type = input_parcel->readInt32();
-  bool enable = (input_parcel->readInt32() > 0);
-  DLOGI("type = %d enable = %d", type, enable);
-  int verbose_level = input_parcel->readInt32();
-
-  switch (type) {
-  case qService::IQService::DEBUG_ALL:
-    HWCDebugHandler::DebugAll(enable, verbose_level);
-    break;
-
-  case qService::IQService::DEBUG_MDPCOMP:
-    HWCDebugHandler::DebugStrategy(enable, verbose_level);
-    HWCDebugHandler::DebugCompManager(enable, verbose_level);
-    break;
-
-  case qService::IQService::DEBUG_PIPE_LIFECYCLE:
-    HWCDebugHandler::DebugResources(enable, verbose_level);
-    break;
-
-  case qService::IQService::DEBUG_DRIVER_CONFIG:
-    HWCDebugHandler::DebugDriverConfig(enable, verbose_level);
-    break;
-
-  case qService::IQService::DEBUG_ROTATOR:
-    HWCDebugHandler::DebugResources(enable, verbose_level);
-    HWCDebugHandler::DebugDriverConfig(enable, verbose_level);
-    HWCDebugHandler::DebugRotator(enable, verbose_level);
-    break;
-
-  case qService::IQService::DEBUG_QDCM:
-    HWCDebugHandler::DebugQdcm(enable, verbose_level);
-    break;
-
-  default:
-    DLOGW("type = %d is not supported", type);
-  }
-}
-
-android::status_t HWCSession::QdcmCMDHandler(const android::Parcel *input_parcel,
-                                             android::Parcel *output_parcel) {
-  int ret = 0;
-  int32_t *brightness_value = NULL;
-  uint32_t display_id(0);
-  PPPendingParams pending_action;
-  PPDisplayAPIPayload resp_payload, req_payload;
-
-  if (!color_mgr_) {
-    return -1;
-  }
-
-  pending_action.action = kNoAction;
-  pending_action.params = NULL;
-
-  // Read display_id, payload_size and payload from in_parcel.
-  ret = HWCColorManager::CreatePayloadFromParcel(*input_parcel, &display_id, &req_payload);
-  if (!ret) {
-    if (HWC_DISPLAY_PRIMARY == display_id && hwc_display_[HWC_DISPLAY_PRIMARY])
-      ret = hwc_display_[HWC_DISPLAY_PRIMARY]->ColorSVCRequestRoute(req_payload,
-                                                                  &resp_payload, &pending_action);
-
-    if (HWC_DISPLAY_EXTERNAL == display_id && hwc_display_[HWC_DISPLAY_EXTERNAL])
-      ret = hwc_display_[HWC_DISPLAY_EXTERNAL]->ColorSVCRequestRoute(req_payload, &resp_payload,
-                                                                  &pending_action);
-  }
-
-  if (ret) {
-    output_parcel->writeInt32(ret);  // first field in out parcel indicates return code.
-    req_payload.DestroyPayload();
-    resp_payload.DestroyPayload();
-    return ret;
-  }
-
-  switch (pending_action.action) {
-    case kInvalidating:
-      AsyncRefresh();
-      break;
-    case kEnterQDCMMode:
-      ret = color_mgr_->EnableQDCMMode(true, hwc_display_[HWC_DISPLAY_PRIMARY]);
-      break;
-    case kExitQDCMMode:
-      ret = color_mgr_->EnableQDCMMode(false, hwc_display_[HWC_DISPLAY_PRIMARY]);
-      break;
-    case kApplySolidFill:
-      ret = color_mgr_->SetSolidFill(pending_action.params,
-                                     true, hwc_display_[HWC_DISPLAY_PRIMARY]);
-      AsyncRefresh();
-      break;
-    case kDisableSolidFill:
-      ret = color_mgr_->SetSolidFill(pending_action.params,
-                                     false, hwc_display_[HWC_DISPLAY_PRIMARY]);
-      AsyncRefresh();
-      break;
-    case kSetPanelBrightness:
-      brightness_value = reinterpret_cast<int32_t*>(resp_payload.payload);
-      if (brightness_value == NULL) {
-        DLOGE("Brightness value is Null");
-        return -EINVAL;
-      }
-      if (HWC_DISPLAY_PRIMARY == display_id)
-        ret = hwc_display_[HWC_DISPLAY_PRIMARY]->SetPanelBrightness(*brightness_value);
-      break;
-    case kEnableFrameCapture:
-      ret = color_mgr_->SetFrameCapture(pending_action.params,
-                                        true, hwc_display_[HWC_DISPLAY_PRIMARY]);
-      AsyncRefresh();
-      break;
-    case kDisableFrameCapture:
-      ret = color_mgr_->SetFrameCapture(pending_action.params,
-                                        false, hwc_display_[HWC_DISPLAY_PRIMARY]);
-      break;
-    case kConfigureDetailedEnhancer:
-      ret = color_mgr_->SetDetailedEnhancer(pending_action.params,
-                                            hwc_display_[HWC_DISPLAY_PRIMARY]);
-      AsyncRefresh();
-      break;
-    case kInvalidatingAndkSetPanelBrightness:
-      brightness_value = reinterpret_cast<int32_t*>(resp_payload.payload);
-      if (brightness_value == NULL) {
-        DLOGE("Brightness value is Null");
-        return -EINVAL;
-      }
-      if (HWC_DISPLAY_PRIMARY == display_id)
-        ret = hwc_display_[HWC_DISPLAY_PRIMARY]->CachePanelBrightness(*brightness_value);
-      AsyncRefresh();
-      break;
-    case kNoAction:
-      break;
-    default:
-      DLOGW("Invalid pending action = %d!", pending_action.action);
-      break;
-  }
-
-  // for display API getter case, marshall returned params into out_parcel.
-  output_parcel->writeInt32(ret);
-  HWCColorManager::MarshallStructIntoParcel(resp_payload, output_parcel);
-  req_payload.DestroyPayload();
-  resp_payload.DestroyPayload();
-
-  return (ret? -EINVAL : 0);
-}
-
-android::status_t HWCSession::OnMinHdcpEncryptionLevelChange(const android::Parcel *input_parcel,
-                                                             android::Parcel *output_parcel) {
-  int ret = -EINVAL;
-  uint32_t display_id = UINT32(input_parcel->readInt32());
-  uint32_t min_enc_level = UINT32(input_parcel->readInt32());
-
-  DLOGI("Display %d", display_id);
-
-  if (display_id >= HWC_NUM_DISPLAY_TYPES) {
-    DLOGE("Invalid display_id");
-  } else if (display_id != HWC_DISPLAY_EXTERNAL) {
-    DLOGE("Not supported for display");
-  } else if (!hwc_display_[display_id]) {
-    DLOGW("Display is not connected");
-  } else {
-    ret = hwc_display_[display_id]->OnMinHdcpEncryptionLevelChange(min_enc_level);
-  }
-
-  output_parcel->writeInt32(ret);
-
-  return ret;
-}
-
-void* HWCSession::HWCUeventThread(void *context) {
-  if (context) {
-    return reinterpret_cast<HWCSession *>(context)->HWCUeventThreadHandler();
-  }
-
-  return NULL;
-}
-
-void* HWCSession::HWCUeventThreadHandler() {
-  static char uevent_data[PAGE_SIZE];
-  int length = 0;
-
-  uevent_locker_.Lock();
-  prctl(PR_SET_NAME, uevent_thread_name_, 0, 0, 0);
-  setpriority(PRIO_PROCESS, 0, HAL_PRIORITY_URGENT_DISPLAY);
-  if (!uevent_init()) {
-    DLOGE("Failed to init uevent");
-    pthread_exit(0);
-    uevent_locker_.Signal();
-    uevent_locker_.Unlock();
-    return NULL;
-  }
-
-  uevent_locker_.Signal();
-  uevent_locker_.Unlock();
-
-  while (!uevent_thread_exit_) {
-    // keep last 2 zeroes to ensure double 0 termination
-    length = uevent_next_event(uevent_data, INT32(sizeof(uevent_data)) - 2);
-
-    if (strcasestr(HWC_UEVENT_SWITCH_HDMI, uevent_data)) {
-      DLOGI("Uevent HDMI = %s", uevent_data);
-      int connected = GetEventValue(uevent_data, length, "SWITCH_STATE=");
-      if (connected >= 0) {
-        DLOGI("HDMI = %s", connected ? "connected" : "disconnected");
-        if (HotPlugHandler(connected) == -1) {
-          DLOGE("Failed handling Hotplug = %s", connected ? "connected" : "disconnected");
-        }
-      }
-    } else if (strcasestr(HWC_UEVENT_GRAPHICS_FB0, uevent_data)) {
-      DLOGI("Uevent FB0 = %s", uevent_data);
-      int panel_reset = GetEventValue(uevent_data, length, "PANEL_ALIVE=");
-      if (panel_reset == 0) {
-        if (hwc_procs_) {
-          reset_panel_ = true;
-          AsyncRefresh();
-        } else {
-          DLOGW("Ignore resetpanel - hwc_proc not registered");
-        }
-      }
-    }
-  }
-  pthread_exit(0);
-
-  return NULL;
-}
-
-int HWCSession::GetEventValue(const char *uevent_data, int length, const char *event_info) {
-  const char *iterator_str = uevent_data;
-  while (((iterator_str - uevent_data) <= length) && (*iterator_str)) {
-    const char *pstr = strstr(iterator_str, event_info);
-    if (pstr != NULL) {
-      return (atoi(iterator_str + strlen(event_info)));
-    }
-    iterator_str += strlen(iterator_str) + 1;
-  }
-
-  return -1;
-}
-
-void HWCSession::ResetPanel() {
-  int status = -EINVAL;
-
-  DLOGI("Powering off primary");
-  status = hwc_display_[HWC_DISPLAY_PRIMARY]->SetPowerMode(HWC_POWER_MODE_OFF);
-  if (status) {
-    DLOGE("power-off on primary failed with error = %d", status);
-  }
-
-  DLOGI("Restoring power mode on primary");
-  int32_t mode = INT(hwc_display_[HWC_DISPLAY_PRIMARY]->GetLastPowerMode());
-  status = hwc_display_[HWC_DISPLAY_PRIMARY]->SetPowerMode(mode);
-  if (status) {
-    DLOGE("Setting power mode = %d on primary failed with error = %d", mode, status);
-  }
-
-  status = hwc_display_[HWC_DISPLAY_PRIMARY]->EventControl(HWC_EVENT_VSYNC, 1);
-  if (status) {
-    DLOGE("enabling vsync failed for primary with error = %d", status);
-  }
-
-  reset_panel_ = false;
-}
-
-int HWCSession::HotPlugHandler(bool connected) {
-  int status = 0;
-  bool notify_hotplug = false;
-  bool refresh_screen = false;
-
-  // To prevent sending events to client while a lock is held, acquire scope locks only within
-  // below scope so that those get automatically unlocked after the scope ends.
-  {
-    SEQUENCE_WAIT_SCOPE_LOCK(locker_);
-
-    if (!hwc_display_[HWC_DISPLAY_PRIMARY]) {
-      DLOGE("Primay display is not connected.");
-      return -1;
-    }
-
-
-    HWCDisplay *primary_display = hwc_display_[HWC_DISPLAY_PRIMARY];
-    HWCDisplay *external_display = NULL;
-    HWCDisplay *null_display = NULL;
-
-    if (primary_display->GetDisplayClass() == DISPLAY_CLASS_EXTERNAL) {
-      external_display = static_cast<HWCDisplayExternal *>(hwc_display_[HWC_DISPLAY_PRIMARY]);
-    } else if (primary_display->GetDisplayClass() == DISPLAY_CLASS_NULL) {
-      null_display = static_cast<HWCDisplayNull *>(hwc_display_[HWC_DISPLAY_PRIMARY]);
-    }
-
-    // If primary display connected is a NULL display, then replace it with the external display
-    if (connected) {
-      // If we are in HDMI as primary and the primary display just got plugged in
-      if (is_hdmi_primary_ && null_display) {
-        uint32_t primary_width, primary_height;
-        int status = 0;
-        null_display->GetFrameBufferResolution(&primary_width, &primary_height);
-        delete null_display;
-        hwc_display_[HWC_DISPLAY_PRIMARY] = NULL;
-
-        // Create external display with a forced framebuffer resolution to that of what the NULL
-        // display had. This is necessary because SurfaceFlinger does not dynamically update
-        // framebuffer resolution once it reads it at bootup. So we always have to have the NULL
-        // display/external display both at the bootup resolution.
-        status = CreateExternalDisplay(HWC_DISPLAY_PRIMARY, primary_width, primary_height, true);
-        if (status) {
-          DLOGE("Could not create external display");
-          return -1;
-        }
-
-        status = hwc_display_[HWC_DISPLAY_PRIMARY]->SetPowerMode(HWC_POWER_MODE_NORMAL);
-        if (status) {
-          DLOGE("power-on on primary failed with error = %d", status);
-        }
-
-        is_hdmi_yuv_ = IsDisplayYUV(HWC_DISPLAY_PRIMARY);
-
-        // Next, go ahead and enable vsync on external display. This is expliclity required
-        // because in HDMI as primary case, SurfaceFlinger may not be aware of underlying
-        // changing display. and thus may not explicitly enable vsync
-
-        status = hwc_display_[HWC_DISPLAY_PRIMARY]->EventControl(HWC_EVENT_VSYNC, true);
-        if (status) {
-          DLOGE("Error enabling vsync for HDMI as primary case");
-        }
-        // Don't do hotplug notification for HDMI as primary case for now
-        notify_hotplug = false;
-        refresh_screen = true;
-      } else {
-        if (hwc_display_[HWC_DISPLAY_EXTERNAL]) {
-          DLOGE("HDMI is already connected");
-          return -1;
-        }
-
-        // Connect external display if virtual display is not connected.
-        // Else, defer external display connection and process it when virtual display
-        // tears down; Do not notify SurfaceFlinger since connection is deferred now.
-        if (!hwc_display_[HWC_DISPLAY_VIRTUAL]) {
-          status = ConnectDisplay(HWC_DISPLAY_EXTERNAL, NULL);
-          if (status) {
-            return status;
-          }
-          notify_hotplug = true;
-        } else {
-          DLOGI("Virtual display is connected, pending connection");
-          external_pending_connect_ = true;
-        }
-      }
-    } else {
-      // Do not return error if external display is not in connected status.
-      // Due to virtual display concurrency, external display connection might be still pending
-      // but hdmi got disconnected before pending connection could be processed.
-
-      if (is_hdmi_primary_ && external_display) {
-        uint32_t x_res, y_res;
-        external_display->GetFrameBufferResolution(&x_res, &y_res);
-        // Need to manually disable VSYNC as SF is not aware of connect/disconnect cases
-        // for HDMI as primary
-        external_display->EventControl(HWC_EVENT_VSYNC, false);
-        HWCDisplayExternal::Destroy(external_display);
-
-        HWCDisplayNull *null_display;
-
-        int status = HWCDisplayNull::Create(core_intf_, &hwc_procs_,
-                                            reinterpret_cast<HWCDisplay **>(&null_display));
-
-        if (status) {
-          DLOGE("Could not create Null display when primary got disconnected");
-          return -1;
-        }
-
-        null_display->SetResolution(x_res, y_res);
-        hwc_display_[HWC_DISPLAY_PRIMARY] = null_display;
-
-        // Don't do hotplug notification for HDMI as primary case for now
-        notify_hotplug = false;
-      } else {
-        if (hwc_display_[HWC_DISPLAY_EXTERNAL]) {
-          status = DisconnectDisplay(HWC_DISPLAY_EXTERNAL);
-          notify_hotplug = true;
-        }
-        external_pending_connect_ = false;
-      }
-    }
-  }
-
-  if (connected && (notify_hotplug || refresh_screen)) {
-    // trigger screen refresh to ensure sufficient resources are available to process new
-    // new display connection.
-    hwc_procs_->invalidate(hwc_procs_);
-    uint32_t vsync_period = UINT32(GetVsyncPeriod(HWC_DISPLAY_PRIMARY));
-    usleep(vsync_period * 2 / 1000);
-  }
-  // notify client
-  if (notify_hotplug) {
-    hwc_procs_->hotplug(hwc_procs_, HWC_DISPLAY_EXTERNAL, connected);
-  }
-
-  qservice_->onHdmiHotplug(INT(connected));
-
-  return 0;
-}
-
-void HWCSession::HandleSecureDisplaySession(hwc_display_contents_1_t **displays) {
-  secure_display_active_ = false;
-  if (!*displays) {
-    DLOGW("Invalid display contents");
-    return;
-  }
-
-  hwc_display_contents_1_t *content_list = displays[HWC_DISPLAY_PRIMARY];
-  if (!content_list) {
-    DLOGW("Invalid primary content list");
-    return;
-  }
-  size_t num_hw_layers = content_list->numHwLayers;
-
-  for (size_t i = 0; i < num_hw_layers - 1; i++) {
-    hwc_layer_1_t &hwc_layer = content_list->hwLayers[i];
-    const private_handle_t *pvt_handle = static_cast<const private_handle_t *>(hwc_layer.handle);
-    if (pvt_handle && pvt_handle->flags & private_handle_t::PRIV_FLAGS_SECURE_DISPLAY) {
-      secure_display_active_ = true;
-    }
-  }
-
-  // Force flush on primary during transitions(secure<->non secure)
-  // when external displays are connected.
-  bool force_flush = false;
-  if ((connected_displays_[HWC_DISPLAY_PRIMARY] == 1) &&
-     ((connected_displays_[HWC_DISPLAY_EXTERNAL] == 1) ||
-      (connected_displays_[HWC_DISPLAY_VIRTUAL] == 1))) {
-    force_flush = true;
-  }
-
-  for (ssize_t dpy = static_cast<ssize_t>(HWC_NUM_DISPLAY_TYPES - 1); dpy >= 0; dpy--) {
-    if (hwc_display_[dpy]) {
-      hwc_display_[dpy]->SetSecureDisplay(secure_display_active_, force_flush);
-    }
-  }
-}
-
-android::status_t HWCSession::GetVisibleDisplayRect(const android::Parcel *input_parcel,
-                                                    android::Parcel *output_parcel) {
-  int dpy = input_parcel->readInt32();
-
-  if (dpy < HWC_DISPLAY_PRIMARY || dpy > HWC_DISPLAY_VIRTUAL) {
-    return android::BAD_VALUE;;
-  }
-
-  if (!hwc_display_[dpy]) {
-    return android::NO_INIT;
-  }
-
-  hwc_rect_t visible_rect = {0, 0, 0, 0};
-  int error = hwc_display_[dpy]->GetVisibleDisplayRect(&visible_rect);
-  if (error < 0) {
-    return error;
-  }
-
-  output_parcel->writeInt32(visible_rect.left);
-  output_parcel->writeInt32(visible_rect.top);
-  output_parcel->writeInt32(visible_rect.right);
-  output_parcel->writeInt32(visible_rect.bottom);
-
-  return android::NO_ERROR;
-}
-
-int HWCSession::CreateExternalDisplay(int disp, uint32_t primary_width, uint32_t primary_height,
-                                      bool use_primary_res) {
-  uint32_t panel_bpp = 0;
-  uint32_t pattern_type = 0;
-
-  if (qdutils::isDPConnected()) {
-    qdutils::getDPTestConfig(&panel_bpp, &pattern_type);
-  }
-
-  if (panel_bpp && pattern_type) {
-    return HWCDisplayExternalTest::Create(core_intf_, &hwc_procs_, qservice_, panel_bpp,
-                                          pattern_type, &hwc_display_[disp]);
-  }
-
-  return HWCDisplayExternal::Create(core_intf_, &hwc_procs_, primary_width, primary_height,
-                                    qservice_, use_primary_res, &hwc_display_[disp]);
-}
-
-}  // namespace sdm
-
diff --git a/sdm/libs/hwc/hwc_session.h b/sdm/libs/hwc/hwc_session.h
deleted file mode 100644
index ce21c46..0000000
--- a/sdm/libs/hwc/hwc_session.h
+++ /dev/null
@@ -1,166 +0,0 @@
-/*
-* Copyright (c) 2014 - 2017, 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_SESSION_H__
-#define __HWC_SESSION_H__
-
-#include <hardware/hwcomposer.h>
-#include <core/core_interface.h>
-#include <utils/locker.h>
-#include <future>   // NOLINT
-
-#include "hwc_display_primary.h"
-#include "hwc_display_external.h"
-#include "hwc_display_virtual.h"
-#include "hwc_color_manager.h"
-#include "hwc_socket_handler.h"
-
-namespace sdm {
-
-class HWCSession : hwc_composer_device_1_t, public qClient::BnQClient {
- public:
-  struct HWCModuleMethods : public hw_module_methods_t {
-    HWCModuleMethods() {
-      hw_module_methods_t::open = HWCSession::Open;
-    }
-  };
-
-  explicit HWCSession(const hw_module_t *module);
-  int Init();
-  int Deinit();
-
- private:
-  static const int kExternalConnectionTimeoutMs = 500;
-  static const int kPartialUpdateControlTimeoutMs = 100;
-
-  // hwc methods
-  static int Open(const hw_module_t *module, const char* name, hw_device_t **device);
-  static int Close(hw_device_t *device);
-  static int Prepare(hwc_composer_device_1 *device, size_t num_displays,
-                     hwc_display_contents_1_t **displays);
-  static int Set(hwc_composer_device_1 *device, size_t num_displays,
-                 hwc_display_contents_1_t **displays);
-  static int EventControl(hwc_composer_device_1 *device, int disp, int event, int enable);
-  static int SetPowerMode(hwc_composer_device_1 *device, int disp, int mode);
-  static int Query(hwc_composer_device_1 *device, int param, int *value);
-  static void RegisterProcs(hwc_composer_device_1 *device, hwc_procs_t const *procs);
-  static void Dump(hwc_composer_device_1 *device, char *buffer, int length);
-  // These config functions always return FB params, the actual display params may differ.
-  static int GetDisplayConfigs(hwc_composer_device_1 *device, int disp, uint32_t *configs,
-                               size_t *numConfigs);
-  static int GetDisplayAttributes(hwc_composer_device_1 *device, int disp, uint32_t config,
-                                  const uint32_t *display_attributes, int32_t *values);
-  static int GetActiveConfig(hwc_composer_device_1 *device, int disp);
-  static int SetActiveConfig(hwc_composer_device_1 *device, int disp, int index);
-  static int SetCursorPositionAsync(hwc_composer_device_1 *device, int disp, int x, int y);
-  static void CloseAcquireFds(hwc_display_contents_1_t *content_list);
-  bool IsDisplayYUV(int disp);
-
-  // Uevent thread
-  static void* HWCUeventThread(void *context);
-  void* HWCUeventThreadHandler();
-  int GetEventValue(const char *uevent_data, int length, const char *event_info);
-  int HotPlugHandler(bool connected);
-  void ResetPanel();
-  int ConnectDisplay(int disp, hwc_display_contents_1_t *content_list);
-  int DisconnectDisplay(int disp);
-  void HandleSecureDisplaySession(hwc_display_contents_1_t **displays);
-  int GetVsyncPeriod(int disp);
-  int CreateExternalDisplay(int disp, uint32_t primary_width, uint32_t primary_height,
-                            bool use_primary_res);
-  void AsyncRefresh();
-
-  // QClient methods
-  virtual android::status_t notifyCallback(uint32_t command, const android::Parcel *input_parcel,
-                                           android::Parcel *output_parcel);
-  void DynamicDebug(const android::Parcel *input_parcel);
-  void SetFrameDumpConfig(const android::Parcel *input_parcel);
-  android::status_t SetMaxMixerStages(const android::Parcel *input_parcel);
-  android::status_t SetDisplayMode(const android::Parcel *input_parcel);
-  android::status_t SetSecondaryDisplayStatus(const android::Parcel *input_parcel,
-                                              android::Parcel *output_parcel);
-  android::status_t ToggleScreenUpdates(const android::Parcel *input_parcel,
-                                        android::Parcel *output_parcel);
-  android::status_t ConfigureRefreshRate(const android::Parcel *input_parcel);
-  android::status_t QdcmCMDHandler(const android::Parcel *input_parcel,
-                                   android::Parcel *output_parcel);
-  android::status_t ControlPartialUpdate(const android::Parcel *input_parcel,
-                                         android::Parcel *output_parcel);
-  android::status_t OnMinHdcpEncryptionLevelChange(const android::Parcel *input_parcel,
-                                                   android::Parcel *output_parcel);
-  android::status_t SetPanelBrightness(const android::Parcel *input_parcel,
-                                       android::Parcel *output_parcel);
-  android::status_t GetPanelBrightness(const android::Parcel *input_parcel,
-                                       android::Parcel *output_parcel);
-  // These functions return the actual display config info as opposed to FB
-  android::status_t HandleSetActiveDisplayConfig(const android::Parcel *input_parcel,
-                                                 android::Parcel *output_parcel);
-  android::status_t HandleGetActiveDisplayConfig(const android::Parcel *input_parcel,
-                                                 android::Parcel *output_parcel);
-  android::status_t HandleGetDisplayConfigCount(const android::Parcel *input_parcel,
-                                                android::Parcel *output_parcel);
-  android::status_t HandleGetDisplayAttributesForConfig(const android::Parcel *input_parcel,
-                                                        android::Parcel *output_parcel);
-  android::status_t GetVisibleDisplayRect(const android::Parcel *input_parcel,
-                                          android::Parcel *output_parcel);
-
-  android::status_t SetDynamicBWForCamera(const android::Parcel *input_parcel,
-                                          android::Parcel *output_parcel);
-  android::status_t GetBWTransactionStatus(const android::Parcel *input_parcel,
-                                          android::Parcel *output_parcel);
-  android::status_t SetMixerResolution(const android::Parcel *input_parcel);
-  android::status_t SetDisplayPort(DisplayPort sdm_disp_port, int *hwc_disp_port);
-  android::status_t GetHdrCapabilities(const android::Parcel *input_parcel,
-                                       android::Parcel *output_parcel);
-
-  static Locker locker_;
-  CoreInterface *core_intf_ = NULL;
-  hwc_procs_t hwc_procs_default_;
-  hwc_procs_t const *hwc_procs_ = &hwc_procs_default_;
-  HWCDisplay *hwc_display_[HWC_NUM_DISPLAY_TYPES] = { NULL };
-  pthread_t uevent_thread_;
-  bool uevent_thread_exit_ = false;
-  const char *uevent_thread_name_ = "HWC_UeventThread";
-  HWCBufferAllocator buffer_allocator_;
-  HWCBufferSyncHandler buffer_sync_handler_;
-  HWCColorManager *color_mgr_ = NULL;
-  bool reset_panel_ = false;
-  bool secure_display_active_ = false;
-  bool external_pending_connect_ = false;
-  bool new_bw_mode_ = false;
-  bool need_invalidate_ = false;
-  int bw_mode_release_fd_ = -1;
-  qService::QService *qservice_ = NULL;
-  bool is_hdmi_primary_ = false;
-  bool is_hdmi_yuv_ = false;
-  std::future<void> future_;
-  std::bitset<HWC_NUM_DISPLAY_TYPES> connected_displays_;  // Bit mask of connected displays
-  HWCSocketHandler socket_handler_;
-  Locker uevent_locker_;
-};
-
-}  // namespace sdm
-
-#endif  // __HWC_SESSION_H__
-
diff --git a/sdm/libs/hwc/hwc_tonemapper.cpp b/sdm/libs/hwc/hwc_tonemapper.cpp
deleted file mode 100644
index c09ff9e..0000000
--- a/sdm/libs/hwc/hwc_tonemapper.cpp
+++ /dev/null
@@ -1,341 +0,0 @@
-/*
-* Copyright (c) 2016 - 2017, 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.
-*/
-
-#include <alloc_controller.h>
-#include <gr.h>
-#include <gralloc_priv.h>
-#include <memalloc.h>
-#include <sync/sync.h>
-
-#include <TonemapFactory.h>
-
-#include <core/buffer_allocator.h>
-
-#include <utils/constants.h>
-#include <utils/debug.h>
-#include <utils/formats.h>
-#include <utils/rect.h>
-#include <utils/utils.h>
-
-#include <vector>
-
-#include "hwc_debugger.h"
-#include "hwc_tonemapper.h"
-
-#define __CLASS__ "HWCToneMapper"
-
-namespace sdm {
-
-ToneMapSession::~ToneMapSession() {
-  delete gpu_tone_mapper_;
-  gpu_tone_mapper_ = NULL;
-  FreeIntermediateBuffers();
-}
-
-DisplayError ToneMapSession::AllocateIntermediateBuffers(int w, int h, int format, int usage) {
-  for (uint8_t i = 0; i < kNumIntermediateBuffers; i++) {
-    int status = alloc_buffer(&intermediate_buffer_[i], w, h, format, usage);
-    if (status < 0) {
-      FreeIntermediateBuffers();
-      return kErrorMemory;
-    }
-  }
-
-  return kErrorNone;
-}
-
-void ToneMapSession::FreeIntermediateBuffers() {
-  for (uint8_t i = 0; i < kNumIntermediateBuffers; i++) {
-    private_handle_t *buffer = intermediate_buffer_[i];
-    if (buffer) {
-      // Free the valid fence
-      if (release_fence_fd_[i] >= 0) {
-        CloseFd(&release_fence_fd_[i]);
-      }
-      free_buffer(buffer);
-      intermediate_buffer_[i] = NULL;
-    }
-  }
-}
-
-void ToneMapSession::UpdateBuffer(int acquire_fence, LayerBuffer *buffer) {
-  // Acquire fence will be closed by HWC Display.
-  // Fence returned by GPU will be closed in PostCommit.
-  buffer->acquire_fence_fd = acquire_fence;
-  buffer->size = intermediate_buffer_[current_buffer_index_]->size;
-  buffer->planes[0].fd = intermediate_buffer_[current_buffer_index_]->fd;
-}
-
-void ToneMapSession::SetReleaseFence(int fd) {
-  CloseFd(&release_fence_fd_[current_buffer_index_]);
-  // Used to give to GPU tonemapper along with input layer fd
-  release_fence_fd_[current_buffer_index_] = dup(fd);
-}
-
-void ToneMapSession::SetToneMapConfig(Layer *layer) {
-  // HDR -> SDR is FORWARD and SDR - > HDR is INVERSE
-  tone_map_config_.type = layer->input_buffer.flags.hdr ? TONEMAP_FORWARD : TONEMAP_INVERSE;
-  tone_map_config_.colorPrimaries = layer->input_buffer.color_metadata.colorPrimaries;
-  tone_map_config_.transfer = layer->input_buffer.color_metadata.transfer;
-  tone_map_config_.secure = layer->request.flags.secure;
-  tone_map_config_.format = layer->request.format;
-}
-
-bool ToneMapSession::IsSameToneMapConfig(Layer *layer) {
-  LayerBuffer& buffer = layer->input_buffer;
-  private_handle_t *handle = intermediate_buffer_[0];
-  int tonemap_type = buffer.flags.hdr ? TONEMAP_FORWARD : TONEMAP_INVERSE;
-
-  return ((tonemap_type == tone_map_config_.type) &&
-          (buffer.color_metadata.colorPrimaries == tone_map_config_.colorPrimaries) &&
-          (buffer.color_metadata.transfer == tone_map_config_.transfer) &&
-          (layer->request.flags.secure == tone_map_config_.secure) &&
-          (layer->request.format == tone_map_config_.format) &&
-          (layer->request.width == UINT32(handle->unaligned_width)) &&
-          (layer->request.height == UINT32(handle->unaligned_height)));
-}
-
-int HWCToneMapper::HandleToneMap(hwc_display_contents_1_t *content_list, LayerStack *layer_stack) {
-  uint32_t gpu_count = 0;
-  DisplayError error = kErrorNone;
-
-  for (uint32_t i = 0; i < layer_stack->layers.size(); i++) {
-    uint32_t session_index = 0;
-    Layer *layer = layer_stack->layers.at(i);
-    if (layer->composition == kCompositionGPU) {
-      gpu_count++;
-    }
-
-    if (layer->request.flags.tone_map) {
-      switch (layer->composition) {
-      case kCompositionGPUTarget:
-        if (!gpu_count) {
-          // When all layers are on FrameBuffer and if they do not update in the next draw cycle,
-          // then SDM marks them for SDE Composition because the cached FB layer gets displayed.
-          // GPU count will be 0 in this case. Try to use the existing tone-mapped frame buffer.
-          // No ToneMap/Blit is required. Just update the buffer & acquire fence fd of FB layer.
-          if (!tone_map_sessions_.empty()) {
-            ToneMapSession *fb_tone_map_session = tone_map_sessions_.at(fb_session_index_);
-            fb_tone_map_session->UpdateBuffer(-1 /* acquire_fence */, &layer->input_buffer);
-            fb_tone_map_session->layer_index_ = INT(i);
-            fb_tone_map_session->acquired_ = true;
-            return 0;
-          }
-        }
-        error = AcquireToneMapSession(layer, &session_index);
-        fb_session_index_ = session_index;
-        break;
-      default:
-        error = AcquireToneMapSession(layer, &session_index);
-        break;
-      }
-
-      if (error != kErrorNone) {
-        Terminate();
-        return -1;
-      }
-
-      ToneMapSession *session = tone_map_sessions_.at(session_index);
-      ToneMap(&content_list->hwLayers[i], layer, session);
-      session->layer_index_ = INT(i);
-    }
-  }
-
-  return 0;
-}
-
-void HWCToneMapper::ToneMap(hwc_layer_1_t *hwc_layer, Layer* layer, ToneMapSession *session) {
-  int fence_fd = -1;
-  int acquire_fd = -1;
-  int merged_fd = -1;
-
-  uint8_t buffer_index = session->current_buffer_index_;
-  const private_handle_t *dst_hnd = session->intermediate_buffer_[buffer_index];
-  const private_handle_t *src_hnd = static_cast<const private_handle_t *>(hwc_layer->handle);
-
-  acquire_fd = dup(layer->input_buffer.acquire_fence_fd);
-  buffer_sync_handler_.SyncMerge(session->release_fence_fd_[buffer_index], acquire_fd, &merged_fd);
-
-  if (acquire_fd >= 0) {
-    CloseFd(&acquire_fd);
-  }
-
-  if (session->release_fence_fd_[buffer_index] >= 0) {
-    CloseFd(&session->release_fence_fd_[buffer_index]);
-  }
-
-  DTRACE_BEGIN("GPU_TM_BLIT");
-  fence_fd = session->gpu_tone_mapper_->blit(reinterpret_cast<const void *>(dst_hnd),
-                                             reinterpret_cast<const void *>(src_hnd), merged_fd);
-  DTRACE_END();
-
-  DumpToneMapOutput(session, &fence_fd);
-  session->UpdateBuffer(fence_fd, &layer->input_buffer);
-}
-
-void HWCToneMapper::PostCommit(LayerStack *layer_stack) {
-  auto it = tone_map_sessions_.begin();
-  while (it != tone_map_sessions_.end()) {
-    uint32_t session_index = UINT32(std::distance(tone_map_sessions_.begin(), it));
-    ToneMapSession *session = tone_map_sessions_.at(session_index);
-    Layer *layer = layer_stack->layers.at(UINT32(session->layer_index_));
-    if (session->acquired_) {
-      // Close the fd returned by GPU ToneMapper and set release fence.
-      LayerBuffer &layer_buffer = layer->input_buffer;
-      CloseFd(&layer_buffer.acquire_fence_fd);
-      session->SetReleaseFence(layer_buffer.release_fence_fd);
-      session->acquired_ = false;
-      it++;
-    } else {
-      delete session;
-      it = tone_map_sessions_.erase(it);
-    }
-  }
-}
-
-void HWCToneMapper::Terminate() {
-  if (tone_map_sessions_.size()) {
-    while (!tone_map_sessions_.empty()) {
-      delete tone_map_sessions_.back();
-      tone_map_sessions_.pop_back();
-    }
-    fb_session_index_ = 0;
-  }
-}
-
-void HWCToneMapper::SetFrameDumpConfig(uint32_t count) {
-  DLOGI("Dump FrameConfig count = %d", count);
-  dump_frame_count_ = count;
-  dump_frame_index_ = 0;
-}
-
-void HWCToneMapper::DumpToneMapOutput(ToneMapSession *session, int *acquire_fd) {
-  if (!dump_frame_count_) {
-    return;
-  }
-
-  private_handle_t *target_buffer = session->intermediate_buffer_[session->current_buffer_index_];
-
-  if (*acquire_fd >= 0) {
-    int error = sync_wait(*acquire_fd, 1000);
-    if (error < 0) {
-      DLOGW("sync_wait error errno = %d, desc = %s", errno, strerror(errno));
-      return;
-    }
-  }
-
-  size_t result = 0;
-  char dump_file_name[PATH_MAX];
-  snprintf(dump_file_name, sizeof(dump_file_name), "/data/misc/display/frame_dump_primary"
-           "/tonemap_%dx%d_frame%d.raw", target_buffer->width, target_buffer->height,
-           dump_frame_index_);
-
-  FILE* fp = fopen(dump_file_name, "w+");
-  if (fp) {
-    DLOGI("base addr = %x", target_buffer->base);
-    result = fwrite(reinterpret_cast<void *>(target_buffer->base), target_buffer->size, 1, fp);
-    fclose(fp);
-  }
-  dump_frame_count_--;
-  dump_frame_index_++;
-  CloseFd(acquire_fd);
-}
-
-DisplayError HWCToneMapper::AcquireToneMapSession(Layer *layer, uint32_t *session_index) {
-  Color10Bit *grid_entries = NULL;
-  int grid_size = 0;
-
-  if (layer->lut_3d.validGridEntries) {
-    grid_entries = layer->lut_3d.gridEntries;
-    grid_size = INT(layer->lut_3d.gridSize);
-  }
-
-  // When the property sdm.disable_hdr_lut_gen is set, the lutEntries and gridEntries in
-  // the Lut3d will be NULL, clients needs to allocate the memory and set correct 3D Lut
-  // for Tonemapping.
-  if (!layer->lut_3d.lutEntries || !layer->lut_3d.dim) {
-    // Atleast lutEntries must be valid for GPU Tonemapper.
-    DLOGE("Invalid Lut Entries or lut dimension = %d", layer->lut_3d.dim);
-    return kErrorParameters;
-  }
-
-  // Check if we can re-use an existing tone map session.
-  for (uint32_t i = 0; i < tone_map_sessions_.size(); i++) {
-    ToneMapSession *tonemap_session = tone_map_sessions_.at(i);
-    if (!tonemap_session->acquired_ && tonemap_session->IsSameToneMapConfig(layer)) {
-      tonemap_session->current_buffer_index_ = (tonemap_session->current_buffer_index_ + 1) %
-                                                ToneMapSession::kNumIntermediateBuffers;
-      tonemap_session->acquired_ = true;
-      *session_index = i;
-      return kErrorNone;
-    }
-  }
-
-  ToneMapSession *session = new ToneMapSession();
-
-  session->SetToneMapConfig(layer);
-  session->gpu_tone_mapper_ = TonemapperFactory_GetInstance(session->tone_map_config_.type,
-                                                            layer->lut_3d.lutEntries,
-                                                            layer->lut_3d.dim,
-                                                            grid_entries, grid_size,
-                                                            session->tone_map_config_.secure);
-
-  if (session->gpu_tone_mapper_ == NULL) {
-    DLOGE("Get Tonemapper failed!");
-    delete session;
-    return kErrorNotSupported;
-  }
-
-  int status, format;
-  DisplayError error = kErrorNone;
-  int usage = INT(GRALLOC_USAGE_PRIVATE_IOMMU_HEAP | GRALLOC_USAGE_HW_TEXTURE);
-
-  if (layer->request.flags.secure) {
-    usage = INT(GRALLOC_USAGE_PRIVATE_MM_HEAP);
-    usage |= INT(GRALLOC_USAGE_PROTECTED);
-  }
-
-  status = buffer_allocator_.SetBufferInfo(layer->request.format, &format, &usage);
-  error = session->AllocateIntermediateBuffers(INT(layer->request.width),
-                                               INT(layer->request.height), format, usage);
-
-  if (error != kErrorNone) {
-    DLOGE("Allocation of Intermediate Buffers failed!");
-    delete session;
-    return error;
-  }
-
-  session->acquired_ = true;
-  tone_map_sessions_.push_back(session);
-  *session_index = UINT32(tone_map_sessions_.size() - 1);
-
-  return kErrorNone;
-}
-
-}  // namespace sdm
diff --git a/sdm/libs/hwc/hwc_tonemapper.h b/sdm/libs/hwc/hwc_tonemapper.h
deleted file mode 100644
index 0a463fe..0000000
--- a/sdm/libs/hwc/hwc_tonemapper.h
+++ /dev/null
@@ -1,101 +0,0 @@
-/*
-* Copyright (c) 2016 - 2017, 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_TONEMAPPER_H__
-#define __HWC_TONEMAPPER_H__
-
-#include <fcntl.h>
-#include <sys/mman.h>
-
-#include <hardware/hwcomposer.h>
-
-#include <core/layer_stack.h>
-#include <utils/sys.h>
-#include <vector>
-#include "hwc_buffer_sync_handler.h"
-#include "hwc_buffer_allocator.h"
-
-class Tonemapper;
-
-namespace sdm {
-
-struct ToneMapConfig {
-  int type = 0;
-  ColorPrimaries colorPrimaries = ColorPrimaries_Max;
-  GammaTransfer transfer = Transfer_Max;
-  LayerBufferFormat format = kFormatRGBA8888;
-  bool secure = false;
-};
-
-class ToneMapSession {
- public:
-  ~ToneMapSession();
-  DisplayError AllocateIntermediateBuffers(int width, int height, int format, int usage);
-  void FreeIntermediateBuffers();
-  void UpdateBuffer(int acquire_fence, LayerBuffer *buffer);
-  void SetReleaseFence(int fd);
-  void SetToneMapConfig(Layer *layer);
-  bool IsSameToneMapConfig(Layer *layer);
-
-  static const uint8_t kNumIntermediateBuffers = 2;
-  Tonemapper *gpu_tone_mapper_ = NULL;
-  ToneMapConfig tone_map_config_ = {};
-  uint8_t current_buffer_index_ = 0;
-  private_handle_t *intermediate_buffer_[kNumIntermediateBuffers] = {NULL, NULL};
-  int release_fence_fd_[kNumIntermediateBuffers] = {-1, -1};
-  bool acquired_ = false;
-  int layer_index_ = -1;
-};
-
-class HWCToneMapper {
- public:
-  HWCToneMapper() {}
-  ~HWCToneMapper() {}
-
-  int HandleToneMap(hwc_display_contents_1_t *content_list, LayerStack *layer_stack);
-  bool IsActive() { return !tone_map_sessions_.empty(); }
-  void PostCommit(LayerStack *layer_stack);
-  void SetFrameDumpConfig(uint32_t count);
-  void Terminate();
-
- private:
-  void ToneMap(hwc_layer_1_t *hwc_layer, Layer *layer, ToneMapSession *session);
-  DisplayError AcquireToneMapSession(Layer *layer, uint32_t *session_index);
-  void DumpToneMapOutput(ToneMapSession *session, int *acquire_fence);
-
-  std::vector<ToneMapSession*> tone_map_sessions_;
-  HWCBufferSyncHandler buffer_sync_handler_ = {};
-  HWCBufferAllocator buffer_allocator_ = {};
-  uint32_t dump_frame_count_ = 0;
-  uint32_t dump_frame_index_ = 0;
-  uint32_t fb_session_index_ = 0;
-};
-
-}  // namespace sdm
-#endif  // __HWC_TONEMAPPER_H__
diff --git a/sdm/libs/hwc2/Android.mk b/sdm/libs/hwc2/Android.mk
index 592dc02..782263d 100644
--- a/sdm/libs/hwc2/Android.mk
+++ b/sdm/libs/hwc2/Android.mk
@@ -13,8 +13,7 @@
 
 LOCAL_CFLAGS                  := -Wno-missing-field-initializers -Wno-unused-parameter \
                                  -std=c++11 -fcolor-diagnostics\
-                                 -DLOG_TAG=\"SDM\" $(common_flags) \
-                                 -I $(display_top)/sdm/libs/hwc
+                                 -DLOG_TAG=\"SDM\" $(common_flags)
 LOCAL_CLANG                   := true
 
 LOCAL_SHARED_LIBRARIES        := libsdmcore libqservice libbinder libhardware libhardware_legacy \
@@ -22,30 +21,22 @@
                                  libsdmutils libc++ liblog libgrallocutils libui libgpu_tonemapper \
                                  libhidlbase libhidltransport vendor.display.config@1.0
 
-ifneq ($(TARGET_USES_GRALLOC1), true)
-    LOCAL_SHARED_LIBRARIES += libmemalloc
-endif
-
 LOCAL_SRC_FILES               := hwc_session.cpp \
                                  hwc_session_services.cpp \
                                  hwc_display.cpp \
                                  hwc_display_primary.cpp \
                                  hwc_display_external.cpp \
                                  hwc_display_virtual.cpp \
-                                 ../hwc/hwc_debugger.cpp \
-                                 ../hwc/hwc_buffer_sync_handler.cpp \
+                                 hwc_debugger.cpp \
+                                 hwc_buffer_sync_handler.cpp \
                                  hwc_color_manager.cpp \
                                  hwc_layers.cpp \
                                  hwc_callbacks.cpp \
-                                 ../hwc/cpuhint.cpp \
-                                 ../hwc/hwc_socket_handler.cpp \
-                                 hwc_tonemapper.cpp
-
-ifneq ($(TARGET_USES_GRALLOC1), true)
-    LOCAL_SRC_FILES += ../hwc/hwc_buffer_allocator.cpp
-else
-    LOCAL_SRC_FILES += hwc_buffer_allocator.cpp
-endif
+                                 cpuhint.cpp \
+                                 hwc_tonemapper.cpp \
+                                 display_null.cpp \
+                                 hwc_socket_handler.cpp \
+                                 hwc_buffer_allocator.cpp
 
 ifeq ($(TARGET_HAS_WIDE_COLOR_DISPLAY), true)
     LOCAL_CFLAGS += -DFEATURE_WIDE_COLOR
diff --git a/sdm/libs/hwc/cpuhint.cpp b/sdm/libs/hwc2/cpuhint.cpp
similarity index 100%
rename from sdm/libs/hwc/cpuhint.cpp
rename to sdm/libs/hwc2/cpuhint.cpp
diff --git a/sdm/libs/hwc/cpuhint.h b/sdm/libs/hwc2/cpuhint.h
similarity index 100%
rename from sdm/libs/hwc/cpuhint.h
rename to sdm/libs/hwc2/cpuhint.h
diff --git a/sdm/libs/hwc2/display_null.cpp b/sdm/libs/hwc2/display_null.cpp
new file mode 100644
index 0000000..16f4da6
--- /dev/null
+++ b/sdm/libs/hwc2/display_null.cpp
@@ -0,0 +1,68 @@
+/*
+* Copyright (c) 2017, 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.
+*/
+
+#include "display_null.h"
+
+#define __CLASS__ "DisplayNull"
+
+namespace sdm {
+
+DisplayError DisplayNull::Commit(LayerStack *layer_stack) {
+  for (Layer *layer : layer_stack->layers) {
+    if (layer->composition != kCompositionGPUTarget) {
+      layer->composition = kCompositionSDE;
+      layer->input_buffer.release_fence_fd = -1;
+    }
+  }
+  layer_stack->retire_fence_fd = -1;
+
+  return kErrorNone;
+}
+
+DisplayError DisplayNull::GetDisplayState(DisplayState *state) {
+  *state = state_;
+  return kErrorNone;
+}
+
+DisplayError DisplayNull::SetDisplayState(DisplayState state) {
+  state_ = state;
+  return kErrorNone;
+}
+
+DisplayError DisplayNull::SetFrameBufferConfig(const DisplayConfigVariableInfo &variable_info) {
+  fb_config_ = variable_info;
+  return kErrorNone;
+}
+
+DisplayError DisplayNull::GetFrameBufferConfig(DisplayConfigVariableInfo *variable_info) {
+  *variable_info = fb_config_;
+  return kErrorNone;
+}
+
+}  // namespace sdm
diff --git a/sdm/libs/hwc2/display_null.h b/sdm/libs/hwc2/display_null.h
new file mode 100644
index 0000000..fa88c28
--- /dev/null
+++ b/sdm/libs/hwc2/display_null.h
@@ -0,0 +1,107 @@
+/*
+* Copyright (c) 2017, 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 __DISPLAY_NULL_H__
+#define __DISPLAY_NULL_H__
+
+#include <core/display_interface.h>
+#include <string>
+#include <vector>
+
+namespace sdm {
+
+#define MAKE_NO_OP(virtual_method_name) \
+      virtual DisplayError virtual_method_name { return kErrorNone; }
+
+class DisplayNull : public DisplayInterface {
+ public:
+  virtual ~DisplayNull() { }
+  virtual DisplayError Commit(LayerStack *layer_stack);
+  virtual DisplayError GetDisplayState(DisplayState *state);
+  virtual DisplayError SetDisplayState(DisplayState state);
+  virtual DisplayError SetFrameBufferConfig(const DisplayConfigVariableInfo &variable_info);
+  virtual DisplayError GetFrameBufferConfig(DisplayConfigVariableInfo *variable_info);
+  virtual bool IsUnderscanSupported() { return true; }
+  virtual void SetIdleTimeoutMs(uint32_t active_ms) { }
+  virtual bool IsPrimaryDisplay() { return true; }
+
+  void SetActive(bool active) {
+    active_ = active;
+  }
+
+  bool IsActive() {
+    return active_;
+  }
+
+  MAKE_NO_OP(Prepare(LayerStack *))
+  MAKE_NO_OP(Flush())
+  MAKE_NO_OP(GetNumVariableInfoConfigs(uint32_t *))
+  MAKE_NO_OP(GetConfig(uint32_t, DisplayConfigVariableInfo *))
+  MAKE_NO_OP(GetConfig(DisplayConfigFixedInfo *))
+  MAKE_NO_OP(GetActiveConfig(uint32_t *))
+  MAKE_NO_OP(GetVSyncState(bool *))
+  MAKE_NO_OP(SetActiveConfig(uint32_t))
+  MAKE_NO_OP(SetActiveConfig(DisplayConfigVariableInfo *))
+  MAKE_NO_OP(SetMaxMixerStages(uint32_t))
+  MAKE_NO_OP(ControlPartialUpdate(bool, uint32_t *))
+  MAKE_NO_OP(DisablePartialUpdateOneFrame())
+  MAKE_NO_OP(SetDisplayMode(uint32_t))
+  MAKE_NO_OP(SetPanelBrightness(int))
+  MAKE_NO_OP(CachePanelBrightness(int))
+  MAKE_NO_OP(OnMinHdcpEncryptionLevelChange(uint32_t))
+  MAKE_NO_OP(ColorSVCRequestRoute(const PPDisplayAPIPayload &, PPDisplayAPIPayload *,
+                                  PPPendingParams *))
+  MAKE_NO_OP(GetColorModeCount(uint32_t *))
+  MAKE_NO_OP(GetColorModes(uint32_t *, std::vector<std::string> *))
+  MAKE_NO_OP(GetColorModeAttr(const std::string &, AttrVal *))
+  MAKE_NO_OP(SetColorMode(const std::string &))
+  MAKE_NO_OP(SetColorModeById(int32_t))
+  MAKE_NO_OP(SetColorTransform(const uint32_t, const double *))
+  MAKE_NO_OP(GetDefaultColorMode(std::string *))
+  MAKE_NO_OP(ApplyDefaultDisplayMode())
+  MAKE_NO_OP(SetCursorPosition(int, int))
+  MAKE_NO_OP(GetRefreshRateRange(uint32_t *, uint32_t *))
+  MAKE_NO_OP(SetRefreshRate(uint32_t, bool))
+  MAKE_NO_OP(GetPanelBrightness(int *))
+  MAKE_NO_OP(SetVSyncState(bool))
+  MAKE_NO_OP(SetMixerResolution(uint32_t, uint32_t))
+  MAKE_NO_OP(GetMixerResolution(uint32_t *, uint32_t *))
+  MAKE_NO_OP(SetDetailEnhancerData(const DisplayDetailEnhancerData &))
+  MAKE_NO_OP(GetDisplayPort(DisplayPort *))
+  MAKE_NO_OP(SetCompositionState(LayerComposition, bool))
+
+ private:
+  bool active_ = false;
+  DisplayState state_ = kStateOff;
+  DisplayConfigVariableInfo fb_config_ = {};
+};
+
+}  // namespace sdm
+
+#endif  // __DISPLAY_NULL_H__
diff --git a/sdm/libs/hwc/hwc_buffer_sync_handler.cpp b/sdm/libs/hwc2/hwc_buffer_sync_handler.cpp
similarity index 100%
rename from sdm/libs/hwc/hwc_buffer_sync_handler.cpp
rename to sdm/libs/hwc2/hwc_buffer_sync_handler.cpp
diff --git a/sdm/libs/hwc/hwc_buffer_sync_handler.h b/sdm/libs/hwc2/hwc_buffer_sync_handler.h
similarity index 100%
rename from sdm/libs/hwc/hwc_buffer_sync_handler.h
rename to sdm/libs/hwc2/hwc_buffer_sync_handler.h
diff --git a/sdm/libs/hwc/hwc_debugger.cpp b/sdm/libs/hwc2/hwc_debugger.cpp
similarity index 95%
rename from sdm/libs/hwc/hwc_debugger.cpp
rename to sdm/libs/hwc2/hwc_debugger.cpp
index 0cc0501..ffbb5c5 100644
--- a/sdm/libs/hwc/hwc_debugger.cpp
+++ b/sdm/libs/hwc2/hwc_debugger.cpp
@@ -98,6 +98,16 @@
   }
 }
 
+void HWCDebugHandler::DebugScalar(bool enable, int verbose_level) {
+  if (enable) {
+    debug_flags_[kTagScalar] = 1;
+    verbose_level_ = verbose_level;
+  } else {
+    debug_flags_[kTagScalar] = 0;
+    verbose_level_ = 0;
+  }
+}
+
 void HWCDebugHandler::DebugQdcm(bool enable, int verbose_level) {
   if (enable) {
     debug_flags_[kTagQDCM] = 1;
diff --git a/sdm/libs/hwc/hwc_debugger.h b/sdm/libs/hwc2/hwc_debugger.h
similarity index 94%
rename from sdm/libs/hwc/hwc_debugger.h
rename to sdm/libs/hwc2/hwc_debugger.h
index 01319ab..82ff2f2 100644
--- a/sdm/libs/hwc/hwc_debugger.h
+++ b/sdm/libs/hwc2/hwc_debugger.h
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2014 - 2016, The Linux Foundation. All rights reserved.
+* Copyright (c) 2014 - 2017, 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
@@ -43,6 +43,7 @@
 class HWCDebugHandler : public DebugHandler {
  public:
   static inline DebugHandler* Get() { return &debug_handler_; }
+  static const char* DumpDir() { return "/data/vendor/display"; }
 
   static void DebugAll(bool enable, int verbose_level);
   static void DebugResources(bool enable, int verbose_level);
@@ -50,6 +51,7 @@
   static void DebugCompManager(bool enable, int verbose_level);
   static void DebugDriverConfig(bool enable, int verbose_level);
   static void DebugRotator(bool enable, int verbose_level);
+  static void DebugScalar(bool enable, int verbose_level);
   static void DebugQdcm(bool enable, int verbose_level);
   static int  GetIdleTimeoutMs();
 
diff --git a/sdm/libs/hwc2/hwc_display.cpp b/sdm/libs/hwc2/hwc_display.cpp
index fd9b0e0..91879ae 100644
--- a/sdm/libs/hwc2/hwc_display.cpp
+++ b/sdm/libs/hwc2/hwc_display.cpp
@@ -39,7 +39,6 @@
 
 #include "hwc_display.h"
 #include "hwc_debugger.h"
-#include "blit_engine_c2d.h"
 #include "hwc_tonemapper.h"
 
 #ifndef USE_GRALLOC1
@@ -833,7 +832,7 @@
 
   client_target_->SetLayerBuffer(target, acquire_fence);
   client_target_->SetLayerSurfaceDamage(damage);
-  // Ignoring dataspace for now
+  client_target_->SetLayerDataspace(dataspace);
   return HWC2::Error::None;
 }
 
@@ -1336,7 +1335,8 @@
     return;
   }
 
-  snprintf(dir_path, sizeof(dir_path), "/data/misc/display/frame_dump_%s", GetDisplayString());
+  snprintf(dir_path, sizeof(dir_path), "%s/frame_dump_%s", HWCDebugHandler::DumpDir(),
+           GetDisplayString());
 
   if (mkdir(dir_path, 0777) != 0 && errno != EEXIST) {
     DLOGW("Failed to create %s directory errno = %d, desc = %s", dir_path, errno, strerror(errno));
@@ -1385,7 +1385,8 @@
 void HWCDisplay::DumpOutputBuffer(const BufferInfo &buffer_info, void *base, int fence) {
   char dir_path[PATH_MAX];
 
-  snprintf(dir_path, sizeof(dir_path), "/data/misc/display/frame_dump_%s", GetDisplayString());
+  snprintf(dir_path, sizeof(dir_path), "%s/frame_dump_%s", HWCDebugHandler::DumpDir(),
+           GetDisplayString());
 
   if (mkdir(dir_path, 777) != 0 && errno != EEXIST) {
     DLOGW("Failed to create %s directory errno = %d, desc = %s", dir_path, errno, strerror(errno));
@@ -1598,6 +1599,7 @@
     auto layer = hwc_layer->GetSDMLayer();
     layer->composition = kCompositionSDE;
   }
+  validated_ = true;
 }
 
 void HWCDisplay::MarkLayersForClientComposition() {
diff --git a/sdm/libs/hwc2/hwc_display.h b/sdm/libs/hwc2/hwc_display.h
index 9ee7811..b70f160 100644
--- a/sdm/libs/hwc2/hwc_display.h
+++ b/sdm/libs/hwc2/hwc_display.h
@@ -159,6 +159,9 @@
     return INT32(status);
   }
 
+  virtual int SetState(bool connected) {
+    return kErrorNotSupported;
+  }
   int SetPanelBrightness(int level);
   int GetPanelBrightness(int *level);
   int ToggleScreenUpdates(bool enable);
diff --git a/sdm/libs/hwc2/hwc_display_external.cpp b/sdm/libs/hwc2/hwc_display_external.cpp
index a8f8480..e89451d 100644
--- a/sdm/libs/hwc2/hwc_display_external.cpp
+++ b/sdm/libs/hwc2/hwc_display_external.cpp
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2014 - 2016, The Linux Foundation. All rights reserved.
+* Copyright (c) 2014-2017, 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
@@ -64,6 +64,7 @@
 
   error = hwc_display_external->GetMixerResolution(&external_width, &external_height);
   if (error != kErrorNone) {
+    Destroy(hwc_display_external);
     return -EINVAL;
   }
 
@@ -215,4 +216,65 @@
   }
 }
 
+int HWCDisplayExternal::SetState(bool connected) {
+  DisplayError error = kErrorNone;
+  DisplayState state = kStateOff;
+  DisplayConfigVariableInfo fb_config = {};
+
+  if (connected) {
+    if (display_null_.IsActive()) {
+      error = core_intf_->CreateDisplay(type_, this, &display_intf_);
+      if (error != kErrorNone) {
+        DLOGE("Display create failed. Error = %d display_type %d event_handler %p disp_intf %p",
+              error, type_, this, &display_intf_);
+        return -EINVAL;
+      }
+
+      // Restore HDMI attributes when display is reconnected.
+      // This is to ensure that surfaceflinger & sdm are in sync.
+      display_null_.GetFrameBufferConfig(&fb_config);
+      int status = SetFrameBufferResolution(fb_config.x_pixels, fb_config.y_pixels);
+      if (status) {
+        DLOGW("Set frame buffer config failed. Error = %d", error);
+        return -1;
+      }
+
+      display_null_.GetDisplayState(&state);
+      display_intf_->SetDisplayState(state);
+
+      SetVsyncEnabled(HWC2::Vsync::Enable);
+
+      display_null_.SetActive(false);
+      DLOGI("Display is connected successfully.");
+    } else {
+      DLOGI("Display is already connected.");
+    }
+  } else {
+    if (!display_null_.IsActive()) {
+      // Preserve required attributes of HDMI display that surfaceflinger sees.
+      // Restore HDMI attributes when display is reconnected.
+      display_intf_->GetDisplayState(&state);
+      display_null_.SetDisplayState(state);
+
+      error = display_intf_->GetFrameBufferConfig(&fb_config);
+      if (error != kErrorNone) {
+        DLOGW("Get frame buffer config failed. Error = %d", error);
+        return -1;
+      }
+      display_null_.SetFrameBufferConfig(fb_config);
+
+      SetVsyncEnabled(HWC2::Vsync::Disable);
+      core_intf_->DestroyDisplay(display_intf_);
+      display_intf_ = &display_null_;
+
+      display_null_.SetActive(true);
+      DLOGI("Display is disconnected successfully.");
+    } else {
+      DLOGI("Display is already disconnected.");
+    }
+  }
+
+  return 0;
+}
+
 }  // namespace sdm
diff --git a/sdm/libs/hwc2/hwc_display_external.h b/sdm/libs/hwc2/hwc_display_external.h
index 802a77c..7aa84b2 100644
--- a/sdm/libs/hwc2/hwc_display_external.h
+++ b/sdm/libs/hwc2/hwc_display_external.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014-2016, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2014-2017, 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
@@ -31,6 +31,7 @@
 #define __HWC_DISPLAY_EXTERNAL_H__
 
 #include "hwc_display.h"
+#include "display_null.h"
 
 namespace sdm {
 
@@ -47,6 +48,7 @@
   virtual HWC2::Error Validate(uint32_t *out_num_types, uint32_t *out_num_requests);
   virtual HWC2::Error Present(int32_t *out_retire_fence);
   virtual void SetSecureDisplay(bool secure_display_active);
+  virtual int SetState(bool connected);
 
  private:
   HWCDisplayExternal(CoreInterface *core_intf, HWCBufferAllocator *buffer_allocator,
@@ -54,6 +56,8 @@
   void ApplyScanAdjustment(hwc_rect_t *display_frame);
   static void GetDownscaleResolution(uint32_t primary_width, uint32_t primary_height,
                                      uint32_t *virtual_width, uint32_t *virtual_height);
+
+  DisplayNull display_null_;
 };
 
 }  // namespace sdm
diff --git a/sdm/libs/hwc2/hwc_display_primary.cpp b/sdm/libs/hwc2/hwc_display_primary.cpp
index 2fcf2a9..1094100 100644
--- a/sdm/libs/hwc2/hwc_display_primary.cpp
+++ b/sdm/libs/hwc2/hwc_display_primary.cpp
@@ -113,6 +113,8 @@
   }
   color_mode_ = new HWCColorMode(display_intf_);
   color_mode_->Init();
+  HWCDebugHandler::Get()->GetProperty("vendor.display.enable_default_color_mode",
+                                      &default_mode_status_);
 
   return status;
 }
@@ -160,6 +162,10 @@
   auto status = HWC2::Error::None;
   DisplayError error = kErrorNone;
 
+  if (default_mode_status_ && !boot_animation_completed_) {
+    ProcessBootAnimCompleted();
+  }
+
   if (display_paused_) {
     MarkLayersForGPUBypass();
     return status;
@@ -521,12 +527,12 @@
   GetPanelResolution(&panel_width, &panel_height);
   GetFrameBufferResolution(&fb_width, &fb_height);
 
-  if (post_processed_output && (output_buffer_info_.buffer_config.width < panel_width ||
-                                output_buffer_info_.buffer_config.height < panel_height)) {
+  if (post_processed_output && (output_buffer_info.buffer_config.width < panel_width ||
+                                output_buffer_info.buffer_config.height < panel_height)) {
     DLOGE("Buffer dimensions should not be less than panel resolution");
     return -1;
-  } else if (!post_processed_output && (output_buffer_info_.buffer_config.width < fb_width ||
-                                        output_buffer_info_.buffer_config.height < fb_height)) {
+  } else if (!post_processed_output && (output_buffer_info.buffer_config.width < fb_width ||
+                                        output_buffer_info.buffer_config.height < fb_height)) {
     DLOGE("Buffer dimensions should not be less than FB resolution");
     return -1;
   }
diff --git a/sdm/libs/hwc2/hwc_display_primary.h b/sdm/libs/hwc2/hwc_display_primary.h
index 4df65b3..bf6b25f 100644
--- a/sdm/libs/hwc2/hwc_display_primary.h
+++ b/sdm/libs/hwc2/hwc_display_primary.h
@@ -101,6 +101,7 @@
   bool dump_output_to_file_ = false;
   BufferInfo output_buffer_info_ = {};
   void *output_buffer_base_ = nullptr;
+  int default_mode_status_ = 0;
 };
 
 }  // namespace sdm
diff --git a/sdm/libs/hwc2/hwc_display_virtual.cpp b/sdm/libs/hwc2/hwc_display_virtual.cpp
index f77e9c9..8ac9be6 100644
--- a/sdm/libs/hwc2/hwc_display_virtual.cpp
+++ b/sdm/libs/hwc2/hwc_display_virtual.cpp
@@ -59,15 +59,15 @@
     return status;
   }
 
-  status = INT32(hwc_display_virtual->SetPowerMode(HWC2::PowerMode::On));
+  status = hwc_display_virtual->SetConfig(width, height);
   if (status) {
-    DLOGW("Failed to set power mode on virtual display");
     Destroy(hwc_display_virtual);
     return status;
   }
 
-  status = hwc_display_virtual->SetConfig(width, height);
+  status = INT32(hwc_display_virtual->SetPowerMode(HWC2::PowerMode::On));
   if (status) {
+    DLOGW("Failed to set power mode on virtual display");
     Destroy(hwc_display_virtual);
     return status;
   }
diff --git a/sdm/libs/hwc2/hwc_layers.cpp b/sdm/libs/hwc2/hwc_layers.cpp
index 7fcd56b..f485ac6 100644
--- a/sdm/libs/hwc2/hwc_layers.cpp
+++ b/sdm/libs/hwc2/hwc_layers.cpp
@@ -18,6 +18,7 @@
  */
 
 #include <stdint.h>
+#include <utility>
 #include <qdMetaData.h>
 
 #include "hwc_layers.h"
@@ -91,8 +92,13 @@
 
 HWC2::Error HWCLayer::SetLayerBuffer(buffer_handle_t buffer, int32_t acquire_fence) {
   if (!buffer) {
-    DLOGE("Invalid buffer handle: %p on layer: %d", buffer, id_);
-    return HWC2::Error::BadParameter;
+    if (client_requested_ == HWC2::Composition::Device ||
+        client_requested_ == HWC2::Composition::Cursor) {
+      DLOGE("Invalid buffer handle: %p on layer: %d", buffer, id_);
+      return HWC2::Error::BadParameter;
+    } else {
+      return HWC2::Error::None;
+    }
   }
 
   if (acquire_fence == 0) {
@@ -273,6 +279,17 @@
   layer_->transform = layer_transform_;
 }
 
+HWC2::Error HWCLayer::SetCursorPosition(int32_t x, int32_t y) {
+  hwc_rect_t frame = {};
+  frame.left = x;
+  frame.top = y;
+  frame.right = x + INT(layer_->dst_rect.right - layer_->dst_rect.left);
+  frame.bottom = y + INT(layer_->dst_rect.bottom - layer_->dst_rect.top);
+  SetLayerDisplayFrame(frame);
+
+  return HWC2::Error::None;
+}
+
 HWC2::Error HWCLayer::SetLayerPlaneAlpha(float alpha) {
   // Conversion of float alpha in range 0.0 to 1.0 similar to the HWC Adapter
   uint8_t plane_alpha = static_cast<uint8_t>(std::round(255.0f * alpha));
@@ -533,6 +550,27 @@
   return sdm_s3d_format;
 }
 
+void HWCLayer::GetUBWCStatsFromMetaData(UBWCStats *cr_stats, UbwcCrStatsVector *cr_vec) {
+  // TODO(user): Check if we can use UBWCStats directly
+  // in layer_buffer or copy directly to Vector
+  if (cr_stats->bDataValid) {
+    switch (cr_stats->version) {
+      case UBWC_2_0:
+        cr_vec->push_back(std::make_pair(32, cr_stats->ubwc_stats.nCRStatsTile32));
+        cr_vec->push_back(std::make_pair(64, cr_stats->ubwc_stats.nCRStatsTile64));
+        cr_vec->push_back(std::make_pair(96, cr_stats->ubwc_stats.nCRStatsTile96));
+        cr_vec->push_back(std::make_pair(128, cr_stats->ubwc_stats.nCRStatsTile128));
+        cr_vec->push_back(std::make_pair(160, cr_stats->ubwc_stats.nCRStatsTile160));
+        cr_vec->push_back(std::make_pair(192, cr_stats->ubwc_stats.nCRStatsTile192));
+        cr_vec->push_back(std::make_pair(256, cr_stats->ubwc_stats.nCRStatsTile256));
+        break;
+      default:
+        DLOGW("Invalid UBWC Version %d", cr_stats->version);
+        break;
+    }  // switch(cr_stats->version)
+  }  // if (cr_stats->bDatvalid)
+}
+
 DisplayError HWCLayer::SetMetaData(const private_handle_t *pvt_handle, Layer *layer) {
   LayerBuffer *layer_buffer = &layer->input_buffer;
   bool use_color_metadata = true;
@@ -576,6 +614,18 @@
     layer_buffer->s3d_format = GetS3DFormat(s3d);
   }
 
+  // Check if metadata is set
+  struct UBWCStats cr_stats[NUM_UBWC_CR_STATS_LAYERS] = {};
+
+  for (int i = 0; i < NUM_UBWC_CR_STATS_LAYERS; i++) {
+    layer_buffer->ubwc_crstats[i].clear();
+  }
+
+  if (getMetaData(handle, GET_UBWC_CR_STATS_INFO, cr_stats) == 0) {
+  // Only copy top layer for now as only top field for interlaced is used
+    GetUBWCStatsFromMetaData(&cr_stats[0], &(layer_buffer->ubwc_crstats[0]));
+  }  // if (getMetaData)
+
   return kErrorNone;
 }
 
diff --git a/sdm/libs/hwc2/hwc_layers.h b/sdm/libs/hwc2/hwc_layers.h
index 82bf466..c566655 100644
--- a/sdm/libs/hwc2/hwc_layers.h
+++ b/sdm/libs/hwc2/hwc_layers.h
@@ -69,6 +69,7 @@
   HWC2::Error SetLayerCompositionType(HWC2::Composition type);
   HWC2::Error SetLayerDataspace(int32_t dataspace);
   HWC2::Error SetLayerDisplayFrame(hwc_rect_t frame);
+  HWC2::Error SetCursorPosition(int32_t x, int32_t y);
   HWC2::Error SetLayerPlaneAlpha(float alpha);
   HWC2::Error SetLayerSourceCrop(hwc_frect_t crop);
   HWC2::Error SetLayerSurfaceDamage(hwc_region_t damage);
@@ -111,6 +112,7 @@
   uint32_t GetUint32Color(const hwc_color_t &source);
   LayerBufferFormat GetSDMFormat(const int32_t &source, const int flags);
   LayerBufferS3DFormat GetS3DFormat(uint32_t s3d_format);
+  void GetUBWCStatsFromMetaData(UBWCStats *cr_stats, UbwcCrStatsVector *cr_vec);
   DisplayError SetMetaData(const private_handle_t *pvt_handle, Layer *layer);
   DisplayError SetIGC(IGC_t source, LayerIGC *target);
   uint32_t RoundToStandardFPS(float fps);
diff --git a/sdm/libs/hwc2/hwc_session.cpp b/sdm/libs/hwc2/hwc_session.cpp
index a6739b2..a135be2 100644
--- a/sdm/libs/hwc2/hwc_session.cpp
+++ b/sdm/libs/hwc2/hwc_session.cpp
@@ -96,9 +96,7 @@
 
   StartServices();
 
-  buffer_allocator_ = new HWCBufferAllocator();
-
-  DisplayError error = CoreInterface::CreateCore(HWCDebugHandler::Get(), buffer_allocator_,
+  DisplayError error = CoreInterface::CreateCore(HWCDebugHandler::Get(), &buffer_allocator_,
                                                  &buffer_sync_handler_, &socket_handler_,
                                                  &core_intf_);
   if (error != kErrorNone) {
@@ -106,20 +104,31 @@
     return -EINVAL;
   }
 
-  // Read which display is first, and create it and store it in primary slot
-  // TODO(user): This will need to be redone for HWC2 - right now we validate only
-  // the primary physical path
-  HWDisplayInterfaceInfo hw_disp_info;
+  // If HDMI display is primary display, defer display creation until hotplug event is received.
+  HWDisplayInterfaceInfo hw_disp_info = {};
   error = core_intf_->GetFirstDisplayInterfaceType(&hw_disp_info);
-  if (error == kErrorNone && hw_disp_info.type == kHDMI && hw_disp_info.is_connected) {
-    // HDMI is primary display. If already connected, then create it and store in
-    // primary display slot. If not connected, create a NULL display for now.
-    status = HWCDisplayExternal::Create(core_intf_, buffer_allocator_, &callbacks_, qservice_,
-                                        &hwc_display_[HWC_DISPLAY_PRIMARY]);
+  if (error != kErrorNone) {
+    CoreInterface::DestroyCore();
+    DLOGE("Primary display type not recognized. Error = %d", error);
+    return -EINVAL;
+  }
+
+  if (hw_disp_info.type == kHDMI) {
+    status = 0;
+    hdmi_is_primary_ = true;
+    // Create display if it is connected, else wait for hotplug connect event.
+    if (hw_disp_info.is_connected) {
+      status = HWCDisplayExternal::Create(core_intf_, &buffer_allocator_, &callbacks_, qservice_,
+                                          &hwc_display_[HWC_DISPLAY_PRIMARY]);
+    }
   } else {
     // Create and power on primary display
-    status = HWCDisplayPrimary::Create(core_intf_, buffer_allocator_, &callbacks_, qservice_,
+    status = HWCDisplayPrimary::Create(core_intf_, &buffer_allocator_, &callbacks_, qservice_,
                                        &hwc_display_[HWC_DISPLAY_PRIMARY]);
+    color_mgr_ = HWCColorManager::CreateColorManager(&buffer_allocator_);
+    if (!color_mgr_) {
+      DLOGW("Failed to load HWCColorManager.");
+    }
   }
 
   if (status) {
@@ -127,19 +136,6 @@
     return status;
   }
 
-  color_mgr_ = HWCColorManager::CreateColorManager(buffer_allocator_);
-  if (!color_mgr_) {
-    DLOGW("Failed to load HWCColorManager.");
-  }
-
-  if (pthread_create(&uevent_thread_, NULL, &HWCUeventThread, this) < 0) {
-    DLOGE("Failed to start = %s, error = %s", uevent_thread_name_, strerror(errno));
-    HWCDisplayPrimary::Destroy(hwc_display_[HWC_DISPLAY_PRIMARY]);
-    hwc_display_[HWC_DISPLAY_PRIMARY] = 0;
-    CoreInterface::DestroyCore();
-    return -errno;
-  }
-
   struct rlimit fd_limit = {};
   getrlimit(RLIMIT_NOFILE, &fd_limit);
   fd_limit.rlim_cur = fd_limit.rlim_cur * 2;
@@ -149,36 +145,43 @@
       DLOGW("Unable to increase fd limit -  err:%d, %s", errno, strerror(errno));
     }
   }
+
+  std::thread uevent_thread(HWCUeventThread, this);
+  uevent_thread_.swap(uevent_thread);
+
   return 0;
 }
 
 int HWCSession::Deinit() {
-  HWCDisplayPrimary::Destroy(hwc_display_[HWC_DISPLAY_PRIMARY]);
-  hwc_display_[HWC_DISPLAY_PRIMARY] = 0;
+  HWCDisplay *primary_display = hwc_display_[HWC_DISPLAY_PRIMARY];
+  if (primary_display) {
+    if (hdmi_is_primary_) {
+      HWCDisplayExternal::Destroy(primary_display);
+    } else {
+      HWCDisplayPrimary::Destroy(primary_display);
+    }
+  }
+  hwc_display_[HWC_DISPLAY_PRIMARY] = nullptr;
+
   if (color_mgr_) {
     color_mgr_->DestroyColorManager();
   }
-  uevent_thread_exit_ = true;
+
   DLOGD("Terminating uevent thread");
-  // TODO(user): on restarting HWC in the same process, the uevent thread does not restart
-  // cleanly.
-  Sys::pthread_cancel_(uevent_thread_);
+  uevent_thread_exit_ = true;
+  // todo(user): add a local event to interrupt thread execution and join.
+  uevent_thread_.detach();
 
   DisplayError error = CoreInterface::DestroyCore();
   if (error != kErrorNone) {
     DLOGE("Display core de-initialization failed. Error = %d", error);
   }
 
-  if (buffer_allocator_ != nullptr) {
-    delete buffer_allocator_;
-  }
-  buffer_allocator_ = nullptr;
-
   return 0;
 }
 
 int HWCSession::Open(const hw_module_t *module, const char *name, hw_device_t **device) {
-  SEQUENCE_WAIT_SCOPE_LOCK(locker_);
+  SCOPE_LOCK(locker_);
 
   if (!module || !name || !device) {
     DLOGE("Invalid parameters.");
@@ -204,7 +207,7 @@
 }
 
 int HWCSession::Close(hw_device_t *device) {
-  SEQUENCE_WAIT_SCOPE_LOCK(locker_);
+  SCOPE_LOCK(locker_);
 
   if (!device) {
     return -EINVAL;
@@ -291,7 +294,7 @@
 }
 
 void HWCSession::Dump(hwc2_device_t *device, uint32_t *out_size, char *out_buffer) {
-  SEQUENCE_WAIT_SCOPE_LOCK(locker_);
+  SCOPE_LOCK(locker_);
 
   if (!device) {
     return;
@@ -409,7 +412,6 @@
                                    int32_t *out_retire_fence) {
   HWCSession *hwc_session = static_cast<HWCSession *>(device);
   DTRACE_SCOPED();
-  SEQUENCE_EXIT_SCOPE_LOCK(locker_);
   if (!device) {
     return HWC2_ERROR_BAD_DISPLAY;
   }
@@ -436,8 +438,13 @@
   auto desc = static_cast<HWC2::Callback>(descriptor);
   auto error = hwc_session->callbacks_.Register(desc, callback_data, pointer);
   DLOGD("Registering callback: %s", to_string(desc).c_str());
-  if (descriptor == HWC2_CALLBACK_HOTPLUG)
-    hwc_session->callbacks_.Hotplug(HWC_DISPLAY_PRIMARY, HWC2::Connection::Connected);
+  if (descriptor == HWC2_CALLBACK_HOTPLUG) {
+    // If primary display (HDMI) is not created yet, wait for it to be hotplugged.
+    if (hwc_session->hwc_display_[HWC_DISPLAY_PRIMARY]) {
+      hwc_session->callbacks_.Hotplug(HWC_DISPLAY_PRIMARY, HWC2::Connection::Connected);
+    }
+  }
+
   return INT32(error);
 }
 
@@ -456,14 +463,14 @@
 int32_t HWCSession::SetColorMode(hwc2_device_t *device, hwc2_display_t display,
                                  int32_t /*android_color_mode_t*/ int_mode) {
   auto mode = static_cast<android_color_mode_t>(int_mode);
-  SEQUENCE_WAIT_SCOPE_LOCK(locker_);
+  SCOPE_LOCK(locker_);
   return HWCSession::CallDisplayFunction(device, display, &HWCDisplay::SetColorMode, mode);
 }
 
 int32_t HWCSession::SetColorTransform(hwc2_device_t *device, hwc2_display_t display,
                                       const float *matrix,
                                       int32_t /*android_color_transform_t*/ hint) {
-  SEQUENCE_WAIT_SCOPE_LOCK(locker_);
+  SCOPE_LOCK(locker_);
   android_color_transform_t transform_hint = static_cast<android_color_transform_t>(hint);
   return HWCSession::CallDisplayFunction(device, display, &HWCDisplay::SetColorTransform, matrix,
                                          transform_hint);
@@ -471,8 +478,14 @@
 
 static int32_t SetCursorPosition(hwc2_device_t *device, hwc2_display_t display, hwc2_layer_t layer,
                                  int32_t x, int32_t y) {
-  return HWCSession::CallDisplayFunction(device, display, &HWCDisplay::SetCursorPosition, layer, x,
-                                         y);
+  auto status = INT32(HWC2::Error::None);
+  status = HWCSession::CallDisplayFunction(device, display, &HWCDisplay::SetCursorPosition,
+                                           layer, x, y);
+  if (status == INT32(HWC2::Error::None)) {
+    // Update cursor position
+    HWCSession::CallLayerFunction(device, display, layer, &HWCLayer::SetCursorPosition, x, y);
+  }
+  return status;
 }
 
 static int32_t SetLayerBlendMode(hwc2_device_t *device, hwc2_display_t display, hwc2_layer_t layer,
@@ -565,7 +578,7 @@
 
 int32_t HWCSession::SetPowerMode(hwc2_device_t *device, hwc2_display_t display, int32_t int_mode) {
   auto mode = static_cast<HWC2::PowerMode>(int_mode);
-  SEQUENCE_WAIT_SCOPE_LOCK(locker_);
+  SCOPE_LOCK(locker_);
   return CallDisplayFunction(device, display, &HWCDisplay::SetPowerMode, mode);
 }
 
@@ -577,6 +590,7 @@
 int32_t HWCSession::ValidateDisplay(hwc2_device_t *device, hwc2_display_t display,
                                     uint32_t *out_num_types, uint32_t *out_num_requests) {
   DTRACE_SCOPED();
+  SCOPE_LOCK(locker_);
   HWCSession *hwc_session = static_cast<HWCSession *>(device);
   if (!device) {
     return HWC2_ERROR_BAD_DISPLAY;
@@ -586,7 +600,6 @@
   // Handle external_pending_connect_ in CreateVirtualDisplay
   auto status = HWC2::Error::BadDisplay;
   if (hwc_session->hwc_display_[display]) {
-    SEQUENCE_ENTRY_SCOPE_LOCK(locker_);
     if (display == HWC_DISPLAY_PRIMARY) {
       // TODO(user): This can be moved to HWCDisplayPrimary
       if (hwc_session->reset_panel_) {
@@ -605,11 +618,6 @@
 
     status = hwc_session->hwc_display_[display]->Validate(out_num_types, out_num_requests);
   }
-  // If validate fails, cancel the sequence lock so that other operations
-  // (such as Dump or SetPowerMode) may succeed without blocking on the condition
-  if (status == HWC2::Error::BadDisplay) {
-    SEQUENCE_CANCEL_SCOPE_LOCK(locker_);
-  }
   return INT32(status);
 }
 
@@ -719,7 +727,7 @@
   if (hwc_display_[HWC_DISPLAY_VIRTUAL]) {
     return HWC2::Error::NoResources;
   }
-  auto status = HWCDisplayVirtual::Create(core_intf_, buffer_allocator_, &callbacks_, width,
+  auto status = HWCDisplayVirtual::Create(core_intf_, &buffer_allocator_, &callbacks_, width,
                                           height, format, &hwc_display_[HWC_DISPLAY_VIRTUAL]);
   // TODO(user): validate width and height support
   if (status)
@@ -738,7 +746,7 @@
   hwc_display_[HWC_DISPLAY_PRIMARY]->GetFrameBufferResolution(&primary_width, &primary_height);
 
   if (disp == HWC_DISPLAY_EXTERNAL) {
-    status = HWCDisplayExternal::Create(core_intf_, buffer_allocator_, &callbacks_, primary_width,
+    status = HWCDisplayExternal::Create(core_intf_, &buffer_allocator_, &callbacks_, primary_width,
                                         primary_height, qservice_, false, &hwc_display_[disp]);
   } else {
     DLOGE("Invalid display type");
@@ -923,7 +931,7 @@
 android::status_t HWCSession::HandleGetDisplayAttributesForConfig(const android::Parcel
                                                                   *input_parcel,
                                                                   android::Parcel *output_parcel) {
-  SEQUENCE_WAIT_SCOPE_LOCK(locker_);
+  SCOPE_LOCK(locker_);
 
   int config = input_parcel->readInt32();
   int dpy = input_parcel->readInt32();
@@ -950,7 +958,7 @@
 }
 
 android::status_t HWCSession::ConfigureRefreshRate(const android::Parcel *input_parcel) {
-  SEQUENCE_WAIT_SCOPE_LOCK(locker_);
+  SCOPE_LOCK(locker_);
 
   uint32_t operation = UINT32(input_parcel->readInt32());
   HWCDisplay *hwc_display = hwc_display_[HWC_DISPLAY_PRIMARY];
@@ -976,14 +984,14 @@
 }
 
 android::status_t HWCSession::SetDisplayMode(const android::Parcel *input_parcel) {
-  SEQUENCE_WAIT_SCOPE_LOCK(locker_);
+  SCOPE_LOCK(locker_);
 
   uint32_t mode = UINT32(input_parcel->readInt32());
   return hwc_display_[HWC_DISPLAY_PRIMARY]->Perform(HWCDisplayPrimary::SET_DISPLAY_MODE, mode);
 }
 
 android::status_t HWCSession::SetMaxMixerStages(const android::Parcel *input_parcel) {
-  SEQUENCE_WAIT_SCOPE_LOCK(locker_);
+  SCOPE_LOCK(locker_);
 
   DisplayError error = kErrorNone;
   std::bitset<32> bit_mask_display_type = UINT32(input_parcel->readInt32());
@@ -1020,7 +1028,7 @@
 }
 
 void HWCSession::SetFrameDumpConfig(const android::Parcel *input_parcel) {
-  SEQUENCE_WAIT_SCOPE_LOCK(locker_);
+  SCOPE_LOCK(locker_);
 
   uint32_t frame_dump_count = UINT32(input_parcel->readInt32());
   std::bitset<32> bit_mask_display_type = UINT32(input_parcel->readInt32());
@@ -1046,7 +1054,7 @@
 }
 
 android::status_t HWCSession::SetMixerResolution(const android::Parcel *input_parcel) {
-  SEQUENCE_WAIT_SCOPE_LOCK(locker_);
+  SCOPE_LOCK(locker_);
 
   DisplayError error = kErrorNone;
   uint32_t dpy = UINT32(input_parcel->readInt32());
@@ -1073,7 +1081,7 @@
 }
 
 android::status_t HWCSession::SetColorModeOverride(const android::Parcel *input_parcel) {
-  SEQUENCE_WAIT_SCOPE_LOCK(locker_);
+  SCOPE_LOCK(locker_);
 
   auto display = static_cast<hwc2_display_t >(input_parcel->readInt32());
   auto mode = static_cast<android_color_mode_t>(input_parcel->readInt32());
@@ -1095,7 +1103,7 @@
 }
 
 void HWCSession::DynamicDebug(const android::Parcel *input_parcel) {
-  SEQUENCE_WAIT_SCOPE_LOCK(locker_);
+  SCOPE_LOCK(locker_);
 
   int type = input_parcel->readInt32();
   bool enable = (input_parcel->readInt32() > 0);
@@ -1130,6 +1138,10 @@
       HWCDebugHandler::DebugQdcm(enable, verbose_level);
       break;
 
+    case qService::IQService::DEBUG_SCALAR:
+      HWCDebugHandler::DebugScalar(enable, verbose_level);
+      break;
+
     default:
       DLOGW("type = %d is not supported", type);
   }
@@ -1137,7 +1149,7 @@
 
 android::status_t HWCSession::QdcmCMDHandler(const android::Parcel *input_parcel,
                                              android::Parcel *output_parcel) {
-  SEQUENCE_WAIT_SCOPE_LOCK(locker_);
+  SCOPE_LOCK(locker_);
 
   int ret = 0;
   int32_t *brightness_value = NULL;
@@ -1341,34 +1353,35 @@
 int HWCSession::HotPlugHandler(bool connected) {
   int status = 0;
   bool notify_hotplug = false;
-  bool hdmi_primary = false;
 
   // To prevent sending events to client while a lock is held, acquire scope locks only within
   // below scope so that those get automatically unlocked after the scope ends.
-  {
-    SEQUENCE_WAIT_SCOPE_LOCK(locker_);
+  do {
+    SCOPE_LOCK(locker_);
 
+    // If HDMI is primary but not created yet (first time), create it and notify surfaceflinger.
+    //    if it is already created, but got disconnected/connected again,
+    //    just toggle display status and do not notify surfaceflinger.
+    // If HDMI is not primary, create/destroy external display normally.
+    if (hdmi_is_primary_) {
+      if (hwc_display_[HWC_DISPLAY_PRIMARY]) {
+        status = hwc_display_[HWC_DISPLAY_PRIMARY]->SetState(connected);
+      } else {
+        status = HWCDisplayExternal::Create(core_intf_, &buffer_allocator_, &callbacks_,
+                                            qservice_, &hwc_display_[HWC_DISPLAY_PRIMARY]);
+        notify_hotplug = true;
+      }
+
+      break;
+    }
+
+    // Primary display must be connected for HDMI as secondary cases.
     if (!hwc_display_[HWC_DISPLAY_PRIMARY]) {
       DLOGE("Primary display is not connected.");
       return -1;
     }
 
-    HWCDisplay *primary_display = hwc_display_[HWC_DISPLAY_PRIMARY];
-    HWCDisplay *external_display = NULL;
-
-    if (primary_display->GetDisplayClass() == DISPLAY_CLASS_EXTERNAL) {
-      external_display = static_cast<HWCDisplayExternal *>(hwc_display_[HWC_DISPLAY_PRIMARY]);
-      hdmi_primary = true;
-    }
-
-    // If primary display connected is a NULL display, then replace it with the external display
     if (connected) {
-      // If we are in HDMI as primary and the primary display just got plugged in
-      if (hwc_display_[HWC_DISPLAY_EXTERNAL]) {
-        DLOGE("HDMI is already connected");
-        return -1;
-      }
-
       // Connect external display if virtual display is not connected.
       // Else, defer external display connection and process it when virtual display
       // tears down; Do not notify SurfaceFlinger since connection is deferred now.
@@ -1386,39 +1399,28 @@
       // Do not return error if external display is not in connected status.
       // Due to virtual display concurrency, external display connection might be still pending
       // but hdmi got disconnected before pending connection could be processed.
-
-      if (hdmi_primary) {
-        assert(external_display != NULL);
-        uint32_t x_res, y_res;
-        external_display->GetFrameBufferResolution(&x_res, &y_res);
-        // Need to manually disable VSYNC as SF is not aware of connect/disconnect cases
-        // for HDMI as primary
-        external_display->SetVsyncEnabled(HWC2::Vsync::Disable);
-        HWCDisplayExternal::Destroy(external_display);
-
-        // In HWC2, primary displays can be hotplugged out
+      if (hwc_display_[HWC_DISPLAY_EXTERNAL]) {
+        status = DisconnectDisplay(HWC_DISPLAY_EXTERNAL);
         notify_hotplug = true;
-      } else {
-        if (hwc_display_[HWC_DISPLAY_EXTERNAL]) {
-          status = DisconnectDisplay(HWC_DISPLAY_EXTERNAL);
-          notify_hotplug = true;
-        }
-        external_pending_connect_ = false;
       }
+      external_pending_connect_ = false;
+    }
+  } while (0);
+
+  if (connected) {
+    callbacks_.Refresh(0);
+
+    if (!hdmi_is_primary_) {
+      // wait for sufficient time to ensure sufficient resources are available to process new
+      // new display connection.
+      uint32_t vsync_period = UINT32(GetVsyncPeriod(HWC_DISPLAY_PRIMARY));
+      usleep(vsync_period * 2 / 1000);
     }
   }
 
-  if (connected && notify_hotplug) {
-    // trigger screen refresh to ensure sufficient resources are available to process new
-    // new display connection.
-    callbacks_.Refresh(0);
-    uint32_t vsync_period = UINT32(GetVsyncPeriod(HWC_DISPLAY_PRIMARY));
-    usleep(vsync_period * 2 / 1000);
-  }
   // notify client
-  // Handle HDMI as primary here
   if (notify_hotplug) {
-    callbacks_.Hotplug(HWC_DISPLAY_EXTERNAL,
+    callbacks_.Hotplug(hdmi_is_primary_ ? HWC_DISPLAY_PRIMARY : HWC_DISPLAY_EXTERNAL,
                        connected ? HWC2::Connection::Connected : HWC2::Connection::Disconnected);
   }
 
@@ -1442,7 +1444,7 @@
 
 android::status_t HWCSession::GetVisibleDisplayRect(const android::Parcel *input_parcel,
                                                     android::Parcel *output_parcel) {
-  SEQUENCE_WAIT_SCOPE_LOCK(locker_);
+  SCOPE_LOCK(locker_);
 
   int dpy = input_parcel->readInt32();
 
diff --git a/sdm/libs/hwc2/hwc_session.h b/sdm/libs/hwc2/hwc_session.h
index be4494e..cd9831d 100644
--- a/sdm/libs/hwc2/hwc_session.h
+++ b/sdm/libs/hwc2/hwc_session.h
@@ -23,6 +23,7 @@
 #include <vendor/display/config/1.0/IDisplayConfig.h>
 #include <core/core_interface.h>
 #include <utils/locker.h>
+#include <thread>
 
 #include "hwc_callbacks.h"
 #include "hwc_layers.h"
@@ -188,23 +189,24 @@
   android::status_t SetColorModeById(const android::Parcel *input_parcel);
 
   static Locker locker_;
-  CoreInterface *core_intf_ = NULL;
-  HWCDisplay *hwc_display_[HWC_NUM_DISPLAY_TYPES] = {NULL};
+  CoreInterface *core_intf_ = nullptr;
+  HWCDisplay *hwc_display_[HWC_NUM_DISPLAY_TYPES] = {nullptr};
   HWCCallbacks callbacks_;
-  pthread_t uevent_thread_;
+  std::thread uevent_thread_;
   bool uevent_thread_exit_ = false;
   const char *uevent_thread_name_ = "HWC_UeventThread";
-  HWCBufferAllocator *buffer_allocator_;
+  HWCBufferAllocator buffer_allocator_;
   HWCBufferSyncHandler buffer_sync_handler_;
-  HWCColorManager *color_mgr_ = NULL;
+  HWCColorManager *color_mgr_ = nullptr;
   bool reset_panel_ = false;
   bool secure_display_active_ = false;
   bool external_pending_connect_ = false;
   bool new_bw_mode_ = false;
   bool need_invalidate_ = false;
   int bw_mode_release_fd_ = -1;
-  qService::QService *qservice_ = NULL;
+  qService::QService *qservice_ = nullptr;
   HWCSocketHandler socket_handler_;
+  bool hdmi_is_primary_ = false;
 };
 
 }  // namespace sdm
diff --git a/sdm/libs/hwc2/hwc_session_services.cpp b/sdm/libs/hwc2/hwc_session_services.cpp
index 4b5374f..5cb9cf7 100644
--- a/sdm/libs/hwc2/hwc_session_services.cpp
+++ b/sdm/libs/hwc2/hwc_session_services.cpp
@@ -92,7 +92,7 @@
 // Methods from ::vendor::hardware::display::config::V1_0::IDisplayConfig follow.
 Return<void> HWCSession::isDisplayConnected(IDisplayConfig::DisplayType dpy,
                                             isDisplayConnected_cb _hidl_cb) {
-  SEQUENCE_WAIT_SCOPE_LOCK(locker_);
+  SCOPE_LOCK(locker_);
 
   int32_t error = -EINVAL;
   bool connected = false;
@@ -109,7 +109,7 @@
 }
 
 int32_t HWCSession::SetSecondaryDisplayStatus(int disp_id, HWCDisplay::DisplayStatus status) {
-  SEQUENCE_WAIT_SCOPE_LOCK(locker_);
+  SCOPE_LOCK(locker_);
 
   if (disp_id < 0) {
     return -EINVAL;
@@ -135,7 +135,7 @@
 
 Return<int32_t> HWCSession::configureDynRefeshRate(IDisplayConfig::DisplayDynRefreshRateOp op,
                                                    uint32_t refreshRate) {
-  SEQUENCE_WAIT_SCOPE_LOCK(locker_);
+  SCOPE_LOCK(locker_);
 
   HWCDisplay *hwc_display = hwc_display_[HWC_DISPLAY_PRIMARY];
 
@@ -158,7 +158,7 @@
 }
 
 int32_t HWCSession::GetConfigCount(int disp_id, uint32_t *count) {
-  SEQUENCE_WAIT_SCOPE_LOCK(locker_);
+  SCOPE_LOCK(locker_);
 
   if (disp_id >= 0 && hwc_display_[disp_id]) {
     return hwc_display_[disp_id]->GetDisplayConfigCount(count);
@@ -170,7 +170,7 @@
 Return<void> HWCSession::getConfigCount(IDisplayConfig::DisplayType dpy,
                                         getConfigCount_cb _hidl_cb) {
   uint32_t count = 0;
-  int32_t error = GetActiveConfigIndex(MapDisplayType(dpy), &count);
+  int32_t error = GetConfigCount(MapDisplayType(dpy), &count);
 
   _hidl_cb(error, count);
 
@@ -178,7 +178,7 @@
 }
 
 int32_t HWCSession::GetActiveConfigIndex(int disp_id, uint32_t *config) {
-  SEQUENCE_WAIT_SCOPE_LOCK(locker_);
+  SCOPE_LOCK(locker_);
 
   if (disp_id >= 0 && hwc_display_[disp_id]) {
     return hwc_display_[disp_id]->GetActiveDisplayConfig(config);
@@ -198,7 +198,7 @@
 }
 
 int32_t HWCSession::SetActiveConfigIndex(int disp_id, uint32_t config) {
-  SEQUENCE_WAIT_SCOPE_LOCK(locker_);
+  SCOPE_LOCK(locker_);
 
   if (disp_id < 0) {
     return -EINVAL;
@@ -222,7 +222,7 @@
 Return<void> HWCSession::getDisplayAttributes(uint32_t configIndex,
                                               IDisplayConfig::DisplayType dpy,
                                               getDisplayAttributes_cb _hidl_cb) {
-  SEQUENCE_WAIT_SCOPE_LOCK(locker_);
+  SCOPE_LOCK(locker_);
 
   int32_t error = -EINVAL;
   IDisplayConfig::DisplayAttributes display_attributes = {};
@@ -247,7 +247,7 @@
 }
 
 Return<int32_t> HWCSession::setPanelBrightness(uint32_t level) {
-  SEQUENCE_WAIT_SCOPE_LOCK(locker_);
+  SCOPE_LOCK(locker_);
 
   int32_t error = -EINVAL;
   if (hwc_display_[HWC_DISPLAY_PRIMARY]) {
@@ -261,7 +261,7 @@
 }
 
 int32_t HWCSession::GetPanelBrightness(int *level) {
-  SEQUENCE_WAIT_SCOPE_LOCK(locker_);
+  SCOPE_LOCK(locker_);
 
   int32_t error = -EINVAL;
 
@@ -285,7 +285,7 @@
 }
 
 int32_t HWCSession::MinHdcpEncryptionLevelChanged(int disp_id, uint32_t min_enc_level) {
-  SEQUENCE_WAIT_SCOPE_LOCK(locker_);
+  SCOPE_LOCK(locker_);
 
   DLOGI("Display %d", disp_id);
 
@@ -310,7 +310,7 @@
 }
 
 Return<int32_t> HWCSession::refreshScreen() {
-  SEQUENCE_WAIT_SCOPE_LOCK(locker_);
+  SCOPE_LOCK(locker_);
 
   callbacks_.Refresh(HWC_DISPLAY_PRIMARY);
 
@@ -318,7 +318,7 @@
 }
 
 int32_t HWCSession::ControlPartialUpdate(int disp_id, bool enable) {
-  SEQUENCE_WAIT_SCOPE_LOCK(locker_);
+  SCOPE_LOCK(locker_);
 
   if (disp_id < 0) {
     return -EINVAL;
@@ -362,7 +362,7 @@
 }
 
 Return<int32_t> HWCSession::toggleScreenUpdate(bool on) {
-  SEQUENCE_WAIT_SCOPE_LOCK(locker_);
+  SCOPE_LOCK(locker_);
 
   int32_t error = -EINVAL;
   if (hwc_display_[HWC_DISPLAY_PRIMARY]) {
@@ -376,7 +376,7 @@
 }
 
 Return<int32_t> HWCSession::setIdleTimeout(uint32_t value) {
-  SEQUENCE_WAIT_SCOPE_LOCK(locker_);
+  SCOPE_LOCK(locker_);
 
   if (hwc_display_[HWC_DISPLAY_PRIMARY]) {
     hwc_display_[HWC_DISPLAY_PRIMARY]->SetIdleTimeoutMs(value);
@@ -388,7 +388,7 @@
 
 Return<void> HWCSession::getHDRCapabilities(IDisplayConfig::DisplayType dpy,
                                             getHDRCapabilities_cb _hidl_cb) {
-  SEQUENCE_WAIT_SCOPE_LOCK(locker_);
+  SCOPE_LOCK(locker_);
 
   int32_t error = -EINVAL;
   IDisplayConfig::DisplayHDRCapabilities hdr_caps = {};
@@ -438,7 +438,7 @@
 }
 
 Return<int32_t> HWCSession::setCameraLaunchStatus(uint32_t on) {
-  SEQUENCE_WAIT_SCOPE_LOCK(locker_);
+  SCOPE_LOCK(locker_);
 
   HWBwModes mode = on > 0 ? kBwCamera : kBwDefault;
 
@@ -456,7 +456,7 @@
 }
 
 int32_t HWCSession::DisplayBWTransactionPending(bool *status) {
-  SEQUENCE_WAIT_SCOPE_LOCK(locker_);
+  SCOPE_LOCK(locker_);
 
   if (hwc_display_[HWC_DISPLAY_PRIMARY]) {
     if (sync_wait(bw_mode_release_fd_, 0) < 0) {
diff --git a/sdm/libs/hwc/hwc_socket_handler.cpp b/sdm/libs/hwc2/hwc_socket_handler.cpp
similarity index 100%
rename from sdm/libs/hwc/hwc_socket_handler.cpp
rename to sdm/libs/hwc2/hwc_socket_handler.cpp
diff --git a/sdm/libs/hwc/hwc_socket_handler.h b/sdm/libs/hwc2/hwc_socket_handler.h
similarity index 100%
rename from sdm/libs/hwc/hwc_socket_handler.h
rename to sdm/libs/hwc2/hwc_socket_handler.h
diff --git a/sdm/libs/hwc2/hwc_tonemapper.cpp b/sdm/libs/hwc2/hwc_tonemapper.cpp
index 74f4c6a..3086fb4 100644
--- a/sdm/libs/hwc2/hwc_tonemapper.cpp
+++ b/sdm/libs/hwc2/hwc_tonemapper.cpp
@@ -299,9 +299,9 @@
 
   size_t result = 0;
   char dump_file_name[PATH_MAX];
-  snprintf(dump_file_name, sizeof(dump_file_name), "/data/misc/display/frame_dump_primary"
-           "/tonemap_%dx%d_frame%d.raw", target_buffer->width, target_buffer->height,
-           dump_frame_index_);
+  snprintf(dump_file_name, sizeof(dump_file_name), "%s/frame_dump_primary"
+           "/tonemap_%dx%d_frame%d.raw", HWCDebugHandler::DumpDir(), target_buffer->width,
+           target_buffer->height, dump_frame_index_);
 
   FILE* fp = fopen(dump_file_name, "w+");
   if (fp) {
diff --git a/sdm/libs/utils/debug.cpp b/sdm/libs/utils/debug.cpp
index 95b4e3b..60ce0ac 100644
--- a/sdm/libs/utils/debug.cpp
+++ b/sdm/libs/utils/debug.cpp
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2014 - 2016, The Linux Foundation. All rights reserved.
+* Copyright (c) 2014 - 2017, 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
@@ -47,11 +47,14 @@
   return value;
 }
 
-int Debug::GetHDMIResolution() {
-  int value = 0;
-  debug_.debug_handler_->GetProperty("hw.hdmi.resolution", &value);
+bool Debug::GetExternalResolution(char *value) {
+  uint32_t retval = 0;
+  debug_.debug_handler_->GetProperty("hw.hdmi.resolution", value);
+  if (value[0]) {
+    retval = 1;
+  }
 
-  return value;
+  return retval;
 }
 
 void Debug::GetIdleTimeoutMs(uint32_t *active_ms, uint32_t *inactive_ms) {
@@ -190,6 +193,22 @@
   return kErrorNone;
 }
 
+DisplayError Debug::GetReducedConfig(uint32_t *num_vig_pipes, uint32_t *num_dma_pipes) {
+  char value[64] = {};
+
+  DisplayError error = debug_.debug_handler_->GetProperty("sdm.debug.reduced_config", value);
+  if (error != kErrorNone) {
+    return error;
+  }
+
+  std::string str(value);
+
+  *num_vig_pipes = UINT32(stoi(str));
+  *num_dma_pipes = UINT32(stoi(str.substr(str.find('x') + 1)));
+
+  return kErrorNone;
+}
+
 int Debug::GetExtMaxlayers() {
   int max_external_layers = 0;
   debug_.debug_handler_->GetProperty("sdm.max_external_layers", &max_external_layers);