diff --git a/displayengine/include/core/core_interface.h b/displayengine/include/core/core_interface.h
index 3328d64..45d9c8c 100644
--- a/displayengine/include/core/core_interface.h
+++ b/displayengine/include/core/core_interface.h
@@ -34,7 +34,7 @@
 
 #include <stdint.h>
 
-#include "device_interface.h"
+#include "display_interface.h"
 #include "display_types.h"
 
 /*! @brief Display core interface version.
@@ -150,16 +150,16 @@
     interface associated with this object is returned via output parameter which can be used to
     interact further with the display device.
 
-    @param[in] type \link DeviceType \endlink
-    @param[in] event_handler \link DeviceEventHandler \endlink
+    @param[in] type \link DisplayType \endlink
+    @param[in] event_handler \link DisplayEventHandler \endlink
     @param[out] interface \link DisplayInterface \endlink
 
     @return \link DisplayError \endlink
 
-    @sa DestroyDevice
+    @sa DestroyDisplay
   */
-  virtual DisplayError CreateDevice(DeviceType type, DeviceEventHandler *event_handler,
-                                    DeviceInterface **interface) = 0;
+  virtual DisplayError CreateDisplay(DisplayType type, DisplayEventHandler *event_handler,
+                                    DisplayInterface **interface) = 0;
 
   /*! @brief Method to destroy a display device.
 
@@ -169,9 +169,9 @@
 
     @return \link DisplayError \endlink
 
-    @sa CreateDevice
+    @sa CreateDisplay
   */
-  virtual DisplayError DestroyDevice(DeviceInterface *interface) = 0;
+  virtual DisplayError DestroyDisplay(DisplayInterface *interface) = 0;
 
  protected:
   virtual ~CoreInterface() { }
diff --git a/displayengine/include/core/device_interface.h b/displayengine/include/core/display_interface.h
similarity index 84%
rename from displayengine/include/core/device_interface.h
rename to displayengine/include/core/display_interface.h
index 01c5446..bb03921 100644
--- a/displayengine/include/core/device_interface.h
+++ b/displayengine/include/core/display_interface.h
@@ -22,7 +22,7 @@
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
-/*! @file device_interface.h
+/*! @file display_interface.h
   @brief Interface file for display device which represents a physical panel or an output buffer
   where contents can be rendered.
 
@@ -30,8 +30,8 @@
   the target device. Each display device represents a unique display target which may be either a
   physical panel or an output buffer..
 */
-#ifndef __DEVICE_INTERFACE_H__
-#define __DEVICE_INTERFACE_H__
+#ifndef __DISPLAY_INTERFACE_H__
+#define __DISPLAY_INTERFACE_H__
 
 #include <stdint.h>
 
@@ -42,10 +42,10 @@
 
 /*! @brief This enum represents display device types where contents can be rendered.
 
-  @sa CoreInterface::CreateDevice
-  @sa CoreInterface::IsDeviceSupported
+  @sa CoreInterface::CreateDisplay
+  @sa CoreInterface::IsDisplaySupported
 */
