forked from ~ljy/RK356X_SDK_RELEASE

blame | history | patch | commit | commitdiff
hc
2023-11-06 15ade055295d13f95d49e3d99b09f3bbfb4a43e7 
 kernel/drivers/video/rockchip/mpp/mpp_common.c
....@@ -36,7 +36,6 @@
3636 #include "mpp_common.h"
3737 #include "mpp_iommu.h"
3838 
39
-#define MPP_WORK_TIMEOUT_DELAY		(200)
4039 #define MPP_WAIT_TIMEOUT_DELAY		(2000)
4140 
4241 /* Use 'v' as magic number */
....@@ -231,20 +230,9 @@
231230 	return 0;
232231 }
233232 
234
-static int mpp_session_clear(struct mpp_dev *mpp,
235
-			     struct mpp_session *session)
233
+static int mpp_session_clear_pending(struct mpp_session *session)
236234 {
237235 	struct mpp_task *task = NULL, *n;
238
-
239
-	/* clear session done list */
240
-	mutex_lock(&session->done_lock);
241
-	list_for_each_entry_safe(task, n,
242
-				 &session->done_list,
243
-				 done_link) {
244
-		list_del_init(&task->done_link);
245
-		kref_put(&task->ref, mpp_free_task);
246
-	}
247
-	mutex_unlock(&session->done_lock);
248236 
249237 	/* clear session pending list */
250238 	mutex_lock(&session->pending_lock);
....@@ -261,6 +249,49 @@
261249 	return 0;
262250 }
263251 
252
+void mpp_session_cleanup_detach(struct mpp_taskqueue *queue, struct kthread_work *work)
253
+{
254
+	struct mpp_session *session, *n;
255
+
256
+	if (!atomic_read(&queue->detach_count))
257
+		return;
258
+
259
+	mutex_lock(&queue->session_lock);
260
+	list_for_each_entry_safe(session, n, &queue->session_detach, session_link) {
261
+		s32 task_count = atomic_read(&session->task_count);
262
+
263
+		if (!task_count) {
264
+			list_del_init(&session->session_link);
265
+			atomic_dec(&queue->detach_count);
266
+		}
267
+
268
+		mutex_unlock(&queue->session_lock);
269
+
270
+		if (task_count) {
271
+			mpp_dbg_session("session %d:%d task not finished %d\n",
272
+					session->pid, session->index,
273
+					atomic_read(&queue->detach_count));
274
+
275
+			mpp_session_clear_pending(session);
276
+		} else {
277
+			mpp_dbg_session("queue detach %d\n",
278
+					atomic_read(&queue->detach_count));
279
+
280
+			mpp_session_deinit(session);
281
+		}
282
+
283
+		mutex_lock(&queue->session_lock);
284
+	}
285
+	mutex_unlock(&queue->session_lock);
286
+
287
+	if (atomic_read(&queue->detach_count)) {
288
+		mpp_dbg_session("queue detach %d again\n",
289
+				atomic_read(&queue->detach_count));
290
+
291
+		kthread_queue_work(&queue->worker, work);
292
+	}
293
+}
294
+
264295 static struct mpp_session *mpp_session_init(void)
265296 {
266297 	struct mpp_session *session = kzalloc(sizeof(*session), GFP_KERNEL);
....@@ -271,13 +302,10 @@
271302 	session->pid = current->pid;
272303 
273304 	mutex_init(&session->pending_lock);
274
-	mutex_init(&session->done_lock);
275305 	INIT_LIST_HEAD(&session->pending_list);
276
-	INIT_LIST_HEAD(&session->done_list);
277306 	INIT_LIST_HEAD(&session->service_link);
278307 	INIT_LIST_HEAD(&session->session_link);
279308 
280
-	init_waitqueue_head(&session->wait);
281309 	atomic_set(&session->task_count, 0);
282310 	atomic_set(&session->release_request, 0);
283311 
....@@ -293,7 +321,7 @@
293321 		if (mpp->dev_ops->free_session)
294322 			mpp->dev_ops->free_session(session);
295323 
296
-		mpp_session_clear(mpp, session);
324
+		mpp_session_clear_pending(session);
297325 
298326 		if (session->dma) {
299327 			mpp_iommu_down_read(mpp->iommu_info);
....@@ -314,14 +342,10 @@
314342 	list_del_init(&session->session_link);
315343 }
316344 
317
-int mpp_session_deinit(struct mpp_session *session)
345
+void mpp_session_deinit(struct mpp_session *session)
318346 {
319
-	u32 task_count = atomic_read(&session->task_count);
320
-
321
-	mpp_dbg_session("session %p:%d task %d release\n",
322
-			session, session->index, task_count);
323
-	if (task_count)
324
-		return -1;
347
+	mpp_dbg_session("session %d:%d task %d deinit\n", session->pid,
348
+			session->index, atomic_read(&session->task_count));
325349 
326350 	if (likely(session->deinit))
327351 		session->deinit(session);
....@@ -331,13 +355,12 @@
331355 	mpp_dbg_session("session %p:%d deinit\n", session, session->index);
332356 
333357 	kfree(session);
334
-	return 0;
335358 }
336359 
337360 static void mpp_session_attach_workqueue(struct mpp_session *session,
338361 					 struct mpp_taskqueue *queue)
339362 {
340
-	mpp_dbg_session("session %p:%d attach\n", session, session->index);
363
+	mpp_dbg_session("session %d:%d attach\n", session->pid, session->index);
341364 	mutex_lock(&queue->session_lock);
342365 	list_add_tail(&session->session_link, &queue->session_attach);
343366 	mutex_unlock(&queue->session_lock);
....@@ -351,14 +374,14 @@
351374 	if (!session->mpp || !session->mpp->queue)
352375 		return;
353376 
354
-	mpp_dbg_session("session %p:%d detach\n", session, session->index);
377
+	mpp_dbg_session("session %d:%d detach\n", session->pid, session->index);
355378 	mpp = session->mpp;
356379 	queue = mpp->queue;
357380 
358381 	mutex_lock(&queue->session_lock);
359382 	list_del_init(&session->session_link);
360383 	list_add_tail(&session->session_link, &queue->session_detach);
361
-	queue->detach_count++;
384
+	atomic_inc(&queue->detach_count);
362385 	mutex_unlock(&queue->session_lock);
363386 
364387 	mpp_taskqueue_trigger_work(mpp);
....@@ -370,6 +393,10 @@
370393 {
371394 	kref_get(&task->ref);
372395 	mutex_lock(&session->pending_lock);
396
+	if (session->srv->timing_en) {
397
+		task->on_pending = ktime_get();
398
+		set_bit(TASK_TIMING_PENDING, &task->state);
399
+	}
373400 	list_add_tail(&task->pending_link, &session->pending_list);
374401 	mutex_unlock(&session->pending_lock);
375402 
....@@ -402,29 +429,6 @@
402429 	return task;
403430 }
404431 
405
-static int mpp_session_push_done(struct mpp_session *session,
406
-				 struct mpp_task *task)
407
-{
408
-	kref_get(&task->ref);
409
-	mutex_lock(&session->done_lock);
410
-	list_add_tail(&task->done_link, &session->done_list);
411
-	mutex_unlock(&session->done_lock);
412
-
413
-	return 0;
414
-}
415
-
416
-static int mpp_session_pop_done(struct mpp_session *session,
417
-				struct mpp_task *task)
418
-{
419
-	mutex_lock(&session->done_lock);
420
-	list_del_init(&task->done_link);
421
-	mutex_unlock(&session->done_lock);
422
-	set_bit(TASK_STATE_DONE, &task->state);
423
-	kref_put(&task->ref, mpp_free_task);
424
-
425
-	return 0;
426
-}
427
-
428432 static void mpp_free_task(struct kref *ref)
429433 {
430434 	struct mpp_dev *mpp;
....@@ -438,9 +442,9 @@
438442 	session = task->session;
439443 
440444 	mpp_debug_func(DEBUG_TASK_INFO,
441
-		       "session=%p, task=%p, state=0x%lx, abort_request=%d\n",
442
-		       session, task, task->state,
443
-		       atomic_read(&task->abort_request));
445
+		       "session %d:%d task %d state 0x%lx abort_request %d\n",
446
+		       session->device_type, session->index, task->task_index,
447
+		       task->state, atomic_read(&task->abort_request));
444448 	if (!session->mpp) {
445449 		mpp_err("session %p, session->mpp is null.\n", session);
446450 		return;
....@@ -469,19 +473,21 @@
469473 		return;
470474 	}
471475 
472
-	mpp_err("task %p processing time out!\n", task);
473476 	if (!task->session) {
474477 		mpp_err("task %p, task->session is null.\n", task);
475478 		return;
476479 	}
480
+
477481 	session = task->session;
478482 
479483 	if (!session->mpp) {
480
-		mpp_err("session %p, session->mpp is null.\n", session);
484
+		mpp_err("session %d:%d, session mpp is null.\n", session->pid,
485
+			session->index);
481486 		return;
482487 	}
483488 	mpp = session->mpp;
484
-
489
+	dev_err(mpp->dev, "session %d:%d task %d state %lx processing time out!\n",
490
+		session->device_type, session->index, task->task_index, task->state);
485491 	synchronize_hardirq(mpp->irq);
486492 
487493 	if (test_and_set_bit(TASK_STATE_HANDLE, &task->state)) {
....@@ -489,18 +495,32 @@
489495 		return;
490496 	}
491497 
498
+	mpp_task_dump_timing(task, ktime_us_delta(ktime_get(), task->on_create));
499
+
500
+	/* disable core irq */
501
+	disable_irq(mpp->irq);
502
+	/* disable mmu irq */
503
+	mpp_iommu_disable_irq(mpp->iommu_info);
504
+
492505 	/* hardware maybe dead, reset it */
493506 	mpp_reset_up_read(mpp->reset_group);
494507 	mpp_dev_reset(mpp);
495508 	mpp_power_off(mpp);
496509 
497
-	mpp_session_push_done(session, task);
510
+	set_bit(TASK_STATE_TIMEOUT, &task->state);
511
+	set_bit(TASK_STATE_DONE, &task->state);
498512 	/* Wake up the GET thread */
499
-	wake_up(&session->wait);
513
+	wake_up(&task->wait);
500514 
501515 	/* remove task from taskqueue running list */
502
-	set_bit(TASK_STATE_TIMEOUT, &task->state);
503516 	mpp_taskqueue_pop_running(mpp->queue, task);
517
+
518
+	/* enable core irq */
519
+	enable_irq(mpp->irq);
520
+	/* enable mmu irq */
521
+	mpp_iommu_enable_irq(mpp->iommu_info);
522
+
523
+	mpp_taskqueue_trigger_work(mpp);
504524 }
505525 
506526 static int mpp_process_task_default(struct mpp_session *session,
....@@ -508,6 +528,8 @@
508528 {
509529 	struct mpp_task *task = NULL;
510530 	struct mpp_dev *mpp = session->mpp;
531
+	u32 timing_en;
532
+	ktime_t on_create;
511533 
512534 	if (unlikely(!mpp)) {
513535 		mpp_err("pid %d clinet %d found invalid process function\n",
....@@ -515,13 +537,26 @@
515537 		return -EINVAL;
516538 	}
517539 
540
+	timing_en = session->srv->timing_en;
541
+	if (timing_en)
542
+		on_create = ktime_get();
543
+
518544 	if (mpp->dev_ops->alloc_task)
519545 		task = mpp->dev_ops->alloc_task(session, msgs);
520546 	if (!task) {
521547 		mpp_err("alloc_task failed.\n");
522548 		return -ENOMEM;
523549 	}
550
+
551
+	if (timing_en) {
552
+		task->on_create_end = ktime_get();
553
+		task->on_create = on_create;
554
+		set_bit(TASK_TIMING_CREATE_END, &task->state);
555
+		set_bit(TASK_TIMING_CREATE, &task->state);
556
+	}
557
+
524558 	kref_init(&task->ref);
559
+	init_waitqueue_head(&task->wait);
525560 	atomic_set(&task->abort_request, 0);
526561 	task->task_index = atomic_fetch_inc(&mpp->task_index);
527562 	INIT_DELAYED_WORK(&task->timeout_work, mpp_task_timeout_work);
....@@ -544,7 +579,10 @@
544579 	/* trigger current queue to run task */
545580 	mpp_taskqueue_trigger_work(mpp);
546581 	kref_put(&task->ref, mpp_free_task);
547
-
582
+	mpp_debug_func(DEBUG_TASK_INFO,
583
+		       "session %d:%d task %d state 0x%lx\n",
584
+		       session->device_type, session->index,
585
+		       task->task_index, task->state);
548586 	return 0;
549587 }
550588 
....@@ -599,10 +637,6 @@
599637 		group->resets[type] = rst;
600638 		group->queue = mpp->queue;
601639 	}
602
-	/* if reset not in the same queue, it means different device
603
-	 * may reset in the same time, then rw_sem_on should set true.
604
-	 */
605
-	group->rw_sem_on |= (group->queue != mpp->queue) ? true : false;
606640 	dev_info(mpp->dev, "reset_group->rw_sem_on=%d\n", group->rw_sem_on);
607641 	up_write(&group->rw_sem);
608642 
....@@ -647,12 +681,49 @@
647681 	return 0;
648682 }
649683 
684
+void mpp_task_run_begin(struct mpp_task *task, u32 timing_en, u32 timeout)
685
+{
686
+	preempt_disable();
687
+
688
+	set_bit(TASK_STATE_START, &task->state);
689
+
690
+	mpp_time_record(task);
691
+	schedule_delayed_work(&task->timeout_work, msecs_to_jiffies(timeout));
692
+
693
+	if (timing_en) {
694
+		task->on_sched_timeout = ktime_get();
695
+		set_bit(TASK_TIMING_TO_SCHED, &task->state);
696
+	}
697
+}
698
+
699
+void mpp_task_run_end(struct mpp_task *task, u32 timing_en)
700
+{
701
+	if (timing_en) {
702
+		task->on_run_end = ktime_get();
703
+		set_bit(TASK_TIMING_RUN_END, &task->state);
704
+	}
705
+
706
+#ifdef MODULE
707
+	preempt_enable();
708
+#else
709
+	preempt_enable_no_resched();
710
+#endif
711
+}
712
+
650713 static int mpp_task_run(struct mpp_dev *mpp,
651714 			struct mpp_task *task)
652715 {
653716 	int ret;
717
+	struct mpp_session *session = task->session;
718
+	u32 timing_en;
654719 
655720 	mpp_debug_enter();
721
+
722
+	timing_en = mpp->srv->timing_en;
723
+	if (timing_en) {
724
+		task->on_run = ktime_get();
725
+		set_bit(TASK_TIMING_RUN, &task->state);
726
+	}
656727 
657728 	/*
658729 	 * before running, we have to switch grf ctrl bit to ensure
....@@ -679,8 +750,10 @@
679750 
680751 	mpp_power_on(mpp);
681752 	mpp_time_record(task);
682
-	mpp_debug(DEBUG_TASK_INFO, "pid %d, start hw %s\n",
683
-		  task->session->pid, dev_name(mpp->dev));
753
+	mpp_debug_func(DEBUG_TASK_INFO,
754
+		       "%s session %d:%d task=%d state=0x%lx\n",
755
+		       dev_name(mpp->dev), session->device_type,
756
+		       session->index, task->task_index, task->state);
684757 
685758 	if (mpp->auto_freq_en && mpp->hw_ops->set_freq)
686759 		mpp->hw_ops->set_freq(mpp, task);
....@@ -690,8 +763,6 @@
690763 	 */
691764 	mpp_reset_down_read(mpp->reset_group);
692765 
693
-	schedule_delayed_work(&task->timeout_work,
694
-			      msecs_to_jiffies(MPP_WORK_TIMEOUT_DELAY));
695766 	if (mpp->dev_ops->run)
696767 		mpp->dev_ops->run(mpp, task);
697768 	set_bit(TASK_STATE_START, &task->state);
....@@ -709,6 +780,7 @@
709780 
710781 	mpp_debug_enter();
711782 
783
+get_task:
712784 	task = mpp_taskqueue_get_pending_task(queue);
713785 	if (!task)
714786 		goto done;
....@@ -716,7 +788,7 @@
716788 	/* if task timeout and aborted, remove it */
717789 	if (atomic_read(&task->abort_request) > 0) {
718790 		mpp_taskqueue_pop_pending(queue, task);
719
-		goto done;
791
+		goto get_task;
720792 	}
721793 
722794 	/* get device for current task */
....@@ -748,28 +820,7 @@
748820 	}
749821 
750822 done:
751
-	mutex_lock(&queue->session_lock);
752
-	while (queue->detach_count) {
753
-		struct mpp_session *session = NULL;
754
-
755
-		session = list_first_entry_or_null(&queue->session_detach, struct mpp_session,
756
-				session_link);
757
-		if (session) {
758
-			list_del_init(&session->session_link);
759
-			queue->detach_count--;
760
-		}
761
-
762
-		mutex_unlock(&queue->session_lock);
763
-
764
-		if (session) {
765
-			mpp_dbg_session("%s detach count %d\n", dev_name(mpp->dev),
766
-					queue->detach_count);
767
-			mpp_session_deinit(session);
768
-		}
769
-
770
-		mutex_lock(&queue->session_lock);
771
-	}
772
-	mutex_unlock(&queue->session_lock);
823
+	mpp_session_cleanup_detach(queue, work_s);
773824 }
774825 
775826 static int mpp_wait_result_default(struct mpp_session *session,
....@@ -785,62 +836,32 @@
785836 		return -EINVAL;
786837 	}
787838 
788
-	ret = wait_event_timeout(session->wait,
789
-				 !list_empty(&session->done_list),
790
-				 msecs_to_jiffies(MPP_WAIT_TIMEOUT_DELAY));
791
-
792839 	task = mpp_session_get_pending_task(session);
793840 	if (!task) {
794
-		mpp_err("session %p pending list is empty!\n", session);
841
+		mpp_err("session %d:%d pending list is empty!\n",
842
+			session->pid, session->index);
795843 		return -EIO;
796844 	}
797845 
846
+	ret = wait_event_timeout(task->wait,
847
+				 test_bit(TASK_STATE_DONE, &task->state),
848
+				 msecs_to_jiffies(MPP_WAIT_TIMEOUT_DELAY));
798849 	if (ret > 0) {
799
-		u32 task_found = 0;
800
-		struct mpp_task *loop = NULL, *n;
801
-
802
-		/* find task in session done list */
803
-		mutex_lock(&session->done_lock);
804
-		list_for_each_entry_safe(loop, n,
805
-					 &session->done_list,
806
-					 done_link) {
807
-			if (loop == task) {
808
-				task_found = 1;
809
-				break;
810
-			}
811
-		}
812
-		mutex_unlock(&session->done_lock);
813
-		if (task_found) {
814
-			if (mpp->dev_ops->result)
815
-				ret = mpp->dev_ops->result(mpp, task, msgs);
816
-			mpp_session_pop_done(session, task);
817
-
818
-			if (test_bit(TASK_STATE_TIMEOUT, &task->state))
819
-				ret = -ETIMEDOUT;
820
-		} else {
821
-			mpp_err("session %p task %p, not found in done list!\n",
822
-				session, task);
823
-			ret = -EIO;
824
-		}
850
+		if (mpp->dev_ops->result)
851
+			ret = mpp->dev_ops->result(mpp, task, msgs);
825852 	} else {
826853 		atomic_inc(&task->abort_request);
827
-		mpp_err("timeout, pid %d session %p:%d count %d cur_task %p index %d.\n",
828
-			session->pid, session, session->index,
829
-			atomic_read(&session->task_count), task,
830
-			task->task_index);
831
-		/* if twice and return timeout, otherwise, re-wait */
832
-		if (atomic_read(&task->abort_request) > 1) {
833
-			mpp_err("session %p:%d, task %p index %d abort wait twice!\n",
834
-				session, session->index,
835
-				task, task->task_index);
836
-			ret = -ETIMEDOUT;
837
-		} else {
838
-			return mpp_wait_result_default(session, msgs);
839
-		}
854
+		set_bit(TASK_STATE_ABORT, &task->state);
855
+		mpp_err("timeout, pid %d session %d:%d count %d cur_task %d state %lx\n",
856
+			session->pid, session->device_type, session->index,
857
+			atomic_read(&session->task_count), task->task_index, task->state);
840858 	}
841859 
842860 	mpp_debug_func(DEBUG_TASK_INFO,
843
-		       "kref_read=%d, ret=%d\n", kref_read(&task->ref), ret);
861
+		       "session %d:%d task %d state 0x%lx kref_read %d ret %d\n",
862
+		       session->device_type,
863
+		       session->index, task->task_index, task->state,
864
+		       kref_read(&task->ref), ret);
844865 	mpp_session_pop_pending(session, task);
845866 
846867 	return ret;
....@@ -919,6 +940,10 @@
919940 			goto err_put_pdev;
920941 		} else {
921942 			mpp->reset_group = mpp->srv->reset_groups[reset_group_node];
943
+			if (!mpp->reset_group->queue)
944
+				mpp->reset_group->queue = queue;
945
+			if (mpp->reset_group->queue != mpp->queue)
946
+				mpp->reset_group->rw_sem_on = true;
922947 		}
923948 	}
924949 
....@@ -951,6 +976,10 @@
951976 
952977 	/* default taskqueue has max 16 task capacity */
953978 	queue->task_capacity = MPP_MAX_TASK_CAPACITY;
979
+
980
+	mutex_init(&queue->ref_lock);
981
+	atomic_set(&queue->runtime_cnt, 0);
982
+	atomic_set(&queue->detach_count, 0);
954983 
955984 	return queue;
956985 }
....@@ -1197,7 +1226,7 @@
11971226 			if (!mpp)
11981227 				return -EINVAL;
11991228 
1200
-			mpp_session_clear(mpp, session);
1229
+			mpp_session_clear_pending(session);
12011230 			mpp_iommu_down_write(mpp->iommu_info);
12021231 			ret = mpp_dma_session_destroy(session->dma);
12031232 			mpp_iommu_up_write(mpp->iommu_info);
....@@ -1410,7 +1439,7 @@
14101439 	/* wait for task all done */
14111440 	atomic_inc(&session->release_request);
14121441 
1413
-	if (session->mpp)
1442
+	if (session->mpp || atomic_read(&session->task_count))
14141443 		mpp_session_detach_workqueue(session);
14151444 	else
14161445 		mpp_session_deinit(session);
....@@ -1421,24 +1450,9 @@
14211450 	return 0;
14221451 }
14231452 
1424
-static unsigned int
1425
-mpp_dev_poll(struct file *filp, poll_table *wait)
1426
-{
1427
-	unsigned int mask = 0;
1428
-	struct mpp_session *session =
1429
-		(struct mpp_session *)filp->private_data;
1430
-
1431
-	poll_wait(filp, &session->wait, wait);
1432
-	if (!list_empty(&session->done_list))
1433
-		mask |= POLLIN | POLLRDNORM;
1434
-
1435
-	return mask;
1436
-}
1437
-
14381453 const struct file_operations rockchip_mpp_fops = {
14391454 	.open		= mpp_dev_open,
14401455 	.release	= mpp_dev_release,
1441
-	.poll		= mpp_dev_poll,
14421456 	.unlocked_ioctl = mpp_dev_ioctl,
14431457 #ifdef CONFIG_COMPAT
14441458 	.compat_ioctl   = mpp_dev_ioctl,
....@@ -1673,12 +1687,23 @@
16731687 		mpp_dev_reset(mpp);
16741688 	mpp_power_off(mpp);
16751689 
1676
-	if (!atomic_read(&task->abort_request)) {
1677
-		mpp_session_push_done(session, task);
1678
-		/* Wake up the GET thread */
1679
-		wake_up(&session->wait);
1680
-	}
16811690 	set_bit(TASK_STATE_FINISH, &task->state);
1691
+	set_bit(TASK_STATE_DONE, &task->state);
1692
+
1693
+	if (session->srv->timing_en) {
1694
+		s64 time_diff;
1695
+
1696
+		task->on_finish = ktime_get();
1697
+		set_bit(TASK_TIMING_FINISH, &task->state);
1698
+
1699
+		time_diff = ktime_us_delta(task->on_finish, task->on_create);
1700
+
1701
+		if (mpp->timing_check && time_diff > (s64)mpp->timing_check)
1702
+			mpp_task_dump_timing(task, time_diff);
1703
+	}
1704
+
1705
+	/* Wake up the GET thread */
1706
+	wake_up(&task->wait);
16821707 	mpp_taskqueue_pop_running(mpp->queue, task);
16831708 
16841709 	return 0;
....@@ -1780,9 +1805,9 @@
17801805 			    unsigned long iova,
17811806 			    int status, void *arg)
17821807 {
1783
-	struct mpp_taskqueue *queue = (struct mpp_taskqueue *)arg;
1808
+	struct mpp_dev *mpp = (struct mpp_dev *)arg;
1809
+	struct mpp_taskqueue *queue = mpp->queue;
17841810 	struct mpp_task *task = mpp_taskqueue_get_running_task(queue);
1785
-	struct mpp_dev *mpp;
17861811 
17871812 	/*
17881813 	 * NOTE: In link mode, this task may not be the task of the current
....@@ -1798,7 +1823,7 @@
17981823 	mpp_task_dump_hw_reg(mpp, task);
17991824 
18001825 	if (mpp->iommu_info->hdl)
1801
-		mpp->iommu_info->hdl(iommu, iommu_dev, iova, status, arg);
1826
+		mpp->iommu_info->hdl(iommu, iommu_dev, iova, status, mpp);
18021827 
18031828 	return 0;
18041829 }
....@@ -1815,6 +1840,8 @@
18151840 
18161841 	/* Get disable auto frequent flag from dtsi */
18171842 	mpp->auto_freq_en = !device_property_read_bool(dev, "rockchip,disable-auto-freq");
1843
+	/* read flag for pum idle request */
1844
+	mpp->skip_idle = device_property_read_bool(dev, "rockchip,skip-pmu-idle-request");
18181845 
18191846 	/* Get and attach to service */
18201847 	ret = mpp_attach_service(mpp, dev);
....@@ -1897,7 +1924,7 @@
18971924 	/* set iommu fault handler */
18981925 	if (!IS_ERR(mpp->iommu_info))
18991926 		iommu_set_fault_handler(mpp->iommu_info->domain,
1900
-					mpp_iommu_handle, mpp->queue);
1927
+					mpp_iommu_handle, mpp);
19011928 
19021929 	/* read hardware id */
19031930 	if (hw_info->reg_id >= 0) {
....@@ -1951,6 +1978,12 @@
19511978 	struct mpp_dev *mpp = param;
19521979 	struct mpp_task *task = mpp->cur_task;
19531980 	irqreturn_t irq_ret = IRQ_NONE;
1981
+	u32 timing_en = mpp->srv->timing_en;
1982
+
1983
+	if (task && timing_en) {
1984
+		task->on_irq = ktime_get();
1985
+		set_bit(TASK_TIMING_IRQ, &task->state);
1986
+	}
19541987 
19551988 	if (mpp->dev_ops->irq)
19561989 		irq_ret = mpp->dev_ops->irq(mpp);
....@@ -1965,6 +1998,10 @@
19651998 					mpp->irq_status);
19661999 				irq_ret = IRQ_HANDLED;
19672000 				goto done;
2001
+			}
2002
+			if (timing_en) {
2003
+				task->on_cancel_timeout = ktime_get();
2004
+				set_bit(TASK_TIMING_TO_CANCEL, &task->state);
19682005 			}
19692006 			cancel_delayed_work(&task->timeout_work);
19702007 			/* normal condition, set state and wake up isr thread */
....@@ -1981,6 +2018,12 @@
19812018 {
19822019 	irqreturn_t ret = IRQ_NONE;
19832020 	struct mpp_dev *mpp = param;
2021
+	struct mpp_task *task = mpp->cur_task;
2022
+
2023
+	if (task && mpp->srv->timing_en) {
2024
+		task->on_isr = ktime_get();
2025
+		set_bit(TASK_TIMING_ISR, &task->state);
2026
+	}
19842027 
19852028 	if (mpp->auto_freq_en &&
19862029 	    mpp->hw_ops->reduce_freq &&
....@@ -2030,24 +2073,88 @@
20302073 
20312074 int mpp_time_record(struct mpp_task *task)
20322075 {
2033
-	if (mpp_debug_unlikely(DEBUG_TIMING) && task)
2034
-		do_gettimeofday(&task->start);
2076
+	if (mpp_debug_unlikely(DEBUG_TIMING) && task) {
2077
+		task->start = ktime_get();
2078
+		task->part = task->start;
2079
+	}
2080
+
2081
+	return 0;
2082
+}
2083
+
2084
+int mpp_time_part_diff(struct mpp_task *task)
2085
+{
2086
+	ktime_t end;
2087
+	struct mpp_dev *mpp = task->session->mpp;
2088
+
2089
+	end = ktime_get();
2090
+	mpp_debug(DEBUG_PART_TIMING, "%s: session %d:%d part time: %lld us\n",
2091
+		  dev_name(mpp->dev), task->session->pid, task->session->index,
2092
+		  ktime_us_delta(end, task->part));
2093
+	task->part = end;
20352094 
20362095 	return 0;
20372096 }
20382097 
20392098 int mpp_time_diff(struct mpp_task *task)
20402099 {
2041
-	struct timeval end;
2100
+	ktime_t end;
20422101 	struct mpp_dev *mpp = task->session->mpp;
20432102 
2044
-	do_gettimeofday(&end);
2045
-	mpp_debug(DEBUG_TIMING, "%s: pid: %d, session: %p, time: %ld us\n",
2046
-		  dev_name(mpp->dev), task->session->pid, task->session,
2047
-		  (end.tv_sec  - task->start.tv_sec)  * 1000000 +
2048
-		  (end.tv_usec - task->start.tv_usec));
2103
+	end = ktime_get();
2104
+	mpp_debug(DEBUG_TIMING, "%s: session %d:%d task time: %lld us\n",
2105
+		  dev_name(mpp->dev), task->session->pid, task->session->index,
2106
+		  ktime_us_delta(end, task->start));
20492107 
20502108 	return 0;
2109
+}
2110
+
2111
+int mpp_time_diff_with_hw_time(struct mpp_task *task, u32 clk_hz)
2112
+{
2113
+	if (mpp_debug_unlikely(DEBUG_TIMING)) {
2114
+		ktime_t end;
2115
+		struct mpp_dev *mpp = task->session->mpp;
2116
+
2117
+		end = ktime_get();
2118
+
2119
+		if (clk_hz)
2120
+			mpp_debug(DEBUG_TIMING, "%s: session %d time: %lld us hw %d us\n",
2121
+				dev_name(mpp->dev), task->session->index,
2122
+				ktime_us_delta(end, task->start),
2123
+				task->hw_cycles / (clk_hz / 1000000));
2124
+		else
2125
+			mpp_debug(DEBUG_TIMING, "%s: session %d time: %lld us\n",
2126
+				  dev_name(mpp->dev), task->session->index,
2127
+				  ktime_us_delta(end, task->start));
2128
+	}
2129
+
2130
+	return 0;
2131
+}
2132
+
2133
+#define LOG_TIMING(state, id, stage, time, base) \
2134
+	do { \
2135
+		if (test_bit(id, &state)) \
2136
+			pr_info("timing: %-14s : %lld us\n", stage, ktime_us_delta(time, base)); \
2137
+		else \
2138
+			pr_info("timing: %-14s : invalid\n", stage); \
2139
+	} while (0)
2140
+
2141
+void mpp_task_dump_timing(struct mpp_task *task, s64 time_diff)
2142
+{
2143
+	ktime_t s = task->on_create;
2144
+	unsigned long state = task->state;
2145
+
2146
+	pr_info("task %d dump timing at %lld us:", task->task_index, time_diff);
2147
+
2148
+	pr_info("timing: %-14s : %lld us\n", "create", ktime_to_us(s));
2149
+	LOG_TIMING(state, TASK_TIMING_CREATE_END, "create end",     task->on_create_end, s);
2150
+	LOG_TIMING(state, TASK_TIMING_PENDING,    "pending",        task->on_pending, s);
2151
+	LOG_TIMING(state, TASK_TIMING_RUN,        "run",            task->on_run, s);
2152
+	LOG_TIMING(state, TASK_TIMING_TO_SCHED,   "timeout start",  task->on_sched_timeout, s);
2153
+	LOG_TIMING(state, TASK_TIMING_RUN_END,    "run end",        task->on_run_end, s);
2154
+	LOG_TIMING(state, TASK_TIMING_IRQ,        "irq",            task->on_irq, s);
2155
+	LOG_TIMING(state, TASK_TIMING_TO_CANCEL,  "timeout cancel", task->on_cancel_timeout, s);
2156
+	LOG_TIMING(state, TASK_TIMING_ISR,        "isr",            task->on_isr, s);
2157
+	LOG_TIMING(state, TASK_TIMING_FINISH,     "finish",         task->on_finish, s);
20512158 }
20522159 
20532160 int mpp_write_req(struct mpp_dev *mpp, u32 *regs,
....@@ -2184,6 +2291,7 @@
21842291 	if (clk_rate_hz) {
21852292 		clk_info->used_rate_hz = clk_rate_hz;
21862293 		clk_set_rate(clk_info->clk, clk_rate_hz);
2294
+		clk_info->real_rate_hz = clk_get_rate(clk_info->clk);
21872295 	}
21882296 
21892297 	return 0;
....@@ -2230,4 +2338,9 @@
22302338 {
22312339 	return proc_create_data(name, mode, parent, &procfs_fops_u32, data);
22322340 }
2341
+
2342
+void mpp_procfs_create_common(struct proc_dir_entry *parent, struct mpp_dev *mpp)
2343
+{
2344
+	mpp_procfs_create_u32("timing_check", 0644, parent, &mpp->timing_check);
2345
+}
22332346 #endif