A-Team_Digital_Solutions/android_kernel_motorola_sm6375
Watch
2
0
Fork
You've already forked android_kernel_motorola_sm6375
 0
mirror of https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git synced 2026-10-08 21:22:09 -04:00
Code Issues Projects Releases Packages Wiki Activity

msm: cvp: Restructure CVP buffer management

Browse source 
It fixes an issue that CVP session creation may fail if session runs
out of buffer cache.

Change-Id: I06f2db2132c16aef51b19a9ac0c7bed917390a7b
Signed-off-by: George Shen <sqiao@codeaurora.org>
This commit is contained in:
George Shen 2020-03-09 22:01:55 -07:00
commit 30bb4347ec
11 changed files with 1104 additions and 1000 deletions
Download patch file Download diff file Expand all files Collapse all files

3
drivers/media/platform/msm/cvp/Makefile
View file

@ -16,6 +16,7 @@ msm-cvp-objs := cvp.o \
hfi_packetization.o \
cvp_core_hfi.o \
msm_cvp_clocks.o \
msm_cvp_dsp.o
msm_cvp_dsp.o \
msm_cvp_buf.o
obj-$(CONFIG_MSM_CVP) := msm-cvp.o

14
drivers/media/platform/msm/cvp/cvp_hfi_helper.h
View file

