hws->funcs.update_plane_addr(dc, pipe_ctx);
 
        if (is_pipe_tree_visible(pipe_ctx))
-               dc->hwss.set_hubp_blank(dc, pipe_ctx, false);
+               hubp->funcs->set_blank(hubp, false);
 }
 
 void dcn10_blank_pixel_data(
        return;
 }
 
-static struct pipe_ctx *get_pipe_ctx_by_hubp_inst(struct dc_state *context, int mpcc_inst)
+static struct hubp *get_hubp_by_inst(struct resource_pool *res_pool, int mpcc_inst)
 {
        int i;
 
-       for (i = 0; i < MAX_PIPES; i++) {
-               if (context->res_ctx.pipe_ctx[i].plane_res.hubp
-                               && context->res_ctx.pipe_ctx[i].plane_res.hubp->inst == mpcc_inst) {
-                       return &context->res_ctx.pipe_ctx[i];
-               }
-
+       for (i = 0; i < res_pool->pipe_count; i++) {
+               if (res_pool->hubps[i]->inst == mpcc_inst)
+                       return res_pool->hubps[i];
        }
        ASSERT(false);
        return NULL;
 
        for (mpcc_inst = 0; mpcc_inst < MAX_PIPES; mpcc_inst++) {
                if (pipe_ctx->stream_res.opp->mpcc_disconnect_pending[mpcc_inst]) {
-                       struct pipe_ctx *restore_bottom_pipe;
-                       struct pipe_ctx *restore_top_pipe;
-                       struct pipe_ctx *inst_pipe_ctx = get_pipe_ctx_by_hubp_inst(dc->current_state, mpcc_inst);
+                       struct hubp *hubp = get_hubp_by_inst(res_pool, mpcc_inst);
 
-                       ASSERT(inst_pipe_ctx);
                        res_pool->mpc->funcs->wait_for_idle(res_pool->mpc, mpcc_inst);
                        pipe_ctx->stream_res.opp->mpcc_disconnect_pending[mpcc_inst] = false;
-                       /*
-                        * Set top and bottom pipes NULL, as we don't want
-                        * to blank those pipes when disconnecting from MPCC
-                        */
-                       restore_bottom_pipe = inst_pipe_ctx->bottom_pipe;
-                       restore_top_pipe = inst_pipe_ctx->top_pipe;
-                       inst_pipe_ctx->top_pipe = inst_pipe_ctx->bottom_pipe = NULL;
-                       dc->hwss.set_hubp_blank(dc, inst_pipe_ctx, true);
-                       inst_pipe_ctx->top_pipe = restore_top_pipe;
-                       inst_pipe_ctx->bottom_pipe = restore_bottom_pipe;
+                       hubp->funcs->set_blank(hubp, true);
                }
        }
 
                                dc->clk_mgr->funcs->get_clock(dc->clk_mgr, context, clock_type, clock_cfg);
 
 }
-
-void dcn10_set_hubp_blank(const struct dc *dc,
-                               struct pipe_ctx *pipe_ctx,
-                               bool blank_enable)
-{
-       pipe_ctx->plane_res.hubp->funcs->set_blank(pipe_ctx->plane_res.hubp, blank_enable);
-}
 
                struct dc_state *context);
 void dcn10_set_hdr_multiplier(struct pipe_ctx *pipe_ctx);
 void dcn10_verify_allow_pstate_change_high(struct dc *dc);
-void dcn10_set_hubp_blank(const struct dc *dc,
-                               struct pipe_ctx *pipe_ctx,
-                               bool blank_enable);
 
 #endif /* __DC_HWSS_DCN10_H__ */
 
        .set_backlight_level = dce110_set_backlight_level,
        .set_abm_immediate_disable = dce110_set_abm_immediate_disable,
        .set_pipe = dce110_set_pipe,
