forked from ~ljy/RK356X_SDK_RELEASE
blame | history | patch | commit | commitdiff
hc
2023-12-11 072de836f53be56a70cecf70b43ae43b7ce17376 
 kernel/drivers/video/rockchip/rga3/rga_job.c
....@@ -14,74 +14,28 @@
1414 #include "rga_iommu.h"
1515 #include "rga_debugger.h"
1616 
17
-struct rga_job *
18
-rga_scheduler_get_pending_job_list(struct rga_scheduler_t *scheduler)
19
-{
20
-	unsigned long flags;
21
-	struct rga_job *job;
22
-
23
-	spin_lock_irqsave(&scheduler->irq_lock, flags);
24
-
25
-	job = list_first_entry_or_null(&scheduler->todo_list,
26
-		struct rga_job, head);
27
-
28
-	spin_unlock_irqrestore(&scheduler->irq_lock, flags);
29
-
30
-	return job;
31
-}
32
-
33
-struct rga_job *
34
-rga_scheduler_get_running_job(struct rga_scheduler_t *scheduler)
35
-{
36
-	unsigned long flags;
37
-	struct rga_job *job;
38
-
39
-	spin_lock_irqsave(&scheduler->irq_lock, flags);
40
-
41
-	job = scheduler->running_job;
42
-
43
-	spin_unlock_irqrestore(&scheduler->irq_lock, flags);
44
-
45
-	return job;
46
-}
47
-
48
-struct rga_scheduler_t *rga_job_get_scheduler(struct rga_job *job)
49
-{
50
-	return job->scheduler;
51
-}
52
-
5317 static void rga_job_free(struct rga_job *job)
5418 {
5519 	free_page((unsigned long)job);
5620 }
5721 
58
-void rga_job_session_destroy(struct rga_session *session)
22
+static void rga_job_kref_release(struct kref *ref)
5923 {
60
-	struct rga_scheduler_t *scheduler = NULL;
61
-	struct rga_job *job_pos, *job_q;
62
-	int i;
24
+	struct rga_job *job;
6325 
64
-	unsigned long flags;
26
+	job = container_of(ref, struct rga_job, refcount);
6527 
66
-	for (i = 0; i < rga_drvdata->num_of_scheduler; i++) {
67
-		scheduler = rga_drvdata->scheduler[i];
28
+	rga_job_free(job);
29
+}
6830 
69
-		spin_lock_irqsave(&scheduler->irq_lock, flags);
31
+static int rga_job_put(struct rga_job *job)
32
+{
33
+	return kref_put(&job->refcount, rga_job_kref_release);
34
+}
7035 
71
-		list_for_each_entry_safe(job_pos, job_q, &scheduler->todo_list, head) {
72
-			if (session == job_pos->session) {
73
-				list_del(&job_pos->head);
74
-
75
-				spin_unlock_irqrestore(&scheduler->irq_lock, flags);
76
-
77
-				rga_job_free(job_pos);
78
-
79
-				spin_lock_irqsave(&scheduler->irq_lock, flags);
80
-			}
81
-		}
82
-
83
-		spin_unlock_irqrestore(&scheduler->irq_lock, flags);
84
-	}
36
+static void rga_job_get(struct rga_job *job)
37
+{
38
+	kref_get(&job->refcount);
8539 }
8640 
8741 static int rga_job_cleanup(struct rga_job *job)
....@@ -90,7 +44,7 @@
9044 		pr_err("(pid:%d) job clean use time = %lld\n", job->pid,
9145 			ktime_us_delta(ktime_get(), job->timestamp));
9246 
93
-	rga_job_free(job);
47
+	rga_job_put(job);
9448 
9549 	return 0;
9650 }
....@@ -165,6 +119,7 @@
165119 		return NULL;
166120 
167121 	INIT_LIST_HEAD(&job->head);
122
+	kref_init(&job->refcount);
168123 
169124 	job->timestamp = ktime_get();
170125 	job->pid = current->pid;
....@@ -232,16 +187,18 @@
232187 		return ret;
233188 	}
234189 
190
+	set_bit(RGA_JOB_STATE_RUNNING, &job->state);
191
+
235192 	/* for debug */
236193 	if (DEBUGGER_EN(MSG))
237194 		rga_job_dump_info(job);
238195 
239196 	return ret;
240
-
241197 }
242198 
243
-static void rga_job_next(struct rga_scheduler_t *scheduler)
199
+void rga_job_next(struct rga_scheduler_t *scheduler)
244200 {
201
+	int ret;
245202 	struct rga_job *job = NULL;
246203 	unsigned long flags;
247204 
....@@ -261,51 +218,33 @@
261218 	scheduler->job_count--;
262219 
263220 	scheduler->running_job = job;
221
+	set_bit(RGA_JOB_STATE_PREPARE, &job->state);
222
+	rga_job_get(job);
264223 
265224 	spin_unlock_irqrestore(&scheduler->irq_lock, flags);
266225 
267
-	job->ret = rga_job_run(job, scheduler);
226
+	ret = rga_job_run(job, scheduler);
268227 	/* If some error before hw run */
269
-	if (job->ret < 0) {
270
-		pr_err("some error on rga_job_run before hw start, %s(%d)\n",
271
-			__func__, __LINE__);
228
+	if (ret < 0) {
229
+		pr_err("some error on rga_job_run before hw start, %s(%d)\n", __func__, __LINE__);
272230 
273231 		spin_lock_irqsave(&scheduler->irq_lock, flags);
274232 
275233 		scheduler->running_job = NULL;
234
+		rga_job_put(job);
276235 
277236 		spin_unlock_irqrestore(&scheduler->irq_lock, flags);
278237 
238
+		job->ret = ret;
279239 		rga_request_release_signal(scheduler, job);
280240 
281241 		goto next_job;
282242 	}
243
+
244
+	rga_job_put(job);
283245 }
284246 
285
-static void rga_job_finish_and_next(struct rga_scheduler_t *scheduler,
286
-		struct rga_job *job, int ret)
287
-{
288
-	ktime_t now;
289
-
290
-	job->ret = ret;
291
-
292
-	if (DEBUGGER_EN(TIME)) {
293
-		now = ktime_get();
294
-		pr_info("hw use time = %lld\n", ktime_us_delta(now, job->hw_running_time));
295
-		pr_info("(pid:%d) job done use time = %lld\n", job->pid,
296
-			ktime_us_delta(now, job->timestamp));
297
-	}
298
-
299
-	rga_mm_unmap_job_info(job);
300
-
301
-	rga_request_release_signal(scheduler, job);
302
-
303
-	rga_job_next(scheduler);
304
-
305
-	rga_power_disable(scheduler);
306
-}
307
-
308
-void rga_job_done(struct rga_scheduler_t *scheduler, int ret)
247
+struct rga_job *rga_job_done(struct rga_scheduler_t *scheduler)
309248 {
310249 	struct rga_job *job;
311250 	unsigned long flags;
....@@ -314,16 +253,34 @@
314253 	spin_lock_irqsave(&scheduler->irq_lock, flags);
315254 
316255 	job = scheduler->running_job;
256
+	if (job == NULL) {
257
+		pr_err("core[0x%x] running job has been cleanup.\n", scheduler->core);
258
+
259
+		spin_unlock_irqrestore(&scheduler->irq_lock, flags);
260
+		return NULL;
261
+	}
317262 	scheduler->running_job = NULL;
318263 
319264 	scheduler->timer.busy_time += ktime_us_delta(now, job->hw_recoder_time);
265
+	set_bit(RGA_JOB_STATE_DONE, &job->state);
320266 
321267 	spin_unlock_irqrestore(&scheduler->irq_lock, flags);
268
+
269
+	if (scheduler->ops->read_back_reg)
270
+		scheduler->ops->read_back_reg(job, scheduler);
322271 
323272 	if (DEBUGGER_EN(DUMP_IMAGE))
324273 		rga_dump_job_image(job);
325274 
326
-	rga_job_finish_and_next(scheduler, job, ret);
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
+	}
280
+
281
+	rga_mm_unmap_job_info(job);
282
+
283
+	return job;
327284 }
328285 
329286 static void rga_job_scheduler_timeout_clean(struct rga_scheduler_t *scheduler)
....@@ -391,13 +348,20 @@
391348 	}
392349 
393350 	scheduler->job_count++;
351
+	set_bit(RGA_JOB_STATE_PENDING, &job->state);
394352 
395353 	spin_unlock_irqrestore(&scheduler->irq_lock, flags);
396354 }
397355 
398356 static struct rga_scheduler_t *rga_job_schedule(struct rga_job *job)
399357 {
358
+	int i;
400359 	struct rga_scheduler_t *scheduler = NULL;
360
+
361
+	for (i = 0; i < rga_drvdata->num_of_scheduler; i++) {
362
+		scheduler = rga_drvdata->scheduler[i];
363
+		rga_job_scheduler_timeout_clean(scheduler);
364
+	}
401365 
402366 	if (rga_drvdata->num_of_scheduler > 1) {
403367 		job->core = rga_job_assign(job);
....@@ -411,14 +375,12 @@
411375 		job->scheduler = rga_drvdata->scheduler[0];
412376 	}
413377 
414
-	scheduler = rga_job_get_scheduler(job);
378
+	scheduler = job->scheduler;
415379 	if (scheduler == NULL) {
416380 		pr_err("failed to get scheduler, %s(%d)\n", __func__, __LINE__);
417381 		job->ret = -EFAULT;
418382 		return NULL;
419383 	}
420
-
421
-	rga_job_scheduler_timeout_clean(scheduler);
422384 
423385 	return scheduler;
424386 }
....@@ -557,26 +519,13 @@
557519 	request->current_mm = NULL;
558520 }
559521 
560
-static int rga_request_alloc_release_fence(struct dma_fence **release_fence)
561
-{
562
-	struct dma_fence *fence;
563
-
564
-	fence = rga_dma_fence_alloc();
565
-	if (IS_ERR(fence)) {
566
-		pr_err("Can not alloc release fence!\n");
567
-		return IS_ERR(fence);
568
-	}
569
-
570
-	*release_fence = fence;
571
-
572
-	return rga_dma_fence_get_fd(fence);
573
-}
574
-
575
-static int rga_request_add_acquire_fence_callback(int acquire_fence_fd, void *private,
522
+static int rga_request_add_acquire_fence_callback(int acquire_fence_fd,
523
+						  struct rga_request *request,
576524 						  dma_fence_func_t cb_func)
577525 {
578526 	int ret;
579527 	struct dma_fence *acquire_fence = NULL;
528
+	struct rga_pending_request_manager *request_manager = rga_drvdata->pend_request_manager;
580529 
581530 	if (DEBUGGER_EN(MSG))
582531 		pr_info("acquire_fence_fd = %d", acquire_fence_fd);
....@@ -587,20 +536,48 @@
587536 		       __func__, acquire_fence_fd);
588537 		return -EINVAL;
589538 	}
590
-	/* close acquire fence fd */
591
-	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
+
592554 
593555 	ret = rga_dma_fence_get_status(acquire_fence);
594
-	if (ret == 0) {
595
-		ret = rga_dma_fence_add_callback(acquire_fence, cb_func, private);
596
-		if (ret < 0) {
597
-			if (ret == -ENOENT)
598
-				return 1;
556
+	if (ret < 0) {
557
+		pr_err("%s: Current acquire fence unexpectedly has error status before signal\n",
558
+		       __func__);
559
+		return ret;
560
+	} else if (ret > 0) {
561
+		/* has been signaled */
562
+		return ret;
563
+	}
599564 
565
+	/*
566
+	 * Ensure that the request will not be free early when
567
+	 * the callback is called.
568
+	 */
569
+	mutex_lock(&request_manager->lock);
570
+	rga_request_get(request);
571
+	mutex_unlock(&request_manager->lock);
572
+
573
+	ret = rga_dma_fence_add_callback(acquire_fence, cb_func, (void *)request);
574
+	if (ret < 0) {
575
+		if (ret != -ENOENT)
600576 			pr_err("%s: failed to add fence callback\n", __func__);
601
-			return ret;
602
-		}
603
-	} else {
577
+
578
+		mutex_lock(&request_manager->lock);
579
+		rga_request_put(request);
580
+		mutex_unlock(&request_manager->lock);
604581 		return ret;
605582 	}
606583 
....@@ -682,7 +659,8 @@
682659 					scheduler->ops->soft_reset(scheduler);
683660 				}
684661 
685
-				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);
686664 				running_abort_count++;
687665 			}
688666 		}
....@@ -742,6 +720,71 @@
742720 	mutex_unlock(&request_manager->lock);
743721 }
744722 
723
+void rga_request_session_destroy_abort(struct rga_session *session)
724
+{
725
+	int request_id;
726
+	struct rga_request *request;
727
+	struct rga_pending_request_manager *request_manager;
728
+
729
+	request_manager = rga_drvdata->pend_request_manager;
730
+	if (request_manager == NULL) {
731
+		pr_err("rga_pending_request_manager is null!\n");
732
+		return;
733
+	}
734
+
735
+	mutex_lock(&request_manager->lock);
736
+
737
+	idr_for_each_entry(&request_manager->request_idr, request, request_id) {
738
+		if (session == request->session) {
739
+			pr_err("[tgid:%d pid:%d] destroy request[%d] when the user exits",
740
+			       session->tgid, current->pid, request->id);
741
+			rga_request_put(request);
742
+		}
743
+	}
744
+
745
+	mutex_unlock(&request_manager->lock);
746
+}
747
+
748
+static int rga_request_timeout_query_state(struct rga_request *request)
749
+{
750
+	int i;
751
+	unsigned long flags;
752
+	struct rga_scheduler_t *scheduler = NULL;
753
+	struct rga_job *job = NULL;
754
+
755
+	for (i = 0; i < rga_drvdata->num_of_scheduler; i++) {
756
+		scheduler = rga_drvdata->scheduler[i];
757
+
758
+		spin_lock_irqsave(&scheduler->irq_lock, flags);
759
+
760
+		if (scheduler->running_job) {
761
+			job = scheduler->running_job;
762
+			if (request->id == job->request_id) {
763
+				if (test_bit(RGA_JOB_STATE_DONE, &job->state) &&
764
+				    test_bit(RGA_JOB_STATE_FINISH, &job->state)) {
765
+					spin_unlock_irqrestore(&scheduler->irq_lock, flags);
766
+					return request->ret;
767
+				} else if (!test_bit(RGA_JOB_STATE_DONE, &job->state) &&
768
+					   test_bit(RGA_JOB_STATE_FINISH, &job->state)) {
769
+					spin_unlock_irqrestore(&scheduler->irq_lock, flags);
770
+					pr_err("request[%d] hardware has finished, but the software has timeout!\n",
771
+					       request->id);
772
+					return -EBUSY;
773
+				} else if (!test_bit(RGA_JOB_STATE_DONE, &job->state) &&
774
+					   !test_bit(RGA_JOB_STATE_FINISH, &job->state)) {
775
+					spin_unlock_irqrestore(&scheduler->irq_lock, flags);
776
+					pr_err("request[%d] hardware has timeout.\n", request->id);
777
+					return -EBUSY;
778
+				}
779
+			}
780
+		}
781
+
782
+		spin_unlock_irqrestore(&scheduler->irq_lock, flags);
783
+	}
784
+
785
+	return request->ret;
786
+}
787
+
745788 static int rga_request_wait(struct rga_request *request)
746789 {
747790 	int left_time;
....@@ -752,8 +795,7 @@
752795 
753796 	switch (left_time) {
754797 	case 0:
755
-		pr_err("%s timeout", __func__);
756
-		ret = -EBUSY;
798
+		ret = rga_request_timeout_query_state(request);
757799 		goto err_request_abort;
758800 	case -ERESTARTSYS:
759801 		ret = -ERESTARTSYS;
....@@ -800,9 +842,15 @@
800842 						  struct dma_fence_cb *_waiter)
801843 {
802844 	struct rga_fence_waiter *waiter = (struct rga_fence_waiter *)_waiter;
845
+	struct rga_request *request = (struct rga_request *)waiter->private;
846
+	struct rga_pending_request_manager *request_manager = rga_drvdata->pend_request_manager;
803847 
804
-	if (rga_request_commit((struct rga_request *)waiter->private))
805
-		pr_err("rga request commit failed!\n");
848
+	if (rga_request_commit(request))
849
+		pr_err("rga request[%d] commit failed!\n", request->id);
850
+
851
+	mutex_lock(&request_manager->lock);
852
+	rga_request_put(request);
853
+	mutex_unlock(&request_manager->lock);
806854 
807855 	kfree(waiter);
808856 }
....@@ -812,6 +860,7 @@
812860 	struct rga_pending_request_manager *request_manager;
813861 	struct rga_request *request;
814862 	int finished_count, failed_count;
863
+	bool is_finished = false;
815864 	unsigned long flags;
816865 
817866 	request_manager = rga_drvdata->pend_request_manager;
....@@ -832,8 +881,6 @@
832881 	rga_request_get(request);
833882 	mutex_unlock(&request_manager->lock);
834883 
835
-	rga_job_cleanup(job);
836
-
837884 	spin_lock_irqsave(&request->lock, flags);
838885 
839886 	if (job->ret < 0) {
....@@ -848,6 +895,8 @@
848895 
849896 	spin_unlock_irqrestore(&request->lock, flags);
850897 
898
+	rga_job_cleanup(job);
899
+
851900 	if ((failed_count + finished_count) >= request->task_count) {
852901 		spin_lock_irqsave(&request->lock, flags);
853902 
....@@ -860,7 +909,7 @@
860909 
861910 		rga_dma_fence_signal(request->release_fence, request->ret);
862911 
863
-		wake_up(&request->finished_wq);
912
+		is_finished = true;
864913 
865914 		if (DEBUGGER_EN(MSG))
866915 			pr_info("request[%d] finished %d failed %d\n",
....@@ -873,7 +922,12 @@
873922 	}
874923 
875924 	mutex_lock(&request_manager->lock);
925
+
926
+	if (is_finished)
927
+		wake_up(&request->finished_wq);
928
+
876929 	rga_request_put(request);
930
+
877931 	mutex_unlock(&request_manager->lock);
878932 
879933 	return 0;
....@@ -927,6 +981,7 @@
927981 	request->sync_mode = user_request->sync_mode;
928982 	request->mpi_config_flags = user_request->mpi_config_flags;
929983 	request->acquire_fence_fd = user_request->acquire_fence_fd;
984
+	request->feature = task_list[0].feature;
930985 
931986 	spin_unlock_irqrestore(&request->lock, flags);
932987 
....@@ -1003,18 +1058,21 @@
10031058 {
10041059 	int ret = 0;
10051060 	unsigned long flags;
1061
+	struct dma_fence *release_fence;
10061062 
10071063 	spin_lock_irqsave(&request->lock, flags);
10081064 
10091065 	if (request->is_running) {
1010
-		pr_err("can not re-config when request is running");
10111066 		spin_unlock_irqrestore(&request->lock, flags);
1067
+
1068
+		pr_err("can not re-config when request is running\n");
10121069 		return -EFAULT;
10131070 	}
10141071 
10151072 	if (request->task_list == NULL) {
1016
-		pr_err("can not find task list from id[%d]", request->id);
10171073 		spin_unlock_irqrestore(&request->lock, flags);
1074
+
1075
+		pr_err("can not find task list from id[%d]\n", request->id);
10181076 		return -EINVAL;
10191077 	}
10201078 
....@@ -1026,46 +1084,71 @@
10261084 
10271085 	rga_request_get_current_mm(request);
10281086 
1087
+	/* Unlock after ensuring that the current request will not be resubmitted. */
10291088 	spin_unlock_irqrestore(&request->lock, flags);
10301089 
10311090 	if (request->sync_mode == RGA_BLIT_ASYNC) {
1032
-		ret = rga_request_alloc_release_fence(&request->release_fence);
1033
-		if (ret < 0) {
1034
-			pr_err("Failed to alloc release fence fd!\n");
1035
-			return ret;
1091
+		release_fence = rga_dma_fence_alloc();
1092
+		if (IS_ERR(release_fence)) {
1093
+			pr_err("Can not alloc release fence!\n");
1094
+			ret = IS_ERR(release_fence);
1095
+			goto error_put_current_mm;
10361096 		}
1037
-		request->release_fence_fd = ret;
1097
+		request->release_fence = release_fence;
10381098 
10391099 		if (request->acquire_fence_fd > 0) {
10401100 			ret = rga_request_add_acquire_fence_callback(
1041
-				request->acquire_fence_fd,
1042
-				(void *)request,
1101
+				request->acquire_fence_fd, request,
10431102 				rga_request_acquire_fence_signaled_cb);
10441103 			if (ret == 0) {
1045
-				return ret;
1046
-			} else if (ret == 1) {
1104
+				/* acquire fence active */
1105
+				goto export_release_fence_fd;
1106
+			} else if (ret > 0) {
1107
+				/* acquire fence has been signaled */
10471108 				goto request_commit;
10481109 			} else {
10491110 				pr_err("Failed to add callback with acquire fence fd[%d]!\n",
10501111 				       request->acquire_fence_fd);
1051
-				goto error_release_fence_put;
1112
+				goto err_put_release_fence;
10521113 			}
10531114 		}
1054
-
10551115 	}
10561116 
10571117 request_commit:
10581118 	ret = rga_request_commit(request);
10591119 	if (ret < 0) {
1060
-		pr_err("rga request commit failed!\n");
1061
-		goto error_release_fence_put;
1120
+		pr_err("rga request[%d] commit failed!\n", request->id);
1121
+		goto err_put_release_fence;
1122
+	}
1123
+
1124
+export_release_fence_fd:
1125
+	if (request->release_fence != NULL) {
1126
+		ret = rga_dma_fence_get_fd(request->release_fence);
1127
+		if (ret < 0) {
1128
+			pr_err("Failed to alloc release fence fd!\n");
1129
+			rga_request_release_abort(request, ret);
1130
+			return ret;
1131
+		}
1132
+
1133
+		request->release_fence_fd = ret;
10621134 	}
10631135 
10641136 	return 0;
10651137 
1066
-error_release_fence_put:
1067
-	rga_dma_fence_put(request->release_fence);
1068
-	request->release_fence = NULL;
1138
+err_put_release_fence:
1139
+	if (request->release_fence != NULL) {
1140
+		rga_dma_fence_put(request->release_fence);
1141
+		request->release_fence = NULL;
1142
+	}
1143
+
1144
+error_put_current_mm:
1145
+	spin_lock_irqsave(&request->lock, flags);
1146
+
1147
+	rga_request_put_current_mm(request);
1148
+	request->is_running = false;
1149
+
1150
+	spin_unlock_irqrestore(&request->lock, flags);
1151
+
10691152 	return ret;
10701153 }
10711154 
....@@ -1159,10 +1242,11 @@
11591242 	request = container_of(ref, struct rga_request, refcount);
11601243 
11611244 	if (rga_dma_fence_get_status(request->release_fence) == 0)
1162
-		rga_dma_fence_signal(request->release_fence, -EEXIST);
1245
+		rga_dma_fence_signal(request->release_fence, -EFAULT);
11631246 
11641247 	spin_lock_irqsave(&request->lock, flags);
11651248 
1249
+	rga_request_put_current_mm(request);
11661250 	rga_dma_fence_put(request->release_fence);
11671251 
11681252 	if (!request->is_running || request->is_done) {
....@@ -1188,6 +1272,7 @@
11881272 
11891273 int rga_request_alloc(uint32_t flags, struct rga_session *session)
11901274 {
1275
+	int new_id;
11911276 	struct rga_pending_request_manager *request_manager;
11921277 	struct rga_request *request;
11931278 
....@@ -1218,17 +1303,17 @@
12181303 	mutex_lock(&request_manager->lock);
12191304 
12201305 	idr_preload(GFP_KERNEL);
1221
-	request->id = idr_alloc(&request_manager->request_idr, request, 1, 0, GFP_KERNEL);
1306
+	new_id = idr_alloc_cyclic(&request_manager->request_idr, request, 1, 0, GFP_NOWAIT);
12221307 	idr_preload_end();
1223
-
1224
-	if (request->id <= 0) {
1225
-		pr_err("alloc request_id failed!\n");
1308
+	if (new_id < 0) {
1309
+		pr_err("request alloc id failed!\n");
12261310 
12271311 		mutex_unlock(&request_manager->lock);
12281312 		kfree(request);
1229
-		return -EFAULT;
1313
+		return new_id;
12301314 	}
12311315 
1316
+	request->id = new_id;
12321317 	request_manager->request_count++;
12331318 
12341319 	mutex_unlock(&request_manager->lock);