Quellcode durchsuchen

Merge "video: driver: fix length of line exceeding max length warning"

qctecmdr vor 1 Jahr
Ursprung
Commit
c43d43d95e

+ 4 - 1
driver/platform/kalama/inc/kalama_technology.h

@@ -76,7 +76,10 @@ static u32 bitrate_table_kalama_2stage_fp[5][10] = {
 	{130, 130, 120, 120, 120, 120, 120, 120, 120, 120},
 };
 
-/* HW limit bitrate table (these values are measured end to end fw/sw impacts are also considered) */
+/*
+ * HW limit bitrate table (these values are measured
+ * end to end fw/sw impacts are also considered)
+ */
 static u32 bitrate_table_kalama_1stage_fp[5][10] = { /* 1-stage assume IPPP */
 	/* h264 cavlc */
 	{0, 220, 220, 220, 220, 220, 220, 220, 220, 220},

+ 5 - 5
driver/platform/pineapple/src/msm_vidc_pineapple.c

@@ -2725,11 +2725,11 @@ static const struct subcache_table pineapple_subcache_table[] = {
 
 /* name, start, size, secure, dma_coherant, region, dma_mask */
 const struct context_bank_table pineapple_context_bank_table[] = {
-	{"qcom,vidc,cb-ns",             0x25800000, 0xba800000, 0, 1, MSM_VIDC_NON_SECURE,       0 },
-	{"qcom,vidc,cb-ns-pxl",         0x00100000, 0xdff00000, 0, 1, MSM_VIDC_NON_SECURE_PIXEL, 0 },
-	{"qcom,vidc,cb-sec-pxl",        0x00500000, 0xdfb00000, 1, 0, MSM_VIDC_SECURE_PIXEL,     0 },
-	{"qcom,vidc,cb-sec-non-pxl",    0x01000000, 0x24800000, 1, 0, MSM_VIDC_SECURE_NONPIXEL,  0 },
-	{"qcom,vidc,cb-sec-bitstream",  0x00500000, 0xdfb00000, 1, 0, MSM_VIDC_SECURE_BITSTREAM, 0 },
+	{"qcom,vidc,cb-ns", 0x25800000, 0xba800000, 0, 1, MSM_VIDC_NON_SECURE, 0},
+	{"qcom,vidc,cb-ns-pxl", 0x00100000, 0xdff00000, 0, 1, MSM_VIDC_NON_SECURE_PIXEL, 0},
+	{"qcom,vidc,cb-sec-pxl", 0x00500000, 0xdfb00000, 1, 0, MSM_VIDC_SECURE_PIXEL, 0},
+	{"qcom,vidc,cb-sec-non-pxl", 0x01000000, 0x24800000, 1, 0, MSM_VIDC_SECURE_NONPIXEL, 0},
+	{"qcom,vidc,cb-sec-bitstream", 0x00500000, 0xdfb00000, 1, 0, MSM_VIDC_SECURE_BITSTREAM, 0},
 };
 
 /* freq */

+ 6 - 3
driver/variant/iris3/inc/hfi_buffer_iris3.h

@@ -1203,14 +1203,17 @@ _yuv_bufcount_min, is_opb, num_vpp_pipes)           \
 			frame_width_coded, codec_standard); \
 		mbs_in_one_tile = (tile_size * frame_height_coded) / (lcu_size * lcu_size); \
 		slice_count_per_tile = \
-			(mbs_in_one_tile + multi_slice_max_mb_count - 1) / (multi_slice_max_mb_count); \
+			(mbs_in_one_tile + multi_slice_max_mb_count - 1) / \
+			(multi_slice_max_mb_count); \
 		if (last_tile_size) { \
 			mbs_in_last_tile = \
 				(last_tile_size * frame_height_coded) / (lcu_size * lcu_size); \
 			slice_count_in_last_tile = \
-				(mbs_in_last_tile + multi_slice_max_mb_count - 1) / (multi_slice_max_mb_count); \
+				(mbs_in_last_tile + multi_slice_max_mb_count - 1) / \
+				(multi_slice_max_mb_count); \
 			total_slice_count = \
-				(slice_count_per_tile * (tile_count - 1)) + slice_count_in_last_tile; \
+				(slice_count_per_tile * (tile_count - 1)) + \
+				slice_count_in_last_tile; \
 		} else { \
 			total_slice_count = (slice_count_per_tile * tile_count); \
 		} \

