samsung-sm8650/android_kernel_samsung_sm8650-modules
1
0
Atdalīts 0
Kods Problēmas Izmaiņu pieprasījumi Darbības Pakotnes Projekti Laidieni Vikivietne Aktivitāte

Merge "video: driver: replace msm_vidc_vmem_alloc/free"

Pārlūkot izejas kodu
Šī revīzija ir iekļauta:
qctecmdr
2023-07-11 17:24:10 -07:00
revīziju iesūtīja Gerrit - the friendly Code Review server
vecāks 78f2d04033 9528c09bf4
revīzija ccafeeddb0
9 mainīti faili ar 85 papildinājumiem un 89 dzēšanām
Lejupielādēt ielāpa failu Lejupielādēt izmaiņu failu Izvērst visus failus Savērst visus failus

2
driver/vidc/inc/msm_vidc_memory.h
Parādīt failu

@@ -45,8 +45,6 @@ struct msm_memory_pool {
struct list_head busy_pool; /* list of struct msm_memory_alloc_header */
};
int msm_vidc_vmem_alloc(unsigned long size, void **mem, const char *msg);
void msm_vidc_vmem_free(void **addr);
void *msm_vidc_pool_alloc(struct msm_vidc_inst *inst,
enum msm_memory_pool_type type);
void msm_vidc_pool_free(struct msm_vidc_inst *inst, void *vidc_buf);

8
driver/vidc/src/msm_vidc.c
Parādīt failu

@@ -711,9 +711,11 @@ void *msm_vidc_open(struct msm_vidc_core *core, u32 session_type)
if (rc)
return NULL;
rc = msm_vidc_vmem_alloc(sizeof(*inst), (void **)&inst, "inst memory");
if (rc)
inst = vzalloc(sizeof(*inst));
if (!inst) {
d_vpr_e("%s: allocation failed\n", __func__);
return NULL;
}
inst->core = core;
inst->domain = session_type;
@@ -853,7 +855,7 @@ fail_add_session:
mutex_destroy(&inst->client_lock);
mutex_destroy(&inst->ctx_q_lock);
mutex_destroy(&inst->lock);
msm_vidc_vmem_free((void **)&inst);
vfree(inst);
return NULL;
}

23
driver/vidc/src/msm_vidc_control.c
Parādīt failu

@@ -183,10 +183,11 @@ static int add_node_list(struct list_head *list, enum msm_vidc_inst_capability_t
int rc = 0;
struct msm_vidc_inst_cap_entry *entry = NULL;
rc = msm_vidc_vmem_alloc(sizeof(struct msm_vidc_inst_cap_entry),
(void **)&entry, __func__);
if (rc)
return rc;
entry = vzalloc(sizeof(*entry));
if (!entry) {
d_vpr_e("%s: allocation failed\n", __func__);
return -ENOMEM;
}
INIT_LIST_HEAD(&entry->list);
entry->cap_id = cap_id;
@@ -403,7 +404,7 @@ static int msm_vidc_adjust_dynamic_property(struct msm_vidc_inst *inst,
}
list_del_init(&entry->list);
msm_vidc_vmem_free((void **)&entry);
vfree(entry);
}
/* expecting children_list to be empty */
@@ -418,12 +419,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);
msm_vidc_vmem_free((void **)&entry);
vfree(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);
msm_vidc_vmem_free((void **)&entry);
vfree(entry);
}
return rc;
@@ -442,7 +443,7 @@ static int msm_vidc_set_dynamic_property(struct msm_vidc_inst *inst)
goto error;
list_del_init(&entry->list);
msm_vidc_vmem_free((void **)&entry);
vfree(entry);
}
return 0;
@@ -450,7 +451,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);
msm_vidc_vmem_free((void **)&entry);
vfree(entry);
}
return rc;
@@ -1029,12 +1030,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);
msm_vidc_vmem_free((void **)&entry);
vfree(entry);
}
list_for_each_entry_safe(entry, temp, &leaf_list, list) {
i_vpr_e(inst, "%s: leaf_list: %s\n", __func__, cap_name(entry->cap_id));
list_del_init(&entry->list);
msm_vidc_vmem_free((void **)&entry);
vfree(entry);
}
return rc;
}

27
driver/vidc/src/msm_vidc_debug.c
Parādīt failu

