static enum bp_result bios_parser_enable_lvtma_control(
        struct dc_bios *dcb,
        uint8_t uc_pwr_on,
-       uint8_t panel_instance,
+       uint8_t pwrseq_instance,
        uint8_t bypass_panel_control_wait)
 {
        struct bios_parser *bp = BP_FROM_DCB(dcb);
        if (!bp->cmd_tbl.enable_lvtma_control)
                return BP_RESULT_FAILURE;
 
-       return bp->cmd_tbl.enable_lvtma_control(bp, uc_pwr_on, panel_instance, bypass_panel_control_wait);
+       return bp->cmd_tbl.enable_lvtma_control(bp, uc_pwr_on, pwrseq_instance, bypass_panel_control_wait);
 }
 
 static bool bios_parser_is_accelerated_mode(
 
 static enum bp_result enable_lvtma_control(
        struct bios_parser *bp,
        uint8_t uc_pwr_on,
-       uint8_t panel_instance,
+       uint8_t pwrseq_instance,
        uint8_t bypass_panel_control_wait);
 
 static void init_enable_lvtma_control(struct bios_parser *bp)
 static void enable_lvtma_control_dmcub(
        struct dc_dmub_srv *dmcub,
        uint8_t uc_pwr_on,
-       uint8_t panel_instance,
+       uint8_t pwrseq_instance,
        uint8_t bypass_panel_control_wait)
 {
 
                        DMUB_CMD__VBIOS_LVTMA_CONTROL;
        cmd.lvtma_control.data.uc_pwr_action =
                        uc_pwr_on;
-       cmd.lvtma_control.data.panel_inst =
-                       panel_instance;
+       cmd.lvtma_control.data.pwrseq_inst =
+                       pwrseq_instance;
        cmd.lvtma_control.data.bypass_panel_control_wait =
                        bypass_panel_control_wait;
        dm_execute_dmub_cmd(dmcub->ctx, &cmd, DM_DMUB_WAIT_TYPE_WAIT);
 static enum bp_result enable_lvtma_control(
        struct bios_parser *bp,
        uint8_t uc_pwr_on,
-       uint8_t panel_instance,
+       uint8_t pwrseq_instance,
        uint8_t bypass_panel_control_wait)
 {
        enum bp_result result = BP_RESULT_FAILURE;
            bp->base.ctx->dc->debug.dmub_command_table) {
                enable_lvtma_control_dmcub(bp->base.ctx->dmub_srv,
                                uc_pwr_on,
-                               panel_instance,
+                               pwrseq_instance,
                                bypass_panel_control_wait);
                return BP_RESULT_OK;
        }
 
                        struct bios_parser *bp, uint8_t id);
        enum bp_result (*enable_lvtma_control)(struct bios_parser *bp,
                        uint8_t uc_pwr_on,
-                       uint8_t panel_instance,
+                       uint8_t pwrseq_instance,
                        uint8_t bypass_panel_control_wait);
 };
 
 
        enum bp_result (*enable_lvtma_control)(
                struct dc_bios *bios,
                uint8_t uc_pwr_on,
-               uint8_t panel_instance,
+               uint8_t pwrseq_instance,
                uint8_t bypass_panel_control_wait);
 
        enum bp_result (*get_soc_bb_info)(
 
        return ret;
 }
 
-static bool dmub_abm_set_pipe_ex(struct abm *abm, uint32_t otg_inst, uint32_t option, uint32_t panel_inst)
+static bool dmub_abm_set_pipe_ex(struct abm *abm,
+               uint32_t otg_inst,
+               uint32_t option,
+               uint32_t panel_inst,
+               uint32_t pwrseq_inst)
 {
        bool ret = false;
        unsigned int feature_support;
        feature_support = abm_feature_support(abm, panel_inst);
 
        if (feature_support == ABM_LCD_SUPPORT)
-               ret = dmub_abm_set_pipe(abm, otg_inst, option, panel_inst);
+               ret = dmub_abm_set_pipe(abm, otg_inst, option, panel_inst, pwrseq_inst);
 
        return ret;
 }
 
        return true;
 }
 
