int msm_dsi_host_disable(struct mipi_dsi_host *host);
 int msm_dsi_host_power_on(struct mipi_dsi_host *host,
                        struct msm_dsi_phy_shared_timings *phy_shared_timings,
-                       bool is_bonded_dsi);
+                       bool is_bonded_dsi, struct msm_dsi_phy *phy);
 int msm_dsi_host_power_off(struct mipi_dsi_host *host);
 int msm_dsi_host_set_display_mode(struct mipi_dsi_host *host,
                                  const struct drm_display_mode *mode);
 void msm_dsi_phy_pll_save_state(struct msm_dsi_phy *phy);
 int msm_dsi_phy_pll_restore_state(struct msm_dsi_phy *phy);
 void msm_dsi_phy_snapshot(struct msm_disp_state *disp_state, struct msm_dsi_phy *phy);
+bool msm_dsi_phy_set_continuous_clock(struct msm_dsi_phy *phy, bool enable);
 
 #endif /* __DSI_CONNECTOR_H__ */
 
 
 #define DSI_LANE_STATUS_DLN0_DIRECTION                         0x00010000
 
 #define REG_DSI_LANE_CTRL                                      0x000000a8
+#define DSI_LANE_CTRL_HS_REQ_SEL_PHY                           0x01000000
 #define DSI_LANE_CTRL_CLKLN_HS_FORCE_REQUEST                   0x10000000
 
 #define REG_DSI_LANE_SWAP_CTRL                                 0x000000ac
 
 }
 
 static void dsi_ctrl_config(struct msm_dsi_host *msm_host, bool enable,
-                       struct msm_dsi_phy_shared_timings *phy_shared_timings)
+                       struct msm_dsi_phy_shared_timings *phy_shared_timings, struct msm_dsi_phy *phy)
 {
        u32 flags = msm_host->mode_flags;
        enum mipi_dsi_pixel_format mipi_fmt = msm_host->format;
 
        if (!(flags & MIPI_DSI_CLOCK_NON_CONTINUOUS)) {
                lane_ctrl = dsi_read(msm_host, REG_DSI_LANE_CTRL);
+
+               if (msm_dsi_phy_set_continuous_clock(phy, enable))
+                       lane_ctrl &= ~DSI_LANE_CTRL_HS_REQ_SEL_PHY;
+
                dsi_write(msm_host, REG_DSI_LANE_CTRL,
                        lane_ctrl | DSI_LANE_CTRL_CLKLN_HS_FORCE_REQUEST);
        }
 
 int msm_dsi_host_power_on(struct mipi_dsi_host *host,
                        struct msm_dsi_phy_shared_timings *phy_shared_timings,
-                       bool is_bonded_dsi)
+                       bool is_bonded_dsi, struct msm_dsi_phy *phy)
 {
        struct msm_dsi_host *msm_host = to_msm_dsi_host(host);
        const struct msm_dsi_cfg_handler *cfg_hnd = msm_host->cfg_hnd;
 
        dsi_timing_setup(msm_host, is_bonded_dsi);
        dsi_sw_reset(msm_host);
-       dsi_ctrl_config(msm_host, true, phy_shared_timings);
+       dsi_ctrl_config(msm_host, true, phy_shared_timings, phy);
 
        if (msm_host->disp_en_gpio)
                gpiod_set_value(msm_host->disp_en_gpio, 1);
                goto unlock_ret;
        }
 
-       dsi_ctrl_config(msm_host, false, NULL);
+       dsi_ctrl_config(msm_host, false, NULL, NULL);
 
        if (msm_host->disp_en_gpio)
                gpiod_set_value(msm_host->disp_en_gpio, 0);
 
        if (ret)
                goto phy_en_fail;
 
-       ret = msm_dsi_host_power_on(host, &phy_shared_timings[id], is_bonded_dsi);
+       ret = msm_dsi_host_power_on(host, &phy_shared_timings[id], is_bonded_dsi, msm_dsi->phy);
        if (ret) {
                pr_err("%s: power on host %d failed, %d\n", __func__, id, ret);
                goto host_on_fail;
 
        if (is_bonded_dsi && msm_dsi1) {
                ret = msm_dsi_host_power_on(msm_dsi1->host,
-                               &phy_shared_timings[DSI_1], is_bonded_dsi);
+                               &phy_shared_timings[DSI_1], is_bonded_dsi, msm_dsi1->phy);
                if (ret) {
                        pr_err("%s: power on host1 failed, %d\n",
                                                        __func__, ret);
 
                phy->usecase = uc;
 }
 
+/* Returns true if we have to clear DSI_LANE_CTRL.HS_REQ_SEL_PHY */
+bool msm_dsi_phy_set_continuous_clock(struct msm_dsi_phy *phy, bool enable)
+{
+       if (!phy || !phy->cfg->ops.set_continuous_clock)
+               return false;
+
+       return phy->cfg->ops.set_continuous_clock(phy, enable);
+}
+
 int msm_dsi_phy_get_clk_provider(struct msm_dsi_phy *phy,
        struct clk **byte_clk_provider, struct clk **pixel_clk_provider)
 {
 
        void (*disable)(struct msm_dsi_phy *phy);
        void (*save_pll_state)(struct msm_dsi_phy *phy);
        int (*restore_pll_state)(struct msm_dsi_phy *phy);
+       bool (*set_continuous_clock)(struct msm_dsi_phy *phy, bool enable);
 };
 
 struct msm_dsi_phy_cfg {
 
        return 0;
 }
 
+static bool dsi_7nm_set_continuous_clock(struct msm_dsi_phy *phy, bool enable)
+{
+       void __iomem *base = phy->base;
+       u32 data;
+
+       data = dsi_phy_read(base + REG_DSI_7nm_PHY_CMN_LANE_CTRL1);
+       if (enable)
+               data |= BIT(5) | BIT(6);
+       else
+               data &= ~(BIT(5) | BIT(6));
+       dsi_phy_write(base + REG_DSI_7nm_PHY_CMN_LANE_CTRL1, data);
+
+       return enable;
+}
+
 static void dsi_7nm_phy_disable(struct msm_dsi_phy *phy)
 {
        void __iomem *base = phy->base;
                .pll_init = dsi_pll_7nm_init,
                .save_pll_state = dsi_7nm_pll_save_state,
                .restore_pll_state = dsi_7nm_pll_restore_state,
+               .set_continuous_clock = dsi_7nm_set_continuous_clock,
        },
        .min_pll_rate = 600000000UL,
 #ifdef CONFIG_64BIT
                .pll_init = dsi_pll_7nm_init,
                .save_pll_state = dsi_7nm_pll_save_state,
                .restore_pll_state = dsi_7nm_pll_restore_state,
+               .set_continuous_clock = dsi_7nm_set_continuous_clock,
        },
        .min_pll_rate = 1000000000UL,
        .max_pll_rate = 3500000000UL,