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

video: driver: Use vzalloc instead of kzalloc

Browse Source 
kzalloc might fail to allocate physically contiguous
memory which may not be available always and hence use
vzalloc to allocate virtually contiguous memory

Change-Id: I8ad89ef107da301217f3d1ec307b9b27b4edd2de
Signed-off-by: Deepa Guthyappa Madivalara <quic_dmadival@quicinc.com>
This commit is contained in:
Deepa Guthyappa Madivalara
2022-05-20 14:12:23 -07:00
parent e95d1dcf89
commit 13d203ba7f
12 changed files with 154 additions and 164 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
driver/platform/common/src/msm_vidc_platform.c
View File

@@ -342,7 +342,7 @@ int msm_vidc_deinit_platform(struct platform_device *pdev)
msm_vidc_deinit_vpu(core, &pdev->dev); msm_vidc_deinit_vpu(core, &pdev->dev);
msm_vidc_deinit_platform_variant(core, &pdev->dev); msm_vidc_deinit_platform_variant(core, &pdev->dev);
kfree(core->platform); msm_vidc_vmem_free((void **)&core->platform);
return 0; return 0;
} }
@@ -366,9 +366,10 @@ int msm_vidc_init_platform(struct platform_device *pdev)
return -EINVAL; return -EINVAL;
} }
platform = kzalloc(sizeof(struct msm_vidc_platform), GFP_KERNEL); rc = msm_vidc_vmem_alloc(sizeof(struct msm_vidc_platform),
if (!platform) (void **)&platform, __func__);
return -ENOMEM; if (rc)
return rc;
core->platform = platform; core->platform = platform;
platform->core = core; platform->core = core;

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

@@ -63,5 +63,6 @@ void msm_memory_pools_deinit(struct msm_vidc_inst *inst);
void *msm_memory_pool_alloc(struct msm_vidc_inst *inst, void *msm_memory_pool_alloc(struct msm_vidc_inst *inst,
enum msm_memory_pool_type type); enum msm_memory_pool_type type);
void msm_memory_pool_free(struct msm_vidc_inst *inst, void *vidc_buf); void msm_memory_pool_free(struct msm_vidc_inst *inst, void *vidc_buf);
int msm_vidc_vmem_alloc(unsigned long size, void **mem, const char *msg);
void msm_vidc_vmem_free(void **addr);
#endif // _MSM_VIDC_MEMORY_H_ #endif // _MSM_VIDC_MEMORY_H_

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

@@ -881,11 +881,10 @@ void *msm_vidc_open(void *vidc_core, u32 session_type)
if (rc) if (rc)
return NULL; return NULL;
inst = kzalloc(sizeof(*inst), GFP_KERNEL); rc = msm_vidc_vmem_alloc(sizeof(*inst), (void **)&inst, "inst memory");
if (!inst) { if (rc)
d_vpr_e("%s: failed to allocate inst memory\n", __func__);
return NULL; return NULL;
}
inst->core = core; inst->core = core;
inst->domain = session_type; inst->domain = session_type;
inst->session_id = hash32_ptr(inst); inst->session_id = hash32_ptr(inst);
@@ -905,7 +904,7 @@ void *msm_vidc_open(void *vidc_core, u32 session_type)
rc = msm_memory_pools_init(inst); rc = msm_memory_pools_init(inst);
if (rc) { if (rc) {
i_vpr_e(inst, "%s: failed to init pool buffers\n", __func__); i_vpr_e(inst, "%s: failed to init pool buffers\n", __func__);
kfree(inst); msm_vidc_vmem_free((void **)&inst);
return NULL; return NULL;
} }
INIT_LIST_HEAD(&inst->response_works); INIT_LIST_HEAD(&inst->response_works);
@@ -969,12 +968,10 @@ void *msm_vidc_open(void *vidc_core, u32 session_type)
INIT_DELAYED_WORK(&inst->stats_work, msm_vidc_stats_handler); INIT_DELAYED_WORK(&inst->stats_work, msm_vidc_stats_handler);
INIT_WORK(&inst->stability_work, msm_vidc_stability_handler); INIT_WORK(&inst->stability_work, msm_vidc_stability_handler);
inst->capabilities = kzalloc(sizeof(struct msm_vidc_inst_capability), GFP_KERNEL); rc = msm_vidc_vmem_alloc(sizeof(struct msm_vidc_inst_capability),
if (!inst->capabilities) { (void **)&inst->capabilities, "inst capability");
i_vpr_e(inst, if (rc)
"%s: inst capability allocation failed\n", __func__);
goto error; goto error;
}
rc = msm_vidc_event_queue_init(inst); rc = msm_vidc_event_queue_init(inst);
if (rc) if (rc)

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