-bool dmub_abm_set_pipe(struct abm *abm, uint32_t otg_inst, uint32_t option, uint32_t panel_inst)
+bool dmub_abm_set_pipe(struct abm *abm,
+               uint32_t otg_inst,
+               uint32_t option,
+               uint32_t panel_inst,
+               uint32_t pwrseq_inst)
 {
        union dmub_rb_cmd cmd;
        struct dc_context *dc = abm->ctx;
        cmd.abm_set_pipe.header.type = DMUB_CMD__ABM;
        cmd.abm_set_pipe.header.sub_type = DMUB_CMD__ABM_SET_PIPE;
        cmd.abm_set_pipe.abm_set_pipe_data.otg_inst = otg_inst;
+       cmd.abm_set_pipe.abm_set_pipe_data.pwrseq_inst = pwrseq_inst;
        cmd.abm_set_pipe.abm_set_pipe_data.set_pipe_option = option;
        cmd.abm_set_pipe.abm_set_pipe_data.panel_inst = panel_inst;
        cmd.abm_set_pipe.abm_set_pipe_data.ramping_boundary = ramping_boundary;
 
                struct dc_context *dc,
                unsigned int panel_inst,
                struct abm_save_restore *pData);
-bool dmub_abm_set_pipe(struct abm *abm, uint32_t otg_inst, uint32_t option, uint32_t panel_inst);
+bool dmub_abm_set_pipe(struct abm *abm, uint32_t otg_inst, uint32_t option, uint32_t panel_inst, uint32_t pwrseq_inst);
 bool dmub_abm_set_backlight_level(struct abm *abm,
                unsigned int backlight_pwm_u16_16,
                unsigned int frame_ramp,
 
        cmd->panel_cntl.header.type = DMUB_CMD__PANEL_CNTL;
        cmd->panel_cntl.header.sub_type = DMUB_CMD__PANEL_CNTL_QUERY_BACKLIGHT_INFO;
        cmd->panel_cntl.header.payload_bytes = sizeof(cmd->panel_cntl.data);
-       cmd->panel_cntl.data.inst = dcn31_panel_cntl->base.inst;
+       cmd->panel_cntl.data.pwrseq_inst = dcn31_panel_cntl->base.pwrseq_inst;
 
        return dm_execute_dmub_cmd(dc_dmub_srv->ctx, cmd, DM_DMUB_WAIT_TYPE_WAIT_WITH_REPLY);
 }
        cmd.panel_cntl.header.type = DMUB_CMD__PANEL_CNTL;
        cmd.panel_cntl.header.sub_type = DMUB_CMD__PANEL_CNTL_HW_INIT;
        cmd.panel_cntl.header.payload_bytes = sizeof(cmd.panel_cntl.data);
-       cmd.panel_cntl.data.inst = dcn31_panel_cntl->base.inst;
+       cmd.panel_cntl.data.pwrseq_inst = dcn31_panel_cntl->base.pwrseq_inst;
        cmd.panel_cntl.data.bl_pwm_cntl = panel_cntl->stored_backlight_registers.BL_PWM_CNTL;
        cmd.panel_cntl.data.bl_pwm_period_cntl = panel_cntl->stored_backlight_registers.BL_PWM_PERIOD_CNTL;
        cmd.panel_cntl.data.bl_pwm_ref_div1 =
        dcn31_panel_cntl->base.funcs = &dcn31_link_panel_cntl_funcs;
        dcn31_panel_cntl->base.ctx = init_data->ctx;
        dcn31_panel_cntl->base.inst = init_data->inst;
+       dcn31_panel_cntl->base.pwrseq_inst = init_data->pwrseq_inst;
 }
 
        struct dc_context *ctx = link->ctx;
        struct bp_transmitter_control cntl = { 0 };
        enum bp_result bp_result;
