forked from ~ljy/RK356X_SDK_RELEASE

blame | history | patch | commit | commitdiff
hc
2023-12-11 d2ccde1c8e90d38cee87a1b0309ad2827f3fd30d 
 kernel/drivers/media/platform/rockchip/ispp/stream.c
....@@ -13,7 +13,8 @@
1313 #include <media/v4l2-subdev.h>
1414 #include <media/videobuf2-dma-contig.h>
1515 #include <media/videobuf2-dma-sg.h>
16
-#include <linux/rkisp1-config.h>
16
+#include <linux/rk-isp1-config.h>
17
+#include <uapi/linux/rk-video-format.h>
1718 
1819 #include "dev.h"
1920 #include "regs.h"
....@@ -23,13 +24,6 @@
2324 
2425 /* memory align for mpp */
2526 #define RK_MPP_ALIGN 4096
26
-
27
-/*
28
- * DDR->|                                 |->MB------->DDR
29
- *      |->TNR->DDR->NR->SHARP->DDR->FEC->|->SCL0----->DDR
30
- * ISP->|                                 |->SCL1----->DDR
31
- *                                        |->SCL2----->DDR
32
- */
3327 
3428 static const struct capture_fmt input_fmts[] = {
3529 	{
....@@ -188,16 +182,6 @@
188182 	},
189183 };
190184 
191
-static void set_y_addr(struct rkispp_stream *stream, u32 val)
192
-{
193
-	rkispp_write(stream->isppdev, stream->config->reg.cur_y_base, val);
194
-}
195
-
196
-static void set_uv_addr(struct rkispp_stream *stream, u32 val)
197
-{
198
-	rkispp_write(stream->isppdev, stream->config->reg.cur_uv_base, val);
199
-}
200
-
201185 static void set_vir_stride(struct rkispp_stream *stream, u32 val)
202186 {
203187 	rkispp_write(stream->isppdev, stream->config->reg.cur_vir_stride, val);
....@@ -329,81 +313,16 @@
329313 		 "%s exit\n", __func__);
330314 }
331315 
332
-static void check_to_force_update(struct rkispp_device *dev, u32 mis_val)
333
-{
334
-	struct rkispp_stream_vdev *vdev = &dev->stream_vdev;
335
-	struct rkispp_stream *stream;
336
-	u32 i, mask = NR_INT | SHP_INT;
337
-	bool is_fec_en = (vdev->module_ens & ISPP_MODULE_FEC);
338
-
339
-	if (mis_val & TNR_INT)
340
-		rkispp_module_work_event(dev, NULL, NULL,
341
-					 ISPP_MODULE_TNR, true);
342
-	if (mis_val & FEC_INT)
343
-		rkispp_module_work_event(dev, NULL, NULL,
344
-					 ISPP_MODULE_FEC, true);
345
-
346
-	/* wait nr_shp/fec/scl idle */
347
-	for (i = STREAM_S0; i <= STREAM_S2; i++) {
348
-		stream = &vdev->stream[i];
349
-		if (stream->is_upd && !is_fec_en &&
350
-		    rkispp_read(dev, stream->config->reg.ctrl) & SW_SCL_ENABLE)
351
-			mask |= stream->config->frame_end_id;
352
-	}
353
-
354
-	vdev->irq_ends |= (mis_val & mask);
355
-	v4l2_dbg(3, rkispp_debug, &dev->v4l2_dev,
356
-		 "irq_ends:0x%x mask:0x%x\n",
357
-		 vdev->irq_ends, mask);
358
-	if (vdev->irq_ends != mask)
359
-		return;
360
-	vdev->irq_ends = 0;
361
-	rkispp_module_work_event(dev, NULL, NULL,
362
-				 ISPP_MODULE_NR, true);
363
-
364
-	for (i = STREAM_MB; i <= STREAM_S2; i++) {
365
-		stream = &vdev->stream[i];
366
-		if (stream->streaming)
367
-			stream->is_upd = true;
368
-	}
369
-}
370
-
371316 static void irq_work(struct work_struct *work)
372317 {
373318 	struct rkispp_device *dev = container_of(work, struct rkispp_device, irq_work);
374319 
375320 	rkispp_set_clk_rate(dev->hw_dev->clks[0], dev->hw_dev->core_clk_max);
376
-	check_to_force_update(dev, dev->mis_val);
321
+	dev->stream_vdev.stream_ops->check_to_force_update(dev, dev->mis_val);
377322 	dev->hw_dev->is_first = false;
378323 }
379324 
380
-static void update_mi(struct rkispp_stream *stream)
381
-{
382
-	struct rkispp_device *dev = stream->isppdev;
383
-	struct rkispp_dummy_buffer *dummy_buf;
384
-	u32 val;
385
-
386
-	if (stream->curr_buf) {
387
-		val = stream->curr_buf->buff_addr[RKISPP_PLANE_Y];
388
-		set_y_addr(stream, val);
389
-		val = stream->curr_buf->buff_addr[RKISPP_PLANE_UV];
390
-		set_uv_addr(stream, val);
391
-	}
392
-
393
-	if (stream->type == STREAM_OUTPUT && !stream->curr_buf) {
394
-		dummy_buf = &dev->hw_dev->dummy_buf;
395
-		set_y_addr(stream, dummy_buf->dma_addr);
396
-		set_uv_addr(stream, dummy_buf->dma_addr);
397
-	}
398
-
399
-	v4l2_dbg(2, rkispp_debug, &stream->isppdev->v4l2_dev,
400
-		 "%s stream:%d Y:0x%x UV:0x%x\n",
401
-		 __func__, stream->id,
402
-		 rkispp_read(dev, stream->config->reg.cur_y_base),
403
-		 rkispp_read(dev, stream->config->reg.cur_uv_base));
404
-}
405
-
406
-static void get_stream_buf(struct rkispp_stream *stream)
325
+void get_stream_buf(struct rkispp_stream *stream)
407326 {
408327 	unsigned long lock_flags = 0;
409328 
....@@ -417,9 +336,10 @@
417336 	spin_unlock_irqrestore(&stream->vbq_lock, lock_flags);
418337 }
419338 
420
-static int rkispp_frame_end(struct rkispp_stream *stream, u32 state)
339
+int rkispp_frame_end(struct rkispp_stream *stream, u32 state)
421340 {
422341 	struct rkispp_device *dev = stream->isppdev;
342
+	struct rkispp_stream_vdev *vdev = &dev->stream_vdev;
423343 	struct capture_fmt *fmt = &stream->out_cap_fmt;
424344 	struct rkisp_ispp_reg *reg_buf = NULL;
425345 	unsigned long lock_flags = 0;
....@@ -513,90 +433,11 @@
513433 	}
514434 
515435 	get_stream_buf(stream);
516
-	update_mi(stream);
436
+	vdev->stream_ops->update_mi(stream);
517437 	return 0;
518438 }
519439 
520
-static bool is_en_done_early(struct rkispp_device *dev)
521
-{
522
-	u32 height = dev->ispp_sdev.out_fmt.height;
523
-	u32 line = dev->stream_vdev.wait_line;
524
-	bool en =  false;
525
-
526
-	if (line) {
527
-		if (line > height - 128)
528
-			dev->stream_vdev.wait_line = height - 128;
529
-		en = true;
530
-		v4l2_dbg(1, rkispp_debug, &dev->v4l2_dev,
531
-			 "wait %d line to wake up frame\n", line);
532
-	}
533
-
534
-	return en;
535
-}
536
-
537
-static enum hrtimer_restart rkispp_frame_done_early(struct hrtimer *timer)
538
-{
539
-	struct rkispp_stream_vdev *vdev =
540
-		container_of(timer, struct rkispp_stream_vdev, frame_qst);
541
-	struct rkispp_stream *stream = &vdev->stream[0];
542
-	struct rkispp_device *dev = stream->isppdev;
543
-	void __iomem *base = dev->hw_dev->base_addr;
544
-	bool is_fec_en = (vdev->module_ens & ISPP_MODULE_FEC);
545
-	enum hrtimer_restart ret = HRTIMER_NORESTART;
546
-	u32 threshold = vdev->wait_line / 128;
547
-	u32 tile, tile_mask, working, work_mask;
548
-	u32 i, seq, ycnt, shift, time, max_time;
549
-	u64 t, ns = ktime_get_ns();
550
-
551
-	working = readl(base + RKISPP_CTRL_SYS_STATUS);
552
-	tile = readl(base + RKISPP_CTRL_SYS_CTL_STA0);
553
-	if (is_fec_en) {
554
-		shift = 16;
555
-		work_mask = FEC_WORKING;
556
-		tile_mask = FEC_TILE_LINE_CNT_MASK;
557
-		t = vdev->fec.dbg.timestamp;
558
-		seq = vdev->fec.dbg.id;
559
-		max_time = 6000000;
560
-	} else {
561
-		shift = 8;
562
-		work_mask = NR_WORKING;
563
-		tile_mask = NR_TILE_LINE_CNT_MASK;
564
-		t = vdev->nr.dbg.timestamp;
565
-		seq = vdev->nr.dbg.id;
566
-		max_time = 2000000;
567
-	}
568
-	working &= work_mask;
569
-	tile &= tile_mask;
570
-	ycnt = tile >> shift;
571
-	time = (u32)(ns - t);
572
-	if (dev->ispp_sdev.state == ISPP_STOP) {
573
-		vdev->is_done_early = false;
574
-		goto end;
575
-	} else if (working && ycnt < threshold) {
576
-		if (!ycnt)
577
-			ns = max_time;
578
-		else
579
-			ns = time * (threshold - ycnt) / ycnt + 100 * 1000;
580
-		if (ns > max_time)
581
-			ns = max_time;
582
-		hrtimer_forward(timer, timer->base->get_time(), ns_to_ktime(ns));
583
-		ret = HRTIMER_RESTART;
584
-	} else {
585
-		v4l2_dbg(3, rkispp_debug, &stream->isppdev->v4l2_dev,
586
-			 "%s seq:%d line:%d ycnt:%d time:%dus\n",
587
-			 __func__, seq, vdev->wait_line, ycnt * 128, time / 1000);
588
-		for (i = 0; i < STREAM_MAX; i++) {
589
-			stream = &vdev->stream[i];
590
-			if (!stream->streaming || !stream->is_cfg || stream->stopping)
591
-				continue;
592
-			rkispp_frame_end(stream, FRAME_WORK);
593
-		}
594
-	}
595
-end:
596
-	return ret;
597
-}
598
-
599
-static void *get_pool_buf(struct rkispp_device *dev,
440
+void *get_pool_buf(struct rkispp_device *dev,
600441 			  struct rkisp_ispp_buf *dbufs)
601442 {
602443 	int i;
....@@ -608,7 +449,7 @@
608449 	return NULL;
609450 }
610451 
611
-static void *dbuf_to_dummy(struct dma_buf *dbuf,
452
+void *dbuf_to_dummy(struct dma_buf *dbuf,
612453 			   struct rkispp_dummy_buffer *pool,
613454 			   int num)
614455 {
....@@ -623,7 +464,7 @@
623464 	return NULL;
624465 }
625466 
626
-static void *get_list_buf(struct list_head *list, bool is_isp_ispp)
467
+void *get_list_buf(struct list_head *list, bool is_isp_ispp)
627468 {
628469 	void *buf = NULL;
629470 
....@@ -641,540 +482,22 @@
641482 	return buf;
642483 }
643484 
644
-static void tnr_free_buf(struct rkispp_device *dev)
485
+void rkispp_start_3a_run(struct rkispp_device *dev)
645486 {
646
-	struct rkispp_stream_vdev *vdev = &dev->stream_vdev;
647
-	struct rkisp_ispp_buf *dbufs;
648
-	struct list_head *list;
649
-	int i;
650
-
651
-	list = &vdev->tnr.list_rd;
652
-	if (vdev->tnr.cur_rd) {
653
-		list_add_tail(&vdev->tnr.cur_rd->list, list);
654
-		if (vdev->tnr.nxt_rd == vdev->tnr.cur_rd)
655
-			vdev->tnr.nxt_rd = NULL;
656
-		vdev->tnr.cur_rd = NULL;
657
-	}
658
-	if (vdev->tnr.nxt_rd) {
659
-		list_add_tail(&vdev->tnr.nxt_rd->list, list);
660
-		vdev->tnr.nxt_rd = NULL;
661
-	}
662
-	while (!list_empty(list)) {
663
-		dbufs = get_list_buf(list, true);
664
-		v4l2_subdev_call(dev->ispp_sdev.remote_sd,
665
-				 video, s_rx_buffer, dbufs, NULL);
666
-	}
667
-
668
-	list = &vdev->tnr.list_wr;
669
-	if (vdev->tnr.cur_wr) {
670
-		list_add_tail(&vdev->tnr.cur_wr->list, list);
671
-		vdev->tnr.cur_wr = NULL;
672
-	}
673
-	while (!list_empty(list)) {
674
-		dbufs = get_list_buf(list, true);
675
-		kfree(dbufs);
676
-	}
677
-	list = &vdev->tnr.list_rpt;
678
-	while (!list_empty(list)) {
679
-		dbufs = get_list_buf(list, true);
680
-		kfree(dbufs);
681
-	}
682
-
683
-	for (i = 0; i < sizeof(vdev->tnr.buf) /
684
-	     sizeof(struct rkispp_dummy_buffer); i++)
685
-		rkispp_free_buffer(dev, &vdev->tnr.buf.iir + i);
686
-
687
-	vdev->tnr.is_buf_init = false;
688
-	vdev->tnr.is_trigger = false;
689
-}
690
-
691
-static int tnr_init_buf(struct rkispp_device *dev,
692
-			u32 pic_size, u32 gain_size)
693
-{
694
-	struct rkispp_stream_vdev *vdev = &dev->stream_vdev;
695
-	struct rkisp_ispp_buf *dbufs;
696
-	struct rkispp_dummy_buffer *buf;
697
-	int i, j, ret, cnt = RKISPP_BUF_MAX;
698
-	u32 buf_idx = 0;
699
-
700
-	if (dev->inp == INP_ISP && dev->isp_mode & ISP_ISPP_QUICK)
701
-		cnt = 1;
702
-	for (i = 0; i < cnt; i++) {
703
-		dbufs = kzalloc(sizeof(*dbufs), GFP_KERNEL);
704
-		if (!dbufs) {
705
-			ret = -ENOMEM;
706
-			goto err;
707
-		}
708
-		dbufs->is_isp = false;
709
-		for (j = 0; j < GROUP_BUF_MAX; j++) {
710
-			buf = &vdev->tnr.buf.wr[i][j];
711
-			buf->is_need_dbuf = true;
712
-			buf->is_need_dmafd = false;
713
-			buf->is_need_vaddr = true;
714
-			buf->size = !j ? pic_size : PAGE_ALIGN(gain_size);
715
-			buf->index = buf_idx++;
716
-			ret = rkispp_allow_buffer(dev, buf);
717
-			if (ret) {
718
-				kfree(dbufs);
719
-				goto err;
720
-			}
721
-			dbufs->dbuf[j] = buf->dbuf;
722
-			dbufs->didx[j] = buf->index;
723
-		}
724
-		list_add_tail(&dbufs->list, &vdev->tnr.list_wr);
725
-	}
726
-
727
-	if (dev->inp == INP_ISP && dev->isp_mode & ISP_ISPP_QUICK) {
728
-		buf = &vdev->tnr.buf.iir;
729
-		buf->size = pic_size;
730
-		ret = rkispp_allow_buffer(dev, buf);
731
-		if (ret < 0)
732
-			goto err;
733
-	}
734
-
735
-	buf = &vdev->tnr.buf.gain_kg;
736
-	buf->is_need_vaddr = true;
737
-	buf->is_need_dbuf = true;
738
-	buf->is_need_dmafd = false;
739
-	buf->size = PAGE_ALIGN(gain_size * 4);
740
-	buf->index = buf_idx++;
741
-	ret = rkispp_allow_buffer(dev, buf);
742
-	if (ret < 0)
743
-		goto err;
744
-
745
-	vdev->tnr.is_buf_init = true;
746
-	return 0;
747
-err:
748
-	tnr_free_buf(dev);
749
-	v4l2_err(&dev->v4l2_dev, "%s failed\n", __func__);
750
-	return ret;
751
-}
752
-
753
-static int config_tnr(struct rkispp_device *dev)
754
-{
755
-	struct rkispp_hw_dev *hw = dev->hw_dev;
756
-	struct rkispp_stream_vdev *vdev;
757
-	struct rkispp_stream *stream = NULL;
758
-	int ret, mult = 1;
759
-	u32 width, height, fmt;
760
-	u32 pic_size, gain_size;
761
-	u32 addr_offs, w, h, val;
762
-	u32 max_w, max_h;
763
-
764
-	vdev = &dev->stream_vdev;
765
-	vdev->tnr.is_end = true;
766
-	vdev->tnr.is_3to1 =
767
-		((vdev->module_ens & ISPP_MODULE_TNR_3TO1) ==
768
-		 ISPP_MODULE_TNR_3TO1);
769
-	if (!(vdev->module_ens & ISPP_MODULE_TNR))
770
-		return 0;
771
-
772
-	if (dev->inp == INP_DDR) {
773
-		vdev->tnr.is_3to1 = false;
774
-		stream = &vdev->stream[STREAM_II];
775
-		fmt = stream->out_cap_fmt.wr_fmt;
776
-	} else {
777
-		fmt = dev->isp_mode & (FMT_YUV422 | FMT_FBC);
778
-	}
779
-
780
-	width = dev->ispp_sdev.in_fmt.width;
781
-	height = dev->ispp_sdev.in_fmt.height;
782
-	max_w = hw->max_in.w ? hw->max_in.w : width;
783
-	max_h = hw->max_in.h ? hw->max_in.h : height;
784
-	w = (fmt & FMT_FBC) ? ALIGN(max_w, 16) : max_w;
785
-	h = (fmt & FMT_FBC) ? ALIGN(max_h, 16) : max_h;
786
-	addr_offs = (fmt & FMT_FBC) ? w * h >> 4 : w * h;
787
-	pic_size = (fmt & FMT_YUV422) ? w * h * 2 : w * h * 3 >> 1;
788
-	vdev->tnr.uv_offset = addr_offs;
789
-	if (fmt & FMT_FBC)
790
-		pic_size += w * h >> 4;
791
-
792
-	gain_size = ALIGN(width, 64) * ALIGN(height, 128) >> 4;
793
-	if (fmt & FMT_YUYV)
794
-		mult = 2;
795
-
796
-	if (vdev->module_ens & (ISPP_MODULE_NR | ISPP_MODULE_SHP)) {
797
-		ret = tnr_init_buf(dev, pic_size, gain_size);
798
-		if (ret)
799
-			return ret;
800
-		if (dev->inp == INP_ISP &&
801
-		    dev->isp_mode & ISP_ISPP_QUICK) {
802
-			rkispp_set_bits(dev, RKISPP_CTRL_QUICK,
803
-					GLB_QUICK_MODE_MASK,
804
-					GLB_QUICK_MODE(0));
805
-
806
-			val = hw->pool[0].dma[GROUP_BUF_PIC];
807
-			rkispp_write(dev, RKISPP_TNR_CUR_Y_BASE, val);
808
-			rkispp_write(dev, RKISPP_TNR_CUR_UV_BASE, val + addr_offs);
809
-
810
-			val = hw->pool[0].dma[GROUP_BUF_GAIN];
811
-			rkispp_write(dev, RKISPP_TNR_GAIN_CUR_Y_BASE, val);
812
-
813
-			if (vdev->tnr.is_3to1) {
814
-				val = hw->pool[1].dma[GROUP_BUF_PIC];
815
-				rkispp_write(dev, RKISPP_TNR_NXT_Y_BASE, val);
816
-				rkispp_write(dev, RKISPP_TNR_NXT_UV_BASE, val + addr_offs);
817
-				val = hw->pool[1].dma[GROUP_BUF_GAIN];
818
-				rkispp_write(dev, RKISPP_TNR_GAIN_NXT_Y_BASE, val);
819
-			}
820
-		}
821
-
822
-		val = vdev->tnr.buf.gain_kg.dma_addr;
823
-		rkispp_write(dev, RKISPP_TNR_GAIN_KG_Y_BASE, val);
824
-
825
-		val = vdev->tnr.buf.wr[0][GROUP_BUF_PIC].dma_addr;
826
-		rkispp_write(dev, RKISPP_TNR_WR_Y_BASE, val);
827
-		rkispp_write(dev, RKISPP_TNR_WR_UV_BASE, val + addr_offs);
828
-		if (vdev->tnr.buf.iir.mem_priv)
829
-			val = vdev->tnr.buf.iir.dma_addr;
830
-		rkispp_write(dev, RKISPP_TNR_IIR_Y_BASE, val);
831
-		rkispp_write(dev, RKISPP_TNR_IIR_UV_BASE, val + addr_offs);
832
-
833
-		val = vdev->tnr.buf.wr[0][GROUP_BUF_GAIN].dma_addr;
834
-		rkispp_write(dev, RKISPP_TNR_GAIN_WR_Y_BASE, val);
835
-
836
-		rkispp_write(dev, RKISPP_TNR_WR_VIR_STRIDE, ALIGN(width * mult, 16) >> 2);
837
-		rkispp_set_bits(dev, RKISPP_TNR_CTRL, FMT_WR_MASK, fmt << 4 | SW_TNR_1ST_FRM);
838
-	}
839
-
840
-	if (stream) {
841
-		stream->config->frame_end_id = TNR_INT;
842
-		stream->config->reg.cur_y_base = RKISPP_TNR_CUR_Y_BASE;
843
-		stream->config->reg.cur_uv_base = RKISPP_TNR_CUR_UV_BASE;
844
-		stream->config->reg.cur_y_base_shd = RKISPP_TNR_CUR_Y_BASE_SHD;
845
-		stream->config->reg.cur_uv_base_shd = RKISPP_TNR_CUR_UV_BASE_SHD;
846
-	}
847
-
848
-	rkispp_set_bits(dev, RKISPP_TNR_CTRL, FMT_RD_MASK, fmt);
849
-	if (fmt & FMT_FBC) {
850
-		rkispp_write(dev, RKISPP_TNR_CUR_VIR_STRIDE, 0);
851
-		rkispp_write(dev, RKISPP_TNR_IIR_VIR_STRIDE, 0);
852
-		rkispp_write(dev, RKISPP_TNR_NXT_VIR_STRIDE, 0);
853
-	} else {
854
-		rkispp_write(dev, RKISPP_TNR_CUR_VIR_STRIDE, ALIGN(width * mult, 16) >> 2);
855
-		rkispp_write(dev, RKISPP_TNR_IIR_VIR_STRIDE, ALIGN(width * mult, 16) >> 2);
856
-		rkispp_write(dev, RKISPP_TNR_NXT_VIR_STRIDE, ALIGN(width * mult, 16) >> 2);
857
-	}
858
-	rkispp_set_bits(dev, RKISPP_TNR_CORE_CTRL, SW_TNR_MODE,
859
-			vdev->tnr.is_3to1 ? SW_TNR_MODE : 0);
860
-	rkispp_write(dev, RKISPP_TNR_GAIN_CUR_VIR_STRIDE, ALIGN(width, 64) >> 4);
861
-	rkispp_write(dev, RKISPP_TNR_GAIN_NXT_VIR_STRIDE, ALIGN(width, 64) >> 4);
862
-	rkispp_write(dev, RKISPP_TNR_GAIN_KG_VIR_STRIDE, ALIGN(width, 16) * 6);
863
-	rkispp_write(dev, RKISPP_TNR_GAIN_WR_VIR_STRIDE, ALIGN(width, 64) >> 4);
864
-	rkispp_write(dev, RKISPP_CTRL_TNR_SIZE, height << 16 | width);
865
-
866
-	if (vdev->monitor.is_en) {
867
-		init_completion(&vdev->monitor.tnr.cmpl);
868
-		schedule_work(&vdev->monitor.tnr.work);
869
-	}
870
-	v4l2_dbg(1, rkispp_debug, &dev->v4l2_dev,
871
-		 "%s size:%dx%d ctrl:0x%x core_ctrl:0x%x\n",
872
-		 __func__, width, height,
873
-		 rkispp_read(dev, RKISPP_TNR_CTRL),
874
-		 rkispp_read(dev, RKISPP_TNR_CORE_CTRL));
875
-	return 0;
876
-}
877
-
878
-static void nr_free_buf(struct rkispp_device *dev)
879
-{
880
-	struct rkispp_stream_vdev *vdev = &dev->stream_vdev;
881
-	struct rkisp_ispp_buf *dbufs;
882
-	struct list_head *list;
883
-	int i;
884
-
885
-	list = &vdev->nr.list_rd;
886
-	if (vdev->nr.cur_rd) {
887
-		list_add_tail(&vdev->nr.cur_rd->list, list);
888
-		vdev->nr.cur_rd = NULL;
889
-	}
890
-	while (!list_empty(list)) {
891
-		dbufs = get_list_buf(list, true);
892
-		if (dbufs->is_isp)
893
-			v4l2_subdev_call(dev->ispp_sdev.remote_sd,
894
-					 video, s_rx_buffer, dbufs, NULL);
895
-		else
896
-			kfree(dbufs);
897
-	}
898
-
899
-	list = &vdev->nr.list_wr;
900
-	if (vdev->nr.cur_wr)
901
-		vdev->nr.cur_wr = NULL;
902
-	while (!list_empty(list))
903
-		get_list_buf(list, false);
904
-	list = &vdev->nr.list_rpt;
905
-	while (!list_empty(list))
906
-		get_list_buf(list, false);
907
-
908
-	for (i = 0; i < sizeof(vdev->nr.buf) /
909
-	     sizeof(struct rkispp_dummy_buffer); i++)
910
-		rkispp_free_buffer(dev, &vdev->nr.buf.tmp_yuv + i);
911
-
912
-	vdev->nr.is_buf_init = false;
913
-}
914
-
915
-static int nr_init_buf(struct rkispp_device *dev, u32 size)
916
-{
917
-	struct rkispp_stream_vdev *vdev = &dev->stream_vdev;
918
-	struct rkispp_dummy_buffer *buf;
919
-	int i, ret, cnt;
920
-
921
-	switch (vdev->module_ens & ISPP_MODULE_FEC_ST) {
922
-	case ISPP_MODULE_FEC_ST:
923
-		cnt = RKISPP_FEC_BUF_MAX;
924
-		break;
925
-	case ISPP_MODULE_FEC:
926
-		cnt = RKISPP_BUF_MAX;
927
-		break;
928
-	default:
929
-		cnt = 0;
930
-	}
931
-
932
-	for (i = 0; i < cnt; i++) {
933
-		buf = &vdev->nr.buf.wr[i];
934
-		buf->size = size;
935
-		buf->index = i;
936
-		buf->is_need_dbuf = true;
937
-		buf->is_need_vaddr = true;
938
-		buf->is_need_dmafd = false;
939
-		ret = rkispp_allow_buffer(dev, buf);
940
-		if (ret)
941
-			goto err;
942
-		list_add_tail(&buf->list, &vdev->nr.list_wr);
943
-	}
944
-
945
-	buf = &vdev->nr.buf.tmp_yuv;
946
-	cnt = DIV_ROUND_UP(dev->ispp_sdev.in_fmt.width, 32);
947
-	buf->size = PAGE_ALIGN(cnt * 42 * 32);
948
-	ret = rkispp_allow_buffer(dev, buf);
949
-	if (ret)
950
-		goto err;
951
-
952
-	vdev->nr.is_buf_init = true;
953
-	return 0;
954
-err:
955
-	nr_free_buf(dev);
956
-	v4l2_err(&dev->v4l2_dev, "%s failed\n", __func__);
957
-	return ret;
958
-}
959
-
960
-static int config_nr_shp(struct rkispp_device *dev)
961
-{
962
-	struct rkispp_hw_dev *hw = dev->hw_dev;
963
-	struct rkispp_stream_vdev *vdev;
964
-	struct rkispp_stream *stream = NULL;
965
-	u32 width, height, fmt;
966
-	u32 pic_size, addr_offs;
967
-	u32 w, h, val;
968
-	u32 max_w, max_h;
969
-	int ret, mult = 1;
970
-
971
-	vdev = &dev->stream_vdev;
972
-	vdev->nr.is_end = true;
973
-	if (!(vdev->module_ens & (ISPP_MODULE_NR | ISPP_MODULE_SHP)))
974
-		return 0;
975
-
976
-	vdev->is_done_early = is_en_done_early(dev);
977
-
978
-	if (dev->inp == INP_DDR) {
979
-		stream = &vdev->stream[STREAM_II];
980
-		fmt = stream->out_cap_fmt.wr_fmt;
981
-	} else {
982
-		fmt = dev->isp_mode & (FMT_YUV422 | FMT_FBC);
983
-	}
984
-
985
-	width = dev->ispp_sdev.in_fmt.width;
986
-	height = dev->ispp_sdev.in_fmt.height;
987
-	w = width;
988
-	h = height;
989
-	max_w = hw->max_in.w ? hw->max_in.w : w;
990
-	max_h = hw->max_in.h ? hw->max_in.h : h;
991
-	if (fmt & FMT_FBC) {
992
-		max_w = ALIGN(max_w, 16);
993
-		max_h = ALIGN(max_h, 16);
994
-		w = ALIGN(w, 16);
995
-		h = ALIGN(h, 16);
996
-	}
997
-	addr_offs = (fmt & FMT_FBC) ? max_w * max_h >> 4 : max_w * max_h;
998
-	pic_size = (fmt & FMT_YUV422) ? w * h * 2 : w * h * 3 >> 1;
999
-	vdev->nr.uv_offset = addr_offs;
1000
-
1001
-	if (fmt & FMT_YUYV)
1002
-		mult = 2;
1003
-
1004
-	ret = nr_init_buf(dev, pic_size);
1005
-	if (ret)
1006
-		return ret;
1007
-
1008
-	if (vdev->module_ens & ISPP_MODULE_TNR) {
1009
-		rkispp_write(dev, RKISPP_NR_ADDR_BASE_Y,
1010
-			     rkispp_read(dev, RKISPP_TNR_WR_Y_BASE));
1011
-		rkispp_write(dev, RKISPP_NR_ADDR_BASE_UV,
1012
-			     rkispp_read(dev, RKISPP_TNR_WR_UV_BASE));
1013
-		rkispp_write(dev, RKISPP_NR_ADDR_BASE_GAIN,
1014
-			     rkispp_read(dev, RKISPP_TNR_GAIN_WR_Y_BASE));
1015
-		rkispp_set_bits(dev, RKISPP_CTRL_QUICK, 0, GLB_NR_SD32_TNR);
1016
-	} else {
1017
-		/* tnr need to set same format with nr in the fbc mode */
1018
-		rkispp_set_bits(dev, RKISPP_TNR_CTRL, FMT_RD_MASK, fmt);
1019
-		rkispp_write(dev, RKISPP_CTRL_TNR_SIZE, height << 16 | width);
1020
-		if (dev->inp == INP_ISP) {
1021
-			if (dev->isp_mode & ISP_ISPP_QUICK)
1022
-				rkispp_set_bits(dev, RKISPP_CTRL_QUICK,
1023
-						GLB_QUICK_MODE_MASK,
1024
-						GLB_QUICK_MODE(2));
1025
-			else
1026
-				rkispp_set_bits(dev, RKISPP_NR_UVNR_CTRL_PARA,
1027
-						0, SW_UVNR_SD32_SELF_EN);
1028
-
1029
-			val = hw->pool[0].dma[GROUP_BUF_PIC];
1030
-			rkispp_write(dev, RKISPP_NR_ADDR_BASE_Y, val);
1031
-			rkispp_write(dev, RKISPP_NR_ADDR_BASE_UV, val + addr_offs);
1032
-			val = hw->pool[0].dma[GROUP_BUF_GAIN];
1033
-			rkispp_write(dev, RKISPP_NR_ADDR_BASE_GAIN, val);
1034
-			rkispp_clear_bits(dev, RKISPP_CTRL_QUICK, GLB_NR_SD32_TNR);
1035
-		} else if (stream) {
1036
-			stream->config->frame_end_id = NR_INT;
1037
-			stream->config->reg.cur_y_base = RKISPP_NR_ADDR_BASE_Y;
1038
-			stream->config->reg.cur_uv_base = RKISPP_NR_ADDR_BASE_UV;
1039
-			stream->config->reg.cur_y_base_shd = RKISPP_NR_ADDR_BASE_Y_SHD;
1040
-			stream->config->reg.cur_uv_base_shd = RKISPP_NR_ADDR_BASE_UV_SHD;
1041
-		}
1042
-	}
1043
-
1044
-	rkispp_clear_bits(dev, RKISPP_CTRL_QUICK, GLB_FEC2SCL_EN);
1045
-	if (vdev->module_ens & ISPP_MODULE_FEC) {
1046
-		addr_offs = width * height;
1047
-		vdev->fec.uv_offset = addr_offs;
1048
-		val = vdev->nr.buf.wr[0].dma_addr;
1049
-		rkispp_write(dev, RKISPP_SHARP_WR_Y_BASE, val);
1050
-		rkispp_write(dev, RKISPP_SHARP_WR_UV_BASE, val + addr_offs);
1051
-		rkispp_write(dev, RKISPP_SHARP_WR_VIR_STRIDE, ALIGN(width * mult, 16) >> 2);
1052
-		rkispp_set_bits(dev, RKISPP_SHARP_CTRL, SW_SHP_WR_FORMAT_MASK, fmt & (~FMT_FBC));
1053
-
1054
-		rkispp_write(dev, RKISPP_FEC_RD_Y_BASE, val);
1055
-		rkispp_write(dev, RKISPP_FEC_RD_UV_BASE, val + addr_offs);
1056
-	} else {
1057
-		stream = &vdev->stream[STREAM_MB];
1058
-		if (!stream->streaming) {
1059
-			val = hw->dummy_buf.dma_addr;
1060
-			rkispp_write(dev, RKISPP_SHARP_WR_Y_BASE, val);
1061
-			rkispp_write(dev, RKISPP_SHARP_WR_UV_BASE, val);
1062
-			rkispp_write(dev, RKISPP_SHARP_WR_VIR_STRIDE, ALIGN(width * mult, 16) >> 2);
1063
-			if (dev->inp == INP_ISP)
1064
-				rkispp_set_bits(dev, RKISPP_SHARP_CTRL, SW_SHP_WR_FORMAT_MASK, FMT_FBC);
1065
-		}
1066
-	}
1067
-
1068
-	val = vdev->nr.buf.tmp_yuv.dma_addr;
1069
-	rkispp_write(dev, RKISPP_SHARP_TMP_YUV_BASE, val);
1070
-
1071
-	/* fix to use new nr algorithm */
1072
-	rkispp_set_bits(dev, RKISPP_NR_CTRL, NR_NEW_ALGO, NR_NEW_ALGO);
1073
-	rkispp_set_bits(dev, RKISPP_NR_CTRL, FMT_RD_MASK, fmt);
1074
-	if (fmt & FMT_FBC) {
1075
-		rkispp_write(dev, RKISPP_NR_VIR_STRIDE, 0);
1076
-		rkispp_write(dev, RKISPP_FBC_VIR_HEIGHT, max_h);
1077
-	} else {
1078
-		rkispp_write(dev, RKISPP_NR_VIR_STRIDE, ALIGN(width * mult, 16) >> 2);
1079
-	}
1080
-	rkispp_write(dev, RKISPP_NR_VIR_STRIDE_GAIN, ALIGN(width, 64) >> 4);
1081
-	rkispp_write(dev, RKISPP_CTRL_SIZE, height << 16 | width);
1082
-
1083
-	if (vdev->monitor.is_en) {
1084
-		init_completion(&vdev->monitor.nr.cmpl);
1085
-		schedule_work(&vdev->monitor.nr.work);
1086
-	}
1087
-	v4l2_dbg(1, rkispp_debug, &dev->v4l2_dev,
1088
-		 "%s size:%dx%d\n"
1089
-		 "nr ctrl:0x%x ctrl_para:0x%x\n"
1090
-		 "shp ctrl:0x%x core_ctrl:0x%x\n",
1091
-		 __func__, width, height,
1092
-		 rkispp_read(dev, RKISPP_NR_CTRL),
1093
-		 rkispp_read(dev, RKISPP_NR_UVNR_CTRL_PARA),
1094
-		 rkispp_read(dev, RKISPP_SHARP_CTRL),
1095
-		 rkispp_read(dev, RKISPP_SHARP_CORE_CTRL));
1096
-	return 0;
1097
-}
1098
-
1099
-static void fec_free_buf(struct rkispp_device *dev)
1100
-{
1101
-	struct rkispp_stream_vdev *vdev = &dev->stream_vdev;
1102
-	struct list_head *list = &vdev->fec.list_rd;
1103
-
1104
-	if (vdev->fec.cur_rd)
1105
-		vdev->fec.cur_rd = NULL;
1106
-	while (!list_empty(list))
1107
-		get_list_buf(list, false);
1108
-}
1109
-
1110
-static int config_fec(struct rkispp_device *dev)
1111
-{
1112
-	struct rkispp_stream_vdev *vdev;
1113
-	struct rkispp_stream *stream = NULL;
1114
-	u32 in_width, in_height, fmt, mult = 1;
1115
-	u32 out_width, out_height;
1116
-
1117
-	vdev = &dev->stream_vdev;
1118
-	vdev->fec.is_end = true;
1119
-	if (!(vdev->module_ens & ISPP_MODULE_FEC))
1120
-		return 0;
1121
-
1122
-	if (dev->inp == INP_DDR) {
1123
-		stream = &vdev->stream[STREAM_II];
1124
-		fmt = stream->out_cap_fmt.wr_fmt;
1125
-	} else {
1126
-		fmt = dev->isp_mode & FMT_YUV422;
1127
-	}
1128
-
1129
-	in_width = dev->ispp_sdev.in_fmt.width;
1130
-	in_height = dev->ispp_sdev.in_fmt.height;
1131
-	out_width = dev->ispp_sdev.out_fmt.width;
1132
-	out_height = dev->ispp_sdev.out_fmt.height;
1133
-
1134
-	if (vdev->module_ens & (ISPP_MODULE_NR | ISPP_MODULE_SHP)) {
1135
-		rkispp_write(dev, RKISPP_FEC_RD_Y_BASE,
1136
-			     rkispp_read(dev, RKISPP_SHARP_WR_Y_BASE));
1137
-		rkispp_write(dev, RKISPP_FEC_RD_UV_BASE,
1138
-			     rkispp_read(dev, RKISPP_SHARP_WR_UV_BASE));
1139
-	} else if (stream) {
1140
-		stream->config->frame_end_id = FEC_INT;
1141
-		stream->config->reg.cur_y_base = RKISPP_FEC_RD_Y_BASE;
1142
-		stream->config->reg.cur_uv_base = RKISPP_FEC_RD_UV_BASE;
1143
-		stream->config->reg.cur_y_base_shd = RKISPP_FEC_RD_Y_BASE_SHD;
1144
-		stream->config->reg.cur_uv_base_shd = RKISPP_FEC_RD_UV_BASE_SHD;
1145
-	}
1146
-
1147
-	if (fmt & FMT_YUYV)
1148
-		mult = 2;
1149
-	rkispp_set_bits(dev, RKISPP_FEC_CTRL, FMT_RD_MASK, fmt);
1150
-	rkispp_write(dev, RKISPP_FEC_RD_VIR_STRIDE, ALIGN(in_width * mult, 16) >> 2);
1151
-	rkispp_write(dev, RKISPP_FEC_PIC_SIZE, out_height << 16 | out_width);
1152
-	rkispp_set_bits(dev, RKISPP_CTRL_QUICK, 0, GLB_FEC2SCL_EN);
1153
-
1154
-	if (vdev->monitor.is_en) {
1155
-		init_completion(&vdev->monitor.fec.cmpl);
1156
-		schedule_work(&vdev->monitor.fec.work);
1157
-	}
1158
-	v4l2_dbg(1, rkispp_debug, &dev->v4l2_dev,
1159
-		 "%s size:%dx%d->%dx%d ctrl:0x%x core_ctrl:0x%x\n",
1160
-		 __func__, in_width, in_height, out_width, out_height,
1161
-		 rkispp_read(dev, RKISPP_FEC_CTRL),
1162
-		 rkispp_read(dev, RKISPP_FEC_CORE_CTRL));
1163
-	return 0;
1164
-}
1165
-
1166
-static void rkispp_start_3a_run(struct rkispp_device *dev)
1167
-{
1168
-	struct rkispp_params_vdev *params_vdev = &dev->params_vdev[PARAM_VDEV_NR];
1169
-	struct video_device *vdev = &params_vdev->vnode.vdev;
487
+	struct rkispp_params_vdev *params_vdev;
488
+	struct video_device *vdev;
1170489 	struct v4l2_event ev = {
1171490 		.type = CIFISP_V4L2_EVENT_STREAM_START,
1172491 	};
1173492 	int ret;
1174493 
494
+	if (dev->ispp_ver == ISPP_V10)
495
+		params_vdev = &dev->params_vdev[PARAM_VDEV_NR];
496
+	else
497
+		params_vdev = &dev->params_vdev[PARAM_VDEV_FEC];
1175498 	if (!params_vdev->is_subs_evt)
1176499 		return;
1177
-
500
+	vdev = &params_vdev->vnode.vdev;
1178501 	v4l2_event_queue(vdev, &ev);
1179502 	ret = wait_event_timeout(dev->sync_onoff,
1180503 			params_vdev->streamon && !params_vdev->first_params,
....@@ -1189,16 +512,20 @@
1189512 
1190513 static void rkispp_stop_3a_run(struct rkispp_device *dev)
1191514 {
1192
-	struct rkispp_params_vdev *params_vdev = &dev->params_vdev[PARAM_VDEV_NR];
1193
-	struct video_device *vdev = &params_vdev->vnode.vdev;
515
+	struct rkispp_params_vdev *params_vdev;
516
+	struct video_device *vdev;
1194517 	struct v4l2_event ev = {
1195518 		.type = CIFISP_V4L2_EVENT_STREAM_STOP,
1196519 	};
1197520 	int ret;
1198521 
522
+	if (dev->ispp_ver == ISPP_V10)
523
+		params_vdev = &dev->params_vdev[PARAM_VDEV_NR];
524
+	else
525
+		params_vdev = &dev->params_vdev[PARAM_VDEV_FEC];
1199526 	if (!params_vdev->is_subs_evt)
1200527 		return;
1201
-
528
+	vdev = &params_vdev->vnode.vdev;
1202529 	v4l2_event_queue(vdev, &ev);
1203530 	ret = wait_event_timeout(dev->sync_onoff, !params_vdev->streamon,
1204531 				 msecs_to_jiffies(1000));
....@@ -1208,44 +535,6 @@
1208535 	else
1209536 		v4l2_dbg(1, rkispp_debug, &dev->v4l2_dev,
1210537 			 "Waiting for 3A off use %d ms\n", 1000 - ret);
1211
-}
1212
-
1213
-static int config_modules(struct rkispp_device *dev)
1214
-{
1215
-	int ret;
1216
-
1217
-	v4l2_dbg(1, rkispp_debug, &dev->v4l2_dev,
1218
-		 "stream module ens:0x%x\n", dev->stream_vdev.module_ens);
1219
-	dev->stream_vdev.monitor.monitoring_module = 0;
1220
-	dev->stream_vdev.monitor.restart_module = 0;
1221
-	dev->stream_vdev.monitor.is_restart = false;
1222
-	dev->stream_vdev.monitor.retry = 0;
1223
-	dev->stream_vdev.monitor.is_en = rkispp_monitor;
1224
-	init_completion(&dev->stream_vdev.monitor.cmpl);
1225
-
1226
-	ret = config_tnr(dev);
1227
-	if (ret < 0)
1228
-		return ret;
1229
-
1230
-	ret = config_nr_shp(dev);
1231
-	if (ret < 0)
1232
-		goto free_tnr;
1233
-
1234
-	ret = config_fec(dev);
1235
-	if (ret < 0)
1236
-		goto free_nr;
1237
-
1238
-	/* config default params */
1239
-	rkispp_params_cfg(&dev->params_vdev[PARAM_VDEV_TNR], 0);
1240
-	rkispp_params_cfg(&dev->params_vdev[PARAM_VDEV_NR], 0);
1241
-	rkispp_params_cfg(&dev->params_vdev[PARAM_VDEV_FEC], 0);
1242
-
1243
-	return 0;
1244
-free_nr:
1245
-	nr_free_buf(dev);
1246
-free_tnr:
1247
-	tnr_free_buf(dev);
1248
-	return ret;
1249538 }
1250539 
1251540 static int start_ii(struct rkispp_stream *stream)
....@@ -1275,9 +564,11 @@
1275564 
1276565 static int config_ii(struct rkispp_stream *stream)
1277566 {
567
+	struct rkispp_stream_vdev *stream_vdev = &stream->isppdev->stream_vdev;
568
+
1278569 	stream->is_cfg = true;
1279570 	rkispp_start_3a_run(stream->isppdev);
1280
-	return config_modules(stream->isppdev);
571
+	return stream_vdev->stream_ops->config_modules(stream->isppdev);
1281572 }
1282573 
1283574 static int is_stopped_ii(struct rkispp_stream *stream)
....@@ -1286,7 +577,7 @@
1286577 	return true;
1287578 }
1288579 
1289
-static void secure_config_mb(struct rkispp_stream *stream)
580
+void secure_config_mb(struct rkispp_stream *stream)
1290581 {
1291582 	struct rkispp_device *dev = stream->isppdev;
1292583 	u32 limit_range, mult = 1;
....@@ -1311,7 +602,7 @@
1311602 			0 : SW_FEC_WR_YUV_LIMIT;
1312603 		rkispp_set_bits(dev, RKISPP_FEC_CTRL, SW_FEC_WR_YUV_LIMIT | FMT_WR_MASK,
1313604 				limit_range | stream->out_cap_fmt.wr_fmt << 4);
1314
-		rkispp_write(dev, RKISPP_FEC_PIC_SIZE,
605
+		rkispp_write(dev, RKISPP_FEC_DST_SIZE,
1315606 			     stream->out_fmt.height << 16 | stream->out_fmt.width);
1316607 		rkispp_clear_bits(dev, RKISPP_FEC_CORE_CTRL, SW_FEC2DDR_DIS);
1317608 		break;
....@@ -1640,6 +931,10 @@
1640931 				pixm->plane_fmt[i].sizeimage;
1641932 			offset = (cap_fmt->wr_fmt & FMT_FBC) ?
1642933 				ALIGN(size, RK_MPP_ALIGN) : size;
934
+			if (cap_fmt->wr_fmt & FMT_FBC && dev->ispp_ver == ISPP_V20)
935
+				rkispp_write(dev, RKISPP_FEC_FBCE_HEAD_OFFSET,
936
+					     offset | SW_OFFSET_ENABLE);
937
+
1643938 			isppbuf->buff_addr[i + 1] =
1644939 				isppbuf->buff_addr[i] + offset;
1645940 		}
....@@ -1662,20 +957,6 @@
1662957 		rkispp_event_handle(dev, CMD_QUEUE_DMABUF, &vdev->input[i]);
1663958 	}
1664959 	spin_unlock_irqrestore(&stream->vbq_lock, lock_flags);
1665
-}
1666
-
1667
-static void rkispp_destroy_buf(struct rkispp_stream *stream)
1668
-{
1669
-	struct rkispp_device *dev = stream->isppdev;
1670
-	struct rkispp_stream_vdev *vdev= &dev->stream_vdev;
1671
-
1672
-	if (atomic_read(&vdev->refcnt) == 1) {
1673
-		vdev->irq_ends = 0;
1674
-		tnr_free_buf(dev);
1675
-		nr_free_buf(dev);
1676
-		fec_free_buf(dev);
1677
-		rkispp_event_handle(dev, CMD_FREE_POOL, NULL);
1678
-	}
1679960 }
1680961 
1681962 static void rkispp_stream_stop(struct rkispp_stream *stream)
....@@ -1745,6 +1026,7 @@
17451026 	struct rkispp_stream *stream = queue->drv_priv;
17461027 	struct rkispp_device *dev = stream->isppdev;
17471028 	struct rkispp_hw_dev *hw = dev->hw_dev;
1029
+	struct rkispp_stream_vdev *vdev = &dev->stream_vdev;
17481030 
17491031 	v4l2_dbg(1, rkispp_debug, &dev->v4l2_dev,
17501032 		 "%s id:%d enter\n", __func__, stream->id);
....@@ -1768,7 +1050,7 @@
17681050 	mutex_lock(&dev->hw_dev->dev_lock);
17691051 	rkispp_stream_stop(stream);
17701052 	destroy_buf_queue(stream, VB2_BUF_STATE_ERROR);
1771
-	rkispp_destroy_buf(stream);
1053
+	vdev->stream_ops->destroy_buf(stream);
17721054 	mutex_unlock(&dev->hw_dev->dev_lock);
17731055 	rkispp_free_common_dummy_buf(dev);
17741056 	atomic_dec(&dev->stream_vdev.refcnt);
....@@ -1783,72 +1065,12 @@
17831065 		 "%s id:%d exit\n", __func__, stream->id);
17841066 }
17851067 
1786
-static int start_isp(struct rkispp_device *dev)
1787
-{
1788
-	struct rkispp_subdev *ispp_sdev = &dev->ispp_sdev;
1789
-	struct rkispp_stream_vdev *vdev = &dev->stream_vdev;
1790
-	struct rkispp_stream *stream;
1791
-	struct rkisp_ispp_mode mode;
1792
-	int i, ret;
1793
-
1794
-	if (dev->inp != INP_ISP || ispp_sdev->state)
1795
-		return 0;
1796
-
1797
-	if (dev->stream_sync) {
1798
-		/* output stream enable then start isp */
1799
-		for (i = STREAM_MB; i <= STREAM_S2; i++) {
1800
-			stream = &vdev->stream[i];
1801
-			if (stream->linked && !stream->streaming)
1802
-				return 0;
1803
-		}
1804
-	} else if (atomic_read(&vdev->refcnt) > 1) {
1805
-		return 0;
1806
-	}
1807
-
1808
-	rkispp_start_3a_run(dev);
1809
-
1810
-	mutex_lock(&dev->hw_dev->dev_lock);
1811
-
1812
-	mode.work_mode = dev->isp_mode;
1813
-	mode.buf_num = ((vdev->module_ens & ISPP_MODULE_TNR_3TO1) ==
1814
-			ISPP_MODULE_TNR_3TO1) ? 2 : 1;
1815
-	mode.buf_num += RKISP_BUF_MAX + 2 * (dev->hw_dev->dev_num - 1);
1816
-	ret = v4l2_subdev_call(ispp_sdev->remote_sd, core, ioctl,
1817
-			       RKISP_ISPP_CMD_SET_MODE, &mode);
1818
-	if (ret)
1819
-		goto err;
1820
-
1821
-	ret = config_modules(dev);
1822
-	if (ret) {
1823
-		rkispp_event_handle(dev, CMD_FREE_POOL, NULL);
1824
-		mode.work_mode = ISP_ISPP_INIT_FAIL;
1825
-		v4l2_subdev_call(ispp_sdev->remote_sd, core, ioctl,
1826
-				 RKISP_ISPP_CMD_SET_MODE, &mode);
1827
-		goto err;
1828
-	}
1829
-	if (dev->hw_dev->is_single)
1830
-		writel(ALL_FORCE_UPD, dev->hw_dev->base_addr + RKISPP_CTRL_UPDATE);
1831
-	for (i = STREAM_MB; i <= STREAM_S2; i++) {
1832
-		stream = &vdev->stream[i];
1833
-		if (stream->streaming)
1834
-			stream->is_upd = true;
1835
-	}
1836
-	if (dev->isp_mode & ISP_ISPP_QUICK)
1837
-		rkispp_set_bits(dev, RKISPP_CTRL_QUICK, 0, GLB_QUICK_EN);
1838
-
1839
-	dev->isr_cnt = 0;
1840
-	dev->isr_err_cnt = 0;
1841
-	ret = v4l2_subdev_call(&ispp_sdev->sd, video, s_stream, true);
1842
-err:
1843
-	mutex_unlock(&dev->hw_dev->dev_lock);
1844
-	return ret;
1845
-}
1846
-
18471068 static int rkispp_start_streaming(struct vb2_queue *queue,
18481069 				  unsigned int count)
18491070 {
18501071 	struct rkispp_stream *stream = queue->drv_priv;
18511072 	struct rkispp_device *dev = stream->isppdev;
1073
+	struct rkispp_stream_vdev *vdev = &dev->stream_vdev;
18521074 	struct rkispp_hw_dev *hw = dev->hw_dev;
18531075 	int ret = -1;
18541076 
....@@ -1878,10 +1100,10 @@
18781100 		return ret;
18791101 	}
18801102 
1881
-	if (dev->inp == INP_DDR &&
1882
-	    !atomic_read(&hw->refcnt) &&
1103
+	if (!atomic_read(&hw->refcnt) &&
18831104 	    !atomic_read(&dev->stream_vdev.refcnt) &&
1884
-	    clk_get_rate(hw->clks[0]) <= hw->core_clk_min) {
1105
+	    clk_get_rate(hw->clks[0]) <= hw->core_clk_min &&
1106
+	    (dev->inp == INP_DDR || dev->ispp_ver == ISPP_V20)) {
18851107 		dev->hw_dev->is_first = false;
18861108 		rkispp_set_clk_rate(hw->clks[0], hw->core_clk_max);
18871109 	}
....@@ -1899,8 +1121,12 @@
18991121 	if (ret < 0)
19001122 		goto free_buf_queue;
19011123 
1902
-	if (dev->inp == INP_ISP)
1903
-		dev->stream_vdev.module_ens |= ISPP_MODULE_NR;
1124
+	if (dev->inp == INP_ISP) {
1125
+		if (dev->ispp_ver == ISPP_V10)
1126
+			dev->stream_vdev.module_ens |= ISPP_MODULE_NR;
1127
+		else if (dev->ispp_ver == ISPP_V20)
1128
+			dev->stream_vdev.module_ens = ISPP_MODULE_FEC;
1129
+	}
19041130 
19051131 	if (stream->ops && stream->ops->config) {
19061132 		ret = stream->ops->config(stream);
....@@ -1915,7 +1141,7 @@
19151141 	stream->streaming = true;
19161142 
19171143 	/* start from isp */
1918
-	ret = start_isp(dev);
1144
+	ret = vdev->stream_ops->start_isp(dev);
19191145 	if (ret)
19201146 		goto free_dummy_buf;
19211147 
....@@ -1926,7 +1152,7 @@
19261152 	rkispp_free_common_dummy_buf(stream->isppdev);
19271153 free_buf_queue:
19281154 	destroy_buf_queue(stream, VB2_BUF_STATE_QUEUED);
1929
-	rkispp_destroy_buf(stream);
1155
+	vdev->stream_ops->destroy_buf(stream);
19301156 	atomic_dec(&dev->stream_vdev.refcnt);
19311157 	stream->streaming = false;
19321158 	stream->is_upd = false;
....@@ -1964,6 +1190,7 @@
19641190 	q->lock = &stream->isppdev->apilock;
19651191 	q->dev = stream->isppdev->hw_dev->dev;
19661192 	q->allow_cache_hints = 1;
1193
+	q->bidirectional = 1;
19671194 	if (stream->isppdev->hw_dev->is_dma_contig)
19681195 		q->dma_attrs = DMA_ATTR_FORCE_CONTIGUOUS;
19691196 	q->gfp_flags = GFP_DMA32;
....@@ -2026,10 +1253,16 @@
20261253 
20271254 		plane_fmt = pixm->plane_fmt + i;
20281255 
2029
-		w = (fmt->wr_fmt & FMT_FBC) ?
2030
-			ALIGN(pixm->width, 16) : pixm->width;
2031
-		h = (fmt->wr_fmt & FMT_FBC) ?
2032
-			ALIGN(pixm->height, 16) : pixm->height;
1256
+		if (pixm->width == RKISPP_MAX_WIDTH_V20) {
1257
+			w = ALIGN(pixm->width, 16);
1258
+			h = ALIGN(pixm->height, 16);
1259
+		} else {
1260
+			w = (fmt->wr_fmt & FMT_FBC) ?
1261
+				ALIGN(pixm->width, 16) : pixm->width;
1262
+			h = (fmt->wr_fmt & FMT_FBC) ?
1263
+				ALIGN(pixm->height, 16) : pixm->height;
1264
+		}
1265
+
20331266 		width = i ? w / xsubs : w;
20341267 		height = i ? h / ysubs : h;
20351268 
....@@ -2074,17 +1307,32 @@
20741307 			 __func__, stream->id, pixm->width, pixm->height,
20751308 			 stream->out_fmt.width, stream->out_fmt.height);
20761309 
2077
-		if (sdev->out_fmt.width > RKISPP_MAX_WIDTH ||
2078
-		    sdev->out_fmt.height > RKISPP_MAX_HEIGHT ||
2079
-		    sdev->out_fmt.width < RKISPP_MIN_WIDTH ||
2080
-		    sdev->out_fmt.height < RKISPP_MIN_HEIGHT) {
2081
-			v4l2_err(&dev->v4l2_dev,
2082
-				 "ispp input min:%dx%d max:%dx%d\n",
2083
-				 RKISPP_MIN_WIDTH, RKISPP_MIN_HEIGHT,
2084
-				 RKISPP_MAX_WIDTH, RKISPP_MAX_HEIGHT);
2085
-			stream->out_fmt.width = 0;
2086
-			stream->out_fmt.height = 0;
2087
-			return -EINVAL;
1310
+		if (dev->ispp_ver == ISPP_V10) {
1311
+			if (sdev->out_fmt.width > RKISPP_MAX_WIDTH_V10 ||
1312
+			sdev->out_fmt.height > RKISPP_MAX_HEIGHT_V10 ||
1313
+			sdev->out_fmt.width < RKISPP_MIN_WIDTH_V10 ||
1314
+			sdev->out_fmt.height < RKISPP_MIN_HEIGHT_V10) {
1315
+				v4l2_err(&dev->v4l2_dev,
1316
+					"ispp input min:%dx%d max:%dx%d\n",
1317
+					RKISPP_MIN_WIDTH_V10, RKISPP_MIN_HEIGHT_V10,
1318
+					RKISPP_MAX_WIDTH_V10, RKISPP_MAX_HEIGHT_V10);
1319
+				stream->out_fmt.width = 0;
1320
+				stream->out_fmt.height = 0;
1321
+				return -EINVAL;
1322
+			}
1323
+		} else if (dev->ispp_ver == ISPP_V20) {
1324
+			if (sdev->out_fmt.width > RKISPP_MAX_WIDTH_V20 ||
1325
+			sdev->out_fmt.height > RKISPP_MAX_HEIGHT_V20 ||
1326
+			sdev->out_fmt.width < RKISPP_MIN_WIDTH_V20 ||
1327
+			sdev->out_fmt.height < RKISPP_MIN_HEIGHT_V20) {
1328
+				v4l2_err(&dev->v4l2_dev,
1329
+					"ispp input min:%dx%d max:%dx%d\n",
1330
+					RKISPP_MIN_WIDTH_V20, RKISPP_MIN_HEIGHT_V20,
1331
+					RKISPP_MAX_WIDTH_V20, RKISPP_MAX_HEIGHT_V20);
1332
+				stream->out_fmt.width = 0;
1333
+				stream->out_fmt.height = 0;
1334
+				return -EINVAL;
1335
+			}
20881336 		}
20891337 	}
20901338 
....@@ -2104,7 +1352,7 @@
21041352 
21051353 	ret = v4l2_fh_open(filp);
21061354 	if (!ret) {
2107
-		ret = v4l2_pipeline_pm_use(&stream->vnode.vdev.entity, 1);
1355
+		ret = v4l2_pipeline_pm_get(&stream->vnode.vdev.entity);
21081356 		if (ret < 0) {
21091357 			v4l2_err(&isppdev->v4l2_dev,
21101358 				 "pipeline power on failed %d\n", ret);
....@@ -2117,16 +1365,11 @@
21171365 static int rkispp_fh_release(struct file *filp)
21181366 {
21191367 	struct rkispp_stream *stream = video_drvdata(filp);
2120
-	struct rkispp_device *isppdev = stream->isppdev;
21211368 	int ret;
21221369 
21231370 	ret = vb2_fop_release(filp);
2124
-	if (!ret) {
2125
-		ret = v4l2_pipeline_pm_use(&stream->vnode.vdev.entity, 0);
2126
-		if (ret < 0)
2127
-			v4l2_err(&isppdev->v4l2_dev,
2128
-				 "pipeline power off failed %d\n", ret);
2129
-	}
1371
+	if (!ret)
1372
+		v4l2_pipeline_pm_put(&stream->vnode.vdev.entity);
21301373 	return ret;
21311374 }
21321375 
....@@ -2169,7 +1412,20 @@
21691412 
21701413 	fmt = &stream->config->fmts[f->index];
21711414 	f->pixelformat = fmt->fourcc;
2172
-
1415
+	switch (f->pixelformat) {
1416
+	case V4L2_PIX_FMT_FBC2:
1417
+		strscpy(f->description,
1418
+			"Rockchip yuv422sp fbc encoder",
1419
+			sizeof(f->description));
1420
+		break;
1421
+	case V4L2_PIX_FMT_FBC0:
1422
+		strscpy(f->description,
1423
+			"Rockchip yuv420sp fbc encoder",
1424
+			sizeof(f->description));
1425
+		break;
1426
+	default:
1427
+		break;
1428
+	}
21731429 	return 0;
21741430 }
21751431 
....@@ -2229,11 +1485,10 @@
22291485 	.vidioc_streamoff = vb2_ioctl_streamoff,
22301486 	.vidioc_enum_input = rkispp_enum_input,
22311487 	.vidioc_try_fmt_vid_cap_mplane = rkispp_try_fmt_vid_mplane,
2232
-	.vidioc_enum_fmt_vid_cap_mplane = rkispp_enum_fmt_vid_mplane,
1488
+	.vidioc_enum_fmt_vid_cap = rkispp_enum_fmt_vid_mplane,
22331489 	.vidioc_s_fmt_vid_cap_mplane = rkispp_s_fmt_vid_mplane,
22341490 	.vidioc_g_fmt_vid_cap_mplane = rkispp_g_fmt_vid_mplane,
22351491 	.vidioc_try_fmt_vid_out_mplane = rkispp_try_fmt_vid_mplane,
2236
-	.vidioc_enum_fmt_vid_out_mplane = rkispp_enum_fmt_vid_mplane,
22371492 	.vidioc_s_fmt_vid_out_mplane = rkispp_s_fmt_vid_mplane,
22381493 	.vidioc_g_fmt_vid_out_mplane = rkispp_g_fmt_vid_mplane,
22391494 	.vidioc_querycap = rkispp_querycap,
....@@ -2280,7 +1535,7 @@
22801535 	rkispp_init_vb2_queue(&node->buf_queue, stream, buf_type);
22811536 	vdev->queue = &node->buf_queue;
22821537 
2283
-	ret = video_register_device(vdev, VFL_TYPE_GRABBER, -1);
1538
+	ret = video_register_device(vdev, VFL_TYPE_VIDEO, -1);
22841539 	if (ret < 0) {
22851540 		v4l2_err(v4l2_dev,
22861541 			 "video register failed with error %d\n", ret);
....@@ -2335,8 +1590,8 @@
23351590 			kernel_write(fp, buf->vaddr[0], vdev->tnr.cur_rd->dbuf[0]->size, &fp->f_pos);
23361591 			filp_close(fp, NULL);
23371592 			v4l2_dbg(1, rkispp_debug, &dev->v4l2_dev,
2338
-				 "dump tnr cur_rd dma:0x%x vaddr:%p\n",
2339
-				 buf->dma[0], buf->vaddr[0]);
1593
+				 "dump tnr cur_rd dma:%pad vaddr:%p\n",
1594
+				 &buf->dma[0], buf->vaddr[0]);
23401595 		}
23411596 
23421597 		if (vdev->tnr.nxt_rd && vdev->tnr.nxt_rd != vdev->tnr.cur_rd) {
....@@ -2352,8 +1607,8 @@
23521607 			kernel_write(fp, buf->vaddr[0], vdev->tnr.nxt_rd->dbuf[0]->size, &fp->f_pos);
23531608 			filp_close(fp, NULL);
23541609 			v4l2_dbg(1, rkispp_debug, &dev->v4l2_dev,
2355
-				 "dump tnr nxt_rd dma:0x%x vaddr:%p\n",
2356
-				 buf->dma[0], buf->vaddr[0]);
1610
+				 "dump tnr nxt_rd dma:%pad vaddr:%p\n",
1611
+				 &buf->dma[0], buf->vaddr[0]);
23571612 		}
23581613 	}
23591614 
....@@ -2373,8 +1628,8 @@
23731628 			kernel_write(fp, dummy->vaddr, dummy->size, &fp->f_pos);
23741629 			filp_close(fp, NULL);
23751630 			v4l2_dbg(1, rkispp_debug, &dev->v4l2_dev,
2376
-				 "dump tnr wr dma:0x%x vaddr:%p\n",
2377
-				 dummy->dma_addr, dummy->vaddr);
1631
+				 "dump tnr wr dma:%pad vaddr:%p\n",
1632
+				 &dummy->dma_addr, dummy->vaddr);
23781633 		}
23791634 	}
23801635 }
....@@ -2546,171 +1801,6 @@
25461801 	monitor->is_restart = false;
25471802 }
25481803 
2549
-static void fec_work_event(struct rkispp_device *dev,
2550
-			   struct rkispp_dummy_buffer *buf_rd,
2551
-			   bool is_isr, bool is_quick)
2552
-{
2553
-	struct rkispp_stream_vdev *vdev = &dev->stream_vdev;
2554
-	struct rkispp_monitor *monitor = &vdev->monitor;
2555
-	struct list_head *list = &vdev->fec.list_rd;
2556
-	void __iomem *base = dev->hw_dev->base_addr;
2557
-	struct rkispp_dummy_buffer *dummy;
2558
-	struct rkispp_stream *stream;
2559
-	unsigned long lock_flags = 0, lock_flags1 = 0;
2560
-	bool is_start = false;
2561
-	struct rkisp_ispp_reg *reg_buf = NULL;
2562
-	u32 val;
2563
-
2564
-	if (!(vdev->module_ens & ISPP_MODULE_FEC))
2565
-		return;
2566
-
2567
-	spin_lock_irqsave(&vdev->fec.buf_lock, lock_flags);
2568
-
2569
-	/* event from fec frame end */
2570
-	if (!buf_rd && is_isr) {
2571
-		vdev->fec.is_end = true;
2572
-
2573
-		if (vdev->fec.cur_rd || vdev->is_done_early)
2574
-			rkispp_module_work_event(dev, NULL, vdev->fec.cur_rd,
2575
-						 ISPP_MODULE_NR, false);
2576
-		vdev->fec.cur_rd = NULL;
2577
-	}
2578
-
2579
-	spin_lock_irqsave(&monitor->lock, lock_flags1);
2580
-	if (monitor->is_restart && buf_rd) {
2581
-		list_add_tail(&buf_rd->list, list);
2582
-		goto restart_unlock;
2583
-	}
2584
-
2585
-	if (buf_rd && vdev->fec.is_end && list_empty(list)) {
2586
-		/* fec read buf from nr */
2587
-		vdev->fec.cur_rd = buf_rd;
2588
-	} else if (vdev->fec.is_end && !list_empty(list)) {
2589
-		/* fec read buf from list
2590
-		 * fec processing slow than nr
2591
-		 * new read buf from nr into list
2592
-		 */
2593
-		vdev->fec.cur_rd = get_list_buf(list, false);
2594
-		if (buf_rd)
2595
-			list_add_tail(&buf_rd->list, list);
2596
-	} else if (!vdev->fec.is_end && buf_rd) {
2597
-		/* fec no idle
2598
-		 * new read buf from nr into list
2599
-		 */
2600
-		list_add_tail(&buf_rd->list, list);
2601
-	}
2602
-
2603
-	if (vdev->fec.cur_rd && vdev->fec.is_end) {
2604
-		dummy = vdev->fec.cur_rd;
2605
-		val = dummy->dma_addr;
2606
-		rkispp_write(dev, RKISPP_FEC_RD_Y_BASE, val);
2607
-		val += vdev->fec.uv_offset;
2608
-		rkispp_write(dev, RKISPP_FEC_RD_UV_BASE, val);
2609
-		is_start = true;
2610
-	}
2611
-
2612
-	if (is_start || is_quick) {
2613
-		u32 seq = 0;
2614
-
2615
-		if (vdev->fec.cur_rd) {
2616
-			seq = vdev->fec.cur_rd->id;
2617
-			dev->ispp_sdev.frame_timestamp =
2618
-				vdev->fec.cur_rd->timestamp;
2619
-			dev->ispp_sdev.frm_sync_seq = seq;
2620
-			rkispp_params_cfg(&dev->params_vdev[PARAM_VDEV_FEC], seq);
2621
-		} else {
2622
-			seq = vdev->nr.buf.wr[0].id;
2623
-			dev->ispp_sdev.frame_timestamp =
2624
-				vdev->nr.buf.wr[0].timestamp;
2625
-			dev->ispp_sdev.frm_sync_seq = seq;
2626
-		}
2627
-
2628
-		/* check MB config and output buf beforce start, when MB connect to FEC
2629
-		 * MB update by FEC_FORCE_UPD
2630
-		 */
2631
-		stream = &vdev->stream[STREAM_MB];
2632
-		if (stream->streaming) {
2633
-			if (!stream->is_cfg) {
2634
-				secure_config_mb(stream);
2635
-			} else if (!stream->curr_buf) {
2636
-				get_stream_buf(stream);
2637
-				if (stream->curr_buf)
2638
-					update_mi(stream);
2639
-			}
2640
-		}
2641
-
2642
-		if (!dev->hw_dev->is_single) {
2643
-			rkispp_update_regs(dev, RKISPP_FEC, RKISPP_FEC_CROP);
2644
-			rkispp_update_regs(dev, RKISPP_SCL0, RKISPP_SCL2_FACTOR);
2645
-		}
2646
-
2647
-		writel(FEC_FORCE_UPD, base + RKISPP_CTRL_UPDATE);
2648
-		if (vdev->nr.is_end) {
2649
-			if (!dev->hw_dev->is_single)
2650
-				rkispp_update_regs(dev, RKISPP_SCL0_CTRL, RKISPP_SCL2_FACTOR);
2651
-			writel(OTHER_FORCE_UPD, base + RKISPP_CTRL_UPDATE);
2652
-			/* check scale stream stop state */
2653
-			for (val = STREAM_S0; val <= STREAM_S2; val++) {
2654
-				stream = &vdev->stream[val];
2655
-				if (stream->streaming && stream->stopping) {
2656
-					if (stream->ops->is_stopped(stream)) {
2657
-						stream->stopping = false;
2658
-						stream->streaming = false;
2659
-						wake_up(&stream->done);
2660
-					} else {
2661
-						stream->ops->stop(stream);
2662
-					}
2663
-				}
2664
-			}
2665
-		}
2666
-		v4l2_dbg(3, rkispp_debug, &dev->v4l2_dev,
2667
-			 "FEC start seq:%d | Y_SHD rd:0x%x\n"
2668
-			 "\txint:0x%x xfra:0x%x yint:0x%x yfra:0x%x\n",
2669
-			 seq, readl(base + RKISPP_FEC_RD_Y_BASE_SHD),
2670
-			 readl(base + RKISPP_FEC_MESH_XINT_BASE_SHD),
2671
-			 readl(base + RKISPP_FEC_MESH_XFRA_BASE_SHD),
2672
-			 readl(base + RKISPP_FEC_MESH_YINT_BASE_SHD),
2673
-			 readl(base + RKISPP_FEC_MESH_YFRA_BASE_SHD));
2674
-
2675
-		vdev->fec.dbg.id = seq;
2676
-		vdev->fec.dbg.timestamp = ktime_get_ns();
2677
-		if (monitor->is_en) {
2678
-			monitor->fec.time = vdev->fec.dbg.interval / 1000 / 1000;
2679
-			monitor->monitoring_module |= MONITOR_FEC;
2680
-			if (!completion_done(&monitor->fec.cmpl))
2681
-				complete(&monitor->fec.cmpl);
2682
-		}
2683
-
2684
-		if (rkispp_is_reg_withstream_global())
2685
-			rkispp_find_regbuf_by_id(dev, &reg_buf, dev->dev_id, seq);
2686
-		if (reg_buf && (rkispp_debug_reg & ISPP_MODULE_FEC)) {
2687
-			u32 offset, size;
2688
-
2689
-			offset = reg_buf->reg_size;
2690
-			size = 4 + RKISPP_FEC_CROP - RKISPP_FEC_CTRL;
2691
-			reg_buf->ispp_size[ISPP_ID_FEC] = size;
2692
-			reg_buf->ispp_offset[ISPP_ID_FEC] = offset;
2693
-			memcpy_fromio(&reg_buf->reg[offset], base + RKISPP_FEC_CTRL, size);
2694
-
2695
-			offset += size;
2696
-			reg_buf->reg_size = offset;
2697
-		}
2698
-
2699
-		if (!dev->hw_dev->is_shutdown) {
2700
-			writel(FEC_ST, base + RKISPP_CTRL_STRT);
2701
-
2702
-			if (vdev->is_done_early)
2703
-				hrtimer_start(&vdev->frame_qst,
2704
-					      ns_to_ktime(5000000),
2705
-					      HRTIMER_MODE_REL);
2706
-		}
2707
-		vdev->fec.is_end = false;
2708
-	}
2709
-restart_unlock:
2710
-	spin_unlock_irqrestore(&monitor->lock, lock_flags1);
2711
-	spin_unlock_irqrestore(&vdev->fec.buf_lock, lock_flags);
2712
-}
2713
-
27141804 static enum hrtimer_restart rkispp_fec_do_early(struct hrtimer *timer)
27151805 {
27161806 	struct rkispp_stream_vdev *vdev =
....@@ -2738,752 +1828,10 @@
27381828 		v4l2_dbg(3, rkispp_debug, &dev->v4l2_dev,
27391829 			 "%s seq:%d ycnt:%d time:%dus\n",
27401830 			 __func__, vdev->nr.dbg.id, ycnt * 128, time / 1000);
2741
-		fec_work_event(dev, NULL, false, true);
1831
+		vdev->stream_ops->fec_work_event(dev, NULL, false, true);
27421832 	}
27431833 end:
27441834 	return ret;
2745
-}
2746
-
2747
-static void nr_work_event(struct rkispp_device *dev,
2748
-			  struct rkisp_ispp_buf *buf_rd,
2749
-			  struct rkispp_dummy_buffer *buf_wr,
2750
-			  bool is_isr)
2751
-{
2752
-	struct rkispp_stream_vdev *vdev = &dev->stream_vdev;
2753
-	struct rkispp_stream *stream = &vdev->stream[STREAM_II];
2754
-	struct rkispp_monitor *monitor = &vdev->monitor;
2755
-	void __iomem *base = dev->hw_dev->base_addr;
2756
-	struct rkispp_dummy_buffer *buf_to_fec = NULL;
2757
-	struct rkispp_dummy_buffer *dummy;
2758
-	struct rkispp_buffer *inbuf;
2759
-	struct v4l2_subdev *sd = NULL;
2760
-	struct list_head *list;
2761
-	struct dma_buf *dbuf;
2762
-	unsigned long lock_flags = 0, lock_flags1 = 0;
2763
-	bool is_start = false, is_quick = false, is_fec_event = false;
2764
-	bool is_fec_en = (vdev->module_ens & ISPP_MODULE_FEC);
2765
-	struct rkisp_ispp_reg *reg_buf = NULL;
2766
-	u32 val;
2767
-
2768
-	if (!(vdev->module_ens & (ISPP_MODULE_NR | ISPP_MODULE_SHP)))
2769
-		return;
2770
-
2771
-	if (dev->inp == INP_ISP) {
2772
-		if (dev->isp_mode & ISP_ISPP_QUICK)
2773
-			is_quick = true;
2774
-		else
2775
-			sd = dev->ispp_sdev.remote_sd;
2776
-	}
2777
-
2778
-	spin_lock_irqsave(&vdev->nr.buf_lock, lock_flags);
2779
-
2780
-	/* event from nr frame end */
2781
-	if (!buf_rd && !buf_wr && is_isr) {
2782
-		vdev->nr.is_end = true;
2783
-		is_fec_event = true;
2784
-		if (vdev->nr.cur_rd) {
2785
-			/* nr read buf return to isp or tnr */
2786
-			if (vdev->nr.cur_rd->is_isp && sd) {
2787
-				v4l2_subdev_call(sd, video, s_rx_buffer, vdev->nr.cur_rd, NULL);
2788
-			} else if (!vdev->nr.cur_rd->priv) {
2789
-				rkispp_module_work_event(dev, NULL, vdev->nr.cur_rd,
2790
-							 ISPP_MODULE_TNR, is_isr);
2791
-			} else if (stream->streaming && vdev->nr.cur_rd->priv) {
2792
-				inbuf = vdev->nr.cur_rd->priv;
2793
-				vb2_buffer_done(&inbuf->vb.vb2_buf, VB2_BUF_STATE_DONE);
2794
-			}
2795
-			vdev->nr.cur_rd = NULL;
2796
-		}
2797
-
2798
-		if (vdev->nr.cur_wr) {
2799
-			/* nr write buf to fec */
2800
-			buf_to_fec = vdev->nr.cur_wr;
2801
-			vdev->nr.cur_wr = NULL;
2802
-
2803
-			if (vdev->is_done_early && !dev->hw_dev->is_first)
2804
-				buf_to_fec = NULL;
2805
-		}
2806
-	}
2807
-
2808
-	if (!vdev->fec.is_end) {
2809
-		if (buf_rd)
2810
-			list_add_tail(&buf_rd->list, &vdev->nr.list_rd);
2811
-		goto end;
2812
-	}
2813
-
2814
-	spin_lock_irqsave(&monitor->lock, lock_flags1);
2815
-	if (monitor->is_restart) {
2816
-		if (buf_rd)
2817
-			list_add_tail(&buf_rd->list, &vdev->nr.list_rd);
2818
-		if (buf_wr)
2819
-			list_add_tail(&buf_wr->list, &vdev->nr.list_wr);
2820
-		goto restart_unlock;
2821
-	}
2822
-
2823
-	list = &vdev->nr.list_rd;
2824
-	if (buf_rd && vdev->nr.is_end && list_empty(list)) {
2825
-		/* nr read buf from isp or tnr */
2826
-		vdev->nr.cur_rd = buf_rd;
2827
-	} else if (vdev->nr.is_end && !list_empty(list)) {
2828
-		/* nr read buf from list
2829
-		 * nr processing slow than isp or tnr
2830
-		 * new read buf from isp or tnr into list
2831
-		 */
2832
-		vdev->nr.cur_rd = get_list_buf(list, true);
2833
-		if (buf_rd)
2834
-			list_add_tail(&buf_rd->list, list);
2835
-	} else if (!vdev->nr.is_end && buf_rd) {
2836
-		/* nr no idle
2837
-		 * new read buf from isp or tnr into list
2838
-		 */
2839
-		list_add_tail(&buf_rd->list, list);
2840
-	}
2841
-
2842
-	list = &vdev->nr.list_wr;
2843
-	if (vdev->nr.is_end && !vdev->nr.cur_wr) {
2844
-		/* nr idle, get new write buf */
2845
-		vdev->nr.cur_wr = buf_wr ? buf_wr :
2846
-				get_list_buf(list, false);
2847
-	} else if (buf_wr) {
2848
-		/* tnr no idle, write buf from nr into list */
2849
-		list_add_tail(&buf_wr->list, list);
2850
-	}
2851
-
2852
-	if (vdev->nr.cur_rd && vdev->nr.is_end) {
2853
-		if (vdev->nr.cur_rd->priv) {
2854
-			inbuf = vdev->nr.cur_rd->priv;
2855
-			val = inbuf->buff_addr[RKISPP_PLANE_Y];
2856
-			rkispp_write(dev, RKISPP_NR_ADDR_BASE_Y, val);
2857
-			val = inbuf->buff_addr[RKISPP_PLANE_UV];
2858
-			rkispp_write(dev, RKISPP_NR_ADDR_BASE_UV, val);
2859
-		} else if (!vdev->nr.cur_rd->is_isp) {
2860
-			u32 size = sizeof(vdev->tnr.buf) / sizeof(*dummy);
2861
-
2862
-			dbuf = vdev->nr.cur_rd->dbuf[GROUP_BUF_PIC];
2863
-			dummy = dbuf_to_dummy(dbuf, &vdev->tnr.buf.iir, size);
2864
-			val = dummy->dma_addr;
2865
-			rkispp_write(dev, RKISPP_NR_ADDR_BASE_Y, val);
2866
-			val += vdev->nr.uv_offset;
2867
-			rkispp_write(dev, RKISPP_NR_ADDR_BASE_UV, val);
2868
-
2869
-			dbuf = vdev->nr.cur_rd->dbuf[GROUP_BUF_GAIN];
2870
-			dummy = dbuf_to_dummy(dbuf, &vdev->tnr.buf.iir, size);
2871
-			val = dummy->dma_addr;
2872
-			rkispp_write(dev, RKISPP_NR_ADDR_BASE_GAIN, val);
2873
-		} else {
2874
-			struct rkispp_isp_buf_pool *buf;
2875
-
2876
-			buf = get_pool_buf(dev, vdev->nr.cur_rd);
2877
-			val = buf->dma[GROUP_BUF_PIC];
2878
-			rkispp_write(dev, RKISPP_NR_ADDR_BASE_Y, val);
2879
-			val += vdev->nr.uv_offset;
2880
-			rkispp_write(dev, RKISPP_NR_ADDR_BASE_UV, val);
2881
-
2882
-			val = buf->dma[GROUP_BUF_GAIN];
2883
-			rkispp_write(dev, RKISPP_NR_ADDR_BASE_GAIN, val);
2884
-		}
2885
-		is_start = true;
2886
-	}
2887
-
2888
-	if (vdev->nr.is_end && is_quick)
2889
-		is_start = true;
2890
-
2891
-	if (vdev->nr.cur_wr && is_start) {
2892
-		dummy = vdev->nr.cur_wr;
2893
-		val = dummy->dma_addr;
2894
-		rkispp_write(dev, RKISPP_SHARP_WR_Y_BASE, val);
2895
-		val += vdev->fec.uv_offset;
2896
-		rkispp_write(dev, RKISPP_SHARP_WR_UV_BASE, val);
2897
-	}
2898
-
2899
-	if (is_start) {
2900
-		u32 seq = 0;
2901
-		u64 timestamp = 0;
2902
-
2903
-		if (vdev->nr.cur_rd) {
2904
-			seq = vdev->nr.cur_rd->frame_id;
2905
-			timestamp = vdev->nr.cur_rd->frame_timestamp;
2906
-			if (vdev->nr.cur_wr) {
2907
-				vdev->nr.cur_wr->id = seq;
2908
-				vdev->nr.cur_wr->timestamp = timestamp;
2909
-			} else {
2910
-				vdev->nr.buf.wr[0].id = seq;
2911
-				vdev->nr.buf.wr[0].timestamp = timestamp;
2912
-			}
2913
-			if (!is_fec_en && !is_quick) {
2914
-				dev->ispp_sdev.frame_timestamp = timestamp;
2915
-				dev->ispp_sdev.frm_sync_seq = seq;
2916
-			}
2917
-
2918
-			dev->stats_vdev[STATS_VDEV_NR].frame_id = seq;
2919
-			rkispp_params_cfg(&dev->params_vdev[PARAM_VDEV_NR], seq);
2920
-		}
2921
-
2922
-		/* check MB config and output buf beforce start, when MB connect to SHARP
2923
-		 * MB update by OTHER_FORCE_UPD
2924
-		 */
2925
-		stream = &vdev->stream[STREAM_MB];
2926
-		if (!is_fec_en && stream->streaming) {
2927
-			if (!stream->is_cfg) {
2928
-				secure_config_mb(stream);
2929
-			} else if (!stream->curr_buf) {
2930
-				get_stream_buf(stream);
2931
-				if (stream->curr_buf)
2932
-					update_mi(stream);
2933
-			}
2934
-		}
2935
-
2936
-		/* check SCL output buf beforce start
2937
-		 * SCL update by OTHER_FORCE_UPD
2938
-		 */
2939
-		for (val = STREAM_S0; val <= STREAM_S2; val++) {
2940
-			stream = &vdev->stream[val];
2941
-			if (!stream->streaming || !stream->is_cfg || stream->curr_buf)
2942
-				continue;
2943
-			get_stream_buf(stream);
2944
-			if (stream->curr_buf) {
2945
-				update_mi(stream);
2946
-				rkispp_set_bits(dev, stream->config->reg.ctrl, 0, SW_SCL_ENABLE);
2947
-			} else {
2948
-				rkispp_clear_bits(dev, stream->config->reg.ctrl, SW_SCL_ENABLE);
2949
-			}
2950
-		}
2951
-
2952
-		if (!dev->hw_dev->is_single) {
2953
-			if (vdev->nr.cur_rd &&
2954
-			    (vdev->nr.cur_rd->is_isp || vdev->nr.cur_rd->priv)) {
2955
-				rkispp_update_regs(dev, RKISPP_CTRL, RKISPP_TNR_CTRL);
2956
-				writel(TNR_FORCE_UPD, base + RKISPP_CTRL_UPDATE);
2957
-			}
2958
-			rkispp_update_regs(dev, RKISPP_NR, RKISPP_ORB_MAX_FEATURE);
2959
-		}
2960
-
2961
-		writel(OTHER_FORCE_UPD, base + RKISPP_CTRL_UPDATE);
2962
-
2963
-		val = readl(base + RKISPP_SHARP_CORE_CTRL);
2964
-		if (!(val & SW_SHP_EN) && !is_fec_en && !stream->streaming)
2965
-			writel(val | SW_SHP_DMA_DIS, base + RKISPP_SHARP_CORE_CTRL);
2966
-		else if (val & SW_SHP_EN)
2967
-			writel(val & ~SW_SHP_DMA_DIS, base + RKISPP_SHARP_CORE_CTRL);
2968
-
2969
-		v4l2_dbg(3, rkispp_debug, &dev->v4l2_dev,
2970
-			 "NR start seq:%d | Y_SHD rd:0x%x wr:0x%x\n",
2971
-			 seq, readl(base + RKISPP_NR_ADDR_BASE_Y_SHD),
2972
-			 readl(base + RKISPP_SHARP_WR_Y_BASE_SHD));
2973
-
2974
-		for (val = STREAM_S0; val <= STREAM_S2 && !is_fec_en; val++) {
2975
-			stream = &vdev->stream[val];
2976
-			/* check scale stream stop state */
2977
-			if (stream->streaming && stream->stopping) {
2978
-				if (stream->ops->is_stopped(stream)) {
2979
-					stream->stopping = false;
2980
-					stream->streaming = false;
2981
-					wake_up(&stream->done);
2982
-				} else {
2983
-					stream->ops->stop(stream);
2984
-				}
2985
-			}
2986
-		}
2987
-
2988
-		vdev->nr.dbg.id = seq;
2989
-		vdev->nr.dbg.timestamp = ktime_get_ns();
2990
-		if (monitor->is_en) {
2991
-			monitor->nr.time = vdev->nr.dbg.interval / 1000 / 1000;
2992
-			monitor->monitoring_module |= MONITOR_NR;
2993
-			monitor->nr.is_err = false;
2994
-			if (!completion_done(&monitor->nr.cmpl))
2995
-				complete(&monitor->nr.cmpl);
2996
-		}
2997
-
2998
-		if (rkispp_is_reg_withstream_global())
2999
-			rkispp_find_regbuf_by_id(dev, &reg_buf, dev->dev_id, seq);
3000
-		if (reg_buf && (rkispp_debug_reg & ISPP_MODULE_NR)) {
3001
-			u32 offset, size;
3002
-
3003
-			offset = reg_buf->reg_size;
3004
-			size = 4 + RKISPP_NR_BUFFER_READY - RKISPP_NR_CTRL;
3005
-			reg_buf->ispp_size[ISPP_ID_NR] = size;
3006
-			reg_buf->ispp_offset[ISPP_ID_NR] = offset;
3007
-			memcpy_fromio(&reg_buf->reg[offset], base + RKISPP_NR_CTRL, size);
3008
-
3009
-			offset += size;
3010
-			reg_buf->reg_size = offset;
3011
-		}
3012
-		if (reg_buf && (rkispp_debug_reg & ISPP_MODULE_SHP)) {
3013
-			u32 offset, size;
3014
-
3015
-			offset = reg_buf->reg_size;
3016
-			size = 4 + RKISPP_SHARP_GRAD_RATIO - RKISPP_SHARP_CTRL;
3017
-			reg_buf->ispp_size[ISPP_ID_SHP] = size;
3018
-			reg_buf->ispp_offset[ISPP_ID_SHP] = offset;
3019
-			memcpy_fromio(&reg_buf->reg[offset], base + RKISPP_SHARP_CTRL, size);
3020
-
3021
-			offset += size;
3022
-			reg_buf->reg_size = offset;
3023
-		}
3024
-		if (reg_buf && (rkispp_debug_reg & ISPP_MODULE_ORB)) {
3025
-			u32 offset, size;
3026
-
3027
-			offset = reg_buf->reg_size;
3028
-			size = 4 + RKISPP_ORB_MAX_FEATURE - RKISPP_ORB_WR_BASE;
3029
-			reg_buf->ispp_size[ISPP_ID_ORB] = size;
3030
-			reg_buf->ispp_offset[ISPP_ID_ORB] = offset;
3031
-			memcpy_fromio(&reg_buf->reg[offset], base + RKISPP_ORB_WR_BASE, size);
3032
-
3033
-			offset += size;
3034
-			reg_buf->reg_size = offset;
3035
-		}
3036
-
3037
-		if (!is_quick && !dev->hw_dev->is_shutdown) {
3038
-			writel(NR_SHP_ST, base + RKISPP_CTRL_STRT);
3039
-
3040
-			if (!is_fec_en && vdev->is_done_early)
3041
-				hrtimer_start(&vdev->frame_qst,
3042
-					      ns_to_ktime(1000000),
3043
-					      HRTIMER_MODE_REL);
3044
-		}
3045
-		vdev->nr.is_end = false;
3046
-	}
3047
-restart_unlock:
3048
-	spin_unlock_irqrestore(&monitor->lock, lock_flags1);
3049
-end:
3050
-	/* nr_shp->fec->scl
3051
-	 * fec start working should after nr
3052
-	 * for scl will update by OTHER_FORCE_UPD
3053
-	 */
3054
-	if (buf_to_fec) {
3055
-		if ((vdev->module_ens & ISPP_MODULE_FEC_ST) == ISPP_MODULE_FEC_ST) {
3056
-			rkispp_finish_buffer(dev, buf_to_fec);
3057
-			list_add_tail(&buf_to_fec->list, &dev->stream_vdev.nr.list_rpt);
3058
-			buf_to_fec = NULL;
3059
-		}
3060
-		rkispp_module_work_event(dev, buf_to_fec, NULL, ISPP_MODULE_FEC, false);
3061
-	} else if (!list_empty(&vdev->fec.list_rd) && is_fec_event) {
3062
-		rkispp_module_work_event(dev, NULL, NULL, ISPP_MODULE_FEC, false);
3063
-	}
3064
-	spin_unlock_irqrestore(&vdev->nr.buf_lock, lock_flags);
3065
-
3066
-	if (is_fec_en && vdev->is_done_early &&
3067
-	    is_start && !dev->hw_dev->is_first &&
3068
-	    (vdev->module_ens & ISPP_MODULE_FEC_ST) != ISPP_MODULE_FEC_ST)
3069
-		hrtimer_start(&vdev->fec_qst,
3070
-			      ns_to_ktime(1000000),
3071
-			      HRTIMER_MODE_REL);
3072
-}
3073
-
3074
-static void tnr_work_event(struct rkispp_device *dev,
3075
-			   struct rkisp_ispp_buf *buf_rd,
3076
-			   struct rkisp_ispp_buf *buf_wr,
3077
-			   bool is_isr)
3078
-{
3079
-	struct rkispp_stream_vdev *vdev = &dev->stream_vdev;
3080
-	struct rkispp_stream *stream = &vdev->stream[STREAM_II];
3081
-	struct rkispp_monitor *monitor = &vdev->monitor;
3082
-	void __iomem *base = dev->hw_dev->base_addr;
3083
-	struct rkispp_dummy_buffer *dummy;
3084
-	struct rkispp_buffer *inbuf;
3085
-	struct v4l2_subdev *sd = NULL;
3086
-	struct list_head *list;
3087
-	struct dma_buf *dbuf;
3088
-	unsigned long lock_flags = 0, lock_flags1 = 0;
3089
-	u32 val, size = sizeof(vdev->tnr.buf) / sizeof(*dummy);
3090
-	bool is_en, is_3to1 = vdev->tnr.is_3to1, is_start = false;
3091
-	struct rkisp_ispp_reg *reg_buf = NULL;
3092
-
3093
-	if (!(vdev->module_ens & ISPP_MODULE_TNR) ||
3094
-	    (dev->inp == INP_ISP && dev->isp_mode & ISP_ISPP_QUICK))
3095
-		return;
3096
-
3097
-	if (dev->inp == INP_ISP)
3098
-		sd = dev->ispp_sdev.remote_sd;
3099
-
3100
-	if (buf_rd)
3101
-		rkispp_params_cfg(&dev->params_vdev[PARAM_VDEV_TNR], buf_rd->frame_id);
3102
-
3103
-	is_en = rkispp_read(dev, RKISPP_TNR_CORE_CTRL) & SW_TNR_EN;
3104
-
3105
-	spin_lock_irqsave(&vdev->tnr.buf_lock, lock_flags);
3106
-
3107
-	/* event from tnr frame end */
3108
-	if (!buf_rd && !buf_wr && is_isr) {
3109
-		vdev->tnr.is_end = true;
3110
-
3111
-		if (vdev->tnr.cur_rd) {
3112
-			/* tnr read buf return to isp */
3113
-			if (sd) {
3114
-				v4l2_subdev_call(sd, video, s_rx_buffer, vdev->tnr.cur_rd, NULL);
3115
-			} else if (stream->streaming && vdev->tnr.cur_rd->priv) {
3116
-				inbuf = vdev->tnr.cur_rd->priv;
3117
-				vb2_buffer_done(&inbuf->vb.vb2_buf, VB2_BUF_STATE_DONE);
3118
-			}
3119
-			if (vdev->tnr.cur_rd == vdev->tnr.nxt_rd)
3120
-				vdev->tnr.nxt_rd = NULL;
3121
-			vdev->tnr.cur_rd = NULL;
3122
-		}
3123
-
3124
-		if (vdev->tnr.cur_wr) {
3125
-
3126
-			if (!vdev->tnr.cur_wr->is_move_judge || !vdev->tnr.is_trigger) {
3127
-				/* tnr write buf to nr */
3128
-				rkispp_module_work_event(dev, vdev->tnr.cur_wr, NULL,
3129
-							 ISPP_MODULE_NR, is_isr);
3130
-			} else {
3131
-				dbuf = vdev->tnr.cur_wr->dbuf[GROUP_BUF_GAIN];
3132
-				dummy = dbuf_to_dummy(dbuf, &vdev->tnr.buf.iir, size);
3133
-				rkispp_finish_buffer(dev, dummy);
3134
-				rkispp_finish_buffer(dev, &vdev->tnr.buf.gain_kg);
3135
-				list_add_tail(&vdev->tnr.cur_wr->list, &vdev->tnr.list_rpt);
3136
-			}
3137
-			vdev->tnr.cur_wr = NULL;
3138
-		}
3139
-	}
3140
-
3141
-	if (!is_en) {
3142
-		if (buf_wr)
3143
-			list_add_tail(&buf_wr->list, &vdev->tnr.list_wr);
3144
-
3145
-		if (vdev->tnr.nxt_rd) {
3146
-			if (sd) {
3147
-				v4l2_subdev_call(sd, video, s_rx_buffer,
3148
-						 vdev->tnr.nxt_rd, NULL);
3149
-			} else if (stream->streaming && vdev->tnr.nxt_rd->priv) {
3150
-				inbuf = vdev->tnr.nxt_rd->priv;
3151
-				vb2_buffer_done(&inbuf->vb.vb2_buf, VB2_BUF_STATE_DONE);
3152
-			}
3153
-			vdev->tnr.nxt_rd = NULL;
3154
-		}
3155
-		list = &vdev->tnr.list_rd;
3156
-		while (!list_empty(list)) {
3157
-			struct rkisp_ispp_buf *buf = get_list_buf(list, true);
3158
-
3159
-			rkispp_module_work_event(dev, buf, NULL,
3160
-						 ISPP_MODULE_NR, is_isr);
3161
-		}
3162
-		if (buf_rd)
3163
-			rkispp_module_work_event(dev, buf_rd, NULL,
3164
-						 ISPP_MODULE_NR, is_isr);
3165
-		goto end;
3166
-	}
3167
-
3168
-	spin_lock_irqsave(&monitor->lock, lock_flags1);
3169
-	if (monitor->is_restart) {
3170
-		if (buf_rd)
3171
-			list_add_tail(&buf_rd->list, &vdev->tnr.list_rd);
3172
-		if (buf_wr)
3173
-			list_add_tail(&buf_wr->list, &vdev->tnr.list_wr);
3174
-		goto restart_unlock;
3175
-	}
3176
-
3177
-	list = &vdev->tnr.list_rd;
3178
-	if (buf_rd && vdev->tnr.is_end && list_empty(list)) {
3179
-		/* tnr read buf from isp */
3180
-		vdev->tnr.cur_rd = vdev->tnr.nxt_rd;
3181
-		vdev->tnr.nxt_rd = buf_rd;
3182
-		/* first buf for 3to1 using twice */
3183
-		if (!is_3to1 ||
3184
-		    (rkispp_read(dev, RKISPP_TNR_CTRL) & SW_TNR_1ST_FRM))
3185
-			vdev->tnr.cur_rd = vdev->tnr.nxt_rd;
3186
-	} else if (vdev->tnr.is_end && !list_empty(list)) {
3187
-		/* tnr read buf from list
3188
-		 * tnr processing slow than isp
3189
-		 * new read buf from isp into list
3190
-		 */
3191
-		vdev->tnr.cur_rd = vdev->tnr.nxt_rd;
3192
-		vdev->tnr.nxt_rd = get_list_buf(list, true);
3193
-		if (!is_3to1)
3194
-			vdev->tnr.cur_rd = vdev->tnr.nxt_rd;
3195
-
3196
-		if (buf_rd)
3197
-			list_add_tail(&buf_rd->list, list);
3198
-	} else if (!vdev->tnr.is_end && buf_rd) {
3199
-		/* tnr no idle
3200
-		 * new read buf from isp into list
3201
-		 */
3202
-		list_add_tail(&buf_rd->list, list);
3203
-	}
3204
-
3205
-	list = &vdev->tnr.list_wr;
3206
-	if (vdev->tnr.is_end && !vdev->tnr.cur_wr) {
3207
-		/* tnr idle, get new write buf */
3208
-		vdev->tnr.cur_wr =
3209
-			buf_wr ? buf_wr : get_list_buf(list, true);
3210
-	} else if (buf_wr) {
3211
-		/* tnr no idle, write buf from nr into list */
3212
-		list_add_tail(&buf_wr->list, list);
3213
-	}
3214
-
3215
-	if (vdev->tnr.cur_rd && vdev->tnr.nxt_rd && vdev->tnr.is_end) {
3216
-		if (vdev->tnr.cur_rd->priv) {
3217
-			inbuf = vdev->tnr.cur_rd->priv;
3218
-			val = inbuf->buff_addr[RKISPP_PLANE_Y];
3219
-			rkispp_write(dev, RKISPP_TNR_CUR_Y_BASE, val);
3220
-			val = inbuf->buff_addr[RKISPP_PLANE_UV];
3221
-			rkispp_write(dev, RKISPP_TNR_CUR_UV_BASE, val);
3222
-		} else {
3223
-			struct rkispp_isp_buf_pool *buf;
3224
-
3225
-			buf = get_pool_buf(dev, vdev->tnr.cur_rd);
3226
-			val = buf->dma[GROUP_BUF_PIC];
3227
-			rkispp_write(dev, RKISPP_TNR_CUR_Y_BASE, val);
3228
-			val += vdev->tnr.uv_offset;
3229
-			rkispp_write(dev, RKISPP_TNR_CUR_UV_BASE, val);
3230
-
3231
-			val = buf->dma[GROUP_BUF_GAIN];
3232
-			rkispp_write(dev, RKISPP_TNR_GAIN_CUR_Y_BASE, val);
3233
-			if (is_3to1) {
3234
-				buf = get_pool_buf(dev, vdev->tnr.nxt_rd);
3235
-				val = buf->dma[GROUP_BUF_PIC];
3236
-				rkispp_write(dev, RKISPP_TNR_NXT_Y_BASE, val);
3237
-				val += vdev->tnr.uv_offset;
3238
-				rkispp_write(dev, RKISPP_TNR_NXT_UV_BASE, val);
3239
-
3240
-				val = buf->dma[GROUP_BUF_GAIN];
3241
-				rkispp_write(dev, RKISPP_TNR_GAIN_NXT_Y_BASE, val);
3242
-
3243
-				if (rkispp_read(dev, RKISPP_TNR_CTRL) & SW_TNR_1ST_FRM)
3244
-					vdev->tnr.cur_rd = NULL;
3245
-			}
3246
-		}
3247
-		is_start = true;
3248
-	}
3249
-
3250
-	if (vdev->tnr.cur_wr && is_start) {
3251
-		dbuf = vdev->tnr.cur_wr->dbuf[GROUP_BUF_PIC];
3252
-		dummy = dbuf_to_dummy(dbuf, &vdev->tnr.buf.iir, size);
3253
-		val = dummy->dma_addr;
3254
-		rkispp_write(dev, RKISPP_TNR_WR_Y_BASE, val);
3255
-		val += vdev->tnr.uv_offset;
3256
-		rkispp_write(dev, RKISPP_TNR_WR_UV_BASE, val);
3257
-
3258
-		dbuf = vdev->tnr.cur_wr->dbuf[GROUP_BUF_GAIN];
3259
-		dummy = dbuf_to_dummy(dbuf, &vdev->tnr.buf.iir, size);
3260
-		val = dummy->dma_addr;
3261
-		rkispp_write(dev, RKISPP_TNR_GAIN_WR_Y_BASE, val);
3262
-	}
3263
-
3264
-	if (is_start) {
3265
-		u32 seq = 0;
3266
-
3267
-		if (vdev->tnr.nxt_rd) {
3268
-			seq = vdev->tnr.nxt_rd->frame_id;
3269
-			if (vdev->tnr.cur_wr) {
3270
-				vdev->tnr.cur_wr->frame_id = seq;
3271
-				vdev->tnr.cur_wr->frame_timestamp =
3272
-					vdev->tnr.nxt_rd->frame_timestamp;
3273
-				vdev->tnr.cur_wr->is_move_judge =
3274
-					vdev->tnr.nxt_rd->is_move_judge;
3275
-			}
3276
-			dev->stats_vdev[STATS_VDEV_TNR].frame_id = seq;
3277
-		}
3278
-
3279
-		if (!dev->hw_dev->is_single)
3280
-			rkispp_update_regs(dev, RKISPP_CTRL, RKISPP_TNR_CORE_WEIGHT);
3281
-		writel(TNR_FORCE_UPD, base + RKISPP_CTRL_UPDATE);
3282
-
3283
-		v4l2_dbg(3, rkispp_debug, &dev->v4l2_dev,
3284
-			 "TNR start seq:%d | Y_SHD nxt:0x%x cur:0x%x iir:0x%x wr:0x%x\n",
3285
-			 seq, readl(base + RKISPP_TNR_NXT_Y_BASE_SHD),
3286
-			 readl(base + RKISPP_TNR_CUR_Y_BASE_SHD),
3287
-			 readl(base + RKISPP_TNR_IIR_Y_BASE_SHD),
3288
-			 readl(base + RKISPP_TNR_WR_Y_BASE_SHD));
3289
-
3290
-		/* iir using previous tnr write frame */
3291
-		rkispp_write(dev, RKISPP_TNR_IIR_Y_BASE,
3292
-			     rkispp_read(dev, RKISPP_TNR_WR_Y_BASE));
3293
-		rkispp_write(dev, RKISPP_TNR_IIR_UV_BASE,
3294
-			     rkispp_read(dev, RKISPP_TNR_WR_UV_BASE));
3295
-
3296
-		rkispp_prepare_buffer(dev, &vdev->tnr.buf.gain_kg);
3297
-
3298
-		vdev->tnr.dbg.id = seq;
3299
-		vdev->tnr.dbg.timestamp = ktime_get_ns();
3300
-		if (monitor->is_en) {
3301
-			monitor->tnr.time = vdev->tnr.dbg.interval / 1000 / 1000;
3302
-			monitor->monitoring_module |= MONITOR_TNR;
3303
-			monitor->tnr.is_err = false;
3304
-			if (!completion_done(&monitor->tnr.cmpl))
3305
-				complete(&monitor->tnr.cmpl);
3306
-		}
3307
-
3308
-		if (rkispp_is_reg_withstream_global())
3309
-			rkispp_find_regbuf_by_id(dev, &reg_buf, dev->dev_id, seq);
3310
-		if (reg_buf && (rkispp_debug_reg & ISPP_MODULE_TNR)) {
3311
-			u32 offset, size;
3312
-
3313
-			offset = reg_buf->reg_size;
3314
-			size = 4 + RKISPP_TNR_STATE - RKISPP_TNR_CTRL;
3315
-			reg_buf->ispp_size[ISPP_ID_TNR] = size;
3316
-			reg_buf->ispp_offset[ISPP_ID_TNR] = offset;
3317
-			memcpy_fromio(&reg_buf->reg[offset], base + RKISPP_TNR_CTRL, size);
3318
-
3319
-			offset += size;
3320
-			reg_buf->reg_size = offset;
3321
-		}
3322
-
3323
-		if (!dev->hw_dev->is_shutdown)
3324
-			writel(TNR_ST, base + RKISPP_CTRL_STRT);
3325
-		vdev->tnr.is_end = false;
3326
-	}
3327
-
3328
-restart_unlock:
3329
-	spin_unlock_irqrestore(&monitor->lock, lock_flags1);
3330
-end:
3331
-	spin_unlock_irqrestore(&vdev->tnr.buf_lock, lock_flags);
3332
-}
3333
-
3334
-int rkispp_get_tnrbuf_fd(struct rkispp_device *dev, struct rkispp_buf_idxfd *idxfd)
3335
-{
3336
-	struct rkispp_stream_vdev *vdev = &dev->stream_vdev;
3337
-	struct rkisp_ispp_buf *dbufs;
3338
-	struct rkispp_dummy_buffer *buf;
3339
-	unsigned long lock_flags = 0;
3340
-	int j, buf_idx, ret = 0;
3341
-
3342
-	spin_lock_irqsave(&vdev->tnr.buf_lock, lock_flags);
3343
-	if (!vdev->tnr.is_buf_init) {
3344
-		spin_unlock_irqrestore(&vdev->tnr.buf_lock, lock_flags);
3345
-		ret = -EAGAIN;
3346
-		return ret;
3347
-	}
3348
-	spin_unlock_irqrestore(&vdev->tnr.buf_lock, lock_flags);
3349
-
3350
-	buf_idx = 0;
3351
-	list_for_each_entry(dbufs, &vdev->tnr.list_wr, list) {
3352
-		for (j = 0; j < GROUP_BUF_MAX; j++) {
3353
-			dbufs->dfd[j] = dma_buf_fd(dbufs->dbuf[j], O_CLOEXEC);
3354
-			get_dma_buf(dbufs->dbuf[j]);
3355
-			idxfd->index[buf_idx] = dbufs->didx[j];
3356
-			idxfd->dmafd[buf_idx] = dbufs->dfd[j];
3357
-			buf_idx++;
3358
-		}
3359
-	}
3360
-
3361
-	list_for_each_entry(dbufs, &vdev->tnr.list_rpt, list) {
3362
-		for (j = 0; j < GROUP_BUF_MAX; j++) {
3363
-			dbufs->dfd[j] = dma_buf_fd(dbufs->dbuf[j], O_CLOEXEC);
3364
-			get_dma_buf(dbufs->dbuf[j]);
3365
-			idxfd->index[buf_idx] = dbufs->didx[j];
3366
-			idxfd->dmafd[buf_idx] = dbufs->dfd[j];
3367
-			buf_idx++;
3368
-		}
3369
-	}
3370
-
3371
-	if (vdev->tnr.cur_wr) {
3372
-		for (j = 0; j < GROUP_BUF_MAX; j++) {
3373
-			vdev->tnr.cur_wr->dfd[j] = dma_buf_fd(vdev->tnr.cur_wr->dbuf[j], O_CLOEXEC);
3374
-			get_dma_buf(vdev->tnr.cur_wr->dbuf[j]);
3375
-			idxfd->index[buf_idx] = vdev->tnr.cur_wr->didx[j];
3376
-			idxfd->dmafd[buf_idx] = vdev->tnr.cur_wr->dfd[j];
3377
-			buf_idx++;
3378
-		}
3379
-	}
3380
-
3381
-	buf = &vdev->tnr.buf.gain_kg;
3382
-	buf->dma_fd = dma_buf_fd(buf->dbuf, O_CLOEXEC);
3383
-	get_dma_buf(buf->dbuf);
3384
-	idxfd->index[buf_idx] = buf->index;
3385
-	idxfd->dmafd[buf_idx] = buf->dma_fd;
3386
-	buf_idx++;
3387
-
3388
-	idxfd->buf_num = buf_idx;
3389
-
3390
-	return ret;
3391
-}
3392
-
3393
-int rkispp_get_nrbuf_fd(struct rkispp_device *dev, struct rkispp_buf_idxfd *idxfd)
3394
-{
3395
-	struct rkispp_stream_vdev *vdev = &dev->stream_vdev;
3396
-	struct rkispp_dummy_buffer *buf;
3397
-	unsigned long lock_flags = 0;
3398
-	int i, ret = 0;
3399
-
3400
-	spin_lock_irqsave(&vdev->nr.buf_lock, lock_flags);
3401
-	if (!vdev->nr.is_buf_init) {
3402
-		spin_unlock_irqrestore(&vdev->nr.buf_lock, lock_flags);
3403
-		ret = -EAGAIN;
3404
-		return ret;
3405
-	}
3406
-	spin_unlock_irqrestore(&vdev->nr.buf_lock, lock_flags);
3407
-
3408
-	for (i = 0; i < RKISPP_FEC_BUF_MAX; i++) {
3409
-		buf = &vdev->nr.buf.wr[i];
3410
-		if (!buf->dbuf)
3411
-			break;
3412
-		buf->dma_fd = dma_buf_fd(buf->dbuf, O_CLOEXEC);
3413
-		get_dma_buf(buf->dbuf);
3414
-		idxfd->index[i] = i;
3415
-		idxfd->dmafd[i] = buf->dma_fd;
3416
-	}
3417
-	idxfd->buf_num = i;
3418
-	return ret;
3419
-}
3420
-
3421
-void rkispp_set_trigger_mode(struct rkispp_device *dev,
3422
-			     struct rkispp_trigger_mode *mode)
3423
-{
3424
-	struct rkispp_stream_vdev *vdev = &dev->stream_vdev;
3425
-
3426
-	if (mode->module & ISPP_MODULE_TNR)
3427
-		vdev->tnr.is_trigger = mode->on;
3428
-}
3429
-
3430
-void rkispp_module_work_event(struct rkispp_device *dev,
3431
-			      void *buf_rd, void *buf_wr,
3432
-			      u32 module, bool is_isr)
3433
-{
3434
-	struct rkispp_stream_vdev *vdev = &dev->stream_vdev;
3435
-	bool is_fec_en = !!(vdev->module_ens & ISPP_MODULE_FEC);
3436
-	bool is_single = dev->hw_dev->is_single;
3437
-	//bool is_early = vdev->is_done_early;
3438
-
3439
-	if (dev->hw_dev->is_shutdown)
3440
-		return;
3441
-
3442
-	if (dev->ispp_sdev.state != ISPP_STOP) {
3443
-		if (module & ISPP_MODULE_TNR)
3444
-			tnr_work_event(dev, buf_rd, buf_wr, is_isr);
3445
-		else if (module & ISPP_MODULE_NR)
3446
-			nr_work_event(dev, buf_rd, buf_wr, is_isr);
3447
-		else
3448
-			fec_work_event(dev, buf_rd, is_isr, false);
3449
-	}
3450
-
3451
-	/*
3452
-	 * ispp frame done to do next conditions
3453
-	 * mulit dev: cur frame (tnr->nr->fec) done for next frame
3454
-	 * 1.single dev: fec async with tnr, and sync with nr:
3455
-	 *   {    f0    }
3456
-	 *   tnr->nr->fec->|
3457
-	 *          |->tnr->nr->fec
3458
-	 *             {    f1    }
3459
-	 * 2.single dev and early mode:
3460
-	 *   {  f0 }  {  f1 }  {  f2 }
3461
-	 *   tnr->nr->tnr->nr->tnr->nr
3462
-	 *        |->fec->||->fec->|
3463
-	 *        {   f0  }{   f1  }
3464
-	 */
3465
-	if (is_isr && !buf_rd && !buf_wr &&
3466
-	    ((!is_fec_en && module == ISPP_MODULE_NR) ||
3467
-	     (is_fec_en &&
3468
-	      ((module == ISPP_MODULE_NR && (is_single ||
3469
-		vdev->fec.is_end)) ||
3470
-	       (module == ISPP_MODULE_FEC && !is_single && vdev->fec.is_end))))) {
3471
-		dev->stream_vdev.monitor.retry = 0;
3472
-		rkispp_soft_reset(dev->hw_dev);
3473
-		rkispp_event_handle(dev, CMD_QUEUE_DMABUF, NULL);
3474
-	}
3475
-
3476
-	if (dev->ispp_sdev.state == ISPP_STOP) {
3477
-		if ((module & (ISPP_MODULE_TNR | ISPP_MODULE_NR)) && buf_rd) {
3478
-			struct rkisp_ispp_buf *buf = buf_rd;
3479
-
3480
-			if (buf->is_isp)
3481
-				v4l2_subdev_call(dev->ispp_sdev.remote_sd,
3482
-						 video, s_rx_buffer, buf, NULL);
3483
-		}
3484
-		if (!dev->hw_dev->is_idle)
3485
-			dev->hw_dev->is_idle = true;
3486
-	}
34871835 }
34881836 
34891837 void rkispp_isr(u32 mis_val, struct rkispp_device *dev)
....@@ -3573,7 +1921,7 @@
35731921 		INIT_WORK(&dev->irq_work, irq_work);
35741922 		schedule_work(&dev->irq_work);
35751923 	} else {
3576
-		check_to_force_update(dev, mis_val);
1924
+		vdev->stream_ops->check_to_force_update(dev, mis_val);
35771925 	}
35781926 }
35791927 
....@@ -3601,12 +1949,20 @@
36011949 	stream_vdev->tnr.is_buf_init = false;
36021950 	stream_vdev->nr.is_buf_init = false;
36031951 
3604
-	hrtimer_init(&stream_vdev->fec_qst, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
3605
-	stream_vdev->fec_qst.function = rkispp_fec_do_early;
3606
-	hrtimer_init(&stream_vdev->frame_qst, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
3607
-	stream_vdev->frame_qst.function = rkispp_frame_done_early;
3608
-
3609
-	for (i = 0; i < STREAM_MAX; i++) {
1952
+	if (dev->ispp_ver == ISPP_V10) {
1953
+		dev->stream_max = STREAM_MAX;
1954
+		rkispp_stream_init_ops_v10(stream_vdev);
1955
+		hrtimer_init(&stream_vdev->fec_qst, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
1956
+		stream_vdev->fec_qst.function = rkispp_fec_do_early;
1957
+		hrtimer_init(&stream_vdev->frame_qst, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
1958
+		stream_vdev->frame_qst.function = stream_vdev->stream_ops->rkispp_frame_done_early;
1959
+		dev->hw_dev->pool[0].group_buf_max = GROUP_BUF_MAX;
1960
+	} else if (dev->ispp_ver == ISPP_V20) {
1961
+		dev->stream_max = STREAM_VIR + 1;
1962
+		rkispp_stream_init_ops_v20(stream_vdev);
1963
+		dev->hw_dev->pool[0].group_buf_max = GROUP_BUF_GAIN;
1964
+	}
1965
+	for (i = 0; i < dev->stream_max; i++) {
36101966 		stream = &stream_vdev->stream[i];
36111967 		stream->id = i;
36121968 		stream->isppdev = dev;
....@@ -3677,7 +2033,7 @@
36772033 	int i;
36782034 
36792035 	stream_vdev = &dev->stream_vdev;
3680
-	for (i = 0; i < STREAM_MAX; i++) {
2036
+	for (i = 0; i < dev->stream_max; i++) {
36812037 		stream = &stream_vdev->stream[i];
36822038 		rkispp_unregister_stream_video(stream);
36832039 	}