@@ -254,19 +254,19 @@ static inline bool is_all_parents_visited(
static int add_node_list(struct list_head *list, enum msm_vidc_inst_capability_type cap_id) static int add_node_list(struct list_head *list, enum msm_vidc_inst_capability_type cap_id)
{ {
int rc = 0;
struct msm_vidc_inst_cap_entry *entry; struct msm_vidc_inst_cap_entry *entry;
entry = kzalloc(sizeof(struct msm_vidc_inst_cap_entry), GFP_KERNEL); rc = msm_vidc_vmem_alloc(sizeof(struct msm_vidc_inst_cap_entry),
if (!entry) { (void **)&entry, __func__);
d_vpr_e("%s: msm_vidc_inst_cap_entry alloc failed\n", __func__); if (rc)
return -EINVAL; return rc;
}
INIT_LIST_HEAD(&entry->list); INIT_LIST_HEAD(&entry->list);
entry->cap_id = cap_id; entry->cap_id = cap_id;
list_add_tail(&entry->list, list); list_add_tail(&entry->list, list);
return 0; return rc;
} }
static int add_node( static int add_node(
@@ -696,7 +696,7 @@ static int msm_vidc_adjust_dynamic_property(struct msm_vidc_inst *inst,
} }
list_del_init(&entry->list); list_del_init(&entry->list);
kfree(entry); msm_vidc_vmem_free((void **)&entry);
} }
/* expecting children_list to be empty */ /* expecting children_list to be empty */
@@ -711,12 +711,12 @@ error:
list_for_each_entry_safe(entry, temp, &inst->children_list, list) { list_for_each_entry_safe(entry, temp, &inst->children_list, list) {
i_vpr_e(inst, "%s: child list: %s\n", __func__, cap_name(entry->cap_id)); i_vpr_e(inst, "%s: child list: %s\n", __func__, cap_name(entry->cap_id));
list_del_init(&entry->list); list_del_init(&entry->list);
kfree(entry); msm_vidc_vmem_free((void **)&entry);
} }
list_for_each_entry_safe(entry, temp, &inst->firmware_list, list) { list_for_each_entry_safe(entry, temp, &inst->firmware_list, list) {
i_vpr_e(inst, "%s: fw list: %s\n", __func__, cap_name(entry->cap_id)); i_vpr_e(inst, "%s: fw list: %s\n", __func__, cap_name(entry->cap_id));
list_del_init(&entry->list); list_del_init(&entry->list);
kfree(entry); msm_vidc_vmem_free((void **)&entry);
} }
return rc; return rc;
@@ -739,7 +739,7 @@ static int msm_vidc_set_dynamic_property(struct msm_vidc_inst *inst)
goto error; goto error;
list_del_init(&entry->list); list_del_init(&entry->list);
kfree(entry); msm_vidc_vmem_free((void **)&entry);
} }
return 0; return 0;
@@ -747,7 +747,7 @@ error:
list_for_each_entry_safe(entry, temp, &inst->firmware_list, list) { list_for_each_entry_safe(entry, temp, &inst->firmware_list, list) {
i_vpr_e(inst, "%s: fw list: %s\n", __func__, cap_name(entry->cap_id)); i_vpr_e(inst, "%s: fw list: %s\n", __func__, cap_name(entry->cap_id));
list_del_init(&entry->list); list_del_init(&entry->list);
kfree(entry); msm_vidc_vmem_free((void **)&entry);
} }
return rc; return rc;
@@ -771,7 +771,7 @@ int msm_vidc_ctrl_deinit(struct msm_vidc_inst *inst)
i_vpr_h(inst, "%s(): num ctrls %d\n", __func__, inst->num_ctrls); i_vpr_h(inst, "%s(): num ctrls %d\n", __func__, inst->num_ctrls);
v4l2_ctrl_handler_free(&inst->ctrl_handler); v4l2_ctrl_handler_free(&inst->ctrl_handler);
memset(&inst->ctrl_handler, 0, sizeof(struct v4l2_ctrl_handler)); memset(&inst->ctrl_handler, 0, sizeof(struct v4l2_ctrl_handler));
kfree(inst->ctrls); msm_vidc_vmem_free((void **)&inst->ctrls);
inst->ctrls = NULL; inst->ctrls = NULL;
return 0; return 0;
@@ -807,12 +807,10 @@ int msm_vidc_ctrl_init(struct msm_vidc_inst *inst)
__func__); __func__);
return -EINVAL; return -EINVAL;
} }
inst->ctrls = kcalloc(num_ctrls, rc = msm_vidc_vmem_alloc(num_ctrls * sizeof(struct v4l2_ctrl *),
sizeof(struct v4l2_ctrl *), GFP_KERNEL); (void **)&inst->ctrls, __func__);
if (!inst->ctrls) { if (rc)
i_vpr_e(inst, "%s: failed to allocate ctrl\n", __func__); return rc;
return -ENOMEM;
}
rc = v4l2_ctrl_handler_init(&inst->ctrl_handler, num_ctrls); rc = v4l2_ctrl_handler_init(&inst->ctrl_handler, num_ctrls);
if (rc) { if (rc) {
@@ -3165,12 +3163,12 @@ error:
list_for_each_entry_safe(entry, temp, &opt_list, list) { list_for_each_entry_safe(entry, temp, &opt_list, list) {
i_vpr_e(inst, "%s: opt_list: %s\n", __func__, cap_name(entry->cap_id)); i_vpr_e(inst, "%s: opt_list: %s\n", __func__, cap_name(entry->cap_id));
list_del_init(&entry->list); list_del_init(&entry->list);
kfree(entry); msm_vidc_vmem_free((void **)&entry);
} }
list_for_each_entry_safe(entry, temp, &root_list, list) { list_for_each_entry_safe(entry, temp, &root_list, list) {
i_vpr_e(inst, "%s: root_list: %s\n", __func__, cap_name(entry->cap_id)); i_vpr_e(inst, "%s: root_list: %s\n", __func__, cap_name(entry->cap_id));
list_del_init(&entry->list); list_del_init(&entry->list);
kfree(entry); msm_vidc_vmem_free((void **)&entry);
} }
return rc; return rc;
} }

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