-       uint8_t panel_instance;
+       uint8_t pwrseq_instance;
 
 
        if (dal_graphics_object_id_get_connector_id(link->link_enc->connector)
                cntl.coherent = false;
                cntl.lanes_number = LANE_COUNT_FOUR;
                cntl.hpd_sel = link->link_enc->hpd_source;
-               panel_instance = link->panel_cntl->inst;
+               pwrseq_instance = link->panel_cntl->pwrseq_inst;
 
                if (ctx->dc->ctx->dmub_srv &&
                                ctx->dc->debug.dmub_command_table) {
                        if (cntl.action == TRANSMITTER_CONTROL_POWER_ON) {
                                bp_result = ctx->dc_bios->funcs->enable_lvtma_control(ctx->dc_bios,
                                                LVTMA_CONTROL_POWER_ON,
-                                               panel_instance, link->link_powered_externally);
+                                               pwrseq_instance, link->link_powered_externally);
                        } else {
                                bp_result = ctx->dc_bios->funcs->enable_lvtma_control(ctx->dc_bios,
                                                LVTMA_CONTROL_POWER_OFF,
-                                               panel_instance, link->link_powered_externally);
+                                               pwrseq_instance, link->link_powered_externally);
                        }
                }
 
 {
        struct dc_context *ctx = link->ctx;
        struct bp_transmitter_control cntl = { 0 };
-       uint8_t panel_instance;
+       uint8_t pwrseq_instance;
        unsigned int pre_T11_delay = OLED_PRE_T11_DELAY;
        unsigned int post_T7_delay = OLED_POST_T7_DELAY;
 
         */
        /* dc_service_sleep_in_milliseconds(50); */
                /*edp 1.2*/
-       panel_instance = link->panel_cntl->inst;
+       pwrseq_instance = link->panel_cntl->pwrseq_inst;
 
        if (cntl.action == TRANSMITTER_CONTROL_BACKLIGHT_ON) {
                if (!link->dc->config.edp_no_power_sequencing)
                if (cntl.action == TRANSMITTER_CONTROL_BACKLIGHT_ON)
                        ctx->dc_bios->funcs->enable_lvtma_control(ctx->dc_bios,
                                        LVTMA_CONTROL_LCD_BLON,
-                                       panel_instance, link->link_powered_externally);
+                                       pwrseq_instance, link->link_powered_externally);
                else
                        ctx->dc_bios->funcs->enable_lvtma_control(ctx->dc_bios,
                                        LVTMA_CONTROL_LCD_BLOFF,
-                                       panel_instance, link->link_powered_externally);
+                                       pwrseq_instance, link->link_powered_externally);
        }
 
        link_transmitter_control(ctx->dc_bios, &cntl);
 
        pipe_ctx->stream->dpms_off = true;
 }
 
