/* Set DPS PPS SDP (AKA "info frames") */
        if (pipe_ctx->stream->timing.flags.DSC) {
-               dp_set_dsc_pps_sdp(pipe_ctx, true);
+               dp_set_dsc_pps_sdp(pipe_ctx, true, true);
        }
 
        /* Allocate Payload */
                        if (dc_is_dp_signal(pipe_ctx->stream->signal) ||
                                        dc_is_virtual_signal(pipe_ctx->stream->signal)) {
                                dp_set_dsc_on_rx(pipe_ctx, true);
-                               dp_set_dsc_pps_sdp(pipe_ctx, true);
+                               dp_set_dsc_pps_sdp(pipe_ctx, true, true);
                        }
                }
 
 
                                pipe_ctx->stream_res.hpo_dp_stream_enc->funcs->dp_set_dsc_pps_info_packet(
                                                                                pipe_ctx->stream_res.hpo_dp_stream_enc,
                                                                                false,
-                                                                               NULL);
+                                                                               NULL,
+                                                                               true);
                        else
 #endif
                                if (!IS_FPGA_MAXIMUS_DC(dc->ctx->dce_environment)) {
                                                        pipe_ctx->stream_res.stream_enc,
                                                        OPTC_DSC_DISABLED, 0, 0);
                                        pipe_ctx->stream_res.stream_enc->funcs->dp_set_dsc_pps_info_packet(
-                                                               pipe_ctx->stream_res.stream_enc, false, NULL);
+                                                               pipe_ctx->stream_res.stream_enc, false, NULL, true);
                                }
                }
 
        return result;
 }
 
-bool dp_set_dsc_pps_sdp(struct pipe_ctx *pipe_ctx, bool enable)
+/*
+ * For dynamic bpp change case, dsc is programmed with MASTER_UPDATE_LOCK enabled;
+ * hence PPS info packet update need to use frame update instead of immediate update.
+ * Added parameter immediate_update for this purpose.
+ * The decision to use frame update is hard-coded in function dp_update_dsc_config(),
+ * which is the only place where a "false" would be passed in for param immediate_update.
+ *
+ * immediate_update is only applicable when DSC is enabled.
+ */
+bool dp_set_dsc_pps_sdp(struct pipe_ctx *pipe_ctx, bool enable, bool immediate_update)
 {
        struct display_stream_compressor *dsc = pipe_ctx->stream_res.dsc;
        struct dc_stream_state *stream = pipe_ctx->stream;
                                pipe_ctx->stream_res.hpo_dp_stream_enc->funcs->dp_set_dsc_pps_info_packet(
                                                                                pipe_ctx->stream_res.hpo_dp_stream_enc,
                                                                                true,
-                                                                               &dsc_packed_pps[0]);
+                                                                               &dsc_packed_pps[0],
+                                                                               immediate_update);
                        else
 #endif
                                pipe_ctx->stream_res.stream_enc->funcs->dp_set_dsc_pps_info_packet(
                                                                                pipe_ctx->stream_res.stream_enc,
                                                                                true,
-                                                                               &dsc_packed_pps[0]);
+                                                                               &dsc_packed_pps[0],
+                                                                               immediate_update);
                }
        } else {
                /* disable DSC PPS in stream encoder */
                                pipe_ctx->stream_res.hpo_dp_stream_enc->funcs->dp_set_dsc_pps_info_packet(
                                                                                pipe_ctx->stream_res.hpo_dp_stream_enc,
                                                                                false,
-                                                                               NULL);
+                                                                               NULL,
+                                                                               true);
                        else
 #endif
                                pipe_ctx->stream_res.stream_enc->funcs->dp_set_dsc_pps_info_packet(
-                                                       pipe_ctx->stream_res.stream_enc, false, NULL);
+                                                       pipe_ctx->stream_res.stream_enc, false, NULL, true);
                }
        }
 
                return false;
 
        dp_set_dsc_on_stream(pipe_ctx, true);
