update kernel to 5.10.198

hc

2024-01-03 2f7c68cb55ecb7331f2381deb497c27155f32faf

 kernel/drivers/media/platform/rockchip/ispp/params.c
..
..
@@ -7,602 +7,13 @@
7
7
 #include <media/videobuf2-vmalloc.h>
8
8
 #include <media/v4l2-event.h>
9
9
 #include <media/v4l2-mc.h>
10
-#include <linux/rkisp1-config.h>
10
+#include <linux/rk-isp1-config.h>
11
+#include <uapi/linux/rk-video-format.h>
11
12
 #include "dev.h"
12
13
 #include "regs.h"
13
14
 
14
15
 #define RKISP1_ISP_PARAMS_REQ_BUFS_MIN	2
15
16
 #define RKISP1_ISP_PARAMS_REQ_BUFS_MAX	8
16
-
17
-#define ISPP_PACK_4BIT(a, b, c, d, e, f, g, h) \
18
-	(((a) & 0xf) << 0 | ((b) & 0xf) << 4 | \
19
-	 ((c) & 0xf) << 8 | ((d) & 0xf) << 12 | \
20
-	 ((e) & 0xf) << 16 | ((f) & 0xf) << 20 | \
21
-	 ((g) & 0xf) << 24 | ((h) & 0xf) << 28)
22
-
23
-#define ISPP_PACK_4BYTE(a, b, c, d) \
24
-	(((a) & 0xFF) << 0 | ((b) & 0xFF) << 8 | \
25
-	 ((c) & 0xFF) << 16 | ((d) & 0xFF) << 24)
26
-
27
-#define ISPP_PACK_2SHORT(a, b) \
28
-	(((a) & 0xFFFF) << 0 | ((b) & 0xFFFF) << 16)
29
-
30
-#define ISPP_NOBIG_OVERFLOW_SIZE	(2560 * 1440)
31
-
32
-static inline size_t get_input_size(struct rkispp_params_vdev *params_vdev)
33
-{
34
-	struct rkispp_device *dev = params_vdev->dev;
35
-	struct rkispp_subdev *isp_sdev = &dev->ispp_sdev;
36
-
37
-	return isp_sdev->out_fmt.width * isp_sdev->out_fmt.height;
38
-}
39
-
40
-static void tnr_config(struct rkispp_params_vdev *params_vdev,
41
-		       struct rkispp_tnr_config *arg)
42
-{
43
-	u32 i, val;
44
-
45
-	val = arg->opty_en << 2 | arg->optc_en << 3 |
46
-		arg->gain_en << 4;
47
-	rkispp_set_bits(params_vdev->dev, RKISPP_TNR_CORE_CTRL,
48
-			SW_TNR_OPTY_EN | SW_TNR_OPTC_EN |
49
-			SW_TNR_GLB_GAIN_EN, val);
50
-
51
-	val = ISPP_PACK_4BYTE(arg->pk0_y, arg->pk1_y,
52
-		arg->pk0_c, arg->pk1_c);
53
-	rkispp_write(params_vdev->dev, RKISPP_TNR_CORE_PK0, val);
54
-
55
-	val = ISPP_PACK_2SHORT(arg->glb_gain_cur, arg->glb_gain_nxt);
56
-	rkispp_write(params_vdev->dev, RKISPP_TNR_CORE_GLB_GAIN, val);
57
-	val = ISPP_PACK_2SHORT(arg->glb_gain_cur_div, arg->glb_gain_cur_sqrt);
58
-	rkispp_write(params_vdev->dev, RKISPP_TNR_CORE_GLB_GAIN_DIV, val);
59
-
60
-	for (i = 0; i < TNR_SIGMA_CURVE_SIZE - 1; i += 2)
61
-		rkispp_write(params_vdev->dev, RKISPP_TNR_CORE_SIG_Y01 + i * 2,
62
-			ISPP_PACK_2SHORT(arg->sigma_y[i], arg->sigma_y[i + 1]));
63
-	rkispp_write(params_vdev->dev, RKISPP_TNR_CORE_SIG_Y10, arg->sigma_y[16]);
64
-	rkispp_write(params_vdev->dev, RKISPP_TNR_CORE_SIG_X18,
65
-		ISPP_PACK_4BIT(arg->sigma_x[0], arg->sigma_x[1],
66
-			arg->sigma_x[2], arg->sigma_x[3],
67
-			arg->sigma_x[4], arg->sigma_x[5],
68
-			arg->sigma_x[6], arg->sigma_x[7]));
69
-	rkispp_write(params_vdev->dev, RKISPP_TNR_CORE_SIG_X910,
70
-		ISPP_PACK_4BIT(arg->sigma_x[8], arg->sigma_x[9],
71
-			arg->sigma_x[10], arg->sigma_x[11],
72
-			arg->sigma_x[12], arg->sigma_x[13],
73
-			arg->sigma_x[14], arg->sigma_x[15]));
74
-
75
-	for (i = 0; i < TNR_LUMA_CURVE_SIZE; i += 2) {
76
-		val = ISPP_PACK_2SHORT(arg->luma_curve[i], arg->luma_curve[i + 1]);
77
-		rkispp_write(params_vdev->dev, RKISPP_TNR_CORE_LUMACURVE_Y01 + i * 2, val);
78
-	}
79
-
80
-	val = ISPP_PACK_2SHORT(arg->txt_th0_y, arg->txt_th1_y);
81
-	rkispp_write(params_vdev->dev, RKISPP_TNR_CORE_TH_Y, val);
82
-	val = ISPP_PACK_2SHORT(arg->txt_th0_c, arg->txt_th1_c);
83
-	rkispp_write(params_vdev->dev, RKISPP_TNR_CORE_TH_C, val);
84
-	val = ISPP_PACK_2SHORT(arg->txt_thy_dlt, arg->txt_thc_dlt);
85
-	rkispp_write(params_vdev->dev, RKISPP_TNR_CORE_TH_DLT, val);
86
-
87
-	val = ISPP_PACK_4BYTE(arg->gfcoef_y0[0], arg->gfcoef_y0[1],
88
-		arg->gfcoef_y0[2], arg->gfcoef_y0[3]);
89
-	rkispp_write(params_vdev->dev, RKISPP_TNR_CORE_GFCOEF_Y0_0, val);
90
-	val = ISPP_PACK_4BYTE(arg->gfcoef_y0[4], arg->gfcoef_y0[5], 0, 0);
91
-	rkispp_write(params_vdev->dev, RKISPP_TNR_CORE_GFCOEF_Y0_1, val);
92
-	val = ISPP_PACK_4BYTE(arg->gfcoef_y1[0], arg->gfcoef_y1[1],
93
-		arg->gfcoef_y1[2], 0);
94
-	rkispp_write(params_vdev->dev, RKISPP_TNR_CORE_GFCOEF_Y1, val);
95
-	val = ISPP_PACK_4BYTE(arg->gfcoef_y2[0], arg->gfcoef_y2[1],
96
-		arg->gfcoef_y2[2], 0);
97
-	rkispp_write(params_vdev->dev, RKISPP_TNR_CORE_GFCOEF_Y2, val);
98
-	val = ISPP_PACK_4BYTE(arg->gfcoef_y3[0], arg->gfcoef_y3[1],
99
-		arg->gfcoef_y3[2], 0);
100
-	rkispp_write(params_vdev->dev, RKISPP_TNR_CORE_GFCOEF_Y3, val);
101
-
102
-	val = ISPP_PACK_4BYTE(arg->gfcoef_yg0[0], arg->gfcoef_yg0[1],
103
-		arg->gfcoef_yg0[2], arg->gfcoef_yg0[3]);
104
-	rkispp_write(params_vdev->dev, RKISPP_TNR_CORE_GFCOEF_YG0_0, val);
105
-	val = ISPP_PACK_4BYTE(arg->gfcoef_yg0[4], arg->gfcoef_yg0[5], 0, 0);
106
-	rkispp_write(params_vdev->dev, RKISPP_TNR_CORE_GFCOEF_YG0_1, val);
107
-	val = ISPP_PACK_4BYTE(arg->gfcoef_yg1[0], arg->gfcoef_yg1[1],
108
-		arg->gfcoef_yg1[2], 0);
109
-	rkispp_write(params_vdev->dev, RKISPP_TNR_CORE_GFCOEF_YG1, val);
110
-	val = ISPP_PACK_4BYTE(arg->gfcoef_yg2[0], arg->gfcoef_yg2[1],
111
-		arg->gfcoef_yg2[2], 0);
112
-	rkispp_write(params_vdev->dev, RKISPP_TNR_CORE_GFCOEF_YG2, val);
113
-	val = ISPP_PACK_4BYTE(arg->gfcoef_yg3[0], arg->gfcoef_yg3[1],
114
-		arg->gfcoef_yg3[2], 0);
115
-	rkispp_write(params_vdev->dev, RKISPP_TNR_CORE_GFCOEF_YG3, val);
116
-
117
-	val = ISPP_PACK_4BYTE(arg->gfcoef_yl0[0], arg->gfcoef_yl0[1],
118
-		arg->gfcoef_yl0[2], arg->gfcoef_yl0[3]);
119
-	rkispp_write(params_vdev->dev, RKISPP_TNR_CORE_GFCOEF_YL0_0, val);
120
-	val = ISPP_PACK_4BYTE(arg->gfcoef_yl0[4], arg->gfcoef_yl0[5], 0, 0);
121
-	rkispp_write(params_vdev->dev, RKISPP_TNR_CORE_GFCOEF_YL0_1, val);
122
-	val = ISPP_PACK_4BYTE(arg->gfcoef_yl1[0], arg->gfcoef_yl1[1],
123
-		arg->gfcoef_yl1[2], 0);
124
-	rkispp_write(params_vdev->dev, RKISPP_TNR_CORE_GFCOEF_YL1, val);
125
-	val = ISPP_PACK_4BYTE(arg->gfcoef_yl2[0], arg->gfcoef_yl2[1],
126
-		arg->gfcoef_yl2[2], 0);
127
-	rkispp_write(params_vdev->dev, RKISPP_TNR_CORE_GFCOEF_YL2, val);
128
-
129
-	val = ISPP_PACK_4BYTE(arg->gfcoef_cg0[0], arg->gfcoef_cg0[1],
130
-		arg->gfcoef_cg0[2], arg->gfcoef_cg0[3]);
131
-	rkispp_write(params_vdev->dev, RKISPP_TNR_CORE_GFCOEF_CG0_0, val);
132
-	val = ISPP_PACK_4BYTE(arg->gfcoef_cg0[4], arg->gfcoef_cg0[5], 0, 0);
133
-	rkispp_write(params_vdev->dev, RKISPP_TNR_CORE_GFCOEF_CG0_1, val);
134
-	val = ISPP_PACK_4BYTE(arg->gfcoef_cg1[0], arg->gfcoef_cg1[1],
135
-		arg->gfcoef_cg1[2], 0);
136
-	rkispp_write(params_vdev->dev, RKISPP_TNR_CORE_GFCOEF_CG1, val);
137
-	val = ISPP_PACK_4BYTE(arg->gfcoef_cg2[0], arg->gfcoef_cg2[1],
138
-		arg->gfcoef_cg2[2], 0);
139
-	rkispp_write(params_vdev->dev, RKISPP_TNR_CORE_GFCOEF_CG2, val);
140
-
141
-	val = ISPP_PACK_4BYTE(arg->gfcoef_cl0[0], arg->gfcoef_cl0[1],
142
-		arg->gfcoef_cl0[2], arg->gfcoef_cl0[3]);
143
-	rkispp_write(params_vdev->dev, RKISPP_TNR_CORE_GFCOEF_CL0_0, val);
144
-	val = ISPP_PACK_4BYTE(arg->gfcoef_cl0[4], arg->gfcoef_cl0[5], 0, 0);
145
-	rkispp_write(params_vdev->dev, RKISPP_TNR_CORE_GFCOEF_CL0_1, val);
146
-	val = ISPP_PACK_4BYTE(arg->gfcoef_cl1[0], arg->gfcoef_cl1[1],
147
-		arg->gfcoef_cl1[2], 0);
148
-	rkispp_write(params_vdev->dev, RKISPP_TNR_CORE_GFCOEF_CL1, val);
149
-
150
-	val = ISPP_PACK_2SHORT(arg->scale_yg[0], arg->scale_yg[1]);
151
-	rkispp_write(params_vdev->dev, RKISPP_TNR_CORE_SCALE_YG01, val);
152
-	val = ISPP_PACK_2SHORT(arg->scale_yg[2], arg->scale_yg[3]);
153
-	rkispp_write(params_vdev->dev, RKISPP_TNR_CORE_SCALE_YG23, val);
154
-	val = ISPP_PACK_2SHORT(arg->scale_yl[0], arg->scale_yl[1]);
155
-	rkispp_write(params_vdev->dev, RKISPP_TNR_CORE_SCALE_YL01, val);
156
-	rkispp_write(params_vdev->dev, RKISPP_TNR_CORE_SCALE_YL2, arg->scale_yl[2]);
157
-	val = ISPP_PACK_2SHORT(arg->scale_cg[0], arg->scale_y2cg[0]);
158
-	rkispp_write(params_vdev->dev, RKISPP_TNR_CORE_SCALE_CG0, val);
159
-	val = ISPP_PACK_2SHORT(arg->scale_cg[1], arg->scale_y2cg[1]);
160
-	rkispp_write(params_vdev->dev, RKISPP_TNR_CORE_SCALE_CG1, val);
161
-	val = ISPP_PACK_2SHORT(arg->scale_cg[2], arg->scale_y2cg[2]);
162
-	rkispp_write(params_vdev->dev, RKISPP_TNR_CORE_SCALE_CG2, val);
163
-	val = ISPP_PACK_2SHORT(arg->scale_cl[0], arg->scale_y2cl[0]);
164
-	rkispp_write(params_vdev->dev, RKISPP_TNR_CORE_SCALE_CL0, val);
165
-	val = ISPP_PACK_2SHORT(arg->scale_cl[1], arg->scale_y2cl[1]);
166
-	rkispp_write(params_vdev->dev, RKISPP_TNR_CORE_SCALE_CL1, val);
167
-	val = arg->scale_y2cl[2] << 16;
168
-	rkispp_write(params_vdev->dev, RKISPP_TNR_CORE_SCALE_CL2, val);
169
-	val = ISPP_PACK_4BYTE(arg->weight_y[0], arg->weight_y[1],
170
-		arg->weight_y[2], 0);
171
-	rkispp_write(params_vdev->dev, RKISPP_TNR_CORE_WEIGHT, val);
172
-}
173
-
174
-static bool is_tnr_enable(struct rkispp_params_vdev *params_vdev)
175
-{
176
-	u32 cur_en;
177
-
178
-	cur_en = rkispp_read(params_vdev->dev, RKISPP_TNR_CORE_CTRL);
179
-	cur_en &= SW_TNR_EN;
180
-
181
-	return (!!cur_en);
182
-}
183
-
184
-static void tnr_enable(struct rkispp_params_vdev *params_vdev, bool en)
185
-{
186
-	if (en && !is_tnr_enable(params_vdev))
187
-		rkispp_set_bits(params_vdev->dev, RKISPP_TNR_CTRL, 0, SW_TNR_1ST_FRM);
188
-	rkispp_set_bits(params_vdev->dev, RKISPP_TNR_CORE_CTRL, SW_TNR_EN, en);
189
-}
190
-
191
-static void nr_config(struct rkispp_params_vdev *params_vdev,
192
-		      struct rkispp_nr_config *arg)
193
-{
194
-	u32 i, val;
195
-	u8 big_en, nobig_en, sd32_self_en = 0;
196
-
197
-	rkispp_write(params_vdev->dev, RKISPP_NR_UVNR_GAIN_1SIGMA,
198
-		arg->uvnr_gain_1sigma);
199
-	rkispp_write(params_vdev->dev, RKISPP_NR_UVNR_GAIN_OFFSET,
200
-		arg->uvnr_gain_offset);
201
-	val = ISPP_PACK_4BYTE(arg->uvnr_gain_uvgain[0],
202
-		arg->uvnr_gain_uvgain[1], arg->uvnr_gain_t2gen,
203
-		arg->uvnr_gain_iso);
204
-	rkispp_write(params_vdev->dev, RKISPP_NR_UVNR_GAIN_GBLGAIN, val);
205
-	rkispp_write(params_vdev->dev, RKISPP_NR_UVNR_T1GEN_M3ALPHA,
206
-		arg->uvnr_t1gen_m3alpha);
207
-	rkispp_write(params_vdev->dev, RKISPP_NR_UVNR_T1FLT_MODE,
208
-		arg->uvnr_t1flt_mode);
209
-	rkispp_write(params_vdev->dev, RKISPP_NR_UVNR_T1FLT_MSIGMA,
210
-		arg->uvnr_t1flt_msigma);
211
-	rkispp_write(params_vdev->dev, RKISPP_NR_UVNR_T1FLT_WTP,
212
-		arg->uvnr_t1flt_wtp);
213
-	for (i = 0; i < NR_UVNR_T1FLT_WTQ_SIZE; i += 4) {
214
-		val = ISPP_PACK_4BYTE(arg->uvnr_t1flt_wtq[i],
215
-			arg->uvnr_t1flt_wtq[i + 1], arg->uvnr_t1flt_wtq[i + 2],
216
-			arg->uvnr_t1flt_wtq[i + 3]);
217
-		rkispp_write(params_vdev->dev, RKISPP_NR_UVNR_T1FLT_WTQ0 + i, val);
218
-	}
219
-	rkispp_write(params_vdev->dev, RKISPP_NR_UVNR_T2GEN_M3ALPHA,
220
-		arg->uvnr_t2gen_m3alpha);
221
-	rkispp_write(params_vdev->dev, RKISPP_NR_UVNR_T2GEN_MSIGMA,
222
-		arg->uvnr_t2gen_msigma);
223
-	rkispp_write(params_vdev->dev, RKISPP_NR_UVNR_T2GEN_WTP,
224
-		arg->uvnr_t2gen_wtp);
225
-	val = ISPP_PACK_4BYTE(arg->uvnr_t2gen_wtq[0],
226
-		arg->uvnr_t2gen_wtq[1], arg->uvnr_t2gen_wtq[2],
227
-		arg->uvnr_t2gen_wtq[3]);
228
-	rkispp_write(params_vdev->dev, RKISPP_NR_UVNR_T2GEN_WTQ, val);
229
-	rkispp_write(params_vdev->dev, RKISPP_NR_UVNR_T2FLT_MSIGMA,
230
-		arg->uvnr_t2flt_msigma);
231
-	val = ISPP_PACK_4BYTE(arg->uvnr_t2flt_wtp,
232
-		arg->uvnr_t2flt_wt[0], arg->uvnr_t2flt_wt[1],
233
-		arg->uvnr_t2flt_wt[2]);
234
-	rkispp_write(params_vdev->dev, RKISPP_NR_UVNR_T2FLT_WT, val);
235
-
236
-	val = ISPP_PACK_4BIT(arg->ynr_sgm_dx[0], arg->ynr_sgm_dx[1],
237
-		arg->ynr_sgm_dx[2], arg->ynr_sgm_dx[3],
238
-		arg->ynr_sgm_dx[4], arg->ynr_sgm_dx[5],
239
-		arg->ynr_sgm_dx[6], arg->ynr_sgm_dx[7]);
240
-	rkispp_write(params_vdev->dev, RKISPP_NR_YNR_SGM_DX_1_8, val);
241
-	val = ISPP_PACK_4BIT(arg->ynr_sgm_dx[8], arg->ynr_sgm_dx[9],
242
-		arg->ynr_sgm_dx[10], arg->ynr_sgm_dx[11],
243
-		arg->ynr_sgm_dx[12], arg->ynr_sgm_dx[13],
244
-		arg->ynr_sgm_dx[14], arg->ynr_sgm_dx[15]);
245
-	rkispp_write(params_vdev->dev, RKISPP_NR_YNR_SGM_DX_9_16, val);
246
-
247
-	for (i = 0; i < NR_YNR_SGM_Y_SIZE - 1; i += 2) {
248
-		rkispp_write(params_vdev->dev, RKISPP_NR_YNR_LSGM_Y_0_1 + i * 2,
249
-			ISPP_PACK_2SHORT(arg->ynr_lsgm_y[i], arg->ynr_lsgm_y[i + 1]));
250
-
251
-		rkispp_write(params_vdev->dev, RKISPP_NR_YNR_HSGM_Y_0_1 + i * 2,
252
-			ISPP_PACK_2SHORT(arg->ynr_hsgm_y[i], arg->ynr_hsgm_y[i + 1]));
253
-	}
254
-	rkispp_write(params_vdev->dev, RKISPP_NR_YNR_LSGM_Y_16, arg->ynr_lsgm_y[16]);
255
-	rkispp_write(params_vdev->dev, RKISPP_NR_YNR_HSGM_Y_16, arg->ynr_hsgm_y[16]);
256
-
257
-	val = ISPP_PACK_4BYTE(arg->ynr_lci[0], arg->ynr_lci[1],
258
-		arg->ynr_lci[2], arg->ynr_lci[3]);
259
-	rkispp_write(params_vdev->dev, RKISPP_NR_YNR_LCI, val);
260
-	val = ISPP_PACK_4BYTE(arg->ynr_lgain_min[0], arg->ynr_lgain_min[1],
261
-		arg->ynr_lgain_min[2], arg->ynr_lgain_min[3]);
262
-	rkispp_write(params_vdev->dev, RKISPP_NR_YNR_LGAIN_DIRE_MIN, val);
263
-	rkispp_write(params_vdev->dev, RKISPP_NR_YNR_IGAIN_DIRE_MAX, arg->ynr_lgain_max);
264
-	val = ISPP_PACK_4BYTE(arg->ynr_lmerge_bound, arg->ynr_lmerge_ratio, 0, 0);
265
-	rkispp_write(params_vdev->dev, RKISPP_NR_YNR_LMERGE, val);
266
-	val = ISPP_PACK_4BYTE(arg->ynr_lweit_flt[0], arg->ynr_lweit_flt[1],
267
-		arg->ynr_lweit_flt[2], arg->ynr_lweit_flt[3]);
268
-	rkispp_write(params_vdev->dev, RKISPP_NR_YNR_LWEIT_FLT, val);
269
-	val = ISPP_PACK_4BYTE(arg->ynr_hlci[0], arg->ynr_hlci[1],
270
-		arg->ynr_hlci[2], arg->ynr_hlci[3]);
271
-	rkispp_write(params_vdev->dev, RKISPP_NR_YNR_HLCI, val);
272
-	val = ISPP_PACK_4BYTE(arg->ynr_lhci[0], arg->ynr_lhci[1],
273
-		arg->ynr_lhci[2], arg->ynr_lhci[3]);
274
-	rkispp_write(params_vdev->dev, RKISPP_NR_YNR_LHCI, val);
275
-	val = ISPP_PACK_4BYTE(arg->ynr_hhci[0], arg->ynr_hhci[1],
276
-		arg->ynr_hhci[2], arg->ynr_hhci[3]);
277
-	rkispp_write(params_vdev->dev, RKISPP_NR_YNR_HHCI, val);
278
-	val = ISPP_PACK_4BYTE(arg->ynr_hgain_sgm[0], arg->ynr_hgain_sgm[1],
279
-		arg->ynr_hgain_sgm[2], arg->ynr_hgain_sgm[3]);
280
-	rkispp_write(params_vdev->dev, RKISPP_NR_YNR_HGAIN_SGM, val);
281
-
282
-	for (i = 0; i < NR_YNR_HWEIT_D_SIZE; i += 4) {
283
-		val = ISPP_PACK_4BYTE(arg->ynr_hweit_d[i], arg->ynr_hweit_d[i + 1],
284
-			arg->ynr_hweit_d[i + 2], arg->ynr_hweit_d[i + 3]);
285
-		rkispp_write(params_vdev->dev, RKISPP_NR_YNR_HWEIT_D0 + i, val);
286
-	}
287
-
288
-	for (i = 0; i < NR_YNR_HGRAD_Y_SIZE; i += 4) {
289
-		val = ISPP_PACK_4BYTE(arg->ynr_hgrad_y[i], arg->ynr_hgrad_y[i + 1],
290
-			arg->ynr_hgrad_y[i + 2], arg->ynr_hgrad_y[i + 3]);
291
-		rkispp_write(params_vdev->dev, RKISPP_NR_YNR_HGRAD_Y0 + i, val);
292
-	}
293
-
294
-	val = ISPP_PACK_2SHORT(arg->ynr_hweit[0], arg->ynr_hweit[1]);
295
-	rkispp_write(params_vdev->dev, RKISPP_NR_YNR_HWEIT_1_2, val);
296
-	val = ISPP_PACK_2SHORT(arg->ynr_hweit[2], arg->ynr_hweit[3]);
297
-	rkispp_write(params_vdev->dev, RKISPP_NR_YNR_HWEIT_3_4, val);
298
-
299
-	rkispp_write(params_vdev->dev, RKISPP_NR_YNR_HMAX_ADJUST, arg->ynr_hmax_adjust);
300
-	rkispp_write(params_vdev->dev, RKISPP_NR_YNR_HSTRENGTH, arg->ynr_hstrength);
301
-
302
-	val = ISPP_PACK_4BYTE(arg->ynr_lweit_cmp[0], arg->ynr_lweit_cmp[1], 0, 0);
303
-	rkispp_write(params_vdev->dev, RKISPP_NR_YNR_LWEIT_CMP, val);
304
-	rkispp_write(params_vdev->dev, RKISPP_NR_YNR_LMAXGAIN_LV4, arg->ynr_lmaxgain_lv4);
305
-
306
-	for (i = 0; i < NR_YNR_HSTV_Y_SIZE - 1; i += 2) {
307
-		val = ISPP_PACK_2SHORT(arg->ynr_hstv_y[i], arg->ynr_hstv_y[i + 1]);
308
-		rkispp_write(params_vdev->dev, RKISPP_NR_YNR_HSTV_Y_0_1 + i * 2, val);
309
-	}
310
-	rkispp_write(params_vdev->dev, RKISPP_NR_YNR_HSTV_Y_16, arg->ynr_hstv_y[16]);
311
-
312
-	val = ISPP_PACK_2SHORT(arg->ynr_st_scale[0], arg->ynr_st_scale[1]);
313
-	rkispp_write(params_vdev->dev, RKISPP_NR_YNR_ST_SCALE_LV1_LV2, val);
314
-	rkispp_write(params_vdev->dev, RKISPP_NR_YNR_ST_SCALE_LV3, arg->ynr_st_scale[2]);
315
-
316
-	big_en = arg->uvnr_big_en & 0x01;
317
-	nobig_en = arg->uvnr_nobig_en & 0x01;
318
-	if (get_input_size(params_vdev) > ISPP_NOBIG_OVERFLOW_SIZE) {
319
-		big_en = 1;
320
-		nobig_en = 0;
321
-	}
322
-
323
-	if (params_vdev->dev->hw_dev->dev_num == 1)
324
-		sd32_self_en = arg->uvnr_sd32_self_en;
325
-	val = arg->uvnr_step1_en << 1 | arg->uvnr_step2_en << 2 |
326
-	      arg->nr_gain_en << 3 | sd32_self_en << 4 |
327
-	      nobig_en << 5 | big_en << 6;
328
-	rkispp_set_bits(params_vdev->dev, RKISPP_NR_UVNR_CTRL_PARA,
329
-			SW_UVNR_STEP1_ON | SW_UVNR_STEP2_ON |
330
-			SW_NR_GAIN_BYPASS | SW_UVNR_NOBIG_EN |
331
-			SW_UVNR_BIG_EN, val);
332
-}
333
-
334
-static void nr_enable(struct rkispp_params_vdev *params_vdev, bool en,
335
-		      struct rkispp_nr_config *arg)
336
-{
337
-	u8 big_en, nobig_en;
338
-	u32 val;
339
-
340
-	big_en = arg->uvnr_big_en & 0x01;
341
-	nobig_en = arg->uvnr_nobig_en & 0x01;
342
-	if (get_input_size(params_vdev) > ISPP_NOBIG_OVERFLOW_SIZE) {
343
-		big_en = 1;
344
-		nobig_en = 0;
345
-	}
346
-
347
-	val = arg->uvnr_step1_en << 1 | arg->uvnr_step2_en << 2 |
348
-	      arg->nr_gain_en << 3 | nobig_en << 5 | big_en << 6;
349
-
350
-	if (en)
351
-		val |= SW_NR_EN;
352
-
353
-	rkispp_set_bits(params_vdev->dev, RKISPP_NR_UVNR_CTRL_PARA,
354
-			SW_UVNR_STEP1_ON | SW_UVNR_STEP2_ON |
355
-			SW_NR_GAIN_BYPASS | SW_UVNR_NOBIG_EN |
356
-			SW_UVNR_BIG_EN | SW_NR_EN, val);
357
-}
358
-
359
-static void shp_config(struct rkispp_params_vdev *params_vdev,
360
-		       struct rkispp_sharp_config *arg)
361
-{
362
-	u32 i, val;
363
-
364
-	rkispp_set_bits(params_vdev->dev, RKISPP_SHARP_CTRL,
365
-			SW_SHP_WR_ROT_MODE(3),
366
-			SW_SHP_WR_ROT_MODE(arg->rotation));
367
-
368
-	rkispp_write(params_vdev->dev, RKISPP_SHARP_SC_DOWN,
369
-		(arg->scl_down_v & 0x1) << 1 | (arg->scl_down_h & 0x1));
370
-
371
-	rkispp_write(params_vdev->dev, RKISPP_SHARP_TILE_IDX,
372
-		(arg->tile_ycnt & 0x1F) << 8 | (arg->tile_xcnt & 0xFF));
373
-
374
-	rkispp_write(params_vdev->dev, RKISPP_SHARP_HBF_FACTOR, arg->hbf_ratio |
375
-		arg->ehf_th << 16 | arg->pbf_ratio << 24);
376
-	rkispp_write(params_vdev->dev, RKISPP_SHARP_EDGE_TH, arg->edge_thed |
377
-		arg->dir_min << 8 | arg->smoth_th4 << 16);
378
-	val = ISPP_PACK_2SHORT(arg->l_alpha, arg->g_alpha);
379
-	rkispp_write(params_vdev->dev, RKISPP_SHARP_EDGE_ALPHA, val);
380
-	val = ISPP_PACK_4BYTE(arg->pbf_k[0], arg->pbf_k[1], arg->pbf_k[2], 0);
381
-	rkispp_write(params_vdev->dev, RKISPP_SHARP_PBF_KERNEL, val);
382
-	val = ISPP_PACK_4BYTE(arg->mrf_k[0], arg->mrf_k[1], arg->mrf_k[2], arg->mrf_k[3]);
383
-	rkispp_write(params_vdev->dev, RKISPP_SHARP_MRF_KERNEL0, val);
384
-	val = ISPP_PACK_4BYTE(arg->mrf_k[4], arg->mrf_k[5], 0, 0);
385
-	rkispp_write(params_vdev->dev, RKISPP_SHARP_MRF_KERNEL1, val);
386
-
387
-	for (i = 0; i < SHP_MBF_KERNEL_SIZE; i += 4) {
388
-		val = ISPP_PACK_4BYTE(arg->mbf_k[i], arg->mbf_k[i + 1],
389
-			arg->mbf_k[i + 2], arg->mbf_k[i + 3]);
390
-		rkispp_write(params_vdev->dev, RKISPP_SHARP_MBF_KERNEL0 + i, val);
391
-	}
392
-
393
-	val = ISPP_PACK_4BYTE(arg->hrf_k[0], arg->hrf_k[1], arg->hrf_k[2], arg->hrf_k[3]);
394
-	rkispp_write(params_vdev->dev, RKISPP_SHARP_HRF_KERNEL0, val);
395
-	val = ISPP_PACK_4BYTE(arg->hrf_k[4], arg->hrf_k[5], 0, 0);
396
-	rkispp_write(params_vdev->dev, RKISPP_SHARP_HRF_KERNEL1, val);
397
-	val = ISPP_PACK_4BYTE(arg->hbf_k[0], arg->hbf_k[1], arg->hbf_k[2], 0);
398
-	rkispp_write(params_vdev->dev, RKISPP_SHARP_HBF_KERNEL, val);
399
-
400
-	val = ISPP_PACK_4BYTE(arg->eg_coef[0], arg->eg_coef[1], arg->eg_coef[2], 0);
401
-	rkispp_write(params_vdev->dev, RKISPP_SHARP_EDGE_COEF, val);
402
-	val = ISPP_PACK_4BYTE(arg->eg_smoth[0], arg->eg_smoth[1], arg->eg_smoth[2], 0);
403
-	rkispp_write(params_vdev->dev, RKISPP_SHARP_EDGE_SMOTH, val);
404
-	val = ISPP_PACK_4BYTE(arg->eg_gaus[0], arg->eg_gaus[1], arg->eg_gaus[2], arg->eg_gaus[3]);
405
-	rkispp_write(params_vdev->dev, RKISPP_SHARP_EDGE_GAUS0, val);
406
-	val = ISPP_PACK_4BYTE(arg->eg_gaus[4], arg->eg_gaus[5], 0, 0);
407
-	rkispp_write(params_vdev->dev, RKISPP_SHARP_EDGE_GAUS1, val);
408
-
409
-	val = ISPP_PACK_4BYTE(arg->dog_k[0], arg->dog_k[1], arg->dog_k[2], arg->dog_k[3]);
410
-	rkispp_write(params_vdev->dev, RKISPP_SHARP_DOG_KERNEL0, val);
411
-	val = ISPP_PACK_4BYTE(arg->dog_k[4], arg->dog_k[5], 0, 0);
412
-	rkispp_write(params_vdev->dev, RKISPP_SHARP_DOG_KERNEL1, val);
413
-	val = ISPP_PACK_4BYTE(arg->lum_point[0], arg->lum_point[1],
414
-		arg->lum_point[2], arg->lum_point[3]);
415
-	rkispp_write(params_vdev->dev, RKISPP_SHARP_LUM_POINT0, val);
416
-	val = ISPP_PACK_4BYTE(arg->lum_point[4], arg->lum_point[5], 0, 0);
417
-	rkispp_write(params_vdev->dev, RKISPP_SHARP_LUM_POINT1, val);
418
-
419
-	val = ISPP_PACK_4BYTE(arg->pbf_shf_bits, arg->mbf_shf_bits, arg->hbf_shf_bits, 0);
420
-	rkispp_write(params_vdev->dev, RKISPP_SHARP_SHF_BITS, val);
421
-
422
-	for (i = 0; i < SHP_SIGMA_SIZE; i += 4) {
423
-		val = ISPP_PACK_4BYTE(arg->pbf_sigma[i], arg->pbf_sigma[i + 1],
424
-			arg->pbf_sigma[i + 2], arg->pbf_sigma[i + 3]);
425
-		rkispp_write(params_vdev->dev, RKISPP_SHARP_PBF_SIGMA_INV0 + i, val);
426
-		val = ISPP_PACK_4BYTE(arg->mbf_sigma[i], arg->mbf_sigma[i + 1],
427
-			arg->mbf_sigma[i + 2], arg->mbf_sigma[i + 3]);
428
-		rkispp_write(params_vdev->dev, RKISPP_SHARP_MBF_SIGMA_INV0 + i, val);
429
-		val = ISPP_PACK_4BYTE(arg->hbf_sigma[i], arg->hbf_sigma[i + 1],
430
-			arg->hbf_sigma[i + 2], arg->hbf_sigma[i + 3]);
431
-		rkispp_write(params_vdev->dev, RKISPP_SHARP_HBF_SIGMA_INV0 + i, val);
432
-	}
433
-
434
-	for (i = 0; i < SHP_LUM_CLP_SIZE; i += 4) {
435
-		val = ISPP_PACK_4BYTE(arg->lum_clp_m[i], arg->lum_clp_m[i + 1],
436
-			arg->lum_clp_m[i + 2], arg->lum_clp_m[i + 3]);
437
-		rkispp_write(params_vdev->dev, RKISPP_SHARP_LUM_CLP_M0 + i, val);
438
-		val = ISPP_PACK_4BYTE(arg->lum_clp_h[i], arg->lum_clp_h[i + 1],
439
-			arg->lum_clp_h[i + 2], arg->lum_clp_h[i + 3]);
440
-		rkispp_write(params_vdev->dev, RKISPP_SHARP_LUM_CLP_H0 + i, val);
441
-	}
442
-
443
-	for (i = 0; i < SHP_LUM_MIN_SIZE; i += 4) {
444
-		val = ISPP_PACK_4BYTE(arg->lum_min_m[i], arg->lum_min_m[i + 1],
445
-			arg->lum_min_m[i + 2], arg->lum_min_m[i + 3]);
446
-		rkispp_write(params_vdev->dev, RKISPP_SHARP_LUM_MIN_M0 + i, val);
447
-	}
448
-
449
-	for (i = 0; i < SHP_EDGE_LUM_THED_SIZE; i += 4) {
450
-		val = ISPP_PACK_4BYTE(arg->edge_lum_thed[i], arg->edge_lum_thed[i + 1],
451
-			arg->edge_lum_thed[i + 2], arg->edge_lum_thed[i + 3]);
452
-		rkispp_write(params_vdev->dev, RKISPP_SHARP_EDGE_LUM_THED0 + i, val);
453
-	}
454
-
455
-	for (i = 0; i < SHP_CLAMP_SIZE; i += 4) {
456
-		val = ISPP_PACK_4BYTE(arg->clamp_pos[i], arg->clamp_pos[i + 1],
457
-			arg->clamp_pos[i + 2], arg->clamp_pos[i + 3]);
458
-		rkispp_write(params_vdev->dev, RKISPP_SHARP_CLAMP_POS_DOG0 + i, val);
459
-		val = ISPP_PACK_4BYTE(arg->clamp_neg[i], arg->clamp_neg[i + 1],
460
-			arg->clamp_neg[i + 2], arg->clamp_neg[i + 3]);
461
-		rkispp_write(params_vdev->dev, RKISPP_SHARP_CLAMP_NEG_DOG0 + i, val);
462
-	}
463
-
464
-	for (i = 0; i < SHP_DETAIL_ALPHA_SIZE; i += 4) {
465
-		val = ISPP_PACK_4BYTE(arg->detail_alpha[i], arg->detail_alpha[i + 1],
466
-			arg->detail_alpha[i + 2], arg->detail_alpha[i + 3]);
467
-		rkispp_write(params_vdev->dev, RKISPP_SHARP_DETAIL_ALPHA_DOG0 + i, val);
468
-	}
469
-
470
-	val = ISPP_PACK_2SHORT(arg->rfl_ratio, arg->rfh_ratio);
471
-	rkispp_write(params_vdev->dev, RKISPP_SHARP_RF_RATIO, val);
472
-
473
-	val = ISPP_PACK_4BYTE(arg->m_ratio, arg->h_ratio, 0, 0);
474
-	rkispp_write(params_vdev->dev, RKISPP_SHARP_GRAD_RATIO, val);
475
-
476
-	val = arg->alpha_adp_en << 1 | arg->yin_flt_en << 3 |
477
-	      arg->edge_avg_en << 4;
478
-	rkispp_set_bits(params_vdev->dev, RKISPP_SHARP_CORE_CTRL,
479
-			SW_SHP_ALPHA_ADP_EN | SW_SHP_YIN_FLT_EN |
480
-			SW_SHP_EDGE_AVG_EN, val);
481
-}
482
-
483
-static void shp_enable(struct rkispp_params_vdev *params_vdev, bool en,
484
-		       struct rkispp_sharp_config *arg)
485
-{
486
-	u32 ens = params_vdev->dev->stream_vdev.module_ens;
487
-	u32 val;
488
-
489
-	if (en && !(ens & ISPP_MODULE_FEC)) {
490
-		rkispp_set_bits(params_vdev->dev, RKISPP_SCL0_CTRL,
491
-				SW_SCL_FIRST_MODE, SW_SCL_FIRST_MODE);
492
-		rkispp_set_bits(params_vdev->dev, RKISPP_SCL1_CTRL,
493
-				SW_SCL_FIRST_MODE, SW_SCL_FIRST_MODE);
494
-		rkispp_set_bits(params_vdev->dev, RKISPP_SCL2_CTRL,
495
-				SW_SCL_FIRST_MODE, SW_SCL_FIRST_MODE);
496
-	} else {
497
-		rkispp_clear_bits(params_vdev->dev, RKISPP_SCL0_CTRL, SW_SCL_FIRST_MODE);
498
-		rkispp_clear_bits(params_vdev->dev, RKISPP_SCL1_CTRL, SW_SCL_FIRST_MODE);
499
-		rkispp_clear_bits(params_vdev->dev, RKISPP_SCL2_CTRL, SW_SCL_FIRST_MODE);
500
-	}
501
-
502
-	val = arg->alpha_adp_en << 1 | arg->yin_flt_en << 3 |
503
-	      arg->edge_avg_en << 4;
504
-	if (en)
505
-		val |= SW_SHP_EN;
506
-	rkispp_set_bits(params_vdev->dev, RKISPP_SHARP_CORE_CTRL,
507
-			SW_SHP_ALPHA_ADP_EN | SW_SHP_YIN_FLT_EN |
508
-			SW_SHP_EDGE_AVG_EN | SW_SHP_EN, val);
509
-}
510
-
511
-static void fec_config(struct rkispp_params_vdev *params_vdev,
512
-		       struct rkispp_fec_config *arg)
513
-{
514
-	struct rkispp_device *dev = params_vdev->dev;
515
-	struct rkispp_fec_head *fec_data;
516
-	u32 width, height, mesh_size;
517
-	dma_addr_t dma_addr;
518
-	u32 val, i, buf_idx;
519
-
520
-	width = dev->ispp_sdev.out_fmt.width;
521
-	height = dev->ispp_sdev.out_fmt.height;
522
-	mesh_size = cal_fec_mesh(width, height, 0);
523
-	if (arg->mesh_size > mesh_size) {
524
-		v4l2_err(&dev->v4l2_dev,
525
-			 "Input mesh size too large. mesh size 0x%x, 0x%x\n",
526
-			 arg->mesh_size, mesh_size);
527
-		return;
528
-	}
529
-
530
-	for (i = 0; i < params_vdev->buf_cnt; i++) {
531
-		if (arg->buf_fd == params_vdev->buf_fec[i].dma_fd)
532
-			break;
533
-	}
534
-	if (i == params_vdev->buf_cnt) {
535
-		dev_err(dev->dev, "cannot find fec buf fd(%d)\n", arg->buf_fd);
536
-		return;
537
-	}
538
-
539
-	if (!params_vdev->buf_fec[i].vaddr) {
540
-		dev_err(dev->dev, "no fec buffer allocated\n");
541
-		return;
542
-	}
543
-
544
-	buf_idx = params_vdev->buf_fec_idx;
545
-	fec_data = (struct rkispp_fec_head *)params_vdev->buf_fec[buf_idx].vaddr;
546
-	fec_data->stat = FEC_BUF_INIT;
547
-
548
-	buf_idx = i;
549
-	fec_data = (struct rkispp_fec_head *)params_vdev->buf_fec[buf_idx].vaddr;
550
-	fec_data->stat = FEC_BUF_CHIPINUSE;
551
-	params_vdev->buf_fec_idx = buf_idx;
552
-
553
-	rkispp_prepare_buffer(dev, &params_vdev->buf_fec[buf_idx]);
554
-
555
-	dma_addr = params_vdev->buf_fec[buf_idx].dma_addr;
556
-	val = dma_addr + fec_data->meshxf_oft;
557
-	rkispp_write(params_vdev->dev, RKISPP_FEC_MESH_XFRA_BASE, val);
558
-	val = dma_addr + fec_data->meshyf_oft;
559
-	rkispp_write(params_vdev->dev, RKISPP_FEC_MESH_YFRA_BASE, val);
560
-	val = dma_addr + fec_data->meshxi_oft;
561
-	rkispp_write(params_vdev->dev, RKISPP_FEC_MESH_XINT_BASE, val);
562
-	val = dma_addr + fec_data->meshyi_oft;
563
-	rkispp_write(params_vdev->dev, RKISPP_FEC_MESH_YINT_BASE, val);
564
-
565
-	val = 0;
566
-	if (arg->mesh_density)
567
-		val = SW_MESH_DENSITY;
568
-	rkispp_set_bits(params_vdev->dev, RKISPP_FEC_CORE_CTRL, SW_MESH_DENSITY, val);
569
-
570
-	rkispp_write(params_vdev->dev, RKISPP_FEC_MESH_SIZE, arg->mesh_size);
571
-
572
-	val = (arg->crop_height & 0x1FFFF) << 14 |
573
-	      (arg->crop_width & 0x1FFFF) << 1 | (arg->crop_en & 0x01);
574
-	rkispp_write(params_vdev->dev, RKISPP_FEC_CROP, val);
575
-}
576
-
577
-static void fec_enable(struct rkispp_params_vdev *params_vdev, bool en)
578
-{
579
-	struct rkispp_device *dev = params_vdev->dev;
580
-	u32 buf_idx;
581
-
582
-	if (en) {
583
-		buf_idx = params_vdev->buf_fec_idx;
584
-		if (!params_vdev->buf_fec[buf_idx].vaddr) {
585
-			dev_err(dev->dev, "no fec buffer allocated\n");
586
-			return;
587
-		}
588
-		rkispp_clear_bits(params_vdev->dev, RKISPP_SCL0_CTRL, SW_SCL_FIRST_MODE);
589
-		rkispp_clear_bits(params_vdev->dev, RKISPP_SCL1_CTRL, SW_SCL_FIRST_MODE);
590
-		rkispp_clear_bits(params_vdev->dev, RKISPP_SCL2_CTRL, SW_SCL_FIRST_MODE);
591
-	}
592
-	rkispp_set_bits(params_vdev->dev, RKISPP_FEC_CORE_CTRL, SW_FEC_EN, en);
593
-}
594
-
595
-static void orb_config(struct rkispp_params_vdev *params_vdev,
596
-		       struct rkispp_orb_config *arg)
597
-{
598
-	rkispp_write(params_vdev->dev, RKISPP_ORB_LIMIT_VALUE, arg->limit_value & 0xFF);
599
-	rkispp_write(params_vdev->dev, RKISPP_ORB_MAX_FEATURE, arg->max_feature & 0x1FFFFF);
600
-}
601
-
602
-static void orb_enable(struct rkispp_params_vdev *params_vdev, bool en)
603
-{
604
-	rkispp_set_bits(params_vdev->dev, RKISPP_ORB_CORE_CTRL, SW_ORB_EN, en);
605
-}
606
17
 