-static bool dmub_abm_set_pipe(struct abm *abm, uint32_t otg_inst, uint32_t option, uint32_t panel_inst)
+static bool dmub_abm_set_pipe(struct abm *abm, uint32_t otg_inst,
+               uint32_t option, uint32_t panel_inst, uint32_t pwrseq_inst)
 {
        union dmub_rb_cmd cmd;
        struct dc_context *dc = abm->ctx;
        cmd.abm_set_pipe.header.type = DMUB_CMD__ABM;
        cmd.abm_set_pipe.header.sub_type = DMUB_CMD__ABM_SET_PIPE;
        cmd.abm_set_pipe.abm_set_pipe_data.otg_inst = otg_inst;
+       cmd.abm_set_pipe.abm_set_pipe_data.pwrseq_inst = pwrseq_inst;
        cmd.abm_set_pipe.abm_set_pipe_data.set_pipe_option = option;
        cmd.abm_set_pipe.abm_set_pipe_data.panel_inst = panel_inst;
        cmd.abm_set_pipe.abm_set_pipe_data.ramping_boundary = ramping_boundary;
        struct abm *abm = pipe_ctx->stream_res.abm;
        uint32_t otg_inst = pipe_ctx->stream_res.tg->inst;
        struct panel_cntl *panel_cntl = pipe_ctx->stream->link->panel_cntl;
-
        struct dmcu *dmcu = pipe_ctx->stream->ctx->dc->res_pool->dmcu;
 
        if (dmcu) {
        if (abm && panel_cntl) {
                if (abm->funcs && abm->funcs->set_pipe_ex) {
                        abm->funcs->set_pipe_ex(abm, otg_inst, SET_ABM_PIPE_IMMEDIATELY_DISABLE,
-                       panel_cntl->inst);
+                                       panel_cntl->inst, panel_cntl->pwrseq_inst);
                } else {
-                       dmub_abm_set_pipe(abm, otg_inst, SET_ABM_PIPE_IMMEDIATELY_DISABLE, panel_cntl->inst);
+                               dmub_abm_set_pipe(abm,
+                                               otg_inst,
+                                               SET_ABM_PIPE_IMMEDIATELY_DISABLE,
+                                               panel_cntl->inst,
+                                               panel_cntl->pwrseq_inst);
                }
                panel_cntl->funcs->store_backlight_level(panel_cntl);
        }
 
        if (abm && panel_cntl) {
                if (abm->funcs && abm->funcs->set_pipe_ex) {
-                       abm->funcs->set_pipe_ex(abm, otg_inst, SET_ABM_PIPE_NORMAL, panel_cntl->inst);
+                       abm->funcs->set_pipe_ex(abm,
+                                       otg_inst,
+                                       SET_ABM_PIPE_NORMAL,
+                                       panel_cntl->inst,
+                                       panel_cntl->pwrseq_inst);
                } else {
-                       dmub_abm_set_pipe(abm, otg_inst, SET_ABM_PIPE_NORMAL, panel_cntl->inst);
+                               dmub_abm_set_pipe(abm, otg_inst,
+                                               SET_ABM_PIPE_NORMAL,
+                                               panel_cntl->inst,
+                                               panel_cntl->pwrseq_inst);
                }
        }
 }
 
                if (abm && panel_cntl) {
                        if (abm->funcs && abm->funcs->set_pipe_ex) {
-                               abm->funcs->set_pipe_ex(abm, otg_inst, SET_ABM_PIPE_NORMAL, panel_cntl->inst);
+                               abm->funcs->set_pipe_ex(abm,
+                                               otg_inst,
+                                               SET_ABM_PIPE_NORMAL,
+                                               panel_cntl->inst,
+                                               panel_cntl->pwrseq_inst);
                        } else {
-                               dmub_abm_set_pipe(abm, otg_inst, SET_ABM_PIPE_NORMAL, panel_cntl->inst);
+                                       dmub_abm_set_pipe(abm,
+                                                       otg_inst,
+                                                       SET_ABM_PIPE_NORMAL,
+                                                       panel_cntl->inst,
+                                                       panel_cntl->pwrseq_inst);
                        }
                }
        }
 
        bool (*set_pipe_ex)(struct abm *abm,
                        unsigned int otg_inst,
                        unsigned int option,
-                       unsigned int panel_inst);
+                       unsigned int panel_inst,
+                       unsigned int pwrseq_inst);
 };
 
 #endif
 
 struct panel_cntl_init_data {
        struct dc_context *ctx;
        uint32_t inst;
+       uint32_t pwrseq_inst;
 };
 
 struct panel_cntl {
        const struct panel_cntl_funcs *funcs;
        struct dc_context *ctx;
        uint32_t inst;
+       uint32_t pwrseq_inst;
        /* registers setting needs to be saved and restored at InitBacklight */
        struct panel_cntl_backlight_registers stored_backlight_registers;
 };
 
        }
 }
 
