result = SMUM_WAIT_FIELD_UNEQUAL(smumgr,
                                        SMU_MP1_SRBM2P_RESP_0, CONTENT, 0);
        if (result != 0) {
-               printk(KERN_ERR "[ powerplay ] cz_send_msg_to_smc_async failed\n");
+               pr_err("cz_send_msg_to_smc_async failed\n");
                return result;
        }
 
                return -EINVAL;
 
        if (0 != (3 & smc_address)) {
-               printk(KERN_ERR "[ powerplay ] SMC address must be 4 byte aligned\n");
+               pr_err("SMC address must be 4 byte aligned\n");
                return -EINVAL;
        }
 
        if (limit <= (smc_address + 3)) {
-               printk(KERN_ERR "[ powerplay ] SMC address beyond the SMC RAM area\n");
+               pr_err("SMC address beyond the SMC RAM area\n");
                return -EINVAL;
        }
 
        uint32_t smc_address;
 
        if (!smumgr->reload_fw) {
-               printk(KERN_INFO "[ powerplay ] skip reloading...\n");
+               pr_info("skip reloading...\n");
                return 0;
        }
 
        }
 
        if (i >= smumgr->usec_timeout) {
-               printk(KERN_ERR "[ powerplay ] SMU check loaded firmware failed.\n");
+               pr_err("SMU check loaded firmware failed.\n");
                return -EINVAL;
        }
 
 
        ret = cz_request_smu_load_fw(smumgr);
        if (ret)
-               printk(KERN_ERR "[ powerplay] SMU firmware load failed\n");
+               pr_err("SMU firmware load failed\n");
 
        cz_check_fw_load_finish(smumgr, fw_to_check);
 
        ret = cz_load_mec_firmware(smumgr);
        if (ret)
-               printk(KERN_ERR "[ powerplay ] Mec Firmware load failed\n");
+               pr_err("Mec Firmware load failed\n");
 
        return ret;
 }
                        break;
 
        if (i >= cz_smu->scratch_buffer_length) {
-               printk(KERN_ERR "[ powerplay ] Invalid Firmware Type\n");
+               pr_err("Invalid Firmware Type\n");
                return -EINVAL;
        }
 
                        break;
 
        if (i >= cz_smu->driver_buffer_length) {
-               printk(KERN_ERR "[ powerplay ] Invalid Firmware Type\n");
+               pr_err("Invalid Firmware Type\n");
                return -EINVAL;
        }
 
                CZ_SCRATCH_ENTRY_UCODE_ID_RLC_SCRATCH,
                UCODE_ID_RLC_SCRATCH_SIZE_BYTE,
                &cz_smu->scratch_buffer[cz_smu->scratch_buffer_length++])) {
-               printk(KERN_ERR "[ powerplay ] Error when Populate Firmware Entry.\n");
+               pr_err("Error when Populate Firmware Entry.\n");
                return -1;
        }
 
                CZ_SCRATCH_ENTRY_UCODE_ID_RLC_SRM_ARAM,
                UCODE_ID_RLC_SRM_ARAM_SIZE_BYTE,
                &cz_smu->scratch_buffer[cz_smu->scratch_buffer_length++])) {
-               printk(KERN_ERR "[ powerplay ] Error when Populate Firmware Entry.\n");
+               pr_err("Error when Populate Firmware Entry.\n");
                return -1;
        }
        if (0 != cz_smu_populate_single_scratch_entry(smumgr,
                CZ_SCRATCH_ENTRY_UCODE_ID_RLC_SRM_DRAM,
                UCODE_ID_RLC_SRM_DRAM_SIZE_BYTE,
                &cz_smu->scratch_buffer[cz_smu->scratch_buffer_length++])) {
-               printk(KERN_ERR "[ powerplay ] Error when Populate Firmware Entry.\n");
+               pr_err("Error when Populate Firmware Entry.\n");
                return -1;
        }
 
                CZ_SCRATCH_ENTRY_UCODE_ID_POWER_PROFILING,
                sizeof(struct SMU8_MultimediaPowerLogData),
                &cz_smu->scratch_buffer[cz_smu->scratch_buffer_length++])) {
-               printk(KERN_ERR "[ powerplay ] Error when Populate Firmware Entry.\n");
+               pr_err("Error when Populate Firmware Entry.\n");
                return -1;
        }
 
                CZ_SCRATCH_ENTRY_SMU8_FUSION_CLKTABLE,
                sizeof(struct SMU8_Fusion_ClkTable),
                &cz_smu->scratch_buffer[cz_smu->scratch_buffer_length++])) {
-               printk(KERN_ERR "[ powerplay ] Error when Populate Firmware Entry.\n");
+               pr_err("Error when Populate Firmware Entry.\n");
                return -1;
        }
        cz_smu_construct_toc(smumgr);
 
                        return offsetof(SMU73_Discrete_DpmTable, LowSclkInterruptThreshold);
                }
        }
