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

msm: eva: New DSP driver interface

Browse Source 
New CPU-DSP interface aims to replace reverse RPC in DSP EVA
applications.

Change-Id: I4225dfa0b1acf8015a763263520442712e571851
Signed-off-by: George Shen <sqiao@codeaurora.org>
This commit is contained in:
George Shen
2021-01-18 09:15:25 -08:00
parent c42a049363
commit f3d06c8ef3
9 changed files with 1485 additions and 30 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
msm/eva/cvp.c
View File

@@ -37,7 +37,7 @@ static int cvp_open(struct inode *inode, struct file *filp)
struct msm_cvp_core, cdev);
struct msm_cvp_inst *inst;
dprintk(CVP_SESS, "%s: Enter\n", __func__);
dprintk(CVP_SESS, "%s: core->id: %d\n", __func__, core->id);
inst = msm_cvp_open(core->id, MSM_CVP_USER);
if (!inst) {
@@ -416,9 +416,13 @@ static int msm_probe_cvp_device(struct platform_device *pdev)
atomic64_set(&core->kernel_trans_id, 0);
rc = cvp_dsp_device_init();
if (rc)
dprintk(CVP_WARN, "Failed to initialize DSP driver\n");
if (core->resources.dsp_enabled) {
rc = cvp_dsp_device_init();
if (rc)
dprintk(CVP_WARN, "Failed to initialize DSP driver\n");
} else {
dprintk(CVP_DSP, "DSP interface not enabled\n");
}
return rc;

327
msm/eva/msm_cvp_buf.c
View File

@@ -3,6 +3,12 @@
* Copyright (c) 2020, The Linux Foundation. All rights reserved.
*/
#include <linux/pid.h>
#include <linux/fdtable.h>
#include <linux/rcupdate.h>
#include <linux/fs.h>
#include <linux/dma-buf.h>
#include <linux/sched/task.h>
#include "msm_cvp_common.h"
#include "cvp_hfi_api.h"
#include "msm_cvp_debug.h"
@@ -251,6 +257,232 @@ int msm_cvp_unmap_buf_dsp(struct msm_cvp_inst *inst, struct eva_kmd_buffer *buf)
return rc;
}
static struct file *msm_cvp_fget(unsigned int fd, struct task_struct *task,
fmode_t mask, unsigned int refs)
{
struct files_struct *files = task->files;
struct file *file;
rcu_read_lock();
loop:
file = fcheck_files(files, fd);
if (file) {
/* File object ref couldn't be taken.
* dup2() atomicity guarantee is the reason
* we loop to catch the new file (or NULL pointer)
*/
if (file->f_mode & mask)
file = NULL;
else if (!get_file_rcu_many(file, refs))
goto loop;
}
rcu_read_unlock();
return file;
}
static struct dma_buf *cvp_dma_buf_get(struct file *file, int fd,
struct task_struct *task)
{
if (file->f_op != gfa_cv.dmabuf_f_op) {
dprintk(CVP_WARN, "fd doesn't refer to dma_buf\n");
return ERR_PTR(-EINVAL);
}
return file->private_data;
}
int msm_cvp_map_buf_dsp_new(struct msm_cvp_inst *inst,
struct eva_kmd_buffer *buf,
int32_t pid, uint32_t *iova)
{
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;
struct pid *pid_s;
struct task_struct *task;
struct file *file;
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;
}
pid_s = find_get_pid(pid);
if (pid_s == NULL) {
dprintk(CVP_WARN, "%s incorrect pid\n", __func__);
return -EINVAL;
}
dprintk(CVP_WARN, "%s get pid_s 0x%x from pidA 0x%x\n", __func__, pid_s, pid);
/* task = get_pid_task(pid, PIDTYPE_PID); */
task = get_pid_task(pid_s, PIDTYPE_TGID);
if (!task)
dprintk(CVP_WARN, "%s task doesn't exist\n", __func__);
file = msm_cvp_fget(buf->fd, task, FMODE_PATH, 1);
if (file == NULL) {
dprintk(CVP_WARN, "%s fail to get file from fd\n", __func__);
put_task_struct(task);
return -EINVAL;
}
//entry->file = file;
dma_buf = cvp_dma_buf_get(
file,
buf->fd,
task);
if (dma_buf == ERR_PTR(-EINVAL)) {
dprintk(CVP_ERR, "%s: Invalid fd = %d", __func__, buf->fd);
fput(file);
put_task_struct(task);
return -EINVAL;
}
dprintk(CVP_WARN, "dma_buf from internal %llu\n", dma_buf);
/* to unmap dsp buf, below sequence is required
* fput(file);
* dma_buf_put(dma_buf);
* put_task_struct(task);
*/
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;
smem->bitmap_index = MAX_DMABUF_NUMS;
dprintk(CVP_DSP, "%s: dma_buf = %llx\n", __func__, dma_buf);
rc = msm_cvp_map_smem(inst, smem, "map dsp");
if (rc) {
print_client_buffer(CVP_ERR, "map failed", inst, buf);
goto exit;
}
cbuf->smem = smem;
cbuf->fd = buf->fd;
cbuf->size = buf->size;
cbuf->offset = buf->offset;
cbuf->ownership = CLIENT;
cbuf->index = buf->index;
*iova = (uint32_t)smem->device_addr;
dprintk(CVP_DSP, "%s: buf->fd %d, device_addr = %llx\n",
__func__, buf->fd, (uint32_t)smem->device_addr);
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(inst, smem, "unmap dsp");
msm_cvp_smem_put_dma_buf(smem->dma_buf);
}
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_new(struct msm_cvp_inst *inst,
struct eva_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 (cbuf->smem->device_addr) {
msm_cvp_unmap_smem(inst, cbuf->smem, "unmap dsp");
msm_cvp_smem_put_dma_buf(cbuf->smem->dma_buf);
}
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)
{
@@ -964,3 +1196,98 @@ int cvp_release_arp_buffers(struct msm_cvp_inst *inst)
return rc;
}
int cvp_allocate_dsp_bufs(struct msm_cvp_inst *inst,
struct cvp_internal_buf *buf,
u32 buffer_size,
u32 secure_type)
{
u32 smem_flags = SMEM_UNCACHED;
int rc = 0;
if (!inst) {
dprintk(CVP_ERR, "%s Invalid input\n", __func__);
return -EINVAL;
}
if (!buf)
return -EINVAL;
if (!buffer_size)
return -EINVAL;
switch (secure_type) {
case 0:
break;
case 1:
smem_flags |= SMEM_SECURE | SMEM_PIXEL;
break;
case 2:
smem_flags |= SMEM_SECURE | SMEM_NON_PIXEL;
break;
default:
dprintk(CVP_ERR, "%s Invalid secure_type %d\n",
__func__, secure_type);
return -EINVAL;
}
dprintk(CVP_ERR, "%s smem_flags 0x%x\n", __func__, smem_flags);
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_smem_cache;
}
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;
}
dprintk(CVP_ERR, "%s dma_buf %pK\n", __func__, buf->smem->dma_buf);
buf->size = buf->smem->size;
buf->type = HFI_BUFFER_INTERNAL_PERSIST_1;
buf->ownership = CLIENT;
return rc;
err_no_mem:
kmem_cache_free(cvp_driver->smem_cache, buf->smem);
fail_kzalloc_smem_cache:
return rc;
}
int cvp_release_dsp_buffers(struct msm_cvp_inst *inst,
struct cvp_internal_buf *buf)
{
struct msm_cvp_smem *smem;
int rc = 0;
if (!inst) {
dprintk(CVP_ERR, "Invalid instance pointer = %pK\n", inst);
return -EINVAL;
}
if (!buf) {
dprintk(CVP_ERR, "Invalid buffer pointer = %pK\n", inst);
return -EINVAL;
}
smem = buf->smem;
if (!smem) {
dprintk(CVP_ERR, "%s invalid smem\n", __func__);
return -EINVAL;
}
if (buf->ownership == CLIENT) {
dprintk(CVP_MEM,
"%s: %x : fd %x %s size %d",
"free dsp buf", 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);
}
return rc;
}