607
18
 static int rkispp_params_enum_fmt_meta_out(struct file *file, void *priv,
608
19
 					   struct v4l2_fmtdesc *f)
..
..
@@ -705,18 +116,18 @@
705
116
 	u32 width, height, mesh_size, buf_size;
706
117
 	int i, ret;
707
118
 
119
+	width = fecsize->meas_width;
120
+	height = fecsize->meas_height;
121
+	mesh_size = cal_fec_mesh(width, height, fecsize->meas_mode);
122
+	buf_size = ALIGN(sizeof(struct rkispp_fec_head), 16);
123
+	buf_size += 2 * (ALIGN(mesh_size * 2, 16) + ALIGN(mesh_size, 16));
124
+
708
125
 	if (fecsize->buf_cnt > FEC_MESH_BUF_MAX)
709
126
 		params->buf_cnt = FEC_MESH_BUF_MAX;
710
127
 	else if (fecsize->buf_cnt > 0)
711
128
 		params->buf_cnt = fecsize->buf_cnt;
712
129
 	else
713
130
 		params->buf_cnt = FEC_MESH_BUF_NUM;
714
-
715
-	width = fecsize->meas_width;
716
-	height = fecsize->meas_height;
717
-	mesh_size = cal_fec_mesh(width, height, fecsize->meas_mode);
718
-	buf_size = ALIGN(sizeof(struct rkispp_fec_head), 16);
719
-	buf_size += 2 * (ALIGN(mesh_size * 2, 16) + ALIGN(mesh_size, 16));
720
131
 
