From: Tony Cheng <[email protected]>

The virtual enable and stream-off that DC1 performs sit inside HWSS
and link helpers: dcn401_enable_stream, link_set_dpms_on,
link_set_dpms_off, dcn401_prepare_bandwidth and
dcn20_wait_for_blank_complete. The DC2 executor has no leaf entry
for those calls, so a builder cannot emit them without calling DC1.

Add one block_sequence entry per call, with its params next to the
enum in hw_sequencer.h, and a DC2 case that makes that single call.
Entries the virtual path already shares with other builders keep
their enum values and params. TG_LOCK calls lock or unlock
directly; preflight rejects the DMUB-inbox1 and triple-buffer
variants because they are not leaf calls. HUBP_PG_CONTROL and
DC_IP_REQUEST_CNTL stay hwseq calls because the hwseq owns those
registers. Preflight checks the block, the function and any pointer
payload before the sequence runs.

Match DC1 when a call fails. enable_crtc, disable_crtc and
program_pix_clk stop the sequence. A blank-wait timeout and a
failed cs_power_down follow continue_on_error, because DC1 only
logs them. A clock raise whose program_watermarks or
program_arbiter reports a change sets dc->optimized_required.

DC1 never emits the new enum values, and hwss_execute_sequence is
unchanged, so the legacy commit is unaffected. The builder that
orders these entries follows in a later patch.

Cc: Jun Lei <[email protected]>
Signed-off-by: Tony Cheng <[email protected]>
Signed-off-by: Wayne Lin <[email protected]>
---
 .../display/dc/bls_executor/bls_executor.c    | 584 ++++++++++++++++++
 .../drm/amd/display/dc/hwss/hw_sequencer.h    | 192 ++++++
 2 files changed, 776 insertions(+)

diff --git a/drivers/gpu/drm/amd/display/dc/bls_executor/bls_executor.c 
b/drivers/gpu/drm/amd/display/dc/bls_executor/bls_executor.c
index 7600954c3478..5111c65fd961 100644
--- a/drivers/gpu/drm/amd/display/dc/bls_executor/bls_executor.c
+++ b/drivers/gpu/drm/amd/display/dc/bls_executor/bls_executor.c
@@ -13,8 +13,12 @@
 #include "abm.h"
 #include "audio.h"
 #include "dchubbub.h"
+#include "hubp.h"
+#include "dpp.h"
+#include "mpc.h"
 #include "dio.h"
 #include "link_encoder.h"
+#include "vpg.h"
 #include "panel_cntl.h"
 #include "link_service.h"
 #include "dc_bios_types.h"