@@ -291,16 +291,17 @@ static ssize_t core_info_read(struct file *file, char __user *buf,
struct msm_vidc_core *core = file->private_data;
char *cur, *end, *dbuf = NULL;
ssize_t len = 0;
int rc = 0;
if (!core) {
d_vpr_e("%s: invalid params %pK\n", __func__, core);
return 0;
}
rc = msm_vidc_vmem_alloc(MAX_DBG_BUF_SIZE, (void **)&dbuf, __func__);
if (rc)
return rc;
dbuf = vzalloc(MAX_DBG_BUF_SIZE);
if (!dbuf) {
d_vpr_e("%s: allocation failed\n", __func__);
return -ENOMEM;
}
cur = dbuf;
end = cur + MAX_DBG_BUF_SIZE;
@@ -316,7 +317,7 @@ static ssize_t core_info_read(struct file *file, char __user *buf,
len = simple_read_from_buffer(buf, count, ppos,
dbuf, cur - dbuf);
msm_vidc_vmem_free((void **)&dbuf);
vfree(dbuf);
return len;
}
@@ -589,10 +590,13 @@ static ssize_t inst_info_read(struct file *file, char __user *buf,
return 0;
}
if (msm_vidc_vmem_alloc(MAX_DBG_BUF_SIZE, (void **)&dbuf, __func__)) {
dbuf = vzalloc(MAX_DBG_BUF_SIZE);
if (!dbuf) {
i_vpr_e(inst, "%s: allocation failed\n", __func__);
len = -ENOMEM;
goto failed_alloc;
}
cur = dbuf;
end = cur + MAX_DBG_BUF_SIZE;
@@ -645,7 +649,7 @@ static ssize_t inst_info_read(struct file *file, char __user *buf,
len = simple_read_from_buffer(buf, count, ppos,
dbuf, cur - dbuf);
msm_vidc_vmem_free((void **)&dbuf);
vfree(dbuf);
failed_alloc:
put_inst(inst);
return len;
@@ -672,8 +676,11 @@ struct dentry *msm_vidc_debugfs_init_inst(struct msm_vidc_inst *inst, struct den
snprintf(debugfs_name, MAX_DEBUGFS_NAME, "inst_%d", inst->session_id);
if (msm_vidc_vmem_alloc(sizeof(struct core_inst_pair), (void **)&idata, __func__))
idata = vzalloc(sizeof(*idata));
if (!idata) {
i_vpr_e(inst, "%s: allocation failed\n", __func__);
goto exit;
}
idata->core = inst->core;
idata->inst = inst;
@@ -703,7 +710,7 @@ failed_create_file:
debugfs_remove_recursive(dir);
dir = NULL;
failed_create_dir:
msm_vidc_vmem_free((void **)&idata);
vfree(idata);
exit:
return dir;
}
@@ -719,7 +726,7 @@ void msm_vidc_debugfs_deinit_inst(struct msm_vidc_inst *inst)
if (dentry->d_inode) {
i_vpr_l(inst, "%s: Destroy %pK\n",
__func__, dentry->d_inode->i_private);
msm_vidc_vmem_free(&dentry->d_inode->i_private);
vfree(dentry->d_inode->i_private);
dentry->d_inode->i_private = NULL;
}
debugfs_remove_recursive(dentry);

52
driver/vidc/src/msm_vidc_driver.c
Parādīt failu

@@ -2293,9 +2293,11 @@ static void msm_vidc_update_input_cr(struct msm_vidc_inst *inst, u32 idx, u32 cr
}
if (!found) {
temp = NULL;
if (msm_vidc_vmem_alloc(sizeof(*temp), (void **)&temp, __func__))
temp = vzalloc(sizeof(*temp));
if (!temp) {
i_vpr_e(inst, "%s: allocation failed\n", __func__);
return;
}
temp->index = idx;
temp->input_cr = cr;
list_add_tail(&temp->list, &inst->enc_input_crs);
@@ -3084,20 +3086,24 @@ int msm_vidc_vb2_queue_init(struct msm_vidc_inst *inst)
}
inst->fh.m2m_ctx = inst->m2m_ctx;
rc = msm_vidc_vmem_alloc(sizeof(struct vb2_queue),
(void **)&inst->bufq[INPUT_META_PORT].vb2q, "input meta port");
if (rc)
inst->bufq[INPUT_META_PORT].vb2q = vzalloc(sizeof(*inst->bufq[INPUT_META_PORT].vb2q));
if (!inst->bufq[INPUT_META_PORT].vb2q) {
i_vpr_e(inst, "%s: allocation failed\n", __func__);
rc = -ENOMEM;
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;
rc = msm_vidc_vmem_alloc(sizeof(struct vb2_queue),
(void **)&inst->bufq[OUTPUT_META_PORT].vb2q, "output meta port");
if (rc)
inst->bufq[OUTPUT_META_PORT].vb2q = vzalloc(sizeof(*inst->bufq[OUTPUT_META_PORT].vb2q));
if (!inst->bufq[OUTPUT_META_PORT].vb2q) {
i_vpr_e(inst, "%s: allocation failed\n", __func__);
rc = -ENOMEM;
goto fail_out_meta_alloc;
}
/* do output meta port queues initialization */
rc = vb2q_init(inst, inst->bufq[OUTPUT_META_PORT].vb2q, OUTPUT_META_PLANE);
@@ -3107,12 +3113,12 @@ int msm_vidc_vb2_queue_init(struct msm_vidc_inst *inst)
return 0;
fail_out_meta_vb2q_init:
msm_vidc_vmem_free((void **)&inst->bufq[OUTPUT_META_PORT].vb2q);
vfree(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:
msm_vidc_vmem_free((void **)&inst->bufq[INPUT_META_PORT].vb2q);
vfree(inst->bufq[INPUT_META_PORT].vb2q);
inst->bufq[INPUT_META_PORT].vb2q = NULL;
fail_in_meta_alloc:
v4l2_m2m_ctx_release(inst->m2m_ctx);
@@ -3148,10 +3154,10 @@ int msm_vidc_vb2_queue_deinit(struct msm_vidc_inst *inst)
inst->m2m_dev = NULL;
vb2_queue_release(inst->bufq[OUTPUT_META_PORT].vb2q);
msm_vidc_vmem_free((void **)&inst->bufq[OUTPUT_META_PORT].vb2q);
vfree(inst->bufq[OUTPUT_META_PORT].vb2q);
inst->bufq[OUTPUT_META_PORT].vb2q = NULL;
vb2_queue_release(inst->bufq[INPUT_META_PORT].vb2q);
msm_vidc_vmem_free((void **)&inst->bufq[INPUT_META_PORT].vb2q);
vfree(inst->bufq[INPUT_META_PORT].vb2q);
inst->bufq[INPUT_META_PORT].vb2q = NULL;
return rc;
@@ -3243,9 +3249,11 @@ int msm_vidc_session_open(struct msm_vidc_inst *inst)
int rc = 0;
inst->packet_size = 4096;
rc = msm_vidc_vmem_alloc(inst->packet_size, (void **)&inst->packet, __func__);
if (rc)
return rc;
inst->packet = vzalloc(inst->packet_size);
if (!inst->packet) {
i_vpr_e(inst, "%s: allocation failed\n", __func__);
return -ENOMEM;
}
rc = venus_hfi_session_open(inst);
if (rc)
@@ -3254,7 +3262,7 @@ int msm_vidc_session_open(struct msm_vidc_inst *inst)
return 0;
error:
i_vpr_e(inst, "%s(): session open failed\n", __func__);
msm_vidc_vmem_free((void **)&inst->packet);
vfree(inst->packet);
inst->packet = NULL;
return rc;
}
@@ -3395,7 +3403,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__);
msm_vidc_vmem_free((void **)&inst->packet);
vfree(inst->packet);
inst->packet = NULL;
if (wait_for_response) {
@@ -4416,23 +4424,23 @@ void msm_vidc_destroy_buffers(struct msm_vidc_inst *inst)
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);
msm_vidc_vmem_free((void **)&entry);
vfree(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);
msm_vidc_vmem_free((void **)&entry);
vfree(entry);
}
list_for_each_entry_safe(entry, dummy_entry, &inst->caps_list, list) {
list_del(&entry->list);
msm_vidc_vmem_free((void **)&entry);
vfree(entry);
}
list_for_each_entry_safe(cr, dummy_cr, &inst->enc_input_crs, list) {
list_del(&cr->list);
msm_vidc_vmem_free((void **)&cr);
vfree(cr);
}
list_for_each_entry_safe(fence, dummy_fence, &inst->fence_list, list) {
@@ -4476,7 +4484,7 @@ static void msm_vidc_close_helper(struct kref *kref)
mutex_destroy(&inst->client_lock);
mutex_destroy(&inst->ctx_q_lock);
mutex_destroy(&inst->lock);
msm_vidc_vmem_free((void **)&inst);
vfree(inst);
}
struct msm_vidc_inst *get_inst_ref(struct msm_vidc_core *core,

9
driver/vidc/src/msm_vidc_fence.c
Parādīt failu

@@ -36,7 +36,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);
msm_vidc_vmem_free((void **)&fence);
vfree(fence);
} else {
d_vpr_e("%s: invalid fence\n", __func__);
}
@@ -51,11 +51,12 @@ 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 = NULL;
int rc = 0;
rc = msm_vidc_vmem_alloc(sizeof(*fence), (void **)&fence, __func__);
if (rc)
fence = vzalloc(sizeof(*fence));
if (!fence) {
i_vpr_e(inst, "%s: allocation failed\n", __func__);
return NULL;
}
fence->fd = INVALID_FD;
spin_lock_init(&fence->lock);

36
driver/vidc/src/msm_vidc_memory.c
Parādīt failu

@@ -38,32 +38,6 @@ static const struct msm_vidc_type_size_name buftype_size_name_arr[] = {
{MSM_MEM_POOL_BUF_STATS, sizeof(struct msm_vidc_buffer_stats), "MSM_MEM_POOL_BUF_STATS"},
};
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;
}
}
void *msm_vidc_pool_alloc(struct msm_vidc_inst *inst, enum msm_memory_pool_type type)
{
struct msm_memory_alloc_header *hdr = NULL;
@@ -92,9 +66,11 @@ void *msm_vidc_pool_alloc(struct msm_vidc_inst *inst, enum msm_memory_pool_type
return hdr->buf;
}
if (msm_vidc_vmem_alloc(pool->size + sizeof(struct msm_memory_alloc_header),
(void **)&hdr, __func__))
hdr = vzalloc(pool->size + sizeof(struct msm_memory_alloc_header));
if (!hdr) {
i_vpr_e(inst, "%s: allocation failed\n", __func__);
return NULL;
}
INIT_LIST_HEAD(&hdr->list);
hdr->type = type;
@@ -162,14 +138,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);
msm_vidc_vmem_free((void **)&hdr);
vfree(hdr);
fcount++;
}
/* destroy all busy buffers */
list_for_each_entry_safe(hdr, dummy, &pool->busy_pool, list) {
list_del(&hdr->list);
msm_vidc_vmem_free((void **)&hdr);
vfree(hdr);
bcount++;
}

