diff --git a/libexternal/external.cpp b/libexternal/external.cpp
index 0a1335a..b0dbf2e 100644
--- a/libexternal/external.cpp
+++ b/libexternal/external.cpp
@@ -651,6 +651,8 @@
             (int)mHwcContext->dpyAttr[HWC_DISPLAY_EXTERNAL].xres;
         mHwcContext->mViewFrame[HWC_DISPLAY_EXTERNAL].bottom =
             (int)mHwcContext->dpyAttr[HWC_DISPLAY_EXTERNAL].yres;
+        mHwcContext->dpyAttr[HWC_DISPLAY_EXTERNAL].refreshRate = fps;
+        mHwcContext->dpyAttr[HWC_DISPLAY_EXTERNAL].dynRefreshRate = fps;
         mHwcContext->dpyAttr[HWC_DISPLAY_EXTERNAL].vsync_period =
                 (int) 1000000000l / fps;
     }
diff --git a/libhwcomposer/Android.mk b/libhwcomposer/Android.mk
index c8229a8..8e3fc8e 100644
--- a/libhwcomposer/Android.mk
+++ b/libhwcomposer/Android.mk
@@ -18,6 +18,11 @@
 endif #TARGET_USES_QCOM_BSP
 
 LOCAL_CFLAGS                  := $(common_flags) -DLOG_TAG=\"qdhwcomposer\"
+#Enable Dynamic FPS if PHASE_OFFSET is not set
+ifeq ($(VSYNC_EVENT_PHASE_OFFSET_NS),)
+    LOCAL_CFLAGS += -DDYNAMIC_FPS
+endif
+
 LOCAL_ADDITIONAL_DEPENDENCIES := $(common_deps)
 LOCAL_SRC_FILES               := hwc.cpp          \
                                  hwc_utils.cpp    \
diff --git a/libhwcomposer/hwc.cpp b/libhwcomposer/hwc.cpp
index 6f4f9c6..099a82e 100644
--- a/libhwcomposer/hwc.cpp
+++ b/libhwcomposer/hwc.cpp
@@ -792,6 +792,8 @@
     dumpsys_log(aBuf, "Qualcomm HWC state:\n");
     dumpsys_log(aBuf, "  MDPVersion=%d\n", ctx->mMDP.version);
     dumpsys_log(aBuf, "  DisplayPanel=%c\n", ctx->mMDP.panel);
+    dumpsys_log(aBuf, "  DynRefreshRate=%d\n",
+                ctx->dpyAttr[HWC_DISPLAY_PRIMARY].dynRefreshRate);
     for(int dpy = 0; dpy < HWC_NUM_DISPLAY_TYPES; dpy++) {
         if(ctx->mMDPComp[dpy])
             ctx->mMDPComp[dpy]->dump(aBuf, ctx);
diff --git a/libhwcomposer/hwc_mdpcomp.cpp b/libhwcomposer/hwc_mdpcomp.cpp
index b222d32..552beae 100644
--- a/libhwcomposer/hwc_mdpcomp.cpp
+++ b/libhwcomposer/hwc_mdpcomp.cpp
@@ -1063,7 +1063,7 @@
 
     int numAppLayers = ctx->listStats[mDpy].numAppLayers;
     mCurrentFrame.reset(numAppLayers);
-    updateLayerCache(ctx, list);
+    updateLayerCache(ctx, list, mCurrentFrame);
 
     //If an MDP marked layer is unsupported cannot do partial MDP Comp
     for(int i = 0; i < numAppLayers; i++) {
@@ -1078,7 +1078,7 @@
         }
     }
 
-    updateYUV(ctx, list, false /*secure only*/);
+    updateYUV(ctx, list, false /*secure only*/, mCurrentFrame);
     /* mark secure RGB layers for MDP comp */
     updateSecureRGB(ctx, list);
     bool ret = markLayersForCaching(ctx, list); //sets up fbZ also
@@ -1238,7 +1238,7 @@
 
     mCurrentFrame.reset(numAppLayers);
     mCurrentFrame.fbCount -= mCurrentFrame.dropCount;
