const struct dce_dmcu_shift *dmcu_shift,
        const struct dce_dmcu_mask *dmcu_mask)
 {
-       struct dce_dmcu *dmcu_dce = kzalloc(sizeof(*dmcu_dce), GFP_KERNEL);
+       struct dce_dmcu *dmcu_dce = kzalloc(sizeof(*dmcu_dce), GFP_ATOMIC);
 
        if (dmcu_dce == NULL) {
                BREAK_TO_DEBUGGER();
        const struct dce_dmcu_shift *dmcu_shift,
        const struct dce_dmcu_mask *dmcu_mask)
 {
-       struct dce_dmcu *dmcu_dce = kzalloc(sizeof(*dmcu_dce), GFP_KERNEL);
+       struct dce_dmcu *dmcu_dce = kzalloc(sizeof(*dmcu_dce), GFP_ATOMIC);
 
        if (dmcu_dce == NULL) {
                BREAK_TO_DEBUGGER();
        const struct dce_dmcu_shift *dmcu_shift,
        const struct dce_dmcu_mask *dmcu_mask)
 {
-       struct dce_dmcu *dmcu_dce = kzalloc(sizeof(*dmcu_dce), GFP_KERNEL);
+       struct dce_dmcu *dmcu_dce = kzalloc(sizeof(*dmcu_dce), GFP_ATOMIC);
 
        if (dmcu_dce == NULL) {
                BREAK_TO_DEBUGGER();
 
        uint32_t inst)
 {
        struct dcn20_dpp *dpp =
-               kzalloc(sizeof(struct dcn20_dpp), GFP_KERNEL);
+               kzalloc(sizeof(struct dcn20_dpp), GFP_ATOMIC);
 
        if (!dpp)
                return NULL;
        struct dc_context *ctx, uint32_t inst)
 {
        struct dcn10_ipp *ipp =
-               kzalloc(sizeof(struct dcn10_ipp), GFP_KERNEL);
+               kzalloc(sizeof(struct dcn10_ipp), GFP_ATOMIC);
 
        if (!ipp) {
                BREAK_TO_DEBUGGER();
        struct dc_context *ctx, uint32_t inst)
 {
        struct dcn20_opp *opp =
-               kzalloc(sizeof(struct dcn20_opp), GFP_KERNEL);
+               kzalloc(sizeof(struct dcn20_opp), GFP_ATOMIC);
 
        if (!opp) {
                BREAK_TO_DEBUGGER();
        uint32_t inst)
 {
        struct aux_engine_dce110 *aux_engine =
-               kzalloc(sizeof(struct aux_engine_dce110), GFP_KERNEL);
+               kzalloc(sizeof(struct aux_engine_dce110), GFP_ATOMIC);
 
        if (!aux_engine)
                return NULL;
        uint32_t inst)
 {
        struct dce_i2c_hw *dce_i2c_hw =
-               kzalloc(sizeof(struct dce_i2c_hw), GFP_KERNEL);
+               kzalloc(sizeof(struct dce_i2c_hw), GFP_ATOMIC);
 
        if (!dce_i2c_hw)
                return NULL;
 struct mpc *dcn20_mpc_create(struct dc_context *ctx)
 {
        struct dcn20_mpc *mpc20 = kzalloc(sizeof(struct dcn20_mpc),
-                                         GFP_KERNEL);
+                                         GFP_ATOMIC);
 
        if (!mpc20)
                return NULL;
 {
        int i;
        struct dcn20_hubbub *hubbub = kzalloc(sizeof(struct dcn20_hubbub),
-                                         GFP_KERNEL);
+                                         GFP_ATOMIC);
 
        if (!hubbub)
                return NULL;
                uint32_t instance)
 {
        struct optc *tgn10 =
-               kzalloc(sizeof(struct optc), GFP_KERNEL);
+               kzalloc(sizeof(struct optc), GFP_ATOMIC);
 
        if (!tgn10)
                return NULL;
        bool dp_clk_src)
 {
        struct dce110_clk_src *clk_src =
-               kzalloc(sizeof(struct dce110_clk_src), GFP_KERNEL);
+               kzalloc(sizeof(struct dce110_clk_src), GFP_ATOMIC);
 
        if (!clk_src)
                return NULL;
        struct dc_context *ctx, uint32_t inst)
 {
        struct dcn20_dsc *dsc =
-               kzalloc(sizeof(struct dcn20_dsc), GFP_KERNEL);
+               kzalloc(sizeof(struct dcn20_dsc), GFP_ATOMIC);
 
        if (!dsc) {
                BREAK_TO_DEBUGGER();
        uint32_t inst)
 {
        struct dcn20_hubp *hubp2 =
-               kzalloc(sizeof(struct dcn20_hubp), GFP_KERNEL);
+               kzalloc(sizeof(struct dcn20_hubp), GFP_ATOMIC);
 
        if (!hubp2)
                return NULL;
 
 static struct pp_smu_funcs *dcn20_pp_smu_create(struct dc_context *ctx)
 {
-       struct pp_smu_funcs *pp_smu = kzalloc(sizeof(*pp_smu), GFP_KERNEL);
+       struct pp_smu_funcs *pp_smu = kzalloc(sizeof(*pp_smu), GFP_ATOMIC);
 
        if (!pp_smu)
                return pp_smu;
                struct dc *dc)
 {
        struct dcn20_resource_pool *pool =
-               kzalloc(sizeof(struct dcn20_resource_pool), GFP_KERNEL);
+               kzalloc(sizeof(struct dcn20_resource_pool), GFP_ATOMIC);
 
        if (!pool)
                return NULL;