diff --git a/drivers/media/platform/qcom/venus/core.c b/drivers/media/platform/qcom/venus/core.c
index cb411eb..6531830 100644
--- a/drivers/media/platform/qcom/venus/core.c
+++ b/drivers/media/platform/qcom/venus/core.c
@@ -13,6 +13,7 @@
  *
  */
 #include <linux/clk.h>
+#include <linux/debugfs.h>
 #include <linux/init.h>
 #include <linux/ioctl.h>
 #include <linux/list.h>
@@ -31,6 +32,50 @@
 #include "venc.h"
 #include "firmware.h"
 
+struct dentry *debugfs_root;
+int venus_debug = ERR;
+EXPORT_SYMBOL_GPL(venus_debug);
+
+static struct dentry *venus_debugfs_init_drv(void)
+{
+	bool ok = false;
+	struct dentry *dir = NULL;
+
+	dir = debugfs_create_dir("venus", NULL);
+	if (IS_ERR_OR_NULL(dir)) {
+		dir = NULL;
+		pr_err("failed to create debug dir");
+		goto failed_create_dir;
+	}
+
+#define __debugfs_create(__type, __fname, __value) ({                          \
+	struct dentry *f = debugfs_create_##__type(__fname, 0644,	\
+		dir, __value);                                                \
+	if (IS_ERR_OR_NULL(f)) {                                              \
+		dprintk(ERR, "Failed creating debugfs file '%pd/%s'\n",  \
+			dir, __name);                                         \
+		f = NULL;                                                     \
+	}                                                                     \
+	f;                                                                    \
+})
+
+	ok =
+	__debugfs_create(x32, "debug_level", &venus_debug);
+
+#undef __debugfs_create
+
+	if (!ok)
+		goto failed_create_dir;
+
+	return dir;
+
+failed_create_dir:
+	if (dir)
+		debugfs_remove_recursive(debugfs_root);
+
+	return NULL;
+}
+
 static void venus_event_notify(struct venus_core *core, u32 event)
 {
 	struct venus_inst *inst;
@@ -137,6 +182,7 @@ static int venus_clks_enable(struct venus_core *core)
 
 	return 0;
 err:
+	dprintk(ERR, "Failed to enable clk:%d\n", i);
 	while (i--)
 		clk_disable_unprepare(core->clks[i]);
 
@@ -236,6 +282,8 @@ static int venus_probe(struct platform_device *pdev)
 	struct resource *r;
 	int ret;
 
+	debugfs_root = venus_debugfs_init_drv();
+
 	core = devm_kzalloc(dev, sizeof(*core), GFP_KERNEL);
 	if (!core)
 		return -ENOMEM;
@@ -245,8 +293,10 @@ static int venus_probe(struct platform_device *pdev)
 
 	r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 	core->base = devm_ioremap_resource(dev, r);
-	if (IS_ERR(core->base))
+	if (IS_ERR(core->base)) {
+		dprintk(ERR, "Failed to ioremap platform resources");
 		return PTR_ERR(core->base);
+		}
 
 	core->irq = platform_get_irq(pdev, 0);
 	if (core->irq < 0)
@@ -297,8 +347,10 @@ static int venus_probe(struct platform_device *pdev)
 		goto err_runtime_disable;
 
 	ret = venus_firmware_init(core);
-	if (ret)
+	if (ret) {
+		dprintk(ERR, "Failed to init video firmware\n");
 		goto err_runtime_disable;
+		}
 
 	ret = venus_boot(core);
 	if (ret)
@@ -321,8 +373,10 @@ static int venus_probe(struct platform_device *pdev)
 		goto err_venus_shutdown;
 
 	ret = v4l2_device_register(dev, &core->v4l2_dev);
-	if (ret)
+	if (ret) {
+		dprintk(ERR, "Failed to register v4l2 device\n");
 		goto err_core_deinit;
+		}
 
 	ret = pm_runtime_put_sync(dev);
 	if (ret)
@@ -366,6 +420,8 @@ static int venus_remove(struct platform_device *pdev)
 
 	v4l2_device_unregister(&core->v4l2_dev);
 
+	debugfs_remove_recursive(debugfs_root);
+
 	return ret;
 }
 
diff --git a/drivers/media/platform/qcom/venus/core.h b/drivers/media/platform/qcom/venus/core.h
index 6382cea..c31d9e0 100644
--- a/drivers/media/platform/qcom/venus/core.h
+++ b/drivers/media/platform/qcom/venus/core.h
@@ -25,6 +25,38 @@
 
 #define VIDC_CLKS_NUM_MAX	4
 
+extern int venus_debug;
+enum venus_msg_prio {
+	ERR  = 0x0001,
+	WARN = 0x0002,
+	INFO = 0x0004,
+	DBG  = 0x0008,
+};
+
+static inline char *get_debug_level_str(int level)
+{
+	switch (level) {
+	case ERR:
+		return "err";
+	case WARN:
+		return "warn";
+	case INFO:
+		return "info";
+	case DBG:
+		return "dbg";
+	default:
+		return "???";
+	}
+}
+
+#define dprintk(dbg_lvl, fmt, arg...)				\
+	do {							\
+		if (venus_debug & dbg_lvl)				\
+			pr_info("venus:" fmt, \
+					get_debug_level_str(dbg_lvl),	\
+					## arg);	\
+	} while (0)
+
 struct freq_tbl {
 	unsigned int load;
 	unsigned long freq;
diff --git a/drivers/media/platform/qcom/venus/firmware.c b/drivers/media/platform/qcom/venus/firmware.c
index c29acfd..eaf5951 100644
--- a/drivers/media/platform/qcom/venus/firmware.c
+++ b/drivers/media/platform/qcom/venus/firmware.c
@@ -142,7 +142,8 @@ static int venus_boot_no_tz(struct venus_core *core, phys_addr_t mem_phys,
 		dev_err(dev, "could not map video firmware region\n");
 		return ret;
 	}
-
+	dprintk(DBG, "%s: Successfully mapped and performed test translation\n",
+		dev_name(dev));
 	venus_reset_cpu(core);
 
 	return 0;
@@ -258,7 +259,8 @@ int venus_firmware_init(struct venus_core *core)
 		dev_err(core->fw.dev, "could not attach device\n");
 		goto err_iommu_free;
 	}
-
+	dprintk(DBG, "Attached and created mapping for %s\n",
+		dev_name(core->fw.dev));
 	core->fw.iommu_domain = iommu_dom;
 
 	of_node_put(np);
diff --git a/drivers/media/platform/qcom/venus/helpers.c b/drivers/media/platform/qcom/venus/helpers.c
index e436385..9065b44 100644
--- a/drivers/media/platform/qcom/venus/helpers.c
+++ b/drivers/media/platform/qcom/venus/helpers.c
@@ -75,6 +75,7 @@ bool venus_helper_check_codec(struct venus_inst *inst, u32 v4l2_pixfmt)
 		codec = HFI_VIDEO_CODEC_HEVC;
 		break;
 	default:
+		dprintk(WARN, "Unknown format:%x\n", pixfmt);
 		return false;
 	}
 
@@ -102,8 +103,11 @@ static int venus_helper_queue_dpb_bufs(struct venus_inst *inst)
 		fdata.buffer_type = buf->type;
 
 		ret = hfi_session_process_buf(inst, &fdata);
