samsung-sm8650/android_kernel_samsung_sm8650-modules
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

video: driver: use char array for printing vidc logs

Browse Source 
Instead of formulating session_id, codec_type, domain at
each log print, used pre-formatted char array to print
the vidc logs.

Change-Id: If7a93ecb25a7b1b98ebca6f39e3990079c00b5dd
Signed-off-by: Govindaraj Rajagopal <grajagop@codeaurora.org>
This commit is contained in:
Govindaraj Rajagopal
2021-02-26 20:59:25 +05:30
parent df69c42511
commit e743f5dd48
17 changed files with 203 additions and 207 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
driver/variant/iris2/src/msm_vidc_buffer_iris2.c
View File

@@ -30,7 +30,7 @@ static u32 msm_vidc_decoder_bin_size_iris2(struct msm_vidc_inst *inst)
core = inst->core; core = inst->core;
if (!core->capabilities) { if (!core->capabilities) {
d_vpr_e("%s: invalid capabilities\n", __func__); i_vpr_e(inst, "%s: invalid capabilities\n", __func__);
return size; return size;
} }
num_vpp_pipes = core->capabilities[NUM_VPP_PIPE].value; num_vpp_pipes = core->capabilities[NUM_VPP_PIPE].value;
@@ -133,7 +133,7 @@ static u32 msm_vidc_decoder_line_size_iris2(struct msm_vidc_inst *inst)
} }
core = inst->core; core = inst->core;
if (!core->capabilities) { if (!core->capabilities) {
d_vpr_e("%s: invalid capabilities\n", __func__); i_vpr_e(inst, "%s: invalid capabilities\n", __func__);
return size; return size;
} }
num_vpp_pipes = core->capabilities[NUM_VPP_PIPE].value; num_vpp_pipes = core->capabilities[NUM_VPP_PIPE].value;

4
driver/variant/iris2/src/msm_vidc_iris2.c
View File

@@ -558,7 +558,7 @@ int msm_vidc_decide_work_mode_iris2(struct msm_vidc_inst* inst)
} }
} }
else { else {
d_vpr_e("%s: invalid session type\n", __func__); i_vpr_e(inst, "%s: invalid session type\n", __func__);
return -EINVAL; return -EINVAL;
} }
@@ -604,7 +604,7 @@ int msm_vidc_decide_work_route_iris2(struct msm_vidc_inst* inst)
work_route = MSM_VIDC_PIPE_1; work_route = MSM_VIDC_PIPE_1;
} else { } else {
d_vpr_e("%s: invalid session type\n", __func__); i_vpr_e(inst, "%s: invalid session type\n", __func__);
return -EINVAL; return -EINVAL;
} }

80
driver/vidc/inc/msm_vidc_debug.h
View File

