video: driver: Use vzalloc instead of kzalloc

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 <[email protected]>

driver/platform/common/src/msm_vidc_platform.c

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

driver/vidc/inc/msm_vidc_memory.h

@@ -63,5 +63,6 @@ void msm_memory_pools_deinit(struct msm_vidc_inst *inst);
 void *msm_memory_pool_alloc(struct msm_vidc_inst *inst,
 	enum msm_memory_pool_type type);
 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_

driver/vidc/src/msm_vidc.c

@@ -881,11 +881,10 @@ void *msm_vidc_open(void *vidc_core, u32 session_type)
 	if (rc)
 		return NULL;
 
-	inst = kzalloc(sizeof(*inst), GFP_KERNEL);
-	if (!inst) {
-		d_vpr_e("%s: failed to allocate inst memory\n", __func__);
+	rc = msm_vidc_vmem_alloc(sizeof(*inst), (void **)&inst, "inst memory");
+	if (rc)
 		return NULL;
-	}
+
 	inst->core = core;
 	inst->domain = session_type;
 	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);
 	if (rc) {
 		i_vpr_e(inst, "%s: failed to init pool buffers\n", __func__);
-		kfree(inst);
+		msm_vidc_vmem_free((void **)&inst);
 		return NULL;
 	}
 	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_WORK(&inst->stability_work, msm_vidc_stability_handler);
 
-	inst->capabilities = kzalloc(sizeof(struct msm_vidc_inst_capability), GFP_KERNEL);
-	if (!inst->capabilities) {
-		i_vpr_e(inst,
-			"%s: inst capability allocation failed\n", __func__);
+	rc = msm_vidc_vmem_alloc(sizeof(struct msm_vidc_inst_capability),
+		(void **)&inst->capabilities, "inst capability");
+	if (rc)
 		goto error;
-	}
 
 	rc = msm_vidc_event_queue_init(inst);
 	if (rc)

driver/vidc/src/msm_vidc_control.c

@@ -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)
 {
+	int rc = 0;
 	struct msm_vidc_inst_cap_entry *entry;
 
-	entry = kzalloc(sizeof(struct msm_vidc_inst_cap_entry), GFP_KERNEL);
-	if (!entry) {
-		d_vpr_e("%s: msm_vidc_inst_cap_entry alloc failed\n", __func__);
-		return -EINVAL;
-	}
+	rc = msm_vidc_vmem_alloc(sizeof(struct msm_vidc_inst_cap_entry),
+			(void **)&entry, __func__);
+	if (rc)
+		return rc;
 
 	INIT_LIST_HEAD(&entry->list);
 	entry->cap_id = cap_id;
 	list_add_tail(&entry->list, list);
 
-	return 0;
+	return rc;
 }
 
 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);
-		kfree(entry);
+		msm_vidc_vmem_free((void **)&entry);
 	}
 
 	/* expecting children_list to be empty */
@@ -711,12 +711,12 @@ error:
 	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));
 		list_del_init(&entry->list);
-		kfree(entry);
+		msm_vidc_vmem_free((void **)&entry);
 	}
 	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));
 		list_del_init(&entry->list);
-		kfree(entry);
+		msm_vidc_vmem_free((void **)&entry);
 	}
 
 	return rc;
@@ -739,7 +739,7 @@ static int msm_vidc_set_dynamic_property(struct msm_vidc_inst *inst)
 			goto error;
 
 		list_del_init(&entry->list);
-		kfree(entry);
+		msm_vidc_vmem_free((void **)&entry);
 	}
 
 	return 0;
@@ -747,7 +747,7 @@ error:
 	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));
 		list_del_init(&entry->list);
-		kfree(entry);
+		msm_vidc_vmem_free((void **)&entry);
 	}
 
 	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);
 	v4l2_ctrl_handler_free(&inst->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;
 
 	return 0;
@@ -807,12 +807,10 @@ int msm_vidc_ctrl_init(struct msm_vidc_inst *inst)
 			__func__);
 		return -EINVAL;
 	}
-	inst->ctrls = kcalloc(num_ctrls,
-		sizeof(struct v4l2_ctrl *), GFP_KERNEL);
-	if (!inst->ctrls) {
-		i_vpr_e(inst, "%s: failed to allocate ctrl\n", __func__);
-		return -ENOMEM;
-	}
+	rc = msm_vidc_vmem_alloc(num_ctrls * sizeof(struct v4l2_ctrl *),
+			(void **)&inst->ctrls, __func__);
+	if (rc)
+		return rc;
 
 	rc = v4l2_ctrl_handler_init(&inst->ctrl_handler, num_ctrls);
 	if (rc) {
@@ -3165,12 +3163,12 @@ error:
 	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));
 		list_del_init(&entry->list);