-		if (ret)
+		if (ret) {
+			dprintk(ERR, "%s: Failed to queue dpb buf to hfi: %d\n",
+				__func__, ret);
 			goto fail;
+		}
 	}
 
 fail:
@@ -157,6 +161,7 @@ int venus_helper_alloc_dpb_bufs(struct venus_inst *inst)
 		return ret;
 
 	count = HFI_BUFREQ_COUNT_MIN(&bufreq, ver);
+	dprintk(DBG, "buf count min %d", count);
 
 	for (i = 0; i < count; i++) {
 		buf = kzalloc(sizeof(*buf), GFP_KERNEL);
@@ -174,6 +179,7 @@ int venus_helper_alloc_dpb_bufs(struct venus_inst *inst)
 		if (!buf->va) {
 			kfree(buf);
 			ret = -ENOMEM;
+			dprintk(ERR, "Failed to alloc dma attrs for dpbbufs\n");
 			goto fail;
 		}
 
@@ -208,6 +214,7 @@ static int intbufs_set_buffer(struct venus_inst *inst, u32 type)
 	for (i = 0; i < bufreq.count_actual; i++) {
 		buf = kzalloc(sizeof(*buf), GFP_KERNEL);
 		if (!buf) {
+			dprintk(ERR, "Out of memory\n");
 			ret = -ENOMEM;
 			goto fail;
 		}
@@ -220,6 +227,7 @@ static int intbufs_set_buffer(struct venus_inst *inst, u32 type)
 					  buf->attrs);
 		if (!buf->va) {
 			ret = -ENOMEM;
+			dprintk(ERR, "Failed to alloc dma attrs for intbufs\n");
 			goto fail;
 		}
 
@@ -228,6 +236,8 @@ static int intbufs_set_buffer(struct venus_inst *inst, u32 type)
 		bd.buffer_type = buf->type;
 		bd.num_buffers = 1;
 		bd.device_addr = buf->da;
+		dprintk(DBG, "Buffer address: %#x\n bufsize: %d, buf_type: %d",
+			bd.device_addr, bd.buffer_size, bd.buffer_type);
 
 		ret = hfi_session_set_buffers(inst, &bd);
 		if (ret) {
@@ -380,8 +390,11 @@ static int load_scale_clocks(struct venus_core *core)
 set_freq:
 
 	ret = clk_set_rate(clk, freq);
-	if (ret)
+	if (ret) {
+		dprintk(ERR, "Failed to set clock rate %lu clk: %d\n",
+			freq, ret);
 		goto err;
+	}
 
 	ret = clk_set_rate(core->core0_clk, freq);
 	if (ret)
@@ -459,8 +472,10 @@ static void return_buf_error(struct venus_inst *inst,
 	}
 
 	ret = hfi_session_process_buf(inst, &fdata);
-	if (ret)
+	if (ret) {
+		dprintk(ERR, "%s: Failed qbuf to hfi: %d\n", __func__, ret);
 		return ret;
+		}
 
 	return 0;
 }
@@ -544,11 +559,15 @@ int venus_helper_get_bufreq(struct venus_inst *inst, u32 type,
 		memset(req, 0, sizeof(*req));
 
 	ret = hfi_session_get_property(inst, ptype, &hprop);
-	if (ret)
+	if (ret) {
+		dprintk(ERR, "Failed getting buffer requirements: %d", ret);
 		return ret;
+		}
 
 	ret = -EINVAL;
-
+	dprintk(DBG, "Buffer requirements from HW:\n");
+	dprintk(DBG, "%15s %8s %8s %8s\n",
+		"buffer type", "count", "mincount_fw", "size");
 	for (i = 0; i < HFI_BUFFER_TYPE_MAX; i++) {
 		if (hprop.bufreq[i].type != type)
 			continue;
@@ -556,6 +575,9 @@ int venus_helper_get_bufreq(struct venus_inst *inst, u32 type,
 		if (req)
 			memcpy(req, &hprop.bufreq[i], sizeof(*req));
 		ret = 0;
+		dprintk(DBG, "%8d %8d %8d %8d\n",
+			req->type, req->count_actual,
+			req->count_min, req->size);
 		break;
 	}
 
@@ -730,16 +752,24 @@ int venus_helper_set_num_bufs(struct venus_inst *inst, unsigned int input_bufs,
 	buf_count.count_actual = input_bufs;
 
 	ret = hfi_session_set_property(inst, ptype, &buf_count);
-	if (ret)
+	if (ret) {
+		dprintk(ERR,
+			"Failed to set actual buffer count %d for buffer type %d\n",
+			buf_count.count_actual, buf_count.type);
 		return ret;
 
 	buf_count.type = HFI_BUFFER_OUTPUT;
 	buf_count.count_actual = output_bufs;
 
 	ret = hfi_session_set_property(inst, ptype, &buf_count);
-	if (ret)
+	if (ret) {
+		dprintk(ERR,
+			"Failed to set actual buffer count %d for buffer type %d\n",
+			buf_count.count_actual, buf_count.type);
 		return ret;
-
+	}
+	dprintk(DBG, "output buf: num = %d, input buf = %d\n",
+		output_bufs, input_bufs);
 	if (output2_bufs) {
 		buf_count.type = HFI_BUFFER_OUTPUT2;
 		buf_count.count_actual = output2_bufs;
@@ -776,8 +806,11 @@ int venus_helper_set_color_format(struct venus_inst *inst, u32 pixfmt)
 		return -EINVAL;
 
 	hfi_format = to_hfi_raw_fmt(pixfmt);
-	if (!hfi_format)
+	if (!hfi_format) {
+		dprintk(ERR, "Using unsupported colorformat %#x\n",
+			pixfmt);
 		return -EINVAL;
+	}
 
 	return venus_helper_set_raw_format(inst, hfi_format, buftype);
 }
diff --git a/drivers/media/platform/qcom/venus/hfi.c b/drivers/media/platform/qcom/venus/hfi.c
index 2420782..80bfb47 100644
--- a/drivers/media/platform/qcom/venus/hfi.c
+++ b/drivers/media/platform/qcom/venus/hfi.c
@@ -52,6 +52,7 @@ static u32 to_codec_type(u32 pixfmt)
 	case V4L2_PIX_FMT_HEVC:
 		return HFI_VIDEO_CODEC_HEVC;
 	default:
+		dprintk(WARN, "Wrong codec: fmt %x\n", pixfmt);
 		return 0;
 	}
 }
@@ -62,8 +63,11 @@ int hfi_core_init(struct venus_core *core)
 
 	mutex_lock(&core->lock);
 
-	if (core->state >= CORE_INIT)
+	if (core->state >= CORE_INIT) {
+		dprintk(INFO, "Video core is already in state: %d\n",
+			core->state);
 		goto unlock;
+	}
 
 	reinit_completion(&core->done);
 
@@ -71,8 +75,11 @@ int hfi_core_init(struct venus_core *core)
 	if (ret)
 		goto unlock;
 
+	dprintk(DBG, "Waiting for HFI_MSG_SYS_INIT\n");
 	ret = wait_for_completion_timeout(&core->done, TIMEOUT);
 	if (!ret) {
+		dprintk(ERR, "%s: Wait interrupted or timed out\n",
+			__func__);
 		ret = -ETIMEDOUT;
 		goto unlock;
 	}
@@ -85,6 +92,7 @@ int hfi_core_init(struct venus_core *core)
 	}
 
 	core->state = CORE_INIT;
+	dprintk(DBG, "SYS_INIT_DONE!!!\n");
 unlock:
 	mutex_unlock(&core->lock);
 	return ret;
@@ -207,13 +215,21 @@ int hfi_session_init(struct venus_inst *inst, u32 pixfmt)
 	const struct hfi_ops *ops = core->ops;
 	int ret;
 
+	if (inst->state >= INST_INIT && inst->state < INST_STOP) {
+		dprintk(INFO, "inst: %pK is already in state: %d\n",
+			inst, inst->state);
+		return 0;
+		}
 	inst->hfi_codec = to_codec_type(pixfmt);
 	reinit_completion(&inst->done);
 
+	dprintk(DBG, "%s: inst %pK\n", __func__, inst);
 	ret = ops->session_init(inst, inst->session_type, inst->hfi_codec);
-	if (ret)
+	if (ret) {
+		dprintk(ERR, "Failed to init session, type = %d\n",
+			inst->session_type);
 		return ret;
-
+	}
 	ret = wait_session_msg(inst);
 	if (ret)
 		return ret;
@@ -241,17 +257,27 @@ int hfi_session_deinit(struct venus_inst *inst)
 	const struct hfi_ops *ops = inst->core->ops;
 	int ret;
 
-	if (inst->state == INST_UNINIT)
+	if (inst->state == INST_UNINIT) {
+		dprintk(INFO,
+			"inst: %pK is already in state: %d\n",
+		inst, inst->state);
 		return 0;
+	}
 
-	if (inst->state < INST_INIT)
+	if (inst->state < INST_INIT) {
+		dprintk(ERR, "%s: inst %pK is in invalid state\n",
+			__func__, inst);
 		return -EINVAL;
+	}
 
 	reinit_completion(&inst->done);
 
+	dprintk(DBG, "%s: inst %pK\n", __func__, inst);
 	ret = ops->session_end(inst);
-	if (ret)
+	if (ret) {
+		dprintk(ERR, "Failed to send close\n");
 		return ret;
+		}
 
 	ret = wait_session_msg(inst);
 	if (ret)
@@ -268,14 +294,20 @@ int hfi_session_start(struct venus_inst *inst)
 	const struct hfi_ops *ops = inst->core->ops;
 	int ret;
 
-	if (inst->state != INST_LOAD_RESOURCES)
+	if (inst->state != INST_LOAD_RESOURCES) {
+		dprintk(ERR,
+			"%s: inst %pK is in invalid state\n",
+			__func__, inst);
 		return -EINVAL;
+	}
 
 	reinit_completion(&inst->done);
 
 	ret = ops->session_start(inst);
-	if (ret)
+	if (ret) {
+		dprintk(ERR, "Failed to send start\n");
 		return ret;
+		}
 
 	ret = wait_session_msg(inst);
 	if (ret)
@@ -291,11 +323,16 @@ int hfi_session_stop(struct venus_inst *inst)
 	const struct hfi_ops *ops = inst->core->ops;
 	int ret;
 
-	if (inst->state != INST_START)
+	if (inst->state != INST_START) {
+		dprintk(ERR,
+			"%s: inst %pK is in invalid state\n",
+			__func__, inst);
 		return -EINVAL;
+	}
 
 	reinit_completion(&inst->done);
 
+	dprintk(DBG, "%s: inst %pK\n", __func__, inst);
 	ret = ops->session_stop(inst);
 	if (ret)
 		return ret;
@@ -328,12 +365,17 @@ int hfi_session_abort(struct venus_inst *inst)
 	reinit_completion(&inst->done);
 
 	ret = ops->session_abort(inst);
-	if (ret)
+	if (ret) {
+		dprintk(ERR, "session_abort failed ret: %d\n", ret);
 		return ret;
+	}
 
 	ret = wait_session_msg(inst);
-	if (ret)
+	if (ret) {
+		dprintk(ERR, "%s: inst %pK session %x abort timed out\n",
+			__func__, inst, inst->session_type);
 		return ret;
+	}
 
 	return 0;
 }
@@ -343,15 +385,21 @@ int hfi_session_load_res(struct venus_inst *inst)
 	const struct hfi_ops *ops = inst->core->ops;
 	int ret;
 
-	if (inst->state != INST_INIT)
+	if (inst->state != INST_INIT) {
+		dprintk(ERR,
+			"%s: inst %pK is in invalid state\n",
+			__func__, inst);
 		return -EINVAL;
+	}
 
 	reinit_completion(&inst->done);
 
+	dprintk(DBG, "%s: inst %pK\n", __func__, inst);
 	ret = ops->session_load_res(inst);
-	if (ret)
+	if (ret) {
+		dprintk(ERR, "Failed to send load resources\n");
 		return ret;
-
+	}
 	ret = wait_session_msg(inst);
 	if (ret)
 		return ret;
@@ -366,14 +414,21 @@ int hfi_session_unload_res(struct venus_inst *inst)
 	const struct hfi_ops *ops = inst->core->ops;
 	int ret;
 
-	if (inst->state != INST_STOP)
+	if (inst->state != INST_STOP) {
+		dprintk(ERR,
+			"%s: inst %pK is in invalid state\n",
+			__func__, inst);
 		return -EINVAL;
+		}
 
 	reinit_completion(&inst->done);
 
+	dprintk(DBG, "%s: inst %pK\n", __func__, inst);
 	ret = ops->session_release_res(inst);
-	if (ret)
+	if (ret) {
+		dprintk(ERR, "Failed to send release resources\n");
 		return ret;
+		}
 
 	ret = wait_session_msg(inst);
 	if (ret)
@@ -461,8 +516,10 @@ int hfi_session_set_property(struct venus_inst *inst, u32 ptype, void *pdata)
 {
 	const struct hfi_ops *ops = inst->core->ops;
 
-	if (inst->state < INST_INIT || inst->state >= INST_STOP)
+	if (inst->state < INST_INIT || inst->state >= INST_STOP) {
+		dprintk(ERR, "Not in proper state to set property\n");
 		return -EINVAL;
+		}
 
 	return ops->session_set_property(inst, ptype, pdata);
 }
@@ -478,6 +535,8 @@ int hfi_session_process_buf(struct venus_inst *inst, struct hfi_frame_data *fd)
 		 fd->buffer_type == HFI_BUFFER_OUTPUT2)
 		return ops->session_ftb(inst, fd);
 