721
132
 	params->buf_fec_idx = 0;
722
133
 	for (i = 0; i < params->buf_cnt; i++) {
..
..
@@ -750,10 +161,10 @@
750
161
 			rkispp_write(pp_dev, RKISPP_FEC_MESH_YINT_BASE, val);
751
162
 		}
752
163
 		v4l2_dbg(1, rkispp_debug, &pp_dev->v4l2_dev,
753
-			 "%s idx:%d fd:%d dma:0x%x offset xf:0x%x yf:0x%x xi:0x%x yi:0x%x\n",
754
-			 __func__, i, params->buf_fec[i].dma_fd, params->buf_fec[i].dma_addr,
755
-			fec_data->meshxf_oft, fec_data->meshyf_oft,
756
-			fec_data->meshxi_oft, fec_data->meshyi_oft);
164
+			 "%s idx:%d fd:%d dma:%pad offset xf:0x%x yf:0x%x xi:0x%x yi:0x%x\n",
165
+			 __func__, i, params->buf_fec[i].dma_fd, &params->buf_fec[i].dma_addr,
166
+			 fec_data->meshxf_oft, fec_data->meshyf_oft,
167
+			 fec_data->meshxi_oft, fec_data->meshyi_oft);
757
168
 	}
758
169
 
759
170
 	return 0;