-    updateYUV(ctx, list, secureOnly);
+    updateYUV(ctx, list, secureOnly, mCurrentFrame);
     int mdpCount = mCurrentFrame.mdpCount;
 
     if(!isYuvPresent(ctx, mDpy) or (mdpCount == 0)) {
@@ -1297,7 +1297,7 @@
     mCurrentFrame.reset(numAppLayers);
     mCurrentFrame.fbCount -= mCurrentFrame.dropCount;
 
-    updateYUV(ctx, list, secureOnly);
+    updateYUV(ctx, list, secureOnly, mCurrentFrame);
     /* mark secure RGB layers for MDP comp */
     updateSecureRGB(ctx, list);
 
@@ -1548,56 +1548,53 @@
 }
 
 void MDPComp::updateLayerCache(hwc_context_t* ctx,
-        hwc_display_contents_1_t* list) {
+        hwc_display_contents_1_t* list, FrameInfo& frame) {
     int numAppLayers = ctx->listStats[mDpy].numAppLayers;
     int fbCount = 0;
 
     for(int i = 0; i < numAppLayers; i++) {
         if (mCachedFrame.hnd[i] == list->hwLayers[i].handle) {
-            if(!mCurrentFrame.drop[i])
+            if(!frame.drop[i])
                 fbCount++;
-            mCurrentFrame.isFBComposed[i] = true;
+            frame.isFBComposed[i] = true;
         } else {
-            mCurrentFrame.isFBComposed[i] = false;
+            frame.isFBComposed[i] = false;
         }
     }
 
-    mCurrentFrame.fbCount = fbCount;
-    mCurrentFrame.mdpCount = mCurrentFrame.layerCount - mCurrentFrame.fbCount
-                                                    - mCurrentFrame.dropCount;
+    frame.fbCount = fbCount;
+    frame.mdpCount = frame.layerCount - frame.fbCount
+                                            - frame.dropCount;
 
-    ALOGD_IF(isDebug(),"%s: MDP count: %d FB count %d drop count: %d"
-             ,__FUNCTION__, mCurrentFrame.mdpCount, mCurrentFrame.fbCount,
-            mCurrentFrame.dropCount);
+    ALOGD_IF(isDebug(),"%s: MDP count: %d FB count %d drop count: %d",
+            __FUNCTION__, frame.mdpCount, frame.fbCount, frame.dropCount);
 }
 
 void MDPComp::updateYUV(hwc_context_t* ctx, hwc_display_contents_1_t* list,
-        bool secureOnly) {
+        bool secureOnly, FrameInfo& frame) {
     int nYuvCount = ctx->listStats[mDpy].yuvCount;
     for(int index = 0;index < nYuvCount; index++){
         int nYuvIndex = ctx->listStats[mDpy].yuvIndices[index];
         hwc_layer_1_t* layer = &list->hwLayers[nYuvIndex];
 
         if(!isYUVDoable(ctx, layer)) {
-            if(!mCurrentFrame.isFBComposed[nYuvIndex]) {
-                mCurrentFrame.isFBComposed[nYuvIndex] = true;
-                mCurrentFrame.fbCount++;
+            if(!frame.isFBComposed[nYuvIndex]) {
+                frame.isFBComposed[nYuvIndex] = true;
+                frame.fbCount++;
             }
         } else {
-            if(mCurrentFrame.isFBComposed[nYuvIndex]) {
+            if(frame.isFBComposed[nYuvIndex]) {
                 private_handle_t *hnd = (private_handle_t *)layer->handle;
                 if(!secureOnly || isSecureBuffer(hnd)) {
-                    mCurrentFrame.isFBComposed[nYuvIndex] = false;
-                    mCurrentFrame.fbCount--;
+                    frame.isFBComposed[nYuvIndex] = false;
+                    frame.fbCount--;
                 }
             }
         }
     }
 
-    mCurrentFrame.mdpCount = mCurrentFrame.layerCount -
-            mCurrentFrame.fbCount - mCurrentFrame.dropCount;
-    ALOGD_IF(isDebug(),"%s: fb count: %d",__FUNCTION__,
-             mCurrentFrame.fbCount);
+    frame.mdpCount = frame.layerCount - frame.fbCount - frame.dropCount;
+    ALOGD_IF(isDebug(),"%s: fb count: %d",__FUNCTION__, frame.fbCount);
 }
 
 void MDPComp::updateSecureRGB(hwc_context_t* ctx,
@@ -1878,6 +1875,26 @@
         ALOGD("%s",sDump.string());
     }
 
+#ifdef DYNAMIC_FPS
+    //For primary display, set the dynamic refreshrate
+    if(!mDpy && qdutils::MDPVersion::getInstance().isDynFpsSupported()) {
+        FrameInfo frame;
+        frame.reset(mCurrentFrame.layerCount);
+        ALOGD_IF(isDebug(), "%s: Update Cache and YUVInfo for Dyn Refresh Rate",
+                 __FUNCTION__);
+        updateLayerCache(ctx, list, frame);
+        updateYUV(ctx, list, false /*secure only*/, frame);
+        uint32_t refreshRate = ctx->dpyAttr[mDpy].refreshRate;
+        //Set the new fresh rate, if there is only one updating YUV layer
+        //or there is one single RGB layer with this request
+        if((ctx->listStats[mDpy].yuvCount == frame.mdpCount) ||
+                                (frame.layerCount == 1)) {
+            refreshRate = ctx->listStats[mDpy].refreshRateRequest;
+        }
+        setRefreshRate(ctx, mDpy, refreshRate);
+    }
+#endif
+
     mCachedFrame.cacheAll(list);
     mCachedFrame.updateCounts(mCurrentFrame);
     return ret;
diff --git a/libhwcomposer/hwc_mdpcomp.h b/libhwcomposer/hwc_mdpcomp.h
index 8c833c2..e43c4f4 100644
--- a/libhwcomposer/hwc_mdpcomp.h
+++ b/libhwcomposer/hwc_mdpcomp.h
@@ -209,7 +209,8 @@
     /* checks for mdp comp dimension limitation */
     bool isValidDimension(hwc_context_t *ctx, hwc_layer_1_t *layer);
     /* tracks non updating layers*/
-    void updateLayerCache(hwc_context_t* ctx, hwc_display_contents_1_t* list);
+    void updateLayerCache(hwc_context_t* ctx, hwc_display_contents_1_t* list,
+                          FrameInfo& frame);
     /* optimize layers for mdp comp*/
     bool markLayersForCaching(hwc_context_t* ctx,
             hwc_display_contents_1_t* list);
@@ -223,7 +224,7 @@
 
         /* updates cache map with YUV info */
     void updateYUV(hwc_context_t* ctx, hwc_display_contents_1_t* list,
-            bool secureOnly);
+            bool secureOnly, FrameInfo& frame);
     /* updates cache map with secure RGB info */
     void updateSecureRGB(hwc_context_t* ctx,
             hwc_display_contents_1_t* list);
diff --git a/libhwcomposer/hwc_utils.cpp b/libhwcomposer/hwc_utils.cpp
index b339cb7..d0b3567 100644
--- a/libhwcomposer/hwc_utils.cpp
+++ b/libhwcomposer/hwc_utils.cpp
@@ -75,6 +75,9 @@
 
 namespace qhwc {
 
+//Std refresh rates for digital videos- 24p, 30p and 48p
+uint32_t stdRefreshRates[] = { 30, 24, 48 };
+
 bool isValidResolution(hwc_context_t *ctx, uint32_t xres, uint32_t yres)
 {
     return !((xres > qdutils::MDPVersion::getInstance().getMaxMixerWidth() &&
@@ -170,6 +173,8 @@
     ctx->dpyAttr[HWC_DISPLAY_PRIMARY].yres = info.yres;
     ctx->dpyAttr[HWC_DISPLAY_PRIMARY].xdpi = xdpi;
     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].vsync_period =
             (uint32_t)(1000000000l / fps);
 
@@ -362,6 +367,50 @@
 
 }
 
+//Helper to roundoff the refreshrates
+static uint32_t roundOff(uint32_t refreshRate) {
+    int count =  (int) (sizeof(stdRefreshRates)/sizeof(stdRefreshRates[0]));
+    uint32_t rate = refreshRate;
+    for(int i=0; i< count; i++) {
+        if(abs(stdRefreshRates[i] - refreshRate) < 2) {
+            // Most likely used for video, the fps can fluctuate
+            // Ex: b/w 29 and 30 for 30 fps clip
+            rate = stdRefreshRates[i];
+            break;
+        }
+    }
+    return rate;
+}
+
+//Helper func to set the dyn fps
+void setRefreshRate(hwc_context_t* ctx, int dpy, uint32_t refreshRate) {
+    //Update only if different
+    if(!ctx || refreshRate == ctx->dpyAttr[dpy].dynRefreshRate)
+        return;
+    const int fbNum = Overlay::getFbForDpy(dpy);
+    char sysfsPath[qdutils::MAX_SYSFS_FILE_PATH];
+    snprintf (sysfsPath, sizeof(sysfsPath),
+            "/sys/class/graphics/fb%d/dynamic_fps", fbNum);
+
+    int fd = open(sysfsPath, O_WRONLY);
+    if(fd >= 0) {
+        char str[64];
+        snprintf(str, sizeof(str), "%d", refreshRate);
+        ssize_t ret = write(fd, str, strlen(str));
+        if(ret < 0) {
+            ALOGE("%s: Failed to write %d with error %s",
+                    __FUNCTION__, refreshRate, strerror(errno));
+        } else {
+            ctx->dpyAttr[dpy].dynRefreshRate = refreshRate;
+            ALOGD_IF(HWC_UTILS_DEBUG, "%s: Wrote %d to dynamic_fps",
+                     __FUNCTION__, refreshRate);
+        }
+        close(fd);
+    } else {
+        ALOGE("%s: Failed to open %s with error %s", __FUNCTION__, sysfsPath,
+              strerror(errno));
+    }
+}
 
 void dumpsys_log(android::String8& buf, const char* fmt, ...)
 {
@@ -829,6 +878,9 @@
     ctx->dpyAttr[dpy].mActionSafePresent = isActionSafePresent(ctx, dpy);
     ctx->listStats[dpy].renderBufIndexforABC = -1;
     ctx->listStats[dpy].secureRGBCount = 0;
+    ctx->listStats[dpy].refreshRateRequest = ctx->dpyAttr[dpy].refreshRate;
+    uint32_t refreshRate = 0;
+    qdutils::MDPVersion& mdpHw = qdutils::MDPVersion::getInstance();
 
     resetROI(ctx, dpy);
 
@@ -882,6 +934,27 @@
         if(layer->blending == HWC_BLENDING_PREMULT)
             ctx->listStats[dpy].preMultipliedAlpha = true;
 
+#ifdef DYNAMIC_FPS
+        if (dpy == HWC_DISPLAY_PRIMARY && mdpHw.isDynFpsSupported()) {
+            //dyn fps: get refreshrate from metadata
+            //Support multiple refresh rates if they are same
+            //else set to  default
+            MetaData_t *mdata = hnd ? (MetaData_t *)hnd->base_metadata : NULL;
+            if (mdata && (mdata->operation & UPDATE_REFRESH_RATE)) {
+                // Valid refreshRate in metadata and within the range
+                uint32_t rate = roundOff(mdata->refreshrate);
+                if((rate >= mdpHw.getMinFpsSupported() &&
+                                rate <= mdpHw.getMaxFpsSupported())) {
+                    if (!refreshRate) {
+                        refreshRate = rate;
+                    } else if(refreshRate != rate) {
+                        // multiple refreshrate requests, set to default
+                        refreshRate = ctx->dpyAttr[dpy].refreshRate;
+                    }
+                }
+            }
+        }
+#endif
     }
     if(ctx->listStats[dpy].yuvCount > 0) {
         if (property_get("hw.cabl.yuv", property, NULL) > 0) {
@@ -905,6 +978,9 @@
 
     if(dpy == HWC_DISPLAY_PRIMARY) {
         ctx->mAD->markDoable(ctx, list);
+        //Store the requested fresh rate
+        ctx->listStats[dpy].refreshRateRequest = refreshRate ?
+                                refreshRate : ctx->dpyAttr[dpy].refreshRate;
     }
 }
 
diff --git a/libhwcomposer/hwc_utils.h b/libhwcomposer/hwc_utils.h
index 4858b3a..9d1e7c0 100644
--- a/libhwcomposer/hwc_utils.h
+++ b/libhwcomposer/hwc_utils.h
@@ -80,6 +80,8 @@
 };
 
 struct DisplayAttributes {
+    uint32_t refreshRate;
+    uint32_t dynRefreshRate;
     uint32_t vsync_period; //nanos
     uint32_t xres;
     uint32_t yres;
@@ -137,6 +139,8 @@
     // Secure RGB specific
     int secureRGBCount;
     int secureRGBIndices[MAX_NUM_APP_LAYERS];
+    //dyn refresh rate-Client requested refreshrate
+    uint32_t refreshRateRequest;
 };
 
 //PTOR Comp info
@@ -305,6 +309,8 @@
 void getAspectRatioPosition(hwc_context_t* ctx, int dpy, int extOrientation,
                                 hwc_rect_t& inRect, hwc_rect_t& outRect);
 
+void setRefreshRate(hwc_context_t *ctx, int dpy, uint32_t refreshRate);
+
 bool isPrimaryPortrait(hwc_context_t *ctx);
 
 bool isOrientationPortrait(hwc_context_t *ctx);
diff --git a/libqdutils/mdp_version.cpp b/libqdutils/mdp_version.cpp
index 575a97c..b0a8d7d 100644
--- a/libqdutils/mdp_version.cpp
+++ b/libqdutils/mdp_version.cpp
@@ -226,6 +226,19 @@
                     mPanelInfo.mNeedsROIMerge = atoi(tokens[1]);
                     ALOGI("Needs ROI Merge: %d", mPanelInfo.mNeedsROIMerge);
                 }
+                if(!strncmp(tokens[0], "dyn_fps_en", strlen("dyn_fps_en"))) {
+                    mPanelInfo.mDynFpsSupported = atoi(tokens[1]);
+                    ALOGI("Dynamic Fps: %s", mPanelInfo.mDynFpsSupported ?
+                                            "Enabled" : "Disabled");
+                }
+                if(!strncmp(tokens[0], "min_fps", strlen("min_fps"))) {
+                    mPanelInfo.mMinFps = atoi(tokens[1]);
+                    ALOGI("Min Panel fps: %d", mPanelInfo.mMinFps);
+                }
+                if(!strncmp(tokens[0], "max_fps", strlen("max_fps"))) {
+                    mPanelInfo.mMaxFps = atoi(tokens[1]);
+                    ALOGI("Max Panel fps: %d", mPanelInfo.mMaxFps);
+                }
             }
         }
         if((property_get("persist.hwc.pubypass", property, 0) > 0) &&
diff --git a/libqdutils/mdp_version.h b/libqdutils/mdp_version.h
index 1ddad70..dd1aa3d 100644
--- a/libqdutils/mdp_version.h
+++ b/libqdutils/mdp_version.h
@@ -92,9 +92,13 @@
     int mMinROIWidth;            // Min width needed for ROI
     int mMinROIHeight;           // Min height needed for ROI
     bool mNeedsROIMerge;         // Merge ROI's of both the DSI's
+    bool mDynFpsSupported;       // Panel Supports dyn fps
+    uint32_t mMinFps;            // Min fps supported by panel
+    uint32_t mMaxFps;            // Max fps supported by panel
     PanelInfo() : mType(NO_PANEL), mPartialUpdateEnable(0),
     mLeftAlign(0), mWidthAlign(0), mTopAlign(0), mHeightAlign(0),
-    mMinROIWidth(0), mMinROIHeight(0), mNeedsROIMerge(false){}
+    mMinROIWidth(0), mMinROIHeight(0), mNeedsROIMerge(false),
+    mDynFpsSupported(0), mMinFps(0), mMaxFps(0) {}
     friend class MDPVersion;
 };
 