+	dprintk(ERR, "%s: invalid qbuf type %d:\n", __func__,
+		fd->buffer_type);
 	return -EINVAL;
 }
 EXPORT_SYMBOL_GPL(hfi_session_process_buf);
diff --git a/drivers/media/platform/qcom/venus/hfi_cmds.c b/drivers/media/platform/qcom/venus/hfi_cmds.c
index 87a4414..3c451a7 100644
--- a/drivers/media/platform/qcom/venus/hfi_cmds.c
+++ b/drivers/media/platform/qcom/venus/hfi_cmds.c
@@ -16,6 +16,7 @@
 #include <linux/hash.h>
 
 #include "hfi_cmds.h"
+#include "core.h"
 
 static enum hfi_version hfi_ver;
 
@@ -161,8 +162,10 @@ void pkt_sys_image_version(struct hfi_sys_get_property_pkt *pkt)
 int pkt_session_init(struct hfi_session_init_pkt *pkt, void *cookie,
 		     u32 session_type, u32 codec)
 {
-	if (!pkt || !cookie || !codec)
+	if (!pkt || !cookie || !codec) {
+		dprintk(ERR, "%s invalid parameters\n", __func__);
 		return -EINVAL;
+		}
 
 	pkt->shdr.hdr.size = sizeof(*pkt);
 	pkt->shdr.hdr.pkt_type = HFI_CMD_SYS_SESSION_INIT;
@@ -185,8 +188,10 @@ int pkt_session_set_buffers(struct hfi_session_set_buffers_pkt *pkt,
 {
 	unsigned int i;
 
-	if (!cookie || !pkt || !bd)
+	if (!cookie || !pkt || !bd) {
+		dprintk(ERR, "%s - invalid params\n", __func__);
 		return -EINVAL;
+		}
 
 	pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_SET_BUFFERS;
 	pkt->shdr.session_id = hash32_ptr(cookie);
@@ -215,7 +220,8 @@ int pkt_session_set_buffers(struct hfi_session_set_buffers_pkt *pkt,
 	}
 
 	pkt->buffer_type = bd->buffer_type;
-
+	dprintk(DBG, "buftype:%d buffer addr: %x\n",
+		pkt->buffer_type, bd->device_addr);
 	return 0;
 }
 
@@ -263,9 +269,11 @@ int pkt_session_unset_buffers(struct hfi_session_release_buffer_pkt *pkt,
 int pkt_session_etb_decoder(struct hfi_session_empty_buffer_compressed_pkt *pkt,
 			    void *cookie, struct hfi_frame_data *in_frame)
 {
-	if (!cookie || !in_frame->device_addr)
+	if (!cookie || !in_frame->device_addr) {
+		dprintk(ERR, "%s: invalid params addr: %#x\n",
+			__func__, in_frame->device_addr);
 		return -EINVAL;
-
+	}
 	pkt->shdr.hdr.size = sizeof(*pkt);
 	pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_EMPTY_BUFFER;
 	pkt->shdr.session_id = hash32_ptr(cookie);
@@ -287,8 +295,11 @@ int pkt_session_etb_encoder(
 		struct hfi_session_empty_buffer_uncompressed_plane0_pkt *pkt,
 		void *cookie, struct hfi_frame_data *in_frame)
 {
-	if (!cookie || !in_frame->device_addr)
+	if (!cookie || !in_frame->device_addr) {
+		dprintk(ERR, "%s: invalid params addr: %#x\n",
+			__func__, in_frame->device_addr);
 		return -EINVAL;
+	}
 
 	pkt->shdr.hdr.size = sizeof(*pkt);
 	pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_EMPTY_BUFFER;
@@ -312,8 +323,11 @@ int pkt_session_etb_encoder(
 int pkt_session_ftb(struct hfi_session_fill_buffer_pkt *pkt, void *cookie,
 		    struct hfi_frame_data *out_frame)
 {
-	if (!cookie || !out_frame || !out_frame->device_addr)
+	if (!cookie || !out_frame || !out_frame->device_addr) {
+		dprintk(ERR, "%s: invalid params addr: %#x\n",
+			__func__, out_frame->device_addr);
 		return -EINVAL;
+	}
 
 	pkt->shdr.hdr.size = sizeof(*pkt);
 	pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_FILL_BUFFER;
@@ -339,8 +353,11 @@ int pkt_session_parse_seq_header(
 		struct hfi_session_parse_sequence_header_pkt *pkt,
 		void *cookie, u32 seq_hdr, u32 seq_hdr_len)
 {
-	if (!cookie || !seq_hdr || !seq_hdr_len)
+	if (!cookie || !seq_hdr || !seq_hdr_len) {
+		dprintk(ERR, "%s: invalid params hdr: %d, hdr_len:%d\n",
+			__func__, seq_hdr, seq_hdr_len);
 		return -EINVAL;
+	}
 
 	pkt->shdr.hdr.size = sizeof(*pkt);
 	pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_PARSE_SEQUENCE_HEADER;
diff --git a/drivers/media/platform/qcom/venus/hfi_msgs.c b/drivers/media/platform/qcom/venus/hfi_msgs.c
index 0ecdaa1..b6ea2f9 100644
--- a/drivers/media/platform/qcom/venus/hfi_msgs.c
+++ b/drivers/media/platform/qcom/venus/hfi_msgs.c
@@ -238,9 +238,14 @@ static void hfi_sys_init_done(struct venus_core *core, struct venus_inst *inst,
 	}
 
 	error = hfi_parser(core, inst, pkt->data, rem_bytes);
+	dprintk(DBG,
+		"supported_codecs[%d]: enc = %#x, dec = %#x\n",
+		core->codecs_count, core->enc_codecs,
+		core->dec_codecs);
 
 done:
 	core->error = error;
+	dprintk(INFO, "sys init ret: %d", core->error);
 	complete(&core->done);
 }
 
diff --git a/drivers/media/platform/qcom/venus/vdec.c b/drivers/media/platform/qcom/venus/vdec.c
index 282de21..7f65e10 100644
--- a/drivers/media/platform/qcom/venus/vdec.c
+++ b/drivers/media/platform/qcom/venus/vdec.c
@@ -97,9 +97,10 @@
 			break;
 	}
 
-	if (i == size || fmt[i].type != type)
+	if (i == size || fmt[i].type != type) {
+		dprintk(INFO, "Format not found\n");
 		return NULL;
-
+	}
 	if (type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE &&
 	    !venus_helper_check_codec(inst, fmt[i].pixfmt))
 		return NULL;
@@ -130,8 +131,10 @@
 			k++;
 	}
 
-	if (i == size)
+	if (i == size) {
+		dprintk(INFO, "Format not found by index\n");
 		return NULL;
+		}
 
 	return &fmt[i];
 }
@@ -236,6 +239,13 @@ static int vdec_g_fmt(struct file *file, void *fh, struct v4l2_format *f)
 
 	vdec_try_fmt_common(inst, f);
 
+	dprintk(DBG,
+		"g_fmt: %x : type %d wxh %dx%d pixelfmt %#x num_planes %d size[0] %d in_reconfig %d\n",
+		inst->session_type, f->type,
+		f->fmt.pix_mp.width, f->fmt.pix_mp.height,
+		f->fmt.pix_mp.pixelformat, f->fmt.pix_mp.num_planes,
+		f->fmt.pix_mp.plane_fmt[0].sizeimage, inst->reconfig);
+
 	return 0;
 }
 
@@ -292,7 +302,8 @@ static int vdec_s_fmt(struct file *file, void *fh, struct v4l2_format *f)
 		inst->fmt_out = fmt;
 	else if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
 		inst->fmt_cap = fmt;
-
+	dprintk(INFO, "s_fmt: inst width: %d height: %d\n",
+		inst->width, inst->height);
 	return 0;
 }
 
@@ -372,8 +383,10 @@ static int vdec_s_parm(struct file *file, void *fh, struct v4l2_streamparm *a)
 	u64 us_per_frame, fps;
 
 	if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE &&
-	    a->type != V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
+	    a->type != V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
+		dprintk(ERR, "Unknown buffer type %d\n", a->type);
 		return -EINVAL;
+		}
 
 	memset(cap->reserved, 0, sizeof(cap->reserved));
 	if (!timeperframe->denominator)
@@ -386,8 +399,11 @@ static int vdec_s_parm(struct file *file, void *fh, struct v4l2_streamparm *a)
 	us_per_frame = timeperframe->numerator * (u64)USEC_PER_SEC;
 	do_div(us_per_frame, timeperframe->denominator);
 
-	if (!us_per_frame)
+	if (!us_per_frame) {
+		dprintk(ERR,
+			"Failed to scale clocks : time between frames is 0\n");
 		return -EINVAL;
+	}
 
 	fps = (u64)USEC_PER_SEC;
 	do_div(fps, us_per_frame);
@@ -395,6 +411,7 @@ static int vdec_s_parm(struct file *file, void *fh, struct v4l2_streamparm *a)
 	inst->fps = fps;
 	inst->timeperframe = *timeperframe;
 
+	dprintk(INFO, "dec: reported fps for %pK: %d\n", inst, inst->fps);
 	return 0;
 }
 