-       .set_hubp_blank = dcn10_set_hubp_blank,
 };
 
 static const struct hwseq_private_funcs dcn10_private_funcs = {
 
 
 
        if (pipe_ctx->update_flags.bits.enable)
-               dc->hwss.set_hubp_blank(dc, pipe_ctx, false);
+               hubp->funcs->set_blank(hubp, false);
 }
 
 
 
        for (i = 0; i < dc->res_pool->pipe_count; i++) {
                struct pipe_ctx *pipe = &context->res_ctx.pipe_ctx[i];
+               struct pipe_ctx *mpcc_pipe;
 
                if (pipe->vtp_locked) {
-                       dc->hwss.set_hubp_blank(dc, pipe, true);
+                       dc->hwseq->funcs.wait_for_blank_complete(pipe->stream_res.opp);
+                       pipe->plane_res.hubp->funcs->set_blank(pipe->plane_res.hubp, true);
                        pipe->vtp_locked = false;
+
+                       for (mpcc_pipe = pipe->bottom_pipe; mpcc_pipe; mpcc_pipe = mpcc_pipe->bottom_pipe)
+                               mpcc_pipe->plane_res.hubp->funcs->set_blank(mpcc_pipe->plane_res.hubp, true);
+
+                       for (i = 0; i < dc->res_pool->pipe_count; i++)
+                               if (context->res_ctx.pipe_ctx[i].update_flags.bits.disable)
+                                       dc->hwss.disable_plane(dc, &dc->current_state->res_ctx.pipe_ctx[i]);
                }
        }
        /* WA to apply WM setting*/
 
        .optimize_timing_for_fsft = dcn20_optimize_timing_for_fsft,
 #endif
        .set_disp_pattern_generator = dcn20_set_disp_pattern_generator,
-       .set_hubp_blank = dcn10_set_hubp_blank,
 };
 
 static const struct hwseq_private_funcs dcn20_private_funcs = {
 
 #endif
        .is_abm_supported = dcn21_is_abm_supported,
        .set_disp_pattern_generator = dcn20_set_disp_pattern_generator,
-       .set_hubp_blank = dcn10_set_hubp_blank,
 };
 
 static const struct hwseq_private_funcs dcn21_private_funcs = {
 
                                dc->res_pool->hubbub, true, true);
 }
 
