msm: eva: New DSP driver interface

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

Change-Id: I4225dfa0b1acf8015a763263520442712e571851
Signed-off-by: George Shen <sqiao@codeaurora.org>

msm/eva/cvp.c

@@ -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);
 
+	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;
 

msm/eva/msm_cvp_buf.c

@@ -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;
+}

msm/eva/msm_cvp_buf.h

@@ -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

msm/eva/msm_cvp_dsp.h

@@ -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,
+	CPU2DSP_INIT = 6,
-	DSP2CPU_POWERON = 6,
+	CPU2DSP_SET_DEBUG_LEVEL = 7,
-	DSP2CPU_POWEROFF = 7,
+	CPU2DSP_MAX_CMD = 8,
-	CVP_DSP_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;

msm/eva/msm_cvp_platform.c

@@ -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,
 	}
 };
 

msm/eva/msm_cvp_res_parse.c

@@ -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");
 

msm/eva/msm_cvp_resources.h

@@ -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;

msm/eva/msm_smem.c

@@ -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;