forked from ~ljy/RK356X_SDK_RELEASE
blame | history | patch | commit | commitdiff
hc
2024-05-13 9d77db3c730780c8ef5ccd4b66403ff5675cfe4e 
 kernel/drivers/video/rockchip/rga3/rga_job.c
....@@ -13,6 +13,7 @@
1313 #include "rga_mm.h"
1414 #include "rga_iommu.h"
1515 #include "rga_debugger.h"
16
+#include "rga_common.h"
1617 
1718 static void rga_job_free(struct rga_job *job)
1819 {
....@@ -40,11 +41,12 @@
4041 
4142 static int rga_job_cleanup(struct rga_job *job)
4243 {
43
-	if (DEBUGGER_EN(TIME))
44
-		pr_err("(pid:%d) job clean use time = %lld\n", job->pid,
45
-			ktime_us_delta(ktime_get(), job->timestamp));
46
-
4744 	rga_job_put(job);
45
+
46
+	if (DEBUGGER_EN(TIME))
47
+		pr_info("request[%d], job cleanup total cost time %lld us\n",
48
+			job->request_id,
49
+			ktime_us_delta(ktime_get(), job->timestamp));
4850 
4951 	return 0;
5052 }
....@@ -272,11 +274,11 @@
272274 	if (DEBUGGER_EN(DUMP_IMAGE))
273275 		rga_dump_job_image(job);
274276 
275
-	if (DEBUGGER_EN(TIME)) {
276
-		pr_info("hw use time = %lld\n", ktime_us_delta(now, job->hw_running_time));
277
-		pr_info("(pid:%d) job done use time = %lld\n", job->pid,
278
-			ktime_us_delta(now, job->timestamp));
279
-	}
277
+	if (DEBUGGER_EN(TIME))
278
+		pr_info("request[%d], hardware[%s] cost time %lld us\n",
279
+			job->request_id,
280
+			rga_get_core_name(scheduler->core),
281
+			ktime_us_delta(now, job->hw_running_time));
280282 
281283 	rga_mm_unmap_job_info(job);
282284 
....@@ -492,7 +494,7 @@
492494 	return false;
493495 }
494496 
495
-static int rga_request_get_current_mm(struct rga_request *request)
497
+static struct mm_struct *rga_request_get_current_mm(struct rga_request *request)
496498 {
497499 	int i;
498500 
....@@ -500,23 +502,21 @@
500502 		if (rga_is_need_current_mm(&(request->task_list[i]))) {
501503 			mmgrab(current->mm);
502504 			mmget(current->mm);
503
-			request->current_mm = current->mm;
504505 
505
-			break;
506
+			return current->mm;
506507 		}
507508 	}
508509 
509
-	return 0;
510
+	return NULL;
510511 }
511512 
512
-static void rga_request_put_current_mm(struct rga_request *request)
513
+static void rga_request_put_current_mm(struct mm_struct *mm)
513514 {
514
-	if (request->current_mm == NULL)
515
+	if (mm == NULL)
515516 		return;
516517 
517
-	mmput(request->current_mm);
518
-	mmdrop(request->current_mm);
519
-	request->current_mm = NULL;
518
+	mmput(mm);
519
+	mmdrop(mm);
520520 }
521521 
522522 static int rga_request_add_acquire_fence_callback(int acquire_fence_fd,
....@@ -536,8 +536,21 @@
536536 		       __func__, acquire_fence_fd);
537537 		return -EINVAL;
538538 	}
539
-	/* close acquire fence fd */
540
-	ksys_close(acquire_fence_fd);
539
+
540
+	if (!request->feature.user_close_fence) {
541
+		/* close acquire fence fd */
542
+#ifdef CONFIG_NO_GKI
543
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(6, 1, 0)
544
+		close_fd(acquire_fence_fd);
545
+#else
546
+		ksys_close(acquire_fence_fd);
547
+#endif
548
+#else
549
+		pr_err("Please update the driver to v1.2.28 to prevent acquire_fence_fd leaks.");
550
+		return -EFAULT;
551
+#endif
552
+	}
553
+
541554 
542555 	ret = rga_dma_fence_get_status(acquire_fence);
543556 	if (ret < 0) {
....@@ -646,7 +659,8 @@
646659 					scheduler->ops->soft_reset(scheduler);
647660 				}
648661 
649
-				pr_err("reset core[%d] by request abort", scheduler->core);
662
+				pr_err("reset core[%d] by request[%d] abort",
663
+				       scheduler->core, request->id);
650664 				running_abort_count++;
651665 			}
652666 		}
....@@ -679,6 +693,7 @@
679693 static void rga_request_release_abort(struct rga_request *request, int err_code)
680694 {
681695 	unsigned long flags;
696
+	struct mm_struct *current_mm;
682697 	struct rga_pending_request_manager *request_manager = rga_drvdata->pend_request_manager;
683698 
684699 	if (rga_request_scheduler_job_abort(request) > 0)
....@@ -693,10 +708,12 @@
693708 
694709 	request->is_running = false;
695710 	request->is_done = false;
696
-
697
-	rga_request_put_current_mm(request);
711
+	current_mm = request->current_mm;
712
+	request->current_mm = NULL;
698713 
699714 	spin_unlock_irqrestore(&request->lock, flags);
715
+
716
+	rga_request_put_current_mm(current_mm);
700717 
701718 	rga_dma_fence_signal(request->release_fence, err_code);
702719 
....@@ -753,12 +770,13 @@
753770 				} else if (!test_bit(RGA_JOB_STATE_DONE, &job->state) &&
754771 					   test_bit(RGA_JOB_STATE_FINISH, &job->state)) {
755772 					spin_unlock_irqrestore(&scheduler->irq_lock, flags);
756
-					pr_err("hardware has finished, but the software has timeout!\n");
773
+					pr_err("request[%d] hardware has finished, but the software has timeout!\n",
774
+					       request->id);
757775 					return -EBUSY;
758776 				} else if (!test_bit(RGA_JOB_STATE_DONE, &job->state) &&
759777 					   !test_bit(RGA_JOB_STATE_FINISH, &job->state)) {
760778 					spin_unlock_irqrestore(&scheduler->irq_lock, flags);
761
-					pr_err("hardware has timeout.\n");
779
+					pr_err("request[%d] hardware has timeout.\n", request->id);
762780 					return -EBUSY;
763781 				}
764782 			}
....@@ -805,7 +823,14 @@
805823 	struct rga_job *job;
806824 
807825 	for (i = 0; i < request->task_count; i++) {
808
-		job = rga_job_commit(&(request->task_list[i]), request);
826
+		struct rga_req *req = &(request->task_list[i]);
827
+
828
+		if (DEBUGGER_EN(MSG)) {
829
+			pr_info("commit request[%d] task[%d]:\n", request->id, i);
830
+			rga_cmd_print_debug_info(req);
831
+		}
832
+
833
+		job = rga_job_commit(req, request);
809834 		if (IS_ERR(job)) {
810835 			pr_err("request[%d] task[%d] job_commit failed.\n", request->id, i);
811836 			rga_request_release_abort(request, PTR_ERR(job));
....@@ -826,12 +851,34 @@
826851 static void rga_request_acquire_fence_signaled_cb(struct dma_fence *fence,
827852 						  struct dma_fence_cb *_waiter)
828853 {
854
+	int ret;
855
+	unsigned long flags;
856
+	struct mm_struct *current_mm;
829857 	struct rga_fence_waiter *waiter = (struct rga_fence_waiter *)_waiter;
830858 	struct rga_request *request = (struct rga_request *)waiter->private;
831859 	struct rga_pending_request_manager *request_manager = rga_drvdata->pend_request_manager;
832860 
833
-	if (rga_request_commit(request))
834
-		pr_err("rga request commit failed!\n");
861
+	ret = rga_request_commit(request);
862
+	if (ret < 0) {
863
+		pr_err("acquire_fence callback: rga request[%d] commit failed!\n", request->id);
864
+
865
+		spin_lock_irqsave(&request->lock, flags);
866
+
867
+		request->is_running = false;
868
+		current_mm = request->current_mm;
869
+		request->current_mm = NULL;
870
+
871
+		spin_unlock_irqrestore(&request->lock, flags);
872
+
873
+		rga_request_put_current_mm(current_mm);
874
+
875
+		/*
876
+		 * Since the callback is called while holding &dma_fence.lock,
877
+		 * the _locked API is used here.
878
+		 */
879
+		if (dma_fence_get_status_locked(request->release_fence) == 0)
880
+			dma_fence_signal_locked(request->release_fence);
881
+	}
835882 
836883 	mutex_lock(&request_manager->lock);
837884 	rga_request_put(request);
....@@ -844,7 +891,9 @@
844891 {
845892 	struct rga_pending_request_manager *request_manager;
846893 	struct rga_request *request;
894
+	struct mm_struct *current_mm;
847895 	int finished_count, failed_count;
896
+	bool is_finished = false;
848897 	unsigned long flags;
849898 
850899 	request_manager = rga_drvdata->pend_request_manager;
....@@ -879,21 +928,21 @@
879928 
880929 	spin_unlock_irqrestore(&request->lock, flags);
881930 
882
-	rga_job_cleanup(job);
883
-
884931 	if ((failed_count + finished_count) >= request->task_count) {
885932 		spin_lock_irqsave(&request->lock, flags);
886933 
887934 		request->is_running = false;
888935 		request->is_done = true;
889
-
890
-		rga_request_put_current_mm(request);
936
+		current_mm = request->current_mm;
937
+		request->current_mm = NULL;
891938 
892939 		spin_unlock_irqrestore(&request->lock, flags);
893940 
941
+		rga_request_put_current_mm(current_mm);
942
+
894943 		rga_dma_fence_signal(request->release_fence, request->ret);
895944 
896
-		wake_up(&request->finished_wq);
945
+		is_finished = true;
897946 
898947 		if (DEBUGGER_EN(MSG))
899948 			pr_info("request[%d] finished %d failed %d\n",
....@@ -906,8 +955,20 @@
906955 	}
907956 
908957 	mutex_lock(&request_manager->lock);
958
+
959
+	if (is_finished)
960
+		wake_up(&request->finished_wq);
961
+
909962 	rga_request_put(request);
963
+
910964 	mutex_unlock(&request_manager->lock);
965
+
966
+	if (DEBUGGER_EN(TIME))
967
+		pr_info("request[%d], job done total cost time %lld us\n",
968
+			job->request_id,
969
+			ktime_us_delta(ktime_get(), job->timestamp));
970
+
971
+	rga_job_cleanup(job);
911972 
912973 	return 0;
913974 }
....@@ -960,6 +1021,7 @@
9601021 	request->sync_mode = user_request->sync_mode;
9611022 	request->mpi_config_flags = user_request->mpi_config_flags;
9621023 	request->acquire_fence_fd = user_request->acquire_fence_fd;
1024
+	request->feature = task_list[0].feature;
9631025 
9641026 	spin_unlock_irqrestore(&request->lock, flags);
9651027 
....@@ -1037,6 +1099,9 @@
10371099 	int ret = 0;
10381100 	unsigned long flags;
10391101 	struct dma_fence *release_fence;
1102
+	struct mm_struct *current_mm;
1103
+
1104
+	current_mm = rga_request_get_current_mm(request);
10401105 
10411106 	spin_lock_irqsave(&request->lock, flags);
10421107 
....@@ -1044,14 +1109,16 @@
10441109 		spin_unlock_irqrestore(&request->lock, flags);
10451110 
10461111 		pr_err("can not re-config when request is running\n");
1047
-		return -EFAULT;
1112
+		ret = -EFAULT;
1113
+		goto err_put_current_mm;
10481114 	}
10491115 
10501116 	if (request->task_list == NULL) {
10511117 		spin_unlock_irqrestore(&request->lock, flags);
10521118 
10531119 		pr_err("can not find task list from id[%d]\n", request->id);
1054
-		return -EINVAL;
1120
+		ret = -EINVAL;
1121
+		goto err_put_current_mm;
10551122 	}
10561123 
10571124 	/* Reset */
....@@ -1059,8 +1126,7 @@
10591126 	request->is_done = false;
10601127 	request->finished_task_count = 0;
10611128 	request->failed_task_count = 0;
1062
-
1063
-	rga_request_get_current_mm(request);
1129
+	request->current_mm = current_mm;
10641130 
10651131 	/* Unlock after ensuring that the current request will not be resubmitted. */
10661132 	spin_unlock_irqrestore(&request->lock, flags);
....@@ -1070,7 +1136,7 @@
10701136 		if (IS_ERR(release_fence)) {
10711137 			pr_err("Can not alloc release fence!\n");
10721138 			ret = IS_ERR(release_fence);
1073
-			goto error_put_current_mm;
1139
+			goto err_reset_request;
10741140 		}
10751141 		request->release_fence = release_fence;
10761142 
....@@ -1095,7 +1161,7 @@
10951161 request_commit:
10961162 	ret = rga_request_commit(request);
10971163 	if (ret < 0) {
1098
-		pr_err("rga request commit failed!\n");
1164
+		pr_err("rga request[%d] commit failed!\n", request->id);
10991165 		goto err_put_release_fence;
11001166 	}
11011167 
....@@ -1119,13 +1185,16 @@
11191185 		request->release_fence = NULL;
11201186 	}
11211187 
1122
-error_put_current_mm:
1188
+err_reset_request:
11231189 	spin_lock_irqsave(&request->lock, flags);
11241190 
1125
-	rga_request_put_current_mm(request);
1191
+	request->current_mm = NULL;
11261192 	request->is_running = false;
11271193 
11281194 	spin_unlock_irqrestore(&request->lock, flags);
1195
+
1196
+err_put_current_mm:
1197
+	rga_request_put_current_mm(current_mm);
11291198 
11301199 	return ret;
11311200 }
....@@ -1215,6 +1284,7 @@
12151284 static void rga_request_kref_release(struct kref *ref)
12161285 {
12171286 	struct rga_request *request;
1287
+	struct mm_struct *current_mm;
12181288 	unsigned long flags;
12191289 
12201290 	request = container_of(ref, struct rga_request, refcount);
....@@ -1224,16 +1294,22 @@
12241294 
12251295 	spin_lock_irqsave(&request->lock, flags);
12261296 
1227
-	rga_request_put_current_mm(request);
12281297 	rga_dma_fence_put(request->release_fence);
1298
+	current_mm = request->current_mm;
1299
+	request->current_mm = NULL;
12291300 
12301301 	if (!request->is_running || request->is_done) {
12311302 		spin_unlock_irqrestore(&request->lock, flags);
1303
+
1304
+		rga_request_put_current_mm(current_mm);
1305
+
12321306 		goto free_request;
12331307 	}
12341308 
12351309 	spin_unlock_irqrestore(&request->lock, flags);
12361310 
1311
+	rga_request_put_current_mm(current_mm);
1312
+
12371313 	rga_request_scheduler_job_abort(request);
12381314 
12391315 free_request: