diff --git a/common.mk b/common.mk
index 768696a..464f296 100644
--- a/common.mk
+++ b/common.mk
@@ -27,7 +27,6 @@
 
 ifeq ($(call is-board-platform-in-list, $(MSM_VIDC_TARGET_LIST)), true)
     common_flags += -DVENUS_COLOR_FORMAT
-    common_flags += -DMDSS_TARGET
 endif
 
 common_deps  :=
diff --git a/libcopybit/copybit_c2d.cpp b/libcopybit/copybit_c2d.cpp
index 3807f33..cc13fec 100644
--- a/libcopybit/copybit_c2d.cpp
+++ b/libcopybit/copybit_c2d.cpp
@@ -350,12 +350,7 @@
     if(!handle)
         return 0;
 
-    if (handle->flags & (private_handle_t::PRIV_FLAGS_USES_PMEM |
-                         private_handle_t::PRIV_FLAGS_USES_PMEM_ADSP))
-        memtype = KGSL_USER_MEM_TYPE_PMEM;
-    else if (handle->flags & private_handle_t::PRIV_FLAGS_USES_ASHMEM)
-        memtype = KGSL_USER_MEM_TYPE_ASHMEM;
-    else if (handle->flags & private_handle_t::PRIV_FLAGS_USES_ION)
+    if (handle->flags & private_handle_t::PRIV_FLAGS_USES_ION)
         memtype = KGSL_USER_MEM_TYPE_ION;
     else {
         ALOGE("Invalid handle flags: 0x%x", handle->flags);
@@ -1005,7 +1000,7 @@
     data.size = get_size(info);
     data.align = getpagesize();
     data.uncached = true;
-    int allocFlags = GRALLOC_USAGE_PRIVATE_SYSTEM_HEAP;
+    int allocFlags = 0;
 
     if (sAlloc == 0) {
         sAlloc = gralloc::IAllocController::getInstance();
diff --git a/libgralloc/alloc_controller.cpp b/libgralloc/alloc_controller.cpp
index 508564a..1d0a40a 100644
--- a/libgralloc/alloc_controller.cpp
+++ b/libgralloc/alloc_controller.cpp
@@ -58,27 +58,6 @@
 static unsigned int getUBwcSize(int, int, int, const int, const int);
 
 //Common functions
-static bool canFallback(int usage, bool triedSystem)
-{
-    // Fallback to system heap when alloc fails unless
-    // 1. Composition type is MDP
-    // 2. Alloc from system heap was already tried
-    // 3. The heap type is requsted explicitly
-    // 4. The heap type is protected
-    // 5. The buffer is meant for external display only
-
-    if(QCCompositionType::getInstance().getCompositionType() &
-       COMPOSITION_TYPE_MDP)
-        return false;
-    if(triedSystem)
-        return false;
-    if(usage & (GRALLOC_HEAP_MASK | GRALLOC_USAGE_PROTECTED))
-        return false;
-    if(usage & (GRALLOC_HEAP_MASK | GRALLOC_USAGE_PRIVATE_EXTERNAL_ONLY))
-        return false;
-    //Return true by default
-    return true;
-}
 
 /* The default policy is to return cached buffers unless the client explicity
  * sets the PRIVATE_UNCACHED flag or indicates that the buffer will be rarely
@@ -344,20 +323,15 @@
 int IonController::allocate(alloc_data& data, int usage)
 {
     int ionFlags = 0;
+    int ionHeapId = 0;
     int ret;
 
     data.uncached = useUncached(usage);
     data.allocType = 0;
 
-    if(usage & GRALLOC_USAGE_PRIVATE_SYSTEM_HEAP)
-        ionFlags |= ION_HEAP(ION_SYSTEM_HEAP_ID);
-
-    if(usage & GRALLOC_USAGE_PRIVATE_IOMMU_HEAP)
-        ionFlags |= ION_HEAP(ION_IOMMU_HEAP_ID);
-
     if(usage & GRALLOC_USAGE_PROTECTED) {
         if (usage & GRALLOC_USAGE_PRIVATE_MM_HEAP) {
-            ionFlags |= ION_HEAP(ION_CP_MM_HEAP_ID);
+            ionHeapId |= ION_HEAP(ION_CP_MM_HEAP_ID);
             ionFlags |= ION_SECURE;
 #ifdef ION_FLAG_ALLOW_NON_CONTIG
             if (!(usage & GRALLOC_USAGE_PRIVATE_SECURE_DISPLAY)) {
@@ -366,8 +340,8 @@
 #endif
         } else {
             // for targets/OEMs which do not need HW level protection
-            // do not set ion secure flag & MM heap. Fallback to IOMMU heap.
-            ionFlags |= ION_HEAP(ION_IOMMU_HEAP_ID);
+            // do not set ion secure flag & MM heap. Fallback to system heap.
+            ionHeapId |= ION_HEAP(ION_SYSTEM_HEAP_ID);
             data.allocType |= private_handle_t::PRIV_FLAGS_PROTECTED_BUFFER;
         }
     } else if(usage & GRALLOC_USAGE_PRIVATE_MM_HEAP) {
@@ -375,40 +349,33 @@
         //If it is used for non secure cases, fallback to IOMMU heap
         ALOGW("GRALLOC_USAGE_PRIVATE_MM_HEAP \
                                 cannot be used as an insecure heap!\
-                                trying to use IOMMU instead !!");
-        ionFlags |= ION_HEAP(ION_IOMMU_HEAP_ID);
+                                trying to use system heap instead !!");
+        ionHeapId |= ION_HEAP(ION_SYSTEM_HEAP_ID);
     }
 
     if(usage & GRALLOC_USAGE_PRIVATE_CAMERA_HEAP)
-        ionFlags |= ION_HEAP(ION_CAMERA_HEAP_ID);
+        ionHeapId |= ION_HEAP(ION_CAMERA_HEAP_ID);
 
     if(usage & GRALLOC_USAGE_PRIVATE_ADSP_HEAP)
-        ionFlags |= ION_HEAP(ION_ADSP_HEAP_ID);
+        ionHeapId |= ION_HEAP(ION_ADSP_HEAP_ID);
 
     if(ionFlags & ION_SECURE)
          data.allocType |= private_handle_t::PRIV_FLAGS_SECURE_BUFFER;
 
-    // if no flags are set, default to
-    // SF + IOMMU heaps, so that bypass can work
-    // we can fall back to system heap if
-    // we run out.
-    if(!ionFlags)
-        ionFlags = ION_HEAP(ION_SF_HEAP_ID) | ION_HEAP(ION_IOMMU_HEAP_ID);
+    // if no ion heap flags are set, default to system heap
+    if(!ionHeapId)
+        ionHeapId = ION_HEAP(ION_SYSTEM_HEAP_ID);
 
+    //At this point we should have the right heap set, there is no fallback
     data.flags = ionFlags;
+    data.heapId = ionHeapId;
     ret = mIonAlloc->alloc_buffer(data);
 
-    // Fallback
-    if(ret < 0 && canFallback(usage,
-                              (ionFlags & ION_SYSTEM_HEAP_ID)))
-    {
-        ALOGW("Falling back to system heap");
-        data.flags = ION_HEAP(ION_SYSTEM_HEAP_ID);
-        ret = mIonAlloc->alloc_buffer(data);
-    }
-
     if(ret >= 0 ) {
         data.allocType |= private_handle_t::PRIV_FLAGS_USES_ION;
+    } else {
+        ALOGE("%s: Failed to allocate buffer - heap: 0x%x flags: 0x%x",
+                __FUNCTION__, ionHeapId, ionFlags);
     }
 
     return ret;
diff --git a/libgralloc/gpu.cpp b/libgralloc/gpu.cpp
index df7be41..9be93d6 100644
--- a/libgralloc/gpu.cpp
+++ b/libgralloc/gpu.cpp
@@ -65,13 +65,11 @@
         data.align = getpagesize();
 
     /* force 1MB alignment selectively for secure buffers, MDP5 onwards */
-#ifdef MDSS_TARGET
     if ((usage & GRALLOC_USAGE_PROTECTED) &&
         (usage & GRALLOC_USAGE_PRIVATE_MM_HEAP)) {
         data.align = ALIGN((int) data.align, SZ_1M);
         size = ALIGN(size, data.align);
     }
-#endif
 
     data.size = size;
     data.pHandle = (uintptr_t) pHandle;
@@ -86,7 +84,7 @@
         eData.size = ROUND_UP_PAGESIZE(sizeof(MetaData_t));
         eData.pHandle = data.pHandle;
         eData.align = getpagesize();
-        int eDataUsage = GRALLOC_USAGE_PRIVATE_SYSTEM_HEAP;
+        int eDataUsage = 0;
         int eDataErr = mAllocCtrl->allocate(eData, eDataUsage);
         ALOGE_IF(eDataErr, "gralloc failed for eDataErr=%s",
                                           strerror(-eDataErr));
@@ -99,10 +97,6 @@
         flags |= private_handle_t::PRIV_FLAGS_ITU_R_601;
         if (bufferType == BUFFER_TYPE_VIDEO) {
             if (usage & GRALLOC_USAGE_HW_CAMERA_WRITE) {
-#ifndef MDSS_TARGET
-                colorSpace = ITU_R_601_FR;
-                flags |= private_handle_t::PRIV_FLAGS_ITU_R_601_FR;
-#else
                 // Per the camera spec ITU 709 format should be set only for
                 // video encoding.
                 // It should be set to ITU 601 full range format for any other
@@ -117,7 +111,6 @@
                         colorSpace = ITU_R_601_FR;
                     }
                 }
-#endif
             }
         }
 
@@ -207,10 +200,7 @@
 {
     private_module_t* m = reinterpret_cast<private_module_t*>(common.module);
 
-    // we don't support framebuffer allocations with graphics heap flags
-    if (usage & GRALLOC_HEAP_MASK) {
-        return -EINVAL;
-    }
+    // This allocation will only happen when gralloc is in fb mode
 
     if (m->framebuffer == NULL) {
         ALOGE("%s: Invalid framebuffer", __FUNCTION__);
diff --git a/libgralloc/gralloc_priv.h b/libgralloc/gralloc_priv.h
index f973b76..676c3bc 100755
--- a/libgralloc/gralloc_priv.h
+++ b/libgralloc/gralloc_priv.h
@@ -34,9 +34,11 @@
                                (~(PAGE_SIZE-1)) )
 
 /* Gralloc usage bits indicating the type of allocation that should be used */
-/* SYSTEM heap comes from kernel vmalloc, can never be uncached,
+/* SYSTEM heap comes from kernel vmalloc (ION_SYSTEM_HEAP_ID)
+ * is cached by default and
  * is not secured */
-#define GRALLOC_USAGE_PRIVATE_SYSTEM_HEAP     GRALLOC_USAGE_PRIVATE_0
+
+/* GRALLOC_USAGE_PRIVATE_0 is unused */
 
 /* Non linear, Universal Bandwidth Compression */
 #define GRALLOC_USAGE_PRIVATE_ALLOC_UBWC      GRALLOC_USAGE_PRIVATE_1
@@ -84,14 +86,6 @@
 #define GRALLOC_MODULE_PERFORM_GET_MAP_SECURE_BUFFER_INFO 8
 #define GRALLOC_MODULE_PERFORM_GET_UBWC_FLAG 9
 
-#define GRALLOC_HEAP_MASK   (GRALLOC_USAGE_PRIVATE_SYSTEM_HEAP    |\
-                             GRALLOC_USAGE_PRIVATE_IOMMU_HEAP     |\
-                             GRALLOC_USAGE_PRIVATE_MM_HEAP        |\
-                             GRALLOC_USAGE_PRIVATE_ADSP_HEAP)
-
-#define INTERLACE_MASK 0x80
-/*****************************************************************************/
-
 /* OEM specific HAL formats */
 
 #define HAL_PIXEL_FORMAT_RGBA_5551               6
@@ -165,8 +159,6 @@
     BUFFER_TYPE_VIDEO
 };
 
-/*****************************************************************************/
-
 #ifdef __cplusplus
 struct private_handle_t : public native_handle {
 #else
@@ -175,8 +167,6 @@
 #endif
         enum {
             PRIV_FLAGS_FRAMEBUFFER        = 0x00000001,
-            PRIV_FLAGS_USES_PMEM          = 0x00000002,
-            PRIV_FLAGS_USES_PMEM_ADSP     = 0x00000004,
             PRIV_FLAGS_USES_ION           = 0x00000008,
             PRIV_FLAGS_USES_ASHMEM        = 0x00000010,
             PRIV_FLAGS_NEEDS_FLUSH        = 0x00000020,
@@ -184,10 +174,6 @@
             PRIV_FLAGS_NONCONTIGUOUS_MEM  = 0x00000100,
             PRIV_FLAGS_CACHED             = 0x00000200,
             PRIV_FLAGS_SECURE_BUFFER      = 0x00000400,
-            // For explicit synchronization
-            PRIV_FLAGS_UNSYNCHRONIZED     = 0x00000800,
-            // Not mapped in userspace
-            PRIV_FLAGS_NOT_MAPPED         = 0x00001000,
             // Display on external only
             PRIV_FLAGS_EXTERNAL_ONLY      = 0x00002000,
             // Set by HWC for protected non secure buffers
@@ -252,10 +238,6 @@
             magic = 0;
         }
 
-        bool usesPhysicallyContiguousMemory() {
-            return (flags & PRIV_FLAGS_USES_PMEM) != 0;
-        }
-
         static int validate(const native_handle* h) {
             const private_handle_t* hnd = (const private_handle_t*)h;
             if (!h || h->version != sizeof(native_handle) ||
diff --git a/libgralloc/ionalloc.cpp b/libgralloc/ionalloc.cpp
index 91a930c..96e0e3e 100644
--- a/libgralloc/ionalloc.cpp
+++ b/libgralloc/ionalloc.cpp
@@ -76,19 +76,9 @@
 
     ionAllocData.len = data.size;
     ionAllocData.align = data.align;
-    ionAllocData.heap_id_mask = data.flags & ~ION_SECURE;
-#ifdef ION_FLAG_ALLOW_NON_CONTIG
-    ionAllocData.heap_id_mask &= (data.flags & ~ION_FLAG_ALLOW_NON_CONTIG);
-#endif
-    ionAllocData.flags = data.uncached ? 0 : ION_FLAG_CACHED;
-    // ToDo: replace usage of alloc data structure with
-    //  ionallocdata structure.
-    if (data.flags & ION_SECURE)
-        ionAllocData.flags |= ION_SECURE;
-#ifdef ION_FLAG_ALLOW_NON_CONTIG
-    if (data.flags & ION_FLAG_ALLOW_NON_CONTIG)
-        ionAllocData.flags |= ION_FLAG_ALLOW_NON_CONTIG;
-#endif
+    ionAllocData.heap_id_mask = data.heapId;
+    ionAllocData.flags = data.flags;
+    ionAllocData.flags |= data.uncached ? 0 : ION_FLAG_CACHED;
     err = open_device();
     if (err)
         return err;
diff --git a/libgralloc/mapper.cpp b/libgralloc/mapper.cpp
index 5382300..8b38952 100644
--- a/libgralloc/mapper.cpp
+++ b/libgralloc/mapper.cpp
@@ -204,10 +204,7 @@
 
     if (hnd->base != 0) {
         // this buffer was mapped, unmap it now
-        if (hnd->flags & (private_handle_t::PRIV_FLAGS_USES_PMEM |
-                          private_handle_t::PRIV_FLAGS_USES_PMEM_ADSP |
-                          private_handle_t::PRIV_FLAGS_USES_ASHMEM |
-                          private_handle_t::PRIV_FLAGS_USES_ION)) {
+        if (hnd->flags & private_handle_t::PRIV_FLAGS_USES_ION) {
                 gralloc_unmap(module, hnd);
         } else {
             ALOGE("terminateBuffer: unmapping a non pmem/ashmem buffer flags = 0x%x",
diff --git a/libgralloc/memalloc.h b/libgralloc/memalloc.h
index 2bc1ddf..598d983 100644
--- a/libgralloc/memalloc.h
+++ b/libgralloc/memalloc.h
@@ -49,6 +49,7 @@
     uintptr_t      pHandle;
     bool           uncached;
     unsigned int   flags;
+    unsigned int   heapId;
     int            allocType;
 };
 
diff --git a/libhwcomposer/hwc_copybit.cpp b/libhwcomposer/hwc_copybit.cpp
index 744195f..d4bcc88 100644
--- a/libhwcomposer/hwc_copybit.cpp
+++ b/libhwcomposer/hwc_copybit.cpp
@@ -979,7 +979,7 @@
 
        ALOGD("%s:%d::tmp_w = %d,tmp_h = %d",__FUNCTION__,__LINE__,tmp_w,tmp_h);
 
-       int usage = GRALLOC_USAGE_PRIVATE_IOMMU_HEAP;
+       int usage = 0;
        int format = fbHandle->format;
 
        // We do not want copybit to generate alpha values from nothing
@@ -1145,8 +1145,7 @@
     for (int i = 0; i < NUM_RENDER_BUFFERS; i++) {
         if (mRenderBuffer[i] == NULL) {
             ret = alloc_buffer(&mRenderBuffer[i],
-                               w, h, f,
-                               GRALLOC_USAGE_PRIVATE_IOMMU_HEAP);
+                               w, h, f, 0);
         }
         if(ret < 0) {
             freeRenderBuffers();
diff --git a/liboverlay/overlayMem.h b/liboverlay/overlayMem.h
index f0a1922..abdd402 100644
--- a/liboverlay/overlayMem.h
+++ b/liboverlay/overlayMem.h
@@ -121,7 +121,7 @@
         uint32_t bufSz, bool isSecure)
 {
     alloc_data data;
-    int allocFlags = GRALLOC_USAGE_PRIVATE_IOMMU_HEAP;
+    int allocFlags = 0;
     int err = 0;
     OVASSERT(numbufs && bufSz, "numbufs=%d bufSz=%d", numbufs, bufSz);
     mBufSz = bufSz;