-       dp_set_dsc_pps_sdp(pipe_ctx, true);
+       dp_set_dsc_pps_sdp(pipe_ctx, true, false);
        return true;
 }
 
 
 
 static void enc2_dp_set_dsc_pps_info_packet(struct stream_encoder *enc,
                                        bool enable,
-                                       uint8_t *dsc_packed_pps)
+                                       uint8_t *dsc_packed_pps,
+                                       bool immediate_update)
 {
        struct dcn10_stream_encoder *enc1 = DCN10STRENC_FROM_STRENC(enc);
 
 
                enc1->base.vpg->funcs->update_generic_info_packet(
                                enc1->base.vpg,
                                packet_index,
-                               info_packet);
+                               info_packet,
+                               true);
 
                /* enable transmission of packet(s) -
                 * packet transmission begins on the next frame */
 
 static void enc3_dp_set_dsc_pps_info_packet(struct stream_encoder *enc,
                                        bool enable,
-                                       uint8_t *dsc_packed_pps)
+                                       uint8_t *dsc_packed_pps,
+                                       bool immediate_update)
 {
        struct dcn10_stream_encoder *enc1 = DCN10STRENC_FROM_STRENC(enc);
 
                        enc1->base.vpg->funcs->update_generic_info_packet(
                                                        enc1->base.vpg,
                                                        11 + i,
-                                                       &pps_sdp);
+                                                       &pps_sdp,
+                                                       immediate_update);
                }
 
                /* SW should make sure VBID[6] update line number is bigger
                enc->vpg->funcs->update_generic_info_packet(
                                enc->vpg,
                                0,  /* packetIndex */
-                               &info_frame->vsc);
+                               &info_frame->vsc,
+                               true);
        }
        if (info_frame->spd.valid) {
                enc->vpg->funcs->update_generic_info_packet(
                                enc->vpg,
                                2,  /* packetIndex */
-                               &info_frame->spd);
+                               &info_frame->spd,
+                               true);
        }
        if (info_frame->hdrsmd.valid) {
                enc->vpg->funcs->update_generic_info_packet(
                                enc->vpg,
                                3,  /* packetIndex */
-                               &info_frame->hdrsmd);
+                               &info_frame->hdrsmd,
+                               true);
        }
        /* packetIndex 4 is used for send immediate sdp message, and please
         * use other packetIndex (such as 5,6) for other info packet
 
                OTG_H_BLANK_END, &h_blank_end);
 
        REG_UPDATE_2(OTG_GLOBAL_CONTROL1,
-               MASTER_UPDATE_LOCK_DB_START_Y, v_blank_start,
-               MASTER_UPDATE_LOCK_DB_END_Y, v_blank_end);
+               MASTER_UPDATE_LOCK_DB_START_Y, v_blank_start - 1,
+               MASTER_UPDATE_LOCK_DB_END_Y, v_blank_start);
        REG_UPDATE_2(OTG_GLOBAL_CONTROL4,
-               DIG_UPDATE_POSITION_X, 20,
-               DIG_UPDATE_POSITION_Y, v_blank_start);
+               DIG_UPDATE_POSITION_X, h_blank_start - 180 - 1,
+               DIG_UPDATE_POSITION_Y, v_blank_start - 1);
+       // there is a DIG_UPDATE_VCOUNT_MODE and it is 0.
+
        REG_UPDATE_3(OTG_GLOBAL_CONTROL0,
                MASTER_UPDATE_LOCK_DB_START_X, h_blank_start - 200 - 1,
-               MASTER_UPDATE_LOCK_DB_END_X, h_blank_end,
+               MASTER_UPDATE_LOCK_DB_END_X, h_blank_start - 180,
                MASTER_UPDATE_LOCK_DB_EN, 1);
        REG_UPDATE(OTG_GLOBAL_CONTROL2, GLOBAL_UPDATE_LOCK_EN, 1);
+
+       REG_SET_3(OTG_VUPDATE_KEEPOUT, 0,
+               MASTER_UPDATE_LOCK_VUPDATE_KEEPOUT_START_OFFSET, 0,
+               MASTER_UPDATE_LOCK_VUPDATE_KEEPOUT_END_OFFSET, 100,
+               OTG_MASTER_UPDATE_LOCK_VUPDATE_KEEPOUT_EN, 1);
 }
 
 void optc3_lock_doublebuffer_disable(struct timing_generator *optc)
 
 void vpg3_update_generic_info_packet(
        struct vpg *vpg,
        uint32_t packet_index,
-       const struct dc_info_packet *info_packet)
+       const struct dc_info_packet *info_packet,
+       bool immediate_update)
 {
        struct dcn30_vpg *vpg3 = DCN30_VPG_FROM_VPG(vpg);
        uint32_t i;
        /* atomically update double-buffered GENERIC0 registers in immediate mode
         * (update at next block_update when block_update_lock == 0).
         */
