diff --git a/drivers/media/platform/msm/cvp/cvp.c b/drivers/media/platform/msm/cvp/cvp.c
index dd6d5d51bf85..2802932c1780 100644
--- a/drivers/media/platform/msm/cvp/cvp.c
+++ b/drivers/media/platform/msm/cvp/cvp.c
@@ -37,7 +37,7 @@ static int cvp_open(struct inode *inode, struct file *filp)
 		struct msm_cvp_core, cdev);
 	struct msm_cvp_inst *inst;
 
-	dprintk(CVP_DBG, "%s: Enter\n", __func__);
+	dprintk(CVP_SESS, "%s: Enter\n", __func__);
 
 	inst = msm_cvp_open(core->id, MSM_CVP_USER);
 	if (!inst) {
@@ -209,7 +209,7 @@ static ssize_t thermal_level_store(struct device *dev,
 			"Invalid thermal level value: %s\n", buf);
 		return -EINVAL;
 	}
-	dprintk(CVP_DBG, "Thermal level old %d new %d\n",
+	dprintk(CVP_PWR, "Thermal level old %d new %d\n",
 			cvp_driver->thermal_level, val);
 
 	if (val == cvp_driver->thermal_level)
@@ -375,7 +375,7 @@ static int msm_probe_cvp_device(struct platform_device *pdev)
 		if (rc != -EPROBE_DEFER)
 			dprintk(CVP_ERR, "Failed to create HFI device\n");
 		else
-			dprintk(CVP_DBG, "msm_cvp: request probe defer\n");
+			dprintk(CVP_CORE, "msm_cvp: request probe defer\n");
 		goto err_hfi_initialize;
 	}
 
@@ -388,7 +388,7 @@ static int msm_probe_cvp_device(struct platform_device *pdev)
 
 	cvp_driver->sku_version = core->resources.sku_version;
 
-	dprintk(CVP_DBG, "populating sub devices\n");
+	dprintk(CVP_CORE, "populating sub devices\n");
 	/*
 	 * Trigger probe for each sub-device i.e. qcom,msm-cvp,context-bank.
 	 * When msm_cvp_probe is called for each sub-device, parse the
diff --git a/drivers/media/platform/msm/cvp/cvp_hfi.c b/drivers/media/platform/msm/cvp/cvp_hfi.c
index 9e468bfe426f..df4c2e8d5ef9 100644
--- a/drivers/media/platform/msm/cvp/cvp_hfi.c
+++ b/drivers/media/platform/msm/cvp/cvp_hfi.c
@@ -441,14 +441,14 @@ static int __dsp_suspend(struct iris_hfi_device *device, bool force, u32 flags)
 
 		/* don't suspend if cvp session is not paused */
 		if (!(temp->flags & SESSION_PAUSE)) {
-			dprintk(CVP_DBG,
+			dprintk(CVP_DSP,
 				"%s: cvp session %x not paused\n",
 				__func__, hash32_ptr(temp));
 			return -EBUSY;
 		}
 	}
 
-	dprintk(CVP_DBG, "%s: suspend dsp\n", __func__);
+	dprintk(CVP_DSP, "%s: suspend dsp\n", __func__);
 	rc = cvp_dsp_suspend(flags);
 	if (rc) {
 		dprintk(CVP_ERR, "%s: dsp suspend failed with error %d\n",
@@ -456,7 +456,7 @@ static int __dsp_suspend(struct iris_hfi_device *device, bool force, u32 flags)
 		return -EINVAL;
 	}
 
-	dprintk(CVP_DBG, "%s: dsp suspended\n", __func__);
+	dprintk(CVP_DSP, "%s: dsp suspended\n", __func__);
 	return 0;
 }
 
@@ -467,7 +467,7 @@ static int __dsp_resume(struct iris_hfi_device *device, u32 flags)
 	if (msm_cvp_dsp_disable)
 		return 0;
 
-	dprintk(CVP_DBG, "%s: resume dsp\n", __func__);
+	dprintk(CVP_DSP, "%s: resume dsp\n", __func__);
 	rc = cvp_dsp_resume(flags);
 	if (rc) {
 		dprintk(CVP_ERR,
@@ -476,7 +476,7 @@ static int __dsp_resume(struct iris_hfi_device *device, u32 flags)
 		return rc;
 	}
 
-	dprintk(CVP_DBG, "%s: dsp resumed\n", __func__);
+	dprintk(CVP_DSP, "%s: dsp resumed\n", __func__);
 	return rc;
 }
 
@@ -487,7 +487,7 @@ static int __dsp_shutdown(struct iris_hfi_device *device, u32 flags)
 	if (msm_cvp_dsp_disable)
 		return 0;
 
-	dprintk(CVP_DBG, "%s: shutdown dsp\n", __func__);
+	dprintk(CVP_DSP, "%s: shutdown dsp\n", __func__);
 	rc = cvp_dsp_shutdown(flags);
 	if (rc) {
 		dprintk(CVP_ERR,
@@ -496,7 +496,7 @@ static int __dsp_shutdown(struct iris_hfi_device *device, u32 flags)
 		WARN_ON(1);
 	}
 
-	dprintk(CVP_DBG, "%s: dsp shutdown successful\n", __func__);
+	dprintk(CVP_DSP, "%s: dsp shutdown successful\n", __func__);
 	return rc;
 }
 
