video: driver: print buffer_name instead of hex value

Handled below items as part of this change.

- print buffer_name instead of hex value.
- enable dcvs only for realtime sessions.
- enhanced max_input_data_size handling at
  msm_vidc_scale_power.

Change-Id: If5ac810f4e020bee54364161596c5547af94161a
Signed-off-by: Govindaraj Rajagopal <[email protected]>

driver/variant/iris2/src/msm_vidc_buffer_iris2.c

@@ -473,8 +473,8 @@ struct msm_vidc_buf_type_handle {
 int msm_buffer_size_iris2(struct msm_vidc_inst *inst,
 		enum msm_vidc_buffer_type buffer_type)
 {
-	int i, size = 0;
-	u32 buf_type_handle_size = 0;
+	int i;
+	u32 size = 0, buf_type_handle_size = 0;
 	const struct msm_vidc_buf_type_handle *buf_type_handle_arr = NULL;
 	static const struct msm_vidc_buf_type_handle dec_buf_type_handle[] = {
 		{MSM_VIDC_BUF_INPUT,           msm_vidc_decoder_input_size              },
@@ -525,9 +525,14 @@ int msm_buffer_size_iris2(struct msm_vidc_inst *inst,
 	}
 
 	/* handle unknown buffer type */
-	if (i == buf_type_handle_size)
+	if (i == buf_type_handle_size) {
 		i_vpr_e(inst, "%s: unknown buffer type %#x\n", __func__, buffer_type);
+		goto exit;
+	}
+
+	i_vpr_l(inst, "buffer_size: type: %11s,  size: %9u\n", buf_name(buffer_type), size);
 
+exit:
 	return size;
 }
 
@@ -589,7 +594,7 @@ int msm_buffer_min_count_iris2(struct msm_vidc_inst *inst,
 		break;
 	}
 
-	i_vpr_l(inst, "%s: type %u, count %u\n", __func__, buffer_type, count);
+	i_vpr_l(inst, "  min_count: type: %11s, count: %9u\n", buf_name(buffer_type), count);
 	return count;
 }
 
@@ -616,6 +621,6 @@ int msm_buffer_extra_count_iris2(struct msm_vidc_inst *inst,
 		break;
 	}
 
-	i_vpr_l(inst, "%s: type %u, count %u\n", __func__, buffer_type, count);
+	i_vpr_l(inst, "extra_count: type: %11s, count: %9u\n", buf_name(buffer_type), count);
 	return count;
 }

driver/vidc/inc/msm_vidc_driver.h

@@ -272,6 +272,7 @@ int msm_vidc_change_core_state(struct msm_vidc_core *core,
 int msm_vidc_core_init(struct msm_vidc_core *core);
 int msm_vidc_core_deinit(struct msm_vidc_core *core, bool force);
 int msm_vidc_core_timeout(struct msm_vidc_core *core);
+int msm_vidc_print_buffer_info(struct msm_vidc_inst *inst);
 int msm_vidc_print_inst_info(struct msm_vidc_inst *inst);
 void msm_vidc_print_core_info(struct msm_vidc_core *core);
 int msm_vidc_smmu_fault_handler(struct iommu_domain *domain,
@@ -360,5 +361,6 @@ bool msm_vidc_allow_decode_batch(struct msm_vidc_inst *inst);
 int msm_vidc_check_session_supported(struct msm_vidc_inst *inst);
 int msm_vidc_check_mbps_supported(struct msm_vidc_inst *inst);
 int msm_vidc_check_scaling_supported(struct msm_vidc_inst *inst);
+const char *buf_name(enum msm_vidc_buffer_type type);
 #endif // _MSM_VIDC_DRIVER_H_
 

driver/vidc/inc/msm_vidc_internal.h

@@ -136,21 +136,20 @@ enum msm_vidc_colorformat_type {
 };
 
 enum msm_vidc_buffer_type {
-	MSM_VIDC_BUF_NONE = 0,
-	MSM_VIDC_BUF_INPUT         = 1,
-	MSM_VIDC_BUF_OUTPUT        = 2,
-	MSM_VIDC_BUF_INPUT_META    = 3,
-	MSM_VIDC_BUF_OUTPUT_META   = 4,
-	MSM_VIDC_BUF_READ_ONLY     = 5,
-	MSM_VIDC_BUF_QUEUE         = 10,
-	MSM_VIDC_BUF_BIN           = 20,
-	MSM_VIDC_BUF_ARP           = 21,
-	MSM_VIDC_BUF_COMV          = 22,
-	MSM_VIDC_BUF_NON_COMV      = 23,
-	MSM_VIDC_BUF_LINE          = 24,
-	MSM_VIDC_BUF_DPB           = 25,
-	MSM_VIDC_BUF_PERSIST       = 26,
-	MSM_VIDC_BUF_VPSS          = 27,
+	MSM_VIDC_BUF_INPUT                 = 1,
+	MSM_VIDC_BUF_OUTPUT                = 2,
+	MSM_VIDC_BUF_INPUT_META            = 3,
+	MSM_VIDC_BUF_OUTPUT_META           = 4,
+	MSM_VIDC_BUF_READ_ONLY             = 5,
+	MSM_VIDC_BUF_QUEUE                 = 6,
+	MSM_VIDC_BUF_BIN                   = 7,
+	MSM_VIDC_BUF_ARP                   = 8,
+	MSM_VIDC_BUF_COMV                  = 9,
+	MSM_VIDC_BUF_NON_COMV              = 10,
+	MSM_VIDC_BUF_LINE                  = 11,
+	MSM_VIDC_BUF_DPB                   = 12,
+	MSM_VIDC_BUF_PERSIST               = 13,
+	MSM_VIDC_BUF_VPSS                  = 14,
 };
 
 /* always match with v4l2 flags V4L2_BUF_FLAG_* */

driver/vidc/src/msm_vdec.c

@@ -816,24 +816,6 @@ static int msm_vdec_get_input_internal_buffers(struct msm_vidc_inst *inst)
 			return rc;
 	}
 
-	i_vpr_h(inst, "input internal buffer: min     size     reuse\n");
-	i_vpr_h(inst, "bin  buffer: %d      %d      %d\n",
-		inst->buffers.bin.min_count,
-		inst->buffers.bin.size,
-		inst->buffers.bin.reuse);
-	i_vpr_h(inst, "comv  buffer: %d      %d      %d\n",
-		inst->buffers.comv.min_count,
-		inst->buffers.comv.size,
-		inst->buffers.comv.reuse);
-	i_vpr_h(inst, "non_comv  buffer: %d      %d      %d\n",
-		inst->buffers.non_comv.min_count,
-		inst->buffers.non_comv.size,
-		inst->buffers.non_comv.reuse);
-	i_vpr_h(inst, "line buffer: %d      %d      %d\n",
-		inst->buffers.line.min_count,
-		inst->buffers.line.size,
-		inst->buffers.line.reuse);
-
 	return rc;
 }
 
