static void process_deferred_updates(struct dc *dc)
 {
 #ifdef CONFIG_DRM_AMD_DC_DCN
-       int i;
+       int i = 0;
 
-       if (dc->debug.enable_mem_low_power.bits.cm)
+       if (dc->debug.enable_mem_low_power.bits.cm) {
+               ASSERT(dc->dcn_ip->max_num_dpp);
                for (i = 0; i < dc->dcn_ip->max_num_dpp; i++)
                        if (dc->res_pool->dpps[i]->funcs->dpp_deferred_update)
                                dc->res_pool->dpps[i]->funcs->dpp_deferred_update(dc->res_pool->dpps[i]);
+       }
 #endif
 }
 
 
        struct dcn10_dpp *dpp = TO_DCN10_DPP(dpp_base);
 
        if (dpp->tf_regs->DSCL_MEM_PWR_CTRL) {
-               REG_UPDATE(DSCL_MEM_PWR_CTRL, LUT_MEM_PWR_FORCE, power_on ? 0 : 3);
-               if (power_on)
+               if (power_on) {
+                       REG_UPDATE(DSCL_MEM_PWR_CTRL, LUT_MEM_PWR_FORCE, 0);
                        REG_WAIT(DSCL_MEM_PWR_STATUS, LUT_MEM_PWR_STATE, 0, 1, 5);
+               } else {
+                       if (dpp->base.ctx->dc->debug.enable_mem_low_power.bits.dscl) {
+                               dpp->base.ctx->dc->optimized_required = true;
+                               dpp->base.deferred_reg_writes.bits.disable_dscl = true;
+                       } else {
+                               REG_UPDATE(DSCL_MEM_PWR_CTRL, LUT_MEM_PWR_FORCE, 3);
+                       }
+               }
        }
 }
 
 
        int bypass_state;
        struct dcn3_dpp *dpp = TO_DCN30_DPP(dpp_base);
 
+       if (dpp_base->deferred_reg_writes.bits.disable_dscl) {
+               REG_UPDATE(DSCL_MEM_PWR_CTRL, LUT_MEM_PWR_FORCE, 3);
+               dpp_base->deferred_reg_writes.bits.disable_dscl = false;
+       }
+
+       if (dpp_base->deferred_reg_writes.bits.disable_gamcor) {
+               REG_GET(CM_GAMCOR_CONTROL, CM_GAMCOR_MODE_CURRENT, &bypass_state);
+               if (bypass_state == 0) {        // only program if bypass was latched
+                       REG_UPDATE(CM_MEM_PWR_CTRL, GAMCOR_MEM_PWR_FORCE, 3);
+               } else
+                       ASSERT(0); // LUT select was updated again before vupdate
+               dpp_base->deferred_reg_writes.bits.disable_gamcor = false;
+       }
+
        if (dpp_base->deferred_reg_writes.bits.disable_blnd_lut) {
                REG_GET(CM_BLNDGAM_CONTROL, CM_BLNDGAM_MODE_CURRENT, &bypass_state);
                if (bypass_state == 0) {        // only program if bypass was latched
 
        struct dcn3_dpp *dpp = TO_DCN30_DPP(dpp_base);
 
        if (dpp_base->ctx->dc->debug.enable_mem_low_power.bits.cm) {
-               REG_UPDATE(CM_MEM_PWR_CTRL, GAMCOR_MEM_PWR_FORCE, power_on ? 0 : 3);
-               if (power_on)
+               if (power_on) {
+                       REG_UPDATE(CM_MEM_PWR_CTRL, GAMCOR_MEM_PWR_FORCE, 0);
                        REG_WAIT(CM_MEM_PWR_STATUS, GAMCOR_MEM_PWR_STATE, 0, 1, 5);
+               } else {
+                       dpp_base->ctx->dc->optimized_required = true;
+                       dpp_base->deferred_reg_writes.bits.disable_gamcor = true;
+               }
        } else
                REG_SET(CM_MEM_PWR_CTRL, 0,
                                GAMCOR_MEM_PWR_DIS, power_on == true ? 0:1);
 
 
        dc->cap_funcs = cap_funcs;
 
+       dc->dcn_ip->max_num_dpp = dcn3_1_ip.max_num_dpp;
+
        DC_FP_END();
 
        return true;
 
                bool disable_blnd_lut:1;
                bool disable_3dlut:1;
                bool disable_shaper:1;
+               bool disable_gamcor:1;
+               bool disable_dscl:1;
        } bits;
        uint32_t raw;
 };