-		kfree(entry);
+		msm_vidc_vmem_free((void **)&entry);
 	}
 	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));
 		list_del_init(&entry->list);
-		kfree(entry);
+		msm_vidc_vmem_free((void **)&entry);
 	}
 	return rc;
 }

driver/vidc/src/msm_vidc_debug.c

@@ -167,17 +167,17 @@ static ssize_t core_info_read(struct file* file, char __user* buf,
 	struct msm_vidc_core *core = file->private_data;
 	char* dbuf, * cur, * end;
 	ssize_t len = 0;
+	int rc = 0;
 
 	if (!core || !core->dt) {
 		d_vpr_e("%s: invalid params %pK\n", __func__, core);
 		return 0;
 	}
 
-	dbuf = kzalloc(MAX_DBG_BUF_SIZE, GFP_KERNEL);
-	if (!dbuf) {
-		d_vpr_e("%s: Allocation failed!\n", __func__);
-		return -ENOMEM;
-	}
+	rc = msm_vidc_vmem_alloc(MAX_DBG_BUF_SIZE, (void **)&dbuf, __func__);
+	if (rc)
+		return rc;
+
 	cur = dbuf;
 	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,
 		dbuf, cur - dbuf);
 
-	kfree(dbuf);
+	msm_vidc_vmem_free((void **)&dbuf);
 	return len;
 }
 
@@ -452,9 +452,7 @@ static ssize_t inst_info_read(struct file *file, char __user *buf,
 		return 0;
 	}
 
-	dbuf = kzalloc(MAX_DBG_BUF_SIZE, GFP_KERNEL);
-	if (!dbuf) {
-		i_vpr_e(inst, "%s: Allocation failed!\n", __func__);
+	if (msm_vidc_vmem_alloc(MAX_DBG_BUF_SIZE, (void **) &dbuf, __func__)) {
 		len = -ENOMEM;
 		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,
 		dbuf, cur - dbuf);
 
-	kfree(dbuf);
+	msm_vidc_vmem_free((void **)&dbuf);
 failed_alloc:
 	put_inst(inst);
 	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);
 
-	idata = kzalloc(sizeof(struct core_inst_pair), GFP_KERNEL);
-	if (!idata) {
-		i_vpr_e(inst, "%s: Allocation failed!\n", __func__);
+	if (msm_vidc_vmem_alloc(sizeof(struct core_inst_pair), (void **)&idata, __func__))
 		goto exit;
-	}
 
 	idata->core = inst->core;
 	idata->inst = inst;
@@ -576,7 +571,7 @@ failed_create_file:
 	debugfs_remove_recursive(dir);
 	dir = NULL;
 failed_create_dir:
-	kfree(idata);
+	msm_vidc_vmem_free((void **)&idata);
 exit:
 	return dir;
 }
@@ -593,7 +588,7 @@ void msm_vidc_debugfs_deinit_inst(void *instance)
 	if (dentry->d_inode) {
 		i_vpr_l(inst, "%s: Destroy %pK\n",
 			__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;
 	}
 	debugfs_remove_recursive(dentry);

driver/vidc/src/msm_vidc_driver.c

@@ -1767,8 +1767,8 @@ static int msm_vidc_flush_pending_last_flag(struct msm_vidc_inst *inst)
 				return rc;
 			}
 			list_del(&resp_work->list);
-			kfree(resp_work->data);
-			kfree(resp_work);
+			msm_vidc_vmem_free((void **)&resp_work->data);
+			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,
 				"%s: discard pending output psc\n", __func__);
 			list_del(&resp_work->list);
-			kfree(resp_work->data);
-			kfree(resp_work);
+			msm_vidc_vmem_free((void **)&resp_work->data);
+			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;
 
 			list_del(&resp_work->list);
-			kfree(resp_work->data);
-			kfree(resp_work);
+			msm_vidc_vmem_free((void **)&resp_work->data);
+			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);
-			kfree(resp_work->data);
-			kfree(resp_work);
+			msm_vidc_vmem_free((void **)&resp_work->data);
+			msm_vidc_vmem_free((void **)&resp_work);
 			/* list contains max only one ipsc at anytime */
 			break;
 		}