-void dcn30_set_hubp_blank(const struct dc *dc,
-               struct pipe_ctx *pipe_ctx,
-               bool blank_enable)
-{
-       struct pipe_ctx *mpcc_pipe;
-       struct pipe_ctx *odm_pipe;
-
-       if (blank_enable) {
-               struct plane_resource *plane_res = &pipe_ctx->plane_res;
-               struct stream_resource *stream_res = &pipe_ctx->stream_res;
-
-               /* Wait for enter vblank */
-               stream_res->tg->funcs->wait_for_state(stream_res->tg, CRTC_STATE_VBLANK);
-
-               /* Blank HUBP to allow p-state during blank on all timings */
-               pipe_ctx->plane_res.hubp->funcs->set_blank(pipe_ctx->plane_res.hubp, true);
-               /* Confirm hubp in blank */
-               ASSERT(plane_res->hubp->funcs->hubp_in_blank(plane_res->hubp));
-               /* Toggle HUBP_DISABLE */
-               plane_res->hubp->funcs->hubp_soft_reset(plane_res->hubp, true);
-               plane_res->hubp->funcs->hubp_soft_reset(plane_res->hubp, false);
-               for (mpcc_pipe = pipe_ctx->bottom_pipe; mpcc_pipe; mpcc_pipe = mpcc_pipe->bottom_pipe) {
-                       mpcc_pipe->plane_res.hubp->funcs->set_blank(mpcc_pipe->plane_res.hubp, true);
-                       /* Confirm hubp in blank */
-                       ASSERT(mpcc_pipe->plane_res.hubp->funcs->hubp_in_blank(mpcc_pipe->plane_res.hubp));
-                       /* Toggle HUBP_DISABLE */
-                       mpcc_pipe->plane_res.hubp->funcs->hubp_soft_reset(mpcc_pipe->plane_res.hubp, true);
-                       mpcc_pipe->plane_res.hubp->funcs->hubp_soft_reset(mpcc_pipe->plane_res.hubp, false);
-
-               }
-               for (odm_pipe = pipe_ctx->next_odm_pipe; odm_pipe; odm_pipe = odm_pipe->next_odm_pipe) {
-                       odm_pipe->plane_res.hubp->funcs->set_blank(odm_pipe->plane_res.hubp, true);
-                       /* Confirm hubp in blank */
-                       ASSERT(odm_pipe->plane_res.hubp->funcs->hubp_in_blank(odm_pipe->plane_res.hubp));
-                       /* Toggle HUBP_DISABLE */
-                       odm_pipe->plane_res.hubp->funcs->hubp_soft_reset(odm_pipe->plane_res.hubp, true);
-                       odm_pipe->plane_res.hubp->funcs->hubp_soft_reset(odm_pipe->plane_res.hubp, false);
-               }
-       } else {
-               pipe_ctx->plane_res.hubp->funcs->set_blank(pipe_ctx->plane_res.hubp, false);
-               for (mpcc_pipe = pipe_ctx->bottom_pipe; mpcc_pipe; mpcc_pipe = mpcc_pipe->bottom_pipe)
-                       mpcc_pipe->plane_res.hubp->funcs->set_blank(mpcc_pipe->plane_res.hubp, false);
-               for (odm_pipe = pipe_ctx->next_odm_pipe; odm_pipe; odm_pipe = odm_pipe->next_odm_pipe)
-                       odm_pipe->plane_res.hubp->funcs->set_blank(odm_pipe->plane_res.hubp, false);
-       }
-}
-
 void dcn30_set_disp_pattern_generator(const struct dc *dc,
                struct pipe_ctx *pipe_ctx,
                enum controller_dp_test_pattern test_pattern,
                int width, int height, int offset)
 {
        struct stream_resource *stream_res = &pipe_ctx->stream_res;
+       struct pipe_ctx *mpcc_pipe;
 
        if (test_pattern != CONTROLLER_DP_TEST_PATTERN_VIDEOMODE) {
                pipe_ctx->vtp_locked = false;
                if (stream_res->tg->funcs->is_tg_enabled(stream_res->tg)) {
                        if (stream_res->tg->funcs->is_locked(stream_res->tg))
                                pipe_ctx->vtp_locked = true;
-                       else
-                               dc->hwss.set_hubp_blank(dc, pipe_ctx, true);
+                       else {
+                               /* Blank HUBP to allow p-state during blank on all timings */
+                               pipe_ctx->plane_res.hubp->funcs->set_blank(pipe_ctx->plane_res.hubp, true);
+
+                               for (mpcc_pipe = pipe_ctx->bottom_pipe; mpcc_pipe; mpcc_pipe = mpcc_pipe->bottom_pipe)
+                                       mpcc_pipe->plane_res.hubp->funcs->set_blank(mpcc_pipe->plane_res.hubp, true);
+                       }
                }
        } else {
-               dc->hwss.set_hubp_blank(dc, pipe_ctx, false);
                /* turning off DPG */
+               pipe_ctx->plane_res.hubp->funcs->set_blank(pipe_ctx->plane_res.hubp, false);
+               for (mpcc_pipe = pipe_ctx->bottom_pipe; mpcc_pipe; mpcc_pipe = mpcc_pipe->bottom_pipe)
+                       mpcc_pipe->plane_res.hubp->funcs->set_blank(mpcc_pipe->plane_res.hubp, false);
+
                stream_res->opp->funcs->opp_set_disp_pattern_generator(stream_res->opp, test_pattern, color_space,
                                color_depth, solid_color, width, height, offset);
        }
 
                const struct tg_color *solid_color,
                int width, int height, int offset);
 
-void dcn30_set_hubp_blank(const struct dc *dc,
-               struct pipe_ctx *pipe_ctx,
-               bool blank_enable);
-
 #endif /* __DC_HWSS_DCN30_H__ */
 
        .hardware_release = dcn30_hardware_release,
        .set_pipe = dcn21_set_pipe,
        .set_disp_pattern_generator = dcn30_set_disp_pattern_generator,
-       .set_hubp_blank = dcn30_set_hubp_blank,
 };
 
 static const struct hwseq_private_funcs dcn30_private_funcs = {
 
        .set_abm_immediate_disable = dcn21_set_abm_immediate_disable,
        .set_pipe = dcn21_set_pipe,
        .set_disp_pattern_generator = dcn30_set_disp_pattern_generator,
-       .set_hubp_blank = dcn30_set_hubp_blank,
 };
 
 static const struct hwseq_private_funcs dcn301_private_funcs = {
 
                        enum dc_color_depth color_depth,
                        const struct tg_color *solid_color,
                        int width, int height, int offset);
-
-       void (*set_hubp_blank)(const struct dc *dc,
-                       struct pipe_ctx *pipe_ctx,
-                       bool blank_enable);
 };
 
 void color_space_to_black_color(