res_ctx->clock_source_ref_count[i]--;
 
-               if (res_ctx->clock_source_ref_count[i] == 0)
+               if (res_ctx->clock_source_ref_count[i] == 0) {
+                       res_ctx->clock_source_changed[i] = true;
                        need_reset = true;
+               }
 
                break;
        }
        if (pool->dp_clock_source == clock_source) {
                res_ctx->dp_clock_source_ref_count--;
 
-               if (res_ctx->dp_clock_source_ref_count == 0)
+               if (res_ctx->dp_clock_source_ref_count == 0) {
+                       res_ctx->dp_clock_source_changed = true;
                        need_reset = true;
+               }
        }
 
        return need_reset;
                                        del_pipe->stream_res.audio,
                                        false);
 
+                       resource_unreference_clock_source(&new_ctx->res_ctx,
+                                                         dc->res_pool,
+                                                         del_pipe->clock_source);
+
                        memset(del_pipe, 0, sizeof(*del_pipe));
 
                        break;
                        if (dc_is_dp_signal(pipe_ctx->stream->signal) &&
                                !find_pll_sharable_stream(stream, new_ctx)) {
 
-                               if (resource_unreference_clock_source(
+                               resource_unreference_clock_source(
                                                &new_ctx->res_ctx,
                                                dc->res_pool,
-                                               pipe_ctx->clock_source)) {
-                                       pipe_ctx->clock_source->funcs->cs_power_down(pipe_ctx->clock_source);
-                                       pipe_ctx->clock_source = NULL;
-                               }
+                                               pipe_ctx->clock_source);
 
                                pipe_ctx->clock_source = dc->res_pool->dp_clock_source;
                                resource_reference_clock_source(
 
                        pipe_ctx_old->stream_res.tg->funcs->disable_crtc(pipe_ctx_old->stream_res.tg);
                        pipe_ctx_old->plane_res.mi->funcs->free_mem_input(
                                        pipe_ctx_old->plane_res.mi, dc->current_state->stream_count);
-                       if (resource_unreference_clock_source(
-                                       &dc->current_state->res_ctx, dc->res_pool,
-                                       pipe_ctx_old->clock_source)) {
-                               pipe_ctx_old->clock_source->funcs->cs_power_down(pipe_ctx_old->clock_source);
-                               pipe_ctx_old->clock_source = NULL;
-                       }
 
                        dc->hwss.power_down_front_end(dc, pipe_ctx_old->pipe_idx);
 
                        pipe_ctx_old->stream = NULL;
                }
        }
+
+       /* power down changed clock sources */
+       for (i = 0; i < dc->res_pool->clk_src_count; i++)
+               if (context->res_ctx.clock_source_changed[i]) {
+                       struct clock_source *clk = dc->res_pool->clock_sources[i];
+
+                       clk->funcs->cs_power_down(clk);
+                       context->res_ctx.clock_source_changed[i] = false;
+               }
+
+       if (context->res_ctx.dp_clock_source_changed) {
+               struct clock_source *clk = dc->res_pool->dp_clock_source;
+
+               clk->funcs->cs_power_down(clk);
+               context->res_ctx.clock_source_changed[i] = false;
+       }
 }
 
 
 
                pipe_ctx->stream_res.tg->funcs->enable_optc_clock(pipe_ctx->stream_res.tg, false);
        }
 
-       if (!IS_FPGA_MAXIMUS_DC(dc->ctx->dce_environment))
-               if (resource_unreference_clock_source(&context->res_ctx,
-                   dc->res_pool, pipe_ctx->clock_source)) {
-                       pipe_ctx->clock_source->funcs->cs_power_down(pipe_ctx->clock_source);
-                       pipe_ctx->clock_source = NULL;
-               }
-
-
        for (i = 0; i < dc->res_pool->pipe_count; i++)
                if (&dc->current_state->res_ctx.pipe_ctx[i] == pipe_ctx)
                        break;
                        plane_atomic_power_down(dc, i);
        }
 
+       /* power down changed clock sources */
+       for (i = 0; i < dc->res_pool->clk_src_count; i++)
+               if (context->res_ctx.clock_source_changed[i]) {
+                       struct clock_source *clk = dc->res_pool->clock_sources[i];
+
+                       clk->funcs->cs_power_down(clk);
+                       context->res_ctx.clock_source_changed[i] = false;
+               }
+
+       if (context->res_ctx.dp_clock_source_changed) {
+               struct clock_source *clk = dc->res_pool->dp_clock_source;
+
+               clk->funcs->cs_power_down(clk);
+               context->res_ctx.dp_clock_source_changed = false;
+       }
+
        /* Reset Back End*/
        for (i = dc->res_pool->pipe_count - 1; i >= 0 ; i--) {
                struct pipe_ctx *pipe_ctx_old =
 
        bool is_stream_enc_acquired[MAX_PIPES * 2];
        bool is_audio_acquired[MAX_PIPES];
        uint8_t clock_source_ref_count[MAX_CLOCK_SOURCES];
+       bool clock_source_changed[MAX_CLOCK_SOURCES];
        uint8_t dp_clock_source_ref_count;
+       bool dp_clock_source_changed;
 };
 
 struct dce_bw_output {