@@ -167,17 +167,17 @@ static ssize_t core_info_read(struct file* file, char __user* buf,
struct msm_vidc_core *core = file->private_data; struct msm_vidc_core *core = file->private_data;
char* dbuf, * cur, * end; char* dbuf, * cur, * end;
ssize_t len = 0; ssize_t len = 0;
int rc = 0;
if (!core || !core->dt) { if (!core || !core->dt) {
d_vpr_e("%s: invalid params %pK\n", __func__, core); d_vpr_e("%s: invalid params %pK\n", __func__, core);
return 0; return 0;
} }
dbuf = kzalloc(MAX_DBG_BUF_SIZE, GFP_KERNEL); rc = msm_vidc_vmem_alloc(MAX_DBG_BUF_SIZE, (void **)&dbuf, __func__);
if (!dbuf) { if (rc)
d_vpr_e("%s: Allocation failed!\n", __func__); return rc;
return -ENOMEM;
}
cur = dbuf; cur = dbuf;
end = cur + MAX_DBG_BUF_SIZE; end = cur + MAX_DBG_BUF_SIZE;
@@ -194,7 +194,7 @@ static ssize_t core_info_read(struct file* file, char __user* buf,
len = simple_read_from_buffer(buf, count, ppos, len = simple_read_from_buffer(buf, count, ppos,
dbuf, cur - dbuf); dbuf, cur - dbuf);
kfree(dbuf); msm_vidc_vmem_free((void **)&dbuf);
return len; return len;
} }
@@ -452,9 +452,7 @@ static ssize_t inst_info_read(struct file *file, char __user *buf,
return 0; return 0;
} }
dbuf = kzalloc(MAX_DBG_BUF_SIZE, GFP_KERNEL); if (msm_vidc_vmem_alloc(MAX_DBG_BUF_SIZE, (void **) &dbuf, __func__)) {
if (!dbuf) {
i_vpr_e(inst, "%s: Allocation failed!\n", __func__);
len = -ENOMEM; len = -ENOMEM;
goto failed_alloc; goto failed_alloc;
} }
@@ -510,7 +508,7 @@ static ssize_t inst_info_read(struct file *file, char __user *buf,
len = simple_read_from_buffer(buf, count, ppos, len = simple_read_from_buffer(buf, count, ppos,
dbuf, cur - dbuf); dbuf, cur - dbuf);
kfree(dbuf); msm_vidc_vmem_free((void **)&dbuf);
failed_alloc: failed_alloc:
put_inst(inst); put_inst(inst);
return len; return len;
@@ -542,11 +540,8 @@ struct dentry *msm_vidc_debugfs_init_inst(void *instance, struct dentry *parent)
} }
snprintf(debugfs_name, MAX_DEBUGFS_NAME, "inst_%d", inst->session_id); snprintf(debugfs_name, MAX_DEBUGFS_NAME, "inst_%d", inst->session_id);
idata = kzalloc(sizeof(struct core_inst_pair), GFP_KERNEL); if (msm_vidc_vmem_alloc(sizeof(struct core_inst_pair), (void **)&idata, __func__))
if (!idata) {
i_vpr_e(inst, "%s: Allocation failed!\n", __func__);
goto exit; goto exit;
}
idata->core = inst->core; idata->core = inst->core;
idata->inst = inst; idata->inst = inst;
@@ -576,7 +571,7 @@ failed_create_file:
debugfs_remove_recursive(dir); debugfs_remove_recursive(dir);
dir = NULL; dir = NULL;
failed_create_dir: failed_create_dir:
kfree(idata); msm_vidc_vmem_free((void **)&idata);
exit: exit:
return dir; return dir;
} }
@@ -593,7 +588,7 @@ void msm_vidc_debugfs_deinit_inst(void *instance)
if (dentry->d_inode) { if (dentry->d_inode) {
i_vpr_l(inst, "%s: Destroy %pK\n", i_vpr_l(inst, "%s: Destroy %pK\n",
__func__, dentry->d_inode->i_private); __func__, dentry->d_inode->i_private);
kfree(dentry->d_inode->i_private); msm_vidc_vmem_free(&dentry->d_inode->i_private);
dentry->d_inode->i_private = NULL; dentry->d_inode->i_private = NULL;
} }
debugfs_remove_recursive(dentry); debugfs_remove_recursive(dentry);

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

