properties->cursor_size_limit = subvp_in_use ? 64 : dc->caps.max_cursor_size;
 }
 
+/**
+ *****************************************************************************
+ * dc_set_edp_power() - DM controls eDP power to be ON/OFF
+ *
+ * Called when DM wants to power on/off eDP.
+ *     Only work on links with flag skip_implict_edp_power_control is set.
+ *
+ *****************************************************************************
+ */
+void dc_set_edp_power(const struct dc *dc, struct dc_link *edp_link,
+                                bool powerOn)
+{
+       if (edp_link->connector_signal != SIGNAL_TYPE_EDP)
+               return;
+
+       if (edp_link->skip_implict_edp_power_control == false)
+               return;
+
+       edp_link->dc->link_srv->edp_set_panel_power(edp_link, powerOn);
+}
+
 
        struct phy_state phy_state;
        // BW ALLOCATON USB4 ONLY
        struct dc_dpia_bw_alloc dpia_bw_alloc_config;
+       bool skip_implict_edp_power_control;
 };
 
 /* Return an enumerated dc_link.
                struct dc_link **edp_links,
                int *edp_num);
 
+void dc_set_edp_power(const struct dc *dc, struct dc_link *edp_link,
+                                bool powerOn);
+
 /* The function initiates detection handshake over the given link. It first
  * determines if there are display connections over the link. If so it initiates
  * detection protocols supported by the connected receiver device. The function
 
        bool vblank_synchronized;
        bool fpo_in_use;
        struct mall_stream_config mall_stream_config;
-       bool skip_edp_power_down;
 };
 
 #define ABM_LEVEL_IMMEDIATE_DISABLE 255
 
        struct dce_hwseq *hws = link->dc->hwseq;
 
        if (link->local_sink && link->local_sink->sink_signal == SIGNAL_TYPE_EDP) {
-               if (!stream->skip_edp_power_down)
+               if (!link->skip_implict_edp_power_control)
                        hws->funcs.edp_backlight_control(link, false);
                link->dc->hwss.set_abm_immediate_disable(pipe_ctx);
        }
 
        struct dmcu *dmcu = dc->res_pool->dmcu;
 
        if (signal == SIGNAL_TYPE_EDP &&
-                       link->dc->hwss.edp_backlight_control)
+                       link->dc->hwss.edp_backlight_control &&
+                       !link->skip_implict_edp_power_control)
                link->dc->hwss.edp_backlight_control(link, false);
        else if (dmcu != NULL && dmcu->funcs->lock_phy)
                dmcu->funcs->lock_phy(dmcu);
 
        bool (*edp_receiver_ready_T9)(struct dc_link *link);
        bool (*edp_receiver_ready_T7)(struct dc_link *link);
        bool (*edp_power_alpm_dpcd_enable)(struct dc_link *link, bool enable);
+       void (*edp_set_panel_power)(struct dc_link *link, bool powerOn);
 
 
        /*************************** DP CTS ************************************/
 
        dp_disable_link_phy(link, link_res, signal);
 
        if (link->connector_signal == SIGNAL_TYPE_EDP) {
-               if (!link->dc->config.edp_no_power_sequencing)
+               if (!link->dc->config.edp_no_power_sequencing &&
+                       !link->skip_implict_edp_power_control)
                        link->dc->hwss.edp_power_control(link, false);
        }
 
         * link settings. Need to call disable first before enabling at
         * new link settings.
         */
-       if (link->link_status.link_active && !stream->skip_edp_power_down)
+       if (link->link_status.link_active)
                disable_link(link, &pipe_ctx->link_res, pipe_ctx->stream->signal);
 
        switch (pipe_ctx->stream->signal) {
                dc->hwss.disable_stream(pipe_ctx);
        } else {
                dc->hwss.disable_stream(pipe_ctx);
-               if (!pipe_ctx->stream->skip_edp_power_down) {
-                       disable_link(pipe_ctx->stream->link, &pipe_ctx->link_res, pipe_ctx->stream->signal);
-               }
+               disable_link(pipe_ctx->stream->link, &pipe_ctx->link_res, pipe_ctx->stream->signal);
        }
 
        if (pipe_ctx->stream->timing.flags.DSC) {
 
        link_srv->edp_receiver_ready_T9 = edp_receiver_ready_T9;
        link_srv->edp_receiver_ready_T7 = edp_receiver_ready_T7;
        link_srv->edp_power_alpm_dpcd_enable = edp_power_alpm_dpcd_enable;
+       link_srv->edp_set_panel_power = edp_set_panel_power;
 }
 
 /* link dp cts implements dp compliance test automation protocols and manual
 
 {
        struct dc  *dc = link->ctx->dc;
 
-       if (!link->wa_flags.dp_keep_receiver_powered)
+       if (!link->wa_flags.dp_keep_receiver_powered &&
+               !link->skip_implict_edp_power_control)
                dpcd_write_rx_power_ctrl(link, false);
 
        dc->hwss.disable_link_output(link, link_res, signal);
 
 #include "link_dp_capability.h"
 #include "dm_helpers.h"
 #include "dal_asic_id.h"
+#include "link_dp_phy.h"
 #include "dce/dmub_psr.h"
 #include "dc/dc_dmub_srv.h"
 #include "dce/dmub_replay.h"
                link->dc->hwss.edp_backlight_control(link, true);
 }
 
+void edp_set_panel_power(struct dc_link *link, bool powerOn)
+{
+       if (powerOn) {
+               // 1. panel VDD on
+               if (!link->dc->config.edp_no_power_sequencing)
+                       link->dc->hwss.edp_power_control(link, true);
+               link->dc->hwss.edp_wait_for_hpd_ready(link, true);
+
+               // 2. panel BL on
+               if (link->dc->hwss.edp_backlight_control)
+                       link->dc->hwss.edp_backlight_control(link, true);
+
+               // 3. Rx power on
+               dpcd_write_rx_power_ctrl(link, true);
+       } else {
+               // 3. Rx power off
+               dpcd_write_rx_power_ctrl(link, false);
+
+               // 2. panel BL off
+               if (link->dc->hwss.edp_backlight_control)
+                       link->dc->hwss.edp_backlight_control(link, false);
+
+               // 1. panel VDD off
+               if (!link->dc->config.edp_no_power_sequencing)
+                       link->dc->hwss.edp_power_control(link, false);
+       }
+}
+
 bool edp_wait_for_t12(struct dc_link *link)
 {
        if (link->connector_signal == SIGNAL_TYPE_EDP && link->dc->hwss.edp_wait_for_T12) {
 
 bool edp_receiver_ready_T9(struct dc_link *link);
 bool edp_receiver_ready_T7(struct dc_link *link);
 bool edp_power_alpm_dpcd_enable(struct dc_link *link, bool enable);
+void edp_set_panel_power(struct dc_link *link, bool powerOn);
 #endif /* __DC_LINK_EDP_POWER_CONTROL_H__ */