..
..
@@ -776,23 +187,28 @@
776
187
 					 struct device *alloc_ctxs[])
777
188
 {
778
189
 	struct rkispp_params_vdev *params_vdev = vq->drv_priv;
190
+	struct rkispp_device *dev = params_vdev->dev;
779
191
 
780
192
 	*num_buffers = clamp_t(u32, *num_buffers,
781
193
 			       RKISP1_ISP_PARAMS_REQ_BUFS_MIN,
782
194
 			       RKISP1_ISP_PARAMS_REQ_BUFS_MAX);
783
195
 
784
196
 	*num_planes = 1;
785
-	switch (params_vdev->vdev_id) {
786
-	case PARAM_VDEV_TNR:
787
-		sizes[0] = sizeof(struct rkispp_params_tnrcfg);
788
-		break;
789
-	case PARAM_VDEV_NR:
790
-		sizes[0] = sizeof(struct rkispp_params_nrcfg);
791
-		break;
792
-	case PARAM_VDEV_FEC:
793
-	default:
794
-		sizes[0] = sizeof(struct rkispp_params_feccfg);
795
-		break;
197
+	if (dev->ispp_ver == ISPP_V10) {
198
+		switch (params_vdev->vdev_id) {
199
+		case PARAM_VDEV_TNR:
200
+			sizes[0] = sizeof(struct rkispp_params_tnrcfg);
201
+			break;
202
+		case PARAM_VDEV_NR:
203
+			sizes[0] = sizeof(struct rkispp_params_nrcfg);
204
+			break;
205
+		case PARAM_VDEV_FEC:
206
+		default:
207
+			sizes[0] = sizeof(struct rkispp_params_feccfg);
208
+			break;
209
+		}
210
+	} else if (dev->ispp_ver == ISPP_V20) {
211
+		sizes[0] = sizeof(struct fec_params_cfg);
796
212
 	}
797
213
 
798
214
 	INIT_LIST_HEAD(&params_vdev->params);
..
..
@@ -803,50 +219,10 @@
803
219
 
804
220
 static void rkispp_params_vb2_buf_queue(struct vb2_buffer *vb)
805
221
 {
806
-	struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
807
-	struct rkispp_buffer *params_buf = to_rkispp_buffer(vbuf);
808
222
 	struct vb2_queue *vq = vb->vb2_queue;
809
223
 	struct rkispp_params_vdev *params_vdev = vq->drv_priv;
810
-	struct rkispp_device *dev = params_vdev->dev;
811
-	struct rkispp_stream_vdev *vdev = &dev->stream_vdev;
812
-	unsigned long flags;
813
224
 
814
-	spin_lock_irqsave(&params_vdev->config_lock, flags);
815
-	if (params_vdev->first_params) {
816
-		params_vdev->first_params = false;
817
-		if (params_vdev->vdev_id == PARAM_VDEV_NR)
818
-			wake_up(&params_vdev->dev->sync_onoff);
819
-	}
820
-	spin_unlock_irqrestore(&params_vdev->config_lock, flags);
821
-
822
-	params_buf->vaddr[0] = vb2_plane_vaddr(vb, 0);
823
-	spin_lock_irqsave(&params_vdev->config_lock, flags);
824
-	list_add_tail(&params_buf->queue, &params_vdev->params);
825
-	spin_unlock_irqrestore(&params_vdev->config_lock, flags);
826
-
827
-	if (params_vdev->vdev_id == PARAM_VDEV_NR) {
828
-		struct rkisp_ispp_buf *buf_rd = NULL;
829
-
830
-		spin_lock_irqsave(&vdev->tnr.buf_lock, flags);
831
-		if (!list_empty(&vdev->tnr.list_rpt)) {
832
-			buf_rd = list_first_entry(&vdev->tnr.list_rpt,
833
-					struct rkisp_ispp_buf, list);
834
-			list_del(&buf_rd->list);
835
-		}
836
-		spin_unlock_irqrestore(&vdev->tnr.buf_lock, flags);
837
-		rkispp_module_work_event(dev, buf_rd, NULL, ISPP_MODULE_NR, false);
838
-	} else if (params_vdev->vdev_id == PARAM_VDEV_FEC) {
839
-		struct rkispp_dummy_buffer *buf_rd = NULL;
840
-
841
-		spin_lock_irqsave(&vdev->nr.buf_lock, flags);
842
-		if (!list_empty(&vdev->nr.list_rpt)) {
843
-			buf_rd = list_first_entry(&vdev->nr.list_rpt,
844
-					struct rkispp_dummy_buffer, list);
845
-			list_del(&buf_rd->list);
846
-			list_add_tail(&buf_rd->list, &vdev->fec.list_rd);
847
-		}
848
-		spin_unlock_irqrestore(&vdev->nr.buf_lock, flags);
849
-	}
225
+	params_vdev->params_ops->rkispp_params_vb2_buf_queue(vb);
850
226
 }
851
227
 
852
228
 static void rkispp_params_vb2_stop_streaming(struct vb2_queue *vq)
..
..
@@ -910,7 +286,7 @@
910
286
 
911
287
 	ret = v4l2_fh_open(filp);
912
288
 	if (!ret) {
913
-		ret = v4l2_pipeline_pm_use(&params->vnode.vdev.entity, 1);
289
+		ret = v4l2_pipeline_pm_get(&params->vnode.vdev.entity);
914
290
 		if (ret < 0) {
915
291
 			v4l2_err(&isppdev->v4l2_dev,
916
292
 				 "pipeline power on failed %d\n", ret);
..
..
@@ -930,19 +306,14 @@
930
306
 {
931
307
 	struct rkispp_params_vdev *params = video_drvdata(filp);
932
308
 	struct video_device *vdev = video_devdata(filp);
933
-	struct rkispp_device *isppdev = params->dev;
934
309
 	int ret;
935
310
 
936
311
 	if (filp->private_data == vdev->queue->owner)
937
312
 		rkispp_param_deinit_fecbuf(params);
938
313
 
939
314
 	ret = vb2_fop_release(filp);
940
-	if (!ret) {
941
-		ret = v4l2_pipeline_pm_use(&params->vnode.vdev.entity, 0);
942
-		if (ret < 0)
943
-			v4l2_err(&isppdev->v4l2_dev,
944
-				 "pipeline power off failed %d\n", ret);
945
-	}
315
+	if (!ret)
316
+		v4l2_pipeline_pm_put(&params->vnode.vdev.entity);
946
317
 	return ret;
947
318
 }
948
319
 
..
..
@@ -953,7 +324,6 @@
953
324
 	.buf_queue = rkispp_params_vb2_buf_queue,
954
325
 	.start_streaming = rkispp_params_vb2_start_streaming,
955
326
 	.stop_streaming = rkispp_params_vb2_stop_streaming,
956
-
957
327
 };
958
328
 
959
329
 struct v4l2_file_operations rkispp_params_fops = {
..
..
@@ -979,128 +349,6 @@
979
349
 	q->dev = params_vdev->dev->hw_dev->dev;
980
350
 
981
351
 	return vb2_queue_init(q);
982
-}
983
-
984
-static void fec_data_abandon(struct rkispp_params_vdev *vdev,
985
-			     struct rkispp_params_feccfg *params)
986
-{
987
-	struct rkispp_fec_head *data;
988
-	int i;
989
-
990
-	for (i = 0; i < vdev->buf_cnt; i++) {
991
-		if (params->fec_cfg.buf_fd == vdev->buf_fec[i].dma_fd) {
992
-			data = (struct rkispp_fec_head *)vdev->buf_fec[i].vaddr;
993
-			if (data)
994
-				data->stat = FEC_BUF_INIT;
995
-			break;
996
-		}
997
-	}
998
-}
999
-
1000
-void rkispp_params_cfg(struct rkispp_params_vdev *params_vdev, u32 frame_id)
1001
-{
1002
-	struct rkispp_params_cfghead *param_head = NULL;
1003
-	u32 module_en_update, module_cfg_update, module_ens;
1004
-
1005
-	spin_lock(&params_vdev->config_lock);
1006
-	if (!params_vdev->streamon) {
1007
-		spin_unlock(&params_vdev->config_lock);
1008
-		return;
1009
-	}
1010
-
1011
-	/* get buffer by frame_id */
1012
-	while (!list_empty(&params_vdev->params) && !params_vdev->cur_buf) {
1013
-		params_vdev->cur_buf = list_first_entry(&params_vdev->params,
1014
-				struct rkispp_buffer, queue);
1015
-
1016
-		param_head = (struct rkispp_params_cfghead *)(params_vdev->cur_buf->vaddr[0]);
1017
-		if (param_head->frame_id < frame_id) {
1018
-			list_del(&params_vdev->cur_buf->queue);
1019
-			/* force to on/off module */
1020
-			if (param_head->module_en_update)
1021
-				break;
1022
-			if (param_head->module_cfg_update & ISPP_MODULE_FEC)
1023
-				fec_data_abandon(params_vdev, (struct rkispp_params_feccfg *)param_head);
1024
-			vb2_buffer_done(&params_vdev->cur_buf->vb.vb2_buf, VB2_BUF_STATE_DONE);
1025
-			params_vdev->cur_buf = NULL;
1026
-			continue;
1027
-		} else if (param_head->frame_id == frame_id) {
1028
-			list_del(&params_vdev->cur_buf->queue);
1029
-		} else {
1030
-			params_vdev->cur_buf = NULL;
1031
-		}
1032
-		break;
1033
-	}
1034
-
1035
-	if (!params_vdev->cur_buf) {
1036
-		spin_unlock(&params_vdev->config_lock);
1037
-		return;
1038
-	}
1039
-
1040
-	param_head = (struct rkispp_params_cfghead *)(params_vdev->cur_buf->vaddr[0]);
1041
-
1042
-	module_en_update = param_head->module_en_update;
1043
-	module_cfg_update = param_head->module_cfg_update;
1044
-	module_ens = param_head->module_ens;
1045
-	if (params_vdev->dev->hw_dev->is_fec_ext) {
1046
-		module_en_update &= ~ISPP_MODULE_FEC;
1047
-		module_cfg_update &= ~ISPP_MODULE_FEC;
1048
-		module_ens &= ~ISPP_MODULE_FEC;
1049
-	}
1050
-
1051
-	if (params_vdev->vdev_id == PARAM_VDEV_TNR) {
1052
-		struct rkispp_params_tnrcfg *tnr_params;
1053
-
1054
-		tnr_params = (struct rkispp_params_tnrcfg *)param_head;
1055
-		if (module_cfg_update & ISPP_MODULE_TNR)
1056
-			tnr_config(params_vdev,
1057
-				   &tnr_params->tnr_cfg);
1058
-		if (module_en_update & ISPP_MODULE_TNR)
1059
-			tnr_enable(params_vdev,
1060
-				   !!(module_ens & ISPP_MODULE_TNR));
1061
-	} else if (params_vdev->vdev_id == PARAM_VDEV_NR) {
1062
-		struct rkispp_params_nrcfg *nr_params;
1063
-
1064
-		nr_params = (struct rkispp_params_nrcfg *)param_head;
1065
-		if (module_cfg_update & ISPP_MODULE_NR)
1066
-			nr_config(params_vdev,
1067
-				  &nr_params->nr_cfg);
1068
-		if (module_en_update & ISPP_MODULE_NR)
1069
-			nr_enable(params_vdev,
1070
-				  !!(module_ens & ISPP_MODULE_NR),
1071
-				  &nr_params->nr_cfg);
1072
-
1073
-		if (module_cfg_update & ISPP_MODULE_SHP)
1074
-			shp_config(params_vdev,
1075
-				   &nr_params->shp_cfg);
1076
-		if (module_en_update & ISPP_MODULE_SHP)
1077
-			shp_enable(params_vdev,
1078
-				   !!(module_ens & ISPP_MODULE_SHP),
1079
-				   &nr_params->shp_cfg);
1080
-
1081
-		if (module_cfg_update & ISPP_MODULE_ORB)
1082
-			orb_config(params_vdev,
1083
-				   &nr_params->orb_cfg);
1084
-		if (module_en_update & ISPP_MODULE_ORB)
1085
-			orb_enable(params_vdev,
1086
-				   !!(module_ens & ISPP_MODULE_ORB));
1087
-	} else {
1088
-		struct rkispp_params_feccfg *fec_params;
1089
-
1090
-		fec_params = (struct rkispp_params_feccfg *)param_head;
1091
-		if (module_cfg_update & ISPP_MODULE_FEC)
1092
-			fec_config(params_vdev,
1093
-				   &fec_params->fec_cfg);
1094
-		if (module_en_update & ISPP_MODULE_FEC)
1095
-			fec_enable(params_vdev,
1096
-				   !!(module_ens & ISPP_MODULE_FEC));
1097
-	}
1098
-
1099
-	vb2_buffer_done(&params_vdev->cur_buf->vb.vb2_buf,
1100
-				VB2_BUF_STATE_DONE);
1101
-	params_vdev->cur_buf = NULL;
1102
-
1103
-	spin_unlock(&params_vdev->config_lock);
1104
352
 }
1105
353
 
1106
354
 void rkispp_params_get_fecbuf_inf(struct rkispp_params_vdev *params_vdev,
..
..
@@ -1144,6 +392,10 @@
1144
392
 	params_vdev->is_subs_evt = false;
1145
393
 	params_vdev->vdev_id = vdev_id;
1146
394
 
395
+	if (dev->ispp_ver == ISPP_V10)
396
+		rkispp_params_init_ops_v10(params_vdev);
397
+	if (dev->ispp_ver == ISPP_V20)
398
+		rkispp_params_init_ops_v20(params_vdev);
1147
399
 	spin_lock_init(&params_vdev->config_lock);
1148
400
 	switch (vdev_id) {
1149
401
 	case PARAM_VDEV_TNR:
..
..
@@ -1180,7 +432,7 @@
1180
432
 	ret = media_entity_pads_init(&vdev->entity, 1, &node->pad);
1181
433
 	if (ret < 0)
1182
434
 		goto err_release_queue;
1183
-	ret = video_register_device(vdev, VFL_TYPE_GRABBER, -1);
435
+	ret = video_register_device(vdev, VFL_TYPE_VIDEO, -1);
1184
436
 	if (ret < 0) {
1185
437
 		dev_err(&vdev->dev,
1186
438
 			"could not register Video for Linux device\n");
..
..
@@ -1212,21 +464,23 @@
1212
464
 {
1213
465
 	int ret = 0;
1214
466
 
1215
-	ret = rkispp_register_params_vdev(dev, PARAM_VDEV_TNR);
467
+	ret = rkispp_register_params_vdev(dev, PARAM_VDEV_FEC);
1216
468
 	if (ret)
1217
469
 		return ret;
1218
470
 
1219
-	ret = rkispp_register_params_vdev(dev, PARAM_VDEV_NR);
1220
-	if (ret) {
1221
-		rkispp_unregister_params_vdev(dev, PARAM_VDEV_TNR);
1222
-		return ret;
1223
-	}
471
+	if (dev->ispp_ver == ISPP_V10) {
472
+		ret = rkispp_register_params_vdev(dev, PARAM_VDEV_TNR);
473
+		if (ret) {
474
+			rkispp_unregister_params_vdev(dev, PARAM_VDEV_FEC);
475
+			return ret;
476
+		}
1224
477
 
1225
-	ret = rkispp_register_params_vdev(dev, PARAM_VDEV_FEC);
1226
-	if (ret) {
1227
-		rkispp_unregister_params_vdev(dev, PARAM_VDEV_TNR);
1228
-		rkispp_unregister_params_vdev(dev, PARAM_VDEV_NR);
1229
-		return ret;
478
+		ret = rkispp_register_params_vdev(dev, PARAM_VDEV_NR);
479
+		if (ret) {
480
+			rkispp_unregister_params_vdev(dev, PARAM_VDEV_FEC);
481
+			rkispp_unregister_params_vdev(dev, PARAM_VDEV_TNR);
482
+			return ret;
483
+		}
1230
484
 	}
1231
485
 
1232
486
 	return ret;
..
..
@@ -1234,7 +488,9 @@
1234
488
 
1235
489
 void rkispp_unregister_params_vdevs(struct rkispp_device *dev)
1236
490
 {
1237
-	rkispp_unregister_params_vdev(dev, PARAM_VDEV_TNR);
1238
-	rkispp_unregister_params_vdev(dev, PARAM_VDEV_NR);
1239
491
 	rkispp_unregister_params_vdev(dev, PARAM_VDEV_FEC);
492
+	if (dev->ispp_ver == ISPP_V10) {
493
+		rkispp_unregister_params_vdev(dev, PARAM_VDEV_TNR);
494
+		rkispp_unregister_params_vdev(dev, PARAM_VDEV_NR);
495
+	}
1240
496
 }