@@ -850,12 +832,6 @@ static int msm_vdec_get_output_internal_buffers(struct msm_vidc_inst *inst)
 	if (rc)
 		return rc;
 
-	i_vpr_h(inst, "output internal buffer: min     size     reuse\n");
-	i_vpr_h(inst, "dpb  buffer: %d      %d      %d\n",
-		inst->buffers.dpb.min_count,
-		inst->buffers.dpb.size,
-		inst->buffers.dpb.reuse);
-
 	return rc;
 }
 
@@ -1832,14 +1808,18 @@ int msm_vdec_process_cmd(struct msm_vidc_inst *inst, u32 cmd)
 		vb2_clear_last_buffer_dequeued(&inst->vb2q[OUTPUT_META_PORT]);
 		vb2_clear_last_buffer_dequeued(&inst->vb2q[OUTPUT_PORT]);
 
+		rc = msm_vidc_state_change_start(inst);
+		if (rc)
+			return rc;
+
 		/* tune power features */
 		inst->decode_batch.enable = msm_vidc_allow_decode_batch(inst);
 		msm_vidc_allow_dcvs(inst);
 		msm_vidc_power_data_reset(inst);
 
-		rc = msm_vidc_state_change_start(inst);
-		if (rc)
-			return rc;
+		/* print final buffer counts & size details */
+		msm_vidc_print_buffer_info(inst);
+
 		rc = venus_hfi_session_command(inst,
 				HFI_CMD_RESUME,
 				port,

driver/vidc/src/msm_venc.c

@@ -653,23 +653,6 @@ static int msm_venc_get_output_internal_buffers(struct msm_vidc_inst *inst)
 			return rc;
 	}
 
-	i_vpr_h(inst, "internal buffer: min     size\n");
-	i_vpr_h(inst, "bin  buffer: %d      %d\n",
-		inst->buffers.bin.min_count,
-		inst->buffers.bin.size);
-	i_vpr_h(inst, "comv  buffer: %d      %d\n",
-		inst->buffers.comv.min_count,
-		inst->buffers.comv.size);
-	i_vpr_h(inst, "non_comv  buffer: %d      %d\n",
-		inst->buffers.non_comv.min_count,
-		inst->buffers.non_comv.size);
-	i_vpr_h(inst, "line buffer: %d      %d\n",
-		inst->buffers.line.min_count,
-		inst->buffers.line.size);
-	i_vpr_h(inst, "dpb buffer: %d      %d\n",
-		inst->buffers.dpb.min_count,
-		inst->buffers.dpb.size);
-
 	return rc;
 }
 
@@ -973,13 +956,17 @@ int msm_venc_process_cmd(struct msm_vidc_inst *inst, u32 cmd)
 		vb2_clear_last_buffer_dequeued(&inst->vb2q[OUTPUT_META_PORT]);
 		vb2_clear_last_buffer_dequeued(&inst->vb2q[OUTPUT_PORT]);
 
+		rc = msm_vidc_state_change_start(inst);
+		if (rc)
+			return rc;
+
 		/* tune power features */
 		msm_vidc_allow_dcvs(inst);
 		msm_vidc_power_data_reset(inst);
 
-		rc = msm_vidc_state_change_start(inst);
-		if (rc)
-			return rc;
+		/* print final buffer counts & size details */
+		msm_vidc_print_buffer_info(inst);
+
 		rc = venus_hfi_session_command(inst,
 				HFI_CMD_RESUME,
 				INPUT_PORT,

driver/vidc/src/msm_vidc_buffer.c

@@ -34,15 +34,6 @@ u32 msm_vidc_input_min_count(struct msm_vidc_inst* inst)
 	if (is_thumbnail_session(inst) || is_image_session(inst))
 		input_min_count = 1;
 
-	//if (is_grid_session(inst))
-	//	input_min_count = 2;
-
-	//if (is_hier_b_session(inst)) {
-		//max_layer = get_ctrl(inst,
-		//	V4L2_CID_MPEG_VIDC_VIDEO_HEVC_MAX_HIER_CODING_LAYER);
-		//input_min_count = (1 << (max_layer->val - 1)) + 2;
-	//}
-
 	return input_min_count;
 }
 