+static uint8_t translate_dig_inst_to_pwrseq_inst(struct dc_link *link)
+{
+       uint8_t pwrseq_inst = 0xF;
+       struct dc_context *dc_ctx = link->dc->ctx;
+
+       DC_LOGGER_INIT(dc_ctx->logger);
+
+       switch (link->eng_id) {
+       case ENGINE_ID_DIGA:
+               pwrseq_inst = 0;
+               break;
+       case ENGINE_ID_DIGB:
+               pwrseq_inst = 1;
+               break;
+       default:
+               DC_LOG_WARNING("Unsupported pwrseq engine id: %d!\n", link->eng_id);
+               ASSERT(false);
+               break;
+       }
+
+       return pwrseq_inst;
+}
+
+
 static void link_destruct(struct dc_link *link)
 {
        int i;
        link->ddc_hw_inst =
                dal_ddc_get_line(get_ddc_pin(link->ddc));
 
-
-       if (link->dc->res_pool->funcs->panel_cntl_create &&
-               (link->link_id.id == CONNECTOR_ID_EDP ||
-                       link->link_id.id == CONNECTOR_ID_LVDS)) {
-               panel_cntl_init_data.ctx = dc_ctx;
-               panel_cntl_init_data.inst =
-                       panel_cntl_init_data.ctx->dc_edp_id_count;
-               link->panel_cntl =
-                       link->dc->res_pool->funcs->panel_cntl_create(
-                                                               &panel_cntl_init_data);
-               panel_cntl_init_data.ctx->dc_edp_id_count++;
-
-               if (link->panel_cntl == NULL) {
-                       DC_ERROR("Failed to create link panel_cntl!\n");
-                       goto panel_cntl_create_fail;
-               }
-       }
-
        enc_init_data.ctx = dc_ctx;
        bp_funcs->get_src_obj(dc_ctx->dc_bios, link->link_id, 0,
                              &enc_init_data.encoder);
        link->dc->res_pool->dig_link_enc_count++;
 
        link->link_enc_hw_inst = link->link_enc->transmitter;
+
+       if (link->dc->res_pool->funcs->panel_cntl_create &&
+               (link->link_id.id == CONNECTOR_ID_EDP ||
+                       link->link_id.id == CONNECTOR_ID_LVDS)) {
+               panel_cntl_init_data.ctx = dc_ctx;
+               panel_cntl_init_data.inst = panel_cntl_init_data.ctx->dc_edp_id_count;
+               panel_cntl_init_data.pwrseq_inst = translate_dig_inst_to_pwrseq_inst(link);
+               link->panel_cntl =
+                       link->dc->res_pool->funcs->panel_cntl_create(
+                                                               &panel_cntl_init_data);
+               panel_cntl_init_data.ctx->dc_edp_id_count++;
+
+               if (link->panel_cntl == NULL) {
+                       DC_ERROR("Failed to create link panel_cntl!\n");
+                       goto panel_cntl_create_fail;
+               }
+       }
        for (i = 0; i < 4; i++) {
                if (bp_funcs->get_device_tag(dc_ctx->dc_bios,
                                             link->link_id, i,
 
         * TODO: Remove.
         */
        uint8_t ramping_boundary;
+
+       /**
+        * PwrSeq HW Instance.
+        */
+       uint8_t pwrseq_inst;
+
+       /**
+        * Explicit padding to 4 byte boundary.
+        */
+       uint8_t pad[3];
 };
 
 /**
  * struct dmub_cmd_panel_cntl_data - Panel control data.
  */
 struct dmub_cmd_panel_cntl_data {
-       uint32_t inst; /**< panel instance */
+       uint32_t pwrseq_inst; /**< pwrseq instance */
        uint32_t current_backlight; /* in/out */
        uint32_t bl_pwm_cntl; /* in/out */
        uint32_t bl_pwm_period_cntl; /* in/out */
        uint8_t uc_pwr_action; /**< LVTMA_ACTION */
        uint8_t bypass_panel_control_wait;
        uint8_t reserved_0[2]; /**< For future use */
-       uint8_t panel_inst; /**< LVTMA control instance */
+       uint8_t pwrseq_inst; /**< LVTMA control instance */
        uint8_t reserved_1[3]; /**< For future use */
 };