media: venus: Add codec data table
Subsystems (4)
PATCH v6 1/4 media: venus: Add codec data table
Add vpp cycles for different types of codec. It indicates the cycles required by video hardware to process each macroblock. Add vsp cycles, cycles required by stream processor. Initialize the codec data with core resources.
Signed-off-by Aniket Masule <[email protected]>
--- drivers/media/platform/qcom/venus/core.c | 13 +++++++++++++ drivers/media/platform/qcom/venus/core.h | 16 +++++++++++++++ drivers/media/platform/qcom/venus/helpers.c | 30 +++++++++++++++++++++++++++++ drivers/media/platform/qcom/venus/helpers.h | 1 + drivers/media/platform/qcom/venus/vdec.c | 4 ++++ drivers/media/platform/qcom/venus/venc.c | 4 ++++ 6 files changed, 68 insertions(+)
drivers/media/platform/qcom/venus/core.c +13 -0
@@ -473,9 +473,22 @@ static __maybe_unused int venus_runtime_resume(struct device *dev) { 244800, 100000000 }, /* 1920x1080@30 */ }; +static struct codec_freq_data sdm845_codec_freq_data[] = { + {V4L2_PIX_FMT_H264 ,VIDC_SESSION_TYPE_ENC ,675 ,10 }, + {V4L2_PIX_FMT_HEVC ,VIDC_SESSION_TYPE_ENC ,675 ,10 }, + {V4L2_PIX_FMT_VP8 ,VIDC_SESSION_TYPE_ENC ,675 ,10 }, + {V4L2_PIX_FMT_MPEG2 ,VIDC_SESSION_TYPE_DEC ,200 ,10 }, + {V4L2_PIX_FMT_H264 ,VIDC_SESSION_TYPE_DEC ,200 ,10 }, + {V4L2_PIX_FMT_HEVC ,VIDC_SESSION_TYPE_DEC ,200 ,10 }, + {V4L2_PIX_FMT_VP8 ,VIDC_SESSION_TYPE_DEC ,200 ,10 }, + {V4L2_PIX_FMT_VP9 ,VIDC_SESSION_TYPE_DEC ,200 ,10 }, +}; +static const struct venus_resources sdm845_res = { .freq_tbl = sdm845_freq_table, .freq_tbl_size =ARRAY_SIZE (sdm845_freq_table), + .codec_freq_data = sdm845_codec_freq_data, + .codec_freq_data_size =ARRAY_SIZE (sdm845_codec_freq_data), .clks = {"core" ,"iface" ,"bus" }, .clks_num =3 , .max_load = 2563200,
drivers/media/platform/qcom/venus/core.h +16 -0
@@ -35,12 +35,21 @@ struct reg_val {u32 value; }; +struct codec_freq_data { +u32 pixfmt; +u32 session_type; +unsigned long vpp_freq; +unsigned long vsp_freq; +}; +struct venus_resources {u64 dma_mask;const struct freq_tbl *freq_tbl;unsigned int freq_tbl_size;const struct reg_val *reg_tbl;unsigned int reg_tbl_size; +const struct codec_freq_data *codec_freq_data; +unsigned int codec_freq_data_size;const char *const clks[VIDC_CLKS_NUM_MAX ];unsigned int clks_num;enum hfi_version hfi_version;
@@ -216,6 +225,12 @@ struct venus_buffer {struct list_head ref_list; }; +struct clock_data { +u32 core_id; +unsigned long freq; +const struct codec_freq_data *codec_freq_data; +}; +#define to_venus_buffer (ptr) container_of(ptr, struct venus_buffer, vb)/**
@@ -275,6 +290,7 @@ struct venus_inst {struct list_head list;struct mutex lock;struct venus_core *core; +struct clock_data clk_data;struct list_head dpbbufs;struct list_head internalbufs;struct list_head registeredbufs;
drivers/media/platform/qcom/venus/helpers.c +30 -0
@@ -715,6 +715,36 @@ int venus_helper_set_core_usage(struct venus_inst *inst, u32 usage) }EXPORT_SYMBOL_GPL (venus_helper_set_core_usage); +int venus_helper_init_codec_freq_data (struct venus_inst *inst) +{ +const struct codec_freq_data *data; +unsigned int i, data_size; +u32 pixfmt; +int ret =0 ; + +if (!IS_V4 (inst->core)) +return 0 ; + + data = inst->core->res->codec_freq_data; + data_size = inst->core->res->codec_freq_data_size; + pixfmt = inst->session_type ==VIDC_SESSION_TYPE_DEC ? + inst->fmt_out->pixfmt : inst->fmt_cap->pixfmt; + +for (i =0 ; i < data_size; i++) { +if (data[i].pixfmt == pixfmt && + data[i].session_type == inst->session_type) { + inst->clk_data.codec_freq_data = &data[i]; +break ; + } + } + +if (!inst->clk_data.codec_freq_data) + ret = -EINVAL ; + +return ret; +} +EXPORT_SYMBOL_GPL (venus_helper_init_codec_freq_data); +int venus_helper_set_num_bufs (struct venus_inst *inst,unsigned int input_bufs,unsigned int output_bufs,unsigned int output2_bufs)
drivers/media/platform/qcom/venus/helpers.h +1 -0
@@ -41,6 +41,7 @@ int venus_helper_set_output_resolution(struct venus_inst *inst, unsigned int width, unsigned int height, u32 buftype);int venus_helper_set_work_mode (struct venus_inst *inst,u32 mode); +int venus_helper_init_codec_freq_data (struct venus_inst *inst);int venus_helper_set_core_usage (struct venus_inst *inst,u32 usage); int venus_helper_set_num_bufs(struct venus_inst *inst, unsigned int input_bufs, unsigned int output_bufs,
drivers/media/platform/qcom/venus/vdec.c +4 -0
@@ -660,6 +660,10 @@ static int vdec_init_session(struct venus_inst *inst)if (ret) goto deinit; + ret =venus_helper_init_codec_freq_data (inst); +if (ret) + goto deinit; +return 0 ; deinit:hfi_session_deinit (inst);
drivers/media/platform/qcom/venus/venc.c +4 -0
@@ -847,6 +847,10 @@ static int venc_init_session(struct venus_inst *inst)if (ret) goto deinit; + ret =venus_helper_init_codec_freq_data (inst); +if (ret) + goto deinit; + ret =venc_set_properties (inst);if (ret) goto deinit;
Signature · 2 lines
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project
PATCH v6 2/4 media: venus: Update clock scaling
Current clock scaling calculations are same for vpu4 and previous versions. For vpu4, Clock scaling calculations are updated with cycles/mb. This helps in getting precise clock required.
Signed-off-by Aniket Masule <[email protected]>
--- drivers/media/platform/qcom/venus/helpers.c | 91 +++++++++++++++++++++++++++-- 1 file changed, 87 insertions(+), 4 deletions(-)
drivers/media/platform/qcom/venus/helpers.c +87 -4
@@ -348,8 +348,9 @@ static u32 load_per_type(struct venus_core *core, u32 session_type)return mbs_per_sec; } -static int load_scale_clocks (struct venus_core *core) +static int scale_clocks (struct venus_inst *inst) { +struct venus_core *core = inst->core;const struct freq_tbl *table = core->res->freq_tbl;unsigned int num_rows = core->res->freq_tbl_size;unsigned long freq = table[0 ].freq;
@@ -398,6 +399,89 @@ static int load_scale_clocks(struct venus_core *core)return ret; } +static unsigned long calculate_vpp_freq (struct venus_inst *inst) +{ +unsigned long vpp_freq =0 ; +u32 mbs_per_sec; + + mbs_per_sec =load_per_instance (inst); + vpp_freq = mbs_per_sec * inst->clk_data.codec_freq_data->vpp_freq; +/* 21 / 20 is overhead factor */ + vpp_freq += vpp_freq /20 ; + +return vpp_freq; +} + +static int scale_clocks_v4 (struct venus_inst *inst) +{ +struct venus_core *core = inst->core; +const struct freq_tbl *table = core->res->freq_tbl; +unsigned int num_rows = core->res->freq_tbl_size; +struct clk *clk = core->clks[0 ]; +struct device *dev = core->dev; +unsigned int i; +unsigned long freq =0 , freq_core1 =0 , freq_core2 =0 ; +int ret; + + freq =calculate_vpp_freq (inst); + +if (freq > table[0 ].freq) +dev_warn (dev,"HW is overloaded, needed: %lu max: %lu\n" , + freq, table[0 ].freq); + +for (i =0 ; i < num_rows; i++) { +if (freq > table[i].freq) +break ; + freq = table[i].freq; + } + + inst->clk_data.freq = freq; + +mutex_lock (&core->lock); +list_for_each_entry (inst, &core->instances, list) { +if (inst->clk_data.core_id ==VIDC_CORE_ID_1 ) { + freq_core1 += inst->clk_data.freq; + }else if (inst->clk_data.core_id ==VIDC_CORE_ID_2 ) { + freq_core2 += inst->clk_data.freq; + }else if (inst->clk_data.core_id ==VIDC_CORE_ID_3 ) { + freq_core1 += inst->clk_data.freq; + freq_core2 += inst->clk_data.freq; + } + } +mutex_unlock (&core->lock); + + freq =max (freq_core1, freq_core2); + + ret =clk_set_rate (clk, freq); +if (ret) + goto err; + + ret =clk_set_rate (core->core0_clk, freq); +if (ret) + goto err; + + ret =clk_set_rate (core->core1_clk, freq); +if (ret) + goto err; + +return 0 ; + +err: +dev_err (dev,"failed to set clock rate %lu (%d)\n" , freq, ret); +return ret; +} + +static int load_scale_clocks (struct venus_inst *inst) +{ +if (IS_V4 (inst->core)) +return scale_clocks_v4 (inst); + +if (inst->state ==INST_START ) +return 0 ; + +return scale_clocks (inst); +} +static void fill_buffer_desc (const struct venus_buffer *buf,struct hfi_buffer_desc *bd,bool response) {
@@ -1053,7 +1137,7 @@ void venus_helper_vb2_stop_streaming(struct vb2_queue *q)venus_helper_free_dpb_bufs (inst); -load_scale_clocks (core); +load_scale_clocks (inst);INIT_LIST_HEAD (&inst->registeredbufs); }
@@ -1070,7 +1154,6 @@ void venus_helper_vb2_stop_streaming(struct vb2_queue *q)int venus_helper_vb2_start_streaming (struct venus_inst *inst) { -struct venus_core *core = inst->core;int ret; ret =intbufs_alloc (inst);
@@ -1081,7 +1164,7 @@ int venus_helper_vb2_start_streaming(struct venus_inst *inst)if (ret) goto err_bufs_free; -load_scale_clocks (core); +load_scale_clocks (inst); ret =hfi_session_load_res (inst);if (ret)
Signature · 2 lines
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project
Re: [PATCH v6 2/4] media: venus: Update clock scaling
Hi Aniket,
Quoted 59 lines · Aniket Masule
Current clock scaling calculations are same for vpu4 and previous versions. For vpu4, Clock scaling calculations are updated with cycles/mb. This helps in getting precise clock required.
Signed-off-by Aniket Masule <[email protected]>--- drivers/media/platform/qcom/venus/helpers.c | 91 +++++++++++++++++++++++++++-- 1 file changed, 87 insertions(+), 4 deletions(-)drivers/media/platform/qcom/venus/helpers.c +32
-1@@ -348,8 +348,9 @@ static u32 load_per_type(struct venus_core *core, u32 session_type)return mbs_per_sec; } -static int load_scale_clocks (struct venus_core *core) +static int scale_clocks (struct venus_inst *inst) { +struct venus_core *core = inst->core;const struct freq_tbl *table = core->res->freq_tbl;unsigned int num_rows = core->res->freq_tbl_size;unsigned long freq = table[0 ].freq;@@ -398,6 +399,89 @@ static int load_scale_clocks(struct venus_core *core)return ret; } +static unsigned long calculate_vpp_freq (struct venus_inst *inst) +{ +unsigned long vpp_freq =0 ; +u32 mbs_per_sec; + + mbs_per_sec =load_per_instance (inst); + vpp_freq = mbs_per_sec * inst->clk_data.codec_freq_data->vpp_freq; +/* 21 / 20 is overhead factor */ + vpp_freq += vpp_freq /20 ; + +return vpp_freq; +} + +static int scale_clocks_v4 (struct venus_inst *inst) +{ +struct venus_core *core = inst->core; +const struct freq_tbl *table = core->res->freq_tbl; +unsigned int num_rows = core->res->freq_tbl_size; +struct clk *clk = core->clks[0 ]; +struct device *dev = core->dev; +unsigned int i; +unsigned long freq =0 , freq_core1 =0 , freq_core2 =0 ; +int ret; + + freq =calculate_vpp_freq (inst); + +if (freq > table[0 ].freq) +dev_warn (dev,"HW is overloaded, needed: %lu max: %lu\n" , + freq, table[0 ].freq); +
...
drivers/media/platform/qcom/venus/helpers.c static int load_scale_clocks(struct venus_core *core) · line 436
Quoted 5 lines
drivers/media/platform/qcom/venus/helpers.c +5
-0+for (i =0 ; i < num_rows; i++) { +if (freq > table[i].freq) +break ; + freq = table[i].freq; + }
The above code snippet will select the biggest table[0].freq always. Infact do we need to "normalize" the calculated freq to the table of possible clock rates? I think tjat should be made after sum all needed frequencies for all cores.
Quoted 19 lines
drivers/media/platform/qcom/venus/helpers.c +19
-0+ + inst->clk_data.freq = freq; + +mutex_lock (&core->lock); +list_for_each_entry (inst, &core->instances, list) { +if (inst->clk_data.core_id ==VIDC_CORE_ID_1 ) { + freq_core1 += inst->clk_data.freq; + }else if (inst->clk_data.core_id ==VIDC_CORE_ID_2 ) { + freq_core2 += inst->clk_data.freq; + }else if (inst->clk_data.core_id ==VIDC_CORE_ID_3 ) { + freq_core1 += inst->clk_data.freq; + freq_core2 += inst->clk_data.freq; + } + } +mutex_unlock (&core->lock); + + freq =max (freq_core1, freq_core2); + + ret =clk_set_rate (clk, freq);
drivers/media/platform/qcom/venus/helpers.c static int load_scale_clocks(struct venus_core *core) · line 465
Quoted 10 lines
drivers/media/platform/qcom/venus/helpers.c +10
-0+if (ret) + goto err; + + ret =clk_set_rate (core->core0_clk, freq); +if (ret) + goto err; + + ret =clk_set_rate (core->core1_clk, freq); +if (ret) + goto err;
This is duplicated in both scale_clocks and scale_clocks_v4, and could be a common function.
Quoted 5 lines
drivers/media/platform/qcom/venus/helpers.c +5
-0+ +return 0 ; + +err: +dev_err (dev,"failed to set clock rate %lu (%d)\n" , freq, ret);
drivers/media/platform/qcom/venus/helpers.c static int load_scale_clocks(struct venus_core *core) · line 480
Quoted 10 lines
drivers/media/platform/qcom/venus/helpers.c +10
-0+return ret; +} + +static int load_scale_clocks (struct venus_inst *inst) +{ +if (IS_V4 (inst->core)) +return scale_clocks_v4 (inst); + +if (inst->state ==INST_START ) +return 0 ;
I'm still not sure about this check of the instance state.
If we look into load_per_instance() it already doing similar check :
!(inst->state >= INST_INIT && inst->state < INST_STOP)
Quoted 34 lines
drivers/media/platform/qcom/venus/helpers.c +6
-3+ +return scale_clocks (inst); +} +static void fill_buffer_desc (const struct venus_buffer *buf,struct hfi_buffer_desc *bd,bool response) {@@ -1053,7 +1137,7 @@ void venus_helper_vb2_stop_streaming(struct vb2_queue *q)venus_helper_free_dpb_bufs (inst); -load_scale_clocks (core); +load_scale_clocks (inst);INIT_LIST_HEAD (&inst->registeredbufs); }@@ -1070,7 +1154,6 @@ void venus_helper_vb2_stop_streaming(struct vb2_queue *q)int venus_helper_vb2_start_streaming (struct venus_inst *inst) { -struct venus_core *core = inst->core;int ret; ret =intbufs_alloc (inst);@@ -1081,7 +1164,7 @@ int venus_helper_vb2_start_streaming(struct venus_inst *inst)if (ret) goto err_bufs_free; -load_scale_clocks (core); +load_scale_clocks (inst); ret =hfi_session_load_res (inst);if (ret)
Signature · 2 lines
regards, Stan
Re: [PATCH v6 2/4] media: venus: Update clock scaling
Hi Stan,
Quoted 68 lines · Stanimir Varbanov
Hi Aniket,
Quoted 62 lines · Aniket Masule
Current clock scaling calculations are same for vpu4 and previous versions. For vpu4, Clock scaling calculations are updated with cycles/mb. This helps in getting precise clock required.
Signed-off-by Aniket Masule <[email protected]>--- drivers/media/platform/qcom/venus/helpers.c | 91 +++++++++++++++++++++++++++-- 1 file changed, 87 insertions(+), 4 deletions(-)drivers/media/platform/qcom/venus/helpers.c +2
-1@@ -348,8 +348,9 @@ static u32 load_per_type(struct venus_core *core, u32 session_type)return mbs_per_sec; } -static int load_scale_clocks (struct venus_core *core) +static int scale_clocks (struct venus_inst *inst) { +struct venus_core *core = inst->core;const struct freq_tbl *table = core->res->freq_tbl;unsigned int num_rows = core->res->freq_tbl_size;drivers/media/platform/qcom/venus/helpers.c +30
-0unsigned long freq = table[0 ].freq;@@ -398,6 +399,89 @@ static int load_scale_clocks(struct venus_core *core)return ret; } +static unsigned long calculate_vpp_freq (struct venus_inst *inst) +{ +unsigned long vpp_freq =0 ; +u32 mbs_per_sec; + + mbs_per_sec =load_per_instance (inst); + vpp_freq = mbs_per_sec * inst->clk_data.codec_freq_data->vpp_freq; +/* 21 / 20 is overhead factor */ + vpp_freq += vpp_freq /20 ; + +return vpp_freq; +} + +static int scale_clocks_v4 (struct venus_inst *inst) +{ +struct venus_core *core = inst->core; +const struct freq_tbl *table = core->res->freq_tbl; +unsigned int num_rows = core->res->freq_tbl_size; +struct clk *clk = core->clks[0 ]; +struct device *dev = core->dev; +unsigned int i; +unsigned long freq =0 , freq_core1 =0 , freq_core2 =0 ; +int ret; + + freq =calculate_vpp_freq (inst); + +if (freq > table[0 ].freq) +dev_warn (dev,"HW is overloaded, needed: %lu max: %lu\n" , + freq, table[0 ].freq); +...
Quoted 11 lines
drivers/media/platform/qcom/venus/helpers.c static int load_scale_clocks(struct venus_core *core) · line 436
Quoted 5 lines
drivers/media/platform/qcom/venus/helpers.c +5
-0+for (i =0 ; i < num_rows; i++) { +if (freq > table[i].freq) +break ; + freq = table[i].freq; + }The above code snippet will select the biggest table[0].freq always. Infact do we need to "normalize" the calculated freq to the table of possible clock rates? I think tjat should be made after sum all needed frequencies for all cores.
Will correct this. Normalizing after sum of all needed frequencies would be more precise.
Quoted 24 lines
Quoted 24 lines
drivers/media/platform/qcom/venus/helpers.c +24
-0+ + inst->clk_data.freq = freq; + +mutex_lock (&core->lock); +list_for_each_entry (inst, &core->instances, list) { +if (inst->clk_data.core_id ==VIDC_CORE_ID_1 ) { + freq_core1 += inst->clk_data.freq; + }else if (inst->clk_data.core_id ==VIDC_CORE_ID_2 ) { + freq_core2 += inst->clk_data.freq; + }else if (inst->clk_data.core_id ==VIDC_CORE_ID_3 ) { + freq_core1 += inst->clk_data.freq; + freq_core2 += inst->clk_data.freq; + } + } +mutex_unlock (&core->lock); + + freq =max (freq_core1, freq_core2); + + ret =clk_set_rate (clk, freq); +if (ret) + goto err; + + ret =clk_set_rate (core->core0_clk, freq); +if (ret)
Quoted 9 lines
drivers/media/platform/qcom/venus/helpers.c static int load_scale_clocks(struct venus_core *core) · line 465
Quoted 5 lines
drivers/media/platform/qcom/venus/helpers.c +5
-0+ goto err; + + ret =clk_set_rate (core->core1_clk, freq); +if (ret) + goto err;This is duplicated in both
scale_clocksandscale_clocks_v4, and could be a common function.
I will move this to common function.
Quoted 18 lines
Quoted 5 lines
drivers/media/platform/qcom/venus/helpers.c +5
-0+ +return 0 ; + +err: +dev_err (dev,"failed to set clock rate %lu (%d)\n" , freq, ret);drivers/media/platform/qcom/venus/helpers.c static int load_scale_clocks(struct venus_core *core) · line 480
Quoted 10 lines
drivers/media/platform/qcom/venus/helpers.c +10
-0+return ret; +} + +static int load_scale_clocks (struct venus_inst *inst) +{ +if (IS_V4 (inst->core)) +return scale_clocks_v4 (inst); + +if (inst->state ==INST_START ) +return 0 ;I'm still not sure about this check of the instance state.
Quoted 5 lines
If we look into
load_per_instance()it already doing similar check :!(inst->state >=
INST_INIT&&inst->state<INST_STOP)
This check would just make sure instance state for scaling, not a mandatory check. I can remove the check.
Quoted 31 lines
Quoted 31 lines
drivers/media/platform/qcom/venus/helpers.c +5
-2+ +return scale_clocks (inst); +} +static void fill_buffer_desc (const struct venus_buffer *buf,struct hfi_buffer_desc *bd,bool response) {@@ -1053,7 +1137,7 @@ void venus_helper_vb2_stop_streaming(struct vb2_queue *q)venus_helper_free_dpb_bufs (inst ); -load_scale_clocks (core); +load_scale_clocks (inst);INIT_LIST_HEAD (&inst->registeredbufs); }@@ -1070,7 +1154,6 @@ void venus_helper_vb2_stop_streaming(struct vb2_queue *q)int venus_helper_vb2_start_streaming (struct venus_inst *inst) { -struct venus_core *core = inst->core;int ret;drivers/media/platform/qcom/venus/helpers.c +0
-0ret =intbufs_alloc (inst);@@ -1081,7 +1164,7 @@ int venus_helper_vb2_start_streaming(struct venus_inst *inst)if (ret) goto err_bufs_free;
Quoted 6 lines
Quoted 6 lines
drivers/media/platform/qcom/venus/helpers.c +1
-1-load_scale_clocks (core); +load_scale_clocks (inst); ret =hfi_session_load_res (inst);if (ret)
Regards,
Aniket
PATCH v6 3/4 media: venus: Update to bitrate based clock scaling
In reply to Aniket MasuleIntroduced clock scaling using bitrate, preavious
calculations consider only the cycles per mb.
Also, clock scaling is now triggered before every
buffer being queued to the device. This helps in
deciding precise clock cycles required.
Signed-off-by Aniket Masule <[email protected]>
--- drivers/media/platform/qcom/venus/helpers.c | 33 +++++++++++++++++++++++++---- 1 file changed, 29 insertions(+), 4 deletions(-)
drivers/media/platform/qcom/venus/helpers.c +29 -4
@@ -399,17 +399,26 @@ static int scale_clocks(struct venus_inst *inst)return ret; } -static unsigned long calculate_vpp_freq (struct venus_inst *inst) +static unsigned long calculate_inst_freq (struct venus_inst *inst, +unsigned long filled_len) { -unsigned long vpp_freq =0 ; +unsigned long vpp_freq =0 , vsp_freq =0 ; +u64 fps = inst->fps;u32 mbs_per_sec; mbs_per_sec =load_per_instance (inst); vpp_freq = mbs_per_sec * inst->clk_data.codec_freq_data->vpp_freq;/* 21 / 20 is overhead factor */ vpp_freq += vpp_freq /20 ; + vsp_freq = mbs_per_sec * inst->clk_data.codec_freq_data->vsp_freq; -return vpp_freq; +/* 10 / 7 is overhead factor */ +if (inst->session_type ==VIDC_SESSION_TYPE_ENC ) + vsp_freq += (inst->controls.enc.bitrate *10 ) /7 ; +else + vsp_freq += ((fps * filled_len *8 ) *10 ) /7 ; + +return max (vpp_freq, vsp_freq); }static int scale_clocks_v4 (struct venus_inst *inst)
@@ -417,13 +426,27 @@ static int scale_clocks_v4(struct venus_inst *inst)struct venus_core *core = inst->core;const struct freq_tbl *table = core->res->freq_tbl;unsigned int num_rows = core->res->freq_tbl_size; +struct v4l2_m2m_ctx *m2m_ctx = inst->m2m_ctx;struct clk *clk = core->clks[0 ];struct device *dev = core->dev;unsigned int i;unsigned long freq =0 , freq_core1 =0 , freq_core2 =0 ; +unsigned long filled_len =0 ; +struct venus_buffer *buf, *n; +struct vb2_buffer *vb;int ret; - freq =calculate_vpp_freq (inst); +mutex_lock (&inst->lock); +v4l2_m2m_for_each_src_buf_safe (m2m_ctx, buf, n) { + vb = &buf->vb.vb2_buf; + filled_len =max (filled_len,vb2_get_plane_payload (vb,0 )); + } +mutex_unlock (&inst->lock); + +if (inst->session_type ==VIDC_SESSION_TYPE_DEC && !filled_len) +return 0 ; + + freq =calculate_inst_freq (inst, filled_len);if (freq > table[0 ].freq) dev_warn(dev, "HW is overloaded, needed: %lu max: %lu\n",
@@ -1093,6 +1116,8 @@ void venus_helper_vb2_buf_queue(struct vb2_buffer *vb)if (ret) goto unlock; +load_scale_clocks (inst); + ret =session_process_buf (inst, vbuf);if (ret)return_buf_error (inst, vbuf);
Signature · 2 lines
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project
Re: [PATCH v6 3/4] media: venus: Update to bitrate based clock scaling
Quoted 51 lines · Aniket Masule
Introduced clock scaling using bitrate, preavious calculations consider only the cycles per mb. Also, clock scaling is now triggered before every buffer being queued to the device. This helps in deciding precise clock cycles required.
Signed-off-by Aniket Masule <[email protected]>--- drivers/media/platform/qcom/venus/helpers.c | 33 +++++++++++++++++++++++++---- 1 file changed, 29 insertions(+), 4 deletions(-)drivers/media/platform/qcom/venus/helpers.c +13
-3@@ -399,17 +399,26 @@ static int scale_clocks(struct venus_inst *inst)return ret; } -static unsigned long calculate_vpp_freq (struct venus_inst *inst) +static unsigned long calculate_inst_freq (struct venus_inst *inst, +unsigned long filled_len) { -unsigned long vpp_freq =0 ; +unsigned long vpp_freq =0 , vsp_freq =0 ; +u64 fps = inst->fps;u32 mbs_per_sec; mbs_per_sec =load_per_instance (inst); vpp_freq = mbs_per_sec * inst->clk_data.codec_freq_data->vpp_freq;/* 21 / 20 is overhead factor */ vpp_freq += vpp_freq /20 ; + vsp_freq = mbs_per_sec * inst->clk_data.codec_freq_data->vsp_freq; -return vpp_freq; +/* 10 / 7 is overhead factor */ +if (inst->session_type ==VIDC_SESSION_TYPE_ENC ) + vsp_freq += (inst->controls.enc.bitrate *10 ) /7 ; +else + vsp_freq += ((fps * filled_len *8 ) *10 ) /7 ; + +return max (vpp_freq, vsp_freq); }static int scale_clocks_v4 (struct venus_inst *inst)@@ -417,13 +426,27 @@ static int scale_clocks_v4(struct venus_inst *inst)struct venus_core *core = inst->core;const struct freq_tbl *table = core->res->freq_tbl;unsigned int num_rows = core->res->freq_tbl_size; +struct v4l2_m2m_ctx *m2m_ctx = inst->m2m_ctx;struct clk *clk = core->clks[0 ];
drivers/media/platform/qcom/venus/helpers.c static int scale_clocks_v4(struct venus_inst *inst) · line 439
Quoted 10 lines
drivers/media/platform/qcom/venus/helpers.c +4
-1struct device *dev = core->dev;unsigned int i;unsigned long freq =0 , freq_core1 =0 , freq_core2 =0 ; +unsigned long filled_len =0 ; +struct venus_buffer *buf, *n; +struct vb2_buffer *vb;int ret; - freq =calculate_vpp_freq (inst); +mutex_lock (&inst->lock);
the lock is not needed and having it will produce a deadlock.
Quoted 23 lines
drivers/media/platform/qcom/venus/helpers.c +12
-0+v4l2_m2m_for_each_src_buf_safe (m2m_ctx, buf, n) { + vb = &buf->vb.vb2_buf; + filled_len =max (filled_len,vb2_get_plane_payload (vb,0 )); + } +mutex_unlock (&inst->lock); + +if (inst->session_type ==VIDC_SESSION_TYPE_DEC && !filled_len) +return 0 ; + + freq =calculate_inst_freq (inst, filled_len);if (freq > table[0 ].freq) dev_warn(dev, "HW is overloaded, needed: %lu max: %lu\n",@@ -1093,6 +1116,8 @@ void venus_helper_vb2_buf_queue(struct vb2_buffer *vb)if (ret) goto unlock; +load_scale_clocks (inst); + ret =session_process_buf (inst, vbuf);if (ret)return_buf_error (inst, vbuf);
Signature · 2 lines
regards, Stan
Re: [PATCH v6 3/4] media: venus: Update to bitrate based clock scaling
In reply to Aniket MasuleHi,
Quoted 30 lines · Aniket Masule
Introduced clock scaling using bitrate, preavious calculations consider only the cycles per mb. Also, clock scaling is now triggered before every buffer being queued to the device. This helps in deciding precise clock cycles required.
Signed-off-by Aniket Masule <[email protected]>--- drivers/media/platform/qcom/venus/helpers.c | 33 +++++++++++++++++++++++++---- 1 file changed, 29 insertions(+), 4 deletions(-)drivers/media/platform/qcom/venus/helpers.c +4
-2@@ -399,17 +399,26 @@ static int scale_clocks(struct venus_inst *inst)return ret; } -static unsigned long calculate_vpp_freq (struct venus_inst *inst) +static unsigned long calculate_inst_freq (struct venus_inst *inst, +unsigned long filled_len) { -unsigned long vpp_freq =0 ; +unsigned long vpp_freq =0 , vsp_freq =0 ; +u64 fps = inst->fps;u32 mbs_per_sec; mbs_per_sec =load_per_instance (inst); vpp_freq = mbs_per_sec * inst->clk_data.codec_freq_data->vpp_freq;
drivers/media/platform/qcom/venus/helpers.c static int scale_clocks(struct venus_inst *inst) · line 419
Quoted 10 lines
drivers/media/platform/qcom/venus/helpers.c +6
-1/* 21 / 20 is overhead factor */ vpp_freq += vpp_freq /20 ; + vsp_freq = mbs_per_sec * inst->clk_data.codec_freq_data->vsp_freq; -return vpp_freq; +/* 10 / 7 is overhead factor */ +if (inst->session_type ==VIDC_SESSION_TYPE_ENC ) + vsp_freq += (inst->controls.enc.bitrate *10 ) /7 ; +else + vsp_freq += ((fps * filled_len *8 ) *10 ) /7 ;
load_per_instance() already taken into account fps, thus I think fps should be excluded from calculation.
Quoted 4 lines
drivers/media/platform/qcom/venus/helpers.c +2
-0+ +return max (vpp_freq, vsp_freq); }
Signature · 2 lines
regards, Stan
Re: [PATCH v6 3/4] media: venus: Update to bitrate based clock scaling
Hi Stan,
Quoted 38 lines · Stanimir Varbanov
Hi,
Quoted 35 lines · Aniket Masule
Introduced clock scaling using bitrate, preavious calculations consider only the cycles per mb. Also, clock scaling is now triggered before every buffer being queued to the device. This helps in deciding precise clock cycles required.
Signed-off-by Aniket Masule <[email protected]>--- drivers/media/platform/qcom/venus/helpers.c | 33 +++++++++++++++++++++++++---- 1 file changed, 29 insertions(+), 4 deletions(-)drivers/media/platform/qcom/venus/helpers.c +5
-2@@ -399,17 +399,26 @@ static int scale_clocks(struct venus_inst *inst)return ret; } -static unsigned long calculate_vpp_freq (struct venus_inst *inst) +static unsigned long calculate_inst_freq (struct venus_inst *inst, +unsigned long filled_len) { -unsigned long vpp_freq =0 ; +unsigned long vpp_freq =0 , vsp_freq =0 ; +u64 fps = inst->fps;u32 mbs_per_sec; mbs_per_sec =load_per_instance (inst); vpp_freq = mbs_per_sec * inst->clk_data.codec_freq_data->vpp_freq;/* 21 / 20 is overhead factor */ vpp_freq += vpp_freq /20 ; + vsp_freq = mbs_per_sec * inst->clk_data.codec_freq_data->vsp_freq;
Quoted 10 lines
drivers/media/platform/qcom/venus/helpers.c static int scale_clocks(struct venus_inst *inst) · line 419
Quoted 6 lines
drivers/media/platform/qcom/venus/helpers.c +5
-1-return vpp_freq; +/* 10 / 7 is overhead factor */ +if (inst->session_type ==VIDC_SESSION_TYPE_ENC ) + vsp_freq += (inst->controls.enc.bitrate *10 ) /7 ; +else + vsp_freq += ((fps * filled_len *8 ) *10 ) /7 ;
load_per_instance()already taken into account fps, thus I think fps should be excluded from calculation.
I will correct this, fps is needed for stream processor frequency calculations, also fps is not needed for vpp.
Quoted 4 lines
drivers/media/platform/qcom/venus/helpers.c static int scale_clocks(struct venus_inst *inst) · line 423
Quoted 4 lines
drivers/media/platform/qcom/venus/helpers.c +2
-0+ +return max (vpp_freq, vsp_freq); }
Regards,
Aniket
PATCH v6 4/4 media: venus: Update core selection
In reply to Aniket MasulePresent core assignment is static. Introduced load balancing across the cores. Load on earch core is calculated and core with minimum load is assigned to given instance.
Signed-off-by Aniket Masule <[email protected]>
--- drivers/media/platform/qcom/venus/helpers.c | 69 +++++++++++++++++++++++--- drivers/media/platform/qcom/venus/helpers.h | 2 +- drivers/media/platform/qcom/venus/hfi_helper.h | 1 + drivers/media/platform/qcom/venus/hfi_parser.h | 5 ++ drivers/media/platform/qcom/venus/vdec.c | 2 +- drivers/media/platform/qcom/venus/venc.c | 2 +- 6 files changed, 72 insertions(+), 9 deletions(-)
drivers/media/platform/qcom/venus/helpers.c +63 -6
@@ -26,6 +26,7 @@#include "helpers.h" #include "hfi_helper.h" #include "hfi_venus_io.h" +#include "hfi_parser.h" struct intbuf {struct list_head list;
@@ -331,6 +332,24 @@ static u32 load_per_instance(struct venus_inst *inst)return mbs * inst->fps; } +static u32 load_per_core (struct venus_core *core,u32 core_id) +{ +struct venus_inst *inst =NULL ; +u32 mbs_per_sec =0 , load =0 ; + +mutex_lock (&core->lock); +list_for_each_entry (inst, &core->instances, list) { +if (inst->clk_data.core_id != core_id) +continue ; + + mbs_per_sec =load_per_instance (inst); + load += mbs_per_sec * inst->clk_data.codec_freq_data->vpp_freq; + } +mutex_unlock (&core->lock); + +return load; +} +static u32 load_per_type (struct venus_core *core,u32 session_type) {struct venus_inst *inst =NULL ;
@@ -505,6 +524,16 @@ static int load_scale_clocks(struct venus_inst *inst)return scale_clocks (inst); } +int set_core_usage (struct venus_inst *inst,u32 usage) +{ +const u32 ptype =HFI_PROPERTY_CONFIG_VIDEOCORES_USAGE ; +struct hfi_videocores_usage_type cu; + + cu.video_core_enable_mask = usage; + +return hfi_session_set_property (inst, ptype, &cu); +} +static void fill_buffer_desc (const struct venus_buffer *buf,struct hfi_buffer_desc *bd,bool response) {
@@ -808,19 +837,47 @@ int venus_helper_set_work_mode(struct venus_inst *inst, u32 mode) }EXPORT_SYMBOL_GPL (venus_helper_set_work_mode); -int venus_helper_set_core_usage (struct venus_inst *inst,u32 usage) +int venus_helper_set_core (struct venus_inst *inst) { -const u32 ptype =HFI_PROPERTY_CONFIG_VIDEOCORES_USAGE ; -struct hfi_videocores_usage_type cu; +struct venus_core *core = inst->core; +u32 min_core_id =0 , core1_load =0 , core2_load =0 ; +unsigned long min_load, max_freq, cur_inst_load; +u32 cores_max; +int ret;if (!IS_V4 (inst->core))return 0 ; - cu.video_core_enable_mask = usage; + core1_load =load_per_core (core,VIDC_CORE_ID_1 ); + core2_load =load_per_core (core,VIDC_CORE_ID_2 ); + min_core_id = core1_load < core2_load ?VIDC_CORE_ID_1 :VIDC_CORE_ID_2 ; + min_load =min (core1_load, core2_load); + cores_max =core_num_max (inst); -return hfi_session_set_property (inst, ptype, &cu); +if (cores_max <VIDC_CORE_ID_2 ) { + min_core_id =VIDC_CORE_ID_1 ; + min_load = core1_load; + } + + cur_inst_load =load_per_instance (inst) * + inst->clk_data.codec_freq_data->vpp_freq; + max_freq = core->res->freq_tbl[0 ].freq; + +if ((cur_inst_load + min_load) > max_freq) { +dev_warn (core->dev,"HW is overloaded, needed: %lu max: %lu\n" , + cur_inst_load, max_freq); +return -EINVAL ; + } + + ret =set_core_usage (inst, min_core_id); +if (ret) +return ret; + + inst->clk_data.core_id = min_core_id; + +return 0 ; } -EXPORT_SYMBOL_GPL (venus_helper_set_core_usage); +EXPORT_SYMBOL_GPL (venus_helper_set_core);int venus_helper_init_codec_freq_data (struct venus_inst *inst) {
drivers/media/platform/qcom/venus/helpers.h +1 -1
@@ -42,7 +42,7 @@ int venus_helper_set_output_resolution(struct venus_inst *inst, u32 buftype);int venus_helper_set_work_mode (struct venus_inst *inst,u32 mode);int venus_helper_init_codec_freq_data (struct venus_inst *inst); -int venus_helper_set_core_usage (struct venus_inst *inst,u32 usage); +int venus_helper_set_core (struct venus_inst *inst);int venus_helper_set_num_bufs (struct venus_inst *inst,unsigned int input_bufs,unsigned int output_bufs,unsigned int output2_bufs);
drivers/media/platform/qcom/venus/hfi_helper.h +1 -0
@@ -559,6 +559,7 @@ struct hfi_bitrate {#define HFI_CAPABILITY_LCU_SIZE 0x14#define HFI_CAPABILITY_HIER_P_HYBRID_NUM_ENH_LAYERS 0x15#define HFI_CAPABILITY_MBS_PER_SECOND_POWERSAVE 0x16 +#define HFI_CAPABILITY_MAX_VIDEOCORES 0x2Bstruct hfi_capability {u32 capability_type;
drivers/media/platform/qcom/venus/hfi_parser.h +5 -0
@@ -107,4 +107,9 @@ static inline u32 frate_step(struct venus_inst *inst) return cap_step(inst, HFI_CAPABILITY_FRAMERATE); } +static inline u32 core_num_max (struct venus_inst *inst) +{ +return cap_max (inst,HFI_CAPABILITY_MAX_VIDEOCORES ); +} +#endif
drivers/media/platform/qcom/venus/vdec.c +1 -1
@@ -551,7 +551,7 @@ static int vdec_output_conf(struct venus_inst *inst)if (ret)return ret; - ret =venus_helper_set_core_usage (inst,VIDC_CORE_ID_1 ); + ret =venus_helper_set_core (inst);if (ret)return ret;
drivers/media/platform/qcom/venus/venc.c +1 -1
@@ -660,7 +660,7 @@ static int venc_set_properties(struct venus_inst *inst)if (ret)return ret; - ret =venus_helper_set_core_usage (inst,VIDC_CORE_ID_2 ); + ret =venus_helper_set_core (inst);if (ret)return ret;
Signature · 2 lines
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project
Re: [PATCH v6 4/4] media: venus: Update core selection
Hi,
Quoted 100 lines · Aniket Masule
Present core assignment is static. Introduced load balancing across the cores. Load on earch core is calculated and core with minimum load is assigned to given instance.
Signed-off-by Aniket Masule <[email protected]>--- drivers/media/platform/qcom/venus/helpers.c | 69 +++++++++++++++++++++++--- drivers/media/platform/qcom/venus/helpers.h | 2 +- drivers/media/platform/qcom/venus/hfi_helper.h | 1 + drivers/media/platform/qcom/venus/hfi_parser.h | 5 ++ drivers/media/platform/qcom/venus/vdec.c | 2 +- drivers/media/platform/qcom/venus/venc.c | 2 +- 6 files changed, 72 insertions(+), 9 deletions(-)drivers/media/platform/qcom/venus/helpers.c +46
-5@@ -26,6 +26,7 @@#include "helpers.h" #include "hfi_helper.h" #include "hfi_venus_io.h" +#include "hfi_parser.h" struct intbuf {struct list_head list;@@ -331,6 +332,24 @@ static u32 load_per_instance(struct venus_inst *inst)return mbs * inst->fps; } +static u32 load_per_core (struct venus_core *core,u32 core_id) +{ +struct venus_inst *inst =NULL ; +u32 mbs_per_sec =0 , load =0 ; + +mutex_lock (&core->lock); +list_for_each_entry (inst, &core->instances, list) { +if (inst->clk_data.core_id != core_id) +continue ; + + mbs_per_sec =load_per_instance (inst); + load += mbs_per_sec * inst->clk_data.codec_freq_data->vpp_freq; + } +mutex_unlock (&core->lock); + +return load; +} +static u32 load_per_type (struct venus_core *core,u32 session_type) {struct venus_inst *inst =NULL ;@@ -505,6 +524,16 @@ static int load_scale_clocks(struct venus_inst *inst)return scale_clocks (inst); } +int set_core_usage (struct venus_inst *inst,u32 usage) +{ +const u32 ptype =HFI_PROPERTY_CONFIG_VIDEOCORES_USAGE ; +struct hfi_videocores_usage_type cu; + + cu.video_core_enable_mask = usage; + +return hfi_session_set_property (inst, ptype, &cu); +} +static void fill_buffer_desc (const struct venus_buffer *buf,struct hfi_buffer_desc *bd,bool response) {@@ -808,19 +837,47 @@ int venus_helper_set_work_mode(struct venus_inst *inst, u32 mode) }EXPORT_SYMBOL_GPL (venus_helper_set_work_mode); -int venus_helper_set_core_usage (struct venus_inst *inst,u32 usage) +int venus_helper_set_core (struct venus_inst *inst) { -const u32 ptype =HFI_PROPERTY_CONFIG_VIDEOCORES_USAGE ; -struct hfi_videocores_usage_type cu; +struct venus_core *core = inst->core; +u32 min_core_id =0 , core1_load =0 , core2_load =0 ; +unsigned long min_load, max_freq, cur_inst_load; +u32 cores_max; +int ret;if (!IS_V4 (inst->core))return 0 ; - cu.video_core_enable_mask = usage; + core1_load =load_per_core (core,VIDC_CORE_ID_1 ); + core2_load =load_per_core (core,VIDC_CORE_ID_2 ); + min_core_id = core1_load < core2_load ?VIDC_CORE_ID_1 :VIDC_CORE_ID_2 ; + min_load =min (core1_load, core2_load); + cores_max =core_num_max (inst); -return hfi_session_set_property (inst, ptype, &cu); +if (cores_max <VIDC_CORE_ID_2 ) { + min_core_id =VIDC_CORE_ID_1 ; + min_load = core1_load; + } + + cur_inst_load = load_per_instance(inst) *
drivers/media/platform/qcom/venus/helpers.c int venus_helper_set_work_mode(struct venus_inst *inst, u32 mode) · line 872
Quoted 10 lines
drivers/media/platform/qcom/venus/helpers.c +10
-0+ inst->clk_data.codec_freq_data->vpp_freq; + max_freq = core->res->freq_tbl[0 ].freq; + +if ((cur_inst_load + min_load) > max_freq) { +dev_warn (core->dev,"HW is overloaded, needed: %lu max: %lu\n" , + cur_inst_load, max_freq); +return -EINVAL ; + } + + ret =set_core_usage (inst, min_core_id);
We have a problem here. Lets assume that we have only one running decoder session and the code above decides that it should be handled by core2, but core2 clocks presently are enabled only if there is an encoder session (see DT subnodes), thus we select core2 but without enabling core2 clocks and power domain.
Quoted 10 lines
drivers/media/platform/qcom/venus/helpers.c +7
-1+if (ret) +return ret; + + inst->clk_data.core_id = min_core_id; + +return 0 ; } -EXPORT_SYMBOL_GPL (venus_helper_set_core_usage); +EXPORT_SYMBOL_GPL (venus_helper_set_core);
Signature · 2 lines
regards, Stan
Re: [PATCH v6 4/4] media: venus: Update core selection
Hi,
Quoted 116 lines · Stanimir Varbanov
Hi,
Quoted 113 lines · Aniket Masule
Present core assignment is static. Introduced load balancing across the cores. Load on earch core is calculated and core with minimum load is assigned to given instance.
Signed-off-by Aniket Masule <[email protected]>--- drivers/media/platform/qcom/venus/helpers.c | 69 +++++++++++++++++++++++--- drivers/media/platform/qcom/venus/helpers.h | 2 +- drivers/media/platform/qcom/venus/hfi_helper.h | 1 + drivers/media/platform/qcom/venus/hfi_parser.h | 5 ++ drivers/media/platform/qcom/venus/vdec.c | 2 +- drivers/media/platform/qcom/venus/venc.c | 2 +- 6 files changed, 72 insertions(+), 9 deletions(-)drivers/media/platform/qcom/venus/helpers.c +19
-0@@ -26,6 +26,7 @@#include "helpers.h" #include "hfi_helper.h" #include "hfi_venus_io.h" +#include "hfi_parser.h" struct intbuf {struct list_head list;@@ -331,6 +332,24 @@ static u32 load_per_instance(struct venus_inst *inst)return mbs * inst->fps; } +static u32 load_per_core (struct venus_core *core,u32 core_id) +{ +struct venus_inst *inst =NULL ; +u32 mbs_per_sec =0 , load =0 ; + +mutex_lock (&core->lock); +list_for_each_entry (inst, &core->instances, list) { +if (inst->clk_data.core_id != core_id) +continue ; + + mbs_per_sec =load_per_instance (inst); + load += mbs_per_sec * inst->clk_data.codec_freq_data->vpp_freq; + } +mutex_unlock (&core->lock); + +return load; +} +static u32 load_per_type (struct venus_core *core,u32 session_type) {drivers/media/platform/qcom/venus/helpers.c +10
-0struct venus_inst *inst =NULL ;@@ -505,6 +524,16 @@ static int load_scale_clocks(struct venus_inst *inst)return scale_clocks (inst); } +int set_core_usage (struct venus_inst *inst,u32 usage) +{ +const u32 ptype =HFI_PROPERTY_CONFIG_VIDEOCORES_USAGE ; +struct hfi_videocores_usage_type cu; + + cu.video_core_enable_mask = usage; + +return hfi_session_set_property (inst, ptype, &cu); +} +static void fill_buffer_desc (const struct venus_buffer *buf,struct hfi_buffer_desc *bd,bool response){
drivers/media/platform/qcom/venus/helpers.c +25
-5@@ -808,19 +837,47 @@ int venus_helper_set_work_mode(struct venus_inst *inst, u32 mode) }EXPORT_SYMBOL_GPL (venus_helper_set_work_mode); -int venus_helper_set_core_usage (struct venus_inst *inst,u32 usage) +int venus_helper_set_core (struct venus_inst *inst) { -const u32 ptype =HFI_PROPERTY_CONFIG_VIDEOCORES_USAGE ; -struct hfi_videocores_usage_type cu; +struct venus_core *core = inst->core; +u32 min_core_id =0 , core1_load =0 , core2_load =0 ; +unsigned long min_load, max_freq, cur_inst_load; +u32 cores_max; +int ret;if (!IS_V4 (inst->core))return 0 ; - cu.video_core_enable_mask = usage; + core1_load =load_per_core (core,VIDC_CORE_ID_1 ); + core2_load =load_per_core (core,VIDC_CORE_ID_2 ); + min_core_id = core1_load < core2_load ?VIDC_CORE_ID_1 :VIDC_CORE_ID_2 ; + min_load =min (core1_load, core2_load); + cores_max =core_num_max (inst); -return hfi_session_set_property (inst, ptype, &cu); +if (cores_max <VIDC_CORE_ID_2 ) { + min_core_id =VIDC_CORE_ID_1 ; + min_load = core1_load; + } + + cur_inst_load =load_per_instance (inst) * + inst->clk_data.codec_freq_data->vpp_freq; + max_freq = core->res->freq_tbl[0 ].freq; + +if ((cur_inst_load + min_load) > max_freq) { +dev_warn (core->dev,"HW is overloaded, needed: %lu max: %lu\n" , + cur_inst_load, max_freq); +return -EINVAL ; + }
Quoted 9 lines
drivers/media/platform/qcom/venus/helpers.c int venus_helper_set_work_mode(struct venus_inst · line 874
Quoted 2 lines
drivers/media/platform/qcom/venus/helpers.c +2
-0+ + ret =set_core_usage (inst, min_core_id);We have a problem here. Lets assume that we have only one running decoder session and the code above decides that it should be handled by core2, but core2 clocks presently are enabled only if there is an encoder session (see DT subnodes), thus we select core2 but without enabling core2 clocks and power domain.
I will send a separate patch for core selection, once power domain issue is fixed.
Quoted 10 lines
drivers/media/platform/qcom/venus/helpers.c int venus_helper_set_work_mode(struct venus_inst *inst, u32 mode) · line 881
Quoted 10 lines
drivers/media/platform/qcom/venus/helpers.c +7
-1+if (ret) +return ret; + + inst->clk_data.core_id = min_core_id; + +return 0 ; } -EXPORT_SYMBOL_GPL (venus_helper_set_core_usage); +EXPORT_SYMBOL_GPL (venus_helper_set_core);
Regards,
Aniket