Merge commit '9894920d7cc633869f4aa6ed043c2e63d0d1da42'

* commit '9894920d7cc633869f4aa6ed043c2e63d0d1da42':
  driver: rknpu: Update rknpu driver, version: 0.9.2
  drm/rockchip: vop: fix the zpos setting in vop_atomic_plane_reset()

Change-Id: I2f2f7411ab6472029738f3aae923a369fd6fcf7c

drivers/gpu/drm/rockchip/rockchip_drm_vop.c

@@ -2450,7 +2450,7 @@ static void vop_atomic_plane_reset(struct drm_plane *plane)
 		return;
 
 	__drm_atomic_helper_plane_reset(plane, &vop_plane_state->base);
-	win->state.zpos = win->zpos;
+	vop_plane_state->base.zpos = win->zpos;
 	vop_plane_state->global_alpha = 0xff;
 }
 

drivers/rknpu/include/rknpu_drv.h

@@ -30,10 +30,10 @@
 
 #define DRIVER_NAME "rknpu"
 #define DRIVER_DESC "RKNPU driver"
-#define DRIVER_DATE "20230721"
+#define DRIVER_DATE "20230825"
 #define DRIVER_MAJOR 0
 #define DRIVER_MINOR 9
-#define DRIVER_PATCHLEVEL 1
+#define DRIVER_PATCHLEVEL 2
 
 #define LOG_TAG "RKNPU"
 