@@ -519,7 +519,7 @@ static int __acquire_regulator(struct regulator_info *rinfo,
 					rinfo->name);
 		} else {
 
-			dprintk(CVP_DBG,
+			dprintk(CVP_PWR,
 					"Acquire regulator control from HW: %s\n",
 					rinfo->name);
 
@@ -547,7 +547,7 @@ static int __hand_off_regulator(struct regulator_info *rinfo)
 				"Failed to hand off regulator control: %s\n",
 					rinfo->name);
 		} else {
-			dprintk(CVP_DBG,
+			dprintk(CVP_PWR,
 					"Hand off regulator control to HW: %s\n",
 					rinfo->name);
 		}
@@ -727,7 +727,7 @@ static int __read_queue(struct cvp_iface_q_info *qinfo, u8 *packet,
 			queue->qhdr_rx_req = 0;
 		} else {
 			spin_unlock(&qinfo->hfi_lock);
-			dprintk(CVP_DBG,
+			dprintk(CVP_HFI,
 				"%s queue is empty, rx_req = %u, tx_req = %u, read_idx = %u\n",
 				receive_request ? "message" : "debug",
 				queue->qhdr_rx_req, queue->qhdr_tx_req,
@@ -820,7 +820,7 @@ static int __smem_alloc(struct iris_hfi_device *dev, struct cvp_mem_addr *mem,
 		goto fail_smem_alloc;
 	}
 
-	dprintk(CVP_DBG, "%s: ptr = %pK, size = %d\n", __func__,
+	dprintk(CVP_MEM, "%s: ptr = %pK, size = %d\n", __func__,
 			alloc->kvaddr, size);
 
 	mem->mem_size = alloc->size;
@@ -863,7 +863,7 @@ static void __write_register(struct iris_hfi_device *device,
 	}
 
 	base_addr = device->cvp_hal_data->register_base;
-	dprintk(CVP_DBG, "Base addr: %pK, written to: %#x, Value: %#x...\n",
+	dprintk(CVP_REG, "Base addr: %pK, written to: %#x, Value: %#x...\n",
 		base_addr, hwiosymaddr, value);
 	base_addr += hwiosymaddr;
 	writel_relaxed(value, base_addr);
@@ -901,7 +901,7 @@ static int __read_register(struct iris_hfi_device *device, u32 reg)
 	 * register.
 	 */
 	rmb();
-	dprintk(CVP_DBG, "Base addr: %pK, read from: %#x, value: %#x...\n",
+	dprintk(CVP_REG, "Base addr: %pK, read from: %#x, value: %#x...\n",
 		base_addr, reg, rc);
 
 	return rc;
@@ -922,7 +922,7 @@ static void __set_registers(struct iris_hfi_device *device)
 	for (i = 0; i < reg_set->count; i++) {
 		__write_register(device, reg_set->reg_tbl[i].reg,
 				reg_set->reg_tbl[i].value);
-		dprintk(CVP_DBG, "write_reg offset=%x, val=%x\n",
+		dprintk(CVP_REG, "write_reg offset=%x, val=%x\n",
 					reg_set->reg_tbl[i].reg,
 					reg_set->reg_tbl[i].value);
 	}
@@ -977,7 +977,7 @@ static int __vote_buses(struct iris_hfi_device *device,
 	struct cvp_bus_vote_data *new_data = NULL;
 
 	if (!num_data) {
-		dprintk(CVP_DBG, "No vote data available\n");
+		dprintk(CVP_PWR, "No vote data available\n");
 		goto no_data_count;
 	} else if (!data) {
 		dprintk(CVP_ERR, "Invalid voting data\n");
@@ -1090,7 +1090,7 @@ static int __tzbsp_set_cvp_state(enum tzbsp_subsys_state state)
 	int rc = 0;
 
 	rc = qcom_scm_set_remote_state(state, TZBSP_CVP_PAS_ID);
-	dprintk(CVP_DBG, "Set state %d, resp %d\n", state, rc);
+	dprintk(CVP_CORE, "Set state %d, resp %d\n", state, rc);
 
 	if (rc) {
 		dprintk(CVP_ERR, "Failed qcom_scm_set_remote_state %d\n", rc);
@@ -1143,7 +1143,7 @@ static int iris_hfi_resume(void *dev)
 		return -EINVAL;
 	}
 
-	dprintk(CVP_DBG, "Resuming Iris\n");
+	dprintk(CVP_CORE, "Resuming Iris\n");
 
 	mutex_lock(&device->lock);
 	rc = __resume(device);
@@ -1165,7 +1165,7 @@ static int iris_hfi_suspend(void *dev)
 		return -ENOTSUPP;
 	}
 
-	dprintk(CVP_DBG, "Suspending Iris\n");
+	dprintk(CVP_CORE, "Suspending Iris\n");
 	mutex_lock(&device->lock);
 	rc = __power_collapse(device, true);
 	if (rc) {
@@ -1253,7 +1253,7 @@ static int __set_clocks(struct iris_hfi_device *device, u32 freq)
 				return rc;
 			}
 
-			dprintk(CVP_DBG, "Scaling clock %s to %u\n",
+			dprintk(CVP_PWR, "Scaling clock %s to %u\n",
 					cl->name, freq);
 		}
 	}
@@ -1297,7 +1297,7 @@ static int __scale_clocks(struct iris_hfi_device *device)
 	rate = device->clk_freq ? device->clk_freq :
 		allowed_clks_tbl[0].clock_rate;
 
-	dprintk(CVP_DBG, "%s: scale clock rate %d\n", __func__, rate);
+	dprintk(CVP_PWR, "%s: scale clock rate %d\n", __func__, rate);
 	rc = __set_clocks(device, rate);
 	return rc;
 }
@@ -1350,7 +1350,7 @@ static int __iface_cmdq_write_relaxed(struct iris_hfi_device *device,
 				&iris_hfi_pm_work,
 				msecs_to_jiffies(
 				device->res->msm_cvp_pwr_collapse_delay))) {
-				dprintk(CVP_DBG,
+				dprintk(CVP_PWR,
 				"PM work already scheduled\n");
 			}
 		}
@@ -1393,7 +1393,7 @@ static int __iface_msgq_read(struct iris_hfi_device *device, void *pkt)
 	__strict_check(device);
 
 	if (!__core_in_valid_state(device)) {
-		dprintk(CVP_DBG, "%s - fw not in init state\n", __func__);
+		dprintk(CVP_WARN, "%s - fw not in init state\n", __func__);
 		rc = -EINVAL;
 		goto read_error_null;
 	}
@@ -1526,7 +1526,7 @@ static int __interface_dsp_queues_init(struct iris_hfi_device *dev)
 		dprintk(CVP_ERR, "%s: failed dma mapping\n", __func__);
 		goto fail_dma_map;
 	}
-	dprintk(CVP_DBG,
+	dprintk(CVP_DSP,
 		"%s: kvaddr %pK dma_handle %#llx iova %#llx size %zd\n",
 		__func__, kvaddr, dma_handle, iova, q_size);
 
@@ -1975,7 +1975,7 @@ static int iris_hfi_core_init(void *device)
 
 	dev = device;
 
-	dprintk(CVP_DBG, "Core initializing\n");
+	dprintk(CVP_CORE, "Core initializing\n");
 
 	mutex_lock(&dev->lock);
 
@@ -1999,7 +1999,7 @@ static int iris_hfi_core_init(void *device)
 	__set_state(dev, IRIS_STATE_INIT);
 	dev->reg_dumped = false;
 
-	dprintk(CVP_DBG, "Dev_Virt: %pa, Reg_Virt: %pK\n",
+	dprintk(CVP_CORE, "Dev_Virt: %pa, Reg_Virt: %pK\n",
 		&dev->cvp_hal_data->firmware_base,
 		dev->cvp_hal_data->register_base);
 
@@ -2051,7 +2051,7 @@ static int iris_hfi_core_init(void *device)
 
 	cvp_dsp_send_hfi_queue();
 
-	dprintk(CVP_DBG, "Core inited successfully\n");
+	dprintk(CVP_CORE, "Core inited successfully\n");
 
 	return 0;
 err_core_init:
@@ -2094,7 +2094,7 @@ static int iris_hfi_core_release(void *dev)
 		session->device = NULL;
 	}
 
-	dprintk(CVP_DBG, "Core released successfully\n");
+	dprintk(CVP_CORE, "Core released successfully\n");
 	mutex_unlock(&device->lock);
 
 	return rc;
@@ -2115,7 +2115,7 @@ static void __core_clear_interrupt(struct iris_hfi_device *device)
 	if (intr_status & mask) {
 		device->intr_status |= intr_status;
 		device->reg_count++;
-		dprintk(CVP_DBG,
+		dprintk(CVP_CORE,
 			"INTERRUPT for device: %pK: times: %d status: %d\n",
 			device, device->reg_count, intr_status);
 	} else {
@@ -2172,7 +2172,7 @@ static void __session_clean(struct cvp_hal_session *session)
 		return;
 	}
 	device = session->device;
-	dprintk(CVP_DBG, "deleted the session: %pK\n", session);
+	dprintk(CVP_SESS, "deleted the session: %pK\n", session);
 	/*
 	 * session might have been removed from the device list in
 	 * core_release, so check and remove if it is in the list
@@ -2237,7 +2237,7 @@ static int iris_hfi_session_init(void *device, void *session_id,
 
 	s->session_id = session_id;
 	s->device = dev;
-	dprintk(CVP_DBG,
+	dprintk(CVP_SESS,
 		"%s: inst %pK, session %pK\n", __func__, session_id, s);
 
 	list_add_tail(&s->list, &dev->sess_head);
@@ -2560,7 +2560,7 @@ static void iris_hfi_pm_handler(struct work_struct *work)
 		return;
 	}
 
-	dprintk(CVP_PROF,
+	dprintk(CVP_PWR,
 		"Entering %s\n", __func__);
 	/*
 	 * It is ok to check this variable outside the lock since
@@ -2582,12 +2582,12 @@ static void iris_hfi_pm_handler(struct work_struct *work)
 		device->skip_pc_count = 0;
 		/* Cancel pending delayed works if any */
 		cancel_delayed_work(&iris_hfi_pm_work);
-		dprintk(CVP_PROF, "%s: power collapse successful!\n",
+		dprintk(CVP_PWR, "%s: power collapse successful!\n",
 			__func__);
 		break;
 	case -EBUSY:
 		device->skip_pc_count = 0;
-		dprintk(CVP_DBG, "%s: retry PC as cvp is busy\n", __func__);
+		dprintk(CVP_PWR, "%s: retry PC as cvp is busy\n", __func__);
 		queue_delayed_work(device->iris_pm_workq,
 			&iris_hfi_pm_work, msecs_to_jiffies(
 			device->res->msm_cvp_pwr_collapse_delay));
@@ -2619,7 +2619,7 @@ static int __power_collapse(struct iris_hfi_device *device, bool force)
 		return -EINVAL;
 	}
 	if (!device->power_enabled) {
-		dprintk(CVP_DBG, "%s: Power already disabled\n",
+		dprintk(CVP_PWR, "%s: Power already disabled\n",
 				__func__);
 		goto exit;
 	}
@@ -2839,10 +2839,10 @@ static void process_system_msg(struct msm_cvp_cb_info *info,
 		__process_sys_error(device);
 		break;
 	case HAL_SYS_RELEASE_RESOURCE_DONE:
-		dprintk(CVP_DBG, "Received SYS_RELEASE_RESOURCE\n");
+		dprintk(CVP_CORE, "Received SYS_RELEASE_RESOURCE\n");
 		break;
 	case HAL_SYS_INIT_DONE:
-		dprintk(CVP_DBG, "Received SYS_INIT_DONE\n");
+		dprintk(CVP_CORE, "Received SYS_INIT_DONE\n");
 		sys_init_done.capabilities =
 			device->sys_init_capabilities;
 		cvp_hfi_process_sys_init_done_prop_read(
@@ -2914,7 +2914,7 @@ static void print_msg_hdr(void *hdr)
 {
 	struct cvp_hfi_msg_session_hdr *new_hdr =
 			(struct cvp_hfi_msg_session_hdr *)hdr;
-	dprintk(CVP_DBG, "HFI MSG received: %x %x %x %x %x %x %x\n",
+	dprintk(CVP_HFI, "HFI MSG received: %x %x %x %x %x %x %x\n",
 			new_hdr->size, new_hdr->packet_type,
 			new_hdr->session_id,
 			new_hdr->client_data.transaction_id,
@@ -3067,7 +3067,7 @@ static void iris_hfi_core_work_handler(struct work_struct *work)
 
 
 	if (!__core_in_valid_state(device)) {
-		dprintk(CVP_DBG, "%s - Core not in init state\n", __func__);
+		dprintk(CVP_WARN, "%s - Core not in init state\n", __func__);
 		goto err_no_work;
 	}
 
@@ -3084,7 +3084,7 @@ static void iris_hfi_core_work_handler(struct work_struct *work)
 
 	__core_clear_interrupt(device);
 	num_responses = __response_handler(device);
-	dprintk(CVP_DBG, "%s:: cvp_driver_debug num_responses = %d ",
+	dprintk(CVP_HFI, "%s:: cvp_driver_debug num_responses = %d ",
 		__func__, num_responses);
 
 err_no_work:
@@ -3108,7 +3108,7 @@ err_no_work:
 				_INVALID_STATE_, (i + 1), num_responses);
 			break;
 		}
-		dprintk(CVP_DBG, "Processing response %d of %d, type %d\n",
+		dprintk(CVP_HFI, "Processing response %d of %d, type %d\n",
 			(i + 1), num_responses, r->response_type);
 		device->callback(r->response_type, rsp);
 	}
@@ -3215,7 +3215,7 @@ static inline int __init_clocks(struct iris_hfi_device *device)
 
 	iris_hfi_for_each_clock(device, cl) {
 
-		dprintk(CVP_DBG, "%s: scalable? %d, count %d\n",
+		dprintk(CVP_PWR, "%s: scalable? %d, count %d\n",
 				cl->name, cl->has_scaling, cl->count);
 	}
 
@@ -3253,7 +3253,7 @@ static int __handle_reset_clk(struct msm_cvp_platform_resources *res,
 
 	rst_info = rst_set->reset_tbl[reset_index];
 	rst = rst_info.rst;
-	dprintk(CVP_DBG, "reset_clk: name %s reset_state %d rst %pK ps=%d\n",
+	dprintk(CVP_PWR, "reset_clk: name %s reset_state %d rst %pK ps=%d\n",
 		rst_set->reset_tbl[reset_index].name, state, rst, pwr_state);
 
 	switch (state) {
@@ -3313,7 +3313,7 @@ static inline void __disable_unprepare_clks(struct iris_hfi_device *device)
 	}
 
 	iris_hfi_for_each_clock_reverse(device, cl) {
-		dprintk(CVP_DBG, "Clock: %s disable and unprepare\n",
+		dprintk(CVP_PWR, "Clock: %s disable and unprepare\n",
 				cl->name);
 		clk_disable_unprepare(cl->clk);
 	}
@@ -3387,7 +3387,7 @@ static inline int __prepare_enable_clks(struct iris_hfi_device *device)
 		}
 
 		c++;
-		dprintk(CVP_DBG, "Clock: %s prepared and enabled\n", cl->name);
+		dprintk(CVP_PWR, "Clock: %s prepared and enabled\n", cl->name);
 	}
 
 	return rc;
@@ -3504,7 +3504,7 @@ static void __deinit_subcaches(struct iris_hfi_device *device)
 
 	iris_hfi_for_each_subcache_reverse(device, sinfo) {
 		if (sinfo->subcache) {
-			dprintk(CVP_DBG, "deinit_subcaches: %s\n",
+			dprintk(CVP_CORE, "deinit_subcaches: %s\n",
 				sinfo->name);
 			llcc_slice_putd(sinfo->subcache);
 			sinfo->subcache = NULL;
@@ -3547,7 +3547,7 @@ static int __init_subcaches(struct iris_hfi_device *device)
 			sinfo->subcache = NULL;
 			goto err_subcache_get;
 		}
-		dprintk(CVP_DBG, "init_subcaches: %s\n",
+		dprintk(CVP_CORE, "init_subcaches: %s\n",
 			sinfo->name);
 	}
 
@@ -3629,7 +3629,7 @@ static int __disable_regulator(struct regulator_info *rinfo,
 {
 	int rc = 0;
 
-	dprintk(CVP_DBG, "Disabling regulator %s\n", rinfo->name);
+	dprintk(CVP_PWR, "Disabling regulator %s\n", rinfo->name);
 
 	/*
 	 * This call is needed. Driver needs to acquire the control back
@@ -3672,7 +3672,7 @@ static int __enable_hw_power_collapse(struct iris_hfi_device *device)
 	int rc = 0;
 
 	if (!msm_cvp_fw_low_power_mode) {
-		dprintk(CVP_DBG, "Not enabling hardware power collapse\n");
+		dprintk(CVP_PWR, "Not enabling hardware power collapse\n");
 		return 0;
 	}
 
@@ -3689,7 +3689,7 @@ static int __enable_regulators(struct iris_hfi_device *device)
 	int rc = 0, c = 0;
 	struct regulator_info *rinfo;
 
-	dprintk(CVP_DBG, "Enabling regulators\n");
+	dprintk(CVP_PWR, "Enabling regulators\n");
 
 	iris_hfi_for_each_regulator(device, rinfo) {
 		rc = regulator_enable(rinfo->regulator);
@@ -3699,7 +3699,7 @@ static int __enable_regulators(struct iris_hfi_device *device)
 			goto err_reg_enable_failed;
 		}
 
-		dprintk(CVP_DBG, "Enabled regulator %s\n", rinfo->name);
+		dprintk(CVP_PWR, "Enabled regulator %s\n", rinfo->name);
 		c++;
 	}
 
@@ -3716,7 +3716,7 @@ static int __disable_regulators(struct iris_hfi_device *device)
 {
 	struct regulator_info *rinfo;
 
-	dprintk(CVP_DBG, "Disabling regulators\n");
+	dprintk(CVP_PWR, "Disabling regulators\n");
 
 	iris_hfi_for_each_regulator_reverse(device, rinfo) {
 		__disable_regulator(rinfo, device);
@@ -3747,11 +3747,11 @@ static int __enable_subcaches(struct iris_hfi_device *device)
 			goto err_activate_fail;
 		}
 		sinfo->isactive = true;
-		dprintk(CVP_DBG, "Activated subcache %s\n", sinfo->name);
+		dprintk(CVP_CORE, "Activated subcache %s\n", sinfo->name);
 		c++;
 	}
 
-	dprintk(CVP_DBG, "Activated %d Subcaches to CVP\n", c);
+	dprintk(CVP_CORE, "Activated %d Subcaches to CVP\n", c);
 
 	return 0;
 
@@ -3772,7 +3772,7 @@ static int __set_subcaches(struct iris_hfi_device *device)
 	struct cvp_resource_hdr rhdr;
 
 	if (device->res->sys_cache_res_set || msm_cvp_syscache_disable) {
-		dprintk(CVP_DBG, "Subcaches already set or disabled\n");
+		dprintk(CVP_CORE, "Subcaches already set or disabled\n");
 		return 0;
 	}
 
@@ -3791,7 +3791,7 @@ static int __set_subcaches(struct iris_hfi_device *device)
 
 	/* Set resource to CVP for activated subcaches */
 	if (c) {
-		dprintk(CVP_DBG, "Setting %d Subcaches\n", c);
+		dprintk(CVP_CORE, "Setting %d Subcaches\n", c);
 
 		rhdr.resource_handle = sc_res_info; /* cookie */
 		rhdr.resource_id = CVP_RESOURCE_SYSCACHE;
@@ -3809,7 +3809,7 @@ static int __set_subcaches(struct iris_hfi_device *device)
 				sinfo->isset = true;
 		}
 
-		dprintk(CVP_DBG, "Set Subcaches done to CVP\n");
+		dprintk(CVP_CORE, "Set Subcaches done to CVP\n");
 		device->res->sys_cache_res_set = true;
 	}
 
@@ -3851,7 +3851,7 @@ static int __release_subcaches(struct iris_hfi_device *device)
 	}
 
 	if (c > 0) {
-		dprintk(CVP_DBG, "Releasing %d subcaches\n", c);
+		dprintk(CVP_CORE, "Releasing %d subcaches\n", c);
 		rhdr.resource_handle = sc_res_info; /* cookie */
 		rhdr.resource_id = CVP_RESOURCE_SYSCACHE;
 
@@ -3877,7 +3877,7 @@ static int __disable_subcaches(struct iris_hfi_device *device)
 	/* De-activate subcaches */
 	iris_hfi_for_each_subcache_reverse(device, sinfo) {
 		if (sinfo->isactive) {
-			dprintk(CVP_DBG, "De-activate subcache %s\n",
+			dprintk(CVP_CORE, "De-activate subcache %s\n",
 				sinfo->name);
 			rc = llcc_slice_deactivate(sinfo->subcache);
 			if (rc) {
@@ -3902,7 +3902,7 @@ static void interrupt_init_iris2(struct iris_hfi_device *device)
 	/* Write 0 to unmask CPU and WD interrupts */
 	mask_val &= ~(CVP_FATAL_INTR_BMSK | CVP_WRAPPER_INTR_MASK_A2HCPU_BMSK);
 	__write_register(device, CVP_WRAPPER_INTR_MASK, mask_val);
-	dprintk(CVP_DBG, "Init irq: reg: %x, mask value %x\n",
+	dprintk(CVP_REG, "Init irq: reg: %x, mask value %x\n",
 		CVP_WRAPPER_INTR_MASK, mask_val);
 }
 
@@ -3995,16 +3995,16 @@ static int __iris_power_on(struct iris_hfi_device *device)
 	/*Do not access registers before this point!*/
 	device->power_enabled = true;
 
-	dprintk(CVP_DBG, "Done with scaling\n");
+	dprintk(CVP_PWR, "Done with scaling\n");
 	/*
 	 * Re-program all of the registers that get reset as a result of
 	 * regulator_disable() and _enable()
 	 */
 	__set_registers(device);
 
-	dprintk(CVP_DBG, "Done with register set\n");
+	dprintk(CVP_CORE, "Done with register set\n");
 	call_iris_op(device, interrupt_init, device);
-	dprintk(CVP_DBG, "Done with interrupt enabling\n");
+	dprintk(CVP_CORE, "Done with interrupt enabling\n");
 	device->intr_status = 0;
 	enable_irq(device->cvp_hal_data->irq);
 
@@ -4054,11 +4054,11 @@ static inline int __suspend(struct iris_hfi_device *device)
 		dprintk(CVP_ERR, "Invalid params: %pK\n", device);
 		return -EINVAL;
 	} else if (!device->power_enabled) {
-		dprintk(CVP_DBG, "Power already disabled\n");
+		dprintk(CVP_PWR, "Power already disabled\n");
 		return 0;
 	}
 
-	dprintk(CVP_PROF, "Entering suspend\n");
+	dprintk(CVP_PWR, "Entering suspend\n");
 
 	if (device->res->pm_qos_latency_us &&
 		pm_qos_request_active(&device->qos))
@@ -4073,7 +4073,7 @@ static inline int __suspend(struct iris_hfi_device *device)
 	__disable_subcaches(device);
 
 	call_iris_op(device, power_off, device);
-	dprintk(CVP_PROF, "Iris power off\n");
+	dprintk(CVP_PWR, "Iris power off\n");
 	return rc;
 
 err_tzbsp_suspend:
@@ -4107,7 +4107,7 @@ static void power_off_iris2(struct iris_hfi_device *device)
 		usleep_range(50, 100);
 		count++;
 	}
-	dprintk(CVP_DBG,
+	dprintk(CVP_PWR,
 		"Noc: lpi_status %x noc_status %x (count %d)\n",
 		lpi_status, reg_status, count);
 	if (count == max_count) {
@@ -4142,7 +4142,7 @@ static void power_off_iris2(struct iris_hfi_device *device)
 		usleep_range(50, 100);
 		count++;
 	}
-	dprintk(CVP_DBG,
+	dprintk(CVP_PWR,
 		"DBLP Release: lpi_status %d(count %d)\n",
 		lpi_status, count);
 	if (count == max_count) {
@@ -4179,11 +4179,11 @@ static inline int __resume(struct iris_hfi_device *device)
 	} else if (device->power_enabled) {
 		goto exit;
 	} else if (!__core_in_valid_state(device)) {
-		dprintk(CVP_DBG, "iris_hfi_device in deinit state.");
+		dprintk(CVP_PWR, "iris_hfi_device in deinit state.");
 		return -EINVAL;
 	}
 
-	dprintk(CVP_PROF, "Resuming from power collapse\n");
+	dprintk(CVP_PWR, "Resuming from power collapse\n");
 	rc = __iris_power_on(device);
 	if (rc) {
 		dprintk(CVP_ERR, "Failed to power on cvp\n");
@@ -4223,7 +4223,7 @@ static inline int __resume(struct iris_hfi_device *device)
 
 	__dsp_resume(device, flags);
 
-	dprintk(CVP_PROF, "Resumed from power collapse\n");
+	dprintk(CVP_PWR, "Resumed from power collapse\n");
 exit:
 	/* Don't reset skip_pc_count for SYS_PC_PREP cmd */
 	if (device->last_packet_type != HFI_CMD_SYS_PC_PREP)
@@ -4343,7 +4343,7 @@ static int iris_hfi_get_fw_info(void *dev, struct cvp_hal_fw_info *fw_info)
 	fw_info->version[CVP_VERSION_LENGTH - 1] = '\0';
 
 fail_version_string:
-	dprintk(CVP_DBG, "F/W version retrieved : %s\n", fw_info->version);
+	dprintk(CVP_CORE, "F/W version retrieved : %s\n", fw_info->version);
 	fw_info->base_addr = device->cvp_hal_data->firmware_base;
 	fw_info->register_base = device->res->register_base;
 	fw_info->register_size = device->cvp_hal_data->register_size;
@@ -4355,7 +4355,7 @@ fail_version_string:
 
 static int iris_hfi_get_core_capabilities(void *dev)
 {
-	dprintk(CVP_DBG, "%s not supported yet!\n", __func__);
+	dprintk(CVP_CORE, "%s not supported yet!\n", __func__);
 	return 0;
 }
 
diff --git a/drivers/media/platform/msm/cvp/hfi_packetization.c b/drivers/media/platform/msm/cvp/hfi_packetization.c
index 846b2208dee3..107e2d744fff 100644
--- a/drivers/media/platform/msm/cvp/hfi_packetization.c
+++ b/drivers/media/platform/msm/cvp/hfi_packetization.c
@@ -79,7 +79,7 @@ int cvp_create_pkt_cmd_sys_coverage_config(
 	pkt->num_properties = 1;
 	pkt->rg_property_data[0] = HFI_PROPERTY_SYS_CONFIG_COVERAGE;
 	pkt->rg_property_data[1] = mode;
-	dprintk(CVP_DBG, "Firmware coverage mode %d\n",
+	dprintk(CVP_PKT, "Firmware coverage mode %d\n",
 			pkt->rg_property_data[1]);
 	return 0;
 }
@@ -99,7 +99,7 @@ int cvp_create_pkt_cmd_sys_set_idle_indicator(
 	pkt->num_properties = 1;
 	pkt->rg_property_data[0] = HFI_PROPERTY_SYS_IDLE_INDICATOR;
 	pkt->rg_property_data[1] = mode;
-	dprintk(CVP_DBG, "Firmware idle indicator mode %d\n",
+	dprintk(CVP_PKT, "Firmware idle indicator mode %d\n",
 			pkt->rg_property_data[1]);
 	return 0;
 }
@@ -148,7 +148,7 @@ int cvp_create_pkt_cmd_sys_set_resource(
 
 		for (i = 0; i < hfi_sc_info->num_entries; i++) {
 			hfi_sc[i] = res_sc[i];
-		dprintk(CVP_DBG, "entry hfi#%d, sc_id %d, size %d\n",
+		dprintk(CVP_PKT, "entry hfi#%d, sc_id %d, size %d\n",
 				 i, hfi_sc[i].sc_id, hfi_sc[i].size);
 		}
 		break;
@@ -189,7 +189,7 @@ int cvp_create_pkt_cmd_sys_release_resource(
 		rc = -ENOTSUPP;
 	}
 
-	dprintk(CVP_DBG,
+	dprintk(CVP_PKT,
 		"rel_res: pkt_type 0x%x res_type 0x%x prepared\n",
 		pkt->packet_type, pkt->resource_type);
 
@@ -449,7 +449,7 @@ static struct cvp_hfi_packetization_ops hfi_default = {
 struct cvp_hfi_packetization_ops *cvp_hfi_get_pkt_ops_handle(
 			enum hfi_packetization_type type)
 {
-	dprintk(CVP_DBG, "%s selected\n",
+	dprintk(CVP_HFI, "%s selected\n",
 		type == HFI_PACKETIZATION_4XX ?
 		"4xx packetization" : "Unknown hfi");
 
diff --git a/drivers/media/platform/msm/cvp/hfi_response_handler.c b/drivers/media/platform/msm/cvp/hfi_response_handler.c
index 6d5417feff23..9a7b0c44ba61 100644
--- a/drivers/media/platform/msm/cvp/hfi_response_handler.c
+++ b/drivers/media/platform/msm/cvp/hfi_response_handler.c
@@ -121,7 +121,7 @@ static int hfi_process_event_notify(u32 device_id,
 	struct cvp_hfi_msg_event_notify_packet *pkt =
 			(struct cvp_hfi_msg_event_notify_packet *)hdr;
 
-	dprintk(CVP_DBG, "Received: EVENT_NOTIFY\n");
+	dprintk(CVP_HFI, "Received: EVENT_NOTIFY\n");
 
 	if (pkt->size < sizeof(struct cvp_hfi_msg_event_notify_packet)) {
 		dprintk(CVP_ERR, "Invalid Params\n");
@@ -156,14 +156,14 @@ static int hfi_process_sys_init_done(u32 device_id,
 	struct msm_cvp_cb_cmd_done cmd_done = {0};
 	enum cvp_status status = CVP_ERR_NONE;
 
-	dprintk(CVP_DBG, "RECEIVED: SYS_INIT_DONE\n");
+	dprintk(CVP_CORE, "RECEIVED: SYS_INIT_DONE\n");
 	if (sizeof(struct cvp_hfi_msg_sys_init_done_packet) > pkt->size) {
 		dprintk(CVP_ERR, "%s: bad_pkt_size: %d\n", __func__,
 				pkt->size);
 		return -E2BIG;
 	}
 	if (!pkt->num_properties) {
-		dprintk(CVP_DBG,
+		dprintk(CVP_CORE,
 				"hal_process_sys_init_done: no_properties\n");
 		goto err_no_prop;
 	}
@@ -218,7 +218,7 @@ enum cvp_status cvp_hfi_process_sys_init_done_prop_read(
 
 	data_ptr = (u8 *) &pkt->rg_property_data[0];
 	num_properties = pkt->num_properties;
-	dprintk(CVP_DBG,
+	dprintk(CVP_HFI,
 		"%s: data_start %pK, num_properties %#x\n",
 		__func__, data_ptr, num_properties);
 
@@ -234,7 +234,7 @@ static int hfi_process_session_init_done(u32 device_id,
 	struct msm_cvp_cb_cmd_done cmd_done = {0};
 	struct cvp_hal_session_init_done session_init_done = { {0} };
 
-	dprintk(CVP_DBG, "RECEIVED: SESSION_INIT_DONE[%x]\n", pkt->session_id);
+	dprintk(CVP_SESS, "RECEIVED: SESSION_INIT_DONE[%x]\n", pkt->session_id);
 
 	if (sizeof(struct cvp_hfi_msg_sys_session_init_done_packet)
 			> pkt->size) {
@@ -261,7 +261,7 @@ static int hfi_process_session_end_done(u32 device_id,
 			(struct cvp_hfi_msg_sys_session_end_done_packet *)hdr;
 	struct msm_cvp_cb_cmd_done cmd_done = {0};
 
-	dprintk(CVP_DBG, "RECEIVED: SESSION_END_DONE[%#x]\n", pkt->session_id);
+	dprintk(CVP_SESS, "RECEIVED: SESSION_END_DONE[%#x]\n", pkt->session_id);
 
 	if (!pkt || pkt->size !=
 		sizeof(struct cvp_hfi_msg_sys_session_end_done_packet)) {
@@ -287,7 +287,7 @@ static int hfi_process_session_abort_done(u32 device_id,
 		(struct cvp_hfi_msg_sys_session_abort_done_packet *)hdr;
 	struct msm_cvp_cb_cmd_done cmd_done = {0};
 
-	dprintk(CVP_DBG, "RECEIVED: SESSION_ABORT_DONE[%#x]\n",
+	dprintk(CVP_SESS, "RECEIVED: SESSION_ABORT_DONE[%#x]\n",
 			pkt->session_id);
 
 	if (!pkt || pkt->size !=
@@ -320,7 +320,7 @@ static int hfi_process_session_set_buf_done(u32 device_id,
 				pkt ? pkt->size : 0);
 		return -E2BIG;
 	}
-	dprintk(CVP_DBG, "RECEIVED:CVP_SET_BUFFER_DONE[%#x]\n",
+	dprintk(CVP_SESS, "RECEIVED:CVP_SET_BUFFER_DONE[%#x]\n",
 			pkt->session_id);
 
 	cmd_done.device_id = device_id;
@@ -341,7 +341,7 @@ static int hfi_process_session_flush_done(u32 device_id,
 		(struct cvp_hfi_msg_sys_session_flush_done_packet *)hdr;
 	struct msm_cvp_cb_cmd_done cmd_done = {0};
 
-	dprintk(CVP_DBG, "RECEIVED: SESSION_FLUSH_DONE[%#x]\n",
+	dprintk(CVP_SESS, "RECEIVED: SESSION_FLUSH_DONE[%#x]\n",
 			pkt->session_id);
 
 	if (!pkt || pkt->size <
@@ -374,7 +374,7 @@ static int hfi_process_session_rel_buf_done(u32 device_id,
 				pkt ? pkt->size : 0);
 		return -E2BIG;
 	}
-	dprintk(CVP_DBG, "RECEIVED:CVP_RELEASE_BUFFER_DONE[%#x]\n",
+	dprintk(CVP_SESS, "RECEIVED:CVP_RELEASE_BUFFER_DONE[%#x]\n",
 			pkt->session_id);
 
 	cmd_done.device_id = device_id;
@@ -412,7 +412,7 @@ static int hfi_process_session_cvp_operation_config(u32 device_id,
 	cmd_done.status = hfi_map_err_status(error_type);
 	cmd_done.size = 0;
 
-	dprintk(CVP_DBG,
+	dprintk(CVP_HFI,
 		"%s: device_id=%d status=%d, sessionid=%pK config=%x\n",
 		__func__, device_id, cmd_done.status,
 		cmd_done.session_id, pkt->op_conf_id);
@@ -516,7 +516,7 @@ static int hfi_process_session_cvp_msg(u32 device_id,
 
 	memcpy(&sess_msg->pkt, pkt, get_msg_size());
 
-	dprintk(CVP_DBG,
+	dprintk(CVP_HFI,
 		"%s: Received msg %x cmd_done.status=%d sessionid=%x\n",
 		__func__, pkt->packet_type,
 		hfi_map_err_status(get_msg_errorcode(pkt)), session_id);
@@ -570,7 +570,7 @@ static void hfi_process_sys_get_prop_image_version(
 			cvp_driver->fw_version[i] = ' ';
 	}
 	cvp_driver->fw_version[i] = '\0';
-	dprintk(CVP_DBG, "F/W version: %s\n", cvp_driver->fw_version);
+	dprintk(CVP_HFI, "F/W version: %s\n", cvp_driver->fw_version);
 }
 
 static int hfi_process_sys_property_info(u32 device_id,
@@ -600,7 +600,7 @@ static int hfi_process_sys_property_info(u32 device_id,
 		};
 		return 0;
 	default:
-		dprintk(CVP_DBG,
+		dprintk(CVP_WARN,
 				"%s: unknown_prop_id: %x\n",
 				__func__, pkt->rg_property_data[0]);
 		return -ENOTSUPP;
@@ -621,7 +621,7 @@ int cvp_hfi_process_msg_packet(u32 device_id, void *hdr,
 		return -EINVAL;
 	}
 
-	dprintk(CVP_DBG, "Received HFI MSG with type %#x\n", msg_hdr->packet);
+	dprintk(CVP_HFI, "Received HFI MSG with type %#x\n", msg_hdr->packet);
 	switch (msg_hdr->packet) {
 	case HFI_MSG_EVENT_NOTIFY:
 		pkt_func = (pkt_func_def)hfi_process_event_notify;
@@ -664,7 +664,7 @@ int cvp_hfi_process_msg_packet(u32 device_id, void *hdr,
 		pkt_func = (pkt_func_def)hfi_process_session_cvp_msg;
 		break;
 	default:
-		dprintk(CVP_DBG, "Use default msg handler: %#x\n",
+		dprintk(CVP_HFI, "Use default msg handler: %#x\n",
 				msg_hdr->packet);
 		pkt_func = (pkt_func_def)hfi_process_session_cvp_msg;
 		break;
diff --git a/drivers/media/platform/msm/cvp/msm_cvp.c b/drivers/media/platform/msm/cvp/msm_cvp.c
index 5e246e54a9a3..7c0a99988e84 100644
--- a/drivers/media/platform/msm/cvp/msm_cvp.c
+++ b/drivers/media/platform/msm/cvp/msm_cvp.c
@@ -31,7 +31,7 @@ static int msm_cvp_get_session_info(struct msm_cvp_inst *inst,
 
 	s->cur_cmd_type = CVP_KMD_GET_SESSION_INFO;
 	session->session_id = hash32_ptr(inst->session);
-	dprintk(CVP_DBG, "%s: id 0x%x\n", __func__, session->session_id);
+	dprintk(CVP_SESS, "%s: id 0x%x\n", __func__, session->session_id);
 
 	s->cur_cmd_type = 0;
 	cvp_put_inst(s);
@@ -291,7 +291,7 @@ static int cvp_fence_dme(struct msm_cvp_inst *inst,
 	u32 hfi_err = HFI_ERR_NONE;
 	struct cvp_hfi_msg_session_hdr *hdr;
 
-	dprintk(CVP_DBG, "%s %s\n", current->comm, __func__);
+	dprintk(CVP_SYNX, "%s %s\n", current->comm, __func__);
 
 	hdev = inst->core->device;
 	sq = &inst->session_queue_fence;
@@ -321,7 +321,7 @@ static int cvp_fence_dme(struct msm_cvp_inst *inst,
 		goto exit;
 	}
 	if (hfi_err == HFI_ERR_SESSION_FLUSHED) {
-		dprintk(CVP_DBG, "%s %s: cvp_wait_process_message flushed\n",
+		dprintk(CVP_SYNX, "%s %s: cvp_wait_process_message flushed\n",
 			current->comm, __func__);
 		synx_state = SYNX_STATE_SIGNALED_CANCEL;
 	} else if (hfi_err == HFI_ERR_SESSION_STREAM_CORRUPT) {
@@ -353,7 +353,7 @@ static int cvp_fence_proc(struct msm_cvp_inst *inst,
 	u32 hfi_err = HFI_ERR_NONE;
 	struct cvp_hfi_msg_session_hdr *hdr;
 
-	dprintk(CVP_DBG, "%s %s\n", current->comm, __func__);
+	dprintk(CVP_SYNX, "%s %s\n", current->comm, __func__);
 
 	hdev = inst->core->device;
 	sq = &inst->session_queue_fence;
@@ -383,7 +383,7 @@ static int cvp_fence_proc(struct msm_cvp_inst *inst,
 		goto exit;
 	}
 	if (hfi_err == HFI_ERR_SESSION_FLUSHED) {
-		dprintk(CVP_DBG, "%s %s: cvp_wait_process_message flushed\n",
+		dprintk(CVP_SYNX, "%s %s: cvp_wait_process_message flushed\n",
 			current->comm, __func__);
 		synx_state = SYNX_STATE_SIGNALED_CANCEL;
 	} else if (hfi_err != HFI_ERR_NONE) {
@@ -435,7 +435,7 @@ static int cvp_fence_thread(void *data)
 	u32 *synx;
 	u64 ktid;
 
-	dprintk(CVP_DBG, "Enter %s\n", current->comm);
+	dprintk(CVP_SYNX, "Enter %s\n", current->comm);
 
 	inst = (struct msm_cvp_inst *)data;
 	if (!inst || !inst->core || !inst->core->device) {
@@ -447,7 +447,7 @@ static int cvp_fence_thread(void *data)
 	q = &inst->fence_cmd_queue;
 
 wait:
-	dprintk(CVP_DBG, "%s starts wait\n", current->comm);
+	dprintk(CVP_SYNX, "%s starts wait\n", current->comm);
 
 	f = NULL;
 	wait_event_interruptible(q->wq, cvp_fence_wait(q, &f, &state));
@@ -461,7 +461,7 @@ wait:
 	synx = (u32 *)f->synx;
 
 	ktid = pkt->client_data.kdata & (FENCE_BIT - 1);
-	dprintk(CVP_DBG, "%s starts working on frame %llu frameID %llu\n",
+	dprintk(CVP_SYNX, "%s starts working on frame %llu frameID %llu\n",
 		current->comm, ktid, f->frame_id);
 
 	switch (f->type) {
@@ -484,7 +484,7 @@ wait:
 	list_del_init(&f->list);
 	mutex_unlock(&q->lock);
 
-	dprintk(CVP_DBG, "%s is done with frame %llu frameID %llu\n",
+	dprintk(CVP_SYNX, "%s is done with frame %llu frameID %llu\n",
 		current->comm, ktid, f->frame_id);
 
 	cvp_free_fence_data(f);
@@ -492,7 +492,7 @@ wait:
 	goto wait;
 
 exit:
-	dprintk(CVP_DBG, "%s exit\n", current->comm);
+	dprintk(CVP_SYNX, "%s exit\n", current->comm);
 	cvp_put_inst(inst);
 	do_exit(rc);
 }
@@ -529,7 +529,7 @@ static int msm_cvp_session_process_hfi_fence(struct msm_cvp_inst *inst,
 	mutex_unlock(&q->lock);
 
 	if (mode == OP_DRAINING) {
-		dprintk(CVP_DBG, "%s: flush in progress\n", __func__);
+		dprintk(CVP_SYNX, "%s: flush in progress\n", __func__);
 		rc = -EBUSY;
 		goto exit;
 	}
@@ -585,7 +585,7 @@ static int msm_cvp_session_process_hfi_fence(struct msm_cvp_inst *inst,
 	}
 
 
-	dprintk(CVP_DBG, "%s: frameID %llu\n", __func__, f->frame_id);
+	dprintk(CVP_SYNX, "%s: frameID %llu\n", __func__, f->frame_id);
 
 	memcpy(f->pkt, pkt, pkt->size);
 
@@ -760,7 +760,7 @@ static int adjust_bw_freqs(void)
 	min_bw = max_bw/10;
 
 	aggregate_power_update(core, &nrt_pwr, &rt_pwr, cvp_max_rate);
-	dprintk(CVP_DBG, "PwrUpdate nrt %u %u rt %u %u\n",
+	dprintk(CVP_PROF, "PwrUpdate nrt %u %u rt %u %u\n",
 		nrt_pwr.core_sum, nrt_pwr.op_core_sum,
 		rt_pwr.core_sum, rt_pwr.op_core_sum);
 
@@ -873,7 +873,7 @@ static int msm_cvp_register_buffer(struct msm_cvp_inst *inst,
 		goto exit;
 	}
 	hdev = inst->core->device;
-	print_client_buffer(CVP_DBG, "register", inst, buf);
+	print_client_buffer(CVP_HFI, "register", inst, buf);
 
 	rc = msm_cvp_map_buf_dsp(inst, buf);
 exit:
@@ -901,7 +901,7 @@ static int msm_cvp_unregister_buffer(struct msm_cvp_inst *inst,
 		return -ECONNRESET;
 
 	inst->cur_cmd_type = CVP_KMD_UNREGISTER_BUFFER;
-	print_client_buffer(CVP_DBG, "unregister", inst, buf);
+	print_client_buffer(CVP_HFI, "unregister", inst, buf);
 
 	rc = msm_cvp_unmap_buf_dsp(inst, buf);
 	inst->cur_cmd_type = 0;
@@ -1269,7 +1269,7 @@ static int cvp_drain_fence_cmd_queue_partial(struct msm_cvp_inst *inst)
 	mutex_unlock(&q->lock);
 	wait_time = count * CVP_MAX_WAIT_TIME * 1000;
 
-	dprintk(CVP_DBG, "%s: wait %d us for %d fence command\n",
+	dprintk(CVP_SYNX, "%s: wait %d us for %d fence command\n",
 			__func__, wait_time, count);
 
 	count = 0;
@@ -1313,16 +1313,16 @@ static int cvp_drain_fence_sched_list(struct msm_cvp_inst *inst)
 	mutex_lock(&q->lock);
 	list_for_each_entry(f, &q->sched_list, list) {
 		ktid = f->pkt->client_data.kdata & (FENCE_BIT - 1);
-		dprintk(CVP_DBG, "%s: frame %llu is in sched_list\n",
+		dprintk(CVP_SYNX, "%s: frame %llu is in sched_list\n",
 			__func__, ktid);
-		dprintk(CVP_DBG, "%s: frameID %llu is in sched_list\n",
+		dprintk(CVP_SYNX, "%s: frameID %llu is in sched_list\n",
 			__func__, f->frame_id);
 		++count;
 	}
 	mutex_unlock(&q->lock);
 	wait_time = count * CVP_MAX_WAIT_TIME * 1000;
 
-	dprintk(CVP_DBG, "%s: wait %d us for %d fence command\n",
+	dprintk(CVP_SYNX, "%s: wait %d us for %d fence command\n",
 			__func__, wait_time, count);
 
 	count = 0;
@@ -1375,9 +1375,9 @@ static int cvp_flush_all(struct msm_cvp_inst *inst)
 	list_for_each_entry_safe(f, d, &q->wait_list, list) {
 		ktid = f->pkt->client_data.kdata & (FENCE_BIT - 1);
 
-		dprintk(CVP_DBG, "%s: flush frame %llu from wait_list\n",
+		dprintk(CVP_SESS, "%s: flush frame %llu from wait_list\n",
 			__func__, ktid);
-		dprintk(CVP_DBG, "%s: flush frameID %llu from wait_list\n",
+		dprintk(CVP_SESS, "%s: flush frameID %llu from wait_list\n",
 			__func__, f->frame_id);
 
 		list_del_init(&f->list);
@@ -1390,16 +1390,16 @@ static int cvp_flush_all(struct msm_cvp_inst *inst)
 	list_for_each_entry(f, &q->sched_list, list) {
 		ktid = f->pkt->client_data.kdata & (FENCE_BIT - 1);
 
-		dprintk(CVP_DBG, "%s: flush frame %llu from sched_list\n",
+		dprintk(CVP_SESS, "%s: flush frame %llu from sched_list\n",
 			__func__, ktid);
-		dprintk(CVP_DBG, "%s: flush frameID %llu from sched_list\n",
+		dprintk(CVP_SESS, "%s: flush frameID %llu from sched_list\n",
 			__func__, f->frame_id);
 		cvp_cancel_synx(inst, CVP_INPUT_SYNX, f);
 	}
 
 	mutex_unlock(&q->lock);
 
-	dprintk(CVP_DBG, "%s: send flush to fw\n", __func__);
+	dprintk(CVP_SESS, "%s: send flush to fw\n", __func__);
 
 	/* Send flush to FW */
 	rc = call_hfi_op(hdev, session_flush, (void *)inst->session);
@@ -1415,7 +1415,7 @@ static int cvp_flush_all(struct msm_cvp_inst *inst)
 		dprintk(CVP_WARN, "%s: wait for signal failed, rc %d\n",
 		__func__, rc);
 
-	dprintk(CVP_DBG, "%s: received flush from fw\n", __func__);
+	dprintk(CVP_SESS, "%s: received flush from fw\n", __func__);
 
 exit:
 	rc = cvp_drain_fence_sched_list(inst);
@@ -1491,9 +1491,9 @@ static int cvp_flush_frame(struct msm_cvp_inst *inst, u64 frame_id)
 
 		ktid = f->pkt->client_data.kdata & (FENCE_BIT - 1);
 
-		dprintk(CVP_DBG, "%s: flush frame %llu from wait_list\n",
+		dprintk(CVP_SESS, "%s: flush frame %llu from wait_list\n",
 			__func__, ktid);
-		dprintk(CVP_DBG, "%s: flush frameID %llu from wait_list\n",
+		dprintk(CVP_SESS, "%s: flush frameID %llu from wait_list\n",
 			__func__, f->frame_id);
 
 		list_del_init(&f->list);
@@ -1509,9 +1509,9 @@ static int cvp_flush_frame(struct msm_cvp_inst *inst, u64 frame_id)
 
 		ktid = f->pkt->client_data.kdata & (FENCE_BIT - 1);
 
-		dprintk(CVP_DBG, "%s: flush frame %llu from sched_list\n",
+		dprintk(CVP_SESS, "%s: flush frame %llu from sched_list\n",
 			__func__, ktid);
-		dprintk(CVP_DBG, "%s: flush frameID %llu from sched_list\n",
+		dprintk(CVP_SESS, "%s: flush frameID %llu from sched_list\n",
 			__func__, f->frame_id);
 		cvp_cancel_synx(inst, CVP_INPUT_SYNX, f);
 	}
@@ -1537,7 +1537,7 @@ int msm_cvp_handle_syscall(struct msm_cvp_inst *inst, struct cvp_kmd_arg *arg)
 		dprintk(CVP_ERR, "%s: invalid args\n", __func__);
 		return -EINVAL;
 	}
-	dprintk(CVP_DBG, "%s: arg->type = %x", __func__, arg->type);
+	dprintk(CVP_HFI, "%s: arg->type = %x", __func__, arg->type);
 
 	if (arg->type != CVP_KMD_SESSION_CONTROL &&
 		arg->type != CVP_KMD_SET_SYS_PROPERTY &&
@@ -1619,7 +1619,7 @@ int msm_cvp_handle_syscall(struct msm_cvp_inst *inst, struct cvp_kmd_arg *arg)
 		rc = cvp_flush_frame(inst, arg->data.frame_id);
 		break;
 	default:
-		dprintk(CVP_DBG, "%s: unknown arg type %#x\n",
+		dprintk(CVP_HFI, "%s: unknown arg type %#x\n",
 				__func__, arg->type);
 		rc = -ENOTSUPP;
 		break;
@@ -1637,7 +1637,7 @@ int msm_cvp_session_deinit(struct msm_cvp_inst *inst)
 		dprintk(CVP_ERR, "%s: invalid params\n", __func__);
 		return -EINVAL;
 	}
-	dprintk(CVP_DBG, "%s: inst %pK (%#x)\n", __func__,
+	dprintk(CVP_SESS, "%s: inst %pK (%#x)\n", __func__,
 		inst, hash32_ptr(inst->session));
 
 	session = (struct cvp_hal_session *)inst->session;
@@ -1661,7 +1661,7 @@ int msm_cvp_session_init(struct msm_cvp_inst *inst)
 		return -EINVAL;
 	}
 
-	dprintk(CVP_DBG, "%s: inst %pK (%#x)\n", __func__,
+	dprintk(CVP_SESS, "%s: inst %pK (%#x)\n", __func__,
 		inst, hash32_ptr(inst->session));
 
 	/* set default frequency */
diff --git a/drivers/media/platform/msm/cvp/msm_cvp_buf.c b/drivers/media/platform/msm/cvp/msm_cvp_buf.c
index 7aa7d12d26c1..7793092fbdd5 100644
--- a/drivers/media/platform/msm/cvp/msm_cvp_buf.c
+++ b/drivers/media/platform/msm/cvp/msm_cvp_buf.c
@@ -126,7 +126,7 @@ int msm_cvp_map_buf_dsp(struct msm_cvp_inst *inst, struct cvp_kmd_buffer *buf)
 
 	smem->dma_buf = dma_buf;
 	smem->bitmap_index = MAX_DMABUF_NUMS;
-	dprintk(CVP_ERR, "%s: dma_buf = %llx\n", __func__, dma_buf);
+	dprintk(CVP_DSP, "%s: dma_buf = %llx\n", __func__, dma_buf);
 	rc = msm_cvp_map_smem(inst, smem);
 	if (rc) {
 		print_client_buffer(CVP_ERR, "map failed", inst, buf);
@@ -234,7 +234,7 @@ void msm_cvp_cache_operations(struct msm_cvp_smem *smem, u32 type,
 	enum smem_cache_ops cache_op;
 
 	if (!msm_cvp_cacheop_enabled) {
-		dprintk(CVP_DBG, "%s: cache operation not enabled\n", __func__);
+		dprintk(CVP_MEM, "%s: cache operation not enabled\n", __func__);
 		return;
 	}
 
@@ -280,7 +280,7 @@ static struct msm_cvp_smem *msm_cvp_session_find_smem(struct msm_cvp_inst *inst,
 			 */
 			msm_cvp_smem_put_dma_buf(smem->dma_buf);
 			mutex_unlock(&inst->dma_cache.lock);
-			print_smem(CVP_DBG, "found", inst, smem);
+			print_smem(CVP_MEM, "found", inst, smem);
 			return smem;
 		}
 
@@ -408,7 +408,7 @@ static u32 msm_cvp_map_user_persist_buf(struct msm_cvp_inst *inst,
 	list_add_tail(&pbuf->list, &inst->persistbufs.list);
 	mutex_unlock(&inst->persistbufs.lock);
 
-	print_internal_buffer(CVP_DBG, "map persist", inst, pbuf);
+	print_internal_buffer(CVP_MEM, "map persist", inst, pbuf);
 
 	iova = smem->device_addr + buf->offset;
 
@@ -448,7 +448,7 @@ u32 msm_cvp_map_frame_buf(struct msm_cvp_inst *inst,
 	frame->bufs[nr].size = buf->size;
 	frame->bufs[nr].offset = buf->offset;
 
-	print_internal_buffer(CVP_DBG, "map cpu", inst, &frame->bufs[nr]);
+	print_internal_buffer(CVP_MEM, "map cpu", inst, &frame->bufs[nr]);
 
 	frame->nr++;
 
@@ -501,7 +501,7 @@ void msm_cvp_unmap_frame(struct msm_cvp_inst *inst, u64 ktid)
 	}
 
 	ktid &= (FENCE_BIT - 1);
-	dprintk(CVP_DBG, "%s: unmap frame %llu\n", __func__, ktid);
+	dprintk(CVP_MEM, "%s: unmap frame %llu\n", __func__, ktid);
 
 	found = false;
 	mutex_lock(&inst->frames.lock);
@@ -544,7 +544,7 @@ int msm_cvp_unmap_user_persist(struct msm_cvp_inst *inst,
 				list_del(&pbuf->list);
 				smem = pbuf->smem;
 
-				dprintk(CVP_DBG, "unmap persist: %x %d %d %#x",
+				dprintk(CVP_MEM, "unmap persist: %x %d %d %#x",
 					hash32_ptr(inst->session), pbuf->fd,
 					pbuf->size, smem->device_addr);
 
@@ -698,7 +698,7 @@ int msm_cvp_map_frame(struct msm_cvp_inst *inst,
 	mutex_lock(&inst->frames.lock);
 	list_add_tail(&frame->list, &inst->frames.list);
 	mutex_unlock(&inst->frames.lock);
-	dprintk(CVP_DBG, "%s: map frame %llu\n", __func__, ktid);
+	dprintk(CVP_MEM, "%s: map frame %llu\n", __func__, ktid);
 
 	return 0;
 }
@@ -724,7 +724,7 @@ int msm_cvp_session_deinit_buffers(struct msm_cvp_inst *inst)
 	for (i = 0; i < inst->dma_cache.nr; i++) {
 		smem = inst->dma_cache.entries[i];
 		if (atomic_read(&smem->refcount) == 0) {
-			print_smem(CVP_DBG, "free", inst, smem);
+			print_smem(CVP_MEM, "free", inst, smem);
 		} else {
 			print_smem(CVP_WARN, "in use", inst, smem);
 		}
@@ -738,7 +738,7 @@ int msm_cvp_session_deinit_buffers(struct msm_cvp_inst *inst)
 	mutex_lock(&inst->cvpdspbufs.lock);
 	list_for_each_entry_safe(cbuf, dummy, &inst->cvpdspbufs.list,
 			list) {
-		print_internal_buffer(CVP_DBG, "remove dspbufs", inst, cbuf);
+		print_internal_buffer(CVP_MEM, "remove dspbufs", inst, cbuf);
 		rc = cvp_dsp_deregister_buffer(hash32_ptr(session),
 			cbuf->fd, cbuf->smem->dma_buf->size, cbuf->size,
 			cbuf->offset, cbuf->index,
@@ -874,7 +874,7 @@ int cvp_release_arp_buffers(struct msm_cvp_inst *inst)
 		return -EINVAL;
 	}
 
-	dprintk(CVP_DBG, "release persist buffer!\n");
+	dprintk(CVP_MEM, "release persist buffer!\n");
 
 	mutex_lock(&inst->persistbufs.lock);
 	/* Workaround for FW: release buffer means release all */
@@ -907,14 +907,14 @@ int cvp_release_arp_buffers(struct msm_cvp_inst *inst)
 		list_del(&buf->list);
 
 		if (buf->ownership == DRIVER) {
-			dprintk(CVP_DBG,
+			dprintk(CVP_MEM,
 			"%s: %x : fd %d %s size %d",
 			"free arp", hash32_ptr(inst->session), buf->fd,
 			smem->dma_buf->name, buf->size);
 			msm_cvp_smem_free(smem);
 			kmem_cache_free(cvp_driver->smem_cache, smem);
 		} else if (buf->ownership == CLIENT) {
-			dprintk(CVP_DBG,
+			dprintk(CVP_MEM,
 			"%s: %x : fd %d %s size %d",
 			"unmap persist", hash32_ptr(inst->session),
 			buf->fd, smem->dma_buf->name, buf->size);
diff --git a/drivers/media/platform/msm/cvp/msm_cvp_common.c b/drivers/media/platform/msm/cvp/msm_cvp_common.c
index 5a72e9ae1724..ea6cbb67e6b0 100644
--- a/drivers/media/platform/msm/cvp/msm_cvp_common.c
+++ b/drivers/media/platform/msm/cvp/msm_cvp_common.c
@@ -125,7 +125,7 @@ static void handle_sys_init_done(enum hal_command_response cmd, void *data)
 	memcpy(core->capabilities, sys_init_msg->capabilities,
 		sys_init_msg->codec_count * sizeof(struct msm_cvp_capability));
 
-	dprintk(CVP_DBG,
+	dprintk(CVP_CORE,
 		"%s: max_inst_count %d, max_secure_inst_count %d\n",
 		__func__, core->resources.max_inst_count,
 		core->resources.max_secure_inst_count);
@@ -236,7 +236,7 @@ static void cvp_handle_session_cmd_done(enum hal_command_response cmd,
 		dprintk(CVP_ERR, "HFI MSG error %d cmd response %d\n",
 			response->status, cmd);
 
-	dprintk(CVP_DBG, "%s: inst=%pK\n", __func__, inst);
+	dprintk(CVP_SESS, "%s: inst=%pK\n", __func__, inst);
 
 	if (IS_HAL_SESSION_CMD(cmd)) {
 		dprintk(CVP_INFO, "%s: calling completion for index = %d",
@@ -310,7 +310,7 @@ static void handle_session_release_buf_done(enum hal_command_response cmd,
 	list_for_each_safe(ptr, next, &inst->persistbufs.list) {
 		buf = list_entry(ptr, struct cvp_internal_buf, list);
 		if (address == buf->smem->device_addr + buf->offset) {
-			dprintk(CVP_DBG, "releasing persist: %#x\n",
+			dprintk(CVP_SESS, "releasing persist: %#x\n",
 					buf->smem->device_addr);
 			buf_found = true;
 		}
@@ -353,12 +353,12 @@ void change_cvp_inst_state(struct msm_cvp_inst *inst, enum instance_state state)
 	}
 	mutex_lock(&inst->lock);
 	if (inst->state == MSM_CVP_CORE_INVALID) {
-		dprintk(CVP_DBG,
+		dprintk(CVP_SESS,
 			"Inst: %pK is in bad state can't change state to %d\n",
 			inst, state);
 		goto exit;
 	}
-	dprintk(CVP_DBG, "Moved inst: %pK from state: %d to state: %d\n",
+	dprintk(CVP_SESS, "Moved inst: %pK from state: %d to state: %d\n",
 		   inst, inst->state, state);
 	inst->state = state;
 exit:
@@ -420,7 +420,7 @@ static int wait_for_state(struct msm_cvp_inst *inst,
 						inst, inst->state);
 		goto err_same_state;
 	}
-	dprintk(CVP_DBG, "Waiting for hal_cmd: %d\n", hal_cmd);
+	dprintk(CVP_SESS, "Waiting for hal_cmd: %d\n", hal_cmd);
 	rc = wait_for_sess_signal_receipt(inst, hal_cmd);
 	if (!rc)
 		change_cvp_inst_state(inst, desired_state);
@@ -481,7 +481,7 @@ static void handle_session_init_done(enum hal_command_response cmd, void *data)
 		return;
 	}
 
-	dprintk(CVP_DBG, "%s: cvp session %#x\n", __func__,
+	dprintk(CVP_SESS, "%s: cvp session %#x\n", __func__,
 		hash32_ptr(inst->session));
 
 	signal_session_msg_receipt(cmd, inst);
@@ -681,7 +681,7 @@ static void handle_sys_error(enum hal_command_response cmd, void *data)
 		MSM_CVP_ERROR(true);
 	}
 
-	dprintk(CVP_DBG, "Calling core_release\n");
+	dprintk(CVP_CORE, "Calling core_release\n");
 	rc = call_hfi_op(hdev, core_release, hdev->hfi_device_data);
 	if (rc) {
 		dprintk(CVP_ERR, "core_release failed\n");
@@ -704,14 +704,14 @@ void msm_cvp_comm_session_clean(struct msm_cvp_inst *inst)
 		return;
 	}
 	if (!inst->session) {
-		dprintk(CVP_DBG, "%s: inst %pK session already cleaned\n",
+		dprintk(CVP_SESS, "%s: inst %pK session already cleaned\n",
 			__func__, inst);
 		return;
 	}
 
 	hdev = inst->core->device;
 	mutex_lock(&inst->lock);
-	dprintk(CVP_DBG, "%s: inst %pK\n", __func__, inst);
+	dprintk(CVP_SESS, "%s: inst %pK\n", __func__, inst);
 	rc = call_hfi_op(hdev, session_clean,
 			(void *)inst->session);
 	if (rc) {
@@ -748,7 +748,7 @@ static void handle_session_close(enum hal_command_response cmd, void *data)
 
 void cvp_handle_cmd_response(enum hal_command_response cmd, void *data)
 {
-	dprintk(CVP_DBG, "Command response = %d\n", cmd);
+	dprintk(CVP_HFI, "Command response = %d\n", cmd);
 	switch (cmd) {
 	case HAL_SYS_INIT_DONE:
 		handle_sys_init_done(cmd, data);
@@ -808,7 +808,7 @@ void cvp_handle_cmd_response(enum hal_command_response cmd, void *data)
 		cvp_handle_session_cmd_done(cmd, data);
 		break;
 	default:
-		dprintk(CVP_DBG, "response unhandled: %d\n", cmd);
+		dprintk(CVP_HFI, "response unhandled: %d\n", cmd);
 		break;
 	}
 }
@@ -851,7 +851,7 @@ static bool is_thermal_permissible(struct msm_cvp_core *core)
 		return true;
 
 	if (msm_cvp_thermal_mitigation_disabled) {
-		dprintk(CVP_DBG,
+		dprintk(CVP_CORE,
 			"Thermal mitigation not enabled. debugfs %d\n",
 			msm_cvp_thermal_mitigation_disabled);
 		return true;
@@ -861,7 +861,7 @@ static bool is_thermal_permissible(struct msm_cvp_core *core)
 	freq = core->curr_freq;
 
 	is_turbo = is_core_turbo(core, freq);
-	dprintk(CVP_DBG,
+	dprintk(CVP_CORE,
 		"Core freq %ld Thermal level %d Turbo mode %d\n",
 		freq, tl, is_turbo);
 
@@ -980,7 +980,7 @@ int msm_cvp_comm_check_core_init(struct msm_cvp_core *core)
 				core->id, core->state);
 		goto exit;
 	}
-	dprintk(CVP_DBG, "Waiting for SYS_INIT_DONE\n");
+	dprintk(CVP_CORE, "Waiting for SYS_INIT_DONE\n");
 	rc = wait_for_completion_timeout(
 		&core->completions[SYS_MSG_INDEX(HAL_SYS_INIT_DONE)],
 		msecs_to_jiffies(core->resources.msm_cvp_hw_rsp_timeout));
@@ -996,7 +996,7 @@ int msm_cvp_comm_check_core_init(struct msm_cvp_core *core)
 		core->state = CVP_CORE_INIT_DONE;
 		rc = 0;
 	}
-	dprintk(CVP_DBG, "SYS_INIT_DONE!!!\n");
+	dprintk(CVP_CORE, "SYS_INIT_DONE!!!\n");
 exit:
 	mutex_unlock(&core->lock);
 	return rc;
@@ -1029,7 +1029,7 @@ static int msm_comm_init_core(struct msm_cvp_inst *inst)
 	hdev = core->device;
 	mutex_lock(&core->lock);
 	if (core->state >= CVP_CORE_INIT) {
-		dprintk(CVP_DBG, "CVP core: %d is already in state: %d\n",
+		dprintk(CVP_CORE, "CVP core: %d is already in state: %d\n",
 				core->id, core->state);
 		goto core_already_inited;
 	}
@@ -1048,7 +1048,7 @@ static int msm_comm_init_core(struct msm_cvp_inst *inst)
 			"%s: capabilities memory is expected to be freed\n",
 			__func__);
 	}
-	dprintk(CVP_DBG, "%s: core %pK\n", __func__, core);
+	dprintk(CVP_CORE, "%s: core %pK\n", __func__, core);
 	rc = call_hfi_op(hdev, core_init, hdev->hfi_device_data);
 	if (rc) {
 		dprintk(CVP_ERR, "Failed to init core, id = %d\n",
@@ -1106,7 +1106,7 @@ int msm_cvp_deinit_core(struct msm_cvp_inst *inst)
 			msecs_to_jiffies(core->state == CVP_CORE_INIT_DONE ?
 			core->resources.msm_cvp_firmware_unload_delay : 0));
 
-		dprintk(CVP_DBG, "firmware unload delayed by %u ms\n",
+		dprintk(CVP_CORE, "firmware unload delayed by %u ms\n",
 			core->state == CVP_CORE_INIT_DONE ?
 			core->resources.msm_cvp_firmware_unload_delay : 0);
 	}
@@ -1122,7 +1122,7 @@ static int msm_comm_session_init_done(int flipped_state,
 {
 	int rc;
 
-	dprintk(CVP_DBG, "inst %pK: waiting for session init done\n", inst);
+	dprintk(CVP_SESS, "inst %pK: waiting for session init done\n", inst);
 	rc = wait_for_state(inst, flipped_state, MSM_CVP_OPEN_DONE,
 			HAL_SESSION_INIT_DONE);
 	if (rc) {
@@ -1152,7 +1152,7 @@ static int msm_comm_session_init(int flipped_state,
 		goto exit;
 	}
 
-	dprintk(CVP_DBG, "%s: inst %pK\n", __func__, inst);
+	dprintk(CVP_SESS, "%s: inst %pK\n", __func__, inst);
 	rc = call_hfi_op(hdev, session_init, hdev->hfi_device_data,
 			inst, &inst->session);
 
@@ -1186,7 +1186,7 @@ static int msm_comm_session_close(int flipped_state,
 		goto exit;
 	}
 	hdev = inst->core->device;
-	dprintk(CVP_DBG, "%s: inst %pK\n", __func__, inst);
+	dprintk(CVP_SESS, "%s: inst %pK\n", __func__, inst);
 	rc = call_hfi_op(hdev, session_end, (void *) inst->session);
 	if (rc) {
 		dprintk(CVP_ERR,
@@ -1252,7 +1252,7 @@ int msm_cvp_comm_try_state(struct msm_cvp_inst *inst, int state)
 		dprintk(CVP_ERR, "%s: invalid params %pK", __func__, inst);
 		return -EINVAL;
 	}
-	dprintk(CVP_DBG,
+	dprintk(CVP_SESS,
 		"Trying to move inst: %pK (%#x) from: %#x to %#x\n",
 		inst, hash32_ptr(inst->session), inst->state, state);
 
@@ -1265,7 +1265,7 @@ int msm_cvp_comm_try_state(struct msm_cvp_inst *inst, int state)
 	}
 
 	flipped_state = get_flipped_state(inst->state, state);
-	dprintk(CVP_DBG,
+	dprintk(CVP_SESS,
 		"inst: %pK (%#x) flipped_state = %#x %x\n",
 		inst, hash32_ptr(inst->session), flipped_state, state);
 	switch (flipped_state) {
@@ -1516,7 +1516,7 @@ void msm_cvp_fw_unload_handler(struct work_struct *work)
 	if (list_empty(&core->instances) &&
 		core->state != CVP_CORE_UNINIT) {
 		if (core->state > CVP_CORE_INIT) {
-			dprintk(CVP_DBG, "Calling cvp_hal_core_release\n");
+			dprintk(CVP_CORE, "Calling cvp_hal_core_release\n");
 			rc = call_hfi_op(hdev, core_release,
 					hdev->hfi_device_data);
 			if (rc) {
@@ -1552,7 +1552,7 @@ static int set_internal_buf_on_fw(struct msm_cvp_inst *inst,
 	iova = handle->device_addr;
 	size = handle->size;
 
-	dprintk(CVP_DBG, "%s: allocated ARP buffer : %x\n", __func__, iova);
+	dprintk(CVP_SESS, "%s: allocated ARP buffer : %x\n", __func__, iova);
 
 	rc = call_hfi_op(hdev, session_set_buffers,
 			(void *) inst->session, iova, size);
diff --git a/drivers/media/platform/msm/cvp/msm_cvp_core.c b/drivers/media/platform/msm/cvp/msm_cvp_core.c
index eec0cb6b32dd..5d17706181cf 100644
--- a/drivers/media/platform/msm/cvp/msm_cvp_core.c
+++ b/drivers/media/platform/msm/cvp/msm_cvp_core.c
@@ -154,7 +154,7 @@ void *msm_cvp_open(int core_id, int session_type)
 	}
 
 	if (!core->resources.auto_pil && session_type == MSM_CVP_BOOT) {
-		dprintk(CVP_DBG, "Auto PIL disabled, bypass CVP init at boot");
+		dprintk(CVP_SESS, "Auto PIL disabled, bypass CVP init at boot");
 		goto err_invalid_core;
 	}
 
@@ -178,7 +178,7 @@ void *msm_cvp_open(int core_id, int session_type)
 		goto err_invalid_core;
 	}
 
-	pr_info(CVP_DBG_TAG "Opening cvp instance: %pK\n", "info", inst);
+	pr_info(CVP_DBG_TAG "Opening cvp instance: %pK\n", "sess", inst);
 	mutex_init(&inst->sync_lock);
 	mutex_init(&inst->lock);
 	spin_lock_init(&inst->event_handler.lock);
@@ -293,7 +293,7 @@ int msm_cvp_destroy(struct msm_cvp_inst *inst)
 	synx_uninitialize(inst->synx_session_id);
 
 	pr_info(CVP_DBG_TAG "Closed cvp instance: %pK session_id = %d\n",
-		"info", inst, hash32_ptr(inst->session));
+		"sess", inst, hash32_ptr(inst->session));
 	if (inst->cur_cmd_type)
 		dprintk(CVP_ERR, "deleted instance has pending cmd %d\n",
 				inst->cur_cmd_type);
diff --git a/drivers/media/platform/msm/cvp/msm_cvp_debug.c b/drivers/media/platform/msm/cvp/msm_cvp_debug.c
index cf3f44516f30..cd5dbb51a6d2 100644
--- a/drivers/media/platform/msm/cvp/msm_cvp_debug.c
+++ b/drivers/media/platform/msm/cvp/msm_cvp_debug.c
@@ -382,7 +382,7 @@ static int inst_info_open(struct inode *inode, struct file *file)
 static int publish_unreleased_reference(struct msm_cvp_inst *inst,
 		char **dbuf, char *end)
 {
-	dprintk(CVP_DBG, "%s deprecated function\n", __func__);
+	dprintk(CVP_SESS, "%s deprecated function\n", __func__);
 	return 0;
 }
 
diff --git a/drivers/media/platform/msm/cvp/msm_cvp_debug.h b/drivers/media/platform/msm/cvp/msm_cvp_debug.h
index 6aa16cfce2f3..8fc4c33331c4 100644
--- a/drivers/media/platform/msm/cvp/msm_cvp_debug.h
+++ b/drivers/media/platform/msm/cvp/msm_cvp_debug.h
@@ -23,13 +23,22 @@
  */
 
 enum cvp_msg_prio {
-	CVP_ERR  = 0x0001,
-	CVP_WARN = 0x0002,
-	CVP_INFO = 0x0004,
-	CVP_DBG  = 0x0008,
-	CVP_PROF = 0x0010,
-	CVP_PKT  = 0x0020,
-	CVP_FW   = 0x1000,
+	CVP_ERR  = 0x000001,
+	CVP_WARN = 0x000002,
+	CVP_INFO = 0x000004,
+	CVP_PROF = 0x000010,
+	CVP_PKT  = 0x000020,
+	CVP_MEM  = 0x000040,
+	CVP_SYNX = 0x000080,
+	CVP_CORE = 0x000100,
+	CVP_REG  = 0x000200,
+	CVP_PWR  = 0x000400,
+	CVP_DSP  = 0x000800,
+	CVP_FW   = 0x001000,
+	CVP_SESS = 0x002000,
+	CVP_HFI  = 0x004000,
+	CVP_DBG  = CVP_MEM | CVP_SYNX | CVP_CORE | CVP_REG |
+		CVP_PWR | CVP_DSP | CVP_SESS | CVP_HFI,
 };
 
 enum cvp_msg_out {
@@ -95,8 +104,24 @@ static inline char *get_debug_level_str(int level)
 		return "prof";
 	case CVP_PKT:
 		return "pkt";
+	case CVP_MEM:
+		return "mem";
+	case CVP_SYNX:
+		return "synx";
+	case CVP_CORE:
+		return "core";
+	case CVP_REG:
+		return "reg";
+	case CVP_PWR:
+		return "pwr";
+	case CVP_DSP:
+		return "dsp";
 	case CVP_FW:
 		return "fw";
+	case CVP_SESS:
+		return "sess";
+	case CVP_HFI:
+		return "hfi";
 	default:
 		return "???";
 	}
diff --git a/drivers/media/platform/msm/cvp/msm_cvp_dsp.c b/drivers/media/platform/msm/cvp/msm_cvp_dsp.c
index 8ad4cb23b19e..95e90e5f8e97 100644
--- a/drivers/media/platform/msm/cvp/msm_cvp_dsp.c
+++ b/drivers/media/platform/msm/cvp/msm_cvp_dsp.c
@@ -32,7 +32,7 @@ static int cvp_dsp_send_cmd(struct cvp_dsp_cmd_msg *cmd, uint32_t len)
 	int rc = 0;
 	struct cvp_dsp_apps *me = &gfa_cv;
 
-	dprintk(CVP_DBG, "%s: cmd = %d\n", __func__, cmd->type);
+	dprintk(CVP_DSP, "%s: cmd = %d\n", __func__, cmd->type);
 
 	if (IS_ERR_OR_NULL(me->chan)) {
 		dprintk(CVP_ERR, "%s: DSP GLink is not ready\n", __func__);
@@ -55,7 +55,7 @@ static int cvp_dsp_send_cmd_sync(struct cvp_dsp_cmd_msg *cmd, uint32_t len)
 	int rc = 0;
 	struct cvp_dsp_apps *me = &gfa_cv;
 
-	dprintk(CVP_DBG, "%s: cmd = %d\n", __func__, cmd->type);
+	dprintk(CVP_DSP, "%s: cmd = %d\n", __func__, cmd->type);
 
 	rc = cvp_dsp_send_cmd(cmd, len);
 	if (rc) {
@@ -92,7 +92,7 @@ static int cvp_dsp_send_cmd_hfi_queue(phys_addr_t *phys_addr,
 		return -EINVAL;
 	}
 
-	dprintk(CVP_DBG,
+	dprintk(CVP_DSP,
 		"%s: address of buffer, PA=0x%pK  size_buff=%d ddr_type=%d\n",
 		__func__, phys_addr, size_in_bytes, cmd.ddr_type);
 
@@ -190,7 +190,7 @@ static int cvp_dsp_rpmsg_callback(struct rpmsg_device *rpdev,
 	struct cvp_dsp_rsp_msg *rsp = (struct cvp_dsp_rsp_msg *)data;
 	struct cvp_dsp_apps *me = &gfa_cv;
 
-	dprintk(CVP_DBG, "%s: type = 0x%x ret = 0x%x\n",
+	dprintk(CVP_DSP, "%s: type = 0x%x ret = 0x%x\n",
 		__func__, rsp->type, rsp->ret);
 
 	if (rsp->type >= CVP_DSP_MAX_CMD) {
@@ -306,11 +306,11 @@ int cvp_dsp_register_buffer(uint32_t session_id, uint32_t buff_fd,
 	cmd.buff_index = buff_index;
 	cmd.buff_fd_iova = buff_fd_iova;
 
-	dprintk(CVP_DBG,
+	dprintk(CVP_DSP,
 		"%s: type=0x%x, buff_fd_iova=0x%x buff_index=0x%x\n",
 		__func__, cmd.type, buff_fd_iova,
 		cmd.buff_index);
-	dprintk(CVP_DBG, "%s: buff_size=0x%x session_id=0x%x\n",
+	dprintk(CVP_DSP, "%s: buff_size=0x%x session_id=0x%x\n",
 		__func__, cmd.buff_size, cmd.session_id);
 
 	mutex_lock(&me->lock);
@@ -344,11 +344,11 @@ int cvp_dsp_deregister_buffer(uint32_t session_id, uint32_t buff_fd,
 	cmd.buff_index = buff_index;
 	cmd.buff_fd_iova = buff_fd_iova;
 
-	dprintk(CVP_DBG,
+	dprintk(CVP_DSP,
 		"%s: type=0x%x, buff_fd_iova=0x%x buff_index=0x%x\n",
 		__func__, cmd.type, buff_fd_iova,
 		cmd.buff_index);
-	dprintk(CVP_DBG, "%s: buff_size=0x%x session_id=0x%x\n",
+	dprintk(CVP_DSP, "%s: buff_size=0x%x session_id=0x%x\n",
 		__func__, cmd.buff_size, cmd.session_id);
 
 	mutex_lock(&me->lock);
@@ -399,7 +399,7 @@ void cvp_dsp_send_hfi_queue(void)
 		return;
 	}
 
-	dprintk(CVP_DBG, "Entering %s\n", __func__);
+	dprintk(CVP_DSP, "Entering %s\n", __func__);
 
 	mutex_lock(&device->lock);
 	mutex_lock(&me->lock);
@@ -408,7 +408,7 @@ void cvp_dsp_send_hfi_queue(void)
 	size = device->dsp_iface_q_table.mem_data.size;
 
 	if (!addr || !size) {
-		dprintk(CVP_DBG, "%s: HFI queue is not ready\n", __func__);
+		dprintk(CVP_DSP, "%s: HFI queue is not ready\n", __func__);
 		goto exit;
 	}
 
@@ -431,7 +431,7 @@ void cvp_dsp_send_hfi_queue(void)
 		goto exit;
 	}
 
-	dprintk(CVP_DBG, "%s: dsp initialized\n", __func__);
+	dprintk(CVP_DSP, "%s: dsp initialized\n", __func__);
 	me->state = DSP_READY;
 
 exit:
diff --git a/drivers/media/platform/msm/cvp/msm_cvp_ioctl.c b/drivers/media/platform/msm/cvp/msm_cvp_ioctl.c
index 8721b3ac3fe0..47a3f6e8341b 100644
--- a/drivers/media/platform/msm/cvp/msm_cvp_ioctl.c
+++ b/drivers/media/platform/msm/cvp/msm_cvp_ioctl.c
@@ -227,7 +227,7 @@ static void print_hfi_short(struct cvp_kmd_arg __user *up)
 			get_user(words[4], &pkt->pkt_data[1]))
 		dprintk(CVP_ERR, "Failed to print ioctl cmd\n");
 
-	dprintk(CVP_DBG, "IOCTL cmd type %#x, offset %d, num %d, pkt %d %#x\n",
+	dprintk(CVP_HFI, "IOCTL cmd type %#x, offset %d, num %d, pkt %d %#x\n",
 			words[0], words[1], words[2], words[3], words[4]);
 }
 
@@ -370,7 +370,7 @@ static int convert_from_user(struct cvp_kmd_arg *kp,
 				kp->type, pkt_hdr.size, pkt_hdr.packet_type);
 			return -EFAULT;
 		}
-		dprintk(CVP_DBG, "system call cmd pkt: %d 0x%x\n",
+		dprintk(CVP_HFI, "system call cmd pkt: %d 0x%x\n",
 				pkt_hdr.size, pkt_hdr.packet_type);
 
 		pkt_idx = get_pkt_index(&pkt_hdr);
@@ -532,7 +532,7 @@ static int convert_to_user(struct cvp_kmd_arg *kp, unsigned long arg)
 		if (_get_pkt_hdr_from_user(up, &pkt_hdr))
 			return -EFAULT;
 
-		dprintk(CVP_DBG, "Send user cmd pkt: %d %d\n",
+		dprintk(CVP_HFI, "Send user cmd pkt: %d %d\n",
 				pkt_hdr.size, pkt_hdr.packet_type);
 		rc = _copy_pkt_to_user(kp, up, (pkt_hdr.size >> 2));
 		break;
@@ -542,7 +542,7 @@ static int convert_to_user(struct cvp_kmd_arg *kp, unsigned long arg)
 		if (_get_fence_pkt_hdr_from_user(up, &pkt_hdr))
 			return -EFAULT;
 
-		dprintk(CVP_DBG, "Send user cmd pkt: %d %d\n",
+		dprintk(CVP_HFI, "Send user cmd pkt: %d %d\n",
 				pkt_hdr.size, pkt_hdr.packet_type);
 
 		rc = _copy_fence_pkt_to_user(kp, up);
diff --git a/drivers/media/platform/msm/cvp/msm_cvp_res_parse.c b/drivers/media/platform/msm/cvp/msm_cvp_res_parse.c
index 3558c9692643..1259e3a6abe1 100644
--- a/drivers/media/platform/msm/cvp/msm_cvp_res_parse.c
+++ b/drivers/media/platform/msm/cvp/msm_cvp_res_parse.c
@@ -127,7 +127,7 @@ static int msm_cvp_load_reg_table(struct msm_cvp_platform_resources *res)
 		 * qcom,reg-presets is an optional property.  It likely won't be
 		 * present if we don't have any register settings to program
 		 */
-		dprintk(CVP_DBG, "qcom,reg-presets not found\n");
+		dprintk(CVP_CORE, "qcom,reg-presets not found\n");
 		return 0;
 	}
 
@@ -137,7 +137,7 @@ static int msm_cvp_load_reg_table(struct msm_cvp_platform_resources *res)
 	reg_set->count /=  sizeof(*reg_set->reg_tbl) / sizeof(u32);
 
 	if (!reg_set->count) {
-		dprintk(CVP_DBG, "no elements in reg set\n");
+		dprintk(CVP_CORE, "no elements in reg set\n");
 		return rc;
 	}
 
@@ -156,7 +156,7 @@ static int msm_cvp_load_reg_table(struct msm_cvp_platform_resources *res)
 		return -EINVAL;
 	}
 	for (i = 0; i < reg_set->count; i++) {
-		dprintk(CVP_DBG,
+		dprintk(CVP_CORE,
 			"reg = %x, value = %x\n",
 			reg_set->reg_tbl[i].reg,
 			reg_set->reg_tbl[i].value
@@ -176,7 +176,7 @@ static int msm_cvp_load_qdss_table(struct msm_cvp_platform_resources *res)
 		 * qcom,qdss-presets is an optional property. It likely won't be
 		 * present if we don't have any register settings to program
 		 */
-		dprintk(CVP_DBG, "qcom,qdss-presets not found\n");
+		dprintk(CVP_CORE, "qcom,qdss-presets not found\n");
 		return rc;
 	}
 
@@ -186,7 +186,7 @@ static int msm_cvp_load_qdss_table(struct msm_cvp_platform_resources *res)
 	qdss_addr_set->count /= sizeof(*qdss_addr_set->addr_tbl) / sizeof(u32);
 
 	if (!qdss_addr_set->count) {
-		dprintk(CVP_DBG, "no elements in qdss reg set\n");
+		dprintk(CVP_CORE, "no elements in qdss reg set\n");
 		return rc;
 	}
 
@@ -210,7 +210,7 @@ static int msm_cvp_load_qdss_table(struct msm_cvp_platform_resources *res)
 	}
 
 	for (i = 0; i < qdss_addr_set->count; i++) {
-		dprintk(CVP_DBG, "qdss addr = %x, value = %x\n",
+		dprintk(CVP_CORE, "qdss addr = %x, value = %x\n",
 				qdss_addr_set->addr_tbl[i].start,
 				qdss_addr_set->addr_tbl[i].size);
 	}
@@ -227,7 +227,7 @@ static int msm_cvp_load_subcache_info(struct msm_cvp_platform_resources *res)
 	num_subcaches = of_property_count_strings(pdev->dev.of_node,
 		"cache-slice-names");
 	if (num_subcaches <= 0) {
-		dprintk(CVP_DBG, "No subcaches found\n");
+		dprintk(CVP_CORE, "No subcaches found\n");
 		goto err_load_subcache_table_fail;
 	}
 
@@ -241,7 +241,7 @@ static int msm_cvp_load_subcache_info(struct msm_cvp_platform_resources *res)
 	}
 
 	subcaches->count = num_subcaches;
-	dprintk(CVP_DBG, "Found %d subcaches\n", num_subcaches);
+	dprintk(CVP_CORE, "Found %d subcaches\n", num_subcaches);
 
 	for (c = 0; c < num_subcaches; ++c) {
 		struct subcache_info *vsc = &res->subcache_set.subcache_tbl[c];
@@ -287,7 +287,7 @@ int msm_cvp_load_u32_table(struct platform_device *pdev,
 	u32 *ptbl = NULL;
 
 	if (!of_find_property(of_node, table_name, NULL)) {
-		dprintk(CVP_DBG, "%s not found\n", table_name);
+		dprintk(CVP_CORE, "%s not found\n", table_name);
 		return 0;
 	}
 
@@ -333,7 +333,7 @@ static int msm_cvp_load_allowed_clocks_table(
 
 	if (!of_find_property(pdev->dev.of_node,
 			"qcom,allowed-clock-rates", NULL)) {
-		dprintk(CVP_DBG, "qcom,allowed-clock-rates not found\n");
+		dprintk(CVP_CORE, "qcom,allowed-clock-rates not found\n");
 		return 0;
 	}
 
@@ -428,7 +428,7 @@ static int msm_cvp_populate_bus(struct device *dev,
 			&bus->governor);
 	if (rc) {
 		rc = 0;
-		dprintk(CVP_DBG,
+		dprintk(CVP_CORE,
 				"'qcom,bus-governor' not found, default to performance governor\n");
 		bus->governor = PERF_GOV;
 	}
@@ -440,7 +440,7 @@ static int msm_cvp_populate_bus(struct device *dev,
 			range, ARRAY_SIZE(range));
 	if (rc) {
 		rc = 0;
-		dprintk(CVP_DBG,
+		dprintk(CVP_CORE,
 				"'qcom,range' not found defaulting to <0 INT_MAX>\n");
 		range[0] = 0;
 		range[1] = INT_MAX;
@@ -451,7 +451,7 @@ static int msm_cvp_populate_bus(struct device *dev,
 
 	buses->count++;
 	bus->dev = dev;
-	dprintk(CVP_DBG, "Found bus %s [%d->%d] with governor %s\n",
+	dprintk(CVP_CORE, "Found bus %s [%d->%d] with governor %s\n",
 			bus->name, bus->master, bus->slave, bus->governor);
 err_bus:
 	return rc;
@@ -537,13 +537,13 @@ static int msm_cvp_load_regulator_table(
 		rinfo->has_hw_power_collapse = of_property_read_bool(
 			regulator_node, "qcom,support-hw-trigger");
 
-		dprintk(CVP_DBG, "Found regulator %s: h/w collapse = %s\n",
+		dprintk(CVP_CORE, "Found regulator %s: h/w collapse = %s\n",
 				rinfo->name,
 				rinfo->has_hw_power_collapse ? "yes" : "no");
 	}
 
 	if (!regulators->count)
-		dprintk(CVP_DBG, "No regulators found");
+		dprintk(CVP_CORE, "No regulators found");
 
 	return 0;
 
@@ -564,7 +564,7 @@ static int msm_cvp_load_clock_table(
 	num_clocks = of_property_count_strings(pdev->dev.of_node,
 				"clock-names");
 	if (num_clocks <= 0) {
-		dprintk(CVP_DBG, "No clocks found\n");
+		dprintk(CVP_CORE, "No clocks found\n");
 		clocks->count = 0;
 		rc = 0;
 		goto err_load_clk_table_fail;
@@ -595,7 +595,7 @@ static int msm_cvp_load_clock_table(
 	}
 
 	clocks->count = num_clocks;
-	dprintk(CVP_DBG, "Found %d clocks\n", num_clocks);
+	dprintk(CVP_CORE, "Found %d clocks\n", num_clocks);
 
 	for (c = 0; c < num_clocks; ++c) {
 		struct clock_info *vc = &res->clock_set.clock_tbl[c];
@@ -615,7 +615,7 @@ static int msm_cvp_load_clock_table(
 		else
 			vc->has_mem_retention = false;
 
-		dprintk(CVP_DBG, "Found clock %s: scale-able = %s\n", vc->name,
+		dprintk(CVP_CORE, "Found clock %s: scale-able = %s\n", vc->name,
 			vc->count ? "yes" : "no");
 	}
 
@@ -650,7 +650,7 @@ static int msm_cvp_load_reset_table(
 		return -ENOMEM;
 
 	rst->count = num_clocks;
-	dprintk(CVP_DBG, "Found %d reset clocks\n", num_clocks);
+	dprintk(CVP_CORE, "Found %d reset clocks\n", num_clocks);
 	ret = of_property_read_u32_array(pdev->dev.of_node,
 				"reset-power-status", pwr_stats,
 				num_clocks);
@@ -703,7 +703,7 @@ int cvp_read_platform_resources_from_drv_data(
 
 	res->fw_name = "cvpss";
 
-	dprintk(CVP_DBG, "Firmware filename: %s\n", res->fw_name);
+	dprintk(CVP_CORE, "Firmware filename: %s\n", res->fw_name);
 
 	res->auto_pil = find_key_value(platform_data,
 			"qcom,auto-pil");
@@ -817,7 +817,7 @@ int cvp_read_platform_resources_from_dt(
 		of_property_read_u32(pdev->dev.of_node, "qcom,fw-bias",
 				&firmware_base);
 		res->firmware_base = (phys_addr_t)firmware_base;
-		dprintk(CVP_DBG,
+		dprintk(CVP_CORE,
 				"Using fw-bias : %pa", &res->firmware_base);
 	}
 
@@ -866,8 +866,8 @@ static int msm_cvp_setup_context_bank(struct msm_cvp_platform_resources *res,
 	dma_set_max_seg_size(dev, DMA_BIT_MASK(32));
 	dma_set_seg_boundary(dev, DMA_BIT_MASK(64));
 
-	dprintk(CVP_DBG, "Attached %s and created mapping\n", dev_name(dev));
-	dprintk(CVP_DBG,
+	dprintk(CVP_CORE, "Attached %s and created mapping\n", dev_name(dev));
+	dprintk(CVP_CORE,
 		"Context bank name:%s, buffer_type: %#x, is_secure: %d, address range start: %#x, size: %#x, dev: %pK",
 		cb->name, cb->buffer_type, cb->is_secure, cb->addr_range.start,
 		cb->addr_range.size, cb->dev);
@@ -942,12 +942,12 @@ static int msm_cvp_populate_context_bank(struct device *dev,
 
 	rc = of_property_read_string(np, "label", &cb->name);
 	if (rc) {
-		dprintk(CVP_DBG,
+		dprintk(CVP_CORE,
 			"Failed to read cb label from device tree\n");
 		rc = 0;
 	}
 
-	dprintk(CVP_DBG, "%s: context bank has name %s\n", __func__, cb->name);
+	dprintk(CVP_CORE, "%s: context bank has name %s\n", __func__, cb->name);
 	rc = of_property_read_u32_array(np, "qcom,iommu-dma-addr-pool",
 			(u32 *)&cb->addr_range, 2);
 	if (rc) {
@@ -958,7 +958,7 @@ static int msm_cvp_populate_context_bank(struct device *dev,
 	}
 
 	cb->is_secure = of_property_read_bool(np, "qcom,iommu-vmid");
-	dprintk(CVP_DBG, "context bank %s : secure = %d\n",
+	dprintk(CVP_CORE, "context bank %s : secure = %d\n",
 			cb->name, cb->is_secure);
 
 	/* setup buffer type for each sub device*/
@@ -968,7 +968,7 @@ static int msm_cvp_populate_context_bank(struct device *dev,
 		rc = -ENOENT;
 		goto err_setup_cb;
 	}
-	dprintk(CVP_DBG,
+	dprintk(CVP_CORE,
 		"context bank %s address start = %x address size = %x buffer_type = %x\n",
 		cb->name, cb->addr_range.start,
 		cb->addr_range.size, cb->buffer_type);
@@ -1021,7 +1021,7 @@ int cvp_read_context_bank_resources_from_dt(struct platform_device *pdev)
 	if (rc)
 		dprintk(CVP_ERR, "Failed to probe context bank\n");
 	else
-		dprintk(CVP_DBG, "Successfully probed context bank\n");
+		dprintk(CVP_CORE, "Successfully probed context bank\n");
 
 	return rc;
 }
diff --git a/drivers/media/platform/msm/cvp/msm_cvp_synx.c b/drivers/media/platform/msm/cvp/msm_cvp_synx.c
index b1b2a44c19f9..8682b2627377 100644
--- a/drivers/media/platform/msm/cvp/msm_cvp_synx.c
+++ b/drivers/media/platform/msm/cvp/msm_cvp_synx.c
@@ -421,7 +421,7 @@ static int cvp_wait_fd_synx_deprecate(struct synx_session ssid, u32 *synx,
 			if (rc) {
 				*synx_state = synx_get_status(ssid, h_synx);
 				if (*synx_state == SYNX_STATE_SIGNALED_CANCEL) {
-					dprintk(CVP_DBG,
+					dprintk(CVP_SYNX,
 					"%s: synx_wait %d cancel %d state %d\n",
 					current->comm, i, rc, *synx_state);
 				} else {
@@ -479,7 +479,7 @@ static int cvp_wait_synx(struct synx_session ssid, u32 *synx, u32 num_synx,
 			if (rc) {
 				*synx_state = synx_get_status(ssid, h_synx);
 				if (*synx_state == SYNX_STATE_SIGNALED_CANCEL) {
-					dprintk(CVP_DBG,
+					dprintk(CVP_SYNX,
 					"%s: synx_wait %d cancel %d state %d\n",
 					current->comm, i, rc, *synx_state);
 				} else {
diff --git a/drivers/media/platform/msm/cvp/msm_smem.c b/drivers/media/platform/msm/cvp/msm_smem.c
index 52fb9d9030ba..98351c7c50cb 100644
--- a/drivers/media/platform/msm/cvp/msm_smem.c
+++ b/drivers/media/platform/msm/cvp/msm_smem.c
@@ -89,7 +89,7 @@ static int msm_dma_get_device_address(struct dma_buf *dbuf, u32 align,
 		mapping_info->buf = dbuf;
 		mapping_info->cb_info = (void *)cb;
 	} else {
-		dprintk(CVP_DBG, "iommu not present, use phys mem addr\n");
+		dprintk(CVP_MEM, "iommu not present, use phys mem addr\n");
 	}
 
 	return 0;
@@ -251,13 +251,13 @@ static int alloc_dma_mem(size_t size, u32 align, u32 flags, int map_kernel,
 
 	if (is_iommu_present(res)) {
 		if (flags & SMEM_ADSP) {
-			dprintk(CVP_DBG, "Allocating from ADSP heap\n");
+			dprintk(CVP_MEM, "Allocating from ADSP heap\n");
 			heap_mask = ION_HEAP(ION_ADSP_HEAP_ID);
 		} else {
 			heap_mask = ION_HEAP(ION_SYSTEM_HEAP_ID);
 		}
 	} else {
-		dprintk(CVP_DBG,
+		dprintk(CVP_MEM,
 		"allocate shared memory from adsp heap size %zx align %d\n",
 		size, align);
 		heap_mask = ION_HEAP(ION_ADSP_HEAP_ID);
@@ -314,7 +314,7 @@ static int alloc_dma_mem(size_t size, u32 align, u32 flags, int map_kernel,
 		}
 	}
 
-	dprintk(CVP_DBG,
+	dprintk(CVP_MEM,
 		"%s: dma_buf = %pK, device_addr = %x, size = %d, kvaddr = %pK, ion_flags = %#x, flags = %#lx\n",
 		__func__, mem->dma_buf, mem->device_addr, mem->size,
 		mem->kvaddr, mem->ion_flags, mem->flags);
@@ -331,7 +331,7 @@ fail_shared_mem_alloc:
 
 static int free_dma_mem(struct msm_cvp_smem *mem)
 {
-	dprintk(CVP_DBG,
+	dprintk(CVP_MEM,
 		"%s: dma_buf = %pK, device_addr = %x, size = %d, kvaddr = %pK, ion_flags = %#x\n",
 		__func__, mem->dma_buf, mem->device_addr, mem->size,
 		mem->kvaddr, mem->ion_flags);