@@ -18,7 +18,8 @@
#define VIDC_DBG_SESSION_RATELIMIT_INTERVAL (1 * HZ) #define VIDC_DBG_SESSION_RATELIMIT_INTERVAL (1 * HZ)
#define VIDC_DBG_SESSION_RATELIMIT_BURST 6 #define VIDC_DBG_SESSION_RATELIMIT_BURST 6
#define VIDC_DBG_TAG VIDC_DBG_LABEL ": %6s: %08x: %5s: " #define VIDC_DBG_TAG_INST VIDC_DBG_LABEL ": %4s: %s: "
#define VIDC_DBG_TAG_CORE VIDC_DBG_LABEL ": %4s: %08x: %s: "
#define FW_DBG_TAG VIDC_DBG_LABEL ": %6s: " #define FW_DBG_TAG VIDC_DBG_LABEL ": %6s: "
#define DEFAULT_SID ((u32)-1) #define DEFAULT_SID ((u32)-1)
@@ -56,64 +57,55 @@ enum vidc_msg_prio {
#define FW_LOGSHIFT 16 #define FW_LOGSHIFT 16
#define FW_LOGMASK 0x0FFF0000 #define FW_LOGMASK 0x0FFF0000
#define dprintk_inst(__level, inst, __fmt, ...) \ #define dprintk_inst(__level, __level_str, inst, __fmt, ...) \
do { \ do { \
if (inst && (msm_vidc_debug & __level)) { \ if (inst && (msm_vidc_debug & __level)) { \
pr_err(VIDC_DBG_TAG __fmt, \ pr_info(VIDC_DBG_TAG_INST __fmt, \
level_str(__level), \ __level_str, \
get_sid(inst), \ inst->debug_str, \
codec_str(inst), \
##__VA_ARGS__); \ ##__VA_ARGS__); \
} \ } \
} while (0) } while (0)
#define i_vpr_e(inst, __fmt, ...) dprintk_inst(VIDC_ERR, inst, __fmt, ##__VA_ARGS__) #define i_vpr_e(inst, __fmt, ...) dprintk_inst(VIDC_ERR, "err ", inst, __fmt, ##__VA_ARGS__)
#define i_vpr_i(inst, __fmt, ...) dprintk_inst(VIDC_HIGH, inst, __fmt, ##__VA_ARGS__) #define i_vpr_i(inst, __fmt, ...) dprintk_inst(VIDC_HIGH, "high", inst, __fmt, ##__VA_ARGS__)
#define i_vpr_h(inst, __fmt, ...) dprintk_inst(VIDC_HIGH, inst, __fmt, ##__VA_ARGS__) #define i_vpr_h(inst, __fmt, ...) dprintk_inst(VIDC_HIGH, "high", inst, __fmt, ##__VA_ARGS__)
#define i_vpr_l(inst, __fmt, ...) dprintk_inst(VIDC_LOW, inst, __fmt, ##__VA_ARGS__) #define i_vpr_l(inst, __fmt, ...) dprintk_inst(VIDC_LOW, "low ", inst, __fmt, ##__VA_ARGS__)
#define i_vpr_p(inst, __fmt, ...) dprintk_inst(VIDC_PERF, inst, __fmt, ##__VA_ARGS__) #define i_vpr_p(inst, __fmt, ...) dprintk_inst(VIDC_PERF, "perf", inst, __fmt, ##__VA_ARGS__)
#define i_vpr_t(inst, __fmt, ...) dprintk_inst(VIDC_PKT, inst, __fmt, ##__VA_ARGS__) #define i_vpr_t(inst, __fmt, ...) dprintk_inst(VIDC_PKT, "pkt ", inst, __fmt, ##__VA_ARGS__)
#define i_vpr_b(inst, __fmt, ...) dprintk_inst(VIDC_BUS, inst, __fmt, ##__VA_ARGS__) #define i_vpr_b(inst, __fmt, ...) dprintk_inst(VIDC_BUS, "bus ", inst, __fmt, ##__VA_ARGS__)
#define i_vpr_hp(inst, __fmt, ...) \
dprintk_inst(VIDC_HIGH | VIDC_PERF, inst, __fmt, ##__VA_ARGS__)
#define dprintk(__level, sid, __fmt, ...) \ #define dprintk_core(__level, __level_str, __fmt, ...) \
do { \ do { \
if (msm_vidc_debug & __level) { \ if (msm_vidc_debug & __level) { \
pr_err(VIDC_DBG_TAG __fmt, \ pr_info(VIDC_DBG_TAG_CORE __fmt, \
level_str(__level), \ __level_str, \
sid, \ DEFAULT_SID, \
"codec", \ "codec", \
##__VA_ARGS__); \ ##__VA_ARGS__); \
} \ } \
} while (0) } while (0)
#define d_vpr_e(__fmt, ...) \ #define d_vpr_e(__fmt, ...) dprintk_core(VIDC_ERR, "err ", __fmt, ##__VA_ARGS__)
dprintk(VIDC_ERR, DEFAULT_SID, __fmt, ##__VA_ARGS__) #define d_vpr_h(__fmt, ...) dprintk_core(VIDC_HIGH, "high", __fmt, ##__VA_ARGS__)
#define d_vpr_i(__fmt, ...) \ #define d_vpr_l(__fmt, ...) dprintk_core(VIDC_LOW, "low ", __fmt, ##__VA_ARGS__)
dprintk(VIDC_HIGH, DEFAULT_SID, __fmt, ##__VA_ARGS__) #define d_vpr_p(__fmt, ...) dprintk_core(VIDC_PERF, "perf", __fmt, ##__VA_ARGS__)
#define d_vpr_h(__fmt, ...) \ #define d_vpr_t(__fmt, ...) dprintk_core(VIDC_PKT, "pkt ", __fmt, ##__VA_ARGS__)
dprintk(VIDC_HIGH, DEFAULT_SID, __fmt, ##__VA_ARGS__) #define d_vpr_b(__fmt, ...) dprintk_core(VIDC_BUS, "bus ", __fmt, ##__VA_ARGS__)
#define d_vpr_l(__fmt, ...) \
dprintk(VIDC_LOW, DEFAULT_SID, __fmt, ##__VA_ARGS__) #define dprintk_ratelimit(__level, __level_str, __fmt, ...) \
#define d_vpr_p(__fmt, ...) \ do { \
dprintk(VIDC_PERF, DEFAULT_SID, __fmt, ##__VA_ARGS__) if (msm_vidc_check_ratelimit()) { \
#define d_vpr_t(__fmt, ...) \ dprintk_core(__level, __level_str, __fmt, ##__VA_ARGS__); \
dprintk(VIDC_PKT, DEFAULT_SID, __fmt, ##__VA_ARGS__) } \
#define d_vpr_b(__fmt, ...) \ } while (0)
dprintk(VIDC_BUS, DEFAULT_SID, __fmt, ##__VA_ARGS__)
#define dprintk_firmware(__level, __fmt, ...) \ #define dprintk_firmware(__level, __fmt, ...) \
do { \ do { \
pr_err(FW_DBG_TAG __fmt, \ if (__level & FW_PRINTK) { \
"fw", \ pr_info(FW_DBG_TAG __fmt, \
##__VA_ARGS__); \ "fw", \
} while (0) ##__VA_ARGS__); \
#define dprintk_ratelimit(__level, __fmt, ...) \
do { \
if (msm_vidc_check_ratelimit()) { \
dprintk(__level, DEFAULT_SID, __fmt, ##__VA_ARGS__); \
} \ } \
} while (0) } while (0)
@@ -122,10 +114,6 @@ enum vidc_msg_prio {
d_vpr_e("BugOn"); \ d_vpr_e("BugOn"); \
} while (0) } while (0)
const char *level_str(u32 level);
const char *codec_str(void *instance);
u32 get_sid(void *instance);
enum msm_vidc_debugfs_event { enum msm_vidc_debugfs_event {
MSM_VIDC_DEBUGFS_EVENT_ETB, MSM_VIDC_DEBUGFS_EVENT_ETB,
MSM_VIDC_DEBUGFS_EVENT_EBD, MSM_VIDC_DEBUGFS_EVENT_EBD,

3
driver/vidc/inc/msm_vidc_driver.h
View File

@@ -183,7 +183,7 @@ static inline bool is_session_error(struct msm_vidc_inst* inst)
return inst->state == MSM_VIDC_ERROR; return inst->state == MSM_VIDC_ERROR;
} }
void print_vidc_buffer(u32 tag, const char *str, struct msm_vidc_inst *inst, void print_vidc_buffer(u32 tag, const char *tag_str, const char *str, struct msm_vidc_inst *inst,
struct msm_vidc_buffer *vbuf); struct msm_vidc_buffer *vbuf);
void print_vb2_buffer(const char *str, struct msm_vidc_inst *inst, void print_vb2_buffer(const char *str, struct msm_vidc_inst *inst,
struct vb2_buffer *vb2); struct vb2_buffer *vb2);
@@ -307,5 +307,6 @@ int msm_vidc_init_core_caps(struct msm_vidc_core* core);
int msm_vidc_init_instance_caps(struct msm_vidc_core* core); int msm_vidc_init_instance_caps(struct msm_vidc_core* core);
int msm_vidc_deinit_core_caps(struct msm_vidc_core* core); int msm_vidc_deinit_core_caps(struct msm_vidc_core* core);
int msm_vidc_deinit_instance_caps(struct msm_vidc_core* core); int msm_vidc_deinit_instance_caps(struct msm_vidc_core* core);
int msm_vidc_update_debug_str(struct msm_vidc_inst *inst);
#endif // _MSM_VIDC_DRIVER_H_ #endif // _MSM_VIDC_DRIVER_H_

2
driver/vidc/inc/msm_vidc_inst.h
View File

@@ -92,7 +92,7 @@ struct msm_vidc_inst {
void *core; void *core;
struct kref kref; struct kref kref;
u32 session_id; u32 session_id;
u32 sid; u8 debug_str[24];
void *packet; void *packet;
u32 packet_size; u32 packet_size;
struct v4l2_format fmts[MAX_PORT]; struct v4l2_format fmts[MAX_PORT];

6
driver/vidc/src/hfi_packet.c
View File

@@ -167,7 +167,7 @@ u32 get_hfi_codec(struct msm_vidc_inst *inst)
case MSM_VIDC_VP9: case MSM_VIDC_VP9:
return HFI_CODEC_DECODE_VP9; return HFI_CODEC_DECODE_VP9;
default: default:
d_vpr_e("invalid codec %d, domain %d\n", i_vpr_e(inst, "invalid codec %d, domain %d\n",
inst->codec, inst->domain); inst->codec, inst->domain);
return 0; return 0;
} }
@@ -614,11 +614,11 @@ int hfi_packet_session_command(struct msm_vidc_inst *inst,
if (rc) if (rc)
goto err_cmd; goto err_cmd;
d_vpr_h("Command packet 0x%x created\n", pkt_type); i_vpr_h(inst, "Command packet 0x%x created\n", pkt_type);
return rc; return rc;
err_cmd: err_cmd:
d_vpr_e("%s: create packet failed\n", __func__); i_vpr_e(inst, "%s: create packet failed\n", __func__);
return rc; return rc;
} }

36
driver/vidc/src/msm_vdec.c
View File

@@ -66,6 +66,10 @@ static int msm_vdec_codec_change(struct msm_vidc_inst *inst, u32 v4l2_codec)
__func__, inst->fmts[INPUT_PORT].fmt.pix_mp.pixelformat, v4l2_codec); __func__, inst->fmts[INPUT_PORT].fmt.pix_mp.pixelformat, v4l2_codec);
inst->codec = v4l2_codec_to_driver(v4l2_codec, __func__); inst->codec = v4l2_codec_to_driver(v4l2_codec, __func__);
rc = msm_vidc_update_debug_str(inst);
if (rc)
goto exit;
rc = msm_vidc_get_inst_capability(inst); rc = msm_vidc_get_inst_capability(inst);
if (rc) if (rc)
goto exit; goto exit;
@@ -1003,7 +1007,7 @@ static int msm_vdec_subscribe_input_port_settings_change(struct msm_vidc_inst *i
return -EINVAL; return -EINVAL;
} }
core = inst->core; core = inst->core;
d_vpr_h("%s()\n", __func__); i_vpr_h(inst, "%s()\n", __func__);
payload[0] = HFI_MODE_PORT_SETTINGS_CHANGE; payload[0] = HFI_MODE_PORT_SETTINGS_CHANGE;
if (inst->codec == MSM_VIDC_H264) { if (inst->codec == MSM_VIDC_H264) {
@@ -1016,13 +1020,13 @@ static int msm_vdec_subscribe_input_port_settings_change(struct msm_vidc_inst *i
subscribe_psc_size = ARRAY_SIZE(msm_vdec_subscribe_for_psc_vp9); subscribe_psc_size = ARRAY_SIZE(msm_vdec_subscribe_for_psc_vp9);
psc = msm_vdec_subscribe_for_psc_vp9; psc = msm_vdec_subscribe_for_psc_vp9;
} else { } else {
d_vpr_e("%s: unsupported codec: %d\n", __func__, inst->codec); i_vpr_e(inst, "%s: unsupported codec: %d\n", __func__, inst->codec);
psc = NULL; psc = NULL;
return -EINVAL; return -EINVAL;
} }
if (!psc || !subscribe_psc_size) { if (!psc || !subscribe_psc_size) {
d_vpr_e("%s: invalid params\n", __func__); i_vpr_e(inst, "%s: invalid params\n", __func__);
return -EINVAL; return -EINVAL;
} }
@@ -1070,7 +1074,7 @@ static int msm_vdec_subscribe_input_port_settings_change(struct msm_vidc_inst *i
rc = msm_vdec_set_tier(inst, port); rc = msm_vdec_set_tier(inst, port);
break; break;
default: default:
d_vpr_e("%s: unknown property %#x\n", __func__, i_vpr_e(inst, "%s: unknown property %#x\n", __func__,
psc[i]); psc[i]);
rc = -EINVAL; rc = -EINVAL;
break; break;
@@ -1097,7 +1101,7 @@ static int msm_vdec_subscribe_property(struct msm_vidc_inst *inst,
return -EINVAL; return -EINVAL;
} }
core = inst->core; core = inst->core;
d_vpr_h("%s()\n", __func__); i_vpr_h(inst, "%s()\n", __func__);
payload[0] = HFI_MODE_PROPERTY; payload[0] = HFI_MODE_PROPERTY;
for (i = 0; i < ARRAY_SIZE(msm_vdec_subscribe_for_properties); i++) for (i = 0; i < ARRAY_SIZE(msm_vdec_subscribe_for_properties); i++)
@@ -1141,7 +1145,7 @@ static int msm_vdec_subscribe_metadata(struct msm_vidc_inst *inst,
return -EINVAL; return -EINVAL;
} }
core = inst->core; core = inst->core;
d_vpr_h("%s()\n", __func__); i_vpr_h(inst, "%s()\n", __func__);
capability = inst->capabilities; capability = inst->capabilities;
payload[0] = HFI_MODE_METADATA; payload[0] = HFI_MODE_METADATA;
@@ -1183,7 +1187,7 @@ static int msm_vdec_set_delivery_mode_metadata(struct msm_vidc_inst *inst,
return -EINVAL; return -EINVAL;
} }
core = inst->core; core = inst->core;
d_vpr_h("%s()\n", __func__); i_vpr_h(inst, "%s()\n", __func__);
capability = inst->capabilities; capability = inst->capabilities;
payload[0] = HFI_MODE_METADATA; payload[0] = HFI_MODE_METADATA;
@@ -1217,7 +1221,7 @@ static int msm_vdec_session_resume(struct msm_vidc_inst *inst,
d_vpr_e("%s: invalid params\n", __func__); d_vpr_e("%s: invalid params\n", __func__);
return -EINVAL; return -EINVAL;
} }
d_vpr_h("%s()\n", __func__); i_vpr_h(inst, "%s()\n", __func__);
rc = venus_hfi_session_command(inst, rc = venus_hfi_session_command(inst,
HFI_CMD_RESUME, HFI_CMD_RESUME,
@@ -1491,7 +1495,11 @@ static int msm_vdec_subscribe_output_port_settings_change(struct msm_vidc_inst *
u32 subscribe_psc_size = 0; u32 subscribe_psc_size = 0;
u32 *psc = NULL; u32 *psc = NULL;
d_vpr_h("%s()\n", __func__); if (!inst) {
d_vpr_e("%s: invalid params\n", __func__);
return -EINVAL;
}
i_vpr_h(inst, "%s()\n", __func__);
payload[0] = HFI_MODE_PORT_SETTINGS_CHANGE; payload[0] = HFI_MODE_PORT_SETTINGS_CHANGE;
if (inst->codec == MSM_VIDC_H264) { if (inst->codec == MSM_VIDC_H264) {
@@ -1504,13 +1512,13 @@ static int msm_vdec_subscribe_output_port_settings_change(struct msm_vidc_inst *
subscribe_psc_size = ARRAY_SIZE(msm_vdec_subscribe_for_psc_vp9); subscribe_psc_size = ARRAY_SIZE(msm_vdec_subscribe_for_psc_vp9);
psc = msm_vdec_subscribe_for_psc_vp9; psc = msm_vdec_subscribe_for_psc_vp9;
} else { } else {
d_vpr_e("%s: unsupported codec: %d\n", __func__, inst->codec); i_vpr_e(inst, "%s: unsupported codec: %d\n", __func__, inst->codec);
psc = NULL; psc = NULL;
return -EINVAL; return -EINVAL;
} }
if (!psc || !subscribe_psc_size) { if (!psc || !subscribe_psc_size) {
d_vpr_e("%s: invalid params\n", __func__); i_vpr_e(inst, "%s: invalid params\n", __func__);
return -EINVAL; return -EINVAL;
} }
@@ -1586,7 +1594,7 @@ static int msm_vdec_subscribe_output_port_settings_change(struct msm_vidc_inst *
payload_type = HFI_PAYLOAD_U32; payload_type = HFI_PAYLOAD_U32;
break; break;
default: default:
d_vpr_e("%s: unknown property %#x\n", __func__, i_vpr_e(inst, "%s: unknown property %#x\n", __func__,
prop_type); prop_type);
prop_type = 0; prop_type = 0;
rc = -EINVAL; rc = -EINVAL;
@@ -1680,7 +1688,7 @@ static int msm_vdec_qbuf_batch(struct msm_vidc_inst *inst,
d_vpr_e("%s: invalid params\n", __func__); d_vpr_e("%s: invalid params\n", __func__);
return -EINVAL; return -EINVAL;
} }
d_vpr_h("%s()\n", __func__); i_vpr_h(inst, "%s()\n", __func__);
return rc; return rc;
} }
@@ -1745,7 +1753,7 @@ int msm_vdec_process_cmd(struct msm_vidc_inst *inst, u32 cmd)
if (rc) if (rc)
return rc; return rc;
} else { } else {
d_vpr_e("%s: unknown cmd %d\n", __func__, cmd); i_vpr_e(inst, "%s: unknown cmd %d\n", __func__, cmd);
return -EINVAL; return -EINVAL;
} }

14
driver/vidc/src/msm_venc.c
View File

@@ -52,6 +52,10 @@ static int msm_venc_codec_change(struct msm_vidc_inst *inst, u32 v4l2_codec)
__func__, inst->fmts[OUTPUT_PORT].fmt.pix_mp.pixelformat, v4l2_codec); __func__, inst->fmts[OUTPUT_PORT].fmt.pix_mp.pixelformat, v4l2_codec);
inst->codec = v4l2_codec_to_driver(v4l2_codec, __func__); inst->codec = v4l2_codec_to_driver(v4l2_codec, __func__);
rc = msm_vidc_update_debug_str(inst);
if (rc)
goto exit;
rc = msm_vidc_get_inst_capability(inst); rc = msm_vidc_get_inst_capability(inst);
if (rc) if (rc)
goto exit; goto exit;
@@ -476,7 +480,7 @@ static int msm_venc_set_input_properties(struct msm_vidc_inst *inst)
rc = msm_venc_set_colorspace(inst, INPUT_PORT); rc = msm_venc_set_colorspace(inst, INPUT_PORT);
break; break;
default: default:
d_vpr_e("%s: unknown property %#x\n", __func__, i_vpr_e(inst, "%s: unknown property %#x\n", __func__,
msm_venc_input_set_prop[i]); msm_venc_input_set_prop[i]);
rc = -EINVAL; rc = -EINVAL;
break; break;
@@ -517,7 +521,7 @@ static int msm_venc_set_output_properties(struct msm_vidc_inst *inst)
rc = msm_venc_set_csc(inst, OUTPUT_PORT); rc = msm_venc_set_csc(inst, OUTPUT_PORT);
break; break;
default: default:
d_vpr_e("%s: unknown property %#x\n", __func__, i_vpr_e(inst, "%s: unknown property %#x\n", __func__,
msm_venc_output_set_prop[i]); msm_venc_output_set_prop[i]);
rc = -EINVAL; rc = -EINVAL;
break; break;
@@ -997,7 +1001,7 @@ int msm_venc_process_cmd(struct msm_vidc_inst *inst, u32 cmd)
if (rc) if (rc)
return rc; return rc;
} else { } else {
d_vpr_e("%s: unknown cmd %d\n", __func__, cmd); i_vpr_e(inst, "%s: unknown cmd %d\n", __func__, cmd);
return -EINVAL; return -EINVAL;
} }
return 0; return 0;
@@ -1712,13 +1716,13 @@ int msm_venc_inst_init(struct msm_vidc_inst *inst)
struct msm_vidc_core *core; struct msm_vidc_core *core;
struct v4l2_format *f; struct v4l2_format *f;
d_vpr_h("%s()\n", __func__);
if (!inst || !inst->core) { if (!inst || !inst->core) {
d_vpr_e("%s: invalid params\n", __func__); d_vpr_e("%s: invalid params\n", __func__);
return -EINVAL; return -EINVAL;
} }
core = inst->core; i_vpr_h(inst, "%s()\n", __func__);
core = inst->core;
f = &inst->fmts[OUTPUT_PORT]; f = &inst->fmts[OUTPUT_PORT];
f->type = OUTPUT_MPLANE; f->type = OUTPUT_MPLANE;
f->fmt.pix_mp.width = DEFAULT_WIDTH; f->fmt.pix_mp.width = DEFAULT_WIDTH;

20
driver/vidc/src/msm_vidc.c
View File

@@ -3,6 +3,8 @@
* Copyright (c) 2020, The Linux Foundation. All rights reserved. * Copyright (c) 2020, The Linux Foundation. All rights reserved.
*/ */
#include <linux/types.h>
#include <linux/hash.h>
#include "msm_vidc.h" #include "msm_vidc.h"
#include "msm_vidc_core.h" #include "msm_vidc_core.h"
#include "msm_vidc_inst.h" #include "msm_vidc_inst.h"
@@ -710,14 +712,22 @@ void *msm_vidc_open(void *vidc_core, u32 session_type)
return NULL; return NULL;
} }
inst->core = core; inst->core = core;
inst->domain = session_type;
inst->session_id = hash32_ptr(inst);
inst->state = MSM_VIDC_OPEN;
inst->active = true;
inst->request = false;
inst->ipsc_properties_set = false;
inst->opsc_properties_set = false;
kref_init(&inst->kref); kref_init(&inst->kref);
mutex_init(&inst->lock); mutex_init(&inst->lock);
msm_vidc_update_debug_str(inst);
i_vpr_h(inst, "Opening video instance: %d\n", session_type); i_vpr_h(inst, "Opening video instance: %d\n", session_type);
inst->response_workq = create_singlethread_workqueue("response_workq"); inst->response_workq = create_singlethread_workqueue("response_workq");
if (!inst->response_workq) { if (!inst->response_workq) {
d_vpr_e("%s: create input_psc_workq failed\n", __func__); i_vpr_e(inst, "%s: create input_psc_workq failed\n", __func__);
goto error; goto error;
} }
@@ -767,12 +777,6 @@ void *msm_vidc_open(void *vidc_core, u32 session_type)
INIT_LIST_HEAD(&inst->mappings.vpss.list); INIT_LIST_HEAD(&inst->mappings.vpss.list);
INIT_LIST_HEAD(&inst->children.list); INIT_LIST_HEAD(&inst->children.list);
INIT_LIST_HEAD(&inst->firmware.list); INIT_LIST_HEAD(&inst->firmware.list);
inst->domain = session_type;
inst->state = MSM_VIDC_OPEN;
inst->active = true;
inst->request = false;
inst->ipsc_properties_set = false;
inst->opsc_properties_set = false;
for (i = 0; i < MAX_SIGNAL; i++) for (i = 0; i < MAX_SIGNAL; i++)
init_completion(&inst->completions[i]); init_completion(&inst->completions[i]);
@@ -793,7 +797,7 @@ void *msm_vidc_open(void *vidc_core, u32 session_type)
rc = msm_vidc_add_session(inst); rc = msm_vidc_add_session(inst);
if (rc) { if (rc) {
d_vpr_e("%s: failed to get session id\n", __func__); i_vpr_e(inst, "%s: failed to get session id\n", __func__);
goto error; goto error;
} }
msm_vidc_scale_power(inst, true); msm_vidc_scale_power(inst, true);

2
driver/vidc/src/msm_vidc_buffer.c
View File

@@ -186,7 +186,7 @@ u32 msm_vidc_internal_buffer_count(struct msm_vidc_inst *inst,
else else
count = 0; count = 0;
} else { } else {
d_vpr_e("%s: unsupported buffer type %#x\n", i_vpr_e(inst, "%s: unsupported buffer type %#x\n",
__func__, buffer_type); __func__, buffer_type);
count = 0; count = 0;
} }

4
driver/vidc/src/msm_vidc_control.c
View File

@@ -1143,13 +1143,13 @@ int msm_vidc_adjust_v4l2_properties(struct msm_vidc_inst *inst)
struct msm_vidc_inst_cap_entry *curr_node = NULL, *tmp_node = NULL; struct msm_vidc_inst_cap_entry *curr_node = NULL, *tmp_node = NULL;
struct msm_vidc_inst_capability *capability; struct msm_vidc_inst_capability *capability;
d_vpr_h("%s()\n", __func__);
if (!inst || !inst->capabilities) { if (!inst || !inst->capabilities) {
d_vpr_e("%s: invalid params\n", __func__); d_vpr_e("%s: invalid params\n", __func__);
return -EINVAL; return -EINVAL;
} }
capability = inst->capabilities; capability = inst->capabilities;
i_vpr_h(inst, "%s()\n", __func__);
for (i = 0; i < INST_CAP_MAX; i++) { for (i = 0; i < INST_CAP_MAX; i++) {
if (capability->cap[i].flags & CAP_FLAG_ROOT) { if (capability->cap[i].flags & CAP_FLAG_ROOT) {
rc = msm_vidc_adjust_property(inst, rc = msm_vidc_adjust_property(inst,
@@ -1719,11 +1719,11 @@ int msm_vidc_set_v4l2_properties(struct msm_vidc_inst *inst)
struct msm_vidc_inst_capability *capability; struct msm_vidc_inst_capability *capability;
struct msm_vidc_inst_cap_entry *curr_node = NULL, *tmp_node = NULL; struct msm_vidc_inst_cap_entry *curr_node = NULL, *tmp_node = NULL;
d_vpr_h("%s()\n", __func__);
if (!inst || !inst->capabilities) { if (!inst || !inst->capabilities) {
d_vpr_e("%s: invalid params\n", __func__); d_vpr_e("%s: invalid params\n", __func__);
return -EINVAL; return -EINVAL;
} }
i_vpr_h(inst, "%s()\n", __func__);
capability = inst->capabilities; capability = inst->capabilities;
list_for_each_entry_safe(curr_node, tmp_node, list_for_each_entry_safe(curr_node, tmp_node,

57
driver/vidc/src/msm_vidc_debug.c
View File

@@ -25,61 +25,6 @@ EXPORT_SYMBOL(msm_vidc_syscache_disable);
int msm_vidc_clock_voting = !1; int msm_vidc_clock_voting = !1;
const char *level_str(u32 level)
{
if (level & VIDC_ERR)
return "err ";
else if (level & VIDC_HIGH)
return "high";
else if (level & VIDC_LOW)
return "low ";
else if (level & VIDC_PERF)
return "perf";
else if (level & VIDC_PKT)
return "pkt ";
else if (level & VIDC_BUS)
return "bus ";
else
return "????";
}
const char *codec_str(void *instance)
{
struct msm_vidc_inst *inst = (struct msm_vidc_inst *) instance;
if (!inst) {
d_vpr_e("%s: invalid params\n", __func__);
goto err_invalid_inst;
}
if (inst->codec == MSM_VIDC_H264)
return "h264 ";
else if (inst->codec == MSM_VIDC_HEVC)
return "hevc ";
else if (inst->codec == MSM_VIDC_VP9)
return "vp9 ";
else
return "?????";
err_invalid_inst:
return "null ";
}
u32 get_sid(void *instance)
{
struct msm_vidc_inst *inst = (struct msm_vidc_inst *) instance;
if (!inst) {
d_vpr_e("%s: invalid params\n", __func__);
goto err_invalid_inst;
}
return inst->sid;
err_invalid_inst:
return 0;
}
#define MAX_DBG_BUF_SIZE 4096 #define MAX_DBG_BUF_SIZE 4096
struct core_inst_pair { struct core_inst_pair {
@@ -442,7 +387,7 @@ struct dentry *msm_vidc_debugfs_init_inst(void *instance, struct dentry *parent)
d_vpr_e("%s: invalid params\n", __func__); d_vpr_e("%s: invalid params\n", __func__);
goto exit; goto exit;
} }
snprintf(debugfs_name, MAX_DEBUGFS_NAME, "inst_%d", inst->sid); snprintf(debugfs_name, MAX_DEBUGFS_NAME, "inst_%d", inst->session_id);
idata = kzalloc(sizeof(struct core_inst_pair), GFP_KERNEL); idata = kzalloc(sizeof(struct core_inst_pair), GFP_KERNEL);
if (!idata) { if (!idata) {

97
driver/vidc/src/msm_vidc_driver.c
View File

@@ -5,7 +5,6 @@
#include <linux/iommu.h> #include <linux/iommu.h>
#include <linux/workqueue.h> #include <linux/workqueue.h>
#include <linux/hash.h>
#include <media/v4l2_vidc_extensions.h> #include <media/v4l2_vidc_extensions.h>
#include "msm_media_info.h" #include "msm_media_info.h"
@@ -34,14 +33,14 @@ struct msm_vidc_buf_details {
char *name; char *name;
}; };
void print_vidc_buffer(u32 tag, const char *str, struct msm_vidc_inst *inst, void print_vidc_buffer(u32 tag, const char *tag_str, const char *str, struct msm_vidc_inst *inst,
struct msm_vidc_buffer *vbuf) struct msm_vidc_buffer *vbuf)
{ {
if (!(tag & msm_vidc_debug) || !inst || !vbuf) if (!(tag & msm_vidc_debug) || !inst || !vbuf || !tag_str || !str)
return; return;
if (vbuf->type == MSM_VIDC_BUF_INPUT || vbuf->type == MSM_VIDC_BUF_OUTPUT) { if (vbuf->type == MSM_VIDC_BUF_INPUT || vbuf->type == MSM_VIDC_BUF_OUTPUT) {
dprintk(tag, inst->sid, 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", "%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", str, vbuf->type == MSM_VIDC_BUF_INPUT ? "INPUT" : "OUTPUT",
vbuf->index, vbuf->fd, vbuf->data_offset, vbuf->index, vbuf->fd, vbuf->data_offset,
@@ -49,7 +48,7 @@ void print_vidc_buffer(u32 tag, const char *str, struct msm_vidc_inst *inst,
vbuf->flags, vbuf->timestamp, vbuf->attr); vbuf->flags, vbuf->timestamp, vbuf->attr);
} else if (vbuf->type == MSM_VIDC_BUF_INPUT_META || } else if (vbuf->type == MSM_VIDC_BUF_INPUT_META ||
vbuf->type == MSM_VIDC_BUF_OUTPUT_META) { vbuf->type == MSM_VIDC_BUF_OUTPUT_META) {
dprintk(tag, inst->sid, 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", "%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", str, vbuf->type == MSM_VIDC_BUF_INPUT_META ? "INPUT_META" : "OUTPUT_META",
vbuf->index, vbuf->fd, vbuf->data_offset, vbuf->index, vbuf->fd, vbuf->data_offset,
@@ -1205,13 +1204,13 @@ int msm_vidc_unmap_driver_buf(struct msm_vidc_inst *inst,
} }
} }
if (!found) { if (!found) {
print_vidc_buffer(VIDC_ERR, "no buf in mappings", inst, buf); print_vidc_buffer(VIDC_ERR, "err ", "no buf in mappings", inst, buf);
return -EINVAL; return -EINVAL;
} }
rc = msm_vidc_memory_unmap(inst->core, map); rc = msm_vidc_memory_unmap(inst->core, map);
if (rc) { if (rc) {
print_vidc_buffer(VIDC_ERR, "unmap failed", inst, buf); print_vidc_buffer(VIDC_ERR, "err ", "unmap failed", inst, buf);
return -EINVAL; return -EINVAL;
} }
@@ -1340,14 +1339,14 @@ struct msm_vidc_buffer *msm_vidc_get_driver_buf(struct msm_vidc_inst *inst,
/* only YUV buffers are allowed to repeat */ /* only YUV buffers are allowed to repeat */
if ((is_decode_session(inst) && vb2->type != OUTPUT_MPLANE) || if ((is_decode_session(inst) && vb2->type != OUTPUT_MPLANE) ||
(is_encode_session(inst) && vb2->type != INPUT_MPLANE)) { (is_encode_session(inst) && vb2->type != INPUT_MPLANE)) {
print_vidc_buffer(VIDC_ERR, print_vidc_buffer(VIDC_ERR, "err ",
"existing buffer", inst, buf); "existing buffer", inst, buf);
goto error; goto error;
} }
/* for decoder, YUV with RO flag are allowed to repeat */ /* for decoder, YUV with RO flag are allowed to repeat */
if (is_decode_session(inst) && if (is_decode_session(inst) &&
!(buf->attr & MSM_VIDC_ATTR_READ_ONLY)) { !(buf->attr & MSM_VIDC_ATTR_READ_ONLY)) {
print_vidc_buffer(VIDC_ERR, print_vidc_buffer(VIDC_ERR, "err ",
"existing buffer without RO flag", inst, buf); "existing buffer without RO flag", inst, buf);
goto error; goto error;
} }
@@ -1455,7 +1454,8 @@ int msm_vidc_queue_buffer(struct msm_vidc_inst *inst, struct vb2_buffer *vb2)
if (buf->type == MSM_VIDC_BUF_INPUT_META || if (buf->type == MSM_VIDC_BUF_INPUT_META ||
buf->type == MSM_VIDC_BUF_OUTPUT_META) { buf->type == MSM_VIDC_BUF_OUTPUT_META) {
buf->attr |= MSM_VIDC_ATTR_DEFERRED; buf->attr |= MSM_VIDC_ATTR_DEFERRED;
print_vidc_buffer(VIDC_HIGH, "qbuf deferred", inst, buf); i_vpr_h(inst, "%s: %s_META qbuf deferred\n", __func__,
buf->type == MSM_VIDC_BUF_INPUT_META ? "INPUT" : "OUTPUT");
return 0; return 0;
} }
@@ -1465,7 +1465,7 @@ int msm_vidc_queue_buffer(struct msm_vidc_inst *inst, struct vb2_buffer *vb2)
return -EINVAL; return -EINVAL;
if (!inst->vb2q[port].streaming) { if (!inst->vb2q[port].streaming) {
buf->attr |= MSM_VIDC_ATTR_DEFERRED; buf->attr |= MSM_VIDC_ATTR_DEFERRED;
print_vidc_buffer(VIDC_HIGH, "qbuf deferred", inst, buf); print_vidc_buffer(VIDC_HIGH, "high", "qbuf deferred", inst, buf);
return 0; return 0;
} }
@@ -1480,15 +1480,16 @@ int msm_vidc_queue_buffer(struct msm_vidc_inst *inst, struct vb2_buffer *vb2)
msm_vidc_scale_power(inst, true); msm_vidc_scale_power(inst, true);
} }
print_vidc_buffer(VIDC_HIGH, "qbuf", inst, buf); print_vidc_buffer(VIDC_HIGH, "high", "qbuf", inst, buf);
meta = get_meta_buffer(inst, buf); meta = get_meta_buffer(inst, buf);
if (!meta) { if (meta)
if (is_meta_enabled(inst, buf->type)) { print_vidc_buffer(VIDC_HIGH, "high", "qbuf", inst, meta);
print_vidc_buffer(VIDC_ERR, "missing meta for",
inst, buf); if (!meta && is_meta_enabled(inst, buf->type)) {
return -EINVAL; print_vidc_buffer(VIDC_ERR, "err ", "missing meta for", inst, buf);
} return -EINVAL;
} }
if (msm_vidc_is_super_buffer(inst) && is_input_buffer(buf->type)) if (msm_vidc_is_super_buffer(inst) && is_input_buffer(buf->type))
rc = venus_hfi_queue_super_buffer(inst, buf, meta); rc = venus_hfi_queue_super_buffer(inst, buf, meta);
else else
@@ -1898,7 +1899,7 @@ int msm_vidc_vb2_buffer_done(struct msm_vidc_inst *inst,
} }
} }
if (!found) { if (!found) {
print_vidc_buffer(VIDC_ERR, "vb2 not found for", inst, buf); print_vidc_buffer(VIDC_ERR, "err ", "vb2 not found for", inst, buf);
return -EINVAL; return -EINVAL;
} }
vbuf = to_vb2_v4l2_buffer(vb2); vbuf = to_vb2_v4l2_buffer(vb2);
@@ -2061,16 +2062,12 @@ int msm_vidc_add_session(struct msm_vidc_inst *inst)
if (count < 0xffffff /*TODO: MAX_SUPPORTED_INSTANCES*/) { if (count < 0xffffff /*TODO: MAX_SUPPORTED_INSTANCES*/) {
list_add_tail(&inst->list, &core->instances); list_add_tail(&inst->list, &core->instances);
} else { } else {
d_vpr_e("%s: total sessions %d exceeded max limit %d\n", i_vpr_e(inst, "%s: total sessions %d exceeded max limit %d\n",
__func__, count, MAX_SUPPORTED_INSTANCES); __func__, count, MAX_SUPPORTED_INSTANCES);
rc = -EINVAL; rc = -EINVAL;
} }
core_unlock(core, __func__); core_unlock(core, __func__);
/* assign session_id */
inst->session_id = hash32_ptr(inst);
inst->sid = inst->session_id;
return rc; return rc;
} }
@@ -2090,14 +2087,13 @@ int msm_vidc_remove_session(struct msm_vidc_inst *inst)
list_for_each_entry_safe(i, temp, &core->instances, list) { list_for_each_entry_safe(i, temp, &core->instances, list) {
if (i->session_id == inst->session_id) { if (i->session_id == inst->session_id) {
list_del_init(&i->list); list_del_init(&i->list);
d_vpr_h("%s: removed session %#x\n", i_vpr_h(inst, "%s: removed session %#x\n",
__func__, i->session_id); __func__, i->session_id);
inst->sid = 0;
} }
} }
list_for_each_entry(i, &core->instances, list) list_for_each_entry(i, &core->instances, list)
count++; count++;
d_vpr_h("%s: remaining sessions %d\n", __func__, count); i_vpr_h(inst, "%s: remaining sessions %d\n", __func__, count);
core_unlock(core, __func__); core_unlock(core, __func__);
return 0; return 0;
@@ -2325,7 +2321,6 @@ int msm_vidc_get_inst_capability(struct msm_vidc_inst *inst)
int i; int i;
struct msm_vidc_core *core; struct msm_vidc_core *core;
d_vpr_h("%s()\n", __func__);
if (!inst || !inst->core || !inst->capabilities) { if (!inst || !inst->core || !inst->capabilities) {
d_vpr_e("%s: invalid params\n", __func__); d_vpr_e("%s: invalid params\n", __func__);
return -EINVAL; return -EINVAL;
@@ -2556,7 +2551,7 @@ int msm_vidc_core_deinit(struct msm_vidc_core *core, bool force)
} }
core_lock(core, __func__); core_lock(core, __func__);
d_vpr_h("%s()\n", __func__); d_vpr_h("%s(): force %u\n", __func__, force);
if (core->state == MSM_VIDC_CORE_DEINIT) if (core->state == MSM_VIDC_CORE_DEINIT)
goto unlock; goto unlock;
@@ -2743,7 +2738,7 @@ int msm_vidc_smmu_fault_handler(struct iommu_domain *domain,
if (core->smmu_fault_handled) { if (core->smmu_fault_handled) {
if (core->capabilities[NON_FATAL_FAULTS].value) { if (core->capabilities[NON_FATAL_FAULTS].value) {
dprintk_ratelimit(VIDC_ERR, dprintk_ratelimit(VIDC_ERR, "err ",
"%s: non-fatal pagefault address: %lx\n", "%s: non-fatal pagefault address: %lx\n",
__func__, iova); __func__, iova);
return 0; return 0;
@@ -2837,7 +2832,7 @@ int msm_vidc_flush_buffers(struct msm_vidc_inst* inst,
list_for_each_entry_safe(buf, dummy, &buffers->list, list) { list_for_each_entry_safe(buf, dummy, &buffers->list, list) {
if (buf->attr & MSM_VIDC_ATTR_QUEUED || if (buf->attr & MSM_VIDC_ATTR_QUEUED ||
buf->attr & MSM_VIDC_ATTR_DEFERRED) { buf->attr & MSM_VIDC_ATTR_DEFERRED) {
print_vidc_buffer(VIDC_ERR, "flushing buffer", inst, buf); print_vidc_buffer(VIDC_ERR, "err ", "flushing buffer", inst, buf);
msm_vidc_vb2_buffer_done(inst, buf); msm_vidc_vb2_buffer_done(inst, buf);
msm_vidc_put_driver_buf(inst, buf); msm_vidc_put_driver_buf(inst, buf);
} }
@@ -3063,3 +3058,43 @@ void msm_vidc_schedule_core_deinit(struct msm_vidc_core *core)
return; return;
} }
static const char *get_codec_str(enum msm_vidc_codec_type type)
{
switch (type) {
case MSM_VIDC_H264: return "h264";
case MSM_VIDC_HEVC: return "h265";
case MSM_VIDC_VP9: return " vp9";
}
return "....";
}
static const char *get_domain_str(enum msm_vidc_domain_type type)
{
switch (type) {
case MSM_VIDC_ENCODER: return "e";
case MSM_VIDC_DECODER: return "d";
}
return ".";
}
int msm_vidc_update_debug_str(struct msm_vidc_inst *inst)
{
u32 sid;
const char *codec;
const char *domain;
if (!inst) {
d_vpr_e("%s: Invalid params\n", __func__);
return -EINVAL;
}
sid = inst->session_id;
codec = get_codec_str(inst->codec);
domain = get_domain_str(inst->domain);
snprintf(inst->debug_str, sizeof(inst->debug_str), "%08x: %s%s", sid, codec, domain);
d_vpr_h("%s: sid: %08x, codec: %s, domain: %s, final: %s\n",
__func__, sid, codec, domain, inst->debug_str);
return 0;
}

4
driver/vidc/src/msm_vidc_power.c
View File

@@ -221,7 +221,7 @@ int msm_vidc_scale_buses(struct msm_vidc_inst *inst)
} }
core = inst->core; core = inst->core;
if (!core->dt) { if (!core->dt) {
d_vpr_e("%s: invalid dt params\n", __func__); i_vpr_e(inst, "%s: invalid dt params\n", __func__);
return -EINVAL; return -EINVAL;
} }
vote_data = &inst->bus_data; vote_data = &inst->bus_data;
@@ -401,7 +401,7 @@ int msm_vidc_set_clocks(struct msm_vidc_inst* inst)
} }
core->power.clk_freq = (u32)rate; core->power.clk_freq = (u32)rate;
d_vpr_p("%s: clock rate %lu requested %lu increment %d decrement %d\n", i_vpr_p(inst, "%s: clock rate %lu requested %lu increment %d decrement %d\n",
__func__, rate, freq, increment, decrement); __func__, rate, freq, increment, decrement);
mutex_unlock(&core->lock); mutex_unlock(&core->lock);

2
driver/vidc/src/msm_vidc_vb2.c
View File

@@ -87,7 +87,7 @@ int msm_vidc_queue_setup(struct vb2_queue *q,
} }
if (inst->state == MSM_VIDC_START) { if (inst->state == MSM_VIDC_START) {
d_vpr_e("%s: invalid state %d\n", __func__, inst->state); i_vpr_e(inst, "%s: invalid state %d\n", __func__, inst->state);
return -EINVAL; return -EINVAL;
} }

48
driver/vidc/src/venus_hfi.c
View File

@@ -138,22 +138,40 @@ void __dump(struct dump dump[], int len)
} }
} }
static void __dump_packet(u8 *packet) static void __dump_packet(u8 *packet, const char *function, void *qinfo)
{ {
u32 c = 0, packet_size = *(u32 *)packet; u32 c = 0, session_id, packet_size = *(u32 *)packet;
const int row_size = 32; const int row_size = 32;
struct msm_vidc_inst *inst = NULL;
bool matches = false;
/* /*
* row must contain enough for 0xdeadbaad * 8 to be converted into * row must contain enough for 0xdeadbaad * 8 to be converted into
* "de ad ba ab " * 8 + '\0' * "de ad ba ab " * 8 + '\0'
*/ */
char row[3 * 32]; char row[3 * 32];
session_id = *((u32 *)packet + 1);
list_for_each_entry(inst, &g_core->instances, list) {
if (inst->session_id == session_id) {
matches = true;
break;
}
}
if (matches)
i_vpr_t(inst, "%s: %pK\n", function, qinfo);
else
d_vpr_t("%s: %pK\n", function, qinfo);
for (c = 0; c * row_size < packet_size; ++c) { for (c = 0; c * row_size < packet_size; ++c) {
int bytes_to_read = ((c + 1) * row_size > packet_size) ? int bytes_to_read = ((c + 1) * row_size > packet_size) ?
packet_size % row_size : row_size; packet_size % row_size : row_size;
hex_dump_to_buffer(packet + c * row_size, bytes_to_read, hex_dump_to_buffer(packet + c * row_size, bytes_to_read,
row_size, 4, row, sizeof(row), false); row_size, 4, row, sizeof(row), false);
d_vpr_t("%s\n", row); if (matches)
i_vpr_t(inst, "%s\n", row);
else
d_vpr_t("%s\n", row);
} }
} }
@@ -185,7 +203,7 @@ static bool __valdiate_session(struct msm_vidc_core *core,
bool valid = false; bool valid = false;
struct msm_vidc_inst *temp; struct msm_vidc_inst *temp;
if (!core) if (!core || !inst)
return false; return false;
__strict_check(core); __strict_check(core);
@@ -461,11 +479,11 @@ static int __vote_bandwidth(struct bus_info *bus,
{ {
int rc = 0; int rc = 0;
d_vpr_p("Voting bus %s to ab %llu kbps\n", bus->name, bw_kbps); d_vpr_p("Voting bus %s to ab %llu kbps\n", bus->name, kbps_to_icc(bw_kbps));
rc = icc_set_bw(bus->path, kbps_to_icc(bw_kbps), 0); rc = icc_set_bw(bus->path, kbps_to_icc(bw_kbps), 0);
if (rc) if (rc)
d_vpr_e("Failed voting bus %s to ab %llu, rc=%d\n", d_vpr_e("Failed voting bus %s to ab %llu, rc=%d\n",
bus->name, bw_kbps, rc); bus->name, kbps_to_icc(bw_kbps), rc);
return rc; return rc;
} }
@@ -560,6 +578,7 @@ static int __set_clk_rate(struct msm_vidc_core *core,
if (rate == cl->prev) if (rate == cl->prev)
return 0; return 0;
d_vpr_p("Scaling clock %s to %llu, prev %llu\n", cl->name, rate, cl->prev);
rc = clk_set_rate(clk, rate); rc = clk_set_rate(clk, rate);
if (rc) { if (rc) {
d_vpr_e("%s: Failed to set clock rate %llu %s: %d\n", d_vpr_e("%s: Failed to set clock rate %llu %s: %d\n",
@@ -577,8 +596,6 @@ static int __set_clocks(struct msm_vidc_core *core, u32 freq)
venus_hfi_for_each_clock(core, cl) { venus_hfi_for_each_clock(core, cl) {
if (cl->has_scaling) {/* has_scaling */ if (cl->has_scaling) {/* has_scaling */
d_vpr_h("Scaling clock %s to %u, prev %llu\n",
cl->name, freq, cl->prev);
rc = __set_clk_rate(core, cl, freq); rc = __set_clk_rate(core, cl, freq);
if (rc) if (rc)
return rc; return rc;
@@ -629,10 +646,9 @@ static int __write_queue(struct msm_vidc_iface_q_info *qinfo, u8 *packet,
return -ENOENT; return -ENOENT;
} }
if (msm_vidc_debug & VIDC_PKT) { if (msm_vidc_debug & VIDC_PKT)
d_vpr_t("%s: %pK\n", __func__, qinfo); __dump_packet(packet, __func__, qinfo);
__dump_packet(packet);
}
// TODO: handle writing packet // TODO: handle writing packet
//d_vpr_e("skip writing packet\n"); //d_vpr_e("skip writing packet\n");
@@ -706,7 +722,6 @@ static int __read_queue(struct msm_vidc_iface_q_info *qinfo, u8 *packet,
u32 receive_request = 0; u32 receive_request = 0;
u32 read_idx, write_idx; u32 read_idx, write_idx;
int rc = 0; int rc = 0;
u32 sid;
if (!qinfo || !packet || !pb_tx_req_is_set) { if (!qinfo || !packet || !pb_tx_req_is_set) {
d_vpr_e("%s: invalid params %pK %pK %pK\n", d_vpr_e("%s: invalid params %pK %pK %pK\n",
@@ -813,9 +828,7 @@ static int __read_queue(struct msm_vidc_iface_q_info *qinfo, u8 *packet,
if ((msm_vidc_debug & VIDC_PKT) && if ((msm_vidc_debug & VIDC_PKT) &&
!(queue->qhdr_type & HFI_Q_ID_CTRL_TO_HOST_DEBUG_Q)) { !(queue->qhdr_type & HFI_Q_ID_CTRL_TO_HOST_DEBUG_Q)) {
sid = *((u32 *)packet + 2); __dump_packet(packet, __func__, qinfo);
d_vpr_t("%s: %pK\n", __func__, qinfo);
__dump_packet(packet);
} }
return rc; return rc;
@@ -2530,8 +2543,6 @@ irqreturn_t venus_hfi_isr(int irq, void *data)
{ {
struct msm_vidc_core *core = data; struct msm_vidc_core *core = data;
d_vpr_l("%s()\n", __func__);
disable_irq_nosync(irq); disable_irq_nosync(irq);
queue_work(core->device_workq, &core->device_work); queue_work(core->device_workq, &core->device_work);
@@ -2543,6 +2554,7 @@ void venus_hfi_work_handler(struct work_struct *work)
struct msm_vidc_core *core; struct msm_vidc_core *core;
int num_responses = 0; int num_responses = 0;
d_vpr_l("%s()\n", __func__);
core = container_of(work, struct msm_vidc_core, device_work); core = container_of(work, struct msm_vidc_core, device_work);
if (!core) { if (!core) {
d_vpr_e("%s: invalid params\n", __func__); d_vpr_e("%s: invalid params\n", __func__);

27
driver/vidc/src/venus_hfi_response.c
View File

@@ -19,13 +19,13 @@ struct msm_vidc_hfi_range {
int (*handle)(struct msm_vidc_inst *inst, struct hfi_packet *pkt); int (*handle)(struct msm_vidc_inst *inst, struct hfi_packet *pkt);
}; };
void print_psc_properties(u32 tag, const char *str, struct msm_vidc_inst *inst, void print_psc_properties(const char *str, struct msm_vidc_inst *inst,
struct msm_vidc_subscription_params subsc_params) struct msm_vidc_subscription_params subsc_params)
{ {
if (!(tag & msm_vidc_debug) || !inst) if (!inst || !str)
return; return;
dprintk(tag, inst->sid, i_vpr_h(inst,
"%s: resolution %#x, crop offsets[0] %#x, crop offsets[1] %#x, bit depth %d, coded frames %d " "%s: resolution %#x, crop offsets[0] %#x, crop offsets[1] %#x, bit depth %d, coded frames %d "
"fw min count %d, poc %d, color info %d, profile %d, level %d, tier %d ", "fw min count %d, poc %d, color info %d, profile %d, level %d, tier %d ",
str, subsc_params.bitstream_resolution, str, subsc_params.bitstream_resolution,
@@ -483,7 +483,7 @@ static int handle_input_buffer(struct msm_vidc_inst *inst,
buf->flags = 0; buf->flags = 0;
buf->flags = get_driver_buffer_flags(inst, buffer->flags); buf->flags = get_driver_buffer_flags(inst, buffer->flags);
print_vidc_buffer(VIDC_HIGH, "EBD", inst, buf); print_vidc_buffer(VIDC_HIGH, "high", "dqbuf", inst, buf);
msm_vidc_debugfs_update(inst, MSM_VIDC_DEBUGFS_EVENT_EBD); msm_vidc_debugfs_update(inst, MSM_VIDC_DEBUGFS_EVENT_EBD);
return rc; return rc;
@@ -554,7 +554,7 @@ static int handle_output_buffer(struct msm_vidc_inst *inst,
buf->flags = 0; buf->flags = 0;
buf->flags = get_driver_buffer_flags(inst, buffer->flags); buf->flags = get_driver_buffer_flags(inst, buffer->flags);
print_vidc_buffer(VIDC_HIGH, "FBD", inst, buf); print_vidc_buffer(VIDC_HIGH, "high", "dqbuf", inst, buf);
msm_vidc_debugfs_update(inst, MSM_VIDC_DEBUGFS_EVENT_FBD); msm_vidc_debugfs_update(inst, MSM_VIDC_DEBUGFS_EVENT_FBD);
return rc; return rc;
@@ -607,7 +607,7 @@ static int handle_input_metadata_buffer(struct msm_vidc_inst *inst,
if (buffer->flags & HFI_BUF_FW_FLAG_LAST) if (buffer->flags & HFI_BUF_FW_FLAG_LAST)
buf->flags |= MSM_VIDC_BUF_FLAG_LAST; buf->flags |= MSM_VIDC_BUF_FLAG_LAST;
print_vidc_buffer(VIDC_HIGH, "EBD META", inst, buf); print_vidc_buffer(VIDC_HIGH, "high", "dqbuf", inst, buf);
return rc; return rc;
} }
@@ -643,7 +643,7 @@ static int handle_output_metadata_buffer(struct msm_vidc_inst *inst,
if (buffer->flags & HFI_BUF_FW_FLAG_LAST) if (buffer->flags & HFI_BUF_FW_FLAG_LAST)
buf->flags |= MSM_VIDC_BUF_FLAG_LAST; buf->flags |= MSM_VIDC_BUF_FLAG_LAST;
print_vidc_buffer(VIDC_HIGH, "FBD META", inst, buf); print_vidc_buffer(VIDC_HIGH, "high", "dqbuf", inst, buf);
return rc; return rc;
} }
@@ -675,7 +675,8 @@ static int handle_dequeue_buffers(struct msm_vidc_inst* inst)
*/ */
if ((buf->attr & MSM_VIDC_ATTR_BUFFER_DONE) && if ((buf->attr & MSM_VIDC_ATTR_BUFFER_DONE) &&
buf->attr & MSM_VIDC_ATTR_READ_ONLY){ buf->attr & MSM_VIDC_ATTR_READ_ONLY){
print_vidc_buffer(VIDC_HIGH, "vb2 done already", inst, buf); print_vidc_buffer(VIDC_HIGH, "high",
"vb2 done already", inst, buf);
} else { } else {
buf->attr |= MSM_VIDC_ATTR_BUFFER_DONE; buf->attr |= MSM_VIDC_ATTR_BUFFER_DONE;
msm_vidc_vb2_buffer_done(inst, buf); msm_vidc_vb2_buffer_done(inst, buf);
@@ -1004,12 +1005,10 @@ static int handle_port_settings_change(struct msm_vidc_inst *inst,
__func__, pkt->port); __func__, pkt->port);
if (pkt->port == HFI_PORT_RAW) { if (pkt->port == HFI_PORT_RAW) {
print_psc_properties(VIDC_HIGH, "OUTPUT_PSC", inst, print_psc_properties("OUTPUT_PSC", inst, inst->subcr_params[OUTPUT_PORT]);
inst->subcr_params[OUTPUT_PORT]);
rc = msm_vdec_output_port_settings_change(inst); rc = msm_vdec_output_port_settings_change(inst);
} else if (pkt->port == HFI_PORT_BITSTREAM) { } else if (pkt->port == HFI_PORT_BITSTREAM) {
print_psc_properties(VIDC_HIGH, "INPUT_PSC", inst, print_psc_properties("INPUT_PSC", inst, inst->subcr_params[INPUT_PORT]);
inst->subcr_params[INPUT_PORT]);
rc = msm_vdec_input_port_settings_change(inst); rc = msm_vdec_input_port_settings_change(inst);
} else { } else {
i_vpr_e(inst, "%s: invalid port type: %#x\n", i_vpr_e(inst, "%s: invalid port type: %#x\n",
@@ -1283,7 +1282,7 @@ int handle_session_response_work(struct msm_vidc_inst *inst,
hdr = (struct hfi_header *)resp_work->data; hdr = (struct hfi_header *)resp_work->data;
if (!hdr) { if (!hdr) {
d_vpr_e("%s: invalid params\n", __func__); i_vpr_e(inst, "%s: invalid params\n", __func__);
return -EINVAL; return -EINVAL;
} }
@@ -1392,7 +1391,7 @@ void handle_session_response_work_handler(struct work_struct *work)
} }
break; break;
default: default:
d_vpr_e("%s: invalid response work type %d\n", __func__, i_vpr_e(inst, "%s: invalid response work type %d\n", __func__,
resp_work->type); resp_work->type);
break; break;
} }