+ 16 - 10
driver/variant/iris3/src/msm_vidc_bus_iris3.c

@@ -97,14 +97,18 @@ u32 get_compression_factors(struct compression_factors *compression_factor,
 		 */
 		if (frame_width < 3840) {
 			compression_factor->ipb_cr =
-				ipblossless_ubwc30_cr_table_cratio_kalama[cr_index_entry][cr_index_uni];
+				ipblossless_ubwc30_cr_table_cratio_kalama[cr_index_entry]
+					[cr_index_uni];
 			compression_factor->ipb_cr_y =
-				ipblossless_ubwc30_cr_table_cratio_kalama[cr_index_entry][cr_index_y];
+				ipblossless_ubwc30_cr_table_cratio_kalama[cr_index_entry]
+					[cr_index_y];
 		} else {
 			compression_factor->ipb_cr =
-				ipblossy_ubwc30_cr_table_cratio_kalama[cr_index_entry][cr_index_uni];
+				ipblossy_ubwc30_cr_table_cratio_kalama[cr_index_entry]
+					[cr_index_uni];
 			compression_factor->ipb_cr_y =
-				ipblossy_ubwc30_cr_table_cratio_kalama[cr_index_entry][cr_index_y];
+				ipblossy_ubwc30_cr_table_cratio_kalama[cr_index_entry]
+					[cr_index_y];
 		}
 
 		compression_factor->dpb_cf_y =
@@ -764,12 +768,13 @@ static int calculate_bandwidth_encoder_iris3(
 	/*
 	 * Summary:
 	 * by default (for both HFR and HSR cases) :
-	 * 	-Any resolution and fps >= 120, enable layering.
+	 *      -Any resolution and fps >= 120, enable layering.
 	 * (120 -> 3, 240 -> 4, 480 -> 5)
-	 * 	- (once we enable layering) : 50 per cent frames are Non - reference
+	 *      - (once we enable layering) : 50 per cent frames are Non - reference
 	 *  frames.recon write is disable by Venus firmware
 	 * 	- Customer has ability to enable / disable layering.
-	 *  Hence, recon write savings would not be there if customer explicitly disables layer encoding.
+	 *  Hence, recon write savings would not be there if
+	 *  customer explicitly disables layer encoding.
 	 */
 
 	/*HFR Cases use alternating rec write if not PWC*/
@@ -822,8 +827,8 @@ static int calculate_bandwidth_encoder_iris3(
 			codec_output->ipb_rd_total_noc = large_bw_calculation_fp;
 			if (codec_input.linear_ipb == 0) {
 				codec_output->ipb_rd_total_noc =
-					(large_bw_calculation_fp * 100 + ipb_compression_factor - 1) /
-					ipb_compression_factor;
+					(large_bw_calculation_fp * 100 +
+					ipb_compression_factor - 1) / ipb_compression_factor;
 			}
 		} else { /* rgb */
 			large_bw_calculation_fp = frame420_y_bw_linear_8bpp;
@@ -832,7 +837,8 @@ static int calculate_bandwidth_encoder_iris3(
 				if (codec_input.complexity_setting == 0) /* pwc */
 					codec_output->ipb_rd_total_noc =
 						(large_bw_calculation_fp * 100 +
-						en_original_compression_factor_rgba_pwd_kalama - 1) /
+						en_original_compression_factor_rgba_pwd_kalama
+						- 1) /
 						en_original_compression_factor_rgba_pwd_kalama;
 				else
 					codec_output->ipb_rd_total_noc =

+ 12 - 6
driver/variant/iris3/src/msm_vidc_clock_iris3.c

@@ -211,7 +211,8 @@ static int calculate_vsp_min_freq(struct api_calculation_input codec_input,
 		 *
 		 *  8KUHD60fps with B frame
 		 *     - bitrate_entry = 0
-		 *     - Clock=NOMINAL for H264 & 2Stage H265. Because bitrate table entry for TURBO is 0.
+		 *     - Clock=NOMINAL for H264 & 2Stage H265. Because bitrate
+		 *       table entry for TURBO is 0.
 		 *
 		 *  TODO : Reduce these conditions by removing the zero entries from Bitrate table.
 		 */
@@ -234,10 +235,12 @@ static int calculate_vsp_min_freq(struct api_calculation_input codec_input,
 			|| (codec_input.codec == CODEC_AV1)) {
 			if (codec_input.vsp_vpp_mode == CODEC_VSPVPP_MODE_2S) {
 				vsp_hw_min_frequency = DIV_ROUND_UP(vsp_hw_min_frequency,
-					(bitrate_table_kalama_2stage_fp[codec][0] * fw_sw_vsp_offset));
+					(bitrate_table_kalama_2stage_fp[codec][0] *
+					fw_sw_vsp_offset));
 			} else {
 				vsp_hw_min_frequency = DIV_ROUND_UP(vsp_hw_min_frequency,
-					(bitrate_table_kalama_1stage_fp[codec][0] * fw_sw_vsp_offset));
+					(bitrate_table_kalama_1stage_fp[codec][0] *
+					fw_sw_vsp_offset));
 			}
 		}
 	} else {
@@ -290,7 +293,8 @@ static u32 calculate_pipe_penalty(struct api_calculation_input codec_input)
 					pipe_penalty_kalama[avid_commercial_content + 1][1]) / 2;
 			else if ((pixel_count == 3840 * 2160) ||
 				(pixel_count == 4096 * 2160) || (pixel_count == 4096 * 2304))
-				pipe_penalty_codec = pipe_penalty_kalama[avid_commercial_content + 1][1];
+				pipe_penalty_codec =
+					pipe_penalty_kalama[avid_commercial_content + 1][1];
 			else if (pixel_count < 7680 * 4320)
 				pipe_penalty_codec =
 					(pipe_penalty_kalama[avid_commercial_content + 1][1] +
@@ -360,7 +364,8 @@ static int calculate_vpp_min_freq(struct api_calculation_input codec_input,
 				1050 : decoder_vpp_fw_overhead;
 
 			/* VPP HW + FW */
-			if (codec_input.linear_opb == 1 && codec_input.bitdepth == CODEC_BITDEPTH_10)
+			if (codec_input.linear_opb == 1 &&
+			    codec_input.bitdepth == CODEC_BITDEPTH_10)
 				/* multiply by 1.20 for 10b case */
 				decoder_vpp_fw_overhead = 1200 + decoder_vpp_fw_overhead - 1000;
 
@@ -375,7 +380,8 @@ static int calculate_vpp_min_freq(struct api_calculation_input codec_input,
 				vpp_hw_min_frequency : vsp_hw_min_frequency;
 		} else {
 			/* 1-stage need SW cycles + FW cycles + HW time */
-			if (codec_input.linear_opb == 1 && codec_input.bitdepth == CODEC_BITDEPTH_10)
+			if (codec_input.linear_opb == 1 &&
+			    codec_input.bitdepth == CODEC_BITDEPTH_10)
 				/* multiply by 1.20 for 10b linear case */
 				vpp_hw_min_frequency =
 					(vpp_hw_min_frequency * 1200 + 999) / 1000;

+ 6 - 3
driver/variant/iris33/inc/hfi_buffer_iris33.h

@@ -1203,14 +1203,17 @@ _yuv_bufcount_min, is_opb, num_vpp_pipes)           \
 			frame_width_coded, codec_standard); \
 		mbs_in_one_tile = (tile_size * frame_height_coded) / (lcu_size * lcu_size); \
 		slice_count_per_tile = \
-			(mbs_in_one_tile + multi_slice_max_mb_count - 1) / (multi_slice_max_mb_count); \
+			(mbs_in_one_tile + multi_slice_max_mb_count - 1) / \
+			(multi_slice_max_mb_count); \
 		if (last_tile_size) { \
 			mbs_in_last_tile = \
 				(last_tile_size * frame_height_coded) / (lcu_size * lcu_size); \
 			slice_count_in_last_tile = \
-				(mbs_in_last_tile + multi_slice_max_mb_count - 1) / (multi_slice_max_mb_count); \
+				(mbs_in_last_tile + multi_slice_max_mb_count - 1) / \
+				(multi_slice_max_mb_count); \
 			total_slice_count = \
-				(slice_count_per_tile * (tile_count - 1)) + slice_count_in_last_tile; \
+				(slice_count_per_tile * (tile_count - 1)) + \
+				slice_count_in_last_tile; \
 		} else { \
 			total_slice_count = (slice_count_per_tile * tile_count); \
 		} \

+ 17 - 10
driver/variant/iris33/src/msm_vidc_bus_iris33.c

@@ -177,14 +177,18 @@ u32 get_compression_factors(struct compression_factors *compression_factor,
 		 */
 		if (frame_width < 3840) {
 			compression_factor->ipb_cr =
-				ipblossless_ubwc30_cr_table_cratio_iris33[cr_index_entry][cr_index_uni];
+				ipblossless_ubwc30_cr_table_cratio_iris33[cr_index_entry]
+					[cr_index_uni];
 			compression_factor->ipb_cr_y =
-				ipblossless_ubwc30_cr_table_cratio_iris33[cr_index_entry][cr_index_y];
+				ipblossless_ubwc30_cr_table_cratio_iris33[cr_index_entry]
+					[cr_index_y];
 		} else {
 			compression_factor->ipb_cr =
-				ipblossy_ubwc30_cr_table_cratio_iris33[cr_index_entry][cr_index_uni];
+				ipblossy_ubwc30_cr_table_cratio_iris33[cr_index_entry]
+					[cr_index_uni];
 			compression_factor->ipb_cr_y =
-				ipblossy_ubwc30_cr_table_cratio_iris33[cr_index_entry][cr_index_y];
+				ipblossy_ubwc30_cr_table_cratio_iris33[cr_index_entry]
+					[cr_index_y];
 		}
 
 		compression_factor->dpb_cf_y =
@@ -854,12 +858,13 @@ static int calculate_bandwidth_encoder_iris33(
 	/*
 	 * Summary:
 	 * by default (for both HFR and HSR cases) :
-	 * 	-Any resolution and fps >= 120, enable layering.
+	 *      -Any resolution and fps >= 120, enable layering.
 	 * (120 -> 3, 240 -> 4, 480 -> 5)
-	 * 	- (once we enable layering) : 50 per cent frames are Non - reference
+	 *      - (once we enable layering) : 50 per cent frames are Non - reference
 	 *  frames.recon write is disable by Venus firmware
-	 * 	- Customer has ability to enable / disable layering.
-	 *  Hence, recon write savings would not be there if customer explicitly disables layer encoding.
+	 *      - Customer has ability to enable / disable layering.
+	 *  Hence, recon write savings would not be there if
+	 *  customer explicitly disables layer encoding.
 	 */
 
 	/*HFR Cases use alternating rec write if not PWC*/
@@ -924,7 +929,8 @@ static int calculate_bandwidth_encoder_iris33(
 			codec_output->ipb_rd_total_noc = large_bw_calculation_fp;
 			if (codec_input.linear_ipb == 0) {
 				codec_output->ipb_rd_total_noc =
-					(large_bw_calculation_fp * 100 + ipb_compression_factor - 1) /
+					(large_bw_calculation_fp * 100 +
+					 ipb_compression_factor - 1) /
 					ipb_compression_factor;
 			}
 		} else { /* rgb */
@@ -934,7 +940,8 @@ static int calculate_bandwidth_encoder_iris33(
 				if (codec_input.complexity_setting == 0) /* pwc */
 					codec_output->ipb_rd_total_noc =
 						(large_bw_calculation_fp * 100 +
-						en_original_compression_factor_rgba_pwd_iris33 - 1) /
+						 en_original_compression_factor_rgba_pwd_iris33
+						 - 1) /
 						en_original_compression_factor_rgba_pwd_iris33;
 				else
 					codec_output->ipb_rd_total_noc =

+ 12 - 5
driver/variant/iris33/src/msm_vidc_clock_iris33.c

@@ -85,7 +85,10 @@ static u32 bitrate_table_iris33_2stage_fp[5][10] = {
 	{130, 130, 120, 120, 120, 120, 120, 120, 120, 120},
 };
 
-/* HW limit bitrate table (these values are measured end to end fw/sw impacts are also considered) */
+/*
+ * HW limit bitrate table (these values are measured
+ * end to end fw/sw impacts are also considered)
+ */
 static u32 bitrate_table_iris33_1stage_fp[5][10] = { /* 1-stage assume IPPP */
 	/* h264 cavlc */
 	{0, 220, 220, 220, 220, 220, 220, 220, 220, 220},
@@ -324,7 +327,8 @@ static int calculate_vsp_min_freq(struct api_calculation_input codec_input,
 		 *
 		 *  8KUHD60fps with B frame
 		 *     - bitrate_entry = 0
-		 *     - Clock=NOMINAL for H264 & 2Stage H265. Because bitrate table entry for TURBO is 0.
+		 *     - Clock=NOMINAL for H264 & 2Stage H265. Because bitrate
+		 *       table entry for TURBO is 0.
 		 *
 		 *  TODO : Reduce these conditions by removing the zero entries from Bitrate table.
 		 */
@@ -409,7 +413,8 @@ static u32 calculate_pipe_penalty(struct api_calculation_input codec_input)
 					pipe_penalty_iris33[avid_commercial_content + 1][1]) / 2;
 			else if ((pixel_count == 3840 * 2160) ||
 				(pixel_count == 4096 * 2160) || (pixel_count == 4096 * 2304))
-				pipe_penalty_codec = pipe_penalty_iris33[avid_commercial_content + 1][1];
+				pipe_penalty_codec =
+					pipe_penalty_iris33[avid_commercial_content + 1][1];
 			else if (pixel_count < 7680 * 4320)
 				pipe_penalty_codec =
 					(pipe_penalty_iris33[avid_commercial_content + 1][1] +
@@ -485,7 +490,8 @@ static int calculate_vpp_min_freq(struct api_calculation_input codec_input,
 				1050 : decoder_vpp_fw_overhead;
 
 			/* VPP HW + FW */
-			if (codec_input.linear_opb == 1 && codec_input.bitdepth == CODEC_BITDEPTH_10)
+			if (codec_input.linear_opb == 1 &&
+			    codec_input.bitdepth == CODEC_BITDEPTH_10)
 				/* multiply by 1.20 for 10b case */
 				decoder_vpp_fw_overhead = 1200 + decoder_vpp_fw_overhead - 1000;
 
@@ -500,7 +506,8 @@ static int calculate_vpp_min_freq(struct api_calculation_input codec_input,
 				vpp_hw_min_frequency : vsp_hw_min_frequency;
 		} else {
 			/* 1-stage need SW cycles + FW cycles + HW time */
-			if (codec_input.linear_opb == 1 && codec_input.bitdepth == CODEC_BITDEPTH_10)
+			if (codec_input.linear_opb == 1 &&
+			    codec_input.bitdepth == CODEC_BITDEPTH_10)
 				/* multiply by 1.20 for 10b linear case */
 				vpp_hw_min_frequency =
 					(vpp_hw_min_frequency * 1200 + 999) / 1000;

+ 2 - 1
driver/variant/iris33/src/msm_vidc_power_iris33.c

@@ -732,7 +732,8 @@ u64 msm_vidc_calc_freq_iris33_legacy(struct msm_vidc_inst *inst, u32 data_size)
 	freq = max(vpp_cycles, vsp_cycles);
 	freq = max(freq, fw_cycles);
 
-	i_vpr_p(inst, "%s: filled len %d, required freq %llu, vpp %llu, vsp %llu, fw_cycles %llu, fps %u, mbpf %u\n",
+	i_vpr_p(inst,
+		"%s: filled len %d, required freq %llu, vpp %llu, vsp %llu, fw_cycles %llu, fps %u, mbpf %u\n",
 		__func__, data_size, freq,
 		vpp_cycles, vsp_cycles, fw_cycles, fps, mbpf);
 

+ 5 - 5
driver/vidc/inc/msm_vidc_inst.h

@@ -100,7 +100,7 @@ struct msm_vidc_inst {
 	struct msm_vidc_buffers_info       buffers;
 	struct msm_vidc_mem_list_info      mem_info;
 	struct msm_vidc_timestamps         timestamps;
-	struct msm_vidc_timestamps         ts_reorder; /* list of struct msm_vidc_timestamp */
+	struct msm_vidc_timestamps         ts_reorder; /* struct msm_vidc_timestamp */
 	struct msm_vidc_subscription_params       subcr_params[MAX_PORT];
 	struct msm_vidc_hfi_frame_info     hfi_frame_info;
 	struct msm_vidc_decode_batch       decode_batch;
@@ -111,13 +111,13 @@ struct msm_vidc_inst {
 	struct msm_vidc_stability          stability;
 	struct workqueue_struct           *workq;
 	struct list_head                   enc_input_crs;
-	struct list_head                   dmabuf_tracker; /* list of struct msm_memory_dmabuf */
-	struct list_head                   input_timer_list; /* list of struct msm_vidc_input_timer */
+	struct list_head                   dmabuf_tracker; /* struct msm_memory_dmabuf */
+	struct list_head                   input_timer_list; /* struct msm_vidc_input_timer */
 	struct list_head                   caps_list;
 	struct list_head                   children_list; /* struct msm_vidc_inst_cap_entry */
 	struct list_head                   firmware_list; /* struct msm_vidc_inst_cap_entry */
-	struct list_head                   pending_pkts; /* list of struct hfi_pending_packet */
-	struct list_head                   fence_list; /* list of struct msm_vidc_fence */
+	struct list_head                   pending_pkts; /* struct hfi_pending_packet */
+	struct list_head                   fence_list; /* struct msm_vidc_fence */
 	struct list_head                   buffer_stats_list; /* struct msm_vidc_buffer_stats */
 	bool                               once_per_session_set;
 	bool                               ipsc_properties_set;

+ 12 - 6
driver/vidc/src/msm_vidc_driver.c

@@ -3920,7 +3920,8 @@ int msm_vidc_print_buffer_info(struct msm_vidc_inst *inst)
 		if (!buffers)
 			continue;
 
-		i_vpr_h(inst, "buf: type: %15s, min %2d, extra %2d, actual %2d, size %9u, reuse %d\n",
+		i_vpr_h(inst,
+			"buf: type: %15s, min %2d, extra %2d, actual %2d, size %9u, reuse %d\n",
 			buf_name(i), buffers->min_count,
 			buffers->extra_count, buffers->actual_count,
 			buffers->size, buffers->reuse);
@@ -4263,9 +4264,11 @@ int msm_vidc_flush_buffers(struct msm_vidc_inst *inst,
 				buf->attr & MSM_VIDC_ATTR_DEFERRED) {
 				print_vidc_buffer(VIDC_HIGH, "high", "flushing buffer", inst, buf);
 				if (!(buf->attr & MSM_VIDC_ATTR_BUFFER_DONE)) {
-					if (is_decode_session(inst) && is_output_buffer(buf->type)) {
+					if (is_decode_session(inst) &&
+					    is_output_buffer(buf->type)) {
 						if (buf->dbuf_get) {
-							call_mem_op(core, dma_buf_put, inst, buf->dmabuf);
+							call_mem_op(core, dma_buf_put,
+								    inst, buf->dmabuf);
 							buf->dbuf_get = 0;
 						}
 					}
@@ -4391,7 +4394,8 @@ void msm_vidc_destroy_buffers(struct msm_vidc_inst *inst)
 			if (buf->attach && buf->dmabuf)
 				call_mem_op(core, dma_buf_detach, core, buf->dmabuf, buf->attach);
 			if (buf->dbuf_get) {
-				print_vidc_buffer(VIDC_ERR, "err ", "destroying: put dmabuf", inst, buf);
+				print_vidc_buffer(VIDC_ERR, "err ", "destroying: put dmabuf",
+						  inst, buf);
 				call_mem_op(core, dma_buf_put, inst, buf->dmabuf);
 			}
 			list_del_init(&buf->list);
@@ -5244,10 +5248,12 @@ static int msm_vidc_check_max_sessions(struct msm_vidc_inst *inst)
 			num_8k_sessions += 1;
 			num_4k_sessions += 2;
 			num_1080p_sessions += 4;
-		} else if (res_is_greater_than(width, height, 1920 + (1920 >> 1), 1088 + (1088 >> 1))) {
+		} else if (res_is_greater_than(width, height, 1920 + (1920 >> 1),
+					       1088 + (1088 >> 1))) {
 			num_4k_sessions += 1;
 			num_1080p_sessions += 2;
-		} else if (res_is_greater_than(width, height, 1280 + (1280 >> 1), 736 + (736 >> 1))) {
+		} else if (res_is_greater_than(width, height, 1280 + (1280 >> 1),
+					       736 + (736 >> 1))) {
 			num_1080p_sessions += 1;
 		}
 	}

+ 2 - 1
driver/vidc/src/msm_vidc_state.c

@@ -808,7 +808,8 @@ static int msm_vidc_input_streaming_state(struct msm_vidc_inst *inst,
 			/* check dynamic allowed if master port is streaming */
 			if (!(inst->capabilities[cap_id].flags & CAP_FLAG_DYNAMIC_ALLOWED)) {
 				i_vpr_e(inst, "%s: cap_id %#x (%s) not allowed in state %s\n",
-					__func__, cap_id, cap_name(cap_id), state_name(inst->state));
+					__func__, cap_id, cap_name(cap_id),
+					state_name(inst->state));
 				return -EINVAL;
 			}
 		}

+ 4 - 2
driver/vidc/src/msm_vidc_vb2.c

@@ -133,7 +133,8 @@ void msm_vb2_detach_dmabuf(void *buf_priv)
 	if (is_decode_session(inst) && is_output_buffer(vbuf->type)) {
 		list_for_each_entry_safe(ro_buf, dummy, &inst->buffers.read_only.list, list) {
 			if (ro_buf->dmabuf == vbuf->dmabuf) {
-				print_vidc_buffer(VIDC_LOW, "low ", "detach: found ro buf", inst, ro_buf);
+				print_vidc_buffer(VIDC_LOW, "low ", "detach: found ro buf",
+						  inst, ro_buf);
 				ro_buf->attach = vbuf->attach;
 				vbuf->attach = NULL;
 				goto exit;
@@ -210,7 +211,8 @@ void msm_vb2_unmap_dmabuf(void *buf_priv)
 	if (is_decode_session(inst) && is_output_buffer(vbuf->type)) {
 		list_for_each_entry_safe(ro_buf, dummy, &inst->buffers.read_only.list, list) {
 			if (ro_buf->dmabuf == vbuf->dmabuf) {
-				print_vidc_buffer(VIDC_LOW, "low ", "unmap: found ro buf", inst, ro_buf);
+				print_vidc_buffer(VIDC_LOW, "low ", "unmap: found ro buf",
+						  inst, ro_buf);
 				ro_buf->sg_table = vbuf->sg_table;
 				ro_buf->attach = vbuf->attach;
 				vbuf->sg_table = NULL;

+ 2 - 1
driver/vidc/src/resources.c

@@ -1224,7 +1224,8 @@ static int __update_residency_stats(struct msm_vidc_core *core,
 	prev_residency = get_residency_stats(cl, cl->prev);
 	if (prev_residency) {
 		if (prev_residency->start_time_us)
-			prev_residency->total_time_us += cur_time_us - prev_residency->start_time_us;
+			prev_residency->total_time_us += cur_time_us -
+			    prev_residency->start_time_us;
 
 		/* reset start time us */
 		prev_residency->start_time_us = 0;