@@ -439,6 +456,7 @@ static int vdec_subscribe_event(struct v4l2_fh *fh,
 	case V4L2_EVENT_CTRL:
 		return v4l2_ctrl_subscribe_event(fh, sub);
 	default:
+		dprintk(ERR, "Failed to subscribe event\n");
 		return -EINVAL;
 	}
 }
@@ -452,6 +470,7 @@ static int vdec_subscribe_event(struct v4l2_fh *fh,
 			return -EINVAL;
 		break;
 	default:
+		dprintk(ERR, "Invalid decoder cmd\n");
 		return -EINVAL;
 	}
 
@@ -527,8 +546,10 @@ static int vdec_set_properties(struct venus_inst *inst)
 	if (ctr->post_loop_deb_mode) {
 		ptype = HFI_PROPERTY_CONFIG_VDEC_POST_LOOP_DEBLOCKER;
 		ret = hfi_session_set_property(inst, ptype, &en);
-		if (ret)
+		if (ret) {
+			dprintk(ERR, "Failed to set dec prop: 0x%x", ptype);
 			return ret;
+			}
 	}
 
 	return 0;
@@ -548,18 +569,24 @@ static int vdec_output_conf(struct venus_inst *inst)
 	int ret;
 
 	ret = venus_helper_set_work_mode(inst, VIDC_WORK_MODE_2);