-enum DeviceType {
+enum DisplayType {
   kPrimary,         //!< Main physical display which is attached to the handheld device.
   kHDMI,            //!< HDMI physical display which is generally detachable.
   kVirtual,         //!< Contents would be rendered into the output buffer provided by the client
@@ -54,10 +54,10 @@
 
 /*! @brief This enum represents states of a display device.
 
-  @sa DisplayInterface::GetDeviceState
-  @sa DisplayInterface::SetDeviceState
+  @sa DisplayInterface::GetDisplayState
+  @sa DisplayInterface::SetDisplayState
 */
-enum DeviceState {
+enum DisplayState {
   kStateOff,        //!< Display is OFF. Contents are not rendered in this state. Client will not
                     //!< receive VSync events in this state. This is default state as well.
 
@@ -75,11 +75,11 @@
   @sa DisplayInterface::GetConfig
   @sa DisplayInterface::SetConfig
 */
-struct DeviceConfigFixedInfo {
+struct DisplayConfigFixedInfo {
   bool underscan;   //!< If display support CE underscan.
   bool secure;      //!< If this display is capable of handling secure content.
 
-  DeviceConfigFixedInfo() : underscan(false), secure(false) { }
+  DisplayConfigFixedInfo() : underscan(false), secure(false) { }
 };
 
 /*! @brief This structure defines configuration for variable properties of a display device.
@@ -87,7 +87,7 @@
   @sa DisplayInterface::GetConfig
   @sa DisplayInterface::SetConfig
 */
-struct DeviceConfigVariableInfo {
+struct DisplayConfigVariableInfo {
   uint32_t x_pixels;          //!< Total number of pixels in X-direction on the display panel.
   uint32_t y_pixels;          //!< Total number of pixels in Y-direction on the display panel.
   float x_dpi;                //!< Dots per inch in X-direction.
@@ -95,18 +95,18 @@
   float fps;                  //!< Frame rate per second.
   uint32_t vsync_period_ns;   //!< VSync period in nanoseconds.
 
-  DeviceConfigVariableInfo() : x_pixels(0), y_pixels(0), x_dpi(0.0f), y_dpi(0.0f),
+  DisplayConfigVariableInfo() : x_pixels(0), y_pixels(0), x_dpi(0.0f), y_dpi(0.0f),
                                fps(0.0f), vsync_period_ns(0) { }
 };
 
 /*! @brief Event data associated with VSync event.
 
-  @sa DeviceEventHandler::VSync
+  @sa DisplayEventHandler::VSync
 */
-struct DeviceEventVSync {
+struct DisplayEventVSync {
   int64_t timestamp;    //!< System monotonic clock timestamp in nanoseconds.
 
-  DeviceEventVSync() : timestamp(0) { }
+  DisplayEventVSync() : timestamp(0) { }
 };
 
 /*! @brief Display device event handler implemented by the client.
@@ -116,23 +116,23 @@
   Client must post heavy-weight event handling to a separate thread and unblock display engine
   thread instantly.
 
-  @sa CoreInterface::CreateDevice
+  @sa CoreInterface::CreateDisplay
 */
-class DeviceEventHandler {
+class DisplayEventHandler {
  public:
   /*! @brief Event handler for VSync event.
 
     @details This event is dispatched on every vertical synchronization. The event is disabled by
     default.
 
-    @param[in] vsync \link DeviceEventVSync \endlink
+    @param[in] vsync \link DisplayEventVSync \endlink
 
     @return \link DisplayError \endlink
 
-    @sa DeviceInterface::GetDeviceState
-    @sa DeviceInterface::SetDeviceState
+    @sa DisplayInterface::GetDisplayState
+    @sa DisplayInterface::SetDisplayState
   */
-  virtual DisplayError VSync(const DeviceEventVSync &vsync) = 0;
+  virtual DisplayError VSync(const DisplayEventVSync &vsync) = 0;
 
   /*! @brief Event handler for Refresh event.
 
@@ -142,13 +142,13 @@
 
     @return \link DisplayError \endlink
 
-    @sa DeviceInterface::Prepare
-    @sa DeviceInterface::Commit
+    @sa DisplayInterface::Prepare
+    @sa DisplayInterface::Commit
   */
   virtual DisplayError Refresh() = 0;
 
  protected:
-  virtual ~DeviceEventHandler() { }
+  virtual ~DisplayEventHandler() { }
 };
 
 /*! @brief Display device interface.
@@ -157,10 +157,10 @@
   to configure or submit layers for composition on the display device. This interface is created
   during display device creation and remains valid until destroyed.
 
-  @sa CoreInterface::CreateDevice
-  @sa CoreInterface::DestroyDevice
+  @sa CoreInterface::CreateDisplay
+  @sa CoreInterface::DestroyDisplay
 */
-class DeviceInterface {
+class DisplayInterface {
  public:
   /*! @brief Method to determine hardware capability to compose layers associated with given frame.
 
@@ -212,9 +212,9 @@
 
     @return \link DisplayError \endlink
 
-    @sa SetDeviceState
+    @sa SetDisplayState
   */
-  virtual DisplayError GetDeviceState(DeviceState *state) = 0;
+  virtual DisplayError GetDisplayState(DisplayState *state) = 0;
 
   /*! @brief Method to get number of configurations(variable properties) supported on the display
     device.
@@ -227,20 +227,20 @@
 
   /*! @brief Method to get configuration for fixed properties of the display device.
 
-    @param[out] fixed_info \link DeviceConfigFixedInfo \endlink
+    @param[out] fixed_info \link DisplayConfigFixedInfo \endlink
 
     @return \link DisplayError \endlink
   */
-  virtual DisplayError GetConfig(DeviceConfigFixedInfo *fixed_info) = 0;
+  virtual DisplayError GetConfig(DisplayConfigFixedInfo *fixed_info) = 0;
 
   /*! @brief Method to get configuration for variable properties of the display device.
 
     @param[in] mode index of the mode
-    @param[out] variable_info \link DeviceConfigVariableInfo \endlink
+    @param[out] variable_info \link DisplayConfigVariableInfo \endlink
 
     @return \link DisplayError \endlink
   */
-  virtual DisplayError GetConfig(DeviceConfigVariableInfo *variable_info, uint32_t mode) = 0;
+  virtual DisplayError GetConfig(DisplayConfigVariableInfo *variable_info, uint32_t mode) = 0;
 
   /*! @brief Method to get VSync event state. Default event state is disabled.
 
@@ -256,9 +256,9 @@
 
     @return \link DisplayError \endlink
 
-    @sa SetDeviceState
+    @sa SetDisplayState
   */
-  virtual DisplayError SetDeviceState(DeviceState state) = 0;
+  virtual DisplayError SetDisplayState(DisplayState state) = 0;
 
   /*! @brief Method to set configuration for variable properties of the display device.
 
@@ -277,10 +277,10 @@
   virtual DisplayError SetVSyncState(bool enable) = 0;
 
  protected:
-  virtual ~DeviceInterface() { }
+  virtual ~DisplayInterface() { }
 };
 
 }  // namespace sde
 
-#endif  // __DEVICE_INTERFACE_H__
+#endif  // __DISPLAY_INTERFACE_H__
 
diff --git a/displayengine/include/core/dump_interface.h b/displayengine/include/core/dump_interface.h
index 3a7d93d..acdc71f 100644
--- a/displayengine/include/core/dump_interface.h
+++ b/displayengine/include/core/dump_interface.h
@@ -53,7 +53,7 @@
 
     @return \link DisplayError \endlink
 
-    @warning Client shall ensure that this interface is not used while a device is being either
+    @warning Client shall ensure that this interface is not used while a display is being either
     created or destroyed through display core.
   */
   static DisplayError GetDump(char *buffer, uint32_t length);
diff --git a/displayengine/include/private/strategy_interface.h b/displayengine/include/private/strategy_interface.h
index 23dea8e..8a3b789 100644
--- a/displayengine/include/private/strategy_interface.h
+++ b/displayengine/include/private/strategy_interface.h
@@ -69,7 +69,7 @@
 */
 const int kMaxSDELayers = 16;
 
-/*! @brief This structure defines constraints and device properties that shall be considered for
+/*! @brief This structure defines constraints and display properties that shall be considered for
     deciding a composition strategy.
 
     @sa GetNextStrategy
diff --git a/displayengine/libs/core/Android.mk b/displayengine/libs/core/Android.mk
index 496c899..337cb73 100644
--- a/displayengine/libs/core/Android.mk
+++ b/displayengine/libs/core/Android.mk
@@ -2,7 +2,7 @@
 include hardware/qcom/display/displayengine/libs/common.mk
 include $(CLEAR_VARS)
 
-LOCAL_MODULE                  := libsdecore
+LOCAL_MODULE                  := libsde
 LOCAL_MODULE_TAGS             := optional
 LOCAL_C_INCLUDES              := $(common_includes) $(kernel_includes)
 LOCAL_CFLAGS                  := $(common_flags) -DLOG_TAG=\"SDE\"
@@ -10,10 +10,10 @@
 LOCAL_ADDITIONAL_DEPENDENCIES := $(common_deps)
 LOCAL_SRC_FILES               := core_interface.cpp \
                                  core_impl.cpp \
-                                 device_base.cpp \
-                                 device_primary.cpp \
-                                 device_hdmi.cpp \
-                                 device_virtual.cpp \
+                                 display_base.cpp \
+                                 display_primary.cpp \
+                                 display_hdmi.cpp \
+                                 display_virtual.cpp \
                                  comp_manager.cpp \
                                  strategy_default.cpp \
                                  res_manager.cpp \
diff --git a/displayengine/libs/core/comp_manager.cpp b/displayengine/libs/core/comp_manager.cpp
index 42a28c2..0d51bb0 100644
--- a/displayengine/libs/core/comp_manager.cpp
+++ b/displayengine/libs/core/comp_manager.cpp
@@ -87,48 +87,50 @@
   return kErrorNone;
 }
 
-DisplayError CompManager::RegisterDevice(DeviceType type, const HWDeviceAttributes &attributes,
-                                         Handle *device) {
+DisplayError CompManager::RegisterDisplay(DisplayType type, const HWDisplayAttributes &attributes,
+                                          Handle *display_ctx) {
   SCOPE_LOCK(locker_);
 
   DisplayError error = kErrorNone;
 
-  CompManagerDevice *comp_mgr_device = new CompManagerDevice();
-  if (!comp_mgr_device) {
+  DisplayCompositionContext *display_comp_ctx = new DisplayCompositionContext();
+  if (!display_comp_ctx) {
     return kErrorMemory;
   }
 
-  error = res_mgr_.RegisterDevice(type, attributes, &comp_mgr_device->res_mgr_device);
+  error = res_mgr_.RegisterDisplay(type, attributes, &display_comp_ctx->display_resource_ctx);
   if (error != kErrorNone) {
-    delete comp_mgr_device;
+    delete display_comp_ctx;
     return error;
   }
   SET_BIT(registered_displays_, type);
-  comp_mgr_device->device_type = type;
-  *device = comp_mgr_device;
-  // New device has been added, so move the composition mode to safe mode until unless resources
-  // for the added display is configured properly.
+  display_comp_ctx->display_type = type;
+  *display_ctx = display_comp_ctx;
+  // New display device has been added, so move the composition mode to safe mode until unless
+  // resources for the added display is configured properly.
   safe_mode_ = true;
 
   return kErrorNone;
 }
 
-DisplayError CompManager::UnregisterDevice(Handle device) {
+DisplayError CompManager::UnregisterDisplay(Handle comp_handle) {
   SCOPE_LOCK(locker_);
 
-  CompManagerDevice *comp_mgr_device = reinterpret_cast<CompManagerDevice *>(device);
+  DisplayCompositionContext *display_comp_ctx =
+                             reinterpret_cast<DisplayCompositionContext *>(comp_handle);
 
-  res_mgr_.UnregisterDevice(comp_mgr_device->res_mgr_device);
-  CLEAR_BIT(registered_displays_, comp_mgr_device->device_type);
-  CLEAR_BIT(configured_displays_, comp_mgr_device->device_type);
-  delete comp_mgr_device;
+  res_mgr_.UnregisterDisplay(display_comp_ctx->display_resource_ctx);
+  CLEAR_BIT(registered_displays_, display_comp_ctx->display_type);
+  CLEAR_BIT(configured_displays_, display_comp_ctx->display_type);
+  delete display_comp_ctx;
 
   return kErrorNone;
 }
 
-void CompManager::PrepareStrategyConstraints(Handle device, HWLayers *hw_layers) {
-  CompManagerDevice *comp_mgr_device = reinterpret_cast<CompManagerDevice *>(device);
-  StrategyConstraints *constraints = &comp_mgr_device->constraints;
+void CompManager::PrepareStrategyConstraints(Handle comp_handle, HWLayers *hw_layers) {
+  DisplayCompositionContext *display_comp_ctx =
+                             reinterpret_cast<DisplayCompositionContext *>(comp_handle);
+  StrategyConstraints *constraints = &display_comp_ctx->constraints;
 
   constraints->safe_mode = safe_mode_;
   // If validation for the best available composition strategy with driver has failed, just
@@ -139,20 +141,21 @@
   }
 }
 
-DisplayError CompManager::Prepare(Handle device, HWLayers *hw_layers) {
+DisplayError CompManager::Prepare(Handle display_ctx, HWLayers *hw_layers) {
   SCOPE_LOCK(locker_);
 
-  CompManagerDevice *comp_mgr_device = reinterpret_cast<CompManagerDevice *>(device);
-  Handle &res_mgr_device = comp_mgr_device->res_mgr_device;
+  DisplayCompositionContext *display_comp_ctx =
+                             reinterpret_cast<DisplayCompositionContext *>(display_ctx);
+  Handle &display_resource_ctx = display_comp_ctx->display_resource_ctx;
 
   DisplayError error = kErrorNone;
 
-  PrepareStrategyConstraints(device, hw_layers);
+  PrepareStrategyConstraints(display_ctx, hw_layers);
 
   // Select a composition strategy, and try to allocate resources for it.
-  res_mgr_.Start(res_mgr_device);
+  res_mgr_.Start(display_resource_ctx);
   while (true) {
-    error = strategy_intf_->GetNextStrategy(&comp_mgr_device->constraints, &hw_layers->info);
+    error = strategy_intf_->GetNextStrategy(&display_comp_ctx->constraints, &hw_layers->info);
     if (UNLIKELY(error != kErrorNone)) {
       // Composition strategies exhausted. Resource Manager could not allocate resources even for
       // GPU composition. This will never happen.
@@ -160,7 +163,7 @@
       return error;
     }
 
-    error = res_mgr_.Acquire(res_mgr_device, hw_layers);
+    error = res_mgr_.Acquire(display_resource_ctx, hw_layers);
     if (error != kErrorNone) {
       // Not enough resources, try next strategy.
       continue;
@@ -169,33 +172,35 @@
       break;
     }
   }
-  res_mgr_.Stop(res_mgr_device);
+  res_mgr_.Stop(display_resource_ctx);
 
   return kErrorNone;
 }
 
-void CompManager::PostPrepare(Handle device, HWLayers *hw_layers) {
+void CompManager::PostPrepare(Handle display_ctx, HWLayers *hw_layers) {
   SCOPE_LOCK(locker_);
 }
 
-void CompManager::PostCommit(Handle device, HWLayers *hw_layers) {
+void CompManager::PostCommit(Handle display_ctx, HWLayers *hw_layers) {
   SCOPE_LOCK(locker_);
 
-  CompManagerDevice *comp_mgr_device = reinterpret_cast<CompManagerDevice *>(device);
-  SET_BIT(configured_displays_, comp_mgr_device->device_type);
+  DisplayCompositionContext *display_comp_ctx =
+                             reinterpret_cast<DisplayCompositionContext *>(display_ctx);
+  SET_BIT(configured_displays_, display_comp_ctx->display_type);
   if (configured_displays_ == registered_displays_) {
       safe_mode_ = false;
   }
 
-  res_mgr_.PostCommit(comp_mgr_device->res_mgr_device, hw_layers);
+  res_mgr_.PostCommit(display_comp_ctx->display_resource_ctx, hw_layers);
 }
 
-void CompManager::Purge(Handle device) {
+void CompManager::Purge(Handle display_ctx) {
   SCOPE_LOCK(locker_);
 
-  CompManagerDevice *comp_mgr_device = reinterpret_cast<CompManagerDevice *>(device);
+  DisplayCompositionContext *display_comp_ctx =
+                             reinterpret_cast<DisplayCompositionContext *>(display_ctx);
 
-  res_mgr_.Purge(comp_mgr_device->res_mgr_device);
+  res_mgr_.Purge(display_comp_ctx->display_resource_ctx);
 }
 
 void CompManager::AppendDump(char *buffer, uint32_t length) {
diff --git a/displayengine/libs/core/comp_manager.h b/displayengine/libs/core/comp_manager.h
index f9c9202..492500a 100644
--- a/displayengine/libs/core/comp_manager.h
+++ b/displayengine/libs/core/comp_manager.h
@@ -25,7 +25,7 @@
 #ifndef __COMP_MANAGER_H__
 #define __COMP_MANAGER_H__
 
-#include <core/device_interface.h>
+#include <core/display_interface.h>
 
 #include "hw_interface.h"
 #include "strategy_default.h"
@@ -39,23 +39,23 @@
   CompManager();
   DisplayError Init(const HWResourceInfo &hw_res_info_);
   DisplayError Deinit();
-  DisplayError RegisterDevice(DeviceType type, const HWDeviceAttributes &attributes,
-                              Handle *device);
-  DisplayError UnregisterDevice(Handle device);
-  DisplayError Prepare(Handle device, HWLayers *hw_layers);
-  void PostPrepare(Handle device, HWLayers *hw_layers);
-  void PostCommit(Handle device, HWLayers *hw_layers);
-  void Purge(Handle device);
+  DisplayError RegisterDisplay(DisplayType type, const HWDisplayAttributes &attributes,
+                               Handle *res_mgr_hnd);
+  DisplayError UnregisterDisplay(Handle res_mgr_hnd);
+  DisplayError Prepare(Handle display_ctx, HWLayers *hw_layers);
+  void PostPrepare(Handle display_ctx, HWLayers *hw_layers);
+  void PostCommit(Handle display_ctx, HWLayers *hw_layers);
+  void Purge(Handle display_ctx);
 
   // DumpImpl method
   virtual void AppendDump(char *buffer, uint32_t length);
 
  private:
-  void PrepareStrategyConstraints(Handle device, HWLayers *hw_layers);
-  struct CompManagerDevice {
+  void PrepareStrategyConstraints(Handle display_ctx, HWLayers *hw_layers);
+  struct DisplayCompositionContext {
     StrategyConstraints constraints;
-    Handle res_mgr_device;
-    DeviceType device_type;
+    Handle display_resource_ctx;
+    DisplayType display_type;
   };
 
   Locker locker_;
diff --git a/displayengine/libs/core/core_impl.cpp b/displayengine/libs/core/core_impl.cpp
index 9a1fa12..a3dfde1 100644
--- a/displayengine/libs/core/core_impl.cpp
+++ b/displayengine/libs/core/core_impl.cpp
@@ -31,9 +31,9 @@
 #include <utils/constants.h>
 
 #include "core_impl.h"
-#include "device_primary.h"
-#include "device_hdmi.h"
-#include "device_virtual.h"
+#include "display_primary.h"
+#include "display_hdmi.h"
+#include "display_virtual.h"
 
 namespace sde {
 
@@ -84,57 +84,57 @@
   return kErrorNone;
 }
 
-DisplayError CoreImpl::CreateDevice(DeviceType type, DeviceEventHandler *event_handler,
-                                    DeviceInterface **intf) {
+DisplayError CoreImpl::CreateDisplay(DisplayType type, DisplayEventHandler *event_handler,
+                                    DisplayInterface **intf) {
   SCOPE_LOCK(locker_);
 
   if (UNLIKELY(!event_handler || !intf)) {
     return kErrorParameters;
   }
 
-  DeviceBase *device_base = NULL;
+  DisplayBase *display_base = NULL;
   switch (type) {
   case kPrimary:
-    device_base = new DevicePrimary(event_handler, hw_intf_, &comp_mgr_);
+    display_base = new DisplayPrimary(event_handler, hw_intf_, &comp_mgr_);
     break;
 
-  case kHWHDMI:
-    device_base = new DeviceHDMI(event_handler, hw_intf_, &comp_mgr_);
+  case kHDMI:
+    display_base = new DisplayHDMI(event_handler, hw_intf_, &comp_mgr_);
     break;
 
   case kVirtual:
-    device_base = new DeviceVirtual(event_handler, hw_intf_, &comp_mgr_);
+    display_base = new DisplayVirtual(event_handler, hw_intf_, &comp_mgr_);
     break;
 
   default:
-    DLOGE("Spurious device type %d", type);
+    DLOGE("Spurious display type %d", type);
     return kErrorParameters;
   }
 
-  if (UNLIKELY(!device_base)) {
+  if (UNLIKELY(!display_base)) {
     return kErrorMemory;
   }
 
-  DisplayError error = device_base->Init();
+  DisplayError error = display_base->Init();
   if (UNLIKELY(error != kErrorNone)) {
-    delete device_base;
+    delete display_base;
     return error;
   }
 
-  *intf = device_base;
+  *intf = display_base;
   return kErrorNone;
 }
 
-DisplayError CoreImpl::DestroyDevice(DeviceInterface *intf) {
+DisplayError CoreImpl::DestroyDisplay(DisplayInterface *intf) {
   SCOPE_LOCK(locker_);
 
   if (UNLIKELY(!intf)) {
     return kErrorParameters;
   }
 
-  DeviceBase *device_base = static_cast<DeviceBase *>(intf);
-  device_base->Deinit();
-  delete device_base;
+  DisplayBase *display_base = static_cast<DisplayBase *>(intf);
+  display_base->Deinit();
+  delete display_base;
 
   return kErrorNone;
 }
diff --git a/displayengine/libs/core/core_impl.h b/displayengine/libs/core/core_impl.h
index 16a01f2..ad86c60 100644
--- a/displayengine/libs/core/core_impl.h
+++ b/displayengine/libs/core/core_impl.h
@@ -52,9 +52,9 @@
   virtual DisplayError Deinit();
 
   // Methods from core interface
-  virtual DisplayError CreateDevice(DeviceType type, DeviceEventHandler *event_handler,
-                                    DeviceInterface **intf);
-  virtual DisplayError DestroyDevice(DeviceInterface *intf);
+  virtual DisplayError CreateDisplay(DisplayType type, DisplayEventHandler *event_handler,
+                                     DisplayInterface **intf);
+  virtual DisplayError DestroyDisplay(DisplayInterface *intf);
 
  protected:
   Locker locker_;
diff --git a/displayengine/libs/core/device_primary.cpp b/displayengine/libs/core/device_primary.cpp
deleted file mode 100644
index c5d45b8..0000000
--- a/displayengine/libs/core/device_primary.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
-* Copyright (c) 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.
-*/
-
-// SDE_LOG_TAG definition must precede debug.h include.
-#define SDE_LOG_TAG kTagCore
-#define SDE_MODULE_NAME "DevicePrimary"
-#include <utils/debug.h>
-
-#include <utils/constants.h>
-
-#include "device_primary.h"
-
-namespace sde {
-
-DevicePrimary::DevicePrimary(DeviceEventHandler *event_handler, HWInterface *hw_intf,
-                             CompManager *comp_manager)
-  : DeviceBase(kPrimary, event_handler, kHWPrimary, hw_intf, comp_manager) {
-}
-
-}  // namespace sde
-
diff --git a/displayengine/libs/core/device_primary.h b/displayengine/libs/core/device_primary.h
deleted file mode 100644
index 771a6f7..0000000
--- a/displayengine/libs/core/device_primary.h
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
-* Copyright (c) 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 __DEVICE_PRIMARY_H__
-#define __DEVICE_PRIMARY_H__
-
-#include "device_base.h"
-
-namespace sde {
-
-class DevicePrimary : public DeviceBase {
- public:
-  DevicePrimary(DeviceEventHandler *event_handler, HWInterface *hw_intf, CompManager *comp_manager);
-};
-
-}  // namespace sde
-
-#endif  // __DEVICE_PRIMARY_H__
-
diff --git a/displayengine/libs/core/device_virtual.h b/displayengine/libs/core/device_virtual.h
deleted file mode 100644
index e279f12..0000000
--- a/displayengine/libs/core/device_virtual.h
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
-* Copyright (c) 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 __DEVICE_VIRTUAL_H__
-#define __DEVICE_VIRTUAL_H__
-
-#include "device_base.h"
-
-namespace sde {
-
-class DeviceVirtual : public DeviceBase {
- public:
-  DeviceVirtual(DeviceEventHandler *event_handler, HWInterface *hw_intf, CompManager *comp_manager);
-};
-
-}  // namespace sde
-
-#endif  // __DEVICE_VIRTUAL_H__
-
diff --git a/displayengine/libs/core/device_base.cpp b/displayengine/libs/core/display_base.cpp
similarity index 75%
rename from displayengine/libs/core/device_base.cpp
rename to displayengine/libs/core/display_base.cpp
index 6dc3ebd..5b2d0af 100644
--- a/displayengine/libs/core/device_base.cpp
+++ b/displayengine/libs/core/display_base.cpp
@@ -24,24 +24,24 @@
 
 // SDE_LOG_TAG definition must precede debug.h include.
 #define SDE_LOG_TAG kTagCore
-#define SDE_MODULE_NAME "DeviceBase"
+#define SDE_MODULE_NAME "DisplayBase"
 #include <utils/debug.h>
 
 #include <utils/constants.h>
 
-#include "device_base.h"
+#include "display_base.h"
 
 namespace sde {
 
-DeviceBase::DeviceBase(DeviceType device_type, DeviceEventHandler *event_handler,
-             HWBlockType hw_block_type, HWInterface *hw_intf, CompManager *comp_manager)
-  : device_type_(device_type), event_handler_(event_handler), hw_block_type_(hw_block_type),
+DisplayBase::DisplayBase(DisplayType display_type, DisplayEventHandler *event_handler,
+                       HWBlockType hw_block_type, HWInterface *hw_intf, CompManager *comp_manager)
+  : display_type_(display_type), event_handler_(event_handler), hw_block_type_(hw_block_type),
     hw_intf_(hw_intf), comp_manager_(comp_manager), state_(kStateOff), hw_device_(0),
-    comp_mgr_device_(0), device_attributes_(NULL), num_modes_(0), active_mode_index_(0),
+    display_comp_ctx_(0), display_attributes_(NULL), num_modes_(0), active_mode_index_(0),
     pending_commit_(false), vsync_enable_(false) {
 }
 
-DisplayError DeviceBase::Init() {
+DisplayError DisplayBase::Init() {
   SCOPE_LOCK(locker_);
 
   DisplayError error = kErrorNone;
@@ -51,19 +51,19 @@
     return error;
   }
 
-  error = hw_intf_->GetNumDeviceAttributes(hw_device_, &num_modes_);
+  error = hw_intf_->GetNumDisplayAttributes(hw_device_, &num_modes_);
   if (UNLIKELY(error != kErrorNone)) {
     goto CleanupOnError;
   }
 
-  device_attributes_ = new HWDeviceAttributes[num_modes_];
-  if (!device_attributes_) {
+  display_attributes_ = new HWDisplayAttributes[num_modes_];
+  if (!display_attributes_) {
     error = kErrorMemory;
     goto CleanupOnError;
   }
 
   for (uint32_t i = 0; i < num_modes_; i++) {
-    error = hw_intf_->GetDeviceAttributes(hw_device_, &device_attributes_[i], i);
+    error = hw_intf_->GetDisplayAttributes(hw_device_, &display_attributes_[i], i);
     if (UNLIKELY(error != kErrorNone)) {
       goto CleanupOnError;
     }
@@ -71,8 +71,8 @@
 
   active_mode_index_ = 0;
 
-  error = comp_manager_->RegisterDevice(device_type_, device_attributes_[active_mode_index_],
-                                        &comp_mgr_device_);
+  error = comp_manager_->RegisterDisplay(display_type_, display_attributes_[active_mode_index_],
+                                        &display_comp_ctx_);
   if (UNLIKELY(error != kErrorNone)) {
     goto CleanupOnError;
   }
@@ -80,10 +80,10 @@
   return kErrorNone;
 
 CleanupOnError:
-  comp_manager_->UnregisterDevice(comp_mgr_device_);
+  comp_manager_->UnregisterDisplay(display_comp_ctx_);
 
-  if (device_attributes_) {
-    delete[] device_attributes_;
+  if (display_attributes_) {
+    delete[] display_attributes_;
   }
 
   hw_intf_->Close(hw_device_);
@@ -91,17 +91,17 @@
   return error;
 }
 
-DisplayError DeviceBase::Deinit() {
+DisplayError DisplayBase::Deinit() {
   SCOPE_LOCK(locker_);
 
-  comp_manager_->UnregisterDevice(comp_mgr_device_);
-  delete[] device_attributes_;
+  comp_manager_->UnregisterDisplay(display_comp_ctx_);
+  delete[] display_attributes_;
   hw_intf_->Close(hw_device_);
 
   return kErrorNone;
 }
 
-DisplayError DeviceBase::Prepare(LayerStack *layer_stack) {
+DisplayError DisplayBase::Prepare(LayerStack *layer_stack) {
   SCOPE_LOCK(locker_);
 
   DisplayError error = kErrorNone;
@@ -118,7 +118,7 @@
     hw_layers_.info.stack = layer_stack;
 
     while (true) {
-      error = comp_manager_->Prepare(comp_mgr_device_, &hw_layers_);
+      error = comp_manager_->Prepare(display_comp_ctx_, &hw_layers_);
       if (UNLIKELY(error != kErrorNone)) {
         break;
       }
@@ -126,7 +126,7 @@
       error = hw_intf_->Validate(hw_device_, &hw_layers_);
       if (LIKELY(error == kErrorNone)) {
         // Strategy is successful now, wait for Commit().
-        comp_manager_->PostPrepare(comp_mgr_device_, &hw_layers_);
+        comp_manager_->PostPrepare(display_comp_ctx_, &hw_layers_);
         pending_commit_ = true;
         break;
       }
@@ -136,7 +136,7 @@
   return error;
 }
 
-DisplayError DeviceBase::Commit(LayerStack *layer_stack) {
+DisplayError DisplayBase::Commit(LayerStack *layer_stack) {
   SCOPE_LOCK(locker_);
 
   DisplayError error = kErrorNone;
@@ -153,7 +153,7 @@
   if (LIKELY(state_ == kStateOn)) {
     error = hw_intf_->Commit(hw_device_, &hw_layers_);
     if (LIKELY(error == kErrorNone)) {
-      comp_manager_->PostCommit(comp_mgr_device_, &hw_layers_);
+      comp_manager_->PostCommit(display_comp_ctx_, &hw_layers_);
     } else {
       DLOGE("Unexpected error. Commit failed on driver.");
     }
@@ -164,7 +164,7 @@
   return kErrorNone;
 }
 
-DisplayError DeviceBase::GetDeviceState(DeviceState *state) {
+DisplayError DisplayBase::GetDisplayState(DisplayState *state) {
   SCOPE_LOCK(locker_);
 
   if (UNLIKELY(!state)) {
@@ -175,7 +175,7 @@
   return kErrorNone;
 }
 
-DisplayError DeviceBase::GetNumVariableInfoConfigs(uint32_t *count) {
+DisplayError DisplayBase::GetNumVariableInfoConfigs(uint32_t *count) {
   SCOPE_LOCK(locker_);
 
   if (UNLIKELY(!count)) {
@@ -187,7 +187,7 @@
   return kErrorNone;
 }
 
-DisplayError DeviceBase::GetConfig(DeviceConfigFixedInfo *fixed_info) {
+DisplayError DisplayBase::GetConfig(DisplayConfigFixedInfo *fixed_info) {
   SCOPE_LOCK(locker_);
 
   if (UNLIKELY(!fixed_info)) {
@@ -197,19 +197,19 @@
   return kErrorNone;
 }
 
-DisplayError DeviceBase::GetConfig(DeviceConfigVariableInfo *variable_info, uint32_t mode) {
+DisplayError DisplayBase::GetConfig(DisplayConfigVariableInfo *variable_info, uint32_t mode) {
   SCOPE_LOCK(locker_);
 
   if (UNLIKELY(!variable_info || mode >= num_modes_)) {
     return kErrorParameters;
   }
 
-  *variable_info = device_attributes_[mode];
+  *variable_info = display_attributes_[mode];
 
   return kErrorNone;
 }
 
-DisplayError DeviceBase::GetVSyncState(bool *enabled) {
+DisplayError DisplayBase::GetVSyncState(bool *enabled) {
   SCOPE_LOCK(locker_);
 
   if (UNLIKELY(!enabled)) {
@@ -219,7 +219,7 @@
   return kErrorNone;
 }
 
-DisplayError DeviceBase::SetDeviceState(DeviceState state) {
+DisplayError DisplayBase::SetDisplayState(DisplayState state) {
   SCOPE_LOCK(locker_);
 
   DisplayError error = kErrorNone;
@@ -233,7 +233,7 @@
 
   switch (state) {
   case kStateOff:
-    comp_manager_->Purge(comp_mgr_device_);
+    comp_manager_->Purge(display_comp_ctx_);
     error = hw_intf_->PowerOff(hw_device_);
     break;
 
@@ -261,13 +261,13 @@
   return error;
 }
 
-DisplayError DeviceBase::SetConfig(uint32_t mode) {
+DisplayError DisplayBase::SetConfig(uint32_t mode) {
   SCOPE_LOCK(locker_);
 
   return kErrorNone;
 }
 
-DisplayError DeviceBase::SetVSyncState(bool enable) {
+DisplayError DisplayBase::SetVSyncState(bool enable) {
   SCOPE_LOCK(locker_);
   DisplayError error = kErrorNone;
   if (vsync_enable_ != enable) {
@@ -280,9 +280,9 @@
   return error;
 }
 
-DisplayError DeviceBase::VSync(int64_t timestamp) {
+DisplayError DisplayBase::VSync(int64_t timestamp) {
   if (vsync_enable_) {
-    DeviceEventVSync vsync;
+    DisplayEventVSync vsync;
     vsync.timestamp = timestamp;
     event_handler_->VSync(vsync);
   }
@@ -290,20 +290,20 @@
   return kErrorNone;
 }
 
-DisplayError DeviceBase::Blank(bool blank) {
+DisplayError DisplayBase::Blank(bool blank) {
   return kErrorNone;
 }
 
-void DeviceBase::AppendDump(char *buffer, uint32_t length) {
+void DisplayBase::AppendDump(char *buffer, uint32_t length) {
   SCOPE_LOCK(locker_);
 
   AppendString(buffer, length, "\n-----------------------");
-  AppendString(buffer, length, "\ndevice type: %u", device_type_);
+  AppendString(buffer, length, "\ndevice type: %u", display_type_);
   AppendString(buffer, length, "\nstate: %u, vsync on: %u", state_, INT(vsync_enable_));
   AppendString(buffer, length, "\nnum configs: %u, active config index: %u",
                                 num_modes_, active_mode_index_);
 
-  DeviceConfigVariableInfo &info = device_attributes_[active_mode_index_];
+  DisplayConfigVariableInfo &info = display_attributes_[active_mode_index_];
   AppendString(buffer, length, "\nres:%ux%u, dpi:%.2fx%.2f, fps:%.2f, vsync period: %u",
       info.x_pixels, info.y_pixels, info.x_dpi, info.y_dpi, info.fps, info.vsync_period_ns);
 
@@ -344,7 +344,8 @@
   }
 }
 
-void DeviceBase::AppendRect(char *buffer, uint32_t length, const char *rect_name, LayerRect *rect) {
+void DisplayBase::AppendRect(char *buffer, uint32_t length, const char *rect_name,
+                             LayerRect *rect) {
   AppendString(buffer, length, "%s %.1f, %.1f, %.1f, %.1f",
                                 rect_name, rect->left, rect->top, rect->right, rect->bottom);
 }
diff --git a/displayengine/libs/core/device_base.h b/displayengine/libs/core/display_base.h
similarity index 78%
rename from displayengine/libs/core/device_base.h
rename to displayengine/libs/core/display_base.h
index a2ef93b..5eaac37 100644
--- a/displayengine/libs/core/device_base.h
+++ b/displayengine/libs/core/display_base.h
@@ -22,10 +22,10 @@
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
-#ifndef __DEVICE_BASE_H__
-#define __DEVICE_BASE_H__
+#ifndef __DISPLAY_BASE_H__
+#define __DISPLAY_BASE_H__
 
-#include <core/device_interface.h>
+#include <core/display_interface.h>
 #include <private/strategy_interface.h>
 #include <utils/locker.h>
 
@@ -34,21 +34,21 @@
 
 namespace sde {
 
-class DeviceBase : public DeviceInterface, HWEventHandler, DumpImpl {
+class DisplayBase : public DisplayInterface, HWEventHandler, DumpImpl {
  public:
-  DeviceBase(DeviceType device_type, DeviceEventHandler *event_handler,
+  DisplayBase(DisplayType display_type, DisplayEventHandler *event_handler,
              HWBlockType hw_block_type, HWInterface *hw_intf, CompManager *comp_manager);
-  virtual ~DeviceBase() { }
+  virtual ~DisplayBase() { }
   virtual DisplayError Init();
   virtual DisplayError Deinit();
   virtual DisplayError Prepare(LayerStack *layer_stack);
   virtual DisplayError Commit(LayerStack *layer_stack);
-  virtual DisplayError GetDeviceState(DeviceState *state);
+  virtual DisplayError GetDisplayState(DisplayState *state);
   virtual DisplayError GetNumVariableInfoConfigs(uint32_t *count);
-  virtual DisplayError GetConfig(DeviceConfigFixedInfo *fixed_info);
-  virtual DisplayError GetConfig(DeviceConfigVariableInfo *variable_info, uint32_t mode);
+  virtual DisplayError GetConfig(DisplayConfigFixedInfo *fixed_info);
+  virtual DisplayError GetConfig(DisplayConfigVariableInfo *variable_info, uint32_t mode);
   virtual DisplayError GetVSyncState(bool *enabled);
-  virtual DisplayError SetDeviceState(DeviceState state);
+  virtual DisplayError SetDisplayState(DisplayState state);
   virtual DisplayError SetConfig(uint32_t mode);
   virtual DisplayError SetVSyncState(bool enable);
 
@@ -62,15 +62,15 @@
 
  protected:
   Locker locker_;
-  DeviceType device_type_;
-  DeviceEventHandler *event_handler_;
+  DisplayType display_type_;
+  DisplayEventHandler *event_handler_;
   HWBlockType hw_block_type_;
   HWInterface *hw_intf_;
   CompManager *comp_manager_;
-  DeviceState state_;
+  DisplayState state_;
   Handle hw_device_;
-  Handle comp_mgr_device_;
-  HWDeviceAttributes *device_attributes_;
+  Handle display_comp_ctx_;
+  HWDisplayAttributes *display_attributes_;
   uint32_t num_modes_;
   uint32_t active_mode_index_;
   HWLayers hw_layers_;
@@ -80,5 +80,5 @@
 
 }  // namespace sde
 
-#endif  // __DEVICE_BASE_H__
+#endif  // __DISPLAY_BASE_H__
 
diff --git a/displayengine/libs/core/device_hdmi.cpp b/displayengine/libs/core/display_hdmi.cpp
similarity index 86%
rename from displayengine/libs/core/device_hdmi.cpp
rename to displayengine/libs/core/display_hdmi.cpp
index a7c8c4f..b44bc87 100644
--- a/displayengine/libs/core/device_hdmi.cpp
+++ b/displayengine/libs/core/display_hdmi.cpp
@@ -24,18 +24,18 @@
 
 // SDE_LOG_TAG definition must precede debug.h include.
 #define SDE_LOG_TAG kTagCore
-#define SDE_MODULE_NAME "DeviceHDMI"
+#define SDE_MODULE_NAME "DisplayHDMI"
 #include <utils/debug.h>
 
 #include <utils/constants.h>
 
-#include "device_hdmi.h"
+#include "display_hdmi.h"
 
 namespace sde {
 
-DeviceHDMI::DeviceHDMI(DeviceEventHandler *event_handler, HWInterface *hw_intf,
-                       CompManager *comp_manager)
-  : DeviceBase(kHDMI, event_handler, kHWHDMI, hw_intf, comp_manager) {
+DisplayHDMI::DisplayHDMI(DisplayEventHandler *event_handler, HWInterface *hw_intf,
+                         CompManager *comp_manager)
+  : DisplayBase(kHDMI, event_handler, kHWHDMI, hw_intf, comp_manager) {
 }
 
 }  // namespace sde
diff --git a/displayengine/libs/core/device_hdmi.h b/displayengine/libs/core/display_hdmi.h
similarity index 86%
rename from displayengine/libs/core/device_hdmi.h
rename to displayengine/libs/core/display_hdmi.h
index 7d8cbc6..85f53fc 100644
--- a/displayengine/libs/core/device_hdmi.h
+++ b/displayengine/libs/core/display_hdmi.h
@@ -22,19 +22,19 @@
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
-#ifndef __DEVICE_HDMI_H__
-#define __DEVICE_HDMI_H__
+#ifndef __DISPLAY_HDMI_H__
+#define __DISPLAY_HDMI_H__
 
-#include "device_base.h"
+#include "display_base.h"
 
 namespace sde {
 
-class DeviceHDMI : public DeviceBase {
+class DisplayHDMI : public DisplayBase {
  public:
-  DeviceHDMI(DeviceEventHandler *event_handler, HWInterface *hw_intf, CompManager *comp_manager);
+  DisplayHDMI(DisplayEventHandler *event_handler, HWInterface *hw_intf, CompManager *comp_manager);
 };
 
 }  // namespace sde
 
-#endif  // __DEVICE_HDMI_H__
+#endif  // __DISPLAY_HDMI_H__
 
diff --git a/displayengine/libs/core/device_virtual.cpp b/displayengine/libs/core/display_primary.cpp
similarity index 85%
rename from displayengine/libs/core/device_virtual.cpp
rename to displayengine/libs/core/display_primary.cpp
index 4e18f93..96ff08a 100644
--- a/displayengine/libs/core/device_virtual.cpp
+++ b/displayengine/libs/core/display_primary.cpp
@@ -24,18 +24,18 @@
 
 // SDE_LOG_TAG definition must precede debug.h include.
 #define SDE_LOG_TAG kTagCore
-#define SDE_MODULE_NAME "DeviceVirtual"
+#define SDE_MODULE_NAME "DisplayPrimary"
 #include <utils/debug.h>
 
 #include <utils/constants.h>
 
-#include "device_virtual.h"
+#include "display_primary.h"
 
 namespace sde {
 
-DeviceVirtual::DeviceVirtual(DeviceEventHandler *event_handler, HWInterface *hw_intf,
-                             CompManager *comp_manager)
-  : DeviceBase(kVirtual, event_handler, kHWBlockMax, hw_intf, comp_manager) {
+DisplayPrimary::DisplayPrimary(DisplayEventHandler *event_handler, HWInterface *hw_intf,
+                               CompManager *comp_manager)
+  : DisplayBase(kPrimary, event_handler, kHWPrimary, hw_intf, comp_manager) {
 }
 
 }  // namespace sde
diff --git a/displayengine/libs/core/device_hdmi.h b/displayengine/libs/core/display_primary.h
similarity index 84%
copy from displayengine/libs/core/device_hdmi.h
copy to displayengine/libs/core/display_primary.h
index 7d8cbc6..183e964 100644
--- a/displayengine/libs/core/device_hdmi.h
+++ b/displayengine/libs/core/display_primary.h
@@ -22,19 +22,20 @@
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
-#ifndef __DEVICE_HDMI_H__
-#define __DEVICE_HDMI_H__
+#ifndef __DISPLAY_PRIMARY_H__
+#define __DISPLAY_PRIMARY_H__
 
-#include "device_base.h"
+#include "display_base.h"
 
 namespace sde {
 
-class DeviceHDMI : public DeviceBase {
+class DisplayPrimary : public DisplayBase {
  public:
-  DeviceHDMI(DeviceEventHandler *event_handler, HWInterface *hw_intf, CompManager *comp_manager);
+  DisplayPrimary(DisplayEventHandler *event_handler, HWInterface *hw_intf,
+                 CompManager *comp_manager);
 };
 
 }  // namespace sde
 
-#endif  // __DEVICE_HDMI_H__
+#endif  // __DISPLAY_PRIMARY_H__
 
diff --git a/displayengine/libs/core/device_virtual.cpp b/displayengine/libs/core/display_virtual.cpp
similarity index 85%
copy from displayengine/libs/core/device_virtual.cpp
copy to displayengine/libs/core/display_virtual.cpp
index 4e18f93..dc18146 100644
--- a/displayengine/libs/core/device_virtual.cpp
+++ b/displayengine/libs/core/display_virtual.cpp
@@ -24,18 +24,18 @@
 
 // SDE_LOG_TAG definition must precede debug.h include.
 #define SDE_LOG_TAG kTagCore
-#define SDE_MODULE_NAME "DeviceVirtual"
+#define SDE_MODULE_NAME "DisplayVirtual"
 #include <utils/debug.h>
 
 #include <utils/constants.h>
 
-#include "device_virtual.h"
+#include "display_virtual.h"
 
 namespace sde {
 
-DeviceVirtual::DeviceVirtual(DeviceEventHandler *event_handler, HWInterface *hw_intf,
-                             CompManager *comp_manager)
-  : DeviceBase(kVirtual, event_handler, kHWBlockMax, hw_intf, comp_manager) {
+DisplayVirtual::DisplayVirtual(DisplayEventHandler *event_handler, HWInterface *hw_intf,
+                               CompManager *comp_manager)
+  : DisplayBase(kVirtual, event_handler, kHWBlockMax, hw_intf, comp_manager) {
 }
 
 }  // namespace sde
diff --git a/displayengine/libs/core/device_hdmi.h b/displayengine/libs/core/display_virtual.h
similarity index 84%
copy from displayengine/libs/core/device_hdmi.h
copy to displayengine/libs/core/display_virtual.h
index 7d8cbc6..a8e29e7 100644
--- a/displayengine/libs/core/device_hdmi.h
+++ b/displayengine/libs/core/display_virtual.h
@@ -22,19 +22,20 @@
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
-#ifndef __DEVICE_HDMI_H__
-#define __DEVICE_HDMI_H__
+#ifndef __DISPLAY_VIRTUAL_H__
+#define __DISPLAY_VIRTUAL_H__
 
-#include "device_base.h"
+#include "display_base.h"
 
 namespace sde {
 
-class DeviceHDMI : public DeviceBase {
+class DisplayVirtual : public DisplayBase {
  public:
-  DeviceHDMI(DeviceEventHandler *event_handler, HWInterface *hw_intf, CompManager *comp_manager);
+  DisplayVirtual(DisplayEventHandler *event_handler, HWInterface *hw_intf,
+                 CompManager *comp_manager);
 };
 
 }  // namespace sde
 
-#endif  // __DEVICE_HDMI_H__
+#endif  // __DISPLAY_VIRTUAL_H__
 
diff --git a/displayengine/libs/core/hw_framebuffer.cpp b/displayengine/libs/core/hw_framebuffer.cpp
index 8dc3330..63adf8c 100644
--- a/displayengine/libs/core/hw_framebuffer.cpp
+++ b/displayengine/libs/core/hw_framebuffer.cpp
@@ -227,7 +227,7 @@
   return kErrorNone;
 }
 
-DisplayError HWFrameBuffer::GetNumDeviceAttributes(Handle device, uint32_t *count) {
+DisplayError HWFrameBuffer::GetNumDisplayAttributes(Handle device, uint32_t *count) {
   HWContext *hw_context = reinterpret_cast<HWContext *>(device);
 
   // TODO(user): Query modes
@@ -236,9 +236,9 @@
   return kErrorNone;
 }
 
-DisplayError HWFrameBuffer::GetDeviceAttributes(Handle device,
-                                                HWDeviceAttributes *device_attributes,
-                                                uint32_t mode) {
+DisplayError HWFrameBuffer::GetDisplayAttributes(Handle device,
+                                                 HWDisplayAttributes *display_attributes,
+                                                 uint32_t mode) {
   HWContext *hw_context = reinterpret_cast<HWContext *>(device);
   int &device_fd = hw_context->device_fd;
 
@@ -265,15 +265,16 @@
     var_screeninfo.height = INT((FLOAT(var_screeninfo.yres) * 25.4f)/160.0f + 0.5f);
   }
 
-  device_attributes->x_pixels = var_screeninfo.xres;
-  device_attributes->y_pixels = var_screeninfo.yres;
-  device_attributes->x_dpi = (FLOAT(var_screeninfo.xres) * 25.4f) / FLOAT(var_screeninfo.width);
-  device_attributes->y_dpi = (FLOAT(var_screeninfo.yres) * 25.4f) / FLOAT(var_screeninfo.height);
-  device_attributes->vsync_period_ns = UINT32(1000000000L / FLOAT(meta_data.data.panel_frame_rate));
+  display_attributes->x_pixels = var_screeninfo.xres;
+  display_attributes->y_pixels = var_screeninfo.yres;
+  display_attributes->x_dpi = (FLOAT(var_screeninfo.xres) * 25.4f) / FLOAT(var_screeninfo.width);
+  display_attributes->y_dpi = (FLOAT(var_screeninfo.yres) * 25.4f) / FLOAT(var_screeninfo.height);
+  display_attributes->vsync_period_ns =
+                 UINT32(1000000000L / FLOAT(meta_data.data.panel_frame_rate));
 
   // TODO(user): set panel information from sysfs
-  device_attributes->is_device_split = true;
-  device_attributes->split_left = device_attributes->x_pixels / 2;
+  display_attributes->is_device_split = true;
+  display_attributes->split_left = display_attributes->x_pixels / 2;
 
   return kErrorNone;
 }
diff --git a/displayengine/libs/core/hw_framebuffer.h b/displayengine/libs/core/hw_framebuffer.h
index 6b844af..d74d03e 100644
--- a/displayengine/libs/core/hw_framebuffer.h
+++ b/displayengine/libs/core/hw_framebuffer.h
@@ -43,9 +43,9 @@
   virtual DisplayError GetHWCapabilities(HWResourceInfo *hw_res_info);
   virtual DisplayError Open(HWBlockType type, Handle *device, HWEventHandler *eventhandler);
   virtual DisplayError Close(Handle device);
-  virtual DisplayError GetNumDeviceAttributes(Handle device, uint32_t *count);
-  virtual DisplayError GetDeviceAttributes(Handle device, HWDeviceAttributes *device_attributes,
-                                           uint32_t mode);
+  virtual DisplayError GetNumDisplayAttributes(Handle device, uint32_t *count);
+  virtual DisplayError GetDisplayAttributes(Handle device, HWDisplayAttributes *display_attributes,
+                                            uint32_t mode);
   virtual DisplayError PowerOn(Handle device);
   virtual DisplayError PowerOff(Handle device);
   virtual DisplayError Doze(Handle device);
diff --git a/displayengine/libs/core/hw_interface.h b/displayengine/libs/core/hw_interface.h
index bb2a8a9..a9bdb96 100644
--- a/displayengine/libs/core/hw_interface.h
+++ b/displayengine/libs/core/hw_interface.h
@@ -25,7 +25,7 @@
 #ifndef __HW_INTERFACE_H__
 #define __HW_INTERFACE_H__
 
-#include <core/device_interface.h>
+#include <core/display_interface.h>
 #include <private/strategy_interface.h>
 #include <utils/constants.h>
 
@@ -103,14 +103,14 @@
   HWLayerConfig config[kMaxSDELayers];
 };
 
-struct HWDeviceAttributes : DeviceConfigVariableInfo {
+struct HWDisplayAttributes : DisplayConfigVariableInfo {
   bool is_device_split;
   uint32_t split_left;
 
-  HWDeviceAttributes() : is_device_split(false), split_left(0) { }
+  HWDisplayAttributes() : is_device_split(false), split_left(0) { }
 };
 
-// HWEventHandler - Implemented in DeviceBase and HWInterface implementation
+// HWEventHandler - Implemented in DisplayBase and HWInterface implementation
 class HWEventHandler {
  public:
   virtual DisplayError VSync(int64_t timestamp) = 0;
@@ -126,9 +126,9 @@
   virtual DisplayError GetHWCapabilities(HWResourceInfo *hw_res_info) = 0;
   virtual DisplayError Open(HWBlockType type, Handle *device, HWEventHandler *eventhandler) = 0;
   virtual DisplayError Close(Handle device) = 0;
-  virtual DisplayError GetNumDeviceAttributes(Handle device, uint32_t *count) = 0;
-  virtual DisplayError GetDeviceAttributes(Handle device, HWDeviceAttributes *device_attributes,
-                                       uint32_t mode) = 0;
+  virtual DisplayError GetNumDisplayAttributes(Handle device, uint32_t *count) = 0;
+  virtual DisplayError GetDisplayAttributes(Handle device,
+                            HWDisplayAttributes *display_attributes, uint32_t mode) = 0;
   virtual DisplayError PowerOn(Handle device) = 0;
   virtual DisplayError PowerOff(Handle device) = 0;
   virtual DisplayError Doze(Handle device) = 0;
diff --git a/displayengine/libs/core/res_config.cpp b/displayengine/libs/core/res_config.cpp
index 0f71945..6e642ed 100644
--- a/displayengine/libs/core/res_config.cpp
+++ b/displayengine/libs/core/res_config.cpp
@@ -34,9 +34,9 @@
 
 namespace sde {
 
-DisplayError ResManager::Config(ResManagerDevice *res_mgr_device, HWLayers *hw_layers) {
-  HWBlockType hw_block_id = res_mgr_device->hw_block_id;
-  HWDeviceAttributes &device_attributes = res_mgr_device->device_attributes;
+DisplayError ResManager::Config(DisplayResourceContext *display_resource_ctx, HWLayers *hw_layers) {
+  HWBlockType hw_block_id = display_resource_ctx->hw_block_id;
+  HWDisplayAttributes &display_attributes = display_resource_ctx->display_attributes;
   HWLayersInfo &layer_info = hw_layers->info;
 
   for (uint32_t i = 0; i < layer_info.count; i++) {
@@ -48,8 +48,8 @@
     }
 
     LayerRect scissor;
-    scissor.right = FLOAT(device_attributes.split_left);
-    scissor.bottom = FLOAT(device_attributes.y_pixels);
+    scissor.right = FLOAT(display_attributes.split_left);
+    scissor.bottom = FLOAT(display_attributes.y_pixels);
     LayerRect crop = layer.src_rect;
     LayerRect dst = layer.dst_rect;
     LayerRect cropRight = crop;
@@ -65,11 +65,11 @@
     if ((dstRight.right - dstRight.left) > kMaxInterfaceWidth ||
          crop_width > kMaxInterfaceWidth ||
         ((hw_block_id == kHWPrimary) && hw_res_info_.is_src_split &&
-         (crop_width > device_attributes.split_left))) {
-      scissor.left = FLOAT(device_attributes.split_left);
+         (crop_width > display_attributes.split_left))) {
+      scissor.left = FLOAT(display_attributes.split_left);
       scissor.top = 0.0f;
-      scissor.right = FLOAT(device_attributes.x_pixels);
-      scissor.bottom = FLOAT(device_attributes.y_pixels);
+      scissor.right = FLOAT(display_attributes.x_pixels);
+      scissor.bottom = FLOAT(display_attributes.y_pixels);
       CalculateCropRects(&cropRight, &dstRight, scissor, layer.transform);
       pipe_info->src_roi = cropRight;
       pipe_info->dst_roi = dstRight;
diff --git a/displayengine/libs/core/res_manager.cpp b/displayengine/libs/core/res_manager.cpp
index de73437..3f5bd32 100644
--- a/displayengine/libs/core/res_manager.cpp
+++ b/displayengine/libs/core/res_manager.cpp
@@ -92,8 +92,8 @@
   return kErrorNone;
 }
 
-DisplayError ResManager::RegisterDevice(DeviceType type, const HWDeviceAttributes &attributes,
-                                        Handle *device) {
+DisplayError ResManager::RegisterDisplay(DisplayType type, const HWDisplayAttributes &attributes,
+                                        Handle *display_ctx) {
   DisplayError error = kErrorNone;
 
   HWBlockType hw_block_id = kHWBlockMax;
@@ -118,7 +118,7 @@
     break;
 
   default:
-    DLOGW("RegisterDevice, invalid type %d", type);
+    DLOGW("RegisterDisplay, invalid type %d", type);
     return kErrorParameters;
   }
 
@@ -126,37 +126,39 @@
     return kErrorResources;
   }
 
-  ResManagerDevice *res_mgr_device = new ResManagerDevice();
-  if (UNLIKELY(!res_mgr_device)) {
+  DisplayResourceContext *display_resource_ctx = new DisplayResourceContext();
+  if (UNLIKELY(!display_resource_ctx)) {
     return kErrorMemory;
   }
 
   hw_block_ctx_[hw_block_id].is_in_use = true;
 
-  res_mgr_device->device_attributes = attributes;
-  res_mgr_device->device_type = type;
-  res_mgr_device->hw_block_id = hw_block_id;
+  display_resource_ctx->display_attributes = attributes;
+  display_resource_ctx->display_type = type;
+  display_resource_ctx->hw_block_id = hw_block_id;
 
-  *device = res_mgr_device;
+  *display_ctx = display_resource_ctx;
 
   return kErrorNone;
 }
 
-DisplayError ResManager::UnregisterDevice(Handle device) {
-  ResManagerDevice *res_mgr_device = reinterpret_cast<ResManagerDevice *>(device);
+DisplayError ResManager::UnregisterDisplay(Handle display_ctx) {
+  DisplayResourceContext *display_resource_ctx =
+                          reinterpret_cast<DisplayResourceContext *>(display_ctx);
 
-  Purge(device);
-  hw_block_ctx_[res_mgr_device->hw_block_id].is_in_use = false;
-  delete res_mgr_device;
+  Purge(display_ctx);
+  hw_block_ctx_[display_resource_ctx->hw_block_id].is_in_use = false;
+  delete display_resource_ctx;
 
   return kErrorNone;
 }
 
 
-DisplayError ResManager::Start(Handle device) {
+DisplayError ResManager::Start(Handle display_ctx) {
   locker_.Lock();
 
-  ResManagerDevice *res_mgr_device = reinterpret_cast<ResManagerDevice *>(device);
+  DisplayResourceContext *display_resource_ctx =
+                          reinterpret_cast<DisplayResourceContext *>(display_ctx);
 
   if (frame_start_) {
     return kErrorNone;  // keep context locked.
@@ -164,10 +166,10 @@
 
   // First call in the cycle
   frame_start_ = true;
-  res_mgr_device->frame_count++;
+  display_resource_ctx->frame_count++;
 
   // Release the pipes not used in the previous cycle
-  HWBlockType hw_block_id = res_mgr_device->hw_block_id;
+  HWBlockType hw_block_id = display_resource_ctx->hw_block_id;
   for (uint32_t i = 0; i < num_pipe_; i++) {
     if ((src_pipes_[i].hw_block_id == hw_block_id) &&
         (src_pipes_[i].state == kPipeStateToRelease)) {
@@ -177,16 +179,18 @@
   return kErrorNone;
 }
 
-DisplayError ResManager::Stop(Handle device) {
+DisplayError ResManager::Stop(Handle display_ctx) {
   locker_.Unlock();
 
-  ResManagerDevice *res_mgr_device = reinterpret_cast<ResManagerDevice *>(device);
+  DisplayResourceContext *display_resource_ctx =
+                          reinterpret_cast<DisplayResourceContext *>(display_ctx);
 
   return kErrorNone;
 }
 
-DisplayError ResManager::Acquire(Handle device, HWLayers *hw_layers) {
-  ResManagerDevice *res_mgr_device = reinterpret_cast<ResManagerDevice *>(device);
+DisplayError ResManager::Acquire(Handle display_ctx, HWLayers *hw_layers) {
+  DisplayResourceContext *display_resource_ctx =
+                          reinterpret_cast<DisplayResourceContext *>(display_ctx);
 
   DisplayError error = kErrorNone;
   const struct HWLayersInfo &layer_info = hw_layers->info;
@@ -199,14 +203,14 @@
     return kErrorResources;
   }
 
-  error = Config(res_mgr_device, hw_layers);
+  error = Config(display_resource_ctx, hw_layers);
   if (UNLIKELY(error != kErrorNone)) {
     return error;
   }
 
   uint32_t left_index = 0;
   bool need_scale = false;
-  HWBlockType hw_block_id = res_mgr_device->hw_block_id;
+  HWBlockType hw_block_id = display_resource_ctx->hw_block_id;
 
   // Clear reserved marking
   for (uint32_t i = 0; i < num_pipe_; i++) {
@@ -274,10 +278,11 @@
   return kErrorResources;
 }
 
-void ResManager::PostCommit(Handle device, HWLayers *hw_layers) {
-  ResManagerDevice *res_mgr_device = reinterpret_cast<ResManagerDevice *>(device);
-  HWBlockType hw_block_id = res_mgr_device->hw_block_id;
-  uint64_t frame_count = res_mgr_device->frame_count;
+void ResManager::PostCommit(Handle display_ctx, HWLayers *hw_layers) {
+  DisplayResourceContext *display_resource_ctx =
+                          reinterpret_cast<DisplayResourceContext *>(display_ctx);
+  HWBlockType hw_block_id = display_resource_ctx->hw_block_id;
+  uint64_t frame_count = display_resource_ctx->frame_count;
 
   DLOGV("Resource for hw_block=%d frame_count=%d", hw_block_id, frame_count);
 
@@ -310,11 +315,12 @@
   frame_start_ = false;
 }
 
-void ResManager::Purge(Handle device) {
+void ResManager::Purge(Handle display_ctx) {
   SCOPE_LOCK(locker_);
 
-  ResManagerDevice *res_mgr_device = reinterpret_cast<ResManagerDevice *>(device);
-  HWBlockType hw_block_id = res_mgr_device->hw_block_id;
+  DisplayResourceContext *display_resource_ctx =
+                          reinterpret_cast<DisplayResourceContext *>(display_ctx);
+  HWBlockType hw_block_id = display_resource_ctx->hw_block_id;
 
   for (uint32_t i = 0; i < num_pipe_; i++) {
     if (src_pipes_[i].hw_block_id == hw_block_id)
diff --git a/displayengine/libs/core/res_manager.h b/displayengine/libs/core/res_manager.h
index b2698c9..c4d425b 100644
--- a/displayengine/libs/core/res_manager.h
+++ b/displayengine/libs/core/res_manager.h
@@ -25,7 +25,7 @@
 #ifndef __RES_MANAGER_H__
 #define __RES_MANAGER_H__
 
-#include <core/device_interface.h>
+#include <core/display_interface.h>
 #include <utils/locker.h>
 
 #include "hw_interface.h"
@@ -38,14 +38,14 @@
   ResManager();
   DisplayError Init(const HWResourceInfo &hw_res_info);
   DisplayError Deinit();
-  DisplayError RegisterDevice(DeviceType type, const HWDeviceAttributes &attributes,
-                              Handle *device);
-  DisplayError UnregisterDevice(Handle device);
-  DisplayError Start(Handle device);
-  DisplayError Stop(Handle device);
-  DisplayError Acquire(Handle device, HWLayers *hw_layers);
-  void PostCommit(Handle device, HWLayers *hw_layers);
-  void Purge(Handle device);
+  DisplayError RegisterDisplay(DisplayType type, const HWDisplayAttributes &attributes,
+                              Handle *display_ctx);
+  DisplayError UnregisterDisplay(Handle display_ctx);
+  DisplayError Start(Handle display_ctx);
+  DisplayError Stop(Handle display_ctx);
+  DisplayError Acquire(Handle display_ctx, HWLayers *hw_layers);
+  void PostCommit(Handle display_ctx, HWLayers *hw_layers);
+  void Purge(Handle display_ctx);
 
   // DumpImpl method
   virtual void AppendDump(char *buffer, uint32_t length);
@@ -103,14 +103,14 @@
                    reserved(false) { }
   };
 
-  struct ResManagerDevice {
-    HWDeviceAttributes device_attributes;
-    DeviceType device_type;
+  struct DisplayResourceContext {
+    HWDisplayAttributes display_attributes;
+    DisplayType display_type;
     HWBlockType hw_block_id;
     uint64_t frame_count;
     int32_t session_id;  // applicable for virtual display sessions only
 
-    ResManagerDevice() : hw_block_id(kHWBlockMax), frame_count(0), session_id(-1) { }
+    DisplayResourceContext() : hw_block_id(kHWBlockMax), frame_count(0), session_id(-1) { }
   };
 
   struct HWBlockContext {
@@ -123,7 +123,7 @@
   uint32_t GetPipe(HWBlockType hw_block_id, bool is_yuv, bool need_scale, bool at_right,
                    bool use_non_dma_pipe);
   bool IsScalingNeeded(const HWPipeInfo *pipe_info);
-  DisplayError Config(ResManagerDevice *res_mgr_device, HWLayers *hw_layers);
+  DisplayError Config(DisplayResourceContext *display_resource_ctx, HWLayers *hw_layers);
   bool IsValidDimension(const Layer &layer, float *width_scale, float *height_scale);
   void CalculateCut(float *left_cut_ratio, float *top_cut_ratio, float *right_cut_ratio,
                     float *bottom_cut_ratio, const LayerTransform &transform);
diff --git a/displayengine/libs/core/strategy_default.h b/displayengine/libs/core/strategy_default.h
index c72bab9..c4e10f4 100644
--- a/displayengine/libs/core/strategy_default.h
+++ b/displayengine/libs/core/strategy_default.h
@@ -25,7 +25,7 @@
 #ifndef __STRATEGY_DEFAULT_H__
 #define __STRATEGY_DEFAULT_H__
 
-#include <core/device_interface.h>
+#include <core/display_interface.h>
 #include <private/strategy_interface.h>
 
 namespace sde {
diff --git a/displayengine/libs/hwc/Android.mk b/displayengine/libs/hwc/Android.mk
index be7e18c..c32337a 100644
--- a/displayengine/libs/hwc/Android.mk
+++ b/displayengine/libs/hwc/Android.mk
@@ -9,12 +9,12 @@
 LOCAL_CFLAGS                  := $(common_flags) -DLOG_TAG=\"HWComposer\"
 LOCAL_SHARED_LIBRARIES        := $(common_libs) libEGL libhardware_legacy \
                                  libdl libsync \
-                                 libbinder libmedia libskia libsdecore
+                                 libbinder libmedia libskia libsde
 LOCAL_ADDITIONAL_DEPENDENCIES := $(common_deps)
 LOCAL_SRC_FILES               := hwc_session.cpp \
-                                 hwc_sink.cpp \
-                                 hwc_sink_primary.cpp \
-                                 hwc_sink_external.cpp \
-                                 hwc_sink_virtual.cpp
+                                 hwc_display.cpp \
+                                 hwc_display_primary.cpp \
+                                 hwc_display_external.cpp \
+                                 hwc_display_virtual.cpp
 
 include $(BUILD_SHARED_LIBRARY)
diff --git a/displayengine/libs/hwc/hwc_sink.cpp b/displayengine/libs/hwc/hwc_display.cpp
similarity index 85%
rename from displayengine/libs/hwc/hwc_sink.cpp
rename to displayengine/libs/hwc/hwc_display.cpp
index 0fb4b8c..66ffcd8 100644
--- a/displayengine/libs/hwc/hwc_sink.cpp
+++ b/displayengine/libs/hwc/hwc_display.cpp
@@ -27,19 +27,20 @@
 #include <utils/constants.h>
 
 // HWC_MODULE_NAME definition must precede hwc_logger.h include.
-#define HWC_MODULE_NAME "HWCSink"
+#define HWC_MODULE_NAME "HWCDisplay"
 #include "hwc_logger.h"
 
-#include "hwc_sink.h"
+#include "hwc_display.h"
 
 namespace sde {
 
-HWCSink::HWCSink(CoreInterface *core_intf, hwc_procs_t const **hwc_procs, DeviceType type, int id)
-  : core_intf_(core_intf), hwc_procs_(hwc_procs), type_(type), id_(id), device_intf_(NULL) {
+HWCDisplay::HWCDisplay(CoreInterface *core_intf, hwc_procs_t const **hwc_procs, DisplayType type,
+                       int id)
+  : core_intf_(core_intf), hwc_procs_(hwc_procs), type_(type), id_(id), display_intf_(NULL) {
 }
 
-int HWCSink::Init() {
-  DisplayError error = core_intf_->CreateDevice(type_, this, &device_intf_);
+int HWCDisplay::Init() {
+  DisplayError error = core_intf_->CreateDisplay(type_, this, &display_intf_);
   if (UNLIKELY(error != kErrorNone)) {
     DLOGE("Display device create failed. Error = %d", error);
     return -EINVAL;
@@ -48,8 +49,8 @@
   return 0;
 }
 
-int HWCSink::Deinit() {
-  DisplayError error = core_intf_->DestroyDevice(device_intf_);
+int HWCDisplay::Deinit() {
+  DisplayError error = core_intf_->DestroyDisplay(display_intf_);
   if (UNLIKELY(error != kErrorNone)) {
     DLOGE("Display device destroy failed. Error = %d", error);
     return -EINVAL;
@@ -62,12 +63,12 @@
   return 0;
 }
 
-int HWCSink::EventControl(int event, int enable) {
+int HWCDisplay::EventControl(int event, int enable) {
   DisplayError error = kErrorNone;
 
   switch (event) {
   case HWC_EVENT_VSYNC:
-    error = device_intf_->SetVSyncState(enable);
+    error = display_intf_->SetVSyncState(enable);
     break;
 
   default:
@@ -82,13 +83,13 @@
   return 0;
 }
 
-int HWCSink::Blank(int blank) {
+int HWCDisplay::Blank(int blank) {
   DLOGI("Blank : %d, display : %d", blank, id_);
-  DeviceState state = blank ? kStateOff : kStateOn;
+  DisplayState state = blank ? kStateOff : kStateOn;
   return SetState(state);
 }
 
-int HWCSink::GetDisplayConfigs(uint32_t *configs, size_t *num_configs) {
+int HWCDisplay::GetDisplayConfigs(uint32_t *configs, size_t *num_configs) {
   if (*num_configs > 0) {
     configs[0] = 0;
     *num_configs = 1;
@@ -97,11 +98,11 @@
   return 0;
 }
 
-int HWCSink::GetDisplayAttributes(uint32_t config, const uint32_t *attributes, int32_t *values) {
+int HWCDisplay::GetDisplayAttributes(uint32_t config, const uint32_t *attributes, int32_t *values) {
   DisplayError error = kErrorNone;
 
-  DeviceConfigVariableInfo variable_config;
-  error = device_intf_->GetConfig(&variable_config, 0);
+  DisplayConfigVariableInfo variable_config;
+  error = display_intf_->GetConfig(&variable_config, 0);
   if (UNLIKELY(error != kErrorNone)) {
     DLOGE("GetConfig variable info failed. Error = %d", error);
     return -EINVAL;
@@ -124,6 +125,9 @@
     case HWC_DISPLAY_DPI_Y:
       values[i] = INT32(variable_config.y_dpi * 1000.0f);
       break;
+    case HWC_DISPLAY_SECURE:
+      values[i] = INT32(true); // For backward compatibility. All Physical displays are secure
+      break;
     default:
       DLOGE("Spurious attribute type %d", attributes[i]);
       return -EINVAL;
@@ -133,8 +137,8 @@
   return 0;
 }
 
-int HWCSink::SetState(DeviceState state) {
-  DisplayError error = device_intf_->SetDeviceState(state);
+int HWCDisplay::SetState(DisplayState state) {
+  DisplayError error = display_intf_->SetDisplayState(state);
   if (UNLIKELY(error != kErrorNone)) {
     DLOGE("Set state failed. Error = %d", error);
     return -EINVAL;
@@ -143,7 +147,7 @@
   return 0;
 }
 
-DisplayError HWCSink::VSync(const DeviceEventVSync &vsync) {
+DisplayError HWCDisplay::VSync(const DisplayEventVSync &vsync) {
   if (*hwc_procs_) {
     (*hwc_procs_)->vsync(*hwc_procs_, id_, vsync.timestamp);
   }
@@ -151,7 +155,7 @@
   return kErrorNone;
 }
 
-DisplayError HWCSink::Refresh() {
+DisplayError HWCDisplay::Refresh() {
   if (*hwc_procs_) {
     (*hwc_procs_)->invalidate(*hwc_procs_);
   }
@@ -159,7 +163,7 @@
   return kErrorNone;
 }
 
-int HWCSink::AllocateLayerStack(hwc_display_contents_1_t *content_list) {
+int HWCDisplay::AllocateLayerStack(hwc_display_contents_1_t *content_list) {
   size_t num_hw_layers = content_list->numHwLayers;
 
   // Allocate memory for a) total number of layers b) buffer handle for each layer c) number of
@@ -220,7 +224,7 @@
   return 0;
 }
 
-int HWCSink::PrepareLayerStack(hwc_display_contents_1_t *content_list) {
+int HWCDisplay::PrepareLayerStack(hwc_display_contents_1_t *content_list) {
   size_t num_hw_layers = content_list->numHwLayers;
   if (UNLIKELY(num_hw_layers <= 1)) {
     return 0;
@@ -282,7 +286,7 @@
   // Configure layer stack
   layer_stack_.flags.geometry_changed = ((content_list->flags & HWC_GEOMETRY_CHANGED) > 0);
 
-  DisplayError error = device_intf_->Prepare(&layer_stack_);
+  DisplayError error = display_intf_->Prepare(&layer_stack_);
   if (UNLIKELY(error != kErrorNone)) {
     DLOGE("Prepare failed. Error = %d", error);
     return -EINVAL;
@@ -304,7 +308,7 @@
   return 0;
 }
 
-void HWCSink::CacheLayerStackInfo(hwc_display_contents_1_t *content_list) {
+void HWCDisplay::CacheLayerStackInfo(hwc_display_contents_1_t *content_list) {
   uint32_t layer_count = layer_stack_.layer_count;
 
   for (size_t i = 0; i < layer_count; i++) {
@@ -315,7 +319,7 @@
   layer_stack_cache_.layer_count = layer_count;
 }
 
-bool HWCSink::NeedsFrameBufferRefresh(hwc_display_contents_1_t *content_list) {
+bool HWCDisplay::NeedsFrameBufferRefresh(hwc_display_contents_1_t *content_list) {
   uint32_t layer_count = layer_stack_.layer_count;
 
   // Frame buffer needs to be refreshed for the following reasons:
@@ -343,7 +347,7 @@
   return false;
 }
 
-int HWCSink::CommitLayerStack(hwc_display_contents_1_t *content_list) {
+int HWCDisplay::CommitLayerStack(hwc_display_contents_1_t *content_list) {
   size_t num_hw_layers = content_list->numHwLayers;
   if (UNLIKELY(num_hw_layers <= 1)) {
     return 0;
@@ -356,7 +360,7 @@
     layer_buffer->acquire_fence_fd = hwc_layer.acquireFenceFd;
   }
 
-  DisplayError error = device_intf_->Commit(&layer_stack_);
+  DisplayError error = display_intf_->Commit(&layer_stack_);
   if (UNLIKELY(error != kErrorNone)) {
     DLOGE("Commit failed. Error = %d", error);
     return -EINVAL;
@@ -379,21 +383,21 @@
   return 0;
 }
 
-void HWCSink::SetRect(LayerRect *target, const hwc_rect_t &source) {
+void HWCDisplay::SetRect(LayerRect *target, const hwc_rect_t &source) {
   target->left = FLOAT(source.left);
   target->top = FLOAT(source.top);
   target->right = FLOAT(source.right);
   target->bottom = FLOAT(source.bottom);
 }
 
-void HWCSink::SetRect(LayerRect *target, const hwc_frect_t &source) {
+void HWCDisplay::SetRect(LayerRect *target, const hwc_frect_t &source) {
   target->left = source.left;
   target->top = source.top;
   target->right = source.right;
   target->bottom = source.bottom;
 }
 
-void HWCSink::SetComposition(LayerComposition *target, const int32_t &source) {
+void HWCDisplay::SetComposition(LayerComposition *target, const int32_t &source) {
   switch (source) {
   case HWC_FRAMEBUFFER_TARGET:
     *target = kCompositionGPUTarget;
@@ -404,7 +408,7 @@
   }
 }
 
-void HWCSink::SetComposition(int32_t *target, const LayerComposition &source) {
+void HWCDisplay::SetComposition(int32_t *target, const LayerComposition &source) {
   switch (source) {
   case kCompositionGPUTarget:
     *target = HWC_FRAMEBUFFER_TARGET;
@@ -418,7 +422,7 @@
   }
 }
 
-void HWCSink::SetBlending(LayerBlending *target, const int32_t &source) {
+void HWCDisplay::SetBlending(LayerBlending *target, const int32_t &source) {
   switch (source) {
   case HWC_BLENDING_PREMULT:
     *target = kBlendingPremultiplied;
@@ -432,7 +436,7 @@
   }
 }
 
-int HWCSink::SetFormat(LayerBufferFormat *target, const int &source) {
+int HWCDisplay::SetFormat(LayerBufferFormat *target, const int &source) {
   switch (source) {
   case HAL_PIXEL_FORMAT_RGBA_8888:
     *target = kFormatRGBA8888;
diff --git a/displayengine/libs/hwc/hwc_sink.h b/displayengine/libs/hwc/hwc_display.h
similarity index 89%
rename from displayengine/libs/hwc/hwc_sink.h
rename to displayengine/libs/hwc/hwc_display.h
index 551a77b..67356af 100644
--- a/displayengine/libs/hwc/hwc_sink.h
+++ b/displayengine/libs/hwc/hwc_display.h
@@ -22,15 +22,15 @@
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
-#ifndef __HWC_SINK_H__
-#define __HWC_SINK_H__
+#ifndef __HWC_DISPLAY_H__
+#define __HWC_DISPLAY_H__
 
 #include <hardware/hwcomposer.h>
 #include <core/core_interface.h>
 
 namespace sde {
 
-class HWCSink : public DeviceEventHandler {
+class HWCDisplay : public DisplayEventHandler {
  public:
   virtual int Init();
   virtual int Deinit();
@@ -40,7 +40,7 @@
   virtual int Blank(int blank);
   virtual int GetDisplayConfigs(uint32_t *configs, size_t *num_configs);
   virtual int GetDisplayAttributes(uint32_t config, const uint32_t *attributes, int32_t *values);
-  int SetState(DeviceState state);
+  int SetState(DisplayState state);
 
  protected:
   // Maximum number of layers supported by display engine.
@@ -55,11 +55,11 @@
     LayerStackMemory() : raw(NULL), size(0) { }
   };
 
-  HWCSink(CoreInterface *core_intf, hwc_procs_t const **hwc_procs, DeviceType type, int id);
-  virtual ~HWCSink() { }
+  HWCDisplay(CoreInterface *core_intf, hwc_procs_t const **hwc_procs, DisplayType type, int id);
+  virtual ~HWCDisplay() { }
 
-  // DeviceEventHandler methods
-  virtual DisplayError VSync(const DeviceEventVSync &vsync);
+  // DisplayEventHandler methods
+  virtual DisplayError VSync(const DisplayEventVSync &vsync);
   virtual DisplayError Refresh();
 
   virtual int AllocateLayerStack(hwc_display_contents_1_t *content_list);
@@ -75,9 +75,9 @@
   LayerStackMemory layer_stack_;
   CoreInterface *core_intf_;
   hwc_procs_t const **hwc_procs_;
-  DeviceType type_;
+  DisplayType type_;
   int id_;
-  DeviceInterface *device_intf_;
+  DisplayInterface *display_intf_;
 
  private:
   struct LayerCache {
@@ -102,5 +102,5 @@
 
 }  // namespace sde
 
-#endif  // __HWC_SINK_H__
+#endif  // __HWC_DISPLAY_H__
 
diff --git a/displayengine/libs/hwc/hwc_sink_external.cpp b/displayengine/libs/hwc/hwc_display_external.cpp
similarity index 77%
copy from displayengine/libs/hwc/hwc_sink_external.cpp
copy to displayengine/libs/hwc/hwc_display_external.cpp
index d506194..369d286 100644
--- a/displayengine/libs/hwc/hwc_sink_external.cpp
+++ b/displayengine/libs/hwc/hwc_display_external.cpp
@@ -25,38 +25,38 @@
 #include <utils/constants.h>
 
 // HWC_MODULE_NAME definition must precede hwc_logger.h include.
-#define HWC_MODULE_NAME "HWCSinkExternal"
+#define HWC_MODULE_NAME "HWCDisplayExternal"
 #include "hwc_logger.h"
 
-#include "hwc_sink_external.h"
+#include "hwc_display_external.h"
 
 namespace sde {
 
-HWCSinkExternal::HWCSinkExternal(CoreInterface *core_intf, hwc_procs_t const **hwc_procs)
-  : HWCSink(core_intf, hwc_procs, kHDMI, HWC_DISPLAY_EXTERNAL) {
+HWCDisplayExternal::HWCDisplayExternal(CoreInterface *core_intf, hwc_procs_t const **hwc_procs)
+  : HWCDisplay(core_intf, hwc_procs, kHDMI, HWC_DISPLAY_EXTERNAL) {
 }
 
-int HWCSinkExternal::Init() {
+int HWCDisplayExternal::Init() {
   return 0;
 }
 
-int HWCSinkExternal::Deinit() {
+int HWCDisplayExternal::Deinit() {
   return 0;
 }
 
-int HWCSinkExternal::Prepare(hwc_display_contents_1_t *content_list) {
+int HWCDisplayExternal::Prepare(hwc_display_contents_1_t *content_list) {
   return 0;
 }
 
-int HWCSinkExternal::Commit(hwc_display_contents_1_t *content_list) {
+int HWCDisplayExternal::Commit(hwc_display_contents_1_t *content_list) {
   return 0;
 }
 
-int HWCSinkExternal::PowerOn() {
+int HWCDisplayExternal::PowerOn() {
   return 0;
 }
 
-int HWCSinkExternal::PowerOff() {
+int HWCDisplayExternal::PowerOff() {
   return 0;
 }
 
diff --git a/displayengine/libs/hwc/hwc_sink_external.h b/displayengine/libs/hwc/hwc_display_external.h
similarity index 87%
rename from displayengine/libs/hwc/hwc_sink_external.h
rename to displayengine/libs/hwc/hwc_display_external.h
index c0eab7f..012c653 100644
--- a/displayengine/libs/hwc/hwc_sink_external.h
+++ b/displayengine/libs/hwc/hwc_display_external.h
@@ -22,16 +22,16 @@
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
-#ifndef __HWC_SINK_EXTERNAL_H__
-#define __HWC_SINK_EXTERNAL_H__
+#ifndef __HWC_DISPLAY_EXTERNAL_H__
+#define __HWC_DISPLAY_EXTERNAL_H__
 
-#include "hwc_sink.h"
+#include "hwc_display.h"
 
 namespace sde {
 
-class HWCSinkExternal : public HWCSink {
+class HWCDisplayExternal : public HWCDisplay {
  public:
-  explicit HWCSinkExternal(CoreInterface *core_intf, hwc_procs_t const **hwc_procs);
+  explicit HWCDisplayExternal(CoreInterface *core_intf, hwc_procs_t const **hwc_procs);
   virtual int Init();
   virtual int Deinit();
   virtual int Prepare(hwc_display_contents_1_t *content_list);
@@ -42,5 +42,5 @@
 
 }  // namespace sde
 
-#endif  // __HWC_SINK_EXTERNAL_H__
+#endif  // __HWC_DISPLAY_EXTERNAL_H__
 
diff --git a/displayengine/libs/hwc/hwc_sink_primary.cpp b/displayengine/libs/hwc/hwc_display_primary.cpp
similarity index 77%
rename from displayengine/libs/hwc/hwc_sink_primary.cpp
rename to displayengine/libs/hwc/hwc_display_primary.cpp
index a9b74bf..d0c0734 100644
--- a/displayengine/libs/hwc/hwc_sink_primary.cpp
+++ b/displayengine/libs/hwc/hwc_display_primary.cpp
@@ -25,26 +25,26 @@
 #include <utils/constants.h>
 
 // HWC_MODULE_NAME definition must precede hwc_logger.h include.
-#define HWC_MODULE_NAME "HWCSinkPrimary"
+#define HWC_MODULE_NAME "HWCDisplayPrimary"
 #include "hwc_logger.h"
 
-#include "hwc_sink_primary.h"
+#include "hwc_display_primary.h"
 
 namespace sde {
 
-HWCSinkPrimary::HWCSinkPrimary(CoreInterface *core_intf, hwc_procs_t const **hwc_procs)
-  : HWCSink(core_intf, hwc_procs, kPrimary, HWC_DISPLAY_PRIMARY) {
+HWCDisplayPrimary::HWCDisplayPrimary(CoreInterface *core_intf, hwc_procs_t const **hwc_procs)
+  : HWCDisplay(core_intf, hwc_procs, kPrimary, HWC_DISPLAY_PRIMARY) {
 }
 
-int HWCSinkPrimary::Init() {
-  return HWCSink::Init();
+int HWCDisplayPrimary::Init() {
+  return HWCDisplay::Init();
 }
 
-int HWCSinkPrimary::Deinit() {
-  return HWCSink::Deinit();
+int HWCDisplayPrimary::Deinit() {
+  return HWCDisplay::Deinit();
 }
 
-int HWCSinkPrimary::Prepare(hwc_display_contents_1_t *content_list) {
+int HWCDisplayPrimary::Prepare(hwc_display_contents_1_t *content_list) {
   int status = 0;
 
   status = AllocateLayerStack(content_list);
@@ -60,10 +60,10 @@
   return 0;
 }
 
-int HWCSinkPrimary::Commit(hwc_display_contents_1_t *content_list) {
+int HWCDisplayPrimary::Commit(hwc_display_contents_1_t *content_list) {
   int status = 0;
 
-  status = HWCSink::CommitLayerStack(content_list);
+  status = HWCDisplay::CommitLayerStack(content_list);
   if (UNLIKELY(status)) {
     return status;
   }
@@ -73,11 +73,11 @@
   return 0;
 }
 
-int HWCSinkPrimary::PowerOn() {
+int HWCDisplayPrimary::PowerOn() {
   return SetState(kStateOn);
 }
 
-int HWCSinkPrimary::PowerOff() {
+int HWCDisplayPrimary::PowerOff() {
   return SetState(kStateOff);
 }
 
diff --git a/displayengine/libs/hwc/hwc_sink_virtual.h b/displayengine/libs/hwc/hwc_display_primary.h
similarity index 87%
copy from displayengine/libs/hwc/hwc_sink_virtual.h
copy to displayengine/libs/hwc/hwc_display_primary.h
index 381c1e3..cd8ae0f 100644
--- a/displayengine/libs/hwc/hwc_sink_virtual.h
+++ b/displayengine/libs/hwc/hwc_display_primary.h
@@ -22,16 +22,16 @@
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
-#ifndef __HWC_SINK_VIRTUAL_H__
-#define __HWC_SINK_VIRTUAL_H__
+#ifndef __HWC_DISPLAY_PRIMARY_H__
+#define __HWC_DISPLAY_PRIMARY_H__
 
-#include "hwc_sink.h"
+#include "hwc_display.h"
 
 namespace sde {
 
-class HWCSinkVirtual : public HWCSink {
+class HWCDisplayPrimary : public HWCDisplay {
  public:
-  explicit HWCSinkVirtual(CoreInterface *core_intf, hwc_procs_t const **hwc_procs);
+  explicit HWCDisplayPrimary(CoreInterface *core_intf, hwc_procs_t const **hwc_procs);
   virtual int Init();
   virtual int Deinit();
   virtual int Prepare(hwc_display_contents_1_t *content_list);
@@ -42,5 +42,5 @@
 
 }  // namespace sde
 
-#endif  // __HWC_SINK_VIRTUAL_H__
+#endif  // __HWC_DISPLAY_PRIMARY_H__
 
diff --git a/displayengine/libs/hwc/hwc_sink_external.cpp b/displayengine/libs/hwc/hwc_display_virtual.cpp
similarity index 77%
rename from displayengine/libs/hwc/hwc_sink_external.cpp
rename to displayengine/libs/hwc/hwc_display_virtual.cpp
index d506194..62e4d2f 100644
--- a/displayengine/libs/hwc/hwc_sink_external.cpp
+++ b/displayengine/libs/hwc/hwc_display_virtual.cpp
@@ -25,38 +25,38 @@
 #include <utils/constants.h>
 
 // HWC_MODULE_NAME definition must precede hwc_logger.h include.
-#define HWC_MODULE_NAME "HWCSinkExternal"
+#define HWC_MODULE_NAME "HWCDisplayVirtual"
 #include "hwc_logger.h"
 
-#include "hwc_sink_external.h"
+#include "hwc_display_virtual.h"
 
 namespace sde {
 
-HWCSinkExternal::HWCSinkExternal(CoreInterface *core_intf, hwc_procs_t const **hwc_procs)
-  : HWCSink(core_intf, hwc_procs, kHDMI, HWC_DISPLAY_EXTERNAL) {
+HWCDisplayVirtual::HWCDisplayVirtual(CoreInterface *core_intf, hwc_procs_t const **hwc_procs)
+  : HWCDisplay(core_intf, hwc_procs, kVirtual, HWC_DISPLAY_VIRTUAL) {
 }
 
-int HWCSinkExternal::Init() {
+int HWCDisplayVirtual::Init() {
   return 0;
 }
 
-int HWCSinkExternal::Deinit() {
+int HWCDisplayVirtual::Deinit() {
   return 0;
 }
 
-int HWCSinkExternal::Prepare(hwc_display_contents_1_t *content_list) {
+int HWCDisplayVirtual::Prepare(hwc_display_contents_1_t *content_list) {
   return 0;
 }
 
-int HWCSinkExternal::Commit(hwc_display_contents_1_t *content_list) {
+int HWCDisplayVirtual::Commit(hwc_display_contents_1_t *content_list) {
   return 0;
 }
 
-int HWCSinkExternal::PowerOn() {
+int HWCDisplayVirtual::PowerOn() {
   return 0;
 }
 
-int HWCSinkExternal::PowerOff() {
+int HWCDisplayVirtual::PowerOff() {
   return 0;
 }
 
diff --git a/displayengine/libs/hwc/hwc_sink_virtual.h b/displayengine/libs/hwc/hwc_display_virtual.h
similarity index 87%
rename from displayengine/libs/hwc/hwc_sink_virtual.h
rename to displayengine/libs/hwc/hwc_display_virtual.h
index 381c1e3..6159425 100644
--- a/displayengine/libs/hwc/hwc_sink_virtual.h
+++ b/displayengine/libs/hwc/hwc_display_virtual.h
@@ -22,16 +22,16 @@
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
-#ifndef __HWC_SINK_VIRTUAL_H__
-#define __HWC_SINK_VIRTUAL_H__
+#ifndef __HWC_DISPLAY_VIRTUAL_H__
+#define __HWC_DISPLAY_VIRTUAL_H__
 
-#include "hwc_sink.h"
+#include "hwc_display.h"
 
 namespace sde {
 
-class HWCSinkVirtual : public HWCSink {
+class HWCDisplayVirtual : public HWCDisplay {
  public:
-  explicit HWCSinkVirtual(CoreInterface *core_intf, hwc_procs_t const **hwc_procs);
+  explicit HWCDisplayVirtual(CoreInterface *core_intf, hwc_procs_t const **hwc_procs);
   virtual int Init();
   virtual int Deinit();
   virtual int Prepare(hwc_display_contents_1_t *content_list);
@@ -42,5 +42,5 @@
 
 }  // namespace sde
 
-#endif  // __HWC_SINK_VIRTUAL_H__
+#endif  // __HWC_DISPLAY_VIRTUAL_H__
 
diff --git a/displayengine/libs/hwc/hwc_session.cpp b/displayengine/libs/hwc/hwc_session.cpp
index 9dfa920..9749fb1 100644
--- a/displayengine/libs/hwc/hwc_session.cpp
+++ b/displayengine/libs/hwc/hwc_session.cpp
@@ -77,24 +77,24 @@
   int status = -EINVAL;
 
   // Create and power on primary display
-  sink_primary_ = new HWCSinkPrimary(core_intf_, &hwc_procs_);
-  if (UNLIKELY(!sink_primary_)) {
+  display_primary_ = new HWCDisplayPrimary(core_intf_, &hwc_procs_);
+  if (UNLIKELY(!display_primary_)) {
     CoreInterface::DestroyCore();
     return -ENOMEM;
   }
 
-  status = sink_primary_->Init();
+  status = display_primary_->Init();
   if (UNLIKELY(status)) {
     CoreInterface::DestroyCore();
-    delete sink_primary_;
+    delete display_primary_;
     return status;
   }
 
-  status = sink_primary_->PowerOn();
+  status = display_primary_->PowerOn();
   if (UNLIKELY(status)) {
     CoreInterface::DestroyCore();
-    sink_primary_->Deinit();
-    delete sink_primary_;
+    display_primary_->Deinit();
+    delete display_primary_;
     return status;
   }
 
@@ -102,9 +102,9 @@
 }
 
 int HWCSession::Deinit() {
-  sink_primary_->PowerOff();
-  sink_primary_->Deinit();
-  delete sink_primary_;
+  display_primary_->PowerOff();
+  display_primary_->Deinit();
+  delete display_primary_;
 
   DisplayError error = CoreInterface::DestroyCore();
   if (error != kErrorNone) {
@@ -173,7 +173,7 @@
 
     switch (i) {
     case HWC_DISPLAY_PRIMARY:
-      status = hwc_session->sink_primary_->Prepare(content_list);
+      status = hwc_session->display_primary_->Prepare(content_list);
       break;
     default:
       status = -EINVAL;
@@ -207,7 +207,7 @@
 
     switch (i) {
     case HWC_DISPLAY_PRIMARY:
-      status = hwc_session->sink_primary_->Commit(content_list);
+      status = hwc_session->display_primary_->Commit(content_list);
       break;
     default:
       status = -EINVAL;
@@ -233,7 +233,7 @@
 
   switch (disp) {
   case HWC_DISPLAY_PRIMARY:
-    status = hwc_session->sink_primary_->EventControl(event, enable);
+    status = hwc_session->display_primary_->EventControl(event, enable);
     break;
   default:
     status = -EINVAL;
@@ -254,7 +254,7 @@
 
   switch (disp) {
   case HWC_DISPLAY_PRIMARY:
-    status = hwc_session->sink_primary_->Blank(blank);
+    status = hwc_session->display_primary_->Blank(blank);
     break;
   default:
     status = -EINVAL;
@@ -301,7 +301,7 @@
 
   switch (disp) {
   case HWC_DISPLAY_PRIMARY:
-    status = hwc_session->sink_primary_->GetDisplayConfigs(configs, num_configs);
+    status = hwc_session->display_primary_->GetDisplayConfigs(configs, num_configs);
     break;
   default:
     status = -EINVAL;
@@ -321,7 +321,7 @@
 
   switch (disp) {
   case HWC_DISPLAY_PRIMARY:
-    status = hwc_session->sink_primary_->GetDisplayAttributes(config, attributes, values);
+    status = hwc_session->display_primary_->GetDisplayAttributes(config, attributes, values);
     break;
   default:
     status = -EINVAL;
diff --git a/displayengine/libs/hwc/hwc_session.h b/displayengine/libs/hwc/hwc_session.h
index 8390459..6b3346b 100644
--- a/displayengine/libs/hwc/hwc_session.h
+++ b/displayengine/libs/hwc/hwc_session.h
@@ -29,7 +29,7 @@
 #include <core/core_interface.h>
 #include <utils/locker.h>
 
-#include "hwc_sink_primary.h"
+#include "hwc_display_primary.h"
 
 namespace sde {
 
@@ -69,7 +69,7 @@
   static Locker locker_;
   CoreInterface *core_intf_;
   hwc_procs_t const *hwc_procs_;
-  HWCSinkPrimary *sink_primary_;
+  HWCDisplayPrimary *display_primary_;
 };
 
 }  // namespace sde
diff --git a/displayengine/libs/hwc/hwc_sink_primary.h b/displayengine/libs/hwc/hwc_sink_primary.h
deleted file mode 100644
index f16c5a6..0000000
--- a/displayengine/libs/hwc/hwc_sink_primary.h
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
-* Copyright (c) 2014, The Linux Foundation. All rights reserved.
-*
-* Redistribution and use in source and binary forms, with or without modification, are permitted
-* provided that the following conditions are met:
-*    * Redistributions of source code must retain the above copyright notice, this list of
-*      conditions and the following disclaimer.
-*    * Redistributions in binary form must reproduce the above copyright notice, this list of
-*      conditions and the following disclaimer in the documentation and/or other materials provided
-*      with the distribution.
-*    * Neither the name of The Linux Foundation nor the names of its contributors may be used to
-*      endorse or promote products derived from this software without specific prior written
-*      permission.
-*
-* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-* NON-INFRINGEMENT ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
-* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
-* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
-* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-#ifndef __HWC_SINK_PRIMARY_H__
-#define __HWC_SINK_PRIMARY_H__
-
-#include "hwc_sink.h"
-
-namespace sde {
-
-class HWCSinkPrimary : public HWCSink {
- public:
-  explicit HWCSinkPrimary(CoreInterface *core_intf, hwc_procs_t const **hwc_procs);
-  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 PowerOn();
-  virtual int PowerOff();
-};
-
-}  // namespace sde
-
-#endif  // __HWC_SINK_PRIMARY_H__
-
diff --git a/displayengine/libs/hwc/hwc_sink_virtual.cpp b/displayengine/libs/hwc/hwc_sink_virtual.cpp
deleted file mode 100644
index 49334a3..0000000
--- a/displayengine/libs/hwc/hwc_sink_virtual.cpp
+++ /dev/null
@@ -1,64 +0,0 @@
-/*
-* Copyright (c) 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.
-*/
-
-#include <utils/constants.h>
-
-// HWC_MODULE_NAME definition must precede hwc_logger.h include.
-#define HWC_MODULE_NAME "HWCSinkVirtual"
-#include "hwc_logger.h"
-
-#include "hwc_sink_virtual.h"
-
-namespace sde {
-
-HWCSinkVirtual::HWCSinkVirtual(CoreInterface *core_intf, hwc_procs_t const **hwc_procs)
-  : HWCSink(core_intf, hwc_procs, kVirtual, HWC_DISPLAY_VIRTUAL) {
-}
-
-int HWCSinkVirtual::Init() {
-  return 0;
-}
-
-int HWCSinkVirtual::Deinit() {
-  return 0;
-}
-
-int HWCSinkVirtual::Prepare(hwc_display_contents_1_t *content_list) {
-  return 0;
-}
-
-int HWCSinkVirtual::Commit(hwc_display_contents_1_t *content_list) {
-  return 0;
-}
-
-int HWCSinkVirtual::PowerOn() {
-  return 0;
-}
-
-int HWCSinkVirtual::PowerOff() {
-  return 0;
-}
-
-}  // namespace sde
-
diff --git a/libhwcomposer/hwc.cpp b/libhwcomposer/hwc.cpp
index 0a7f940..c96eb1e 100644
--- a/libhwcomposer/hwc.cpp
+++ b/libhwcomposer/hwc.cpp
@@ -799,6 +799,7 @@
         HWC_DISPLAY_HEIGHT,
         HWC_DISPLAY_DPI_X,
         HWC_DISPLAY_DPI_Y,
+        HWC_DISPLAY_SECURE,
         HWC_DISPLAY_NO_ATTRIBUTE,
     };
 
@@ -844,6 +845,9 @@
         case HWC_DISPLAY_DPI_Y:
             values[i] = (int32_t) (ctx->dpyAttr[disp].ydpi*1000.0);
             break;
+        case HWC_DISPLAY_SECURE:
+            values[i] = (int32_t) (ctx->dpyAttr[disp].secure);
+            break;
         default:
             ALOGE("Unknown display attribute %d",
                     attributes[i]);
diff --git a/libhwcomposer/hwc_dump_layers.cpp b/libhwcomposer/hwc_dump_layers.cpp
index e717c26..6a8feb2 100644
--- a/libhwcomposer/hwc_dump_layers.cpp
+++ b/libhwcomposer/hwc_dump_layers.cpp
@@ -319,7 +319,7 @@
         bool bResult = false;
         char dumpFilename[PATH_MAX];
         SkBitmap *tempSkBmp = new SkBitmap();
-        SkBitmap::Config tempSkBmpConfig = SkBitmap::kNo_Config;
+        SkColorType tempSkBmpColor = kUnknown_SkColorType;
         snprintf(dumpFilename, sizeof(dumpFilename),
             "%s/sfdump%03d.layer%zu.%s.png", mDumpDirPng,
             mDumpCntrPng, layerIndex, mDisplayName);
@@ -327,21 +327,24 @@
         switch (hnd->format) {
             case HAL_PIXEL_FORMAT_RGBA_8888:
             case HAL_PIXEL_FORMAT_RGBX_8888:
+                tempSkBmpColor = kRGBA_8888_SkColorType;
+                break;
             case HAL_PIXEL_FORMAT_BGRA_8888:
-                tempSkBmpConfig = SkBitmap::kARGB_8888_Config;
+                tempSkBmpColor = kBGRA_8888_SkColorType;
                 break;
             case HAL_PIXEL_FORMAT_RGB_565:
+                tempSkBmpColor = kRGB_565_SkColorType;
+                break;
             case HAL_PIXEL_FORMAT_RGBA_5551:
             case HAL_PIXEL_FORMAT_RGBA_4444:
-                tempSkBmpConfig = SkBitmap::kRGB_565_Config;
-                break;
             case HAL_PIXEL_FORMAT_RGB_888:
             default:
-                tempSkBmpConfig = SkBitmap::kNo_Config;
+                tempSkBmpColor = kUnknown_SkColorType;
                 break;
         }
-        if (SkBitmap::kNo_Config != tempSkBmpConfig) {
-            tempSkBmp->setConfig(tempSkBmpConfig, getWidth(hnd), getHeight(hnd));
+        if (kUnknown_SkColorType != tempSkBmpColor) {
+            tempSkBmp->setInfo(SkImageInfo::Make(getWidth(hnd), getHeight(hnd),
+                    tempSkBmpColor, kIgnore_SkAlphaType), 0);
             tempSkBmp->setPixels((void*)hnd->base);
             bResult = SkImageEncoder::EncodeFile(dumpFilename,
                                     *tempSkBmp, SkImageEncoder::kPNG_Type, 100);
diff --git a/libhwcomposer/hwc_mdpcomp.cpp b/libhwcomposer/hwc_mdpcomp.cpp
index d7f31da..975c195 100644
--- a/libhwcomposer/hwc_mdpcomp.cpp
+++ b/libhwcomposer/hwc_mdpcomp.cpp
@@ -46,6 +46,7 @@
 int MDPComp::sMaxPipesPerMixer = 0;
 bool MDPComp::sEnableYUVsplit = false;
 bool MDPComp::sSrcSplitEnabled = false;
+int MDPComp::sMaxSecLayers = 1;
 bool MDPComp::enablePartialUpdateForMDP3 = false;
 MDPComp* MDPComp::getObject(hwc_context_t *ctx, const int& dpy) {
     if(qdutils::MDPVersion::getInstance().isSrcSplit()) {
@@ -139,6 +140,16 @@
             sMaxPipesPerMixer = min(val, sMaxPipesPerMixer);
     }
 
+    /* Maximum layers allowed to use MDP on secondary panels. If property
+     * doesn't exist, default to 1. Using the property it can be set to 0 or
+     * more.
+     */
+    if(property_get("persist.hwc.maxseclayers", property, "1") > 0) {
+        int val = atoi(property);
+        sMaxSecLayers = (val >= 0) ? val : 1;
+        sMaxSecLayers = min(sMaxSecLayers, sMaxPipesPerMixer);
+    }
+
     if(ctx->mMDP.panel != MIPI_CMD_PANEL) {
         sIdleInvalidator = IdleInvalidator::getInstance();
         if(sIdleInvalidator->init(timeout_handler, ctx) < 0) {
@@ -733,7 +744,6 @@
                                 hwc_display_contents_1_t* list){
 
     const int numAppLayers = ctx->listStats[mDpy].numAppLayers;
-    int priDispW = ctx->dpyAttr[HWC_DISPLAY_PRIMARY].xres;
 
     // Fall back to video only composition, if AIV video mode is enabled
     if(ctx->listStats[mDpy].mAIVVideoMode) {
@@ -770,19 +780,6 @@
         return false;
     }
 
-    MDPVersion& mdpHw = MDPVersion::getInstance();
-    if(mDpy > HWC_DISPLAY_PRIMARY &&
-            (priDispW >  (int) mdpHw.getMaxMixerWidth()) &&
-            (ctx->dpyAttr[mDpy].xres <  mdpHw.getMaxMixerWidth())) {
-        // Disable MDP comp on Secondary when the primary is highres panel and
-        // the secondary is a normal 1080p, because, MDP comp on secondary under
-        // in such usecase, decimation gets used for downscale and there will be
-        // a quality mismatch when there will be a fallback to GPU comp
-        ALOGD_IF(isDebug(), "%s: Disable MDP Compositon for Secondary Disp",
-              __FUNCTION__);
-        return false;
-    }
-
     // check for action safe flag and MDP scaling mode which requires scaling.
     if(ctx->dpyAttr[mDpy].mActionSafePresent
             || ctx->dpyAttr[mDpy].mMDPScalingMode) {
@@ -804,6 +801,7 @@
 
         //For 8x26 with panel width>1k, if RGB layer needs HFLIP fail mdp comp
         // may not need it if Gfx pre-rotation can handle all flips & rotations
+        MDPVersion& mdpHw = MDPVersion::getInstance();
         int transform = (layer->flags & HWC_COLOR_FILL) ? 0 : layer->transform;
         if( mdpHw.is8x26() && (ctx->dpyAttr[mDpy].xres > 1024) &&
                 (transform & HWC_TRANSFORM_FLIP_H) && (!isYuvBuffer(hnd)))
@@ -832,13 +830,6 @@
     if(sSimulationFlags & MDPCOMP_AVOID_FULL_MDP)
         return false;
 
-    //Will benefit presentation / secondary-only layer.
-    if((mDpy > HWC_DISPLAY_PRIMARY) &&
-            (list->numHwLayers - 1) > MAX_SEC_LAYERS) {
-        ALOGD_IF(isDebug(), "%s: Exceeds max secondary pipes",__FUNCTION__);
-        return false;
-    }
-
     const int numAppLayers = ctx->listStats[mDpy].numAppLayers;
     for(int i = 0; i < numAppLayers; i++) {
         hwc_layer_1_t* layer = &list->hwLayers[i];
@@ -1041,7 +1032,7 @@
             // Update layer attributes
             hwc_rect_t srcCrop = integerizeSourceCrop(layer->sourceCropf);
             hwc_rect_t destRect = deductRect(layer->displayFrame,
-                                             overlapRect[j]);
+                        getIntersection(layer->displayFrame, overlapRect[j]));
             qhwc::calculate_crop_rects(srcCrop, layer->displayFrame, destRect,
                                        layer->transform);
             layer->sourceCropf.left = (float)srcCrop.left;
@@ -1055,8 +1046,14 @@
     mCurrentFrame.fbCount = 0;
     mCurrentFrame.fbZ = -1;
 
-    for (int j = 0; j < numAppLayers; j++)
-        mCurrentFrame.isFBComposed[j] = false;
+    for (int j = 0; j < numAppLayers; j++) {
+        if(isValidRect(list->hwLayers[j].displayFrame)) {
+            mCurrentFrame.isFBComposed[j] = false;
+        } else {
+            mCurrentFrame.mdpCount--;
+            mCurrentFrame.drop[j] = true;
+        }
+    }
 
     bool result = postHeuristicsHandling(ctx, list);
 
@@ -1154,14 +1151,6 @@
         adjustForSourceSplit(ctx, list);
     }
 
-    //Will benefit cases where a video has non-updating background.
-    if((mDpy > HWC_DISPLAY_PRIMARY) and
-            (mdpCount > MAX_SEC_LAYERS)) {
-        ALOGD_IF(isDebug(), "%s: Exceeds max secondary pipes",__FUNCTION__);
-        reset(ctx);
-        return false;
-    }
-
     if(!postHeuristicsHandling(ctx, list)) {
         ALOGD_IF(isDebug(), "post heuristic handling failed");
         reset(ctx);
@@ -1813,6 +1802,14 @@
         ALOGD_IF(isDebug(), "%s: Exceeds MAX_PIPES_PER_MIXER",__FUNCTION__);
         return false;
     }
+
+    //Will benefit cases where a video has non-updating background.
+    if((mDpy > HWC_DISPLAY_PRIMARY) and
+            (mCurrentFrame.mdpCount > sMaxSecLayers)) {
+        ALOGD_IF(isDebug(), "%s: Exceeds max secondary pipes",__FUNCTION__);
+        return false;
+    }
+
     // Init rotCount to number of rotate sessions used by other displays
     int rotCount = ctx->mRotMgr->getNumActiveSessions();
     // Count the number of rotator sessions required for current display
diff --git a/libhwcomposer/hwc_mdpcomp.h b/libhwcomposer/hwc_mdpcomp.h
index 7fa6674..8929c40 100644
--- a/libhwcomposer/hwc_mdpcomp.h
+++ b/libhwcomposer/hwc_mdpcomp.h
@@ -58,8 +58,6 @@
     static void setMaxPipesPerMixer(const uint32_t value);
 
 protected:
-    enum { MAX_SEC_LAYERS = 1 }; //TODO add property support
-
     enum ePipeType {
         MDPCOMP_OV_RGB = ovutils::OV_MDP_PIPE_RGB,
         MDPCOMP_OV_VG = ovutils::OV_MDP_PIPE_VG,
@@ -258,6 +256,7 @@
     static int sMaxPipesPerMixer;
     static bool sSrcSplitEnabled;
     static IdleInvalidator *sIdleInvalidator;
+    static int sMaxSecLayers;
     struct FrameInfo mCurrentFrame;
     struct LayerCache mCachedFrame;
     //Enable 4kx2k yuv layer split
diff --git a/libhwcomposer/hwc_utils.cpp b/libhwcomposer/hwc_utils.cpp
index f964212..ace0017 100644
--- a/libhwcomposer/hwc_utils.cpp
+++ b/libhwcomposer/hwc_utils.cpp
@@ -81,8 +81,8 @@
 
 namespace qhwc {
 
-//Std refresh rates for digital videos- 24p, 30p and 48p
-uint32_t stdRefreshRates[] = { 30, 24, 48 };
+// Std refresh rates for digital videos- 24p, 30p, 48p and 60p
+uint32_t stdRefreshRates[] = { 30, 24, 48, 60 };
 
 bool isValidResolution(hwc_context_t *ctx, uint32_t xres, uint32_t yres)
 {
@@ -128,6 +128,10 @@
     ctx->dpyAttr[dpy].yres = ctx->mHDMIDisplay->getHeight();
     ctx->dpyAttr[dpy].mMDPScalingMode = ctx->mHDMIDisplay->getMDPScalingMode();
     ctx->dpyAttr[dpy].vsync_period = ctx->mHDMIDisplay->getVsyncPeriod();
+    //FIXME: for now assume HDMI as secure
+    //Will need to read the HDCP status from the driver
+    //and update this accordingly
+    ctx->dpyAttr[dpy].secure = true;
     ctx->mViewFrame[dpy].left = 0;
     ctx->mViewFrame[dpy].top = 0;
     ctx->mViewFrame[dpy].right = ctx->dpyAttr[dpy].xres;
@@ -224,6 +228,7 @@
     ctx->dpyAttr[HWC_DISPLAY_PRIMARY].ydpi = ydpi;
     ctx->dpyAttr[HWC_DISPLAY_PRIMARY].refreshRate = (uint32_t)fps;
     ctx->dpyAttr[HWC_DISPLAY_PRIMARY].dynRefreshRate = (uint32_t)fps;
+    ctx->dpyAttr[HWC_DISPLAY_PRIMARY].secure = true;
     ctx->dpyAttr[HWC_DISPLAY_PRIMARY].vsync_period =
             (uint32_t)(1000000000l / fps);
 
diff --git a/libhwcomposer/hwc_utils.h b/libhwcomposer/hwc_utils.h
index 0dd25c6..286ae22 100644
--- a/libhwcomposer/hwc_utils.h
+++ b/libhwcomposer/hwc_utils.h
@@ -89,6 +89,7 @@
     uint32_t stride;
     float xdpi;
     float ydpi;
+    bool secure;
     int fd;
     bool connected; //Applies only to pluggable disp.
     //Connected does not mean it ready to use.
diff --git a/libmemtrack/kgsl.c b/libmemtrack/kgsl.c
index 3026175..b120246 100644
--- a/libmemtrack/kgsl.c
+++ b/libmemtrack/kgsl.c
@@ -113,7 +113,7 @@
                 unaccounted_size += size;
 
         } else if (type == MEMTRACK_TYPE_GRAPHICS && strcmp(line_type, "ion") == 0) {
-            if (!is_surfaceflinger || strcmp(line_usage, "egl_image") != 0) {
+            if ( !(is_surfaceflinger == false && strcmp(line_usage, "egl_surface") == 0)) {
                 unaccounted_size += size;
             }
         }
diff --git a/liboverlay/mdpWrapper.h b/liboverlay/mdpWrapper.h
index 349b720..f689e45 100644
--- a/liboverlay/mdpWrapper.h
+++ b/liboverlay/mdpWrapper.h
@@ -72,7 +72,7 @@
 bool setOverlay(int fd, mdp_overlay& ov);
 
 /* MSMFB_OVERLAY_PREPARE */
-bool validateAndSet(const int& fd, mdp_overlay_list& list);
+int validateAndSet(const int& fd, mdp_overlay_list& list);
 
 /* MSM_ROTATOR_IOCTL_FINISH */
 bool endRotator(int fd, int sessionId);
@@ -180,7 +180,7 @@
     return true;
 }
 
-inline bool validateAndSet(const int& fd, mdp_overlay_list& list) {
+inline int validateAndSet(const int& fd, mdp_overlay_list& list) {
     ATRACE_CALL();
     uint32_t id = 0;
     if(UNLIKELY(Overlay::isDebugPipeLifecycle())) {
@@ -198,7 +198,7 @@
     if (ioctl(fd, MSMFB_OVERLAY_PREPARE, &list) < 0) {
         ALOGD_IF(IOCTL_DEBUG, "Failed to call ioctl MSMFB_OVERLAY_PREPARE "
                 "err=%s", strerror(errno));
-        return false;
+        return errno;
     }
 
     if(UNLIKELY(Overlay::isDebugPipeLifecycle())) {
@@ -209,7 +209,7 @@
         ALOGD("%s Pipe mask after OVERLAY_PREPARE 0x%04x", __FUNCTION__, id);
     }
 
-    return true;
+    return 0;
 }
 
 inline bool endRotator(int fd, uint32_t sessionId) {
diff --git a/liboverlay/overlay.cpp b/liboverlay/overlay.cpp
index 9320848..e9c0a13 100644
--- a/liboverlay/overlay.cpp
+++ b/liboverlay/overlay.cpp
@@ -97,9 +97,11 @@
     return dest;
 }
 
-eDest Overlay::nextPipe(eMdpPipeType type, int dpy, int mixer) {
+eDest Overlay::nextPipe(eMdpPipeType type, const PipeSpecs& pipeSpecs) {
     eDest dest = OV_INVALID;
-
+    int dpy = pipeSpecs.dpy;
+    int mixer = pipeSpecs.mixer;
+    int formatType = pipeSpecs.formatClass;
     for(int i = 0; i < PipeBook::NUM_PIPES; i++) {
         if( (type == OV_MDP_PIPE_ANY || //Pipe type match
              type == PipeBook::getPipeType((eDest)i)) &&
@@ -107,6 +109,8 @@
              mPipeBook[i].mDisplay == dpy) &&
             (mPipeBook[i].mMixer == MIXER_UNUSED || //Free or same mixer
              mPipeBook[i].mMixer == mixer) &&
+            (mPipeBook[i].mFormatType == FORMAT_NONE || //Free or same format
+             mPipeBook[i].mFormatType == formatType) &&
             PipeBook::isNotAllocated(i) && //Free pipe
             ( (sDMAMultiplexingSupported && dpy) ||
               !(sDMAMode == DMA_BLOCK_MODE && //DMA pipe in Line mode
@@ -122,6 +126,7 @@
         int index = (int)dest;
         mPipeBook[index].mDisplay = dpy;
         mPipeBook[index].mMixer = mixer;
+        mPipeBook[index].mFormatType = formatType;
         if(not mPipeBook[index].valid()) {
             mPipeBook[index].mPipe = new GenericPipe(dpy);
             mPipeBook[index].mSession = PipeBook::NONE;
@@ -146,28 +151,28 @@
 
     //The default behavior is to assume RGB and VG pipes have scalars
     if(pipeSpecs.formatClass == FORMAT_YUV) {
-        return nextPipe(OV_MDP_PIPE_VG, pipeSpecs.dpy, pipeSpecs.mixer);
+        return nextPipe(OV_MDP_PIPE_VG, pipeSpecs);
     } else if(pipeSpecs.fb == false) { //RGB App layers
         if(not pipeSpecs.needsScaling) {
-            dest = nextPipe(OV_MDP_PIPE_DMA, pipeSpecs.dpy, pipeSpecs.mixer);
+            dest = nextPipe(OV_MDP_PIPE_DMA, pipeSpecs);
         }
         if(dest == OV_INVALID) {
-            dest = nextPipe(OV_MDP_PIPE_RGB, pipeSpecs.dpy, pipeSpecs.mixer);
+            dest = nextPipe(OV_MDP_PIPE_RGB, pipeSpecs);
         }
         if(dest == OV_INVALID) {
-            dest = nextPipe(OV_MDP_PIPE_VG, pipeSpecs.dpy, pipeSpecs.mixer);
+            dest = nextPipe(OV_MDP_PIPE_VG, pipeSpecs);
         }
     } else { //FB layer
-        dest = nextPipe(OV_MDP_PIPE_RGB, pipeSpecs.dpy, pipeSpecs.mixer);
+        dest = nextPipe(OV_MDP_PIPE_RGB, pipeSpecs);
         if(dest == OV_INVALID) {
-            dest = nextPipe(OV_MDP_PIPE_VG, pipeSpecs.dpy, pipeSpecs.mixer);
+            dest = nextPipe(OV_MDP_PIPE_VG, pipeSpecs);
         }
         //Some features can cause FB to have scaling as well.
         //If we ever come to this block with FB needing scaling,
         //the screen will be black for a frame, since the FB won't get a pipe
         //but atleast this will prevent a hang
         if(dest == OV_INVALID and (not pipeSpecs.needsScaling)) {
-            dest = nextPipe(OV_MDP_PIPE_DMA, pipeSpecs.dpy, pipeSpecs.mixer);
+            dest = nextPipe(OV_MDP_PIPE_DMA, pipeSpecs);
         }
     }
     return dest;
@@ -178,31 +183,31 @@
     //described in a generic way
     eDest dest = OV_INVALID;
     if(pipeSpecs.formatClass == FORMAT_YUV) { //video
-        return nextPipe(OV_MDP_PIPE_VG, pipeSpecs.dpy, pipeSpecs.mixer);
+        return nextPipe(OV_MDP_PIPE_VG, pipeSpecs);
     } else if(pipeSpecs.fb == false) { //RGB app layers
         if((not pipeSpecs.needsScaling) and
           (not (pipeSpecs.numActiveDisplays > 1 &&
                 pipeSpecs.dpy == DPY_PRIMARY))) {
-            dest = nextPipe(OV_MDP_PIPE_DMA, pipeSpecs.dpy, pipeSpecs.mixer);
+            dest = nextPipe(OV_MDP_PIPE_DMA, pipeSpecs);
         }
         if(dest == OV_INVALID) {
-            dest = nextPipe(OV_MDP_PIPE_RGB, pipeSpecs.dpy, pipeSpecs.mixer);
+            dest = nextPipe(OV_MDP_PIPE_RGB, pipeSpecs);
         }
         if(dest == OV_INVALID) {
-            dest = nextPipe(OV_MDP_PIPE_VG, pipeSpecs.dpy, pipeSpecs.mixer);
+            dest = nextPipe(OV_MDP_PIPE_VG, pipeSpecs);
         }
     } else { //FB layer
         //For 8x26 Secondary we use DMA always for FB for inline rotation
         if(pipeSpecs.dpy == DPY_PRIMARY) {
-            dest = nextPipe(OV_MDP_PIPE_RGB, pipeSpecs.dpy, pipeSpecs.mixer);
+            dest = nextPipe(OV_MDP_PIPE_RGB, pipeSpecs);
             if(dest == OV_INVALID) {
-                dest = nextPipe(OV_MDP_PIPE_VG, pipeSpecs.dpy, pipeSpecs.mixer);
+                dest = nextPipe(OV_MDP_PIPE_VG, pipeSpecs);
             }
         }
         if(dest == OV_INVALID and (not pipeSpecs.needsScaling) and
           (not (pipeSpecs.numActiveDisplays > 1 &&
                 pipeSpecs.dpy == DPY_PRIMARY))) {
-            dest = nextPipe(OV_MDP_PIPE_DMA, pipeSpecs.dpy, pipeSpecs.mixer);
+            dest = nextPipe(OV_MDP_PIPE_DMA, pipeSpecs);
         }
     }
     return dest;
@@ -213,16 +218,16 @@
     //and rife with assumptions
     eDest dest = OV_INVALID;
     if(pipeSpecs.formatClass == FORMAT_YUV or pipeSpecs.needsScaling) {
-        return nextPipe(OV_MDP_PIPE_VG, pipeSpecs.dpy, pipeSpecs.mixer);
+        return nextPipe(OV_MDP_PIPE_VG, pipeSpecs);
     } else {
         //Since this is a specific func, we can assume stuff like RGB pipe not
         //having scalar blocks
-        dest = nextPipe(OV_MDP_PIPE_RGB, pipeSpecs.dpy, pipeSpecs.mixer);
+        dest = nextPipe(OV_MDP_PIPE_RGB, pipeSpecs);
         if(dest == OV_INVALID) {
-            dest = nextPipe(OV_MDP_PIPE_DMA, pipeSpecs.dpy, pipeSpecs.mixer);
+            dest = nextPipe(OV_MDP_PIPE_DMA, pipeSpecs);
         }
         if(dest == OV_INVALID) {
-            dest = nextPipe(OV_MDP_PIPE_VG, pipeSpecs.dpy, pipeSpecs.mixer);
+            dest = nextPipe(OV_MDP_PIPE_VG, pipeSpecs);
         }
     }
     return dest;
@@ -241,14 +246,14 @@
     //unused
     eDest dest = OV_INVALID;
     if(pipeSpecs.formatClass == FORMAT_YUV) {
-        return nextPipe(OV_MDP_PIPE_VG, pipeSpecs.dpy, pipeSpecs.mixer);
+        return nextPipe(OV_MDP_PIPE_VG, pipeSpecs);
     } else {
-        dest = nextPipe(OV_MDP_PIPE_RGB, pipeSpecs.dpy, pipeSpecs.mixer);
+        dest = nextPipe(OV_MDP_PIPE_RGB, pipeSpecs);
         if(dest == OV_INVALID) {
-            dest = nextPipe(OV_MDP_PIPE_VG, pipeSpecs.dpy, pipeSpecs.mixer);
+            dest = nextPipe(OV_MDP_PIPE_VG, pipeSpecs);
         }
         if(dest == OV_INVALID and not pipeSpecs.needsScaling) {
-            dest = nextPipe(OV_MDP_PIPE_DMA, pipeSpecs.dpy, pipeSpecs.mixer);
+            dest = nextPipe(OV_MDP_PIPE_DMA, pipeSpecs);
         }
     }
     return dest;
@@ -402,48 +407,6 @@
         }
     }
 
-    if (mdpVersion < qdutils::MDSS_V5 && mdpVersion > qdutils::MDP_V3_0_5) {
-        msmfb_mixer_info_req  req;
-        mdp_mixer_info *minfo = NULL;
-        char name[64];
-        int fd = -1;
-        for(int i = 0; i < MAX_FB_DEVICES; i++) {
-            snprintf(name, 64, FB_DEVICE_TEMPLATE, i);
-            ALOGD("initoverlay:: opening the device:: %s", name);
-            fd = ::open(name, O_RDWR, 0);
-            if(fd < 0) {
-                ALOGE("cannot open framebuffer(%d)", i);
-                return -1;
-            }
-            //Get the mixer configuration */
-            req.mixer_num = i;
-            if (ioctl(fd, MSMFB_MIXER_INFO, &req) == -1) {
-                ALOGE("ERROR: MSMFB_MIXER_INFO ioctl failed");
-                close(fd);
-                return -1;
-            }
-            minfo = req.info;
-            for (int j = 0; j < req.cnt; j++) {
-                ALOGD("ndx=%d num=%d z_order=%d", minfo->pndx, minfo->pnum,
-                      minfo->z_order);
-                // except the RGB base layer with z_order of -1, clear any
-                // other pipes connected to mixer.
-                if((minfo->z_order) != -1) {
-                    int index = minfo->pndx;
-                    ALOGD("Unset overlay with index: %d at mixer %d", index, i);
-                    if(ioctl(fd, MSMFB_OVERLAY_UNSET, &index) == -1) {
-                        ALOGE("ERROR: MSMFB_OVERLAY_UNSET failed");
-                        close(fd);
-                        return -1;
-                    }
-                }
-                minfo++;
-            }
-            close(fd);
-            fd = -1;
-        }
-    }
-
     FILE *displayDeviceFP = NULL;
     char fbType[MAX_FRAME_BUFFER_NAME_SIZE];
     char msmFbTypePath[MAX_FRAME_BUFFER_NAME_SIZE];
@@ -567,6 +530,7 @@
     mPipe = NULL;
     mDisplay = DPY_UNUSED;
     mMixer = MIXER_UNUSED;
+    mFormatType = FORMAT_NONE;
 }
 
 void Overlay::PipeBook::destroy() {
@@ -576,6 +540,7 @@
     }
     mDisplay = DPY_UNUSED;
     mMixer = MIXER_UNUSED;
+    mFormatType = FORMAT_NONE;
     mSession = NONE;
 }
 
diff --git a/liboverlay/overlay.h b/liboverlay/overlay.h
index e8369ca..665e23f 100644
--- a/liboverlay/overlay.h
+++ b/liboverlay/overlay.h
@@ -50,7 +50,7 @@
     enum { MIXER_LEFT, MIXER_RIGHT, MIXER_UNUSED };
     enum { MIXER_DEFAULT = MIXER_LEFT, MIXER_MAX = MIXER_UNUSED };
     enum { MAX_FB_DEVICES = DPY_MAX };
-    enum { FORMAT_YUV, FORMAT_RGB };
+    enum { FORMAT_YUV, FORMAT_RGB , FORMAT_NONE };
 
     struct PipeSpecs {
         PipeSpecs() : formatClass(FORMAT_RGB), needsScaling(false), fb(false),
@@ -170,7 +170,7 @@
      * display without being garbage-collected once. To add if a pipe is
      * asisgned to a mixer within a display it cannot be reused for another
      * mixer without being UNSET once*/
-    utils::eDest nextPipe(utils::eMdpPipeType, int dpy, int mixer);
+    utils::eDest nextPipe(utils::eMdpPipeType, const PipeSpecs& pipeSpecs);
     /* Helpers that enfore target specific policies while returning pipes */
     utils::eDest getPipe_8x26(const PipeSpecs& pipeSpecs);
     utils::eDest getPipe_8x16(const PipeSpecs& pipeSpecs);
@@ -199,6 +199,8 @@
         int mDisplay;
         /* Mixer within a split display this pipe is attached to */
         int mMixer;
+        /* Format for which this pipe is attached to the mixer*/
+        int mFormatType;
 
         /* operations on bitmap */
         static bool pipeUsageUnchanged();
diff --git a/liboverlay/overlayMdp.cpp b/liboverlay/overlayMdp.cpp
index b8bb33e..4cd52a7 100644
--- a/liboverlay/overlayMdp.cpp
+++ b/liboverlay/overlayMdp.cpp
@@ -359,9 +359,12 @@
         fnProgramScale(&list);
     }
 
-    if(!mdp_wrapper::validateAndSet(fbFd, list)) {
+    // Error value is based on file errno-base.h
+    // 0 - indicates no error.
+    int errVal = mdp_wrapper::validateAndSet(fbFd, list);
+    if(errVal) {
         /* No dump for failure due to insufficient resource */
-        if(errno != E2BIG) {
+        if(errVal != E2BIG) {
             mdp_wrapper::dump("Bad ov dump: ",
                 *list.overlay_list[list.processed_overlays]);
         }