}
 
 
-static void acquire_dsc(struct resource_context *res_ctx,
-                       const struct resource_pool *pool,
+static void acquire_dsc(const struct dc *dc,
+                       struct resource_context *res_ctx,
                        struct display_stream_compressor **dsc,
                        int pipe_idx)
 {
        int i;
+       const struct resource_pool *pool = dc->res_pool;
+       struct display_stream_compressor *dsc_old = dc->current_state->res_ctx.pipe_ctx[pipe_idx].stream_res.dsc;
 
-       ASSERT(*dsc == NULL);
+       ASSERT(*dsc == NULL); /* If this ASSERT fails, dsc was not released properly */
        *dsc = NULL;
 
+       /* Always do 1-to-1 mapping when number of DSCs is same as number of pipes */
        if (pool->res_cap->num_dsc == pool->res_cap->num_opp) {
                *dsc = pool->dscs[pipe_idx];
                res_ctx->is_dsc_acquired[pipe_idx] = true;
                return;
        }
 
+       /* Return old DSC to avoid the need for re-programming */
+       if (dsc_old && !res_ctx->is_dsc_acquired[dsc_old->inst]) {
+               *dsc = dsc_old;
+               res_ctx->is_dsc_acquired[dsc_old->inst] = true;
+               return ;
+       }
+
        /* Find first free DSC */
        for (i = 0; i < pool->res_cap->num_dsc; i++)
                if (!res_ctx->is_dsc_acquired[i]) {
 {
        enum dc_status result = DC_OK;
        int i;
-       const struct resource_pool *pool = dc->res_pool;
 
        /* Get a DSC if required and available */
        for (i = 0; i < dc->res_pool->pipe_count; i++) {
                if (pipe_ctx->stream_res.dsc)
                        continue;
 
-               acquire_dsc(&dc_ctx->res_ctx, pool, &pipe_ctx->stream_res.dsc, i);
+               acquire_dsc(dc, &dc_ctx->res_ctx, &pipe_ctx->stream_res.dsc, i);
 
                /* The number of DSCs can be less than the number of pipes */
                if (!pipe_ctx->stream_res.dsc) {
 }
 
 bool dcn20_split_stream_for_odm(
+               const struct dc *dc,
                struct resource_context *res_ctx,
-               const struct resource_pool *pool,
                struct pipe_ctx *prev_odm_pipe,
                struct pipe_ctx *next_odm_pipe)
 {
        int pipe_idx = next_odm_pipe->pipe_idx;
+       const struct resource_pool *pool = dc->res_pool;
 
        *next_odm_pipe = *prev_odm_pipe;
 
        }
        next_odm_pipe->stream_res.opp = pool->opps[next_odm_pipe->pipe_idx];
        if (next_odm_pipe->stream->timing.flags.DSC == 1) {
-               acquire_dsc(res_ctx, pool, &next_odm_pipe->stream_res.dsc, next_odm_pipe->pipe_idx);
+               acquire_dsc(dc, res_ctx, &next_odm_pipe->stream_res.dsc, next_odm_pipe->pipe_idx);
                ASSERT(next_odm_pipe->stream_res.dsc);
                if (next_odm_pipe->stream_res.dsc == NULL)
                        return false;
                        hsplit_pipe = dcn20_find_secondary_pipe(dc, &context->res_ctx, dc->res_pool, pipe);
                        ASSERT(hsplit_pipe);
                        if (!dcn20_split_stream_for_odm(
-                                       &context->res_ctx, dc->res_pool,
+                                       dc, &context->res_ctx,
                                        pipe, hsplit_pipe))
                                goto validate_fail;
                        pipe_split_from[hsplit_pipe->pipe_idx] = pipe_idx;
                                }
                                if (context->bw_ctx.dml.vba.ODMCombineEnabled[pipe_idx]) {
                                        if (!dcn20_split_stream_for_odm(
-                                                       &context->res_ctx, dc->res_pool,
+                                                       dc, &context->res_ctx,
                                                        pipe, hsplit_pipe))
                                                goto validate_fail;
                                        dcn20_build_mapped_resource(dc, context, pipe->stream);