-	if (ret)
+	if (ret) {
+		dprintk(ERR, "Failed to set workmode 2\n");
 		return ret;
+	}
 
 	ret = venus_helper_set_core_usage(inst, VIDC_CORE_ID_1);
-	if (ret)
+	if (ret) {
+		dprintk(ERR, "Failed to set core usage\n");
 		return ret;
+		}
 
 	if (core->res->hfi_version == HFI_VERSION_1XX) {
 		ptype = HFI_PROPERTY_PARAM_VDEC_CONTINUE_DATA_TRANSFER;
 		ret = hfi_session_set_property(inst, ptype, &en);
-		if (ret)
+		if (ret) {
+			dprintk(ERR, "Failed to set dec prop: 0x%x", ptype);
 			return ret;
+			}
 	}
 
 	/* Force searching UBWC formats for bigger then HD resolutions */
@@ -572,8 +599,10 @@ static int vdec_output_conf(struct venus_inst *inst)
 
 	ret = venus_helper_get_out_fmts(inst, inst->fmt_cap->pixfmt, &out_fmt,
 					&out2_fmt, ubwc);
-	if (ret)
+	if (ret) {
+		dprintk(ERR, "Failed to get outfmt:%x", inst->fmt_cap->pixfmt);
 		return ret;
+		}
 
 	inst->output_buf_size =
 			venus_helper_get_framesz_raw(out_fmt, width, height);
@@ -599,23 +628,34 @@ static int vdec_output_conf(struct venus_inst *inst)
 
 	ret = venus_helper_set_raw_format(inst, inst->opb_fmt,
 					  inst->opb_buftype);
-	if (ret)
+	if (ret) {
+		dprintk(ERR, "Failed to set raw fmt opb fmt:0x%x",
+			inst->opb_fmt);
 		return ret;
+	}
 
 	if (inst->dpb_fmt) {
 		ret = venus_helper_set_multistream(inst, false, true);
-		if (ret)
+		if (ret) {
+			dprintk(ERR, "Failed to set multistream");
 			return ret;
+		}
 
 		ret = venus_helper_set_raw_format(inst, inst->dpb_fmt,
 						  inst->dpb_buftype);
-		if (ret)
+		if (ret) {
+			dprintk(ERR, "Failed to set raw fmt dpb fmt:0x%x",
+				inst->dpb_fmt);
 			return ret;
-
+			}
 		ret = venus_helper_set_output_resolution(inst, width, height,
 							 HFI_BUFFER_OUTPUT2);
-		if (ret)
+		if (ret) {
+			dprintk(ERR,
+				"Failed to set o/p resolution width:%d, height:%d",
+				width, height);
 			return ret;
+		}
 	}
 
 	if (IS_V3(core) || IS_V4(core)) {
@@ -623,23 +663,32 @@ static int vdec_output_conf(struct venus_inst *inst)
 			ret = venus_helper_set_bufsize(inst,
 						       inst->output2_buf_size,
 						       HFI_BUFFER_OUTPUT2);
-			if (ret)
+			if (ret) {
+				dprintk(ERR,
+					"Failed to set bufsize: %d for o/p2",
+					inst->output2_buf_size);
 				return ret;
+			}
 		}
 
 		if (inst->output_buf_size) {
 			ret = venus_helper_set_bufsize(inst,
 						       inst->output_buf_size,
 						       HFI_BUFFER_OUTPUT);
-			if (ret)
+			if (ret) {
+				dprintk(ERR,
+					"Failed to set bufsize: %d for o/p",
+						inst->output_buf_size);
 				return ret;
+			}
 		}
 	}
 
 	ret = venus_helper_set_dyn_bufmode(inst);
-	if (ret)
+	if (ret) {
+		dprintk(ERR, "Failed to set dynamic buffer mode\n");
 		return ret;
-
+		}
 	return 0;
 }
 
@@ -648,17 +697,26 @@ static int vdec_init_session(struct venus_inst *inst)
 	int ret;
 
 	ret = hfi_session_init(inst, inst->fmt_out->pixfmt);
-	if (ret)
+	if (ret) {
+		dprintk(ERR, "Failed to init firmware session\n");
 		return ret;
+	}
 
 	ret = venus_helper_set_input_resolution(inst, inst->out_width,
 						inst->out_height);
-	if (ret)
+	if (ret) {
+		dprintk(ERR,
+			"Failed to set i/p resolution width:%d, height:%d",
+			inst->out_width, inst->out_height);
 		goto deinit;
+	}
 
 	ret = venus_helper_set_color_format(inst, inst->fmt_cap->pixfmt);
-	if (ret)
+	if (ret) {
+		dprintk(ERR, "Failed to set color format fmt:0x%x",
+			inst->fmt_cap->pixfmt);
 		goto deinit;
+		}
 
 	return 0;
 deinit:
@@ -676,18 +734,24 @@ static int vdec_num_buffers(struct venus_inst *inst, unsigned int *in_num,
 	*in_num = *out_num = 0;
 
 	ret = vdec_init_session(inst);
-	if (ret)
+	if (ret) {
+		dprintk(ERR, "Failed to init decoder session");
 		return ret;
+		}
 
 	ret = venus_helper_get_bufreq(inst, HFI_BUFFER_INPUT, &bufreq);
-	if (ret)
+	if (ret) {
+		dprintk(ERR, "Failed to get bufreq on i/p");
 		goto deinit;
+		}
 
 	*in_num = HFI_BUFREQ_COUNT_MIN(&bufreq, ver);
 
 	ret = venus_helper_get_bufreq(inst, HFI_BUFFER_OUTPUT, &bufreq);
-	if (ret)
+	if (ret) {
+		dprintk(ERR, "Failed to get bufreq on i/p");
 		goto deinit;
+	}
 
 	*out_num = HFI_BUFREQ_COUNT_MIN(&bufreq, ver);
 
@@ -728,8 +792,10 @@ static int vdec_queue_setup(struct vb2_queue *q,
 	}
 
 	ret = vdec_num_buffers(inst, &in_num, &out_num);
-	if (ret)
+	if (ret) {
+		dprintk(ERR, "Failed : No buffer requirements\n");
 		return ret;
+		}
 
 	switch (q->type) {
 	case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
@@ -752,10 +818,14 @@ static int vdec_queue_setup(struct vb2_queue *q,
 		inst->num_output_bufs = *num_buffers;
 		break;
 	default:
+		dprintk(ERR, "Invalid q type = %d\n", q->type);
 		ret = -EINVAL;
 		break;
 	}
-
+	dprintk(DBG,
+		"%s: %d : type %d num_buffers %d num_planes %d sizes[0] %d\n",
+		__func__, inst->session_type, q->type, *num_buffers,
+		*num_planes, sizes[0]);
 	return ret;
 }
 
@@ -765,24 +835,45 @@ static int vdec_verify_conf(struct venus_inst *inst)
 	struct hfi_buffer_requirements bufreq;
 	int ret;
 
-	if (!inst->num_input_bufs || !inst->num_output_bufs)
+	if (!inst->num_input_bufs || !inst->num_output_bufs) {
+		dprintk(ERR, "Failed: insuffice bufs i/p_buf: %d o/p_buf: %d",
+			inst->num_input_bufs, inst->num_output_bufs);
 		return -EINVAL;
+		}
 
 	ret = venus_helper_get_bufreq(inst, HFI_BUFFER_OUTPUT, &bufreq);
-	if (ret)
+	if (ret) {
+		dprintk(ERR, "Failed to get bufreq o/p\n");
 		return ret;
-
+		}
+	dprintk(DBG, "Verifying Buffer: %d\n", bufreq.type);
 	if (inst->num_output_bufs < bufreq.count_actual ||
-	    inst->num_output_bufs < HFI_BUFREQ_COUNT_MIN(&bufreq, ver))
+	    inst->num_output_bufs < HFI_BUFREQ_COUNT_MIN(&bufreq, ver)) {
+		dprintk(ERR,
+			"Invalid data : Counts mismatch\n");
+		dprintk(ERR, "num of output bufs = %d ",
+			inst->num_output_bufs);
+		dprintk(ERR, "actual buf count = %d ",
+			bufreq.count_actual);
+		dprintk(ERR, "Min Actual Count = %d\n",
+			HFI_BUFREQ_COUNT_MIN(&bufreq, ver));
 		return -EINVAL;
-
+	}
+	dprintk(DBG, "Verifying Buffer: %d\n", bufreq.type);
 	ret = venus_helper_get_bufreq(inst, HFI_BUFFER_INPUT, &bufreq);
-	if (ret)
+	if (ret) {
+		dprintk(ERR, "Failed to get bufreq i/p\n");
 		return ret;
-
-	if (inst->num_input_bufs < HFI_BUFREQ_COUNT_MIN(&bufreq, ver))
+		}
+	if (inst->num_input_bufs < HFI_BUFREQ_COUNT_MIN(&bufreq, ver)) {
+		dprintk(ERR,
+			"Invalid data : Counts mismatch\n");
+		dprintk(ERR, "num of input bufs = %d ",
+			inst->num_input_bufs);
+		dprintk(ERR, "Min Actual Count = %d\n",
+			HFI_BUFREQ_COUNT_MIN(&bufreq, ver));
 		return -EINVAL;
-
+	}
 	return 0;
 }
 
@@ -791,6 +882,9 @@ static int vdec_start_streaming(struct vb2_queue *q, unsigned int count)
 	struct venus_inst *inst = vb2_get_drv_priv(q);
 	int ret;
 
+	dprintk(DBG, "Streamon called on: %d capability for inst: %pK\n",
+		q->type, inst);
+
 	mutex_lock(&inst->lock);
 
 	if (q->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
@@ -894,8 +988,12 @@ static void vdec_buf_done(struct venus_inst *inst, unsigned int buf_type,
 		if (vbuf->flags & V4L2_BUF_FLAG_LAST) {
 			const struct v4l2_event ev = { .type = V4L2_EVENT_EOS };
 
+			dprintk(DBG, "Received EOS buffer");
 			v4l2_event_queue_fh(&inst->fh, &ev);
 		}
+		dprintk(INFO,
+			"buf done: data_offset = %d; bytesused = %d; length = %d\n",
+			vb->planes[0].data_offset, vb->planes[0].length);
 	} else {
 		vbuf->sequence = inst->sequence_out++;
 	}
@@ -1021,8 +1119,10 @@ static int vdec_open(struct file *file)
 	int ret;
 
 	inst = kzalloc(sizeof(*inst), GFP_KERNEL);
-	if (!inst)
+	if (!inst) {
+		dprintk(ERR, "dec: Failed to create video instance");
 		return -ENOMEM;
+		}
 
 	INIT_LIST_HEAD(&inst->dpbbufs);
 	INIT_LIST_HEAD(&inst->registeredbufs);
@@ -1041,12 +1141,16 @@ static int vdec_open(struct file *file)
 		goto err_free_inst;
 
 	ret = vdec_ctrl_init(inst);
-	if (ret)
+	if (ret) {
+		dprintk(ERR, "Failed control initialization\n");
 		goto err_put_sync;
+	}
 
 	ret = hfi_session_create(inst, &vdec_hfi_ops);
-	if (ret)
+	if (ret) {
+		dprintk(ERR, "Failed to create session\n");
 		goto err_ctrl_deinit;
+	}
 
 	vdec_inst_init(inst);
 
@@ -1232,6 +1336,7 @@ static __maybe_unused int vdec_runtime_resume(struct device *dev)
 err_unprepare_core0:
 	clk_disable_unprepare(core->core0_clk);
 err_power_disable:
+	dprintk(ERR, "Failed to enable core0 clk\n");
 	venus_helper_power_enable(core, VIDC_SESSION_TYPE_DEC, false);
 	return ret;
 }
diff --git a/drivers/media/platform/qcom/venus/vdec_ctrls.c b/drivers/media/platform/qcom/venus/vdec_ctrls.c
index f4604b0..bfc6904 100644
--- a/drivers/media/platform/qcom/venus/vdec_ctrls.c
+++ b/drivers/media/platform/qcom/venus/vdec_ctrls.c
@@ -91,8 +91,11 @@ int vdec_ctrl_init(struct venus_inst *inst)
 	int ret;
 
 	ret = v4l2_ctrl_handler_init(&inst->ctrl_handler, 7);