@@ -193,8 +184,8 @@ u32 msm_vidc_internal_buffer_count(struct msm_vidc_inst *inst,
 			else
 				count = 0;
 		} else {
-			i_vpr_e(inst, "%s: unsupported buffer type %#x\n",
-				__func__, buffer_type);
+			i_vpr_e(inst, "%s: unsupported buffer type %s\n",
+				__func__, buf_name(buffer_type));
 			count = 0;
 		}
 	}
@@ -317,9 +308,6 @@ u32 msm_vidc_encoder_output_size(struct msm_vidc_inst *inst)
 	 * Initially frame_size = YUVsize * 2;
 	 */
 
-	/* if (is_grid_session(inst)) {
-		f->fmt.pix_mp.width = f->fmt.pix_mp.height = HEIC_GRID_DIMENSION;
-	} */
 	width = ALIGN(f->fmt.pix_mp.width, BUFFER_ALIGNMENT_SIZE(32));
 	height = ALIGN(f->fmt.pix_mp.height, BUFFER_ALIGNMENT_SIZE(32));
 	mbs_per_frame = NUM_MBS_PER_FRAME(width, height);

driver/vidc/src/msm_vidc_control.c

@@ -266,7 +266,7 @@ int msm_vidc_update_cap_value(struct msm_vidc_inst *inst, u32 cap,
 
 	if (inst->capabilities->cap[cap].value != adjusted_val)
 		i_vpr_h(inst,
-			"%s: updated database: name %s, value %#x -> %#x\n",
+			"%s: updated database: name: %s, value: %#x -> %#x\n",
 			func, cap_name(cap),
 			inst->capabilities->cap[cap].value, adjusted_val);
 
@@ -1678,6 +1678,9 @@ int msm_vidc_set_vbr_related_properties(void *instance,
 
 	hfi_value = inst->capabilities->cap[cap_id].value;
 
+	i_vpr_h(inst, "set cap: name: %24s, value: %#10x, hfi: %#10x\n", cap_name(cap_id),
+		inst->capabilities->cap[cap_id].value, hfi_value);
+
 	rc = msm_vidc_packetize_control(inst, cap_id, HFI_PAYLOAD_U32,
 		&hfi_value, sizeof(u32), __func__);
 
@@ -1707,6 +1710,9 @@ int msm_vidc_set_cbr_related_properties(void *instance,
 
 	hfi_value = inst->capabilities->cap[cap_id].value;
 
+	i_vpr_h(inst, "set cap: name: %24s, value: %#10x, hfi: %#10x\n", cap_name(cap_id),
+		inst->capabilities->cap[cap_id].value, hfi_value);
+
 	rc = msm_vidc_packetize_control(inst, cap_id, HFI_PAYLOAD_U32,
 		&hfi_value, sizeof(u32), __func__);
 
@@ -2071,6 +2077,9 @@ int msm_vidc_set_layer_count_and_type(void *instance,
 	/* hfi baselayer starts from 1 */
 	hfi_layer_count = inst->capabilities->cap[ENH_LAYER_COUNT].value + 1;
 
+	i_vpr_h(inst, "set cap: name: %24s, value: %#10x, hfi: %#10x\n", cap_name(cap_id),
+		inst->capabilities->cap[cap_id].value, hfi_layer_count);
+
 	rc = msm_vidc_packetize_control(inst, cap_id, HFI_PAYLOAD_U32,
 		&hfi_layer_count, sizeof(u32), __func__);
 	if (rc)
@@ -2102,6 +2111,8 @@ int msm_vidc_set_gop_size(void *instance,
 	}
 
 	hfi_value = inst->capabilities->cap[GOP_SIZE].value;
+	i_vpr_h(inst, "set cap: name: %24s, value: %#10x, hfi: %#10x\n", cap_name(cap_id),
+		inst->capabilities->cap[cap_id].value, hfi_value);
 
 	rc = msm_vidc_packetize_control(inst, cap_id, HFI_PAYLOAD_U32,
 		&hfi_value, sizeof(u32), __func__);
@@ -2170,6 +2181,10 @@ int msm_vidc_set_bitrate(void *instance,
 
 set_total_bitrate:
 	hfi_value = inst->capabilities->cap[BIT_RATE].value;
+
+	i_vpr_h(inst, "set cap: name: %24s, value: %#10x, hfi: %#10x\n", cap_name(cap_id),
+		inst->capabilities->cap[cap_id].value, hfi_value);
+
 	rc = msm_vidc_packetize_control(inst, BIT_RATE, HFI_PAYLOAD_U32,
 			&hfi_value, sizeof(u32), __func__);
 exit:
@@ -2190,6 +2205,9 @@ int msm_vidc_set_session_priority(void *instance,
 
 	hfi_value = (inst->capabilities->cap[cap_id].value * 2) + inst->priority_level;
 
+	i_vpr_h(inst, "set cap: name: %24s, value: %#10x, hfi: %#10x\n", cap_name(cap_id),
+		inst->capabilities->cap[cap_id].value, hfi_value);
+
 	rc = msm_vidc_packetize_control(inst, cap_id, HFI_PAYLOAD_U32,
 		&hfi_value, sizeof(u32), __func__);
 

driver/vidc/src/msm_vidc_driver.c

@@ -37,11 +37,6 @@ extern struct msm_vidc_core *g_core;
 #define SSR_ADDR_ID 0xFFFFFFFF00000000
 #define SSR_ADDR_SHIFT 32
 
-struct msm_vidc_buf_type_name {
-	enum msm_vidc_buffer_type type;
-	char *name;
-};
-
 struct msm_vidc_cap_name {
 	enum msm_vidc_inst_capability_type cap;
 	char *name;
@@ -202,6 +197,44 @@ exit:
 	return name;
 }
 
+struct msm_vidc_buf_type_name {
+	enum msm_vidc_buffer_type type;
+	char *name;
+};
+
+static const struct msm_vidc_buf_type_name buf_type_name_arr[] = {
+	{MSM_VIDC_BUF_INPUT,             "INPUT"                      },
+	{MSM_VIDC_BUF_OUTPUT,            "OUTPUT"                     },
+	{MSM_VIDC_BUF_INPUT_META,        "INPUT_META"                 },
+	{MSM_VIDC_BUF_OUTPUT_META,       "OUTPUT_META"                },
+	{MSM_VIDC_BUF_READ_ONLY,         "READ_ONLY"                  },
+	{MSM_VIDC_BUF_QUEUE,             "QUEUE"                      },
+	{MSM_VIDC_BUF_BIN,               "BIN"                        },
+	{MSM_VIDC_BUF_ARP,               "ARP"                        },
+	{MSM_VIDC_BUF_COMV,              "COMV"                       },
+	{MSM_VIDC_BUF_NON_COMV,          "NON_COMV"                   },
+	{MSM_VIDC_BUF_LINE,              "LINE"                       },
+	{MSM_VIDC_BUF_DPB,               "DPB"                        },
+	{MSM_VIDC_BUF_PERSIST,           "PERSIST"                    },
+	{MSM_VIDC_BUF_VPSS,              "VPSS"                       },
+};
+
+const char *buf_name(enum msm_vidc_buffer_type type)
+{
+	const char *name = "UNKNOWN BUF";
+
+	if (!type || type > ARRAY_SIZE(buf_type_name_arr))
+		goto exit;
+
+	if (buf_type_name_arr[type - 1].type != type)
+		goto exit;
+
+	name = buf_type_name_arr[type - 1].name;
+
+exit:
+	return name;
+}
+
 struct msm_vidc_inst_state_name {
 	enum msm_vidc_inst_state state;
 	char *name;
@@ -270,22 +303,12 @@ void print_vidc_buffer(u32 tag, const char *tag_str, const char *str, struct msm
 	if (!(tag & msm_vidc_debug) || !inst || !vbuf || !tag_str || !str)
 		return;
 
-	if (vbuf->type == MSM_VIDC_BUF_INPUT || vbuf->type == MSM_VIDC_BUF_OUTPUT) {
-		dprintk_inst(tag, tag_str, inst,
-			"%s: %s: idx %2d fd %3d off %d daddr %#llx size %d filled %d flags %#x ts %lld attr %#x\n",
-			str, vbuf->type == MSM_VIDC_BUF_INPUT ? "INPUT" : "OUTPUT",
-			vbuf->index, vbuf->fd, vbuf->data_offset,
-			vbuf->device_addr, vbuf->buffer_size, vbuf->data_size,
-			vbuf->flags, vbuf->timestamp, vbuf->attr);
-	} else if (vbuf->type == MSM_VIDC_BUF_INPUT_META ||
-			   vbuf->type == MSM_VIDC_BUF_OUTPUT_META) {
-		dprintk_inst(tag, tag_str, inst,
-			"%s: %s: idx %2d fd %3d off %d daddr %#llx size %d filled %d flags %#x ts %lld attr %#x\n",
-			str, vbuf->type == MSM_VIDC_BUF_INPUT_META ? "INPUT_META" : "OUTPUT_META",
-			vbuf->index, vbuf->fd, vbuf->data_offset,
-			vbuf->device_addr, vbuf->buffer_size, vbuf->data_size,
-			vbuf->flags, vbuf->timestamp, vbuf->attr);
-	}
+	dprintk_inst(tag, tag_str, inst,
+		"%s: %s: idx %2d fd %3d off %d daddr %#llx size %d filled %d flags %#x ts %lld attr %#x\n",
+		str, buf_name(vbuf->type),
+		vbuf->index, vbuf->fd, vbuf->data_offset,
+		vbuf->device_addr, vbuf->buffer_size, vbuf->data_size,
+		vbuf->flags, vbuf->timestamp, vbuf->attr);
 }
 
 void print_vb2_buffer(const char *str, struct msm_vidc_inst *inst,
@@ -899,6 +922,8 @@ struct msm_vidc_buffers *msm_vidc_get_buffers(
 		return &inst->buffers.persist;
 	case MSM_VIDC_BUF_VPSS:
 		return &inst->buffers.vpss;
+	case MSM_VIDC_BUF_QUEUE:
+		return NULL;
 	default:
 		i_vpr_e(inst, "%s: invalid driver buffer type %d\n",
 			func, buffer_type);
@@ -2103,6 +2128,12 @@ void msm_vidc_allow_dcvs(struct msm_vidc_inst *inst)
 		goto exit;
 	}
 
+	allow = is_realtime_session(inst);
+	if (!allow) {
+		i_vpr_h(inst, "%s: non-realtime session\n", __func__);
+		goto exit;
+	}
+
 	allow = !is_image_session(inst);
 	if (!allow) {
 		i_vpr_h(inst, "%s: image session\n", __func__);
@@ -2327,7 +2358,7 @@ int msm_vidc_queue_buffer_single(struct msm_vidc_inst *inst, struct vb2_buffer *
 		if (is_encode_session(inst)) {
 			cr = inst->capabilities->cap[ENC_IP_CR].value;
 			msm_vidc_update_input_cr(inst, vb2->index, cr);
-			inst->capabilities->cap[ENC_IP_CR].value = 0;
+			msm_vidc_update_cap_value(inst, ENC_IP_CR, 0, __func__);
 		}
 		inst->power.buffer_counter++;
 	}
@@ -2357,15 +2388,13 @@ int msm_vidc_destroy_internal_buffer(struct msm_vidc_inst *inst,
 	}
 
 	if (!is_internal_buffer(buffer->type)) {
-		i_vpr_e(inst, "%s: buffer type %#x is not internal\n",
-			__func__, buffer->type);
+		i_vpr_e(inst, "%s: type: %s is not internal\n",
+			__func__, buf_name(buffer->type));
 		return 0;
 	}
 
-	i_vpr_h(inst,
-		"%s: destroy buffer_type %#x, size %d device_addr %#x\n",
-		__func__, buffer->type, buffer->buffer_size,
-		buffer->device_addr);
+	i_vpr_h(inst, "%s: destroy: type: %8s, size: %9u, device_addr %#x\n", __func__,
+		buf_name(buffer->type), buffer->buffer_size, buffer->device_addr);
 
 	buffers = msm_vidc_get_buffers(inst, buffer->type, __func__);
 	if (!buffers)
@@ -2460,8 +2489,8 @@ int msm_vidc_create_internal_buffer(struct msm_vidc_inst *inst,
 		return -EINVAL;
 	}
 	if (!is_internal_buffer(buffer_type)) {
-		i_vpr_e(inst, "%s: buffer type %#x is not internal\n",
-			__func__, buffer_type);
+		i_vpr_e(inst, "%s: type %s is not internal\n",
+			__func__, buf_name(buffer_type));
 		return 0;
 	}
 
@@ -2522,10 +2551,8 @@ int msm_vidc_create_internal_buffer(struct msm_vidc_inst *inst,
 
 	buffer->dmabuf = alloc->dmabuf;
 	buffer->device_addr = map->device_addr;
-	i_vpr_h(inst,
-		"%s: created buffer_type %#x, size %d device_addr %#x\n",
-		__func__, buffer_type, buffers->size,
-		buffer->device_addr);
+	i_vpr_h(inst, "%s: create: type: %8s, size: %9u, device_addr %#x\n", __func__,
+		buf_name(buffer_type), buffers->size, buffer->device_addr);
 
 	return 0;
 }
@@ -2547,8 +2574,7 @@ int msm_vidc_create_internal_buffers(struct msm_vidc_inst *inst,
 		return -EINVAL;
 
 	if (buffers->reuse) {
-		i_vpr_l(inst, "%s: reuse enabled for buffer type %#x\n",
-			__func__, buffer_type);
+		i_vpr_l(inst, "%s: reuse enabled for %s\n", __func__, buf_name(buffer_type));
 		return 0;
 	}
 
@@ -2573,8 +2599,7 @@ int msm_vidc_queue_internal_buffers(struct msm_vidc_inst *inst,
 		return -EINVAL;
 	}
 	if (!is_internal_buffer(buffer_type)) {
-		i_vpr_e(inst, "%s: buffer type %#x is not internal\n",
-			__func__, buffer_type);
+		i_vpr_e(inst, "%s: %s is not internal\n", __func__, buf_name(buffer_type));
 		return 0;
 	}
 
@@ -2583,8 +2608,8 @@ int msm_vidc_queue_internal_buffers(struct msm_vidc_inst *inst,
 		return -EINVAL;
 
 	if (buffers->reuse) {
-		i_vpr_l(inst, "%s: reuse enabled for buffer type %#x\n",
-			__func__, buffer_type);
+		i_vpr_l(inst, "%s: reuse enabled for %s buf\n",
+			__func__, buf_name(buffer_type));
 		return 0;
 	}
 
@@ -2601,8 +2626,8 @@ int msm_vidc_queue_internal_buffers(struct msm_vidc_inst *inst,
 		/* mark queued */
 		buffer->attr |= MSM_VIDC_ATTR_QUEUED;
 
-		i_vpr_h(inst, "%s: queued buffer_type %#x, size %d\n",
-			__func__, buffer_type, buffers->size);
+		i_vpr_h(inst, "%s: queue: type: %8s, size: %9u, device_addr %#x\n", __func__,
+			buf_name(buffer->type), buffer->buffer_size, buffer->device_addr);
 	}
 
 	return 0;
@@ -2620,8 +2645,8 @@ int msm_vidc_alloc_and_queue_session_internal_buffers(struct msm_vidc_inst *inst
 
 	if (buffer_type != MSM_VIDC_BUF_ARP &&
 		buffer_type != MSM_VIDC_BUF_PERSIST) {
-		i_vpr_e(inst, "%s: invalid buffer type: %d\n",
-			__func__, buffer_type);
+		i_vpr_e(inst, "%s: invalid buffer type: %s\n",
+			__func__, buf_name(buffer_type));
 		rc = -EINVAL;
 		goto exit;
 	}
@@ -2654,8 +2679,8 @@ int msm_vidc_release_internal_buffers(struct msm_vidc_inst *inst,
 		return -EINVAL;
 	}
 	if (!is_internal_buffer(buffer_type)) {
-		i_vpr_e(inst, "%s: buffer type %#x is not internal\n",
-			__func__, buffer_type);
+		i_vpr_e(inst, "%s: %s is not internal\n",
+			__func__, buf_name(buffer_type));
 		return 0;
 	}
 
@@ -2664,8 +2689,8 @@ int msm_vidc_release_internal_buffers(struct msm_vidc_inst *inst,
 		return -EINVAL;
 
 	if (buffers->reuse) {
-		i_vpr_l(inst, "%s: reuse enabled for buffer type %#x\n",
-			__func__, buffer_type);
+		i_vpr_l(inst, "%s: reuse enabled for %s buf\n",
+			__func__, buf_name(buffer_type));
 		return 0;
 	}
 
@@ -2682,8 +2707,8 @@ int msm_vidc_release_internal_buffers(struct msm_vidc_inst *inst,
 		/* mark pending release */
 		buffer->attr |= MSM_VIDC_ATTR_PENDING_RELEASE;
 
-		i_vpr_h(inst, "%s: released buffer_type %#x, size %d\n",
-			__func__, buffer_type, buffers->size);
+		i_vpr_h(inst, "%s: release: type: %8s, size: %9u, device_addr %#x\n", __func__,
+			buf_name(buffer->type), buffer->buffer_size, buffer->device_addr);
 	}
 
 	return 0;
@@ -3461,6 +3486,31 @@ int msm_vidc_core_timeout(struct msm_vidc_core *core)
 	return msm_vidc_core_deinit(core, true);
 }
 
+int msm_vidc_print_buffer_info(struct msm_vidc_inst *inst)
+{
+	struct msm_vidc_buffers *buffers;
+	int i;
+
+	if (!inst) {
+		i_vpr_e(inst, "%s: invalid params\n", __func__);
+		return -EINVAL;
+	}
+
+	/* Print buffer details */
+	for (i = 0; i < ARRAY_SIZE(buf_type_name_arr); i++) {
+		buffers = msm_vidc_get_buffers(inst, buf_type_name_arr[i].type, __func__);
+		if (!buffers)
+			continue;
+
+		i_vpr_h(inst, "buf: type: %11s, count %2d, extra %2d, actual %2d, size %9u\n",
+			buf_type_name_arr[i].name, buffers->min_count,
+			buffers->extra_count, buffers->actual_count,
+			buffers->size);
+	}
+
+	return 0;
+}
+
 int msm_vidc_print_inst_info(struct msm_vidc_inst *inst)
 {
 	struct msm_vidc_buffers *buffers;
@@ -3471,20 +3521,6 @@ int msm_vidc_print_inst_info(struct msm_vidc_inst *inst)
 	struct dma_buf *dbuf;
 	int i = 0;
 
-	static const struct msm_vidc_buf_type_name buf_type_name[] = {
-		{MSM_VIDC_BUF_INPUT,             "INPUT"      },
-		{MSM_VIDC_BUF_OUTPUT,            "OUTPUT"     },
-		{MSM_VIDC_BUF_INPUT_META,        "IN_META"    },
-		{MSM_VIDC_BUF_OUTPUT_META,       "OUT_META"   },
-		{MSM_VIDC_BUF_BIN,               "BIN"        },
-		{MSM_VIDC_BUF_ARP,               "ARP"        },
-		{MSM_VIDC_BUF_COMV,              "COMV"       },
-		{MSM_VIDC_BUF_NON_COMV,          "NON_COMV"   },
-		{MSM_VIDC_BUF_LINE,              "LINE"       },
-		{MSM_VIDC_BUF_PERSIST,           "PERSIST"    },
-		{MSM_VIDC_BUF_VPSS,              "VPSS"       },
-	};
-
 	if (!inst || !inst->capabilities) {
 		i_vpr_e(inst, "%s: invalid params\n", __func__);
 		return -EINVAL;
@@ -3506,13 +3542,13 @@ int msm_vidc_print_inst_info(struct msm_vidc_inst *inst)
 		frame_rate, bit_rate, bit_depth);
 
 	/* Print buffer details */
-	for (i = 0; i < ARRAY_SIZE(buf_type_name); i++) {
-		buffers = msm_vidc_get_buffers(inst, buf_type_name[i].type, __func__);
+	for (i = 0; i < ARRAY_SIZE(buf_type_name_arr); i++) {
+		buffers = msm_vidc_get_buffers(inst, buf_type_name_arr[i].type, __func__);
 		if (!buffers)
 			continue;
 
-		i_vpr_e(inst, "count: type: %8s, min: %2d, extra: %2d, actual: %2d\n",
-			buf_type_name[i].name, buffers->min_count,
+		i_vpr_e(inst, "count: type: %11s, min: %2d, extra: %2d, actual: %2d\n",
+			buf_type_name_arr[i].name, buffers->min_count,
 			buffers->extra_count, buffers->actual_count);
 
 		list_for_each_entry(buf, &buffers->list, list) {
@@ -3520,8 +3556,8 @@ int msm_vidc_print_inst_info(struct msm_vidc_inst *inst)
 				continue;
 			dbuf = (struct dma_buf *)buf->dmabuf;
 			i_vpr_e(inst,
-				"buf: type: %8s, index: %2d, fd: %4d, size: %9u, off: %8u, filled: %9u, iova: %8x, inode: %9ld, flags: %8x, ts: %16lld, attr: %8x\n",
-				buf_type_name[i].name, buf->index, buf->fd, buf->buffer_size,
+				"buf: type: %11s, index: %2d, fd: %4d, size: %9u, off: %8u, filled: %9u, iova: %8x, inode: %9ld, flags: %8x, ts: %16lld, attr: %8x\n",
+				buf_type_name_arr[i].name, buf->index, buf->fd, buf->buffer_size,
 				buf->data_offset, buf->data_size, buf->device_addr,
 				file_inode(dbuf->file)->i_ino,
 				buf->flags, buf->timestamp, buf->attr);

driver/vidc/src/msm_vidc_memory.c

@@ -13,6 +13,7 @@
 #include "msm_vidc_memory.h"
 #include "msm_vidc_debug.h"
 #include "msm_vidc_internal.h"
+#include "msm_vidc_driver.h"
 #include "msm_vidc_dt.h"
 #include "msm_vidc_core.h"
 
@@ -153,8 +154,8 @@ int msm_vidc_memory_map(struct msm_vidc_core *core, struct msm_vidc_map *map)
 	map->refcount++;
 
 	d_vpr_l(
-		"%s: type %d device_addr %#x refcount %d region %d\n",
-		__func__, map->type, map->device_addr, map->refcount, map->region);
+		"%s: type %11s, device_addr %#x, refcount %d, region %d\n",
+		__func__, buf_name(map->type), map->device_addr, map->refcount, map->region);
 
 	return 0;
 
@@ -188,8 +189,8 @@ int msm_vidc_memory_unmap(struct msm_vidc_core *core,
 		goto exit;
 
 	d_vpr_l(
-		"%s: type %d device_addr %#x refcount %d region %d\n",
-		__func__, map->type, map->device_addr, map->refcount, map->region);
+		"%s: type %11s, device_addr %#x, refcount %d, region %d\n",
+		__func__, buf_name(map->type), map->device_addr, map->refcount, map->region);
 
 	dma_buf_unmap_attachment(map->attach, map->table, DMA_BIDIRECTIONAL);
 	dma_buf_detach(map->dmabuf, map->attach);
@@ -281,8 +282,8 @@ int msm_vidc_memory_alloc(struct msm_vidc_core *core, struct msm_vidc_alloc *mem
 	}
 
 	d_vpr_h(
-		"%s: dmabuf = %pK, size = %d, kvaddr = %pK, buffer_type = %#x secure %d region %d\n",
-		__func__, mem->dmabuf, mem->size, mem->kvaddr, mem->type,
+		"%s: dmabuf %pK, size %d, kvaddr %pK, buffer_type %s, secure %d, region %d\n",
+		__func__, mem->dmabuf, mem->size, mem->kvaddr, buf_name(mem->type),
 		mem->secure, mem->region);
 	return 0;
 
@@ -301,8 +302,9 @@ int msm_vidc_memory_free(struct msm_vidc_core *core, struct msm_vidc_alloc *mem)
 	}
 
 	d_vpr_h(
-		"%s: dmabuf = %pK, size = %d, kvaddr = %pK, buffer_type = %#x\n",
-		__func__, mem->dmabuf, mem->size, mem->kvaddr, mem->type);
+		"%s: dmabuf %pK, size %d, kvaddr %pK, buffer_type %s, secure %d, region %d\n",
+		__func__, mem->dmabuf, mem->size, mem->kvaddr, buf_name(mem->type),
+		mem->secure, mem->region);
 
 	if (mem->kvaddr) {
 		dma_buf_vunmap(mem->dmabuf, mem->kvaddr);

driver/vidc/src/msm_vidc_power.c

@@ -162,10 +162,6 @@ static int msm_vidc_set_buses(struct msm_vidc_inst* inst)
 	mutex_lock(&core->lock);
 	curr_time_ns = ktime_get_ns();
 	list_for_each_entry(temp, &core->instances, list) {
-		/* skip no input data sessions */
-		if (!temp->max_input_data_size)
-			continue;
-
 		/* skip inactive session bus bandwidth */
 		if (!is_active_session(temp->last_qbuf_time_ns, curr_time_ns)) {
 			temp->active = false;
@@ -201,8 +197,6 @@ int msm_vidc_scale_buses(struct msm_vidc_inst *inst)
 	struct vidc_bus_vote_data *vote_data;
 	struct v4l2_format *out_f;
 	struct v4l2_format *inp_f;
-	struct msm_vidc_buffer *vbuf;
-	u32 data_size = 0;
 	int codec = 0, frame_rate;
 
 	if (!inst || !inst->core || !inst->capabilities) {
@@ -216,12 +210,6 @@ int msm_vidc_scale_buses(struct msm_vidc_inst *inst)
 	}
 	vote_data = &inst->bus_data;
 
-	list_for_each_entry(vbuf, &inst->buffers.input.list, list)
-		data_size = max(data_size, vbuf->data_size);
-	inst->max_input_data_size = data_size;
-	if (!data_size)
-		return 0;
-
 	vote_data->power_mode = VIDC_POWER_NORMAL;
 	if (inst->power.buffer_counter < DCVS_WINDOW || is_image_session(inst))
 		vote_data->power_mode = VIDC_POWER_TURBO;
@@ -275,7 +263,7 @@ int msm_vidc_scale_buses(struct msm_vidc_inst *inst)
 		u32 color_format;
 
 		vote_data->domain = MSM_VIDC_DECODER;
-		vote_data->bitrate = data_size * vote_data->fps * 8;
+		vote_data->bitrate = inst->max_input_data_size * vote_data->fps * 8;
 		color_format = v4l2_colorformat_to_driver(
 			inst->fmts[OUTPUT_PORT].fmt.pix_mp.pixelformat, __func__);
 		if (is_linear_colorformat(color_format)) {
@@ -342,10 +330,6 @@ int msm_vidc_set_clocks(struct msm_vidc_inst* inst)
 	freq = 0;
 	curr_time_ns = ktime_get_ns();
 	list_for_each_entry(temp, &core->instances, list) {
-		/* skip no input data sessions */
-		if (!temp->max_input_data_size)
-			continue;
-
 		/* skip inactive session clock rate */
 		if (!is_active_session(temp->last_qbuf_time_ns, curr_time_ns)) {
 			temp->active = false;
@@ -398,7 +382,7 @@ int msm_vidc_set_clocks(struct msm_vidc_inst* inst)
 	 * TODO: Remove this scaling if using source clock instead of branch clock.
 	 */
 	rate = rate * MSM_VIDC_CLOCK_SOURCE_SCALING_RATIO;
-	i_vpr_h(inst, "%s: scaled clock rate %lu\n", __func__, rate);
+	i_vpr_l(inst, "%s: scaled clock rate %lu\n", __func__, rate);
 
 	rc = venus_hfi_scale_clocks(inst, rate);
 	if (rc)
@@ -487,8 +471,6 @@ exit:
 int msm_vidc_scale_clocks(struct msm_vidc_inst *inst)
 {
 	struct msm_vidc_core* core;
-	struct msm_vidc_buffer *vbuf;
-	u32 data_size = 0;
 
 	if (!inst || !inst->core) {
 		d_vpr_e("%s: invalid params\n", __func__);
@@ -496,12 +478,6 @@ int msm_vidc_scale_clocks(struct msm_vidc_inst *inst)
 	}
 	core = inst->core;
 
-	list_for_each_entry(vbuf, &inst->buffers.input.list, list)
-		data_size = max(data_size, vbuf->data_size);
-	inst->max_input_data_size = data_size;
-	if (!data_size)
-		return 0;
-
 	if (inst->power.buffer_counter < DCVS_WINDOW || is_image_session(inst)) {
 		inst->power.min_freq = msm_vidc_max_freq(inst);
 		inst->power.dcvs_flags = 0;
@@ -510,7 +486,7 @@ int msm_vidc_scale_clocks(struct msm_vidc_inst *inst)
 		inst->power.dcvs_flags = 0;
 	} else {
 		inst->power.min_freq =
-			call_session_op(core, calc_freq, inst, data_size);
+			call_session_op(core, calc_freq, inst, inst->max_input_data_size);
 		msm_vidc_apply_dcvs(inst);
 	}
 	inst->power.curr_freq = inst->power.min_freq;
@@ -522,6 +498,8 @@ int msm_vidc_scale_clocks(struct msm_vidc_inst *inst)
 int msm_vidc_scale_power(struct msm_vidc_inst *inst, bool scale_buses)
 {
 	struct msm_vidc_core *core;
+	struct msm_vidc_buffer *vbuf;
+	u32 data_size = 0;
 
 	if (!inst || !inst->core) {
 		d_vpr_e("%s: invalid params %pK\n", __func__, inst);
@@ -535,6 +513,14 @@ int msm_vidc_scale_power(struct msm_vidc_inst *inst, bool scale_buses)
 		inst->active = true;
 	}
 
+	list_for_each_entry(vbuf, &inst->buffers.input.list, list)
+		data_size = max(data_size, vbuf->data_size);
+	inst->max_input_data_size = data_size;
+
+	/* no pending inputs - skip scale power */
+	if (!inst->max_input_data_size)
+		return 0;
+
 	if (msm_vidc_scale_clocks(inst))
 		i_vpr_e(inst, "failed to scale clock\n");
 

driver/vidc/src/msm_vidc_vb2.c

@@ -184,10 +184,6 @@ int msm_vidc_start_streaming(struct vb2_queue *q, unsigned int count)
 				MSM_VIDC_BUF_ARP);
 			if (rc)
 				goto error;
-			i_vpr_h(inst, "session internal buffer: min     size\n");
-			i_vpr_h(inst, "arp  buffer: %d      %d\n",
-				inst->buffers.arp.min_count,
-				inst->buffers.arp.size);
 		} else if(is_decode_session(inst)) {
 			rc = msm_vidc_session_set_default_header(inst);
 			if (rc)
@@ -197,11 +193,6 @@ int msm_vidc_start_streaming(struct vb2_queue *q, unsigned int count)
 				MSM_VIDC_BUF_PERSIST);
 			if (rc)
 				goto error;
-			i_vpr_h(inst, "session internal buffer: min     size     reuse\n");
-			i_vpr_h(inst, "persist  buffer: %d      %d      %d\n",
-				inst->buffers.persist.min_count,
-				inst->buffers.persist.size,
-				inst->buffers.persist.reuse);
 		}
 	}
 
@@ -229,8 +220,13 @@ int msm_vidc_start_streaming(struct vb2_queue *q, unsigned int count)
 		i_vpr_e(inst, "%s: invalid type %d\n", q->type);
 		goto error;
 	}
-	if (!rc)
-		i_vpr_h(inst, "Streamon: %d successful\n", q->type);
+	if (rc)
+		goto error;
+
+	/* print final buffer counts & size details */
+	msm_vidc_print_buffer_info(inst);
+
+	i_vpr_h(inst, "Streamon: %d successful\n", q->type);
 
 	return rc;
 

driver/vidc/src/venus_hfi.c

@@ -3438,8 +3438,8 @@ int venus_hfi_release_buffer(struct msm_vidc_inst *inst,
 	}
 
 	if (!is_internal_buffer(buffer->type)) {
-		i_vpr_e(inst, "release not allowed for buffer type %d\n",
-			buffer->type);
+		i_vpr_e(inst, "release not allowed for buffer_type %s\n",
+			buf_name(buffer->type));
 		goto unlock;
 	}
 	core = inst->core;

driver/vidc/src/venus_hfi_response.c

@@ -584,6 +584,7 @@ static int handle_input_buffer(struct msm_vidc_inst *inst,
 			return 0;
 		}
 	}
+
 	buf->data_offset = buffer->data_offset;
 	buf->data_size = buffer->data_size;
 	buf->attr &= ~MSM_VIDC_ATTR_QUEUED;
@@ -1274,7 +1275,7 @@ static int handle_session_property(struct msm_vidc_inst *inst,
 	u32 port;
 	u32 *payload_ptr;
 
-	i_vpr_h(inst, "%s: property type %#x\n", __func__, pkt->type);
+	i_vpr_l(inst, "%s: property type %#x\n", __func__, pkt->type);
 
 	port = vidc_port_from_hfi(inst, pkt->port);
 	if (port >= MAX_PORT) {