@@ -3236,11 +3236,9 @@ static void msm_vidc_update_input_cr(struct msm_vidc_inst *inst, u32 idx, u32 cr
 		}
 	}
 	if (!found) {
-		temp = kzalloc(sizeof(*temp), GFP_KERNEL);
-		if (!temp) {
-			i_vpr_e(inst, "%s: malloc failure.\n", __func__);
+		if (msm_vidc_vmem_alloc(sizeof(*temp), (void **)&temp, __func__))
 			return;
-		}
+
 		temp->index = idx;
 		temp->input_cr = cr;
 		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_del(&temp->list);
-		kfree(temp);
+		msm_vidc_vmem_free((void **)&temp);
 	}
 	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->bufq[INPUT_META_PORT].vb2q = kzalloc(sizeof(struct vb2_queue), GFP_KERNEL);
-	if (!inst->bufq[INPUT_META_PORT].vb2q) {
-		i_vpr_e(inst, "%s: queue allocation failed for input meta port\n", __func__);
+	rc = msm_vidc_vmem_alloc(sizeof(struct vb2_queue),
+			(void **)&inst->bufq[INPUT_META_PORT].vb2q, "input meta port");
+	if (rc)
 		goto fail_in_meta_alloc;
-	}
 
 	/* do input meta port queues initialization */
 	rc = vb2q_init(inst, inst->bufq[INPUT_META_PORT].vb2q, INPUT_META_PLANE);
 	if (rc)
 		goto fail_in_meta_vb2q_init;
 
-	inst->bufq[OUTPUT_META_PORT].vb2q = kzalloc(sizeof(struct vb2_queue), GFP_KERNEL);
-	if (!inst->bufq[OUTPUT_META_PORT].vb2q) {
-		i_vpr_e(inst, "%s: queue allocation failed for output meta port\n", __func__);
+	rc = msm_vidc_vmem_alloc(sizeof(struct vb2_queue),
+			(void **)&inst->bufq[OUTPUT_META_PORT].vb2q, "output meta port");
+	if (rc)
 		goto fail_out_meta_alloc;
-	}
 
 	/* do output meta port queues initialization */
 	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;
 
 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;
 fail_out_meta_alloc:
 	vb2_queue_release(inst->bufq[INPUT_META_PORT].vb2q);
 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;
 fail_in_meta_alloc:
 	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);
-	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;
 	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;
 	/*
 	 * 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 = kzalloc(inst->packet_size, GFP_KERNEL);
-	if (!inst->packet) {
-		i_vpr_e(inst, "%s(): inst packet allocation failed\n", __func__);
-		return -ENOMEM;
-	}
+	rc = msm_vidc_vmem_alloc(inst->packet_size, (void **)&inst->packet, __func__);
+	if (rc)
+		return rc;
 
 	rc = venus_hfi_session_open(inst);
 	if (rc)
@@ -4309,7 +4303,7 @@ int msm_vidc_session_open(struct msm_vidc_inst *inst)
 	return 0;
 error:
 	i_vpr_e(inst, "%s(): session open failed\n", __func__);
-	kfree(inst->packet);
+	msm_vidc_vmem_free((void **)&inst->packet);
 	inst->packet = NULL;
 	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 */
 	i_vpr_h(inst, "%s: free session packet data\n", __func__);
-	kfree(inst->packet);
+	msm_vidc_vmem_free((void **)&inst->packet);
 	inst->packet = NULL;
 
 	core = inst->core;
@@ -4573,7 +4567,7 @@ int msm_vidc_deinit_core_caps(struct msm_vidc_core *core)
 		return -EINVAL;
 	}
 
-	kfree(core->capabilities);
+	msm_vidc_vmem_free((void **)&core->capabilities);
 	core->capabilities = NULL;
 	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;
 	}
 
-	core->capabilities = kcalloc(1,
-		(sizeof(struct msm_vidc_core_capability) *
-		(CORE_CAP_MAX + 1)), GFP_KERNEL);
-	if (!core->capabilities) {
-		d_vpr_e("%s: failed to allocate core capabilities\n",
-			__func__);
-		rc = -ENOMEM;
+	rc = msm_vidc_vmem_alloc((sizeof(struct msm_vidc_core_capability) *
+		(CORE_CAP_MAX + 1)), (void **)&core->capabilities, __func__);
+	if (rc)
 		goto exit;
-	}
 
 	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;
 	}
 
-	kfree(core->inst_caps);
+	msm_vidc_vmem_free((void **)&core->inst_caps);
 	core->inst_caps = NULL;
 	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);
 
 	core->codecs_count = codecs_count;