-	if (ret)
+	if (ret) {
+		dprintk(ERR, "CTRL ERR: Control handler init failed, %d\n",
+			inst->ctrl_handler.error);
 		return ret;
+	}
 
 	ctrl = v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &vdec_ctrl_ops,
 		V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE,
@@ -147,6 +150,8 @@ int vdec_ctrl_init(struct venus_inst *inst)
 
 	ret = inst->ctrl_handler.error;
 	if (ret) {
+		dprintk(ERR, "Error adding ctrl to ctrl handle, %d\n",
+			inst->ctrl_handler.error);
 		v4l2_ctrl_handler_free(&inst->ctrl_handler);
 		return ret;
 	}
diff --git a/drivers/media/platform/qcom/venus/venc.c b/drivers/media/platform/qcom/venus/venc.c
index 32cff29..0151b01 100644
--- a/drivers/media/platform/qcom/venus/venc.c
+++ b/drivers/media/platform/qcom/venus/venc.c
@@ -79,9 +79,10 @@
 			break;
 	}
 
-	if (i == size || fmt[i].type != type)
+	if (i == size || fmt[i].type != type) {
+		dprintk(INFO, "Format not found\n");
 		return NULL;
-
+	}
 	if (type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE &&
 	    !venus_helper_check_codec(inst, fmt[i].pixfmt))
 		return NULL;
@@ -112,9 +113,10 @@
 			k++;
 	}
 
-	if (i == size)
+	if (i == size) {
+		dprintk(INFO, "Format not found by index\n");
 		return NULL;
-
+	}
 	return &fmt[i];
 }
 
@@ -289,8 +291,10 @@ static int venc_enum_fmt(struct file *file, void *fh, struct v4l2_fmtdesc *f)
 
 	memset(f->reserved, 0, sizeof(f->reserved));
 
-	if (!fmt)
+	if (!fmt) {
+		dprintk(DBG, "No more formats found\n");
 		return -EINVAL;
+	}
 
 	f->pixelformat = fmt->pixfmt;
 
@@ -367,8 +371,11 @@ static int venc_s_fmt(struct file *file, void *fh, struct v4l2_format *f)
 	orig_pixmp = *pixmp;
 
 	fmt = venc_try_fmt_common(inst, f);
-	if (!fmt)
+	if (!fmt) {
+		dprintk(ERR, "Format: %d not supported\n",
+			f->fmt.pix_mp.pixelformat);
 		return -EINVAL;
+	}
 
 	if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
 		pixfmt_out = pixmp->pixelformat;
@@ -410,7 +417,8 @@ static int venc_s_fmt(struct file *file, void *fh, struct v4l2_format *f)
 		inst->fmt_out = fmt;
 	else if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
 		inst->fmt_cap = fmt;
-
+	dprintk(INFO, "s_fmt: inst width: %d height: %d\n",
+		inst->width, inst->height);
 	return 0;
 }
 
@@ -443,6 +451,13 @@ static int venc_g_fmt(struct file *file, void *fh, struct v4l2_format *f)
 
 	venc_try_fmt_common(inst, f);
 
+	dprintk(DBG,
+		"g_fmt: %x : type %d wxh %dx%d pixelfmt %#x num_planes %d size[0] %d in_reconfig %d\n",
+		inst->session_type, f->type,
+		f->fmt.pix_mp.width, f->fmt.pix_mp.height,
+		f->fmt.pix_mp.pixelformat, f->fmt.pix_mp.num_planes,
+		f->fmt.pix_mp.plane_fmt[0].sizeimage, inst->reconfig);
+
 	return 0;
 }
 
@@ -504,8 +519,10 @@ static int venc_s_parm(struct file *file, void *fh, struct v4l2_streamparm *a)
 	u64 us_per_frame, fps;
 
 	if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE &&
-	    a->type != V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
+	    a->type != V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
+		dprintk(ERR, "Unknown buffer type %d\n", a->type);
 		return -EINVAL;
+	}
 
 	memset(out->reserved, 0, sizeof(out->reserved));
 
@@ -519,8 +536,11 @@ static int venc_s_parm(struct file *file, void *fh, struct v4l2_streamparm *a)
 	us_per_frame = timeperframe->numerator * (u64)USEC_PER_SEC;
 	do_div(us_per_frame, timeperframe->denominator);
 
-	if (!us_per_frame)
+	if (!us_per_frame) {
+		dprintk(ERR,
+			"Failed to scale clocks : time between frames is 0\n");
 		return -EINVAL;
+		}
 
 	fps = (u64)USEC_PER_SEC;
 	do_div(fps, us_per_frame);
@@ -528,6 +548,7 @@ static int venc_s_parm(struct file *file, void *fh, struct v4l2_streamparm *a)
 	inst->timeperframe = *timeperframe;
 	inst->fps = fps;
 
+	dprintk(INFO, "enc: reported fps for %pK: %d\n", inst, inst->fps);
 	return 0;
 }
 
@@ -657,20 +678,26 @@ static int venc_set_properties(struct venus_inst *inst)
 	int ret;
 
 	ret = venus_helper_set_work_mode(inst, VIDC_WORK_MODE_2);
-	if (ret)
+	if (ret) {
+		dprintk(ERR, "Failed to set workmode 2\n");
 		return ret;
+	}
 
 	ret = venus_helper_set_core_usage(inst, VIDC_CORE_ID_2);
-	if (ret)
+	if (ret) {
+		dprintk(ERR, "Failed to set core usage\n");
 		return ret;
+		}
 
 	ptype = HFI_PROPERTY_CONFIG_FRAME_RATE;
 	frate.buffer_type = HFI_BUFFER_OUTPUT;
 	frate.framerate = inst->fps * (1 << 16);
 
 	ret = hfi_session_set_property(inst, ptype, &frate);