@ -442,20 +442,6 @@ struct cvp_hfi_cmd_sys_test_ssr_packet {
u32 trigger_type;
};
struct cvp_buf_type {
s32 fd;
u32 size;
u32 offset;
u32 flags;
union {
struct dma_buf *dbuf;
struct {
u32 reserved1;
u32 reserved2;
};
};
};
struct cvp_hfi_msg_sys_session_flush_done_packet {
u32 size;
u32 packet_type;

689
drivers/media/platform/msm/cvp/msm_cvp.c
View file

@ -6,6 +6,7 @@
#include "msm_cvp.h"
#include "cvp_hfi.h"
#include "cvp_core_hfi.h"
#include "msm_cvp_buf.h"
struct cvp_power_level {
unsigned long core_sum;
@ -13,39 +14,6 @@ struct cvp_power_level {
unsigned long bw_sum;
};
static void print_internal_buffer(u32 tag, const char *str,
struct msm_cvp_inst *inst, struct cvp_internal_buf *cbuf)
{
if (!(tag & msm_cvp_debug) || !inst || !cbuf)
return;
if (cbuf->smem->dma_buf) {
dprintk(tag,
"%s: %x : fd %d off %d %s size %d iova %#x",
str, hash32_ptr(inst->session), cbuf->fd,
cbuf->offset, cbuf->smem->dma_buf->name, cbuf->size,
cbuf->smem->device_addr);
} else {
dprintk(tag,
"%s: %x : idx %2d fd %d off %d size %d iova %#x",
str, hash32_ptr(inst->session), cbuf->fd,
cbuf->offset, cbuf->size, cbuf->smem->device_addr);
}
}
void print_smem(u32 tag, const char *str, struct msm_cvp_inst *inst,
struct msm_cvp_smem *smem)
{
if (!(tag & msm_cvp_debug) || !inst || !smem)
return;
if (smem->dma_buf) {
dprintk(tag, "%s: %x : %s size %d flags %#x iova %#x", str,
hash32_ptr(inst->session), smem->dma_buf->name,
smem->size, smem->flags, smem->device_addr);
}
}
static int msm_cvp_get_session_info(struct msm_cvp_inst *inst,
struct cvp_kmd_session_info *session)
{
@ -70,444 +38,7 @@ static int msm_cvp_get_session_info(struct msm_cvp_inst *inst,
return rc;
}
static int msm_cvp_map_buf_dsp(struct msm_cvp_inst *inst,
struct cvp_kmd_buffer *buf)
{
int rc = 0;
bool found = false;
struct cvp_internal_buf *cbuf;
struct msm_cvp_smem *smem = NULL;
struct cvp_hal_session *session;
struct dma_buf *dma_buf = NULL;
if (!inst || !inst->core || !buf) {
dprintk(CVP_ERR, "%s: invalid params\n", __func__);
return -EINVAL;
}
if (buf->fd < 0) {
dprintk(CVP_ERR, "%s: Invalid fd = %d", __func__, buf->fd);
return 0;
}
if (buf->offset) {
dprintk(CVP_ERR,
"%s: offset is deprecated, set to 0.\n",
__func__);
return -EINVAL;
}
session = (struct cvp_hal_session *)inst->session;
mutex_lock(&inst->cvpdspbufs.lock);
list_for_each_entry(cbuf, &inst->cvpdspbufs.list, list) {
if (cbuf->fd == buf->fd) {
if (cbuf->size != buf->size) {
dprintk(CVP_ERR, "%s: buf size mismatch\n",
__func__);
mutex_unlock(&inst->cvpdspbufs.lock);
return -EINVAL;
}
found = true;
break;
}
}
mutex_unlock(&inst->cvpdspbufs.lock);
if (found) {
print_internal_buffer(CVP_ERR, "duplicate", inst, cbuf);
return -EINVAL;
}
dma_buf = msm_cvp_smem_get_dma_buf(buf->fd);
if (!dma_buf) {
dprintk(CVP_ERR, "%s: Invalid fd = %d", __func__, buf->fd);
return 0;
}
cbuf = kmem_cache_zalloc(cvp_driver->buf_cache, GFP_KERNEL);
if (!cbuf)
return -ENOMEM;
smem = kmem_cache_zalloc(cvp_driver->smem_cache, GFP_KERNEL);
if (!smem) {
kmem_cache_free(cvp_driver->buf_cache, cbuf);
return -ENOMEM;
}
smem->dma_buf = dma_buf;
dprintk(CVP_ERR, "%s: dma_buf = %llx\n", __func__, dma_buf);
rc = msm_cvp_map_smem(inst, smem);
if (rc) {
print_client_buffer(CVP_ERR, "map failed", inst, buf);
goto exit;
}
if (buf->index) {
rc = cvp_dsp_register_buffer(hash32_ptr(session), buf->fd,
smem->dma_buf->size, buf->size, buf->offset,
buf->index, (uint32_t)smem->device_addr);
if (rc) {
dprintk(CVP_ERR,
"%s: failed dsp registration for fd=%d rc=%d",
__func__, buf->fd, rc);
goto exit;
}
} else {
dprintk(CVP_ERR, "%s: buf index is 0 fd=%d", __func__, buf->fd);
rc = -EINVAL;
goto exit;
}
cbuf->smem = smem;
cbuf->fd = buf->fd;
cbuf->size = buf->size;
cbuf->offset = buf->offset;
cbuf->ownership = CLIENT;
cbuf->index = buf->index;
mutex_lock(&inst->cvpdspbufs.lock);
list_add_tail(&cbuf->list, &inst->cvpdspbufs.list);
mutex_unlock(&inst->cvpdspbufs.lock);
return rc;
exit:
if (smem->device_addr)
msm_cvp_unmap_smem(smem);
kmem_cache_free(cvp_driver->buf_cache, cbuf);
cbuf = NULL;
kmem_cache_free(cvp_driver->smem_cache, smem);
smem = NULL;
return rc;
}
static int msm_cvp_unmap_buf_dsp(struct msm_cvp_inst *inst,
struct cvp_kmd_buffer *buf)
{
int rc = 0;
bool found;
struct cvp_internal_buf *cbuf;
struct cvp_hal_session *session;
if (!inst || !inst->core || !buf) {
dprintk(CVP_ERR, "%s: invalid params\n", __func__);
return -EINVAL;
}
session = (struct cvp_hal_session *)inst->session;
if (!session) {
dprintk(CVP_ERR, "%s: invalid session\n", __func__);
return -EINVAL;
}
mutex_lock(&inst->cvpdspbufs.lock);
found = false;
list_for_each_entry(cbuf, &inst->cvpdspbufs.list, list) {
if (cbuf->fd == buf->fd) {
found = true;
break;
}
}
mutex_unlock(&inst->cvpdspbufs.lock);
if (!found) {
print_client_buffer(CVP_ERR, "invalid", inst, buf);
return -EINVAL;
}
if (buf->index) {
rc = cvp_dsp_deregister_buffer(hash32_ptr(session), buf->fd,
cbuf->smem->dma_buf->size, buf->size, buf->offset,
buf->index, (uint32_t)cbuf->smem->device_addr);
if (rc) {
dprintk(CVP_ERR,
"%s: failed dsp deregistration fd=%d rc=%d",
__func__, buf->fd, rc);
return rc;
}
}
if (cbuf->smem->device_addr)
msm_cvp_unmap_smem(cbuf->smem);
mutex_lock(&inst->cvpdspbufs.lock);
list_del(&cbuf->list);
mutex_unlock(&inst->cvpdspbufs.lock);
kmem_cache_free(cvp_driver->smem_cache, cbuf->smem);
kmem_cache_free(cvp_driver->buf_cache, cbuf);
return rc;
}
static void msm_cvp_cache_operations(struct msm_cvp_smem *smem, u32 type,
u32 offset, u32 size)
{
enum smem_cache_ops cache_op;
if (!smem) {
dprintk(CVP_ERR, "%s: invalid params\n", __func__);
return;
}
switch (type) {
case CVP_KMD_BUFTYPE_INPUT:
cache_op = SMEM_CACHE_CLEAN;
break;
case CVP_KMD_BUFTYPE_OUTPUT:
cache_op = SMEM_CACHE_INVALIDATE;
break;
default:
cache_op = SMEM_CACHE_CLEAN_INVALIDATE;
}
msm_cvp_smem_cache_operations(smem->dma_buf, cache_op, offset, size);
}
static struct msm_cvp_smem *msm_cvp_session_find_smem(
struct msm_cvp_inst *inst,
struct dma_buf *dma_buf)
{
struct msm_cvp_smem *smem;
mutex_lock(&inst->cpusmems.lock);
list_for_each_entry(smem, &inst->cpusmems.list, list) {
if (smem->dma_buf == dma_buf) {
atomic_inc(&smem->refcount);
/*
* If we find it, it means we already increased
* refcount before, so we put it to avoid double
* incremental.
*/
msm_cvp_smem_put_dma_buf(smem->dma_buf);
mutex_unlock(&inst->cpusmems.lock);
print_smem(CVP_DBG, "found", inst, smem);
return smem;
}
}
mutex_unlock(&inst->cpusmems.lock);
return NULL;
}
static int msm_cvp_session_add_smem(struct msm_cvp_inst *inst,
struct msm_cvp_smem *smem)
{
struct msm_cvp_smem *smem2, *d;
int found = false;
mutex_lock(&inst->cpusmems.lock);
if (inst->cpusmems.nr == inst->cpusmems.maxnr) {
list_for_each_entry_safe(smem2, d, &inst->cpusmems.list, list) {
if (atomic_read(&smem2->refcount) == 0) {
found = true;
list_del(&smem2->list);
msm_cvp_unmap_smem(smem2);
msm_cvp_smem_put_dma_buf(smem2->dma_buf);
kmem_cache_free(cvp_driver->smem_cache, smem2);
smem2 = NULL;
break;
}
}
if (!found) {
dprintk(CVP_ERR, "%s: not enough memory\n", __func__);
mutex_unlock(&inst->cpusmems.lock);
return -ENOMEM;
}
inst->cpusmems.nr--;
}
atomic_inc(&smem->refcount);
list_add_tail(&smem->list, &inst->cpusmems.list);
inst->cpusmems.nr++;
mutex_unlock(&inst->cpusmems.lock);
return 0;
}
static struct msm_cvp_smem *msm_cvp_session_get_smem(
struct msm_cvp_inst *inst,
struct cvp_buf_type *buf)
{
int rc = 0;
struct msm_cvp_smem *smem = NULL;
struct dma_buf *dma_buf = NULL;
if (buf->fd < 0) {
dprintk(CVP_ERR, "%s: Invalid fd = %d", __func__, buf->fd);
return NULL;
}
dma_buf = msm_cvp_smem_get_dma_buf(buf->fd);
if (!dma_buf) {
dprintk(CVP_ERR, "%s: Invalid fd = %d", __func__, buf->fd);
return NULL;
}
smem = msm_cvp_session_find_smem(inst, dma_buf);
if (!smem) {
smem = kmem_cache_zalloc(cvp_driver->smem_cache, GFP_KERNEL);
if (!smem)
return NULL;
smem->dma_buf = dma_buf;
rc = msm_cvp_map_smem(inst, smem);
if (rc)
goto exit;
rc = msm_cvp_session_add_smem(inst, smem);
if (rc)
goto exit2;
}
if (buf->size > smem->size || buf->size > smem->size - buf->offset) {
dprintk(CVP_ERR, "%s: invalid offset %d or size %d\n",
__func__, buf->offset, buf->size);
goto exit2;
}
return smem;
exit2:
msm_cvp_unmap_smem(smem);
exit:
msm_cvp_smem_put_dma_buf(dma_buf);
kmem_cache_free(cvp_driver->smem_cache, smem);
smem = NULL;
return smem;
}
static u32 msm_cvp_map_user_persist_buf(struct msm_cvp_inst *inst,
struct cvp_buf_type *buf)
{
u32 iova = 0;
struct msm_cvp_smem *smem = NULL;
struct cvp_internal_buf *pbuf;
if (!inst) {
dprintk(CVP_ERR, "%s: invalid params\n", __func__);
return -EINVAL;
}
pbuf = kmem_cache_zalloc(cvp_driver->buf_cache, GFP_KERNEL);
if (!pbuf)
return 0;
smem = msm_cvp_session_get_smem(inst, buf);
if (!smem)
goto exit;
pbuf->smem = smem;
pbuf->fd = buf->fd;
pbuf->size = buf->size;
pbuf->offset = buf->offset;
pbuf->ownership = CLIENT;
mutex_lock(&inst->persistbufs.lock);
list_add_tail(&pbuf->list, &inst->persistbufs.list);
mutex_unlock(&inst->persistbufs.lock);
print_internal_buffer(CVP_DBG, "map persist", inst, pbuf);
iova = smem->device_addr + buf->offset;
return iova;
exit:
kmem_cache_free(cvp_driver->buf_cache, pbuf);
return 0;
}
static u32 msm_cvp_map_frame_buf(struct msm_cvp_inst *inst,
struct cvp_buf_type *buf,
struct msm_cvp_frame *frame)
{
u32 iova = 0;
struct msm_cvp_smem *smem = NULL;
u32 nr;
u32 type;
if (!inst || !frame) {
dprintk(CVP_ERR, "%s: invalid params\n", __func__);
return 0;
}
nr = frame->nr;
if (nr == MAX_FRAME_BUFFER_NUMS) {
dprintk(CVP_ERR, "%s: max frame buffer reached\n", __func__);
return 0;
}
smem = msm_cvp_session_get_smem(inst, buf);
if (!smem)
return 0;
frame->bufs[nr].fd = buf->fd;
frame->bufs[nr].smem = smem;
frame->bufs[nr].size = buf->size;
frame->bufs[nr].offset = buf->offset;
print_internal_buffer(CVP_DBG, "map cpu", inst, &frame->bufs[nr]);
frame->nr++;
type = CVP_KMD_BUFTYPE_INPUT | CVP_KMD_BUFTYPE_OUTPUT;
msm_cvp_cache_operations(smem, type, buf->size, buf->offset);
iova = smem->device_addr + buf->offset;
return iova;
}
static void msm_cvp_unmap_frame_buf(struct msm_cvp_frame *frame)
{
u32 i;
u32 type;
struct msm_cvp_smem *smem = NULL;
struct cvp_internal_buf *buf;
type = CVP_KMD_BUFTYPE_OUTPUT;
for (i = 0; i < frame->nr; ++i) {
buf = &frame->bufs[i];
smem = buf->smem;
msm_cvp_cache_operations(smem, type, buf->size, buf->offset);
atomic_dec(&smem->refcount);
}
kmem_cache_free(cvp_driver->frame_cache, frame);
}
static void msm_cvp_unmap_frame(struct msm_cvp_inst *inst, u64 ktid)
{
struct msm_cvp_frame *frame, *dummy1;
bool found;
if (!inst) {
dprintk(CVP_ERR, "%s: invalid params\n", __func__);
return;
}
ktid &= (FENCE_BIT - 1);
dprintk(CVP_DBG, "%s: unmap frame %llu\n", __func__, ktid);
found = false;
mutex_lock(&inst->frames.lock);
list_for_each_entry_safe(frame, dummy1, &inst->frames.list, list) {
if (frame->ktid == ktid) {
found = true;
list_del(&frame->list);
break;
}
}
mutex_unlock(&inst->frames.lock);
if (found)
msm_cvp_unmap_frame_buf(frame);
else
dprintk(CVP_WARN, "%s frame %llu not found!\n", __func__, ktid);
}
static bool cvp_msg_pending(struct cvp_session_queue *sq,
struct cvp_session_msg **msg, u64 *ktid)
@ -619,178 +150,6 @@ static int msm_cvp_session_receive_hfi(struct msm_cvp_inst *inst,
return rc;
}
static int msm_cvp_unmap_user_persist(struct msm_cvp_inst *inst,
struct cvp_kmd_hfi_packet *in_pkt,
unsigned int offset, unsigned int buf_num)
{
struct cvp_buf_type *buf;
struct cvp_hfi_cmd_session_hdr *cmd_hdr;
struct cvp_internal_buf *pbuf, *dummy;
u64 ktid;
int i, rc = 0;
struct msm_cvp_smem *smem = NULL;
if (!offset || !buf_num)
return 0;
cmd_hdr = (struct cvp_hfi_cmd_session_hdr *)in_pkt;
ktid = cmd_hdr->client_data.kdata & (FENCE_BIT - 1);
for (i = 0; i < buf_num; i++) {
buf = (struct cvp_buf_type *)&in_pkt->pkt_data[offset];
offset += sizeof(*buf) >> 2;
mutex_lock(&inst->persistbufs.lock);
list_for_each_entry_safe(pbuf, dummy, &inst->persistbufs.list,
list) {
if (pbuf->ktid == ktid) {
list_del(&pbuf->list);
smem = pbuf->smem;
atomic_dec(&smem->refcount);
dprintk(CVP_DBG, "unmap persist: %x %d %d %#x",
hash32_ptr(inst->session), pbuf->fd,
pbuf->size, smem->device_addr);
kmem_cache_free(cvp_driver->buf_cache, pbuf);
break;
}
}
mutex_unlock(&inst->persistbufs.lock);
}
return rc;
}
static int msm_cvp_mark_user_persist(struct msm_cvp_inst *inst,
struct cvp_kmd_hfi_packet *in_pkt,
unsigned int offset, unsigned int buf_num)
{
struct cvp_hfi_cmd_session_hdr *cmd_hdr;
struct cvp_internal_buf *pbuf, *dummy;
u64 ktid;
struct cvp_buf_type *buf;
int i, rc = 0;
if (!offset || !buf_num)
return 0;
cmd_hdr = (struct cvp_hfi_cmd_session_hdr *)in_pkt;
ktid = atomic64_inc_return(&inst->core->kernel_trans_id);
ktid &= (FENCE_BIT - 1);
cmd_hdr->client_data.kdata = ktid;
for (i = 0; i < buf_num; i++) {
buf = (struct cvp_buf_type *)&in_pkt->pkt_data[offset];
offset += sizeof(*buf) >> 2;
if (buf->fd < 0 || !buf->size)
continue;
mutex_lock(&inst->persistbufs.lock);
list_for_each_entry_safe(pbuf, dummy, &inst->persistbufs.list,
list) {
if (pbuf->fd == buf->fd && pbuf->size == buf->size &&
pbuf->ownership == CLIENT) {
rc = 1;
break;
}
}
mutex_unlock(&inst->persistbufs.lock);
if (!rc) {
dprintk(CVP_ERR, "%s No persist buf %d found\n",
__func__, buf->fd);
rc = -EFAULT;
break;
}
buf->fd = pbuf->smem->device_addr;
pbuf->ktid = ktid;
rc = 0;
}
return rc;
}
static int msm_cvp_map_user_persist(struct msm_cvp_inst *inst,
struct cvp_kmd_hfi_packet *in_pkt,
unsigned int offset, unsigned int buf_num)
{
struct cvp_buf_type *buf;
int i;
u32 iova;
if (!offset || !buf_num)
return 0;
for (i = 0; i < buf_num; i++) {
buf = (struct cvp_buf_type *)&in_pkt->pkt_data[offset];
offset += sizeof(*buf) >> 2;
if (buf->fd < 0 || !buf->size)
continue;
iova = msm_cvp_map_user_persist_buf(inst, buf);
if (!iova) {
dprintk(CVP_ERR,
"%s: buf %d register failed.\n",
__func__, i);
return -EINVAL;
}
buf->fd = iova;
}
return 0;
}
static int msm_cvp_map_frame(struct msm_cvp_inst *inst,
struct cvp_kmd_hfi_packet *in_pkt,
unsigned int offset, unsigned int buf_num)
{
struct cvp_buf_type *buf;
int i;
u32 iova;
u64 ktid;
struct msm_cvp_frame *frame;
struct cvp_hfi_cmd_session_hdr *cmd_hdr;
if (!offset || !buf_num)
return 0;
cmd_hdr = (struct cvp_hfi_cmd_session_hdr *)in_pkt;
ktid = atomic64_inc_return(&inst->core->kernel_trans_id);
ktid &= (FENCE_BIT - 1);
cmd_hdr->client_data.kdata = ktid;
frame = kmem_cache_zalloc(cvp_driver->frame_cache, GFP_KERNEL);
if (!frame)
return -ENOMEM;
frame->ktid = ktid;
frame->nr = 0;
for (i = 0; i < buf_num; i++) {
buf = (struct cvp_buf_type *)&in_pkt->pkt_data[offset];
offset += sizeof(*buf) >> 2;
if (buf->fd < 0 || !buf->size)
continue;
iova = msm_cvp_map_frame_buf(inst, buf, frame);
if (!iova) {
dprintk(CVP_ERR,
"%s: buf %d register failed.\n",
__func__, i);
msm_cvp_unmap_frame_buf(frame);
return -EINVAL;
}
buf->fd = iova;
}
mutex_lock(&inst->frames.lock);
list_add_tail(&frame->list, &inst->frames.list);
mutex_unlock(&inst->frames.lock);
dprintk(CVP_DBG, "%s: map frame %llu\n", __func__, ktid);
return 0;
}
static int msm_cvp_session_process_hfi(
struct msm_cvp_inst *inst,
struct cvp_kmd_hfi_packet *in_pkt,
@ -2678,9 +2037,6 @@ int msm_cvp_session_deinit(struct msm_cvp_inst *inst)
{
int rc = 0;
struct cvp_hal_session *session;
struct cvp_internal_buf *cbuf, *dummy;
struct msm_cvp_frame *frame, *dummy1;
struct msm_cvp_smem *smem, *dummy3;
if (!inst || !inst->core) {
dprintk(CVP_ERR, "%s: invalid params\n", __func__);
@ -2697,48 +2053,7 @@ int msm_cvp_session_deinit(struct msm_cvp_inst *inst)
if (rc)
dprintk(CVP_ERR, "%s: close failed\n", __func__);
mutex_lock(&inst->frames.lock);
list_for_each_entry_safe(frame, dummy1, &inst->frames.list, list) {
list_del(&frame->list);
msm_cvp_unmap_frame_buf(frame);
}
mutex_unlock(&inst->frames.lock);
mutex_lock(&inst->cpusmems.lock);
list_for_each_entry_safe(smem, dummy3, &inst->cpusmems.list, list) {
if (atomic_read(&smem->refcount) == 0) {
list_del(&smem->list);
print_smem(CVP_DBG, "free", inst, smem);
msm_cvp_unmap_smem(smem);
msm_cvp_smem_put_dma_buf(smem->dma_buf);
kmem_cache_free(cvp_driver->smem_cache, smem);
smem = NULL;
} else {
print_smem(CVP_WARN, "in use", inst, smem);
}
}
mutex_unlock(&inst->cpusmems.lock);
mutex_lock(&inst->cvpdspbufs.lock);
list_for_each_entry_safe(cbuf, dummy, &inst->cvpdspbufs.list,
list) {
print_internal_buffer(CVP_DBG, "remove dspbufs", inst, cbuf);
rc = cvp_dsp_deregister_buffer(hash32_ptr(session),
cbuf->fd, cbuf->smem->dma_buf->size, cbuf->size,
cbuf->offset, cbuf->index,
(uint32_t)cbuf->smem->device_addr);
if (rc)
dprintk(CVP_ERR,
"%s: failed dsp deregistration fd=%d rc=%d",
__func__, cbuf->fd, rc);
msm_cvp_unmap_smem(cbuf->smem);
msm_cvp_smem_put_dma_buf(cbuf->smem->dma_buf);
list_del(&cbuf->list);
kmem_cache_free(cvp_driver->buf_cache, cbuf);
}
mutex_unlock(&inst->cvpdspbufs.lock);
rc = msm_cvp_session_deinit_buffers(inst);
return rc;
}

922
drivers/media/platform/msm/cvp/msm_cvp_buf.c Normal file
View file

@ -0,0 +1,922 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2020, The Linux Foundation. All rights reserved.
*/
#include "msm_cvp_common.h"
#include "cvp_hfi_api.h"
#include "msm_cvp_debug.h"
#include "msm_cvp_core.h"
#include "msm_cvp_dsp.h"
void print_smem(u32 tag, const char *str, struct msm_cvp_inst *inst,
struct msm_cvp_smem *smem)
{
if (!(tag & msm_cvp_debug) || !inst || !smem)
return;
if (smem->dma_buf) {
dprintk(tag, "%s: %x : %s size %d flags %#x iova %#x", str,
hash32_ptr(inst->session), smem->dma_buf->name,
smem->size, smem->flags, smem->device_addr);
}
}
static void print_internal_buffer(u32 tag, const char *str,
struct msm_cvp_inst *inst, struct cvp_internal_buf *cbuf)
{
if (!(tag & msm_cvp_debug) || !inst || !cbuf)
return;
if (cbuf->smem->dma_buf) {
dprintk(tag,
"%s: %x : fd %d off %d %s size %d iova %#x",
str, hash32_ptr(inst->session), cbuf->fd,
cbuf->offset, cbuf->smem->dma_buf->name, cbuf->size,
cbuf->smem->device_addr);
} else {
dprintk(tag,
"%s: %x : idx %2d fd %d off %d size %d iova %#x",
str, hash32_ptr(inst->session), cbuf->fd,
cbuf->offset, cbuf->size, cbuf->smem->device_addr);
}
}
void print_cvp_buffer(u32 tag, const char *str, struct msm_cvp_inst *inst,
struct cvp_internal_buf *cbuf)
{
dprintk(tag, "%s addr: %x size %u\n", str,
cbuf->smem->device_addr, cbuf->size);
}
void print_client_buffer(u32 tag, const char *str,
struct msm_cvp_inst *inst, struct cvp_kmd_buffer *cbuf)
{
if (!(tag & msm_cvp_debug) || !inst || !cbuf)
return;
dprintk(tag,
"%s: %x : idx %2d fd %d off %d size %d type %d flags 0x%x\n",
str, hash32_ptr(inst->session), cbuf->index, cbuf->fd,
cbuf->offset, cbuf->size, cbuf->type, cbuf->flags);
}
int msm_cvp_map_buf_dsp(struct msm_cvp_inst *inst, struct cvp_kmd_buffer *buf)
{
int rc = 0;
bool found = false;
struct cvp_internal_buf *cbuf;
struct msm_cvp_smem *smem = NULL;
struct cvp_hal_session *session;
struct dma_buf *dma_buf = NULL;
if (!inst || !inst->core || !buf) {
dprintk(CVP_ERR, "%s: invalid params\n", __func__);
return -EINVAL;
}
if (buf->fd < 0) {
dprintk(CVP_ERR, "%s: Invalid fd = %d", __func__, buf->fd);
return 0;
}
if (buf->offset) {
dprintk(CVP_ERR,
"%s: offset is deprecated, set to 0.\n",
__func__);
return -EINVAL;
}
session = (struct cvp_hal_session *)inst->session;
mutex_lock(&inst->cvpdspbufs.lock);
list_for_each_entry(cbuf, &inst->cvpdspbufs.list, list) {
if (cbuf->fd == buf->fd) {
if (cbuf->size != buf->size) {
dprintk(CVP_ERR, "%s: buf size mismatch\n",
__func__);
mutex_unlock(&inst->cvpdspbufs.lock);
return -EINVAL;
}
found = true;
break;
}
}
mutex_unlock(&inst->cvpdspbufs.lock);
if (found) {
print_internal_buffer(CVP_ERR, "duplicate", inst, cbuf);
return -EINVAL;
}
dma_buf = msm_cvp_smem_get_dma_buf(buf->fd);
if (!dma_buf) {
dprintk(CVP_ERR, "%s: Invalid fd = %d", __func__, buf->fd);
return 0;
}
cbuf = kmem_cache_zalloc(cvp_driver->buf_cache, GFP_KERNEL);
if (!cbuf)
return -ENOMEM;
smem = kmem_cache_zalloc(cvp_driver->smem_cache, GFP_KERNEL);
if (!smem) {
kmem_cache_free(cvp_driver->buf_cache, cbuf);
return -ENOMEM;
}
smem->dma_buf = dma_buf;
dprintk(CVP_ERR, "%s: dma_buf = %llx\n", __func__, dma_buf);
rc = msm_cvp_map_smem(inst, smem);
if (rc) {
print_client_buffer(CVP_ERR, "map failed", inst, buf);
goto exit;
}
if (buf->index) {
rc = cvp_dsp_register_buffer(hash32_ptr(session), buf->fd,
smem->dma_buf->size, buf->size, buf->offset,
buf->index, (uint32_t)smem->device_addr);
if (rc) {
dprintk(CVP_ERR,
"%s: failed dsp registration for fd=%d rc=%d",
__func__, buf->fd, rc);
goto exit;
}
} else {
dprintk(CVP_ERR, "%s: buf index is 0 fd=%d", __func__, buf->fd);
rc = -EINVAL;
goto exit;
}
cbuf->smem = smem;
cbuf->fd = buf->fd;
cbuf->size = buf->size;
cbuf->offset = buf->offset;
cbuf->ownership = CLIENT;
cbuf->index = buf->index;
mutex_lock(&inst->cvpdspbufs.lock);
list_add_tail(&cbuf->list, &inst->cvpdspbufs.list);
mutex_unlock(&inst->cvpdspbufs.lock);
return rc;
exit:
if (smem->device_addr)
msm_cvp_unmap_smem(smem);
kmem_cache_free(cvp_driver->buf_cache, cbuf);
cbuf = NULL;
kmem_cache_free(cvp_driver->smem_cache, smem);
smem = NULL;
return rc;
}
int msm_cvp_unmap_buf_dsp(struct msm_cvp_inst *inst, struct cvp_kmd_buffer *buf)
{
int rc = 0;
bool found;
struct cvp_internal_buf *cbuf;
struct cvp_hal_session *session;
if (!inst || !inst->core || !buf) {
dprintk(CVP_ERR, "%s: invalid params\n", __func__);
return -EINVAL;
}
session = (struct cvp_hal_session *)inst->session;
if (!session) {
dprintk(CVP_ERR, "%s: invalid session\n", __func__);
return -EINVAL;
}
mutex_lock(&inst->cvpdspbufs.lock);
found = false;
list_for_each_entry(cbuf, &inst->cvpdspbufs.list, list) {
if (cbuf->fd == buf->fd) {
found = true;
break;
}
}
mutex_unlock(&inst->cvpdspbufs.lock);
if (!found) {
print_client_buffer(CVP_ERR, "invalid", inst, buf);
return -EINVAL;
}
if (buf->index) {
rc = cvp_dsp_deregister_buffer(hash32_ptr(session), buf->fd,
cbuf->smem->dma_buf->size, buf->size, buf->offset,
buf->index, (uint32_t)cbuf->smem->device_addr);
if (rc) {
dprintk(CVP_ERR,
"%s: failed dsp deregistration fd=%d rc=%d",
__func__, buf->fd, rc);
return rc;
}
}
if (cbuf->smem->device_addr)
msm_cvp_unmap_smem(cbuf->smem);
mutex_lock(&inst->cvpdspbufs.lock);
list_del(&cbuf->list);
mutex_unlock(&inst->cvpdspbufs.lock);
kmem_cache_free(cvp_driver->smem_cache, cbuf->smem);
kmem_cache_free(cvp_driver->buf_cache, cbuf);
return rc;
}
void msm_cvp_cache_operations(struct msm_cvp_smem *smem, u32 type,
u32 offset, u32 size)
{
enum smem_cache_ops cache_op;
if (!smem) {
dprintk(CVP_ERR, "%s: invalid params\n", __func__);
return;
}
switch (type) {
case CVP_KMD_BUFTYPE_INPUT:
cache_op = SMEM_CACHE_CLEAN;
break;
case CVP_KMD_BUFTYPE_OUTPUT:
cache_op = SMEM_CACHE_INVALIDATE;
break;
default:
cache_op = SMEM_CACHE_CLEAN_INVALIDATE;
}
msm_cvp_smem_cache_operations(smem->dma_buf, cache_op, offset, size);
}
static struct msm_cvp_smem *msm_cvp_session_find_smem(struct msm_cvp_inst *inst,
struct dma_buf *dma_buf)
{
struct msm_cvp_smem *smem;
mutex_lock(&inst->dma_cache.lock);
list_for_each_entry(smem, &inst->dma_cache.list, list) {
if (smem->dma_buf == dma_buf) {
atomic_inc(&smem->refcount);
/*
* If we find it, it means we already increased
* refcount before, so we put it to avoid double
* incremental.
*/
msm_cvp_smem_put_dma_buf(smem->dma_buf);
mutex_unlock(&inst->dma_cache.lock);
print_smem(CVP_DBG, "found", inst, smem);
return smem;
}
}
mutex_unlock(&inst->dma_cache.lock);
return NULL;
}
static int msm_cvp_session_add_smem(struct msm_cvp_inst *inst,
struct msm_cvp_smem *smem)
{
struct msm_cvp_smem *smem2, *d;
int found = false;
mutex_lock(&inst->dma_cache.lock);
if (inst->dma_cache.nr == inst->dma_cache.maxnr) {
list_for_each_entry_safe(smem2, d,
&inst->dma_cache.list, list) {
if (atomic_read(&smem2->refcount) == 0) {
found = true;
list_del(&smem2->list);
msm_cvp_unmap_smem(smem2);
msm_cvp_smem_put_dma_buf(smem2->dma_buf);
kmem_cache_free(cvp_driver->smem_cache, smem2);
smem2 = NULL;
break;
}
}
if (!found) {
dprintk(CVP_WARN, "%s: not enough memory\n", __func__);
mutex_unlock(&inst->dma_cache.lock);
return -ENOMEM;
}
inst->dma_cache.nr--;
}
atomic_inc(&smem->refcount);
list_add_tail(&smem->list, &inst->dma_cache.list);
inst->dma_cache.nr++;
mutex_unlock(&inst->dma_cache.lock);
return 0;
}
static struct msm_cvp_smem *msm_cvp_session_get_smem(struct msm_cvp_inst *inst,
struct cvp_buf_type *buf)
{
int rc = 0;
struct msm_cvp_smem *smem = NULL;
struct dma_buf *dma_buf = NULL;
if (buf->fd < 0) {
dprintk(CVP_ERR, "%s: Invalid fd = %d", __func__, buf->fd);
return NULL;
}
dma_buf = msm_cvp_smem_get_dma_buf(buf->fd);
if (!dma_buf) {
dprintk(CVP_ERR, "%s: Invalid fd = %d", __func__, buf->fd);
return NULL;
}
smem = msm_cvp_session_find_smem(inst, dma_buf);
if (!smem) {
smem = kmem_cache_zalloc(cvp_driver->smem_cache, GFP_KERNEL);
if (!smem)
return NULL;
smem->dma_buf = dma_buf;
rc = msm_cvp_map_smem(inst, smem);
if (rc)
goto exit;
rc = msm_cvp_session_add_smem(inst, smem);
if (rc && rc != -ENOMEM)
goto exit2;
}
if (buf->size > smem->size || buf->size > smem->size - buf->offset) {
dprintk(CVP_ERR, "%s: invalid offset %d or size %d\n",
__func__, buf->offset, buf->size);
goto exit2;
}
return smem;
exit2:
msm_cvp_unmap_smem(smem);
exit:
msm_cvp_smem_put_dma_buf(dma_buf);
kmem_cache_free(cvp_driver->smem_cache, smem);
smem = NULL;
return smem;
}
static u32 msm_cvp_map_user_persist_buf(struct msm_cvp_inst *inst,
struct cvp_buf_type *buf)
{
u32 iova = 0;
struct msm_cvp_smem *smem = NULL;
struct cvp_internal_buf *pbuf;
if (!inst) {
dprintk(CVP_ERR, "%s: invalid params\n", __func__);
return -EINVAL;
}
pbuf = kmem_cache_zalloc(cvp_driver->buf_cache, GFP_KERNEL);
if (!pbuf)
return 0;
smem = msm_cvp_session_get_smem(inst, buf);
if (!smem)
goto exit;
pbuf->smem = smem;
pbuf->fd = buf->fd;
pbuf->size = buf->size;
pbuf->offset = buf->offset;
pbuf->ownership = CLIENT;
mutex_lock(&inst->persistbufs.lock);
list_add_tail(&pbuf->list, &inst->persistbufs.list);
mutex_unlock(&inst->persistbufs.lock);
print_internal_buffer(CVP_DBG, "map persist", inst, pbuf);
iova = smem->device_addr + buf->offset;
return iova;
exit:
kmem_cache_free(cvp_driver->buf_cache, pbuf);
return 0;
}
u32 msm_cvp_map_frame_buf(struct msm_cvp_inst *inst,
struct cvp_buf_type *buf,
struct msm_cvp_frame *frame)
{
u32 iova = 0;
struct msm_cvp_smem *smem = NULL;
u32 nr;
u32 type;
if (!inst || !frame) {
dprintk(CVP_ERR, "%s: invalid params\n", __func__);
return 0;
}
nr = frame->nr;
if (nr == MAX_FRAME_BUFFER_NUMS) {
dprintk(CVP_ERR, "%s: max frame buffer reached\n", __func__);
return 0;
}
smem = msm_cvp_session_get_smem(inst, buf);
if (!smem)
return 0;
frame->bufs[nr].fd = buf->fd;
frame->bufs[nr].smem = smem;
frame->bufs[nr].size = buf->size;
frame->bufs[nr].offset = buf->offset;
print_internal_buffer(CVP_DBG, "map cpu", inst, &frame->bufs[nr]);
frame->nr++;
type = CVP_KMD_BUFTYPE_INPUT | CVP_KMD_BUFTYPE_OUTPUT;
msm_cvp_cache_operations(smem, type, buf->size, buf->offset);
iova = smem->device_addr + buf->offset;
return iova;
}
void msm_cvp_unmap_frame_buf(struct msm_cvp_frame *frame)
{
u32 i;
u32 type;
struct msm_cvp_smem *smem = NULL;
struct cvp_internal_buf *buf;
type = CVP_KMD_BUFTYPE_OUTPUT;
for (i = 0; i < frame->nr; ++i) {
buf = &frame->bufs[i];
smem = buf->smem;
msm_cvp_cache_operations(smem, type, buf->size, buf->offset);
if (atomic_read(&smem->refcount) > 0) {
atomic_dec(&smem->refcount);
} else {
msm_cvp_unmap_smem(smem);
dma_buf_put(smem->dma_buf);
kfree(smem);
buf->smem = NULL;
}
}
kmem_cache_free(cvp_driver->frame_cache, frame);
}
void msm_cvp_unmap_frame(struct msm_cvp_inst *inst, u64 ktid)
{
struct msm_cvp_frame *frame, *dummy1;
bool found;
if (!inst) {
dprintk(CVP_ERR, "%s: invalid params\n", __func__);
return;
}
ktid &= (FENCE_BIT - 1);
dprintk(CVP_DBG, "%s: unmap frame %llu\n", __func__, ktid);
found = false;
mutex_lock(&inst->frames.lock);
list_for_each_entry_safe(frame, dummy1, &inst->frames.list, list) {
if (frame->ktid == ktid) {
found = true;
list_del(&frame->list);
break;
}
}
mutex_unlock(&inst->frames.lock);
if (found)
msm_cvp_unmap_frame_buf(frame);
else
dprintk(CVP_WARN, "%s frame %llu not found!\n", __func__, ktid);
}
int msm_cvp_unmap_user_persist(struct msm_cvp_inst *inst,
struct cvp_kmd_hfi_packet *in_pkt,
unsigned int offset, unsigned int buf_num)
{
struct cvp_buf_type *buf;
struct cvp_hfi_cmd_session_hdr *cmd_hdr;
struct cvp_internal_buf *pbuf, *dummy;
u64 ktid;
int i, rc = 0;
struct msm_cvp_smem *smem = NULL;
if (!offset || !buf_num)
return 0;
cmd_hdr = (struct cvp_hfi_cmd_session_hdr *)in_pkt;
ktid = cmd_hdr->client_data.kdata & (FENCE_BIT - 1);
for (i = 0; i < buf_num; i++) {
buf = (struct cvp_buf_type *)&in_pkt->pkt_data[offset];
offset += sizeof(*buf) >> 2;
mutex_lock(&inst->persistbufs.lock);
list_for_each_entry_safe(pbuf, dummy, &inst->persistbufs.list,
list) {
if (pbuf->ktid == ktid) {
list_del(&pbuf->list);
smem = pbuf->smem;
dprintk(CVP_DBG, "unmap persist: %x %d %d %#x",
hash32_ptr(inst->session), pbuf->fd,
pbuf->size, smem->device_addr);
if (atomic_read(&smem->refcount) > 0) {
atomic_dec(&smem->refcount);
} else {
msm_cvp_unmap_smem(smem);
dma_buf_put(smem->dma_buf);
kfree(smem);
pbuf->smem = NULL;
}
kmem_cache_free(cvp_driver->buf_cache, pbuf);
break;
}
}
mutex_unlock(&inst->persistbufs.lock);
}
return rc;
}
int msm_cvp_mark_user_persist(struct msm_cvp_inst *inst,
struct cvp_kmd_hfi_packet *in_pkt,
unsigned int offset, unsigned int buf_num)
{
struct cvp_hfi_cmd_session_hdr *cmd_hdr;
struct cvp_internal_buf *pbuf, *dummy;
u64 ktid;
struct cvp_buf_type *buf;
int i, rc = 0;
if (!offset || !buf_num)
return 0;
cmd_hdr = (struct cvp_hfi_cmd_session_hdr *)in_pkt;
ktid = atomic64_inc_return(&inst->core->kernel_trans_id);
ktid &= (FENCE_BIT - 1);
cmd_hdr->client_data.kdata = ktid;
for (i = 0; i < buf_num; i++) {
buf = (struct cvp_buf_type *)&in_pkt->pkt_data[offset];
offset += sizeof(*buf) >> 2;
if (buf->fd < 0 || !buf->size)
continue;
mutex_lock(&inst->persistbufs.lock);
list_for_each_entry_safe(pbuf, dummy, &inst->persistbufs.list,
list) {
if (pbuf->fd == buf->fd && pbuf->size == buf->size &&
pbuf->ownership == CLIENT) {
rc = 1;
break;
}
}
mutex_unlock(&inst->persistbufs.lock);
if (!rc) {
dprintk(CVP_ERR, "%s No persist buf %d found\n",
__func__, buf->fd);
rc = -EFAULT;
break;
}
buf->fd = pbuf->smem->device_addr;
pbuf->ktid = ktid;
rc = 0;
}
return rc;
}
int msm_cvp_map_user_persist(struct msm_cvp_inst *inst,
struct cvp_kmd_hfi_packet *in_pkt,
unsigned int offset, unsigned int buf_num)
{
struct cvp_buf_type *buf;
int i;
u32 iova;
if (!offset || !buf_num)
return 0;
for (i = 0; i < buf_num; i++) {
buf = (struct cvp_buf_type *)&in_pkt->pkt_data[offset];
offset += sizeof(*buf) >> 2;
if (buf->fd < 0 || !buf->size)
continue;
iova = msm_cvp_map_user_persist_buf(inst, buf);
if (!iova) {
dprintk(CVP_ERR,
"%s: buf %d register failed.\n",
__func__, i);
return -EINVAL;
}
buf->fd = iova;
}
return 0;
}
int msm_cvp_map_frame(struct msm_cvp_inst *inst,
struct cvp_kmd_hfi_packet *in_pkt,
unsigned int offset, unsigned int buf_num)
{
struct cvp_buf_type *buf;
int i;
u32 iova;
u64 ktid;
struct msm_cvp_frame *frame;
struct cvp_hfi_cmd_session_hdr *cmd_hdr;
if (!offset || !buf_num)
return 0;
cmd_hdr = (struct cvp_hfi_cmd_session_hdr *)in_pkt;
ktid = atomic64_inc_return(&inst->core->kernel_trans_id);
ktid &= (FENCE_BIT - 1);
cmd_hdr->client_data.kdata = ktid;
frame = kmem_cache_zalloc(cvp_driver->frame_cache, GFP_KERNEL);
if (!frame)
return -ENOMEM;
frame->ktid = ktid;
frame->nr = 0;
for (i = 0; i < buf_num; i++) {
buf = (struct cvp_buf_type *)&in_pkt->pkt_data[offset];
offset += sizeof(*buf) >> 2;
if (buf->fd < 0 || !buf->size)
continue;
iova = msm_cvp_map_frame_buf(inst, buf, frame);
if (!iova) {
dprintk(CVP_ERR,
"%s: buf %d register failed.\n",
__func__, i);
msm_cvp_unmap_frame_buf(frame);
return -EINVAL;
}
buf->fd = iova;
}
mutex_lock(&inst->frames.lock);
list_add_tail(&frame->list, &inst->frames.list);
mutex_unlock(&inst->frames.lock);
dprintk(CVP_DBG, "%s: map frame %llu\n", __func__, ktid);
return 0;
}
int msm_cvp_session_deinit_buffers(struct msm_cvp_inst *inst)
{
int rc = 0;
struct cvp_internal_buf *cbuf, *dummy;
struct msm_cvp_frame *frame, *dummy1;
struct msm_cvp_smem *smem, *dummy3;
struct cvp_hal_session *session;
session = (struct cvp_hal_session *)inst->session;
mutex_lock(&inst->frames.lock);
list_for_each_entry_safe(frame, dummy1, &inst->frames.list, list) {
list_del(&frame->list);
msm_cvp_unmap_frame_buf(frame);
}
mutex_unlock(&inst->frames.lock);
mutex_lock(&inst->dma_cache.lock);
list_for_each_entry_safe(smem, dummy3, &inst->dma_cache.list, list) {
if (atomic_read(&smem->refcount) == 0) {
list_del(&smem->list);
print_smem(CVP_DBG, "free", inst, smem);
msm_cvp_unmap_smem(smem);
msm_cvp_smem_put_dma_buf(smem->dma_buf);
kmem_cache_free(cvp_driver->smem_cache, smem);
smem = NULL;
} else {
print_smem(CVP_WARN, "in use", inst, smem);
}
}
mutex_unlock(&inst->dma_cache.lock);
mutex_lock(&inst->cvpdspbufs.lock);
list_for_each_entry_safe(cbuf, dummy, &inst->cvpdspbufs.list,
list) {
print_internal_buffer(CVP_DBG, "remove dspbufs", inst, cbuf);
rc = cvp_dsp_deregister_buffer(hash32_ptr(session),
cbuf->fd, cbuf->smem->dma_buf->size, cbuf->size,
cbuf->offset, cbuf->index,
(uint32_t)cbuf->smem->device_addr);
if (rc)
dprintk(CVP_ERR,
"%s: failed dsp deregistration fd=%d rc=%d",
__func__, cbuf->fd, rc);
msm_cvp_unmap_smem(cbuf->smem);
msm_cvp_smem_put_dma_buf(cbuf->smem->dma_buf);
list_del(&cbuf->list);
kmem_cache_free(cvp_driver->buf_cache, cbuf);
}
mutex_unlock(&inst->cvpdspbufs.lock);
return rc;
}
void msm_cvp_print_inst_bufs(struct msm_cvp_inst *inst)
{
struct cvp_internal_buf *buf;
struct msm_cvp_smem *smem;
if (!inst) {
dprintk(CVP_ERR, "%s - invalid param %pK\n",
__func__, inst);
return;
}
dprintk(CVP_ERR, "active session cmd %d\n", inst->cur_cmd_type);
dprintk(CVP_ERR,
"---Buffer details for inst: %pK of type: %d---\n",
inst, inst->session_type);
mutex_lock(&inst->dma_cache.lock);
dprintk(CVP_ERR, "dma cache:\n");
list_for_each_entry(smem, &inst->dma_cache.list, list)
print_smem(CVP_ERR, "bufdump", inst, smem);
mutex_unlock(&inst->dma_cache.lock);
mutex_lock(&inst->cvpdspbufs.lock);
dprintk(CVP_ERR, "dsp buffer list:\n");
list_for_each_entry(buf, &inst->cvpdspbufs.list, list)
print_cvp_buffer(CVP_ERR, "bufdump", inst, buf);
mutex_unlock(&inst->cvpdspbufs.lock);
mutex_lock(&inst->persistbufs.lock);
dprintk(CVP_ERR, "persist buffer list:\n");
list_for_each_entry(buf, &inst->persistbufs.list, list)
print_cvp_buffer(CVP_ERR, "bufdump", inst, buf);
mutex_unlock(&inst->persistbufs.lock);
}
struct cvp_internal_buf *cvp_allocate_arp_bufs(struct msm_cvp_inst *inst,
u32 buffer_size)
{
struct cvp_internal_buf *buf;
struct msm_cvp_list *buf_list;
u32 smem_flags = SMEM_UNCACHED;
int rc = 0;
if (!inst) {
dprintk(CVP_ERR, "%s Invalid input\n", __func__);
return NULL;
}
buf_list = &inst->persistbufs;
if (!buffer_size)
return NULL;
/* PERSIST buffer requires secure mapping */
smem_flags |= SMEM_SECURE | SMEM_NON_PIXEL;
buf = kmem_cache_zalloc(cvp_driver->buf_cache, GFP_KERNEL);
if (!buf) {
dprintk(CVP_ERR, "%s Out of memory\n", __func__);
goto fail_kzalloc;
}
buf->smem = kmem_cache_zalloc(cvp_driver->smem_cache, GFP_KERNEL);
if (!buf->smem) {
dprintk(CVP_ERR, "%s Out of memory\n", __func__);
goto fail_kzalloc;
}
rc = msm_cvp_smem_alloc(buffer_size, 1, smem_flags, 0,
&(inst->core->resources), buf->smem);
if (rc) {
dprintk(CVP_ERR, "Failed to allocate ARP memory\n");
goto err_no_mem;
}
buf->size = buf->smem->size;
buf->type = HFI_BUFFER_INTERNAL_PERSIST_1;
buf->ownership = DRIVER;
mutex_lock(&buf_list->lock);
list_add_tail(&buf->list, &buf_list->list);
mutex_unlock(&buf_list->lock);
return buf;
err_no_mem:
kmem_cache_free(cvp_driver->buf_cache, buf);
fail_kzalloc:
return NULL;
}
int cvp_release_arp_buffers(struct msm_cvp_inst *inst)
{
struct msm_cvp_smem *smem;
struct list_head *ptr, *next;
struct cvp_internal_buf *buf;
int rc = 0;
struct msm_cvp_core *core;
struct cvp_hfi_device *hdev;
int all_released;
if (!inst) {
dprintk(CVP_ERR, "Invalid instance pointer = %pK\n", inst);
return -EINVAL;
}
core = inst->core;
if (!core) {
dprintk(CVP_ERR, "Invalid core pointer = %pK\n", core);
return -EINVAL;
}
hdev = core->device;
if (!hdev) {
dprintk(CVP_ERR, "Invalid device pointer = %pK\n", hdev);
return -EINVAL;
}
dprintk(CVP_DBG, "release persist buffer!\n");
all_released = 0;
mutex_lock(&inst->persistbufs.lock);
list_for_each_safe(ptr, next, &inst->persistbufs.list) {
buf = list_entry(ptr, struct cvp_internal_buf, list);
smem = buf->smem;
if (!smem) {
dprintk(CVP_ERR, "%s invalid smem\n", __func__);
mutex_unlock(&inst->persistbufs.lock);
return -EINVAL;
}
/* Workaround for FW: release buffer means release all */
if (inst->state <= MSM_CVP_CLOSE_DONE && !all_released) {
rc = call_hfi_op(hdev, session_release_buffers,
(void *)inst->session);
if (!rc) {
mutex_unlock(&inst->persistbufs.lock);
rc = wait_for_sess_signal_receipt(inst,
HAL_SESSION_RELEASE_BUFFER_DONE);
if (rc)
dprintk(CVP_WARN,
"%s: wait for signal failed, rc %d\n",
__func__, rc);
mutex_lock(&inst->persistbufs.lock);
} else {
dprintk(CVP_WARN,
"Rel prst buf fail:%x, %d\n",
smem->device_addr,
smem->size);
}
all_released = 1;
}
list_del(&buf->list);
if (buf->ownership == DRIVER) {
dprintk(CVP_DBG,
"%s: %x : fd %d %s size %d",
"free arp", hash32_ptr(inst->session), buf->fd,
smem->dma_buf->name, buf->size);
msm_cvp_smem_free(smem);
kmem_cache_free(cvp_driver->smem_cache, smem);
} else if (buf->ownership == CLIENT) {
dprintk(CVP_DBG,
"%s: %x : fd %d %s size %d",
"unmap persist", hash32_ptr(inst->session),
buf->fd, smem->dma_buf->name, buf->size);
mutex_lock(&inst->dma_cache.lock);
if (atomic_read(&smem->refcount) == 0) {
list_del(&smem->list);
msm_cvp_unmap_smem(smem);
dma_buf_put(smem->dma_buf);
kfree(smem);
buf->smem = NULL;
}
mutex_unlock(&inst->dma_cache.lock);
}
kmem_cache_free(cvp_driver->buf_cache, buf);
}
mutex_unlock(&inst->persistbufs.lock);
return rc;
}

160
drivers/media/platform/msm/cvp/msm_cvp_buf.h Normal file
View file

@ -0,0 +1,160 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* Copyright (c) 2020, The Linux Foundation. All rights reserved.
*/
#ifndef _MSM_CVP_BUF_H_
#define _MSM_CVP_BUF_H_
#include <linux/poll.h>
#include <linux/types.h>
#include <linux/dma-buf.h>
#include <linux/ion.h>
#include <linux/msm_ion.h>
#include <linux/refcount.h>
#include <media/msm_cvp_private.h>
#include <media/msm_cvp_vidc.h>
#define MAX_FRAME_BUFFER_NUMS 30
#define MAX_DMABUF_NUMS 64
struct msm_cvp_inst;
struct msm_cvp_platform_resources;
struct msm_cvp_list;
enum smem_cache_ops {
SMEM_CACHE_CLEAN,
SMEM_CACHE_INVALIDATE,
SMEM_CACHE_CLEAN_INVALIDATE,
};
enum smem_prop {
SMEM_UNCACHED = 0x1,
SMEM_CACHED = 0x2,
SMEM_SECURE = 0x4,
SMEM_ADSP = 0x8,
SMEM_NON_PIXEL = 0x10
};
struct cvp_dma_mapping_info {
struct device *dev;
struct iommu_domain *domain;
struct sg_table *table;
struct dma_buf_attachment *attach;
struct dma_buf *buf;
void *cb_info;
};
struct msm_cvp_smem {
struct list_head list;
atomic_t refcount;
struct dma_buf *dma_buf;
void *kvaddr;
u32 device_addr;
dma_addr_t dma_handle;
u32 size;
u32 flags;
u32 ion_flags;
struct cvp_dma_mapping_info mapping_info;
};
struct cvp_buf_type {
s32 fd;
u32 size;
u32 offset;
u32 flags;
union {
struct dma_buf *dbuf;
struct {
u32 reserved1;
u32 reserved2;
};
};
};
enum buffer_owner {
DRIVER,
FIRMWARE,
CLIENT,
MAX_OWNER
};
struct cvp_internal_buf {
struct list_head list;
s32 fd;
u32 size;
u32 offset;
u32 type;
u32 index;
u64 ktid;
enum buffer_owner ownership;
struct msm_cvp_smem *smem;
};
struct msm_cvp_frame {
struct list_head list;
struct cvp_internal_buf bufs[MAX_FRAME_BUFFER_NUMS];
u32 nr;
u64 ktid;
};
void print_cvp_buffer(u32 tag, const char *str,
struct msm_cvp_inst *inst,
struct cvp_internal_buf *cbuf);
void print_cvp_buffer(u32 tag, const char *str,
struct msm_cvp_inst *inst,
struct cvp_internal_buf *cbuf);
void print_client_buffer(u32 tag, const char *str,
struct msm_cvp_inst *inst,
struct cvp_kmd_buffer *cbuf);
void print_smem(u32 tag, const char *str,
struct msm_cvp_inst *inst,
struct msm_cvp_smem *smem);
/*Kernel DMA buffer and IOMMU mapping functions*/
int msm_cvp_smem_alloc(size_t size, u32 align, u32 flags, int map_kernel,
void *res, struct msm_cvp_smem *smem);
int msm_cvp_smem_free(struct msm_cvp_smem *smem);
struct context_bank_info *msm_cvp_smem_get_context_bank(bool is_secure,
struct msm_cvp_platform_resources *res,
unsigned long ion_flags);
int msm_cvp_map_smem(struct msm_cvp_inst *inst,
struct msm_cvp_smem *smem);
int msm_cvp_unmap_smem(struct msm_cvp_smem *smem);
struct dma_buf *msm_cvp_smem_get_dma_buf(int fd);
void msm_cvp_smem_put_dma_buf(void *dma_buf);
int msm_cvp_smem_cache_operations(struct dma_buf *dbuf,
enum smem_cache_ops cache_op,
unsigned long offset,
unsigned long size);
/* CVP driver internal buffer management functions*/
struct cvp_internal_buf *cvp_allocate_arp_bufs(struct msm_cvp_inst *inst,
u32 buffer_size);
int cvp_release_arp_buffers(struct msm_cvp_inst *inst);
int msm_cvp_map_buf_dsp(struct msm_cvp_inst *inst,
struct cvp_kmd_buffer *buf);
int msm_cvp_unmap_buf_dsp(struct msm_cvp_inst *inst,
struct cvp_kmd_buffer *buf);
void msm_cvp_cache_operations(struct msm_cvp_smem *smem,
u32 type, u32 offset, u32 size);
u32 msm_cvp_map_frame_buf(struct msm_cvp_inst *inst,
struct cvp_buf_type *buf,
struct msm_cvp_frame *frame);
void msm_cvp_unmap_frame_buf(struct msm_cvp_frame *frame);
int msm_cvp_mark_user_persist(struct msm_cvp_inst *inst,
struct cvp_kmd_hfi_packet *in_pkt,
unsigned int offset, unsigned int buf_num);
int msm_cvp_map_user_persist(struct msm_cvp_inst *inst,
struct cvp_kmd_hfi_packet *in_pkt,
unsigned int offset, unsigned int buf_num);
int msm_cvp_unmap_user_persist(struct msm_cvp_inst *inst,
struct cvp_kmd_hfi_packet *in_pkt,
unsigned int offset, unsigned int buf_num);
int msm_cvp_map_frame(struct msm_cvp_inst *inst,
struct cvp_kmd_hfi_packet *in_pkt,
unsigned int offset, unsigned int buf_num);
void msm_cvp_unmap_frame(struct msm_cvp_inst *inst, u64 ktid);
int msm_cvp_session_deinit_buffers(struct msm_cvp_inst *inst);
void msm_cvp_print_inst_bufs(struct msm_cvp_inst *inst);
#endif

216
drivers/media/platform/msm/cvp/msm_cvp_common.c
View file

@ -671,7 +671,7 @@ static void handle_sys_error(enum hal_command_response cmd, void *data)
}
if (!core->trigger_ssr)
msm_cvp_comm_print_inst_info(inst);
msm_cvp_print_inst_bufs(inst);
}
/* handle the hw error before core released to get full debug info */
@ -1534,47 +1534,6 @@ void msm_cvp_fw_unload_handler(struct work_struct *work)
mutex_unlock(&core->lock);
}
void print_cvp_buffer(u32 tag, const char *str, struct msm_cvp_inst *inst,
struct cvp_internal_buf *cbuf)
{
dprintk(tag, "%s addr: %x size %u\n", str,
cbuf->smem->device_addr, cbuf->size);
}
void msm_cvp_comm_print_inst_info(struct msm_cvp_inst *inst)
{
struct cvp_internal_buf *buf;
struct msm_cvp_smem *smem;
if (!inst) {
dprintk(CVP_ERR, "%s - invalid param %pK\n",
__func__, inst);
return;
}
dprintk(CVP_ERR, "active session cmd %d\n", inst->cur_cmd_type);
dprintk(CVP_ERR,
"---Buffer details for inst: %pK of type: %d---\n",
inst, inst->session_type);
mutex_lock(&inst->cpusmems.lock);
dprintk(CVP_ERR, "smem list:\n");
list_for_each_entry(smem, &inst->cpusmems.list, list)
print_smem(CVP_ERR, "bufdump", inst, smem);
mutex_unlock(&inst->cpusmems.lock);
mutex_lock(&inst->cvpdspbufs.lock);
dprintk(CVP_ERR, "dsp buffer list:\n");
list_for_each_entry(buf, &inst->cvpdspbufs.list, list)
print_cvp_buffer(CVP_ERR, "bufdump", inst, buf);
mutex_unlock(&inst->cvpdspbufs.lock);
mutex_lock(&inst->persistbufs.lock);
dprintk(CVP_ERR, "persist buffer list:\n");
list_for_each_entry(buf, &inst->persistbufs.list, list)
print_cvp_buffer(CVP_ERR, "bufdump", inst, buf);
mutex_unlock(&inst->persistbufs.lock);
}
static int set_internal_buf_on_fw(struct msm_cvp_inst *inst,
struct msm_cvp_smem *handle)
{
@ -1604,80 +1563,24 @@ static int set_internal_buf_on_fw(struct msm_cvp_inst *inst,
return 0;
}
static int allocate_and_set_internal_bufs(struct msm_cvp_inst *inst,
u32 buffer_size, struct msm_cvp_list *buf_list)
{
struct cvp_internal_buf *buf;
u32 smem_flags = SMEM_UNCACHED;
int rc = 0;
if (!inst || !buf_list) {
dprintk(CVP_ERR, "%s Invalid input\n", __func__);
return -EINVAL;
}
if (!buffer_size)
return 0;
/* PERSIST buffer requires secure mapping */
smem_flags |= SMEM_SECURE | SMEM_NON_PIXEL;
buf = kmem_cache_zalloc(cvp_driver->buf_cache, GFP_KERNEL);
if (!buf) {
dprintk(CVP_ERR, "%s Out of memory\n", __func__);
rc = -ENOMEM;
goto fail_kzalloc;
}
buf->smem = kmem_cache_zalloc(cvp_driver->smem_cache, GFP_KERNEL);
if (!buf->smem) {
dprintk(CVP_ERR, "%s Out of memory\n", __func__);
rc = -ENOMEM;
goto fail_kzalloc;
}
rc = msm_cvp_smem_alloc(buffer_size, 1, smem_flags, 0,
&(inst->core->resources), buf->smem);
if (rc) {
dprintk(CVP_ERR, "Failed to allocate ARP memory\n");
goto err_no_mem;
}
buf->size = buf->smem->size;
buf->type = HFI_BUFFER_INTERNAL_PERSIST_1;
buf->ownership = DRIVER;
rc = set_internal_buf_on_fw(inst, buf->smem);
if (rc)
goto fail_set_buffers;
mutex_lock(&buf_list->lock);
list_add_tail(&buf->list, &buf_list->list);
mutex_unlock(&buf_list->lock);
return rc;
fail_set_buffers:
msm_cvp_smem_free(buf->smem);
kmem_cache_free(cvp_driver->smem_cache, buf->smem);
err_no_mem:
kmem_cache_free(cvp_driver->buf_cache, buf);
fail_kzalloc:
return rc;
}
/* Set ARP buffer for CVP firmware to handle concurrency */
int cvp_comm_set_arp_buffers(struct msm_cvp_inst *inst)
{
int rc = 0;
struct cvp_internal_buf *buf;
if (!inst || !inst->core || !inst->core->device) {
dprintk(CVP_ERR, "%s invalid parameters\n", __func__);
return -EINVAL;
}
rc = allocate_and_set_internal_bufs(inst, ARP_BUF_SIZE,
&inst->persistbufs);
buf = cvp_allocate_arp_bufs(inst, ARP_BUF_SIZE);
if (!buf) {
rc = -ENOMEM;
goto error;
}
rc = set_internal_buf_on_fw(inst, buf->smem);
if (rc)
goto error;
@ -1690,109 +1593,10 @@ int cvp_comm_set_arp_buffers(struct msm_cvp_inst *inst)
return rc;
error:
cvp_comm_release_persist_buffers(inst);
cvp_release_arp_buffers(inst);
return rc;
}
int cvp_comm_release_persist_buffers(struct msm_cvp_inst *inst)
{
struct msm_cvp_smem *smem;
struct list_head *ptr, *next;
struct cvp_internal_buf *buf;
int rc = 0;
struct msm_cvp_core *core;
struct cvp_hfi_device *hdev;
int all_released;
if (!inst) {
dprintk(CVP_ERR, "Invalid instance pointer = %pK\n", inst);
return -EINVAL;
}
core = inst->core;
if (!core) {
dprintk(CVP_ERR, "Invalid core pointer = %pK\n", core);
return -EINVAL;
}
hdev = core->device;
if (!hdev) {
dprintk(CVP_ERR, "Invalid device pointer = %pK\n", hdev);
return -EINVAL;
}
dprintk(CVP_DBG, "release persist buffer!\n");
all_released = 0;
mutex_lock(&inst->persistbufs.lock);
list_for_each_safe(ptr, next, &inst->persistbufs.list) {
buf = list_entry(ptr, struct cvp_internal_buf, list);
smem = buf->smem;
if (!smem) {
dprintk(CVP_ERR, "%s invalid smem\n", __func__);
mutex_unlock(&inst->persistbufs.lock);
return -EINVAL;
}
/* Workaround for FW: release buffer means release all */
if (inst->state <= MSM_CVP_CLOSE_DONE && !all_released) {
rc = call_hfi_op(hdev, session_release_buffers,
(void *)inst->session);
if (!rc) {
mutex_unlock(&inst->persistbufs.lock);
rc = wait_for_sess_signal_receipt(inst,
HAL_SESSION_RELEASE_BUFFER_DONE);
if (rc)
dprintk(CVP_WARN,
"%s: wait for signal failed, rc %d\n",
__func__, rc);
mutex_lock(&inst->persistbufs.lock);
} else {
dprintk(CVP_WARN,
"Rel prst buf fail:%x, %d\n",
smem->device_addr,
smem->size);
}
all_released = 1;
}
list_del(&buf->list);
if (buf->ownership == DRIVER) {
dprintk(CVP_DBG,
"%s: %x : fd %d %s size %d",
"free arp", hash32_ptr(inst->session), buf->fd,
smem->dma_buf->name, buf->size);
msm_cvp_smem_free(smem);
kmem_cache_free(cvp_driver->smem_cache, smem);
} else if (buf->ownership == CLIENT) {
dprintk(CVP_DBG,
"%s: %x : fd %d %s size %d",
"unmap persist", hash32_ptr(inst->session),
buf->fd, smem->dma_buf->name, buf->size);
mutex_lock(&inst->cpusmems.lock);
if (atomic_read(&smem->refcount) == 0) {
list_del(&smem->list);
msm_cvp_unmap_smem(smem);
dma_buf_put(smem->dma_buf);
kfree(smem);
buf->smem = NULL;
}
mutex_unlock(&inst->cpusmems.lock);
}
kmem_cache_free(cvp_driver->buf_cache, buf);
}
mutex_unlock(&inst->persistbufs.lock);
return rc;
}
void print_client_buffer(u32 tag, const char *str,
struct msm_cvp_inst *inst, struct cvp_kmd_buffer *cbuf)
{
if (!(tag & msm_cvp_debug) || !inst || !cbuf)
return;
dprintk(tag,
"%s: %x : idx %2d fd %d off %d size %d type %d flags 0x%x\n",
str, hash32_ptr(inst->session), cbuf->index, cbuf->fd,
cbuf->offset, cbuf->size, cbuf->type, cbuf->flags);
}

8
drivers/media/platform/msm/cvp/msm_cvp_common.h
View file

@ -26,17 +26,9 @@ void msm_cvp_comm_generate_sys_error(struct msm_cvp_inst *inst);
int msm_cvp_comm_smem_cache_operations(struct msm_cvp_inst *inst,
struct msm_cvp_smem *mem, enum smem_cache_ops cache_ops);
int msm_cvp_comm_check_core_init(struct msm_cvp_core *core);
void msm_cvp_comm_print_inst_info(struct msm_cvp_inst *inst);
void print_cvp_buffer(u32 tag, const char *str,
struct msm_cvp_inst *inst,
struct cvp_internal_buf *cbuf);
int wait_for_sess_signal_receipt(struct msm_cvp_inst *inst,
enum hal_command_response cmd);
int cvp_comm_set_arp_buffers(struct msm_cvp_inst *inst);
int cvp_comm_release_persist_buffers(struct msm_cvp_inst *inst);
void print_client_buffer(u32 tag, const char *str,
struct msm_cvp_inst *inst, struct cvp_kmd_buffer *cbuf);
void print_smem(u32 tag, const char *str, struct msm_cvp_inst *inst,
struct msm_cvp_smem *smem);
int msm_cvp_noc_error_info(struct msm_cvp_core *core);
#endif

10
drivers/media/platform/msm/cvp/msm_cvp_core.c
View file

@ -321,7 +321,7 @@ void *msm_cvp_open(int core_id, int session_type)
spin_lock_init(&inst->event_handler.lock);
INIT_MSM_CVP_LIST(&inst->persistbufs);
INIT_MSM_CVP_LIST(&inst->cpusmems);
INIT_MSM_CVP_LIST(&inst->dma_cache);
INIT_MSM_CVP_LIST(&inst->cvpdspbufs);
INIT_MSM_CVP_LIST(&inst->frames);
@ -338,7 +338,7 @@ void *msm_cvp_open(int core_id, int session_type)
inst->clk_data.sys_cache_bw = 0;
inst->clk_data.bitrate = 0;
inst->clk_data.core_id = 0;
inst->cpusmems.maxnr = MAX_DMABUF_NUMS;
inst->dma_cache.maxnr = MAX_DMABUF_NUMS;
for (i = SESSION_MSG_INDEX(SESSION_MSG_START);
i <= SESSION_MSG_INDEX(SESSION_MSG_END); i++) {
@ -377,7 +377,7 @@ fail_init:
mutex_destroy(&inst->lock);
DEINIT_MSM_CVP_LIST(&inst->persistbufs);
DEINIT_MSM_CVP_LIST(&inst->cpusmems);
DEINIT_MSM_CVP_LIST(&inst->dma_cache);
DEINIT_MSM_CVP_LIST(&inst->cvpdspbufs);
DEINIT_MSM_CVP_LIST(&inst->frames);
@ -395,7 +395,7 @@ static void msm_cvp_cleanup_instance(struct msm_cvp_inst *inst)
return;
}
if (cvp_comm_release_persist_buffers(inst))
if (cvp_release_arp_buffers(inst))
dprintk(CVP_ERR,
"Failed to release persist buffers\n");
}
@ -417,7 +417,7 @@ int msm_cvp_destroy(struct msm_cvp_inst *inst)
mutex_unlock(&core->lock);
DEINIT_MSM_CVP_LIST(&inst->persistbufs);
DEINIT_MSM_CVP_LIST(&inst->cpusmems);
DEINIT_MSM_CVP_LIST(&inst->dma_cache);
DEINIT_MSM_CVP_LIST(&inst->cvpdspbufs);
DEINIT_MSM_CVP_LIST(&inst->frames);

37
drivers/media/platform/msm/cvp/msm_cvp_core.h
View file

@ -14,42 +14,7 @@
#include <linux/refcount.h>
#include <media/msm_cvp_private.h>
#include <media/msm_cvp_vidc.h>
enum smem_prop {
SMEM_UNCACHED = 0x1,
SMEM_CACHED = 0x2,
SMEM_SECURE = 0x4,
SMEM_ADSP = 0x8,
SMEM_NON_PIXEL = 0x10
};
struct cvp_dma_mapping_info {
struct device *dev;
struct iommu_domain *domain;
struct sg_table *table;
struct dma_buf_attachment *attach;
struct dma_buf *buf;
void *cb_info;
};
struct msm_cvp_smem {
struct list_head list;
atomic_t refcount;
struct dma_buf *dma_buf;
void *kvaddr;
u32 device_addr;
dma_addr_t dma_handle;
u32 size;
u32 flags;
u32 ion_flags;
struct cvp_dma_mapping_info mapping_info;
};
enum smem_cache_ops {
SMEM_CACHE_CLEAN,
SMEM_CACHE_INVALIDATE,
SMEM_CACHE_CLEAN_INVALIDATE,
};
#include "msm_cvp_buf.h"
enum core_id {
MSM_CORE_CVP = 0,

43
drivers/media/platform/msm/cvp/msm_cvp_internal.h
View file

@ -37,9 +37,6 @@
#define FENCE_DME_DS_IDX 1
#define FENCE_DME_OUTPUT_IDX 7
#define MAX_FRAME_BUFFER_NUMS 10
#define MAX_DMABUF_NUMS 30
#define SYS_MSG_START HAL_SYS_INIT_DONE
#define SYS_MSG_END HAL_SYS_ERROR
#define SESSION_MSG_START HAL_SESSION_EVENT_CHANGE
@ -102,25 +99,6 @@ static inline void DEINIT_MSM_CVP_LIST(struct msm_cvp_list *mlist)
mutex_destroy(&mlist->lock);
}
enum buffer_owner {
DRIVER,
FIRMWARE,
CLIENT,
MAX_OWNER
};
struct cvp_internal_buf {
struct list_head list;
s32 fd;
u32 size;
u32 offset;
u32 type;
u32 index;
u64 ktid;
enum buffer_owner ownership;
struct msm_cvp_smem *smem;
};
struct msm_cvp_common_data {
char key[128];
int value;
@ -343,7 +321,7 @@ struct msm_cvp_inst {
enum instance_state state;
struct msm_cvp_list freqs;
struct msm_cvp_list persistbufs;
struct msm_cvp_list cpusmems;
struct msm_cvp_list dma_cache;
struct msm_cvp_list cvpdspbufs;
struct msm_cvp_list frames;
struct completion completions[SESSION_MSG_END - SESSION_MSG_START + 1];
@ -374,13 +352,6 @@ struct cvp_fence_command {
struct cvp_hfi_cmd_session_hdr *pkt;
};
struct msm_cvp_frame {
struct list_head list;
struct cvp_internal_buf bufs[MAX_FRAME_BUFFER_NUMS];
u32 nr;
u64 ktid;
};
extern struct msm_cvp_drv *cvp_driver;
void cvp_handle_cmd_response(enum hal_command_response cmd, void *data);
@ -388,19 +359,7 @@ int msm_cvp_trigger_ssr(struct msm_cvp_core *core,
enum hal_ssr_trigger_type type);
int msm_cvp_noc_error_info(struct msm_cvp_core *core);
void msm_cvp_comm_handle_thermal_event(void);
int msm_cvp_smem_alloc(size_t size, u32 align, u32 flags, int map_kernel,
void *res, struct msm_cvp_smem *smem);
int msm_cvp_smem_free(struct msm_cvp_smem *smem);
struct context_bank_info *msm_cvp_smem_get_context_bank(bool is_secure,
struct msm_cvp_platform_resources *res, unsigned long ion_flags);
int msm_cvp_map_smem(struct msm_cvp_inst *inst,
struct msm_cvp_smem *smem);
int msm_cvp_unmap_smem(struct msm_cvp_smem *smem);
struct dma_buf *msm_cvp_smem_get_dma_buf(int fd);
void msm_cvp_smem_put_dma_buf(void *dma_buf);
int msm_cvp_smem_cache_operations(struct dma_buf *dbuf,
enum smem_cache_ops cache_op, unsigned long offset, unsigned long size);
void msm_cvp_fw_unload_handler(struct work_struct *work);
void msm_cvp_ssr_handler(struct work_struct *work);
/*

2
drivers/media/platform/msm/cvp/msm_cvp_res_parse.c
View file

@ -904,7 +904,7 @@ int msm_cvp_smmu_fault_handler(struct iommu_domain *domain,
mutex_lock(&core->lock);
list_for_each_entry(inst, &core->instances, list) {
msm_cvp_comm_print_inst_info(inst);
msm_cvp_print_inst_bufs(inst);
}
core->smmu_fault_handled = true;
msm_cvp_noc_error_info(core);