-	core->inst_caps = kcalloc(codecs_count,
-		sizeof(struct msm_vidc_inst_capability),
-		GFP_KERNEL);
-	if (!core->inst_caps) {
-		d_vpr_e("%s: failed to allocate core capabilities\n",
-			__func__);
-		rc = -ENOMEM;
+	rc = msm_vidc_vmem_alloc(codecs_count * sizeof(struct msm_vidc_inst_capability),
+		(void **)&core->inst_caps, __func__);
+	if (rc)
 		goto error;
-	}
 
 	check_bit = 0;
 	/* 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_del(&work->list);
-		kfree(work->data);
-		kfree(work);
+		msm_vidc_vmem_free((void **)&work->data);
+		msm_vidc_vmem_free((void **)&work);
 	}
 
 	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));
 		list_del(&entry->list);
-		kfree(entry);
+		msm_vidc_vmem_free((void **)&entry);
 	}
 
 	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));
 		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_del(&entry->list);
-		kfree(entry);
+		msm_vidc_vmem_free((void **)&entry);
 	}
 
 	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);
 	mutex_destroy(&inst->request_lock);
 	mutex_destroy(&inst->lock);
-	kfree(inst->capabilities);
-	kfree(inst);
+	msm_vidc_vmem_free((void **)&inst->capabilities);
+	msm_vidc_vmem_free((void **)&inst);
 }
 
 struct msm_vidc_inst *get_inst_ref(struct msm_vidc_core *core,

driver/vidc/src/msm_vidc_dt.c

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

driver/vidc/src/msm_vidc_fence.c

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

driver/vidc/src/msm_vidc_memory.c

@@ -314,6 +314,31 @@ exit:
 	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 rc = 0;
@@ -475,11 +500,10 @@ void *msm_memory_pool_alloc(struct msm_vidc_inst *inst, enum msm_memory_pool_typ
 		return hdr->buf;
 	}
 
-	hdr = kzalloc(pool->size + sizeof(struct msm_memory_alloc_header), GFP_KERNEL);
-	if (!hdr) {
-		i_vpr_e(inst, "%s: buffer allocation failed\n", __func__);
+	if (msm_vidc_vmem_alloc(pool->size + sizeof(struct msm_memory_alloc_header),
+			(void **)&hdr, __func__))
 		return NULL;
-	}
+
 	INIT_LIST_HEAD(&hdr->list);
 	hdr->type = type;
 	hdr->busy = true;
@@ -549,14 +573,14 @@ static void msm_vidc_destroy_pool_buffers(struct msm_vidc_inst *inst,
 	/* destroy all free buffers */
 	list_for_each_entry_safe(hdr, dummy, &pool->free_pool, list) {
 		list_del(&hdr->list);
-		kfree(hdr);
+		msm_vidc_vmem_free((void **)&hdr);
 		fcount++;
 	}
 
 	/* destroy all busy buffers */
 	list_for_each_entry_safe(hdr, dummy, &pool->busy_pool, list) {
 		list_del(&hdr->list);
-		kfree(hdr);
+		msm_vidc_vmem_free((void **)&hdr);
 		bcount++;
 	}
 

driver/vidc/src/msm_vidc_probe.c

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

driver/vidc/src/venus_hfi.c

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

driver/vidc/src/venus_hfi_response.c

@@ -1854,8 +1854,8 @@ void handle_session_response_work_handler(struct work_struct *work)
 			break;
 		}
 		list_del(&resp_work->list);
-		kfree(resp_work->data);
-		kfree(resp_work);
+		msm_vidc_vmem_free((void **)&resp_work->data);
+		msm_vidc_vmem_free((void **)&resp_work);
 	}
 	inst_unlock(inst, __func__);
 
@@ -1867,14 +1867,12 @@ static int queue_response_work(struct msm_vidc_inst *inst,
 {
 	struct response_work *work;
 
-	work = kzalloc(sizeof(struct response_work), GFP_KERNEL);
-	if (!work)
+	if (msm_vidc_vmem_alloc(sizeof(struct response_work), (void **)&work, __func__))
 		return -ENOMEM;
 	INIT_LIST_HEAD(&work->list);
 	work->type = type;
 	work->data_size = hdr_size;
-	work->data = kzalloc(hdr_size, GFP_KERNEL);
-	if (!work->data)
+	if (msm_vidc_vmem_alloc(hdr_size, (void **)&work->data, "Work data"))
 		return -ENOMEM;
 	memcpy(work->data, hdr, hdr_size);
 	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_del(&work->list);
-		kfree(work->data);
-		kfree(work);
+		msm_vidc_vmem_free((void **)&work->data);
+		msm_vidc_vmem_free((void **)&work);
 	}
 
 	return 0;