-	if (ret)
+	if (ret) {
+		dprintk(ERR, "Failed to set core usage\n");
 		return ret;
+		}
 
 	if (inst->fmt_cap->pixfmt == V4L2_PIX_FMT_H264) {
 		struct hfi_h264_vui_timing_info info;
@@ -829,28 +856,41 @@ static int venc_init_session(struct venus_inst *inst)
 	int ret;
 
 	ret = hfi_session_init(inst, inst->fmt_cap->pixfmt);
-	if (ret)
+	if (ret) {
+		dprintk(ERR, "Failed to init firmware session\n");
 		return ret;
+	}
 
 	ret = venus_helper_set_input_resolution(inst, inst->width,
 						inst->height);
-	if (ret)
+	if (ret) {
+		dprintk(ERR,
+			"Failed to set i/p resolution width: %d, height: %d",
+			inst->width, inst->height);
 		goto deinit;
+	}
 
 	ret = venus_helper_set_output_resolution(inst, inst->width,
 						 inst->height,
 						 HFI_BUFFER_OUTPUT);
-	if (ret)
+	if (ret) {
+		dprintk(ERR,
+			"Failed to set o/p resolution width: %d, height: %d",
+			inst->width, inst->height);
 		goto deinit;
+	}
 
 	ret = venus_helper_set_color_format(inst, inst->fmt_out->pixfmt);
-	if (ret)
+	if (ret) {
+		dprintk(ERR, "Failed to set color format");
 		goto deinit;
+		}
 
 	ret = venc_set_properties(inst);
-	if (ret)
+	if (ret) {
+		dprintk(ERR, "Failed to set enc properties");
 		goto deinit;
-
+	}
 	return 0;
 deinit:
 	hfi_session_deinit(inst);
@@ -863,8 +903,10 @@ static int venc_out_num_buffers(struct venus_inst *inst, unsigned int *num)
 	int ret;
 
 	ret = venc_init_session(inst);
-	if (ret)
+	if (ret) {
+		dprintk(ERR, "Failed to init encoder session");
 		return ret;
+		}
 
 	ret = venus_helper_get_bufreq(inst, HFI_BUFFER_INPUT, &bufreq);
 
@@ -908,9 +950,12 @@ static int venc_queue_setup(struct vb2_queue *q,
 		*num_planes = inst->fmt_out->num_planes;
 
 		ret = venc_out_num_buffers(inst, &num);
-		if (ret)
+		if (ret) {
+			dprintk(ERR,
+				"Failed : No buffer requirements : %x\n",
+				HFI_BUFFER_INPUT);
 			break;
-
+		}
 		num = max(num, min);
 		*num_buffers = max(*num_buffers, num);
 		inst->num_input_bufs = *num_buffers;
@@ -930,10 +975,15 @@ static int venc_queue_setup(struct vb2_queue *q,
 		inst->output_buf_size = sizes[0];
 		break;
 	default:
+		dprintk(ERR, "Invalid q type = %d\n", q->type);
 		ret = -EINVAL;
 		break;
 	}
 
+	dprintk(DBG,
+		"queue_setup: %d : type %d num_buffers %d num_planes %d sizes[0] %d\n",
+		inst->session_type, q->type, *num_buffers,
+		*num_planes, sizes[0]);
 	return ret;
 }
 
@@ -943,25 +993,52 @@ static int venc_verify_conf(struct venus_inst *inst)
 	struct hfi_buffer_requirements bufreq;
 	int ret;
 
-	if (!inst->num_input_bufs || !inst->num_output_bufs)
+	if (!inst->num_input_bufs || !inst->num_output_bufs) {
+		dprintk(ERR,
+			"Failed with insufficient bufs i/p_buf: %d o/p_buf: %d",
+			inst->num_input_bufs, inst->num_output_bufs);
 		return -EINVAL;
+	}
 
 	ret = venus_helper_get_bufreq(inst, HFI_BUFFER_OUTPUT, &bufreq);
-	if (ret)
+	if (ret) {
+		dprintk(ERR, "Failed to get bufreq o/p\n");
 		return ret;
+		}
+	dprintk(DBG, "Verifying Buffer: %d\n", bufreq.type);
 
 	if (inst->num_output_bufs < bufreq.count_actual ||
-	    inst->num_output_bufs < HFI_BUFREQ_COUNT_MIN(&bufreq, ver))
+	    inst->num_output_bufs < HFI_BUFREQ_COUNT_MIN(&bufreq, ver)) {
+		dprintk(ERR,
+			"Invalid data : Counts mismatch\n");
+		dprintk(ERR, "num of output bufs = %d ",
+			inst->num_output_bufs);
+		dprintk(ERR, "actual buf count = %d ",
+			bufreq.count_actual);
+		dprintk(ERR, "Min Actual Count = %d\n",
+			HFI_BUFREQ_COUNT_MIN(&bufreq, ver));
 		return -EINVAL;
+		}
 
+	dprintk(DBG, "Verifying Buffer: %d\n", bufreq.type);
 	ret = venus_helper_get_bufreq(inst, HFI_BUFFER_INPUT, &bufreq);
-	if (ret)
+	if (ret) {
+		dprintk(ERR, "Failed to get bufreq i/p\n");
 		return ret;
+		}
 
 	if (inst->num_input_bufs < bufreq.count_actual ||
-	    inst->num_input_bufs < HFI_BUFREQ_COUNT_MIN(&bufreq, ver))
+	    inst->num_input_bufs < HFI_BUFREQ_COUNT_MIN(&bufreq, ver)) {
+		dprintk(ERR,
+			"Invalid data : Counts mismatch\n");
+		dprintk(ERR, "num of input bufs = %d ",
+			inst->num_output_bufs);
+		dprintk(ERR, "actual buf count = %d ",
+			bufreq.count_actual);
+		dprintk(ERR, "Min Actual Count = %d\n",
+			HFI_BUFREQ_COUNT_MIN(&bufreq, ver));
 		return -EINVAL;
-
+		}
 	return 0;
 }
 
@@ -972,6 +1049,9 @@ static int venc_start_streaming(struct vb2_queue *q, unsigned int count)
 
 	mutex_lock(&inst->lock);
 
+	dprintk(DBG, "Streamon called on: %d capability for inst: %pK\n",
+		q->type, inst);
+
 	if (q->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
 		inst->streamon_out = 1;
 	else
@@ -1148,8 +1228,10 @@ static int venc_open(struct file *file)
 	int ret;
 
 	inst = kzalloc(sizeof(*inst), GFP_KERNEL);
-	if (!inst)
+	if (!inst) {
+		dprintk(ERR, "enc: Failed to create video instance");
 		return -ENOMEM;
+	}
 
 	INIT_LIST_HEAD(&inst->dpbbufs);
 	INIT_LIST_HEAD(&inst->registeredbufs);
@@ -1358,6 +1440,7 @@ static __maybe_unused int venc_runtime_resume(struct device *dev)
 err_unprepare_core1:
 	clk_disable_unprepare(core->core1_clk);
 err_power_disable:
+	dprintk(ERR, "Failed to enable core1 clk");
 	venus_helper_power_enable(core, VIDC_SESSION_TYPE_ENC, false);
 	return ret;
 }
diff --git a/drivers/media/platform/qcom/venus/venc_ctrls.c b/drivers/media/platform/qcom/venus/venc_ctrls.c
index ac1e1d2..dbbec61 100644
--- a/drivers/media/platform/qcom/venus/venc_ctrls.c
+++ b/drivers/media/platform/qcom/venus/venc_ctrls.c
@@ -203,6 +203,7 @@ static int venc_op_s_ctrl(struct v4l2_ctrl *ctrl)
 		mutex_unlock(&inst->lock);
 		break;
 	default:
+		dprintk(ERR, "Unsupported ctrl: %x\n", ctrl->id);
 		return -EINVAL;
 	}
 
@@ -218,9 +219,11 @@ int venc_ctrl_init(struct venus_inst *inst)
 	int ret;
 
 	ret = v4l2_ctrl_handler_init(&inst->ctrl_handler, 28);
-	if (ret)
+	if (ret) {
+		dprintk(ERR, "CTRL ERR: Control handler init failed, %d\n",
+			inst->ctrl_handler.error);
 		return ret;
-
+	}
 	v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
 		V4L2_CID_MPEG_VIDEO_BITRATE_MODE,
 		V4L2_MPEG_VIDEO_BITRATE_MODE_CBR,
@@ -351,6 +354,8 @@ int venc_ctrl_init(struct venus_inst *inst)
 
 	return 0;
 err:
+	dprintk(ERR, "Error adding ctrl to ctrl handle, %d\n",
+		inst->ctrl_handler.error);
 	v4l2_ctrl_handler_free(&inst->ctrl_handler);
 	return ret;
 }