9
driver/vidc/src/msm_vidc_synx.c
Parādīt failu

@@ -62,7 +62,7 @@ static void msm_vidc_synx_fence_release(struct dma_fence *df)
__func__, fence->name);
}
msm_vidc_vmem_free((void **)&fence);
vfree(fence);
return;
}
@@ -178,11 +178,12 @@ static int msm_vidc_synx_fence_deregister(struct msm_vidc_core *core)
static struct msm_vidc_fence *msm_vidc_synx_dma_fence_create(struct msm_vidc_inst *inst)
{
struct msm_vidc_fence *fence = NULL;
int rc = 0;
rc = msm_vidc_vmem_alloc(sizeof(*fence), (void **)&fence, __func__);
if (rc)
fence = vzalloc(sizeof(*fence));
if (!fence) {
i_vpr_e(inst, "%s: allocation failed\n", __func__);
return NULL;
}
fence->fd = INVALID_FD;
spin_lock_init(&fence->lock);

8
driver/vidc/src/venus_hfi.c
Parādīt failu

@@ -116,9 +116,11 @@ static void __flush_debug_queue(struct msm_vidc_core *core,
enum vidc_msg_prio_fw log_level_fw = msm_fw_debug;
if (!packet || !packet_size) {
if (msm_vidc_vmem_alloc(VIDC_IFACEQ_VAR_HUGE_PKT_SIZE,
(void **)&packet, __func__))
packet = vzalloc(VIDC_IFACEQ_VAR_HUGE_PKT_SIZE);
if (!packet) {
d_vpr_e("%s: allocation failed\n", __func__);
return;
}
packet_size = VIDC_IFACEQ_VAR_HUGE_PKT_SIZE;
local_packet = true;
@@ -157,7 +159,7 @@ static void __flush_debug_queue(struct msm_vidc_core *core,
}
if (local_packet)
msm_vidc_vmem_free((void **)&packet);
vfree(packet);
}
static int __cmdq_write(struct msm_vidc_core *core, void *pkt)