-       switch (packet_index) {
-       case 0:
-               REG_UPDATE(VPG_GSP_IMMEDIATE_UPDATE_CTRL,
-                               VPG_GENERIC0_IMMEDIATE_UPDATE, 1);
-               break;
-       case 1:
-               REG_UPDATE(VPG_GSP_IMMEDIATE_UPDATE_CTRL,
-                               VPG_GENERIC1_IMMEDIATE_UPDATE, 1);
-               break;
-       case 2:
-               REG_UPDATE(VPG_GSP_IMMEDIATE_UPDATE_CTRL,
-                               VPG_GENERIC2_IMMEDIATE_UPDATE, 1);
-               break;
-       case 3:
-               REG_UPDATE(VPG_GSP_IMMEDIATE_UPDATE_CTRL,
-                               VPG_GENERIC3_IMMEDIATE_UPDATE, 1);
-               break;
-       case 4:
-               REG_UPDATE(VPG_GSP_IMMEDIATE_UPDATE_CTRL,
-                               VPG_GENERIC4_IMMEDIATE_UPDATE, 1);
-               break;
-       case 5:
-               REG_UPDATE(VPG_GSP_IMMEDIATE_UPDATE_CTRL,
-                               VPG_GENERIC5_IMMEDIATE_UPDATE, 1);
-               break;
-       case 6:
-               REG_UPDATE(VPG_GSP_IMMEDIATE_UPDATE_CTRL,
-                               VPG_GENERIC6_IMMEDIATE_UPDATE, 1);
-               break;
-       case 7:
-               REG_UPDATE(VPG_GSP_IMMEDIATE_UPDATE_CTRL,
-                               VPG_GENERIC7_IMMEDIATE_UPDATE, 1);
-               break;
-       case 8:
-               REG_UPDATE(VPG_GSP_IMMEDIATE_UPDATE_CTRL,
-                               VPG_GENERIC8_IMMEDIATE_UPDATE, 1);
-               break;
-       case 9:
-               REG_UPDATE(VPG_GSP_IMMEDIATE_UPDATE_CTRL,
-                               VPG_GENERIC9_IMMEDIATE_UPDATE, 1);
-               break;
-       case 10:
-               REG_UPDATE(VPG_GSP_IMMEDIATE_UPDATE_CTRL,
-                               VPG_GENERIC10_IMMEDIATE_UPDATE, 1);
-               break;
-       case 11:
-               REG_UPDATE(VPG_GSP_IMMEDIATE_UPDATE_CTRL,
-                               VPG_GENERIC11_IMMEDIATE_UPDATE, 1);
-               break;
-       case 12:
-               REG_UPDATE(VPG_GSP_IMMEDIATE_UPDATE_CTRL,
-                               VPG_GENERIC12_IMMEDIATE_UPDATE, 1);
-               break;
-       case 13:
-               REG_UPDATE(VPG_GSP_IMMEDIATE_UPDATE_CTRL,
-                               VPG_GENERIC13_IMMEDIATE_UPDATE, 1);
-               break;
-       case 14:
-               REG_UPDATE(VPG_GSP_IMMEDIATE_UPDATE_CTRL,
-                               VPG_GENERIC14_IMMEDIATE_UPDATE, 1);
-               break;
-       default:
-               break;
+       if (immediate_update) {
+               switch (packet_index) {
+               case 0:
+                       REG_UPDATE(VPG_GSP_IMMEDIATE_UPDATE_CTRL,
+                                       VPG_GENERIC0_IMMEDIATE_UPDATE, 1);
+                       break;
+               case 1:
+                       REG_UPDATE(VPG_GSP_IMMEDIATE_UPDATE_CTRL,
+                                       VPG_GENERIC1_IMMEDIATE_UPDATE, 1);
+                       break;
+               case 2:
+                       REG_UPDATE(VPG_GSP_IMMEDIATE_UPDATE_CTRL,
+                                       VPG_GENERIC2_IMMEDIATE_UPDATE, 1);
+                       break;
+               case 3:
+                       REG_UPDATE(VPG_GSP_IMMEDIATE_UPDATE_CTRL,
+                                       VPG_GENERIC3_IMMEDIATE_UPDATE, 1);
+                       break;
+               case 4:
+                       REG_UPDATE(VPG_GSP_IMMEDIATE_UPDATE_CTRL,
+                                       VPG_GENERIC4_IMMEDIATE_UPDATE, 1);
+                       break;
+               case 5:
+                       REG_UPDATE(VPG_GSP_IMMEDIATE_UPDATE_CTRL,
+                                       VPG_GENERIC5_IMMEDIATE_UPDATE, 1);
+                       break;
+               case 6:
+                       REG_UPDATE(VPG_GSP_IMMEDIATE_UPDATE_CTRL,
+                                       VPG_GENERIC6_IMMEDIATE_UPDATE, 1);
+                       break;
+               case 7:
+                       REG_UPDATE(VPG_GSP_IMMEDIATE_UPDATE_CTRL,
+                                       VPG_GENERIC7_IMMEDIATE_UPDATE, 1);
+                       break;
+               case 8:
+                       REG_UPDATE(VPG_GSP_IMMEDIATE_UPDATE_CTRL,
+                                       VPG_GENERIC8_IMMEDIATE_UPDATE, 1);
+                       break;
+               case 9:
+                       REG_UPDATE(VPG_GSP_IMMEDIATE_UPDATE_CTRL,
+                                       VPG_GENERIC9_IMMEDIATE_UPDATE, 1);
+                       break;
+               case 10:
+                       REG_UPDATE(VPG_GSP_IMMEDIATE_UPDATE_CTRL,
+                                       VPG_GENERIC10_IMMEDIATE_UPDATE, 1);
+                       break;
+               case 11:
+                       REG_UPDATE(VPG_GSP_IMMEDIATE_UPDATE_CTRL,
+                                       VPG_GENERIC11_IMMEDIATE_UPDATE, 1);
+                       break;
+               case 12:
+                       REG_UPDATE(VPG_GSP_IMMEDIATE_UPDATE_CTRL,
+                                       VPG_GENERIC12_IMMEDIATE_UPDATE, 1);
+                       break;
+               case 13:
+                       REG_UPDATE(VPG_GSP_IMMEDIATE_UPDATE_CTRL,
+                                       VPG_GENERIC13_IMMEDIATE_UPDATE, 1);
+                       break;
+               case 14:
+                       REG_UPDATE(VPG_GSP_IMMEDIATE_UPDATE_CTRL,
+                                       VPG_GENERIC14_IMMEDIATE_UPDATE, 1);
+                       break;
+               default:
+                       break;
+               }
+       } else {
+               switch (packet_index) {
+               case 0:
+                       REG_UPDATE(VPG_GSP_FRAME_UPDATE_CTRL,
+                                       VPG_GENERIC0_FRAME_UPDATE, 1);
+                       break;
+               case 1:
+                       REG_UPDATE(VPG_GSP_FRAME_UPDATE_CTRL,
+                                       VPG_GENERIC1_FRAME_UPDATE, 1);
+                       break;
+               case 2:
+                       REG_UPDATE(VPG_GSP_FRAME_UPDATE_CTRL,
+                                       VPG_GENERIC2_FRAME_UPDATE, 1);
+                       break;
+               case 3:
+                       REG_UPDATE(VPG_GSP_FRAME_UPDATE_CTRL,
+                                       VPG_GENERIC3_FRAME_UPDATE, 1);
+                       break;
+               case 4:
+                       REG_UPDATE(VPG_GSP_FRAME_UPDATE_CTRL,
+                                       VPG_GENERIC4_FRAME_UPDATE, 1);
+                       break;
+               case 5:
+                       REG_UPDATE(VPG_GSP_FRAME_UPDATE_CTRL,
+                                       VPG_GENERIC5_FRAME_UPDATE, 1);
+                       break;
+               case 6:
+                       REG_UPDATE(VPG_GSP_FRAME_UPDATE_CTRL,
+                                       VPG_GENERIC6_FRAME_UPDATE, 1);
+                       break;
+               case 7:
+                       REG_UPDATE(VPG_GSP_FRAME_UPDATE_CTRL,
+                                       VPG_GENERIC7_FRAME_UPDATE, 1);
+                       break;
+               case 8:
+                       REG_UPDATE(VPG_GSP_FRAME_UPDATE_CTRL,
+                                       VPG_GENERIC8_FRAME_UPDATE, 1);
+                       break;
+               case 9:
+                       REG_UPDATE(VPG_GSP_FRAME_UPDATE_CTRL,
+                                       VPG_GENERIC9_FRAME_UPDATE, 1);
+                       break;
+               case 10:
+                       REG_UPDATE(VPG_GSP_FRAME_UPDATE_CTRL,
+                                       VPG_GENERIC10_FRAME_UPDATE, 1);
+                       break;
+               case 11:
+                       REG_UPDATE(VPG_GSP_FRAME_UPDATE_CTRL,
+                                       VPG_GENERIC11_FRAME_UPDATE, 1);
+                       break;
+               case 12:
+                       REG_UPDATE(VPG_GSP_FRAME_UPDATE_CTRL,
+                                       VPG_GENERIC12_FRAME_UPDATE, 1);
+                       break;
+               case 13:
+                       REG_UPDATE(VPG_GSP_FRAME_UPDATE_CTRL,
+                                       VPG_GENERIC13_FRAME_UPDATE, 1);
+                       break;
+               case 14:
+                       REG_UPDATE(VPG_GSP_FRAME_UPDATE_CTRL,
+                                       VPG_GENERIC14_FRAME_UPDATE, 1);
+                       break;
+
+               default:
+                       break;
+               }
+
        }
 }
 
 
        void (*update_generic_info_packet)(
                struct vpg *vpg,
                uint32_t packet_index,
-               const struct dc_info_packet *info_packet);
+               const struct dc_info_packet *info_packet,
+               bool immediate_update);
 
        void (*vpg_poweron)(
                struct vpg *vpg);
 void vpg3_update_generic_info_packet(
        struct vpg *vpg,
        uint32_t packet_index,
-       const struct dc_info_packet *info_packet);
+       const struct dc_info_packet *info_packet,
+       bool immediate_update);
 
 void vpg3_construct(struct dcn30_vpg *vpg3,
        struct dc_context *ctx,
 
                enc->vpg->funcs->update_generic_info_packet(
                                enc->vpg,
                                0,  /* packetIndex */
-                               &info_frame->vsc);
+                               &info_frame->vsc,
+                               true);
                sdp_stream_enable = true;
        }
        if (info_frame->spd.valid) {
                enc->vpg->funcs->update_generic_info_packet(
                                enc->vpg,
                                2,  /* packetIndex */
-                               &info_frame->spd);
+                               &info_frame->spd,
+                               true);
                sdp_stream_enable = true;
        }
        if (info_frame->hdrsmd.valid) {
                enc->vpg->funcs->update_generic_info_packet(
                                enc->vpg,
                                3,  /* packetIndex */
-                               &info_frame->hdrsmd);
+                               &info_frame->hdrsmd,
+                               true);
                sdp_stream_enable = true;
        }
        /* enable/disable transmission of packet(s).
 static void dcn31_hpo_dp_stream_enc_set_dsc_pps_info_packet(
                struct hpo_dp_stream_encoder *enc,
                bool enable,
-               uint8_t *dsc_packed_pps)
+               uint8_t *dsc_packed_pps,
+               bool immediate_update)
 {
        struct dcn31_hpo_dp_stream_encoder *enc3 = DCN3_1_HPO_DP_STREAM_ENC_FROM_HPO_STREAM_ENC(enc);
 
                        enc3->base.vpg->funcs->update_generic_info_packet(
                                                        enc3->base.vpg,
                                                        11 + i,
-                                                       &pps_sdp);
+                                                       &pps_sdp,
+                                                       immediate_update);
                }
 
                /* SW should make sure VBID[6] update line number is bigger
 
 enum dc_status dp_set_fec_ready(struct dc_link *link, bool ready);
 void dp_set_fec_enable(struct dc_link *link, bool enable);
 bool dp_set_dsc_enable(struct pipe_ctx *pipe_ctx, bool enable);
-bool dp_set_dsc_pps_sdp(struct pipe_ctx *pipe_ctx, bool enable);
+bool dp_set_dsc_pps_sdp(struct pipe_ctx *pipe_ctx, bool enable, bool immediate_update);
 void dp_set_dsc_on_stream(struct pipe_ctx *pipe_ctx, bool enable);
 bool dp_update_dsc_config(struct pipe_ctx *pipe_ctx);
 bool dp_set_dsc_on_rx(struct pipe_ctx *pipe_ctx, bool enable);
 
 
        void (*dp_set_dsc_pps_info_packet)(struct stream_encoder *enc,
                                bool enable,
-                               uint8_t *dsc_packed_pps);
+                               uint8_t *dsc_packed_pps,
+                               bool immediate_update);
 
        void (*set_dynamic_metadata)(struct stream_encoder *enc,
                        bool enable,
        void (*dp_set_dsc_pps_info_packet)(
                        struct hpo_dp_stream_encoder *enc,
                        bool enable,
-                       uint8_t *dsc_packed_pps);
+                       uint8_t *dsc_packed_pps,
+                       bool immediate_update);
 
        void (*map_stream_to_link)(
                        struct hpo_dp_stream_encoder *enc,
 
 static void virtual_stream_encoder_set_dsc_pps_info_packet(
                struct stream_encoder *enc,
                bool enable,
-               uint8_t *dsc_packed_pps)
+               uint8_t *dsc_packed_pps,
+               bool immediate_update)
 {}
 
 static const struct stream_encoder_funcs virtual_str_enc_funcs = {