u8 ivpu_pll_min_ratio;
 module_param_named(pll_min_ratio, ivpu_pll_min_ratio, byte, 0644);
-MODULE_PARM_DESC(pll_min_ratio, "Minimum PLL ratio used to set VPU frequency");
+MODULE_PARM_DESC(pll_min_ratio, "Minimum PLL ratio used to set NPU frequency");
 
 u8 ivpu_pll_max_ratio = U8_MAX;
 module_param_named(pll_max_ratio, ivpu_pll_max_ratio, byte, 0644);
-MODULE_PARM_DESC(pll_max_ratio, "Maximum PLL ratio used to set VPU frequency");
+MODULE_PARM_DESC(pll_max_ratio, "Maximum PLL ratio used to set NPU frequency");
 
 bool ivpu_disable_mmu_cont_pages;
 module_param_named(disable_mmu_cont_pages, ivpu_disable_mmu_cont_pages, bool, 0644);
        ivpu_ipc_consumer_del(vdev, &cons);
 
        if (!ret && ipc_hdr.data_addr != IVPU_IPC_BOOT_MSG_DATA_ADDR) {
-               ivpu_err(vdev, "Invalid VPU ready message: 0x%x\n",
+               ivpu_err(vdev, "Invalid NPU ready message: 0x%x\n",
                         ipc_hdr.data_addr);
                return -EIO;
        }
 
        if (!ret)
-               ivpu_dbg(vdev, PM, "VPU ready message received successfully\n");
+               ivpu_dbg(vdev, PM, "NPU ready message received successfully\n");
 
        return ret;
 }
 
        case PCI_DEVICE_ID_LNL:
                return IVPU_HW_40XX;
        default:
-               ivpu_err(vdev, "Unknown VPU device\n");
+               ivpu_err(vdev, "Unknown NPU device\n");
                return 0;
        }
 }
 
 
 static char *ivpu_firmware;
 module_param_named_unsafe(firmware, ivpu_firmware, charp, 0644);
-MODULE_PARM_DESC(firmware, "VPU firmware binary in /lib/firmware/..");
+MODULE_PARM_DESC(firmware, "NPU firmware binary in /lib/firmware/..");
 
 static struct {
        int gen;
 
 unsigned int ivpu_log_level = IVPU_FW_LOG_ERROR;
 module_param(ivpu_log_level, uint, 0444);
 MODULE_PARM_DESC(ivpu_log_level,
-                "VPU firmware default trace level: debug=" __stringify(IVPU_FW_LOG_DEBUG)
+                "NPU firmware default trace level: debug=" __stringify(IVPU_FW_LOG_DEBUG)
                 " info=" __stringify(IVPU_FW_LOG_INFO)
                 " warn=" __stringify(IVPU_FW_LOG_WARN)
                 " error=" __stringify(IVPU_FW_LOG_ERROR)
        u32 next = 0;
 
        while (fw_log_ptr(vdev, vdev->fw->mem_log_crit, &next, &log_header) == 0)
-               fw_log_print_buffer(vdev, log_header, "VPU critical", only_new_msgs, p);
+               fw_log_print_buffer(vdev, log_header, "NPU critical", only_new_msgs, p);
 
        next = 0;
        while (fw_log_ptr(vdev, vdev->fw->mem_log_verb, &next, &log_header) == 0)
-               fw_log_print_buffer(vdev, log_header, "VPU verbose", only_new_msgs, p);
+               fw_log_print_buffer(vdev, log_header, "NPU verbose", only_new_msgs, p);
 }
 
 void ivpu_fw_log_clear(struct ivpu_device *vdev)
 
 
                ret = ivpu_hw_37xx_wait_for_vpuip_bar(vdev);
                if (ret) {
-                       ivpu_err(vdev, "Timed out waiting for VPUIP bar\n");
+                       ivpu_err(vdev, "Timed out waiting for NPU IP bar\n");
                        return ret;
                }
        }
        ivpu_hw_37xx_save_d0i3_entry_timestamp(vdev);
 
        if (!ivpu_hw_37xx_is_idle(vdev))
-               ivpu_warn(vdev, "VPU not idle during power down\n");
+               ivpu_warn(vdev, "NPU not idle during power down\n");
 
        if (ivpu_hw_37xx_reset(vdev)) {
-               ivpu_err(vdev, "Failed to reset VPU\n");
+               ivpu_err(vdev, "Failed to reset NPU\n");
                ret = -EIO;
        }
 
 
 {
        switch (platform) {
        case IVPU_PLATFORM_SILICON:
-               return "IVPU_PLATFORM_SILICON";
+               return "SILICON";
        case IVPU_PLATFORM_SIMICS:
-               return "IVPU_PLATFORM_SIMICS";
+               return "SIMICS";
        case IVPU_PLATFORM_FPGA:
-               return "IVPU_PLATFORM_FPGA";
+               return "FPGA";
        default:
                return "Invalid platform";
        }
        int ret = 0;
 
        if (ivpu_hw_40xx_ip_reset(vdev)) {
-               ivpu_err(vdev, "Failed to reset VPU IP\n");
+               ivpu_err(vdev, "Failed to reset NPU IP\n");
                ret = -EIO;
        }
 
        ivpu_hw_40xx_save_d0i3_entry_timestamp(vdev);
 
        if (!ivpu_hw_40xx_is_idle(vdev) && ivpu_hw_40xx_ip_reset(vdev))
-               ivpu_warn(vdev, "Failed to reset the VPU\n");
+               ivpu_warn(vdev, "Failed to reset the NPU\n");
 
        if (ivpu_pll_disable(vdev)) {
                ivpu_err(vdev, "Failed to disable PLL\n");
 
 
 static bool ivpu_disable_recovery;
 module_param_named_unsafe(disable_recovery, ivpu_disable_recovery, bool, 0644);
-MODULE_PARM_DESC(disable_recovery, "Disables recovery when VPU hang is detected");
+MODULE_PARM_DESC(disable_recovery, "Disables recovery when NPU hang is detected");
 
 static unsigned long ivpu_tdr_timeout_ms;
 module_param_named(tdr_timeout_ms, ivpu_tdr_timeout_ms, ulong, 0644);
        char *evt[2] = {"IVPU_PM_EVENT=IVPU_RECOVER", NULL};
        int ret;
 
-       ivpu_err(vdev, "Recovering the VPU (reset #%d)\n", atomic_read(&vdev->pm->reset_counter));
+       ivpu_err(vdev, "Recovering the NPU (reset #%d)\n", atomic_read(&vdev->pm->reset_counter));
 
        ret = pm_runtime_resume_and_get(vdev->drm.dev);
        if (ret)
-               ivpu_err(vdev, "Failed to resume VPU: %d\n", ret);
+               ivpu_err(vdev, "Failed to resume NPU: %d\n", ret);
 
        ivpu_fw_log_dump(vdev);
 
 
        ret = ivpu_suspend(vdev);
        if (ret)
-               ivpu_err(vdev, "Failed to set suspend VPU: %d\n", ret);
+               ivpu_err(vdev, "Failed to suspend NPU: %d\n", ret);
 
        if (!hw_is_idle) {
-               ivpu_err(vdev, "VPU failed to enter idle, force suspended.\n");
+               ivpu_err(vdev, "NPU failed to enter idle, force suspended.\n");
                ivpu_fw_log_dump(vdev);
                ivpu_pm_prepare_cold_boot(vdev);
        } else {