@@ -1767,8 +1767,8 @@ static int msm_vidc_flush_pending_last_flag(struct msm_vidc_inst *inst)
return rc; return rc;
} }
list_del(&resp_work->list); list_del(&resp_work->list);
kfree(resp_work->data); msm_vidc_vmem_free((void **)&resp_work->data);
kfree(resp_work); msm_vidc_vmem_free((void **)&resp_work);
} }
} }
@@ -1794,8 +1794,8 @@ static int msm_vidc_discard_pending_opsc(struct msm_vidc_inst *inst)
i_vpr_h(inst, i_vpr_h(inst,
"%s: discard pending output psc\n", __func__); "%s: discard pending output psc\n", __func__);
list_del(&resp_work->list); list_del(&resp_work->list);
kfree(resp_work->data); msm_vidc_vmem_free((void **)&resp_work->data);
kfree(resp_work); msm_vidc_vmem_free((void **)&resp_work);
} }
} }
@@ -1825,8 +1825,8 @@ static int msm_vidc_discard_pending_ipsc(struct msm_vidc_inst *inst)
inst->ipsc_properties_set = false; inst->ipsc_properties_set = false;
list_del(&resp_work->list); list_del(&resp_work->list);
kfree(resp_work->data); msm_vidc_vmem_free((void **)&resp_work->data);
kfree(resp_work); msm_vidc_vmem_free((void **)&resp_work);
} }
} }
@@ -1863,8 +1863,8 @@ static int msm_vidc_process_pending_ipsc(struct msm_vidc_inst *inst,
} }
} }
list_del(&resp_work->list); list_del(&resp_work->list);
kfree(resp_work->data); msm_vidc_vmem_free((void **)&resp_work->data);
kfree(resp_work); msm_vidc_vmem_free((void **)&resp_work);
/* list contains max only one ipsc at anytime */ /* list contains max only one ipsc at anytime */
break; break;
} }
@@ -3236,11 +3236,9 @@ static void msm_vidc_update_input_cr(struct msm_vidc_inst *inst, u32 idx, u32 cr
} }
} }
if (!found) { if (!found) {
temp = kzalloc(sizeof(*temp), GFP_KERNEL); if (msm_vidc_vmem_alloc(sizeof(*temp), (void **)&temp, __func__))
if (!temp) {
i_vpr_e(inst, "%s: malloc failure.\n", __func__);
return; return;
}
temp->index = idx; temp->index = idx;
temp->input_cr = cr; temp->input_cr = cr;
list_add_tail(&temp->list, &inst->enc_input_crs); list_add_tail(&temp->list, &inst->enc_input_crs);
@@ -3253,7 +3251,7 @@ static void msm_vidc_free_input_cr_list(struct msm_vidc_inst *inst)
list_for_each_entry_safe(temp, next, &inst->enc_input_crs, list) { list_for_each_entry_safe(temp, next, &inst->enc_input_crs, list) {
list_del(&temp->list); list_del(&temp->list);
kfree(temp); msm_vidc_vmem_free((void **)&temp);
} }
INIT_LIST_HEAD(&inst->enc_input_crs); INIT_LIST_HEAD(&inst->enc_input_crs);
} }
@@ -4112,22 +4110,20 @@ int msm_vidc_vb2_queue_init(struct msm_vidc_inst *inst)
} }
inst->event_handler.m2m_ctx = inst->m2m_ctx; inst->event_handler.m2m_ctx = inst->m2m_ctx;
inst->bufq[INPUT_META_PORT].vb2q = kzalloc(sizeof(struct vb2_queue), GFP_KERNEL); rc = msm_vidc_vmem_alloc(sizeof(struct vb2_queue),
if (!inst->bufq[INPUT_META_PORT].vb2q) { (void **)&inst->bufq[INPUT_META_PORT].vb2q, "input meta port");
i_vpr_e(inst, "%s: queue allocation failed for input meta port\n", __func__); if (rc)
goto fail_in_meta_alloc; goto fail_in_meta_alloc;
}
/* do input meta port queues initialization */ /* do input meta port queues initialization */
rc = vb2q_init(inst, inst->bufq[INPUT_META_PORT].vb2q, INPUT_META_PLANE); rc = vb2q_init(inst, inst->bufq[INPUT_META_PORT].vb2q, INPUT_META_PLANE);
if (rc) if (rc)
goto fail_in_meta_vb2q_init; goto fail_in_meta_vb2q_init;
inst->bufq[OUTPUT_META_PORT].vb2q = kzalloc(sizeof(struct vb2_queue), GFP_KERNEL); rc = msm_vidc_vmem_alloc(sizeof(struct vb2_queue),
if (!inst->bufq[OUTPUT_META_PORT].vb2q) { (void **)&inst->bufq[OUTPUT_META_PORT].vb2q, "output meta port");
i_vpr_e(inst, "%s: queue allocation failed for output meta port\n", __func__); if (rc)
goto fail_out_meta_alloc; goto fail_out_meta_alloc;
}
/* do output meta port queues initialization */ /* do output meta port queues initialization */
rc = vb2q_init(inst, inst->bufq[OUTPUT_META_PORT].vb2q, OUTPUT_META_PLANE); rc = vb2q_init(inst, inst->bufq[OUTPUT_META_PORT].vb2q, OUTPUT_META_PLANE);
@@ -4138,12 +4134,12 @@ int msm_vidc_vb2_queue_init(struct msm_vidc_inst *inst)
return 0; return 0;
fail_out_meta_vb2q_init: fail_out_meta_vb2q_init:
kfree(inst->bufq[OUTPUT_META_PORT].vb2q); msm_vidc_vmem_free((void **)&inst->bufq[OUTPUT_META_PORT].vb2q);
inst->bufq[OUTPUT_META_PORT].vb2q = NULL; inst->bufq[OUTPUT_META_PORT].vb2q = NULL;
fail_out_meta_alloc: fail_out_meta_alloc:
vb2_queue_release(inst->bufq[INPUT_META_PORT].vb2q); vb2_queue_release(inst->bufq[INPUT_META_PORT].vb2q);
fail_in_meta_vb2q_init: fail_in_meta_vb2q_init:
kfree(inst->bufq[INPUT_META_PORT].vb2q); msm_vidc_vmem_free((void **)&inst->bufq[INPUT_META_PORT].vb2q);
inst->bufq[INPUT_META_PORT].vb2q = NULL; inst->bufq[INPUT_META_PORT].vb2q = NULL;
fail_in_meta_alloc: fail_in_meta_alloc:
v4l2_m2m_ctx_release(inst->m2m_ctx); v4l2_m2m_ctx_release(inst->m2m_ctx);
@@ -4169,10 +4165,10 @@ int msm_vidc_vb2_queue_deinit(struct msm_vidc_inst *inst)
} }
vb2_queue_release(inst->bufq[OUTPUT_META_PORT].vb2q); vb2_queue_release(inst->bufq[OUTPUT_META_PORT].vb2q);
kfree(inst->bufq[OUTPUT_META_PORT].vb2q); msm_vidc_vmem_free((void **)&inst->bufq[OUTPUT_META_PORT].vb2q);
inst->bufq[OUTPUT_META_PORT].vb2q = NULL; inst->bufq[OUTPUT_META_PORT].vb2q = NULL;
vb2_queue_release(inst->bufq[INPUT_META_PORT].vb2q); vb2_queue_release(inst->bufq[INPUT_META_PORT].vb2q);
kfree(inst->bufq[INPUT_META_PORT].vb2q); msm_vidc_vmem_free((void **)&inst->bufq[INPUT_META_PORT].vb2q);
inst->bufq[INPUT_META_PORT].vb2q = NULL; inst->bufq[INPUT_META_PORT].vb2q = NULL;
/* /*
* vb2_queue_release() for input and output queues * vb2_queue_release() for input and output queues
@@ -4296,11 +4292,9 @@ int msm_vidc_session_open(struct msm_vidc_inst *inst)
} }
inst->packet_size = 4096; inst->packet_size = 4096;
inst->packet = kzalloc(inst->packet_size, GFP_KERNEL); rc = msm_vidc_vmem_alloc(inst->packet_size, (void **)&inst->packet, __func__);
if (!inst->packet) { if (rc)
i_vpr_e(inst, "%s(): inst packet allocation failed\n", __func__); return rc;
return -ENOMEM;
}
rc = venus_hfi_session_open(inst); rc = venus_hfi_session_open(inst);
if (rc) if (rc)
@@ -4309,7 +4303,7 @@ int msm_vidc_session_open(struct msm_vidc_inst *inst)
return 0; return 0;
error: error:
i_vpr_e(inst, "%s(): session open failed\n", __func__); i_vpr_e(inst, "%s(): session open failed\n", __func__);
kfree(inst->packet); msm_vidc_vmem_free((void **)&inst->packet);
inst->packet = NULL; inst->packet = NULL;
return rc; return rc;
} }
@@ -4494,7 +4488,7 @@ int msm_vidc_session_close(struct msm_vidc_inst *inst)
/* we are not supposed to send any more commands after close */ /* we are not supposed to send any more commands after close */
i_vpr_h(inst, "%s: free session packet data\n", __func__); i_vpr_h(inst, "%s: free session packet data\n", __func__);
kfree(inst->packet); msm_vidc_vmem_free((void **)&inst->packet);
inst->packet = NULL; inst->packet = NULL;
core = inst->core; core = inst->core;
@@ -4573,7 +4567,7 @@ int msm_vidc_deinit_core_caps(struct msm_vidc_core *core)
return -EINVAL; return -EINVAL;
} }
kfree(core->capabilities); msm_vidc_vmem_free((void **)&core->capabilities);
core->capabilities = NULL; core->capabilities = NULL;
d_vpr_h("%s: Core capabilities freed\n", __func__); d_vpr_h("%s: Core capabilities freed\n", __func__);
@@ -4600,15 +4594,10 @@ int msm_vidc_init_core_caps(struct msm_vidc_core *core)
goto exit; goto exit;
} }
core->capabilities = kcalloc(1, rc = msm_vidc_vmem_alloc((sizeof(struct msm_vidc_core_capability) *
(sizeof(struct msm_vidc_core_capability) * (CORE_CAP_MAX + 1)), (void **)&core->capabilities, __func__);
(CORE_CAP_MAX + 1)), GFP_KERNEL); if (rc)
if (!core->capabilities) {
d_vpr_e("%s: failed to allocate core capabilities\n",
__func__);
rc = -ENOMEM;
goto exit; goto exit;
}
num_platform_caps = core->platform->data.core_data_size; num_platform_caps = core->platform->data.core_data_size;
@@ -4677,7 +4666,7 @@ int msm_vidc_deinit_instance_caps(struct msm_vidc_core *core)
return -EINVAL; return -EINVAL;
} }
kfree(core->inst_caps); msm_vidc_vmem_free((void **)&core->inst_caps);
core->inst_caps = NULL; core->inst_caps = NULL;
d_vpr_h("%s: core->inst_caps freed\n", __func__); d_vpr_h("%s: core->inst_caps freed\n", __func__);
@@ -4727,15 +4716,10 @@ int msm_vidc_init_instance_caps(struct msm_vidc_core *core)
COUNT_BITS(count_bits, codecs_count); COUNT_BITS(count_bits, codecs_count);
core->codecs_count = codecs_count; core->codecs_count = codecs_count;
core->inst_caps = kcalloc(codecs_count, rc = msm_vidc_vmem_alloc(codecs_count * sizeof(struct msm_vidc_inst_capability),
sizeof(struct msm_vidc_inst_capability), (void **)&core->inst_caps, __func__);
GFP_KERNEL); if (rc)
if (!core->inst_caps) {
d_vpr_e("%s: failed to allocate core capabilities\n",
__func__);
rc = -ENOMEM;
goto error; goto error;
}
check_bit = 0; check_bit = 0;
/* determine codecs for enc domain */ /* determine codecs for enc domain */
@@ -5572,25 +5556,25 @@ void msm_vidc_destroy_buffers(struct msm_vidc_inst *inst)
list_for_each_entry_safe(work, dummy_work, &inst->response_works, list) { list_for_each_entry_safe(work, dummy_work, &inst->response_works, list) {
list_del(&work->list); list_del(&work->list);
kfree(work->data); msm_vidc_vmem_free((void **)&work->data);
kfree(work); msm_vidc_vmem_free((void **)&work);
} }
list_for_each_entry_safe(entry, dummy_entry, &inst->firmware_list, list) { list_for_each_entry_safe(entry, dummy_entry, &inst->firmware_list, list) {
i_vpr_e(inst, "%s: fw list: %s\n", __func__, cap_name(entry->cap_id)); i_vpr_e(inst, "%s: fw list: %s\n", __func__, cap_name(entry->cap_id));
list_del(&entry->list); list_del(&entry->list);
kfree(entry); msm_vidc_vmem_free((void **)&entry);
} }
list_for_each_entry_safe(entry, dummy_entry, &inst->children_list, list) { list_for_each_entry_safe(entry, dummy_entry, &inst->children_list, list) {
i_vpr_e(inst, "%s: child list: %s\n", __func__, cap_name(entry->cap_id)); i_vpr_e(inst, "%s: child list: %s\n", __func__, cap_name(entry->cap_id));
list_del(&entry->list); list_del(&entry->list);
kfree(entry); msm_vidc_vmem_free((void **)&entry);
} }
list_for_each_entry_safe(entry, dummy_entry, &inst->caps_list, list) { list_for_each_entry_safe(entry, dummy_entry, &inst->caps_list, list) {
list_del(&entry->list); list_del(&entry->list);
kfree(entry); msm_vidc_vmem_free((void **)&entry);
} }
list_for_each_entry_safe(fence, dummy_fence, &inst->fence_list, list) { list_for_each_entry_safe(fence, dummy_fence, &inst->fence_list, list) {
@@ -5622,8 +5606,8 @@ static void msm_vidc_close_helper(struct kref *kref)
msm_vidc_remove_dangling_session(inst); msm_vidc_remove_dangling_session(inst);
mutex_destroy(&inst->request_lock); mutex_destroy(&inst->request_lock);
mutex_destroy(&inst->lock); mutex_destroy(&inst->lock);
kfree(inst->capabilities); msm_vidc_vmem_free((void **)&inst->capabilities);
kfree(inst); msm_vidc_vmem_free((void **)&inst);
} }
struct msm_vidc_inst *get_inst_ref(struct msm_vidc_core *core, struct msm_vidc_inst *get_inst_ref(struct msm_vidc_core *core,

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

@@ -344,11 +344,10 @@ static int msm_vidc_load_bus_table(struct msm_vidc_core *core)
buses->count = num_buses; buses->count = num_buses;
d_vpr_h("Found %d bus interconnects\n", num_buses); d_vpr_h("Found %d bus interconnects\n", num_buses);
bus_ranges = kzalloc(2 * num_buses * sizeof(*bus_ranges), GFP_KERNEL); rc = msm_vidc_vmem_alloc(2 * num_buses * sizeof(*bus_ranges),
if (!bus_ranges) { (void **)&bus_ranges, " for bus ranges");
d_vpr_e("No memory to read bus ranges\n"); if (rc)
return -ENOMEM; return rc;
}
rc = of_property_read_u32_array(pdev->dev.of_node, rc = of_property_read_u32_array(pdev->dev.of_node,
"qcom,bus-range-kbps", bus_ranges, "qcom,bus-range-kbps", bus_ranges,
@@ -385,7 +384,7 @@ static int msm_vidc_load_bus_table(struct msm_vidc_core *core)
} }
exit: exit:
kfree(bus_ranges); msm_vidc_vmem_free((void **) &bus_ranges);
return rc; return rc;
} }
@@ -942,12 +941,13 @@ void msm_vidc_deinit_dt(struct platform_device *pdev)
msm_vidc_free_qdss_addr_table(core->dt); msm_vidc_free_qdss_addr_table(core->dt);
msm_vidc_free_bus_table(core->dt); msm_vidc_free_bus_table(core->dt);
msm_vidc_free_buffer_usage_table(core->dt); msm_vidc_free_buffer_usage_table(core->dt);
msm_vidc_vmem_free((void **)&core->dt);
} }
int msm_vidc_init_dt(struct platform_device *pdev) int msm_vidc_init_dt(struct platform_device *pdev)
{ {
int rc = 0; int rc = 0;
struct msm_vidc_dt *dt; struct msm_vidc_dt *dt = NULL;
struct msm_vidc_core *core; struct msm_vidc_core *core;
if (!pdev) { if (!pdev) {
@@ -962,9 +962,9 @@ int msm_vidc_init_dt(struct platform_device *pdev)
return -EINVAL; return -EINVAL;
} }
dt = kzalloc(sizeof(struct msm_vidc_dt), GFP_KERNEL); rc = msm_vidc_vmem_alloc(sizeof(struct msm_vidc_dt), (void **)&dt, __func__);
if (!dt) if (rc)
return -ENOMEM; return rc;
core->dt = dt; core->dt = dt;
dt->core = core; dt->core = core;

10
driver/vidc/src/msm_vidc_fence.c
View File

@@ -38,7 +38,7 @@ static void msm_vidc_dma_fence_release(struct dma_fence *df)
if (df) { if (df) {
fence = container_of(df, struct msm_vidc_fence, dma_fence); fence = container_of(df, struct msm_vidc_fence, dma_fence);
d_vpr_l("%s: name %s\n", __func__, fence->name); d_vpr_l("%s: name %s\n", __func__, fence->name);
kfree(fence); msm_vidc_vmem_free((void **)&fence);
} else { } else {
d_vpr_e("%s: invalid fence\n", __func__); d_vpr_e("%s: invalid fence\n", __func__);
} }
@@ -53,18 +53,16 @@ static const struct dma_fence_ops msm_vidc_dma_fence_ops = {
struct msm_vidc_fence *msm_vidc_fence_create(struct msm_vidc_inst *inst) struct msm_vidc_fence *msm_vidc_fence_create(struct msm_vidc_inst *inst)
{ {
struct msm_vidc_fence *fence; struct msm_vidc_fence *fence;
int rc = 0;
if (!inst) { if (!inst) {
d_vpr_e("%s: invalid params\n", __func__); d_vpr_e("%s: invalid params\n", __func__);
return NULL; return NULL;
} }
fence = kzalloc(sizeof(*fence), GFP_KERNEL); rc = msm_vidc_vmem_alloc(sizeof(*fence), (void **)&fence, __func__);
if (!fence) { if (rc)
i_vpr_e(inst, "%s: failed to allocate memory for fence\n",
__func__);
return NULL; return NULL;
}
fence->fd = INVALID_FD; fence->fd = INVALID_FD;
dma_fence_init(&fence->dma_fence, &msm_vidc_dma_fence_ops, dma_fence_init(&fence->dma_fence, &msm_vidc_dma_fence_ops,

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

@@ -314,6 +314,31 @@ exit:
return rc; return rc;
} }
int msm_vidc_vmem_alloc(unsigned long size, void **mem, const char *msg)
{
int rc = 0;
if (*mem) {
d_vpr_e("%s: error: double alloc\n", msg);
rc = -EINVAL;
}
*mem = vzalloc(size);
if (!*mem) {
d_vpr_e("allocation failed for %s\n", msg);
rc = -ENOMEM;
}
return rc;
}
void msm_vidc_vmem_free(void **addr)
{
if (addr && *addr) {
vfree(*addr);
*addr = NULL;
}
}
int msm_vidc_memory_alloc(struct msm_vidc_core *core, struct msm_vidc_alloc *mem) int msm_vidc_memory_alloc(struct msm_vidc_core *core, struct msm_vidc_alloc *mem)
{ {
int rc = 0; int rc = 0;
@@ -475,11 +500,10 @@ void *msm_memory_pool_alloc(struct msm_vidc_inst *inst, enum msm_memory_pool_typ
return hdr->buf; return hdr->buf;
} }
hdr = kzalloc(pool->size + sizeof(struct msm_memory_alloc_header), GFP_KERNEL); if (msm_vidc_vmem_alloc(pool->size + sizeof(struct msm_memory_alloc_header),
if (!hdr) { (void **)&hdr, __func__))
i_vpr_e(inst, "%s: buffer allocation failed\n", __func__);
return NULL; return NULL;
}
INIT_LIST_HEAD(&hdr->list); INIT_LIST_HEAD(&hdr->list);
hdr->type = type; hdr->type = type;
hdr->busy = true; hdr->busy = true;
@@ -549,14 +573,14 @@ static void msm_vidc_destroy_pool_buffers(struct msm_vidc_inst *inst,
/* destroy all free buffers */ /* destroy all free buffers */
list_for_each_entry_safe(hdr, dummy, &pool->free_pool, list) { list_for_each_entry_safe(hdr, dummy, &pool->free_pool, list) {
list_del(&hdr->list); list_del(&hdr->list);
kfree(hdr); msm_vidc_vmem_free((void **)&hdr);
fcount++; fcount++;
} }
/* destroy all busy buffers */ /* destroy all busy buffers */
list_for_each_entry_safe(hdr, dummy, &pool->busy_pool, list) { list_for_each_entry_safe(hdr, dummy, &pool->busy_pool, list) {
list_del(&hdr->list); list_del(&hdr->list);
kfree(hdr); msm_vidc_vmem_free((void **)&hdr);
bcount++; bcount++;
} }

38
driver/vidc/src/msm_vidc_probe.c
View File

@@ -16,6 +16,7 @@
#include "msm_vidc_dt.h" #include "msm_vidc_dt.h"
#include "msm_vidc_platform.h" #include "msm_vidc_platform.h"
#include "msm_vidc_core.h" #include "msm_vidc_core.h"
#include "msm_vidc_memory.h"
#include "venus_hfi.h" #include "venus_hfi.h"
#include "video_generated_h" #include "video_generated_h"
@@ -262,8 +263,8 @@ static int msm_vidc_deinitialize_core(struct msm_vidc_core *core)
mutex_destroy(&core->lock); mutex_destroy(&core->lock);
msm_vidc_change_core_state(core, MSM_VIDC_CORE_DEINIT, __func__); msm_vidc_change_core_state(core, MSM_VIDC_CORE_DEINIT, __func__);
kfree(core->response_packet); msm_vidc_vmem_free((void **)&core->response_packet);
kfree(core->packet); msm_vidc_vmem_free((void **)&core->packet);
core->response_packet = NULL; core->response_packet = NULL;
core->packet = NULL; core->packet = NULL;
@@ -306,20 +307,15 @@ static int msm_vidc_initialize_core(struct msm_vidc_core *core)
} }
core->packet_size = 4096; core->packet_size = 4096;
core->packet = kzalloc(core->packet_size, GFP_KERNEL); rc = msm_vidc_vmem_alloc(core->packet_size,
if (!core->packet) { (void **)&core->packet, "core packet");
d_vpr_e("%s(): core packet allocation failed\n", __func__); if (rc)
rc = -ENOMEM;
goto exit; goto exit;
}
core->response_packet = kzalloc(core->packet_size, GFP_KERNEL); rc = msm_vidc_vmem_alloc(core->packet_size,
if (!core->response_packet) { (void **)&core->response_packet, "core response packet");
d_vpr_e("%s(): core response packet allocation failed\n", if (rc)
__func__);
rc = -ENOMEM;
goto exit; goto exit;
}
mutex_init(&core->lock); mutex_init(&core->lock);
INIT_LIST_HEAD(&core->instances); INIT_LIST_HEAD(&core->instances);
@@ -331,8 +327,8 @@ static int msm_vidc_initialize_core(struct msm_vidc_core *core)
return 0; return 0;
exit: exit:
kfree(core->response_packet); msm_vidc_vmem_free((void **)&core->response_packet);
kfree(core->packet); msm_vidc_vmem_free((void **)&core->packet);
core->response_packet = NULL; core->response_packet = NULL;
core->packet = NULL; core->packet = NULL;
if (core->batch_workq) if (core->batch_workq)
@@ -396,7 +392,7 @@ static int msm_vidc_remove_video_device(struct platform_device *pdev)
dev_set_drvdata(&pdev->dev, NULL); dev_set_drvdata(&pdev->dev, NULL);
debugfs_remove_recursive(core->debugfs_parent); debugfs_remove_recursive(core->debugfs_parent);
kfree(core); msm_vidc_vmem_free((void **)&core);
g_core = NULL; g_core = NULL;
return 0; return 0;
@@ -432,14 +428,14 @@ static int msm_vidc_remove(struct platform_device *pdev)
static int msm_vidc_probe_video_device(struct platform_device *pdev) static int msm_vidc_probe_video_device(struct platform_device *pdev)
{ {
int rc = 0; int rc = 0;
struct msm_vidc_core *core; struct msm_vidc_core *core = NULL;
int nr = BASE_DEVICE_NUMBER; int nr = BASE_DEVICE_NUMBER;
d_vpr_h("%s()\n", __func__); d_vpr_h("%s()\n", __func__);
core = kzalloc(sizeof(*core), GFP_KERNEL); rc = msm_vidc_vmem_alloc(sizeof(*core), (void **)&core, __func__);
if (!core) if (rc)
return -ENOMEM; return rc;
g_core = core; g_core = core;
core->debugfs_parent = msm_vidc_debugfs_init_drv(); core->debugfs_parent = msm_vidc_debugfs_init_drv();
@@ -589,7 +585,7 @@ init_dt_failed:
init_core_failed: init_core_failed:
dev_set_drvdata(&pdev->dev, NULL); dev_set_drvdata(&pdev->dev, NULL);
debugfs_remove_recursive(core->debugfs_parent); debugfs_remove_recursive(core->debugfs_parent);
kfree(core); msm_vidc_vmem_free((void **)&core);
g_core = NULL; g_core = NULL;
return rc; return rc;

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

@@ -1110,11 +1110,9 @@ static void __flush_debug_queue(struct msm_vidc_core *core,
} }
if (!packet || !packet_size) { if (!packet || !packet_size) {
packet = kzalloc(VIDC_IFACEQ_VAR_HUGE_PKT_SIZE, GFP_KERNEL); if (msm_vidc_vmem_alloc(VIDC_IFACEQ_VAR_HUGE_PKT_SIZE,
if (!packet) { (void **)&packet, __func__))
d_vpr_e("%s: fail to allocate\n", __func__);
return; return;
}
packet_size = VIDC_IFACEQ_VAR_HUGE_PKT_SIZE; packet_size = VIDC_IFACEQ_VAR_HUGE_PKT_SIZE;
local_packet = true; local_packet = true;
@@ -1153,7 +1151,7 @@ static void __flush_debug_queue(struct msm_vidc_core *core,
} }
if (local_packet) if (local_packet)
kfree(packet); msm_vidc_vmem_free((void **)&packet);
} }
static int __sys_set_debug(struct msm_vidc_core *core, u32 debug) static int __sys_set_debug(struct msm_vidc_core *core, u32 debug)

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

@@ -1854,8 +1854,8 @@ void handle_session_response_work_handler(struct work_struct *work)
break; break;
} }
list_del(&resp_work->list); list_del(&resp_work->list);
kfree(resp_work->data); msm_vidc_vmem_free((void **)&resp_work->data);
kfree(resp_work); msm_vidc_vmem_free((void **)&resp_work);
} }
inst_unlock(inst, __func__); inst_unlock(inst, __func__);
@@ -1867,14 +1867,12 @@ static int queue_response_work(struct msm_vidc_inst *inst,
{ {
struct response_work *work; struct response_work *work;
work = kzalloc(sizeof(struct response_work), GFP_KERNEL); if (msm_vidc_vmem_alloc(sizeof(struct response_work), (void **)&work, __func__))
if (!work)
return -ENOMEM; return -ENOMEM;
INIT_LIST_HEAD(&work->list); INIT_LIST_HEAD(&work->list);
work->type = type; work->type = type;
work->data_size = hdr_size; work->data_size = hdr_size;
work->data = kzalloc(hdr_size, GFP_KERNEL); if (msm_vidc_vmem_alloc(hdr_size, (void **)&work->data, "Work data"))
if (!work->data)
return -ENOMEM; return -ENOMEM;
memcpy(work->data, hdr, hdr_size); memcpy(work->data, hdr, hdr_size);
list_add_tail(&work->list, &inst->response_works); list_add_tail(&work->list, &inst->response_works);
@@ -1895,8 +1893,8 @@ int cancel_response_work(struct msm_vidc_inst *inst)
list_for_each_entry_safe(work, dummy_work, &inst->response_works, list) { list_for_each_entry_safe(work, dummy_work, &inst->response_works, list) {
list_del(&work->list); list_del(&work->list);
kfree(work->data); msm_vidc_vmem_free((void **)&work->data);
kfree(work); msm_vidc_vmem_free((void **)&work);
} }
return 0; return 0;