@@ -31,6 +35,15 @@ static noinline_for_stack bool dc2_bls_step_supported(const 
struct dc2 *dc2,
        struct clk_mgr *clk_mgr;
        struct dccg *dccg;
        struct dc_context *ctx;
+       struct hubbub *hubbub;
+       struct timing_generator *tg;
+       struct output_pixel_processor *opp;
+       struct clock_source *cs;
+       struct link_encoder *link_enc;
+       struct dce_hwseq *hws;
+       struct hubp *hubp;
+       struct dpp *dpp;
+       struct mpc *mpc;
 
        switch (step->func) {
        case LEGACY_CLK_MGR_INIT_CLOCKS:
@@ -283,6 +296,197 @@ static noinline_for_stack bool 
dc2_bls_step_supported(const struct dc2 *dc2,
                return hubbub && hubbub->funcs &&
                                hubbub->funcs->force_pstate_change_control;
        }
+       case CLK_MGR_UPDATE_CLOCKS_FOR_STATE:
+               clk_mgr = step->params.clk_mgr_update_clocks_for_state_params
+                               .clk_mgr;
+               return clk_mgr && clk_mgr->funcs && 
clk_mgr->funcs->update_clocks &&
+                               
step->params.clk_mgr_update_clocks_for_state_params
+                               .context;
+       case HUBBUB_PROGRAM_WATERMARKS:
+               hubbub = step->params.hubbub_program_watermarks_params.hubbub;
+               return hubbub && hubbub->funcs &&
+                               hubbub->funcs->program_watermarks &&
+                               step->params.hubbub_program_watermarks_params
+                               .watermarks;
+       case HUBBUB_PROGRAM_ARBITER:
+               hubbub = step->params.hubbub_program_arbiter_params.hubbub;
+               return hubbub && hubbub->funcs &&
+                               hubbub->funcs->program_arbiter &&
+                               
step->params.hubbub_program_arbiter_params.arb_regs;
+       case HUBBUB_PROGRAM_COMPBUF_SEGMENTS:
+               hubbub = step->params.hubbub_program_compbuf_segments_params
+                               .hubbub;
+               return hubbub && hubbub->funcs &&
+                               hubbub->funcs->program_compbuf_segments;
+       case HUBP_PROGRAM_DET_SEGMENTS:
+               hubbub = step->params.program_det_segments_params.hubbub;
+               return hubbub && hubbub->funcs &&
+                               hubbub->funcs->program_det_segments;
+       case TG_LOCK: {
+               const struct tg_lock_params *p = &step->params.tg_lock_params;
+
+               /* DMUB inbox1 and triple-buffer locks are not leaf calls. */
+               return p->tg && p->tg->funcs && !p->use_dmub_inbox1 &&
+                               !p->triplebuffer_flips &&
+                               (p->lock ? p->tg->funcs->lock : 
p->tg->funcs->unlock);
+       }
+       case TG_ENABLE_CRTC:
+               tg = step->params.tg_enable_crtc_params.tg;
+               return tg && tg->funcs && tg->funcs->enable_crtc;
+       case TG_DISABLE_CRTC:
+               tg = step->params.tg_disable_crtc_params.tg;
+               return tg && tg->funcs && tg->funcs->disable_crtc;
+       case TG_WAIT_ODM_DOUBLEBUFFER_PENDING_CLEAR:
+               tg = 
step->params.tg_wait_odm_doublebuffer_pending_clear_params.tg;
+               return tg && tg->funcs &&
+                               tg->funcs->wait_odm_doublebuffer_pending_clear;
+       case TG_PROGRAM_STEREO:
+               tg = step->params.tg_program_stereo_params.tg;
+               return tg && tg->funcs && tg->funcs->program_stereo &&
+                               step->params.tg_program_stereo_params.timing;
+       case OPP_PROGRAM_STEREO:
+               opp = step->params.opp_program_stereo_params.opp;
+               return opp && opp->funcs && opp->funcs->opp_program_stereo &&
+                               step->params.opp_program_stereo_params.timing;
+       case TG_WAIT_FOR_STATE:
+               tg = step->params.tg_wait_for_state_params.tg;
+               return tg && tg->funcs && tg->funcs->wait_for_state;
+       case TG_SETUP_VERTICAL_INTERRUPT2:
+               tg = step->params.tg_setup_vertical_interrupt2_params.tg;
+               return tg && tg->funcs && tg->funcs->setup_vertical_interrupt2;
+       case OPTC_SET_ODM_BYPASS:
+               tg = step->params.set_odm_bypass_params.tg;
+               return tg && tg->funcs && tg->funcs->set_odm_bypass &&
+                               step->params.set_odm_bypass_params.timing;
+       case TG_ENABLE_OPTC_CLOCK:
+               tg = step->params.tg_enable_optc_clock_params.tg;
+               return tg && tg->funcs && tg->funcs->enable_optc_clock;
+       case TG_PROGRAM_TIMING:
+               tg = step->params.tg_program_timing_params.tg;
+               return tg && tg->funcs && tg->funcs->program_timing &&
+                               step->params.tg_program_timing_params.timing;
+       case TG_SET_H_TIMING_DIV_MANUAL_MODE:
+               tg = step->params.tg_set_h_timing_div_manual_mode_params.tg;
+               return tg && tg->funcs &&
+                               tg->funcs->set_h_timing_div_manual_mode;
+       case TG_SET_DRR:
+               tg = step->params.tg_set_drr_params.tg;
+               return tg && tg->funcs && tg->funcs->set_drr;
+       case TG_SET_STATIC_SCREEN_CONTROL:
+               tg = step->params.tg_set_static_screen_control_params.tg;
+               return tg && tg->funcs && tg->funcs->set_static_screen_control;
+       case TG_SET_OUT_MUX:
+               tg = step->params.tg_set_out_mux_params.tg;
+               return tg && tg->funcs && tg->funcs->set_out_mux;
+       case TG_SET_EARLY_CONTROL:
+               tg = step->params.tg_set_early_control_params.tg;
+               return tg && tg->funcs && tg->funcs->set_early_control;
+       case OPP_PROGRAM_FMT:
+               opp = step->params.opp_program_fmt_params.opp;
+               return opp && opp->funcs && opp->funcs->opp_program_fmt &&
+                               
step->params.opp_program_fmt_params.fmt_bit_depth &&
+                               step->params.opp_program_fmt_params.clamping;
+       case OPP_SET_DYN_EXPANSION:
+               opp = step->params.opp_set_dyn_expansion_params.opp;
+               return opp && opp->funcs && opp->funcs->opp_set_dyn_expansion;
+       case OPP_PIPE_CLOCK_CONTROL:
+               opp = step->params.opp_pipe_clock_control_params.opp;
+               return opp && opp->funcs && opp->funcs->opp_pipe_clock_control;
+       case OPP_PROGRAM_LEFT_EDGE_EXTRA_PIXEL:
+               opp = step->params.opp_program_left_edge_extra_pixel_params.opp;
+               return opp && opp->funcs &&
+                               opp->funcs->opp_program_left_edge_extra_pixel;
+       case OPP_SET_DISP_PATTERN_GENERATOR:
+               opp = step->params.opp_set_disp_pattern_generator_params.opp;
+               return opp && opp->funcs &&
+                               opp->funcs->opp_set_disp_pattern_generator;
+       case OPP_WAIT_FOR_BLANK_COMPLETE:
+               opp = step->params.opp_wait_for_blank_complete_params.opp;
+               return opp && opp->funcs && opp->funcs->dpg_is_pending &&
+                               opp->funcs->dpg_is_blanked &&
+                               step->params.opp_wait_for_blank_complete_params
+                               .polling_interval_us;
+       case DCCG_SET_PIXEL_RATE_DIV:
+               dccg = step->params.dccg_set_pixel_rate_div_params.dccg;
+               return dccg && dccg->funcs && dccg->funcs->set_pixel_rate_div;
+       case DCCG_DISABLE_SYMCLK_SE:
+               dccg = step->params.dccg_disable_symclk_se_params.dccg;
+               return dccg && dccg->funcs && dccg->funcs->disable_symclk_se;
+       case DCCG_ENABLE_SYMCLK_SE:
+               dccg = step->params.dccg_enable_symclk_se_params.dccg;
+               return dccg && dccg->funcs && dccg->funcs->enable_symclk_se;
+       case DCCG_SET_DTBCLK_P_SRC:
+               dccg = step->params.dccg_set_dtbclk_p_src_params.dccg;
+               return dccg && dccg->funcs && dccg->funcs->set_dtbclk_p_src;
+       case CLK_SRC_PROGRAM_PIX_CLK: {
+               const struct clk_src_program_pix_clk_params *p =
+                               &step->params.clk_src_program_pix_clk_params;
+
+               return p->clock_source && p->clock_source->funcs &&
+                               p->clock_source->funcs->program_pix_clk &&
+                               p->pix_clk_params && p->pll_settings;
+       }
+       case CLK_SRC_POWER_DOWN:
+               cs = step->params.clk_src_power_down_params.clock_source;
+               return cs && cs->funcs && cs->funcs->cs_power_down;
+       case DIO_LINK_ENC_CONNECT_DIG_BE_TO_FE:
+               link_enc = step->params.link_enc_connect_dig_be_to_fe_params
+                               .link_enc;
+               return link_enc && link_enc->funcs &&
+                               link_enc->funcs->connect_dig_be_to_fe;
+       case DIO_LINK_ENC_ENABLE_DP_OUTPUT:
+               link_enc = step->params.link_enc_enable_dp_output_params
+                               .link_enc;
+               return link_enc && link_enc->funcs &&
+                               link_enc->funcs->enable_dp_output &&
+                               step->params.link_enc_enable_dp_output_params
+                               .link_settings;
+       case DIO_LINK_ENC_DISABLE_OUTPUT:
+               link_enc = step->params.link_enc_disable_output_params.link_enc;
+               return link_enc && link_enc->funcs &&
+                               link_enc->funcs->disable_output;
+       case BIOS_SET_SCRATCH_CRITICAL_STATE: {
+               struct dc_bios *dcb =
+                               
step->params.bios_set_scratch_critical_state_params.dcb;
+
+               return dcb && dcb->funcs && 
dcb->funcs->set_scratch_critical_state;
+       }
+       case HUBP_PG_CONTROL:
+               hws = step->params.hubp_pg_control_params.hws;
+               return hws && hws->funcs.hubp_pg_control;
+       case DC_IP_REQUEST_CNTL:
+               hws = step->params.dc_ip_request_cntl_params.hws;
+               return hws && hws->funcs.dc_ip_request_cntl;
+       case HUBP_CLK_CNTL:
+               hubp = step->params.hubp_clk_cntl_params.hubp;
+               return hubp && hubp->funcs && hubp->funcs->hubp_clk_cntl;
+       case HUBP_SET_BLANK:
+               hubp = step->params.hubp_set_blank_params.hubp;
+               return hubp && hubp->funcs && hubp->funcs->set_blank;
+       case HUBP_UPDATE_MALL_SEL:
+               hubp = step->params.hubp_update_mall_sel_params.hubp;
+               return hubp && hubp->funcs && hubp->funcs->hubp_update_mall_sel;
+       case HUBP_SET_FLIP_CONTROL_GSL:
+               hubp = step->params.set_flip_control_gsl_params.hubp;
+               return hubp && hubp->funcs &&
+                               hubp->funcs->hubp_set_flip_control_surface_gsl;
+       case HUBP_RESET:
+               hubp = step->params.hubp_reset_params.hubp;
+               return hubp && hubp->funcs && hubp->funcs->hubp_reset;
+       case DPP_RESET:
+               dpp = step->params.dpp_reset_params.dpp;
+               return dpp && dpp->funcs && dpp->funcs->dpp_reset;
+       case MPC_ASSERT_IDLE_MPCC:
+               mpc = step->params.mpc_assert_idle_mpcc_params.mpc;
+               return mpc && mpc->funcs && mpc->funcs->wait_for_idle;
+       case DPP_DPPCLK_CONTROL:
+               dpp = step->params.dpp_dppclk_control_params.dpp;
+               return dpp && dpp->funcs && dpp->funcs->dpp_dppclk_control;
+       case MPC_REMOVE_MPCC:
+               mpc = step->params.mpc_remove_mpcc_params.mpc;
+               return mpc && mpc->funcs && mpc->funcs->remove_mpcc &&
+                               
step->params.mpc_remove_mpcc_params.mpc_tree_params &&
+                               
step->params.mpc_remove_mpcc_params.mpcc_to_remove;
        default:
                return false;
        }
@@ -346,6 +550,21 @@ static noinline_for_stack enum dc2_bls_exec_result 
dc2_bls_exec_dmub_gpint(
        return DC2_BLS_EXEC_OK;
 }
 
+static noinline_for_stack bool dc2_bls_wait_for_blank_complete(
+               const struct opp_wait_for_blank_complete_params *w)
+{
+       unsigned int waited_us;
+
+       for (waited_us = 0; w->opp->funcs->dpg_is_pending(w->opp);
+                       waited_us += w->polling_interval_us) {
+               if (waited_us >= w->timeout_us)
+                       return false;
+               udelay(w->polling_interval_us);
+       }
+
+       return w->opp->funcs->dpg_is_blanked(w->opp);
+}
+
 enum dc2_bls_exec_result dc2_bls_execute(
                struct dc2 *dc2,
                const struct block_sequence *steps,
@@ -354,6 +573,13 @@ enum dc2_bls_exec_result dc2_bls_execute(
        enum dc2_bls_exec_result result = DC2_BLS_EXEC_OK;
        const struct block_sequence *entry;
        enum dc2_bls_exec_result sent;
+       struct timing_generator *tg;
+       struct output_pixel_processor *opp;
+       struct clock_source *cs;
+       struct link_encoder *link_enc;
+       struct hubp *hubp;
+       struct dpp *dpp;
+       struct mpc *mpc;
        unsigned int i;
 
        if (!steps || num_steps > MAX_HWSS_BLOCK_SEQUENCE_SIZE)
@@ -693,6 +919,364 @@ enum dc2_bls_exec_result dc2_bls_execute(
                                        p->num_chans, p->words_per_umc);
                        break;
                }
+               case CLK_MGR_UPDATE_CLOCKS_FOR_STATE: {
+                       const struct clk_mgr_update_clocks_for_state_params *p =
+                                       &entry->params
+                                       .clk_mgr_update_clocks_for_state_params;
+                       bool *p_state = &p->context->bw_ctx.bw.dcn.clk
+                                       .p_state_change_support;
+                       bool saved = *p_state;
+
+                       if (p->disallow_p_state_change)
+                               *p_state = false;
+                       p->clk_mgr->funcs->update_clocks(p->clk_mgr, p->context,
+                                       p->safe_to_lower);
+                       *p_state = saved;
+                       break;
+               }
+               case HUBBUB_PROGRAM_WATERMARKS: {
+                       const struct hubbub_program_watermarks_params *p =
+                                       
&entry->params.hubbub_program_watermarks_params;
+                       bool changed = p->hubbub->funcs->program_watermarks(
+                                       p->hubbub, p->watermarks, p->refclk_mhz,
+                                       p->safe_to_lower);
+
+                       if (p->dc && !p->safe_to_lower)
+                               p->dc->optimized_required |= changed;
+                       break;
+               }
+               case HUBBUB_PROGRAM_ARBITER: {
+                       const struct hubbub_program_arbiter_params *p =
+                                       
&entry->params.hubbub_program_arbiter_params;
+                       bool changed = 
p->hubbub->funcs->program_arbiter(p->hubbub,
+                                       p->arb_regs, p->safe_to_lower);
+
+                       if (p->dc && !p->safe_to_lower)
+                               p->dc->optimized_required |= changed;
+                       break;
+               }
+               case HUBBUB_PROGRAM_COMPBUF_SEGMENTS: {
+                       const struct hubbub_program_compbuf_segments_params *p =
+                                       &entry->params
+                                       .hubbub_program_compbuf_segments_params;
+
+                       p->hubbub->funcs->program_compbuf_segments(p->hubbub,
+                                       p->compbuf_size, p->safe_to_lower);
+                       break;
+               }
+               case HUBP_PROGRAM_DET_SEGMENTS: {
+                       const struct program_det_segments_params *p =
+                                       
&entry->params.program_det_segments_params;
+
+                       p->hubbub->funcs->program_det_segments(p->hubbub,
+                                       p->hubp_inst, p->det_size);
+                       break;
+               }
+               case TG_LOCK: {
+                       const struct tg_lock_params *p =
+                                       &entry->params.tg_lock_params;
+
+                       if (p->lock)
+                               p->tg->funcs->lock(p->tg);
+                       else
+                               p->tg->funcs->unlock(p->tg);
+                       break;
+               }
+               case TG_ENABLE_CRTC:
+                       tg = entry->params.tg_enable_crtc_params.tg;
+                       if (!tg->funcs->enable_crtc(tg))
+                               return DC2_BLS_EXEC_ERROR;
+                       break;
+               case TG_DISABLE_CRTC:
+                       tg = entry->params.tg_disable_crtc_params.tg;
+                       if (!tg->funcs->disable_crtc(tg))
+                               return DC2_BLS_EXEC_ERROR;
+                       break;
+               case TG_WAIT_ODM_DOUBLEBUFFER_PENDING_CLEAR:
+                       tg = entry->params
+                                       
.tg_wait_odm_doublebuffer_pending_clear_params.tg;
+                       tg->funcs->wait_odm_doublebuffer_pending_clear(tg);
+                       break;
+               case TG_PROGRAM_STEREO: {
+                       const struct tg_program_stereo_params *p =
+                                       &entry->params.tg_program_stereo_params;
+                       struct crtc_stereo_flags flags = p->flags;
+
+                       p->tg->funcs->program_stereo(p->tg, p->timing, &flags);
+                       break;
+               }
+               case OPP_PROGRAM_STEREO: {
+                       const struct opp_program_stereo_params *p =
+                                       
&entry->params.opp_program_stereo_params;
+
+                       p->opp->funcs->opp_program_stereo(p->opp, p->enable,
+                                       p->timing);
+                       break;
+               }
+               case TG_WAIT_FOR_STATE:
+                       tg = entry->params.tg_wait_for_state_params.tg;
+                       tg->funcs->wait_for_state(tg,
+                                       
entry->params.tg_wait_for_state_params.state);
+                       break;
+               case TG_SETUP_VERTICAL_INTERRUPT2:
+                       tg = 
entry->params.tg_setup_vertical_interrupt2_params.tg;
+                       tg->funcs->setup_vertical_interrupt2(tg, entry->params
+                                       
.tg_setup_vertical_interrupt2_params.start_line);
+                       break;
+               case OPTC_SET_ODM_BYPASS:
+                       tg = entry->params.set_odm_bypass_params.tg;
+                       tg->funcs->set_odm_bypass(tg,
+                                       
entry->params.set_odm_bypass_params.timing);
+                       break;
+               case TG_ENABLE_OPTC_CLOCK:
+                       tg = entry->params.tg_enable_optc_clock_params.tg;
+                       tg->funcs->enable_optc_clock(tg,
+                                       
entry->params.tg_enable_optc_clock_params.enable);
+                       break;
+               case TG_PROGRAM_TIMING: {
+                       const struct tg_program_timing_params *p =
+                                       &entry->params.tg_program_timing_params;
+
+                       p->tg->funcs->program_timing(p->tg, p->timing,
+                                       p->vready_offset, p->vstartup_start,
+                                       p->vupdate_offset, p->vupdate_width,
+                                       p->pstate_keepout, p->signal, 
p->use_vbios);
+                       break;
+               }
+               case TG_SET_H_TIMING_DIV_MANUAL_MODE:
+                       tg = 
entry->params.tg_set_h_timing_div_manual_mode_params.tg;
+                       tg->funcs->set_h_timing_div_manual_mode(tg, 
entry->params
+                                       .tg_set_h_timing_div_manual_mode_params
+                                       .manual_mode);
+                       break;
+               case TG_SET_DRR:
+                       tg = entry->params.tg_set_drr_params.tg;
+                       tg->funcs->set_drr(tg, 
&entry->params.tg_set_drr_params.drr);
+                       break;
+               case TG_SET_STATIC_SCREEN_CONTROL: {
+                       const struct tg_set_static_screen_control_params *p =
+                                       &entry->params
+                                       .tg_set_static_screen_control_params;
+
+                       p->tg->funcs->set_static_screen_control(p->tg,
+                                       p->event_triggers, p->num_frames);
+                       break;
+               }
+               case TG_SET_OUT_MUX:
+                       tg = entry->params.tg_set_out_mux_params.tg;
+                       tg->funcs->set_out_mux(tg,
+                                       
entry->params.tg_set_out_mux_params.dest);
+                       break;
+               case TG_SET_EARLY_CONTROL:
+                       tg = entry->params.tg_set_early_control_params.tg;
+                       tg->funcs->set_early_control(tg, entry->params
+                                       
.tg_set_early_control_params.early_cntl);
+                       break;
+               case OPP_PROGRAM_FMT:
+                       opp = entry->params.opp_program_fmt_params.opp;
+                       opp->funcs->opp_program_fmt(opp,
+                                       entry->params.opp_program_fmt_params
+                                       .fmt_bit_depth,
+                                       
entry->params.opp_program_fmt_params.clamping);
+                       break;
+               case OPP_SET_DYN_EXPANSION: {
+                       const struct opp_set_dyn_expansion_params *p =
+                                       
&entry->params.opp_set_dyn_expansion_params;
+
+                       p->opp->funcs->opp_set_dyn_expansion(p->opp,
+                                       p->color_space, p->color_depth, 
p->signal);
+                       break;
+               }
+               case OPP_PIPE_CLOCK_CONTROL:
+                       opp = entry->params.opp_pipe_clock_control_params.opp;
+                       opp->funcs->opp_pipe_clock_control(opp, entry->params
+                                       .opp_pipe_clock_control_params.enable);
+                       break;
+               case OPP_PROGRAM_LEFT_EDGE_EXTRA_PIXEL: {
+                       const struct opp_program_left_edge_extra_pixel_params 
*p =
+                                       &entry->params
+                                       
.opp_program_left_edge_extra_pixel_params;
+
+                       p->opp->funcs->opp_program_left_edge_extra_pixel(p->opp,
+                                       p->pixel_encoding, p->is_otg_master);
+                       break;
+               }
+               case OPP_SET_DISP_PATTERN_GENERATOR: {
+                       const struct opp_set_disp_pattern_generator_params *p =
+                                       &entry->params
+                                       .opp_set_disp_pattern_generator_params;
+
+                       p->opp->funcs->opp_set_disp_pattern_generator(p->opp,
+                                       p->test_pattern, p->color_space,
+                                       p->color_depth,
+                                       p->use_solid_color ? &p->solid_color : 
NULL,
+                                       p->width, p->height, p->offset,
+                                       p->disable_dyn_exp_for_test_pattern);
+                       break;
+               }
+               case OPP_WAIT_FOR_BLANK_COMPLETE:
+                       if (dc2_bls_wait_for_blank_complete(&entry->params
+                                       .opp_wait_for_blank_complete_params))
+                               break;
+                       if (!entry->params.opp_wait_for_blank_complete_params
+                                       .continue_on_error)
+                               return DC2_BLS_EXEC_ERROR;
+                       result = DC2_BLS_EXEC_CONTINUED_ON_ERROR;
+                       break;
+               case DCCG_SET_PIXEL_RATE_DIV: {
+                       const struct dccg_set_pixel_rate_div_params *p =
+                                       
&entry->params.dccg_set_pixel_rate_div_params;
+
+                       p->dccg->funcs->set_pixel_rate_div(p->dccg, p->otg_inst,
+                                       p->k1, p->k2);
+                       break;
+               }
+               case DCCG_DISABLE_SYMCLK_SE: {
+                       const struct dccg_disable_symclk_se_params *p =
+                                       
&entry->params.dccg_disable_symclk_se_params;
+
+                       p->dccg->funcs->disable_symclk_se(p->dccg,
+                                       p->stream_enc_inst, p->link_enc_inst);
+                       break;
+               }
+               case DCCG_ENABLE_SYMCLK_SE: {
+                       const struct dccg_enable_symclk_se_params *p =
+                                       
&entry->params.dccg_enable_symclk_se_params;
+
+                       p->dccg->funcs->enable_symclk_se(p->dccg,
+                                       p->stream_enc_inst, p->link_enc_inst);
+                       break;
+               }
+               case DCCG_SET_DTBCLK_P_SRC: {
+                       const struct dccg_set_dtbclk_p_src_params *p =
+                                       
&entry->params.dccg_set_dtbclk_p_src_params;
+
+                       p->dccg->funcs->set_dtbclk_p_src(p->dccg, p->src,
+                                       p->otg_inst);
+                       break;
+               }
+               case CLK_SRC_PROGRAM_PIX_CLK: {
+                       const struct clk_src_program_pix_clk_params *p =
+                                       
&entry->params.clk_src_program_pix_clk_params;
+
+                       if (!p->clock_source->funcs->program_pix_clk(
+                                       p->clock_source, p->pix_clk_params,
+                                       p->encoding, p->pll_settings))
+                               return DC2_BLS_EXEC_ERROR;
+                       break;
+               }
+               case CLK_SRC_POWER_DOWN:
+                       cs = 
entry->params.clk_src_power_down_params.clock_source;
+                       if (cs->funcs->cs_power_down(cs))
+                               break;
+                       if (!entry->params.clk_src_power_down_params
+                                       .continue_on_error)
+                               return DC2_BLS_EXEC_ERROR;
+                       result = DC2_BLS_EXEC_CONTINUED_ON_ERROR;
+                       break;
+               case DIO_LINK_ENC_CONNECT_DIG_BE_TO_FE: {
+                       const struct link_enc_connect_dig_be_to_fe_params *p =
+                                       &entry->params
+                                       .link_enc_connect_dig_be_to_fe_params;
+
+                       p->link_enc->funcs->connect_dig_be_to_fe(p->link_enc,
+                                       p->engine, p->connect);
+                       break;
+               }
+               case DIO_LINK_ENC_ENABLE_DP_OUTPUT: {
+                       const struct link_enc_enable_dp_output_params *p =
+                                       
&entry->params.link_enc_enable_dp_output_params;
+
+                       p->link_enc->funcs->enable_dp_output(p->link_enc,
+                                       p->link_settings, p->clock_source);
+                       break;
+               }
+               case DIO_LINK_ENC_DISABLE_OUTPUT:
+                       link_enc = entry->params.link_enc_disable_output_params
+                                       .link_enc;
+                       link_enc->funcs->disable_output(link_enc,
+                                       
entry->params.link_enc_disable_output_params
+                                       .signal);
+                       break;
+               case BIOS_SET_SCRATCH_CRITICAL_STATE: {
+                       const struct bios_set_scratch_critical_state_params *p =
+                                       &entry->params
+                                       .bios_set_scratch_critical_state_params;
+
+                       p->dcb->funcs->set_scratch_critical_state(p->dcb, 
p->state);
+                       break;
+               }
+               case HUBP_PG_CONTROL: {
+                       const struct hubp_pg_control_params *p =
+                                       &entry->params.hubp_pg_control_params;
+
+                       p->hws->funcs.hubp_pg_control(p->hws, p->hubp_inst,
+                                       p->power_on);
+                       break;
+               }
+               case DC_IP_REQUEST_CNTL: {
+                       const struct dc_ip_request_cntl_params *p =
+                                       
&entry->params.dc_ip_request_cntl_params;
+
+                       p->hws->funcs.dc_ip_request_cntl(p->hws, p->enable);
+                       break;
+               }
+               case HUBP_CLK_CNTL:
+                       hubp = entry->params.hubp_clk_cntl_params.hubp;
+                       hubp->funcs->hubp_clk_cntl(hubp,
+                                       
entry->params.hubp_clk_cntl_params.enable);
+                       hubp->power_gated =
+                                       
!entry->params.hubp_clk_cntl_params.enable;
+                       break;
+               case HUBP_SET_BLANK:
+                       hubp = entry->params.hubp_set_blank_params.hubp;
+                       hubp->funcs->set_blank(hubp,
+                                       
entry->params.hubp_set_blank_params.blank);
+                       break;
+               case HUBP_UPDATE_MALL_SEL: {
+                       const struct hubp_update_mall_sel_params *p =
+                                       
&entry->params.hubp_update_mall_sel_params;
+
+                       p->hubp->funcs->hubp_update_mall_sel(p->hubp, 
p->mall_sel,
+                                       p->cache_cursor);
+                       break;
+               }
+               case HUBP_SET_FLIP_CONTROL_GSL: {
+                       const struct set_flip_control_gsl_params *p =
+                                       
&entry->params.set_flip_control_gsl_params;
+
+                       
p->hubp->funcs->hubp_set_flip_control_surface_gsl(p->hubp,
+                                       p->flip_immediate);
+                       break;
+               }
+               case HUBP_RESET:
+                       hubp = entry->params.hubp_reset_params.hubp;
+                       hubp->funcs->hubp_reset(hubp);
+                       break;
+               case DPP_RESET:
+                       dpp = entry->params.dpp_reset_params.dpp;
+                       dpp->funcs->dpp_reset(dpp);
+                       break;
+               case MPC_ASSERT_IDLE_MPCC:
+                       mpc = entry->params.mpc_assert_idle_mpcc_params.mpc;
+                       mpc->funcs->wait_for_idle(mpc,
+                                       
entry->params.mpc_assert_idle_mpcc_params.mpcc_id);
+                       break;
+               case DPP_DPPCLK_CONTROL:
+                       dpp = entry->params.dpp_dppclk_control_params.dpp;
+                       dpp->funcs->dpp_dppclk_control(dpp,
+                                       entry->params.dpp_dppclk_control_params
+                                       .dppclk_div,
+                                       
entry->params.dpp_dppclk_control_params.enable);
+                       break;
+               case MPC_REMOVE_MPCC: {
+                       const struct mpc_remove_mpcc_params *p =
+                                       &entry->params.mpc_remove_mpcc_params;
+
+                       p->mpc->funcs->remove_mpcc(p->mpc, p->mpc_tree_params,
+                                       p->mpcc_to_remove);
+                       break;
+               }
                default:
                        ASSERT(false);
                        return DC2_BLS_EXEC_ERROR;
diff --git a/drivers/gpu/drm/amd/display/dc/hwss/hw_sequencer.h 
b/drivers/gpu/drm/amd/display/dc/hwss/hw_sequencer.h
index 9f97503a02ff..3042785cb8fc 100644
--- a/drivers/gpu/drm/amd/display/dc/hwss/hw_sequencer.h
+++ b/drivers/gpu/drm/amd/display/dc/hwss/hw_sequencer.h
@@ -29,6 +29,7 @@
 #include "inc/clock_source.h"
 #include "inc/hw/timing_generator.h"
 #include "inc/hw/opp.h"
+#include "inc/hw/dccg.h"
 #include "inc/hw/link_encoder.h"
 #include "inc/core_status.h"
 #include "inc/hw/hw_shared.h"
@@ -285,6 +286,143 @@ struct bios_is_accelerated_mode_params {
        bool *out_accelerated_mode;
 };
 
+struct clk_mgr_update_clocks_for_state_params {
+       struct clk_mgr *clk_mgr;
+       struct dc_state *context;
+       bool safe_to_lower;
+       /* Clears context's p_state_change_support for this call only. */
+       bool disallow_p_state_change;
+};
+
+struct tg_enable_optc_clock_params {
+       struct timing_generator *tg;
+       bool enable;
+};
+
+struct tg_program_timing_params {
+       struct timing_generator *tg;
+       const struct dc_crtc_timing *timing;
+       int vready_offset;
+       int vstartup_start;
+       int vupdate_offset;
+       int vupdate_width;
+       int pstate_keepout;
+       enum signal_type signal;
+       bool use_vbios;
+};
+
+struct tg_set_h_timing_div_manual_mode_params {
+       struct timing_generator *tg;
+       bool manual_mode;
+};
+
+struct tg_set_drr_params {
+       struct timing_generator *tg;
+       struct drr_params drr;
+};
+
+struct tg_set_static_screen_control_params {
+       struct timing_generator *tg;
+       uint32_t event_triggers;
+       uint32_t num_frames;
+};
+
+struct tg_set_out_mux_params {
+       struct timing_generator *tg;
+       enum otg_out_mux_dest dest;
+};
+
+struct tg_set_early_control_params {
+       struct timing_generator *tg;
+       uint32_t early_cntl;
+};
+
+struct tg_disable_crtc_params {
+       struct timing_generator *tg;
+};
+
+struct tg_wait_odm_doublebuffer_pending_clear_params {
+       struct timing_generator *tg;
+};
+
+struct tg_program_stereo_params {
+       struct timing_generator *tg;
+       const struct dc_crtc_timing *timing;
+       struct crtc_stereo_flags flags;
+};
+
+struct opp_program_stereo_params {
+       struct output_pixel_processor *opp;
+       bool enable;
+       const struct dc_crtc_timing *timing;
+};
+
+struct opp_wait_for_blank_complete_params {
+       struct output_pixel_processor *opp;
+       unsigned int polling_interval_us;
+       unsigned int timeout_us;
+       bool continue_on_error;
+};
+
+struct dccg_set_pixel_rate_div_params {
+       struct dccg *dccg;
+       uint32_t otg_inst;
+       enum pixel_rate_div k1;
+       enum pixel_rate_div k2;
+};
+
+struct dccg_disable_symclk_se_params {
+       struct dccg *dccg;
+       uint32_t stream_enc_inst;
+       uint32_t link_enc_inst;
+};
+
+struct dccg_enable_symclk_se_params {
+       struct dccg *dccg;
+       uint32_t stream_enc_inst;
+       uint32_t link_enc_inst;
+};
+
+struct dccg_set_dtbclk_p_src_params {
+       struct dccg *dccg;
+       enum streamclk_source src;
+       uint32_t otg_inst;
+};
+
+struct clk_src_program_pix_clk_params {
+       struct clock_source *clock_source;
+       struct pixel_clk_params *pix_clk_params;
+       enum dp_link_encoding encoding;
+       struct pll_settings *pll_settings;
+};
+
+struct clk_src_power_down_params {
+       struct clock_source *clock_source;
+       bool continue_on_error;
+};
+
+struct link_enc_connect_dig_be_to_fe_params {
+       struct link_encoder *link_enc;
+       enum engine_id engine;
+       bool connect;
+};
+
+struct link_enc_enable_dp_output_params {
+       struct link_encoder *link_enc;
+       const struct dc_link_settings *link_settings;
+       enum clock_source_id clock_source;
+};
+
+struct link_enc_disable_output_params {
+       struct link_encoder *link_enc;
+       enum signal_type signal;
+};
+
+struct bios_set_scratch_critical_state_params {
+       struct dc_bios *dcb;
+       bool state;
+};
+
 struct lsdma_send_pio_copy_params {
        struct dc_dmub_srv *dc_dmub_srv;
        uint64_t src_addr;
@@ -1350,6 +1488,37 @@ union block_sequence_params {
                        clk_mgr_initialize_min_clocks_params;
        struct clk_mgr_notify_wm_ranges_params clk_mgr_notify_wm_ranges_params;
        struct bios_is_accelerated_mode_params bios_is_accelerated_mode_params;
+       struct clk_mgr_update_clocks_for_state_params
+                       clk_mgr_update_clocks_for_state_params;
+       struct tg_enable_optc_clock_params tg_enable_optc_clock_params;
+       struct tg_program_timing_params tg_program_timing_params;
+       struct tg_set_h_timing_div_manual_mode_params
+                       tg_set_h_timing_div_manual_mode_params;
+       struct tg_set_drr_params tg_set_drr_params;
+       struct tg_set_static_screen_control_params
+                       tg_set_static_screen_control_params;
+       struct tg_set_out_mux_params tg_set_out_mux_params;
+       struct tg_set_early_control_params tg_set_early_control_params;
+       struct tg_disable_crtc_params tg_disable_crtc_params;
+       struct tg_wait_odm_doublebuffer_pending_clear_params
+                       tg_wait_odm_doublebuffer_pending_clear_params;
+       struct tg_program_stereo_params tg_program_stereo_params;
+       struct opp_program_stereo_params opp_program_stereo_params;
+       struct opp_wait_for_blank_complete_params
+                       opp_wait_for_blank_complete_params;
+       struct dccg_set_pixel_rate_div_params dccg_set_pixel_rate_div_params;
+       struct dccg_disable_symclk_se_params dccg_disable_symclk_se_params;
+       struct dccg_enable_symclk_se_params dccg_enable_symclk_se_params;
+       struct dccg_set_dtbclk_p_src_params dccg_set_dtbclk_p_src_params;
+       struct clk_src_program_pix_clk_params clk_src_program_pix_clk_params;
+       struct clk_src_power_down_params clk_src_power_down_params;
+       struct link_enc_connect_dig_be_to_fe_params
+                       link_enc_connect_dig_be_to_fe_params;
+       struct link_enc_enable_dp_output_params
+                       link_enc_enable_dp_output_params;
+       struct link_enc_disable_output_params link_enc_disable_output_params;
+       struct bios_set_scratch_critical_state_params
+                       bios_set_scratch_critical_state_params;
        struct hubbub_program_watermarks_params 
hubbub_program_watermarks_params;
        struct hubbub_program_arbiter_params hubbub_program_arbiter_params;
        struct hubbub_program_compbuf_segments_params 
hubbub_program_compbuf_segments_params;
@@ -1559,6 +1728,29 @@ enum block_sequence_func {
        HUBBUB_SET_REQUEST_LIMIT,
        BIOS_IS_ACCELERATED_MODE,
        DMUB_FAMS2_UPDATE_CONFIG,
+       CLK_MGR_UPDATE_CLOCKS_FOR_STATE,
+       TG_ENABLE_OPTC_CLOCK,
+       TG_PROGRAM_TIMING,
+       TG_SET_H_TIMING_DIV_MANUAL_MODE,
+       TG_SET_DRR,
+       TG_SET_STATIC_SCREEN_CONTROL,
+       TG_SET_OUT_MUX,
+       TG_SET_EARLY_CONTROL,
+       TG_DISABLE_CRTC,
+       TG_WAIT_ODM_DOUBLEBUFFER_PENDING_CLEAR,
+       TG_PROGRAM_STEREO,
+       OPP_PROGRAM_STEREO,
+       OPP_WAIT_FOR_BLANK_COMPLETE,
+       DCCG_SET_PIXEL_RATE_DIV,
+       DCCG_DISABLE_SYMCLK_SE,
+       DCCG_ENABLE_SYMCLK_SE,
+       DCCG_SET_DTBCLK_P_SRC,
+       CLK_SRC_PROGRAM_PIX_CLK,
+       CLK_SRC_POWER_DOWN,
+       DIO_LINK_ENC_CONNECT_DIG_BE_TO_FE,
+       DIO_LINK_ENC_ENABLE_DP_OUTPUT,
+       DIO_LINK_ENC_DISABLE_OUTPUT,
+       BIOS_SET_SCRATCH_CRITICAL_STATE,
        /* This must be the last value in this enum, add new ones above */
        HWSS_BLOCK_SEQUENCE_FUNC_COUNT
 };
-- 
2.43.0

Reply via email to