@@ -130,6 +134,9 @@
     unsigned long getLowBw() { return mLowBw; }
     unsigned long getHighBw() { return mHighBw; }
     bool isRotDownscaleEnabled() { return mRotDownscale; }
+    bool isDynFpsSupported() { return mPanelInfo.mDynFpsSupported; }
+    uint32_t getMinFpsSupported() { return mPanelInfo.mMinFps; }
+    uint32_t getMaxFpsSupported() { return mPanelInfo.mMaxFps; }
     int getMaxMixerWidth() const { return mMaxMixerWidth; }
     bool isSrcSplit() const;
     bool isSrcSplitAlways() const;
diff --git a/libqdutils/qdMetaData.cpp b/libqdutils/qdMetaData.cpp
index dbd6f10..de94591 100644
--- a/libqdutils/qdMetaData.cpp
+++ b/libqdutils/qdMetaData.cpp
@@ -83,7 +83,10 @@
             break;
         case UPDATE_BUFFER_GEOMETRY:
             memcpy((void *)&data->bufferDim, param, sizeof(BufferDim_t));
-        break;
+            break;
+        case UPDATE_REFRESH_RATE:
+            data->refreshrate = *((uint32_t *)param);
+            break;
         case UPDATE_COLOR_SPACE:
             data->colorSpace = *((ColorSpace_t *)param);
             break;
diff --git a/libqdutils/qdMetaData.h b/libqdutils/qdMetaData.h
index 3ebe782..a71ee8b 100644
--- a/libqdutils/qdMetaData.h
+++ b/libqdutils/qdMetaData.h
@@ -77,6 +77,7 @@
     struct IGCData_t igcData;
     struct Sharp2Data_t Sharp2Data;
     int64_t timestamp;
+    uint32_t refreshrate;
     enum ColorSpace_t colorSpace;
 };
 
@@ -89,6 +90,7 @@
     PP_PARAM_SHARP2     = 0x0020,
     PP_PARAM_TIMESTAMP  = 0x0040,
     UPDATE_BUFFER_GEOMETRY = 0x0080,
+    UPDATE_REFRESH_RATE = 0x0100,
     UPDATE_COLOR_SPACE = 0x0200,
 };