17
msm/eva/msm_cvp_buf.h
View File

@@ -15,7 +15,7 @@
#include <linux/refcount.h>
#include <media/msm_eva_private.h>
#define MAX_FRAME_BUFFER_NUMS 48
#define MAX_FRAME_BUFFER_NUMS 30
#define MAX_DMABUF_NUMS 64
struct msm_cvp_inst;
@@ -33,7 +33,8 @@ enum smem_prop {
SMEM_CACHED = 0x2,
SMEM_SECURE = 0x4,
SMEM_ADSP = 0x8,
SMEM_NON_PIXEL = 0x10
SMEM_NON_PIXEL = 0x10,
SMEM_PIXEL = 0x20
};
struct msm_cvp_list {
@@ -177,6 +178,12 @@ int msm_cvp_map_buf_dsp(struct msm_cvp_inst *inst,
struct eva_kmd_buffer *buf);
int msm_cvp_unmap_buf_dsp(struct msm_cvp_inst *inst,
struct eva_kmd_buffer *buf);
int msm_cvp_map_buf_dsp_new(struct msm_cvp_inst *inst,
struct eva_kmd_buffer *buf,
int32_t pid,
uint32_t *iova);
int msm_cvp_unmap_buf_dsp_new(struct msm_cvp_inst *inst,
struct eva_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,
@@ -197,4 +204,10 @@ int msm_cvp_map_frame(struct msm_cvp_inst *inst,
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);
int cvp_allocate_dsp_bufs(struct msm_cvp_inst *inst,
struct cvp_internal_buf *buf,
u32 buffer_size,
u32 secure_type);
int cvp_release_dsp_buffers(struct msm_cvp_inst *inst,
struct cvp_internal_buf *buf);
#endif

1025
msm/eva/msm_cvp_dsp.c
View File

File diff suppressed because it is too large Load Diff

117
msm/eva/msm_cvp_dsp.h
View File

@@ -10,6 +10,16 @@
#include "msm_cvp_debug.h"
#include "cvp_core_hfi.h"
#include <linux/pid.h>
#include <linux/sched.h>
/*#define FASTRPC_DRIVER_AVAILABLE*/
#ifdef FASTRPC_DRIVER_AVAILABLE
#include <linux/fastrpc.h>
#endif
#define CVP_APPS_DSP_GLINK_GUID "cvp-glink-apps-dsp"
#define CVP_APPS_DSP_SMD_GUID "cvp-smd-apps-dsp"
@@ -20,6 +30,17 @@
#define CVP_DSP2CPU_RESERVED 8
#define CVP_DSP_RESPONSE_TIMEOUT 300
#define CVP_INVALID_RPMSG_TYPE 0xBADDFACE
#define MAX_FRAME_BUF_NUM 16
#define BITPTRSIZE32 (4)
#define BITPTRSIZE64 (8)
#define HIGH32 (0xFFFFFFFF00000000LL)
#define LOW32 (0xFFFFFFFFLL)
/* Supports up to 8 DSP sessions in 4 processes */
#define MAX_FASTRPC_DRIVER_NUM (4)
#define MAX_DSP_SESSION_NUM (8)
int cvp_dsp_device_init(void);
void cvp_dsp_device_exit(void);
@@ -42,10 +63,56 @@ enum CVP_DSP_COMMAND {
CPU2DSP_SHUTDOWN = 3,
CPU2DSP_REGISTER_BUFFER = 4,
CPU2DSP_DEREGISTER_BUFFER = 5,
CPU2DSP_MAX_CMD = 6,
DSP2CPU_POWERON = 6,
DSP2CPU_POWEROFF = 7,
CVP_DSP_MAX_CMD = 8,
CPU2DSP_INIT = 6,
CPU2DSP_SET_DEBUG_LEVEL = 7,
CPU2DSP_MAX_CMD = 8,
DSP2CPU_POWERON = 11,
DSP2CPU_POWEROFF = 12,
DSP2CPU_CREATE_SESSION = 13,
DSP2CPU_DETELE_SESSION = 14,
DSP2CPU_POWER_REQUEST = 15,
DSP2CPU_POWER_CANCEL = 16,
DSP2CPU_REGISTER_BUFFER = 17,
DSP2CPU_DEREGISTER_BUFFER = 18,
DSP2CPU_MEM_ALLOC = 19,
DSP2CPU_MEM_FREE = 20,
CVP_DSP_MAX_CMD = 21,
};
enum eva_dsp_debug_level {
EVA_PORT_INFO_ON = 0,
EVA_PORT_DEBUG_ON = 1,
EVA_QDI_INFO_ON = 2,
EVA_QDI_DEBUG_ON = 3,
EVA_MEM_DEBUG_ON = 4
};
struct eva_power_req {
uint32_t clock_fdu;
uint32_t clock_ica;
uint32_t clock_od;
uint32_t clock_mpu;
uint32_t clock_fw;
uint32_t bw_ddr;
uint32_t bw_sys_cache;
uint32_t op_clock_fdu;
uint32_t op_clock_ica;
uint32_t op_clock_od;
uint32_t op_clock_mpu;
uint32_t op_clock_fw;
uint32_t op_bw_ddr;
uint32_t op_bw_sys_cache;
};
struct eva_mem_remote {
uint32_t type;
uint32_t size;
uint32_t fd;
uint32_t offset;
uint32_t index;
uint32_t iova;
uint32_t dsp_remote_map;
uint64_t v_dsp_addr;
};
struct cvp_dsp_cmd_msg {
@@ -61,6 +128,15 @@ struct cvp_dsp_cmd_msg {
uint32_t buff_fd;
uint32_t buff_offset;
uint32_t buff_fd_size;
uint32_t eva_dsp_debug_level;
/* Create Session */
uint32_t session_cpu_low;
uint32_t session_cpu_high;
struct eva_mem_remote sbuf;
uint32_t reserved1;
uint32_t reserved2;
};
@@ -76,9 +152,38 @@ struct cvp_dsp2cpu_cmd_msg {
uint32_t type;
uint32_t ver;
uint32_t len;
/* Create Session */
uint32_t session_type;
uint32_t kernel_mask;
uint32_t session_prio;
uint32_t is_secure;
uint32_t dsp_access_mask;
uint32_t session_id;
uint32_t session_cpu_low;
uint32_t session_cpu_high;
int32_t pid;
struct eva_power_req power_req;
struct eva_mem_remote sbuf;
uint32_t data[CVP_DSP2CPU_RESERVED];
};
struct cvp_dsp_fastrpc_driver_entry {
struct list_head list;
uint32_t handle;
uint32_t session_cnt;
#ifdef FASTRPC_DRIVER_AVAILABLE
struct fastrpc_driver cvp_fastrpc_driver;
struct fastrpc_device *cvp_fastrpc_device;
#endif
struct completion fastrpc_probe_completion;
struct msm_cvp_list dspbufs;
/* all dsp sessions list */
struct msm_cvp_list dsp_session;
};
struct cvp_dsp_apps {
struct mutex lock;
struct rpmsg_device *chan;
@@ -90,6 +195,10 @@ struct cvp_dsp_apps {
struct cvp_dsp2cpu_cmd_msg pending_dsp2cpu_cmd;
struct cvp_dsp_rsp_msg pending_dsp2cpu_rsp;
struct task_struct *dsp_thread;
/* dsp buffer mapping, set of dma function pointer */
const struct file_operations *dmabuf_f_op;
uint32_t buf_num;
struct msm_cvp_list fastrpc_driver_list;
};
extern struct cvp_dsp_apps gfa_cv;

6
msm/eva/msm_cvp_platform.c
View File

@@ -93,11 +93,15 @@ static struct msm_cvp_common_data sm8450_common_data[] = {
},
{
.key = "qcom,dsp-resp-timeout",
.value = 1000
.value = 1000,
},
{
.key = "qcom,debug-timeout",
.value = 0,
},
{
.key = "qcom,dsp-enabled",
.value = 0,
}
};

3
msm/eva/msm_cvp_res_parse.c
View File

@@ -727,6 +727,9 @@ int cvp_read_platform_resources_from_drv_data(
res->auto_pil = find_key_value(platform_data,
"qcom,auto-pil");
res->dsp_enabled = find_key_value(platform_data,
"qcom,dsp-enabled");
res->max_load = find_key_value(platform_data,
"qcom,max-hw-load");

1
msm/eva/msm_cvp_resources.h
View File

@@ -158,6 +158,7 @@ struct msm_cvp_platform_resources {
bool use_non_secure_pil;
bool sw_power_collapsible;
bool auto_pil;
bool dsp_enabled;
struct list_head context_banks;
bool thermal_mitigable;
const char *fw_name;

7
msm/eva/msm_smem.c
View File

@@ -16,6 +16,7 @@
#include "msm_cvp_debug.h"
#include "msm_cvp_resources.h"
#include "cvp_core_hfi.h"
#include "msm_cvp_dsp.h"
static int msm_dma_get_device_address(struct dma_buf *dbuf, u32 align,
@@ -277,6 +278,9 @@ static int alloc_dma_mem(size_t size, u32 align, u32 flags, int map_kernel,
if (flags & SMEM_NON_PIXEL)
ion_flags |= ION_FLAG_CP_NON_PIXEL;
if (flags & SMEM_PIXEL)
ion_flags |= ION_FLAG_CP_PIXEL;
if (flags & SMEM_SECURE) {
ion_flags |= ION_FLAG_SECURE;
heap_mask = ION_HEAP(ION_SECURE_HEAP_ID);
@@ -292,6 +296,9 @@ static int alloc_dma_mem(size_t size, u32 align, u32 flags, int map_kernel,
goto fail_shared_mem_alloc;
}
if (!gfa_cv.dmabuf_f_op)
gfa_cv.dmabuf_f_op = (const struct file_operations *)dbuf->file->f_op;
mem->flags = flags;
mem->ion_flags = ion_flags;
mem->size = size;