@@ -75,6 +75,7 @@ struct rknpu_config {
 	int num_resets;
 	__u64 nbuf_phyaddr;
 	__u64 nbuf_size;
+	__u64 max_submit_number;
 };
 
 struct rknpu_timer {
@@ -101,6 +102,7 @@ struct rknpu_device {
 	void __iomem *base[RKNPU_MAX_CORES];
 	struct device *dev;
 #ifdef CONFIG_ROCKCHIP_RKNPU_DRM_GEM
+	struct device *fake_dev;
 	struct drm_device *drm_dev;
 #endif
 #ifdef CONFIG_ROCKCHIP_RKNPU_DMA_HEAP

drivers/rknpu/include/rknpu_job.h

@@ -46,6 +46,7 @@ struct rknpu_job {
 	atomic_t interrupt_count;
 	ktime_t hw_recoder_time;
 	ktime_t commit_pc_time;
+	atomic_t submit_count[RKNPU_MAX_CORES];
 };
 
 irqreturn_t rknpu_core0_irq_handler(int irq, void *data);

drivers/rknpu/rknpu_debugger.c

@@ -63,7 +63,7 @@ static int rknpu_load_show(struct seq_file *m, void *data)
 
 		div_value = (RKNPU_LOAD_INTERVAL / 100000);
 		do_div(busy_time_total, div_value);
-		load = busy_time_total;
+		load = busy_time_total > 100 ? 100 : busy_time_total;
 
 		if (rknpu_dev->config->num_irqs > 1)
 			seq_printf(m, "%2.d%%,", load);

drivers/rknpu/rknpu_drv.c

@@ -117,7 +117,8 @@ static const struct rknpu_config rk356x_rknpu_config = {
 	.num_irqs = ARRAY_SIZE(rknpu_irqs),
 	.num_resets = ARRAY_SIZE(rknpu_resets),
 	.nbuf_phyaddr = 0,
-	.nbuf_size = 0
+	.nbuf_size = 0,
+	.max_submit_number = (1 << 12) - 1
 };
 
 static const struct rknpu_config rk3588_rknpu_config = {
@@ -135,7 +136,8 @@ static const struct rknpu_config rk3588_rknpu_config = {
 	.num_irqs = ARRAY_SIZE(rk3588_npu_irqs),
 	.num_resets = ARRAY_SIZE(rk3588_npu_resets),
 	.nbuf_phyaddr = 0,
-	.nbuf_size = 0
+	.nbuf_size = 0,
+	.max_submit_number = (1 << 12) - 1
 };
 
 static const struct rknpu_config rv1106_rknpu_config = {
@@ -153,7 +155,8 @@ static const struct rknpu_config rv1106_rknpu_config = {
 	.num_irqs = ARRAY_SIZE(rknpu_irqs),
 	.num_resets = ARRAY_SIZE(rknpu_resets),
 	.nbuf_phyaddr = 0,
-	.nbuf_size = 0
+	.nbuf_size = 0,
+	.max_submit_number = (1 << 16) - 1
 };
 
 static const struct rknpu_config rk3562_rknpu_config = {
@@ -171,7 +174,8 @@ static const struct rknpu_config rk3562_rknpu_config = {
 	.num_irqs = ARRAY_SIZE(rknpu_irqs),
 	.num_resets = ARRAY_SIZE(rknpu_resets),
 	.nbuf_phyaddr = 0xfe400000,
-	.nbuf_size = 256 * 1024
+	.nbuf_size = 256 * 1024,
+	.max_submit_number = (1 << 16) - 1
 };
 
 /* driver probe and init */
@@ -539,6 +543,9 @@ static const struct drm_ioctl_desc rknpu_ioctls[] = {
 			  DRM_RENDER_ALLOW),
 };
 
+#if KERNEL_VERSION(6, 1, 0) <= LINUX_VERSION_CODE
+DEFINE_DRM_GEM_FOPS(rknpu_drm_driver_fops);
+#else
 static const struct file_operations rknpu_drm_driver_fops = {
 	.owner = THIS_MODULE,
 	.open = drm_open,
@@ -552,6 +559,7 @@ static const struct file_operations rknpu_drm_driver_fops = {
 	.release = drm_release,
 	.llseek = noop_llseek,
 };
+#endif
 
 static struct drm_driver rknpu_drm_driver = {
 #if KERNEL_VERSION(5, 4, 0) <= LINUX_VERSION_CODE
@@ -582,7 +590,11 @@ static struct drm_driver rknpu_drm_driver = {
 	.gem_prime_import = drm_gem_prime_import,
 #endif
 	.gem_prime_import_sg_table = rknpu_gem_prime_import_sg_table,
+#if KERNEL_VERSION(6, 1, 0) <= LINUX_VERSION_CODE
+	.gem_prime_mmap = drm_gem_prime_mmap,
+#else
 	.gem_prime_mmap = rknpu_gem_prime_mmap,
+#endif
 	.ioctls = rknpu_ioctls,
 	.num_ioctls = ARRAY_SIZE(rknpu_ioctls),
 	.fops = &rknpu_drm_driver_fops,
@@ -602,7 +614,7 @@ static enum hrtimer_restart hrtimer_handler(struct hrtimer *timer)
 		container_of(timer, struct rknpu_device, timer);
 	struct rknpu_subcore_data *subcore_data = NULL;
 	struct rknpu_job *job = NULL;
-	ktime_t now = ktime_get();
+	ktime_t now;
 	unsigned long flags;
 	int i;
 
@@ -613,9 +625,10 @@ static enum hrtimer_restart hrtimer_handler(struct hrtimer *timer)
 
 		job = subcore_data->job;
 		if (job) {
+			now = ktime_get();
 			subcore_data->timer.busy_time +=
 				ktime_us_delta(now, job->hw_recoder_time);
-			job->hw_recoder_time = ktime_get();
+			job->hw_recoder_time = now;
 		}
 
 		subcore_data->timer.busy_time_record =
@@ -667,6 +680,42 @@ static bool rknpu_is_iommu_enable(struct device *dev)
 }
 
 #ifdef CONFIG_ROCKCHIP_RKNPU_DRM_GEM
+static int drm_fake_dev_register(struct rknpu_device *rknpu_dev)
+{
+	const struct platform_device_info rknpu_dev_info = {
+		.name = "rknpu_dev",
+		.id = PLATFORM_DEVID_AUTO,
+		.dma_mask = rknpu_dev->config->dma_mask,
+	};
+	struct platform_device *pdev = NULL;
+	int ret = -EINVAL;
+
+	pdev = platform_device_register_full(&rknpu_dev_info);
+	if (pdev) {
+		ret = of_dma_configure(&pdev->dev, NULL, true);
+		if (ret) {
+			platform_device_unregister(pdev);
+			pdev = NULL;
+		}
+	}
+
+	rknpu_dev->fake_dev = pdev ? &pdev->dev : NULL;
+
+	return ret;
+}
+
+static void drm_fake_dev_unregister(struct rknpu_device *rknpu_dev)
+{
+	struct platform_device *pdev = NULL;
+
+	if (!rknpu_dev->fake_dev)
+		return;
+
+	pdev = to_platform_device(rknpu_dev->fake_dev);
+
+	platform_device_unregister(pdev);
+}
+
 static int rknpu_drm_probe(struct rknpu_device *rknpu_dev)
 {
 	struct device *dev = rknpu_dev->dev;
@@ -685,6 +734,8 @@ static int rknpu_drm_probe(struct rknpu_device *rknpu_dev)
 	drm_dev->dev_private = rknpu_dev;
 	rknpu_dev->drm_dev = drm_dev;
 
+	drm_fake_dev_register(rknpu_dev);
+
 	return 0;
 
 err_free_drm:
@@ -701,6 +752,8 @@ static void rknpu_drm_remove(struct rknpu_device *rknpu_dev)
 {
 	struct drm_device *drm_dev = rknpu_dev->drm_dev;
 
+	drm_fake_dev_unregister(rknpu_dev);
+
 	drm_dev_unregister(drm_dev);
 
 #if KERNEL_VERSION(4, 15, 0) <= LINUX_VERSION_CODE

drivers/rknpu/rknpu_gem.c

@@ -985,6 +985,7 @@ static int rknpu_gem_mmap_buffer(struct rknpu_gem_object *rknpu_obj,
 	 * vm_pgoff (used as a fake buffer offset by DRM) to 0 as we want to map
 	 * the whole buffer.
 	 */
+	vma->vm_flags |= VM_DONTCOPY | VM_DONTEXPAND | VM_DONTDUMP | VM_IO;
 	vma->vm_flags &= ~VM_PFNMAP;
 	vma->vm_pgoff = 0;
 
@@ -1329,19 +1330,29 @@ void rknpu_gem_prime_vunmap(struct drm_gem_object *obj, void *vaddr)
 int rknpu_gem_prime_vmap(struct drm_gem_object *obj, struct iosys_map *map)
 {
 	struct rknpu_gem_object *rknpu_obj = to_rknpu_obj(obj);
+	void *vaddr = NULL;
 
 	if (!rknpu_obj->pages)
 		return -EINVAL;
 
-	map->vaddr = vmap(rknpu_obj->pages, rknpu_obj->num_pages, VM_MAP,
+	vaddr = vmap(rknpu_obj->pages, rknpu_obj->num_pages, VM_MAP,
 			  PAGE_KERNEL);
+	if (!vaddr)
+		return -ENOMEM;
+
+	iosys_map_set_vaddr(map, vaddr);
 
 	return 0;
 }
 
 void rknpu_gem_prime_vunmap(struct drm_gem_object *obj, struct iosys_map *map)
 {
-	vunmap(map->vaddr);
+	struct rknpu_gem_object *rknpu_obj = to_rknpu_obj(obj);
+
+	if (rknpu_obj->pages) {
+		vunmap(map->vaddr);
+		map->vaddr = NULL;
+	}
 }
 #endif
 
@@ -1412,10 +1423,12 @@ int rknpu_gem_sync_ioctl(struct drm_device *dev, void *data,
 			 struct drm_file *file_priv)
 {
 	struct rknpu_gem_object *rknpu_obj = NULL;
+	struct rknpu_device *rknpu_dev = dev->dev_private;
 	struct rknpu_mem_sync *args = data;
 	struct scatterlist *sg;
+	dma_addr_t sg_phys_addr;
 	unsigned long length, offset = 0;
-	unsigned long sg_left, size = 0;
+	unsigned long sg_offset, sg_left, size = 0;
 	unsigned long len = 0;
 	int i;
 
@@ -1439,6 +1452,8 @@ int rknpu_gem_sync_ioctl(struct drm_device *dev, void *data,
 						      DMA_FROM_DEVICE);
 		}
 	} else {
+		WARN_ON(!rknpu_dev->fake_dev);
+
 		length = args->size;
 		offset = args->offset;
 
@@ -1462,17 +1477,23 @@ int rknpu_gem_sync_ioctl(struct drm_device *dev, void *data,
 			if (len <= offset)
 				continue;
 
+			sg_phys_addr = sg_phys(sg);
+
 			sg_left = len - offset;
+			sg_offset = sg->length - sg_left;
+
 			size = (length < sg_left) ? length : sg_left;
 
 			if (args->flags & RKNPU_MEM_SYNC_TO_DEVICE) {
-				dma_sync_sg_for_device(dev->dev, sg, 1,
-						       DMA_TO_DEVICE);
+				dma_sync_single_range_for_device(
+					rknpu_dev->fake_dev, sg_phys_addr,
+					sg_offset, size, DMA_TO_DEVICE);
 			}
 
 			if (args->flags & RKNPU_MEM_SYNC_FROM_DEVICE) {
-				dma_sync_sg_for_cpu(dev->dev, sg, 1,
-						    DMA_FROM_DEVICE);
+				dma_sync_single_range_for_cpu(
+					rknpu_dev->fake_dev, sg_phys_addr,
+					sg_offset, size, DMA_FROM_DEVICE);
 			}
 
 			offset += size;

drivers/rknpu/rknpu_job.c

@@ -23,16 +23,25 @@
 #define REG_READ(offset) _REG_READ(rknpu_core_base, offset)
 #define REG_WRITE(value, offset) _REG_WRITE(rknpu_core_base, value, offset)
 
-static int rknpu_core_index(int core_mask)
+static int rknpu_wait_core_index(int core_mask)
 {
 	int index = 0;
 
-	if (core_mask & RKNPU_CORE0_MASK)
+	switch (core_mask & ((1 << RKNPU_MAX_CORES) - 1)) {
+	case RKNPU_CORE0_MASK:
+	case RKNPU_CORE0_MASK | RKNPU_CORE1_MASK:
+	case RKNPU_CORE0_MASK | RKNPU_CORE1_MASK | RKNPU_CORE2_MASK:
 		index = 0;
-	else if (core_mask & RKNPU_CORE1_MASK)
+		break;
+	case RKNPU_CORE1_MASK:
 		index = 1;
-	else if (core_mask & RKNPU_CORE2_MASK)
+		break;
+	case RKNPU_CORE2_MASK:
 		index = 2;
+		break;
+	default:
+		break;
+	}
 
 	return index;
 }
@@ -58,14 +67,24 @@ static int rknpu_core_mask(int core_index)
 	return core_mask;
 }
 
-static int rknn_get_task_number(struct rknpu_job *job, int core_index)
+static int rknpu_get_task_number(struct rknpu_job *job, int core_index)
 {
+	struct rknpu_device *rknpu_dev = job->rknpu_dev;
 	int task_num = job->args->task_number;
 
-	if (job->use_core_num == 2)
-		task_num = job->args->subcore_task[core_index].task_number;
-	else if (job->use_core_num == 3)
-		task_num = job->args->subcore_task[core_index + 2].task_number;
+	if (core_index >= RKNPU_MAX_CORES || core_index < 0) {
+		LOG_ERROR("core_index: %d set error!", core_index);
+		return 0;
+	}
+
+	if (rknpu_dev->config->num_irqs > 1) {
+		if (job->use_core_num == 1 || job->use_core_num == 2)
+			task_num =
+				job->args->subcore_task[core_index].task_number;
+		else if (job->use_core_num == 3)
+			task_num = job->args->subcore_task[core_index + 2]
+					   .task_number;
+	}
 
 	return task_num;
 }
@@ -159,7 +178,7 @@ static inline int rknpu_job_wait(struct rknpu_job *job)
 	struct rknpu_subcore_data *subcore_data = NULL;
 	struct rknpu_job *entry, *q;
 	void __iomem *rknpu_core_base = NULL;
-	int core_index = rknpu_core_index(job->args->core_mask);
+	int core_index = rknpu_wait_core_index(job->args->core_mask);
 	unsigned long flags;
 	int wait_count = 0;
 	bool continue_wait = false;
@@ -179,7 +198,6 @@ static inline int rknpu_job_wait(struct rknpu_job *job)
 
 		if (ret == 0) {
 			int64_t commit_time = 0;
-
 			spin_lock_irqsave(&rknpu_dev->irq_lock, flags);
 			commit_time = ktime_us_delta(ktime_get(),
 						     job->commit_pc_time);
@@ -245,7 +263,8 @@ static inline int rknpu_job_wait(struct rknpu_job *job)
 	return 0;
 }
 
-static inline int rknpu_job_commit_pc(struct rknpu_job *job, int core_index)
+static inline int rknpu_job_subcore_commit_pc(struct rknpu_job *job,
+					      int core_index)
 {
 	struct rknpu_device *rknpu_dev = job->rknpu_dev;
 	struct rknpu_submit *args = job->args;
@@ -262,12 +281,14 @@ static inline int rknpu_job_commit_pc(struct rknpu_job *job, int core_index)
 	struct rknpu_task *last_task = NULL;
 	void __iomem *rknpu_core_base = rknpu_dev->base[core_index];
 	int task_start = args->task_start;
-	int task_end = args->task_start + args->task_number - 1;
+	int task_end;
 	int task_number = args->task_number;
 	int task_pp_en = args->flags & RKNPU_JOB_PINGPONG ? 1 : 0;
 	int pc_data_amount_scale = rknpu_dev->config->pc_data_amount_scale;
 	int pc_task_number_bits = rknpu_dev->config->pc_task_number_bits;
 	int i = 0;
+	int submit_index = atomic_read(&job->submit_count[core_index]);
+	int max_submit_number = rknpu_dev->config->max_submit_number;
 
 	if (!task_obj) {
 		job->ret = -EINVAL;
@@ -282,38 +303,40 @@ static inline int rknpu_job_commit_pc(struct rknpu_job *job, int core_index)
 			}
 		}
 
-		if (job->use_core_num == 1) {
+		switch (job->use_core_num) {
+		case 1:
+		case 2:
 			task_start = args->subcore_task[core_index].task_start;
-			task_end = args->subcore_task[core_index].task_start +
-				   args->subcore_task[core_index].task_number -
-				   1;
 			task_number =
 				args->subcore_task[core_index].task_number;
-		} else if (job->use_core_num == 2) {
-			task_start = args->subcore_task[core_index].task_start;
-			task_end = args->subcore_task[core_index].task_start +
-				   args->subcore_task[core_index].task_number -
-				   1;
-			task_number =
-				args->subcore_task[core_index].task_number;
-		} else if (job->use_core_num == 3) {
+			break;
+		case 3:
 			task_start =
 				args->subcore_task[core_index + 2].task_start;
-			task_end =
-				args->subcore_task[core_index + 2].task_start +
-				args->subcore_task[core_index + 2].task_number -
-				1;
 			task_number =
 				args->subcore_task[core_index + 2].task_number;
+			break;
+		default:
+			LOG_ERROR("Unknown use core num %d\n",
+				  job->use_core_num);
+			break;
 		}
 	}
 
+	task_start = task_start + submit_index * max_submit_number;
+	task_number = task_number - submit_index * max_submit_number;
+	task_number = task_number > max_submit_number ? max_submit_number :
+							task_number;
+	task_end = task_start + task_number - 1;
+
 	task_base = task_obj->kv_addr;
 
 	first_task = &task_base[task_start];
 	last_task = &task_base[task_end];
 
+	spin_lock(&rknpu_dev->lock);
 	REG_WRITE(first_task->regcmd_addr, RKNPU_OFFSET_PC_DATA_ADDR);
+	spin_unlock(&rknpu_dev->lock);
 
 	REG_WRITE((first_task->regcfg_amount + RKNPU_PC_DATA_EXTRA_AMOUNT +
 		   pc_data_amount_scale - 1) /
@@ -340,21 +363,50 @@ static inline int rknpu_job_commit_pc(struct rknpu_job *job, int core_index)
 	return 0;
 }
 
-static int rknpu_job_commit(struct rknpu_job *job, int core_index)
+static inline int rknpu_job_subcore_commit(struct rknpu_job *job, int core_index)
 {
 	struct rknpu_device *rknpu_dev = job->rknpu_dev;
 	struct rknpu_submit *args = job->args;
 	void __iomem *rknpu_core_base = rknpu_dev->base[core_index];
 
 	// switch to slave mode
+	spin_lock(&rknpu_dev->lock);
 	REG_WRITE(0x1, RKNPU_OFFSET_PC_DATA_ADDR);
+	spin_unlock(&rknpu_dev->lock);
 
 	if (!(args->flags & RKNPU_JOB_PC)) {
 		job->ret = -EINVAL;
 		return job->ret;
 	}
 
-	return rknpu_job_commit_pc(job, core_index);
+	return rknpu_job_subcore_commit_pc(job, core_index);
+}
+
+static void rknpu_job_commit(struct rknpu_job *job)
+{
+	switch (job->args->core_mask & ((1 << RKNPU_MAX_CORES) - 1)) {
+	case RKNPU_CORE0_MASK:
+		rknpu_job_subcore_commit(job, 0);
+		break;
+	case RKNPU_CORE1_MASK:
+		rknpu_job_subcore_commit(job, 1);
+		break;
+	case RKNPU_CORE2_MASK:
+		rknpu_job_subcore_commit(job, 2);
+		break;
+	case RKNPU_CORE0_MASK | RKNPU_CORE1_MASK:
+		rknpu_job_subcore_commit(job, 0);
+		rknpu_job_subcore_commit(job, 1);
+		break;
+	case RKNPU_CORE0_MASK | RKNPU_CORE1_MASK | RKNPU_CORE2_MASK:
+		rknpu_job_subcore_commit(job, 0);
+		rknpu_job_subcore_commit(job, 1);
+		rknpu_job_subcore_commit(job, 2);
+		break;
+	default:
+		LOG_ERROR("Unknown core mask: %d\n", job->args->core_mask);
+		break;
+	}
 }
 
 static void rknpu_job_next(struct rknpu_device *rknpu_dev, int core_index)
@@ -385,30 +437,7 @@ static void rknpu_job_next(struct rknpu_device *rknpu_dev, int core_index)
 	spin_unlock_irqrestore(&rknpu_dev->irq_lock, flags);
 
 	if (atomic_dec_and_test(&job->run_count)) {
-		switch (job->args->core_mask & ((1 << RKNPU_MAX_CORES) - 1)) {
-		case RKNPU_CORE0_MASK:
-			rknpu_job_commit(job, 0);
-			break;
-		case RKNPU_CORE1_MASK:
-			rknpu_job_commit(job, 1);
-			break;
-		case RKNPU_CORE2_MASK:
-			rknpu_job_commit(job, 2);
-			break;
-		case RKNPU_CORE0_MASK | RKNPU_CORE1_MASK:
-			rknpu_job_commit(job, 0);
-			rknpu_job_commit(job, 1);
-			break;
-		case RKNPU_CORE0_MASK | RKNPU_CORE1_MASK | RKNPU_CORE2_MASK:
-			rknpu_job_commit(job, 0);
-			rknpu_job_commit(job, 1);
-			rknpu_job_commit(job, 2);
-			break;
-		default:
-			LOG_ERROR("Unknown core mask: %#x\n",
-				  job->args->core_mask);
-			break;
-		}
+		rknpu_job_commit(job);
 	}
 }
 
@@ -417,15 +446,22 @@ static void rknpu_job_done(struct rknpu_job *job, int ret, int core_index)
 	struct rknpu_device *rknpu_dev = job->rknpu_dev;
 	struct rknpu_subcore_data *subcore_data = NULL;
 	unsigned long flags;
-	ktime_t now = ktime_get();
+	int max_submit_number = rknpu_dev->config->max_submit_number;
+
+	if (atomic_inc_return(&job->submit_count[core_index]) <
+	    (rknpu_get_task_number(job, core_index) + max_submit_number - 1) /
+		    max_submit_number) {
+		rknpu_job_commit(job);
+		return;
+	}
 
 	subcore_data = &rknpu_dev->subcore_datas[core_index];
 
 	spin_lock_irqsave(&rknpu_dev->irq_lock, flags);
 	subcore_data->job = NULL;
-	subcore_data->task_num -= rknn_get_task_number(job, core_index);
+	subcore_data->task_num -= rknpu_get_task_number(job, core_index);
 	subcore_data->timer.busy_time +=
-		ktime_us_delta(now, job->hw_recoder_time);
+		ktime_us_delta(ktime_get(), job->hw_recoder_time);
 	spin_unlock_irqrestore(&rknpu_dev->irq_lock, flags);
 
 	if (atomic_dec_and_test(&job->interrupt_count)) {
@@ -498,7 +534,7 @@ static void rknpu_job_schedule(struct rknpu_job *job)
 		if (job->args->core_mask & rknpu_core_mask(i)) {
 			subcore_data = &rknpu_dev->subcore_datas[i];
 			list_add_tail(&job->head[i], &subcore_data->todo_list);
-			subcore_data->task_num += rknn_get_task_number(job, i);
+			subcore_data->task_num += rknpu_get_task_number(job, i);
 		}
 	}
 	spin_unlock_irqrestore(&rknpu_dev->irq_lock, flags);
@@ -525,7 +561,7 @@ static void rknpu_job_abort(struct rknpu_job *job)
 			if (job == subcore_data->job && !job->irq_entry[i]) {
 				subcore_data->job = NULL;
 				subcore_data->task_num -=
-					rknn_get_task_number(job, i);
+					rknpu_get_task_number(job, i);
 			}
 		}
 	}

drivers/rknpu/rknpu_mem.c

@@ -15,6 +15,8 @@
 #include "rknpu_ioctl.h"
 #include "rknpu_mem.h"
 
+#ifdef CONFIG_ROCKCHIP_RKNPU_DMA_HEAP
+
 int rknpu_mem_create_ioctl(struct rknpu_device *rknpu_dev, unsigned long data,
 			   struct file *file)
 {
@@ -108,7 +110,7 @@ int rknpu_mem_create_ioctl(struct rknpu_device *rknpu_dev, unsigned long data,
 	}
 
 	page_count = length >> PAGE_SHIFT;
-	pages = kmalloc_array(page_count, sizeof(struct page), GFP_KERNEL);
+	pages = vmalloc(page_count * sizeof(struct page));
 	if (!pages) {
 		LOG_ERROR("alloc pages failed\n");
 		ret = -ENOMEM;
@@ -146,7 +148,8 @@ int rknpu_mem_create_ioctl(struct rknpu_device *rknpu_dev, unsigned long data,
 		goto err_unmap_kv_addr;
 	}
 
-	kfree(pages);
+	vfree(pages);
+	pages = NULL;
 	dma_buf_unmap_attachment(attachment, table, DMA_BIDIRECTIONAL);
 	dma_buf_detach(dmabuf, attachment);
 
@@ -169,7 +172,8 @@ err_unmap_kv_addr:
 	rknpu_obj->kv_addr = NULL;
 
 err_free_pages:
-	kfree(pages);
+	vfree(pages);
+	pages = NULL;
 
 err_detach_dma_buf:
 	dma_buf_unmap_attachment(attachment, table, DMA_BIDIRECTIONAL);
@@ -292,7 +296,9 @@ int rknpu_mem_sync_ioctl(struct rknpu_device *rknpu_dev, unsigned long data)
 {
 	struct rknpu_mem_object *rknpu_obj = NULL;
 	struct rknpu_mem_sync args;
+#ifdef CONFIG_DMABUF_PARTIAL
 	struct dma_buf *dmabuf;
+#endif
 	int ret = -EFAULT;
 
 	if (unlikely(copy_from_user(&args, (struct rknpu_mem_sync *)data,
@@ -310,7 +316,6 @@ int rknpu_mem_sync_ioctl(struct rknpu_device *rknpu_dev, unsigned long data)
 	}
 
 	rknpu_obj = (struct rknpu_mem_object *)(uintptr_t)args.obj_addr;
-	dmabuf = rknpu_obj->dmabuf;
 
 #ifndef CONFIG_DMABUF_PARTIAL
 	if (args.flags & RKNPU_MEM_SYNC_TO_DEVICE) {
@@ -322,6 +327,7 @@ int rknpu_mem_sync_ioctl(struct rknpu_device *rknpu_dev, unsigned long data)
 				   DMA_FROM_DEVICE, true);
 	}
 #else
+	dmabuf = rknpu_obj->dmabuf;
 	if (args.flags & RKNPU_MEM_SYNC_TO_DEVICE) {
 		dmabuf->ops->end_cpu_access_partial(dmabuf, DMA_TO_DEVICE,
 						    args.offset, args.size);
@@ -334,3 +340,5 @@ int rknpu_mem_sync_ioctl(struct rknpu_device *rknpu_dev, unsigned long data)
 
 	return 0;
 }
+
+#endif