-       printk(KERN_WARNING "can't get the offset of type %x member %x\n", type, member);
+       pr_warning("can't get the offset of type %x member %x\n", type, member);
        return 0;
 }
 
                return SMU73_MAX_LEVELS_MVDD;
        }
 
-       printk(KERN_WARNING "can't get the mac of %x\n", value);
+       pr_warning("can't get the mac of %x\n", value);
        return 0;
 }
 
 
                        result = 0;
                        break;
                default:
-                       printk(KERN_ERR "Table Exit with Invalid Command!");
+                       pr_err("Table Exit with Invalid Command!");
                        priv->avfs.AvfsBtcStatus = AVFS_BTC_VIRUS_FAIL;
                        result = -1;
                        break;
                                priv->avfs.AvfsBtcStatus = AVFS_BTC_COMPLETED_UNSAVED;
                                result = 0;
                        } else {
-                               printk(KERN_ERR "[AVFS][fiji_start_avfs_btc] Attempt"
+                               pr_err("[AVFS][fiji_start_avfs_btc] Attempt"
                                                " to Enable AVFS Failed!");
                                smum_send_msg_to_smc(smumgr, PPSMC_MSG_DisableAvfs);
                                result = -1;
                        }
                } else {
-                       printk(KERN_ERR "[AVFS][fiji_start_avfs_btc] "
+                       pr_err("[AVFS][fiji_start_avfs_btc] "
                                        "PerformBTC SMU msg failed");
                        result = -1;
                }
        case AVFS_BTC_NOTSUPPORTED: /* Do nothing */
                break;
        default:
-               printk(KERN_ERR "[AVFS] Something is broken. See log!");
+               pr_err("[AVFS] Something is broken. See log!");
                break;
        }
        return 0;
 
 
        if (0 != result) {
                smu_data->smc_state_table.GraphicsBootLevel = 0;
-               printk(KERN_ERR "[ powerplay ] VBIOS did not find boot engine clock value \
+               pr_err("VBIOS did not find boot engine clock value \
                        in dependency table. Using Graphics DPM level 0!");
                result = 0;
        }
 
        if (0 != result) {
                smu_data->smc_state_table.MemoryBootLevel = 0;
-               printk(KERN_ERR "[ powerplay ] VBIOS did not find boot engine clock value \
+               pr_err("VBIOS did not find boot engine clock value \
                        in dependency table. Using Memory DPM level 0!");
                result = 0;
        }
                        return offsetof(SMU71_Discrete_DpmTable, LowSclkInterruptThreshold);
                }
        }
-       printk(KERN_WARNING "can't get the offset of type %x member %x\n", type, member);
+       pr_warning("can't get the offset of type %x member %x\n", type, member);
        return 0;
 }
 
                return SMU71_MAX_LEVELS_MVDD;
        }
 
-       printk(KERN_WARNING "can't get the mac of %x\n", value);
+       pr_warning("can't get the mac of %x\n", value);
        return 0;
 }
 
 
                return result;
 
        if (!smu7_is_smc_ram_running(smumgr)) {
-               printk("smu not running, upload firmware again \n");
+               pr_info("smu not running, upload firmware again \n");
                result = iceland_smu_upload_firmware_image(smumgr);
                if (result)
                        return result;
 
                        return offsetof(SMU74_Discrete_DpmTable, LowSclkInterruptThreshold);
                }
        }
-       printk(KERN_WARNING "can't get the offset of type %x member %x\n", type, member);
+       pr_warning("can't get the offset of type %x member %x\n", type, member);
        return 0;
 }
 
                return SMU7_UVD_MCLK_HANDSHAKE_DISABLE;
        }
 
-       printk(KERN_WARNING "can't get the mac of %x\n", value);
+       pr_warning("can't get the mac of %x\n", value);
        return 0;
 }
 
 
                        break;
 
                default:
-                       printk("Table Exit with Invalid Command!");
+                       pr_info("Table Exit with Invalid Command!");
                        smu_data->avfs.avfs_btc_status = AVFS_BTC_VIRUS_FAIL;
                        result = -1;
                        break;
 
        if (0 != smu_data->avfs.avfs_btc_param) {
                if (0 != smu7_send_msg_to_smc_with_parameter(smumgr, PPSMC_MSG_PerformBtc, smu_data->avfs.avfs_btc_param)) {
-                       printk("[AVFS][SmuPolaris10_PerformBtc] PerformBTC SMU msg failed");
+                       pr_info("[AVFS][SmuPolaris10_PerformBtc] PerformBTC SMU msg failed");
                        result = -1;
                }
        }
                return -1);
 
                if (smu_data->avfs.avfs_btc_param > 1) {
-                       printk("[AVFS][Polaris10_AVFSEventMgr] AC BTC has not been successfully verified on Fiji. There may be in this setting.");
+                       pr_info("[AVFS][Polaris10_AVFSEventMgr] AC BTC has not been successfully verified on Fiji. There may be in this setting.");
                        smu_data->avfs.avfs_btc_status = AVFS_BTC_VIRUS_FAIL;
                        PP_ASSERT_WITH_CODE(-1 == polaris10_setup_pwr_virus(smumgr),
                        "[AVFS][Polaris10_AVFSEventMgr] Could not setup Pwr Virus for AVFS ",
                break;
 
        default:
-               printk("[AVFS] Something is broken. See log!");
+               pr_info("[AVFS] Something is broken. See log!");
                break;
        }
 
 
        ret = SMUM_READ_FIELD(smumgr->device, SMC_RESP_0, SMC_RESP);
 
        if (ret != 1)
-               printk("\n failed to send pre message %x ret is %d \n",  msg, ret);
+               pr_info("\n failed to send pre message %x ret is %d \n",  msg, ret);
 
        cgs_write_register(smumgr->device, mmSMC_MESSAGE_0, msg);
 
        ret = SMUM_READ_FIELD(smumgr->device, SMC_RESP_0, SMC_RESP);
 
        if (ret != 1)
-               printk("\n failed to send message %x ret is %d \n",  msg, ret);
+               pr_info("\n failed to send message %x ret is %d \n",  msg, ret);
 
        return 0;
 }
        SMUM_WAIT_FIELD_UNEQUAL(smumgr, SMC_RESP_0, SMC_RESP, 0);
 
        if (1 != SMUM_READ_FIELD(smumgr->device, SMC_RESP_0, SMC_RESP))
-               printk("Failed to send Message.\n");
+               pr_info("Failed to send Message.\n");
 
        return 0;
 }
                result = UCODE_ID_RLC_G_MASK;
                break;
        default:
-               printk("UCode type is out of range! \n");
+               pr_info("UCode type is out of range! \n");
                result = 0;
        }
 
        struct SMU_DRAMData_TOC *toc;
 
        if (!smumgr->reload_fw) {
-               printk(KERN_INFO "[ powerplay ] skip reloading...\n");
+               pr_info("skip reloading...\n");
                return 0;
        }
 
        smu7_send_msg_to_smc_with_parameter(smumgr, PPSMC_MSG_DRV_DRAM_ADDR_LO, smu_data->header_buffer.mc_addr_low);
 
        if (smu7_send_msg_to_smc_with_parameter(smumgr, PPSMC_MSG_LoadUcodes, fw_to_load))
-               printk(KERN_ERR "Fail to Request SMU Load uCode");
+               pr_err("Fail to Request SMU Load uCode");
 
        return result;
 }
 
                }
        } else {
                if (0 == data->dpm_level_enable_mask.pcie_dpm_enable_mask)
-                       printk(KERN_ERR "[ powerplay ] Pcie Dpm Enablemask is 0 !");
+                       pr_err("Pcie Dpm Enablemask is 0 !");
 
                while (data->dpm_level_enable_mask.pcie_dpm_enable_mask &&
                                ((data->dpm_level_enable_mask.pcie_dpm_enable_mask &
 
        if (result != 0) {
                smu_data->smc_state_table.GraphicsBootLevel = 0;
-               printk(KERN_ERR "[powerplay] VBIOS did not find boot engine "
+               pr_err("[powerplay] VBIOS did not find boot engine "
                                "clock value in dependency table. "
                                "Using Graphics DPM level 0 !");
                result = 0;
 
        if (result != 0) {
                smu_data->smc_state_table.MemoryBootLevel = 0;
-               printk(KERN_ERR "[powerplay] VBIOS did not find boot "
+               pr_err("[powerplay] VBIOS did not find boot "
                                "engine clock value in dependency table."
                                "Using Memory DPM level 0 !");
                result = 0;
                        config = VR_SVI2_PLANE_2;
                        table->VRConfig |= config;
                } else {
-                       printk(KERN_ERR "[ powerplay ] VDDC and VDDGFX should "
+                       pr_err("VDDC and VDDGFX should "
                                "be both on SVI2 control in splitted mode !\n");
                }
        } else {
                        config = VR_SVI2_PLANE_1;
                        table->VRConfig |= config;
                } else {
-                       printk(KERN_ERR "[ powerplay ] VDDC should be on "
+                       pr_err("VDDC should be on "
                                        "SVI2 control in merged mode !\n");
                }
        }
                        return offsetof(SMU72_Discrete_DpmTable, LowSclkInterruptThreshold);
                }
        }
-       printk(KERN_WARNING "can't get the offset of type %x member %x\n", type, member);
+       pr_warning("can't get the offset of type %x member %x\n", type, member);
        return 0;
 }
 
        case SMU_MAX_LEVELS_MVDD:
                return SMU72_MAX_LEVELS_MVDD;
        }
-       printk(KERN_WARNING "can't get the mac value %x\n", value);
+       pr_warning("can't get the mac value %x\n", value);
 
        return 0;
 }
 
        /* Check pass/failed indicator */
        if (1 != SMUM_READ_VFPF_INDIRECT_FIELD(smumgr->device,
                                CGS_IND_REG__SMC, SMU_STATUS, SMU_PASS)) {
-               printk(KERN_ERR "[ powerplay ] SMU Firmware start failed\n");
+               pr_err("SMU Firmware start failed\n");
                return -EINVAL;
        }