update kernel to 5.10.198

hc

2024-01-03 2f7c68cb55ecb7331f2381deb497c27155f32faf

 kernel/drivers/media/platform/rockchip/isp/bridge.c
..
..
@@ -2,6 +2,9 @@
2
2
 /* Copyright (c) 2019 Fuzhou Rockchip Electronics Co., Ltd. */
3
3
 
4
4
 #include <linux/delay.h>
5
+#include <linux/of.h>
6
+#include <linux/of_graph.h>
7
+#include <linux/of_platform.h>
5
8
 #include <linux/pm_runtime.h>
6
9
 #include <linux/slab.h>
7
10
 #include <media/v4l2-common.h>
..
..
@@ -20,778 +23,6 @@
20
23
 {
21
24
 	return container_of(dbufs, struct rkisp_bridge_buf, dbufs);
22
25
 }
23
-
24
-/* compatible with MI frame end are triggered before ISP frame end */
25
-static void reg_buf_wait_for_stats(struct rkisp_bridge_device *dev,
26
-				   struct rkisp_ispp_reg *reg_buf,
27
-				   struct rkisp_isp2x_stat_buffer *tmp_statsbuf)
28
-{
29
-	s32 retry = 10;
30
-
31
-	do {
32
-		if (reg_buf->frame_id > tmp_statsbuf->frame_id)
33
-			usleep_range(1000, 1200);
34
-		else
35
-			break;
36
-	} while (retry-- > 0);
37
-
38
-	if (retry < 0)
39
-		v4l2_err(&dev->sd, "reg id(%d) don't match stats id(%d)\n",
40
-			 reg_buf->frame_id, tmp_statsbuf->frame_id);
41
-}
42
-
43
-static void dump_dbg_reg(struct rkisp_bridge_device *dev, struct rkisp_ispp_reg *reg_buf)
44
-{
45
-	struct rkisp_isp2x_stat_buffer *tmp_statsbuf;
46
-	struct rkisp_hw_dev *hw = dev->ispdev->hw_dev;
47
-	u32 offset = 0, size;
48
-
49
-	tmp_statsbuf = (struct rkisp_isp2x_stat_buffer *)dev->ispdev->stats_vdev.tmp_statsbuf.vaddr;
50
-	reg_buf_wait_for_stats(dev, reg_buf, tmp_statsbuf);
51
-	memset(reg_buf->isp_offset, -1, sizeof(reg_buf->isp_offset));
52
-	memset(reg_buf->ispp_offset, -1, sizeof(reg_buf->ispp_offset));
53
-	memset(reg_buf->isp_size, 0, sizeof(reg_buf->isp_offset));
54
-	memset(reg_buf->isp_stats_size, 0, sizeof(reg_buf->isp_offset));
55
-	memset(reg_buf->ispp_size, 0, sizeof(reg_buf->ispp_offset));
56
-	if (rkisp_debug_reg & ISP2X_MODULE_DPCC) {
57
-		size = 4 + ISP_DPCC0_PDAF_FORWARD_MED - ISP_DPCC0_MODE;
58
-		reg_buf->isp_size[ISP2X_ID_DPCC] = size;
59
-		reg_buf->isp_offset[ISP2X_ID_DPCC] = offset;
60
-		memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_DPCC0_MODE, size);
61
-		offset += size;
62
-	}
63
-
64
-	if (rkisp_debug_reg & ISP2X_MODULE_BLS) {
65
-		size = 4 + ISP_BLS_D_MEASURED - ISP_BLS_CTRL;
66
-		reg_buf->isp_size[ISP2X_ID_BLS] = size;
67
-		reg_buf->isp_offset[ISP2X_ID_BLS] = offset;
68
-		memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_BLS_CTRL, size);
69
-		offset += size;
70
-	}
71
-
72
-	if (rkisp_debug_reg & ISP2X_MODULE_SDG) {
73
-		size = 4 + ISP_GAMMA_B_Y_16 - ISP_GAMMA_DX_LO;
74
-		reg_buf->isp_size[ISP2X_ID_SDG] = size;
75
-		reg_buf->isp_offset[ISP2X_ID_SDG] = offset;
76
-		memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_GAMMA_DX_LO, size);
77
-		offset += size;
78
-	}
79
-
80
-	if (rkisp_debug_reg & ISP2X_MODULE_SIHST) {
81
-		size = 4 + ISP_HIST_HIST3_DBG2 - ISP_HIST_HIST_CTRL;
82
-		reg_buf->isp_size[ISP2X_ID_SIHST] = size;
83
-		reg_buf->isp_offset[ISP2X_ID_SIHST] = offset;
84
-		memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_HIST_HIST_CTRL, size);
85
-		offset += size;
86
-	}
87
-
88
-	if (rkisp_debug_reg & ISP2X_MODULE_LSC) {
89
-		size = 4 + ISP_LSC_STATUS - ISP_LSC_CTRL;
90
-		reg_buf->isp_size[ISP2X_ID_LSC] = size;
91
-		reg_buf->isp_offset[ISP2X_ID_LSC] = offset;
92
-		memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_LSC_CTRL, size);
93
-		offset += size;
94
-	}
95
-
96
-	if (rkisp_debug_reg & ISP2X_MODULE_AWB_GAIN) {
97
-		size = 4 + CIF_ISP_AWB_GAIN_RB_V12 - CIF_ISP_AWB_GAIN_G_V12;
98
-		reg_buf->isp_size[ISP2X_ID_AWB_GAIN] = size;
99
-		reg_buf->isp_offset[ISP2X_ID_AWB_GAIN] = offset;
100
-		memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + CIF_ISP_AWB_GAIN_G_V12, size);
101
-		offset += size;
102
-	}
103
-
104
-	if (rkisp_debug_reg & ISP2X_MODULE_CCM) {
105
-		size = 4 + ISP_CCM_BOUND_BIT - ISP_CCM_CTRL;
106
-		reg_buf->isp_size[ISP2X_ID_CCM] = size;
107
-		reg_buf->isp_offset[ISP2X_ID_CCM] = offset;
108
-		memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_CCM_CTRL, size);
109
-		offset += size;
110
-	}
111
-
112
-	if (rkisp_debug_reg & ISP2X_MODULE_GOC) {
113
-		size = 4 + ISP_GAMMA_OUT_Y40 - ISP_GAMMA_OUT_CTRL;
114
-		reg_buf->isp_size[ISP2X_ID_GOC] = size;
115
-		reg_buf->isp_offset[ISP2X_ID_GOC] = offset;
116
-		memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_GAMMA_OUT_CTRL, size);
117
-		offset += size;
118
-	}
119
-
120
-	if (rkisp_debug_reg & ISP2X_MODULE_CPROC) {
121
-		size = 4 + CPROC_HUE - CPROC_CTRL;
122
-		reg_buf->isp_size[ISP2X_ID_CPROC] = size;
123
-		reg_buf->isp_offset[ISP2X_ID_CPROC] = offset;
124
-		memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + CPROC_CTRL, size);
125
-		offset += size;
126
-	}
127
-
128
-	if (rkisp_debug_reg & ISP2X_MODULE_SIAF) {
129
-		size = 4 + ISP_AFM_LUM_C - ISP_AFM_CTRL;
130
-		reg_buf->isp_size[ISP2X_ID_SIAF] = size;
131
-		reg_buf->isp_offset[ISP2X_ID_SIAF] = offset;
132
-		memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_AFM_CTRL, size);
133
-		offset += size;
134
-	}
135
-
136
-	if (rkisp_debug_reg & ISP2X_MODULE_SIAWB) {
137
-		size = 4 + CIF_ISP_AWB_MEAN_V10 - CIF_ISP_AWB_PROP_V10;
138
-		reg_buf->isp_size[ISP2X_ID_SIAWB] = size;
139
-		reg_buf->isp_offset[ISP2X_ID_SIAWB] = offset;
140
-		memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + CIF_ISP_AWB_PROP_V10, size);
141
-		offset += size;
142
-	}
143
-
144
-	if (rkisp_debug_reg & ISP2X_MODULE_IE) {
145
-		size = 4 + CIF_IMG_EFF_SHARPEN - CIF_IMG_EFF_CTRL;
146
-		reg_buf->isp_size[ISP2X_ID_IE] = size;
147
-		reg_buf->isp_offset[ISP2X_ID_IE] = offset;
148
-		memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + CIF_IMG_EFF_CTRL, size);
149
-		offset += size;
150
-	}
151
-
152
-	if (rkisp_debug_reg & ISP2X_MODULE_YUVAE) {
153
-		size = 4 + ISP_YUVAE_RO_DBG3 - ISP_YUVAE_CTRL;
154
-		reg_buf->isp_size[ISP2X_ID_YUVAE] = size;
155
-		reg_buf->isp_offset[ISP2X_ID_YUVAE] = offset;
156
-		memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_YUVAE_CTRL, size);
157
-		offset += size;
158
-	}
159
-
160
-	if (rkisp_debug_reg & ISP2X_MODULE_WDR) {
161
-		size = 4 + ISP_WDR_BLKMEAN8_ROW9_4TO7 - ISP_WDR_CTRL;
162
-		reg_buf->isp_size[ISP2X_ID_WDR] = size;
163
-		reg_buf->isp_offset[ISP2X_ID_WDR] = offset;
164
-		memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_WDR_CTRL, size);
165
-		offset += size;
166
-	}
167
-
168
-	if (rkisp_debug_reg & ISP2X_MODULE_RK_IESHARP) {
169
-		size = 4 + CIF_RKSHARP_UV_GAUSS_OTHER_COE33_COE35 - CIF_RKSHARP_CTRL;
170
-		reg_buf->isp_size[ISP2X_ID_RK_IESHARP] = size;
171
-		reg_buf->isp_offset[ISP2X_ID_RK_IESHARP] = offset;
172
-		memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + CIF_RKSHARP_CTRL, size);
173
-		offset += size;
174
-	}
175
-
176
-	if (rkisp_debug_reg & ISP2X_MODULE_RAWAF) {
177
-		size = 4 + ISP_RAWAF_INT_STATE - ISP_RAWAF_CTRL;
178
-		reg_buf->isp_size[ISP2X_ID_RAWAF] = size;
179
-		reg_buf->isp_offset[ISP2X_ID_RAWAF] = offset;
180
-		memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_RAWAF_CTRL, size);
181
-		offset += size;
182
-
183
-		size = ISP2X_RAWAF_SUMDATA_NUM * sizeof(tmp_statsbuf->params.rawaf.ramdata[0]);
184
-		reg_buf->isp_size[ISP2X_ID_RAWAF] += size;
185
-		reg_buf->isp_stats_size[ISP2X_ID_RAWAF] = size;
186
-		if (tmp_statsbuf->frame_id == reg_buf->frame_id)
187
-			memcpy(&reg_buf->reg[offset], &tmp_statsbuf->params.rawaf.ramdata[0], size);
188
-		else
189
-			memset(&reg_buf->reg[offset], 0, size);
190
-		offset += size;
191
-	}
192
-
193
-	if (rkisp_debug_reg & ISP2X_MODULE_RAWAE0) {
194
-		size = 4 + ISP_RAWAE_LITE_RO_DBG2 - ISP_RAWAE_LITE_CTRL;
195
-		reg_buf->isp_size[ISP2X_ID_RAWAE0] = size;
196
-		reg_buf->isp_offset[ISP2X_ID_RAWAE0] = offset;
197
-		memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_RAWAE_LITE_CTRL, size);
198
-		offset += size;
199
-
200
-		size = ISP2X_RAWAELITE_MEAN_NUM * sizeof(tmp_statsbuf->params.rawae0.data[0]);
201
-		reg_buf->isp_size[ISP2X_ID_RAWAE0] += size;
202
-		reg_buf->isp_stats_size[ISP2X_ID_RAWAE0] = size;
203
-		if (tmp_statsbuf->frame_id == reg_buf->frame_id)
204
-			memcpy(&reg_buf->reg[offset], &tmp_statsbuf->params.rawae0.data[0], size);
205
-		else
206
-			memset(&reg_buf->reg[offset], 0, size);
207
-		offset += size;
208
-	}
209
-
210
-	if (rkisp_debug_reg & ISP2X_MODULE_RAWAE1) {
211
-		size = 4 + RAWAE_BIG_RO_DBG3 - RAWAE_BIG_CTRL;
212
-		reg_buf->isp_size[ISP2X_ID_RAWAE1] = size;
213
-		reg_buf->isp_offset[ISP2X_ID_RAWAE1] = offset;
214
-		memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + RAWAE_BIG1_BASE, size);
215
-		offset += size;
216
-
217
-		size = ISP2X_RAWAEBIG_MEAN_NUM * sizeof(tmp_statsbuf->params.rawae1.data[0]);
218
-		reg_buf->isp_size[ISP2X_ID_RAWAE1] += size;
219
-		reg_buf->isp_stats_size[ISP2X_ID_RAWAE1] = size;
220
-		if (tmp_statsbuf->frame_id == reg_buf->frame_id)
221
-			memcpy(&reg_buf->reg[offset], &tmp_statsbuf->params.rawae1.data[0], size);
222
-		else
223
-			memset(&reg_buf->reg[offset], 0, size);
224
-		offset += size;
225
-	}
226
-
227
-	if (rkisp_debug_reg & ISP2X_MODULE_RAWAE2) {
228
-		size = 4 + RAWAE_BIG_RO_DBG3 - RAWAE_BIG_CTRL;
229
-		reg_buf->isp_size[ISP2X_ID_RAWAE2] = size;
230
-		reg_buf->isp_offset[ISP2X_ID_RAWAE2] = offset;
231
-		memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + RAWAE_BIG2_BASE, size);
232
-		offset += size;
233
-
234
-		size = ISP2X_RAWAEBIG_MEAN_NUM * sizeof(tmp_statsbuf->params.rawae2.data[0]);
235
-		reg_buf->isp_size[ISP2X_ID_RAWAE2] += size;
236
-		reg_buf->isp_stats_size[ISP2X_ID_RAWAE2] = size;
237
-		if (tmp_statsbuf->frame_id == reg_buf->frame_id)
238
-			memcpy(&reg_buf->reg[offset], &tmp_statsbuf->params.rawae2.data[0], size);
239
-		else
240
-			memset(&reg_buf->reg[offset], 0, size);
241
-		offset += size;
242
-	}
243
-
244
-	if (rkisp_debug_reg & ISP2X_MODULE_RAWAE3) {
245
-		size = 4 + RAWAE_BIG_RO_DBG3 - RAWAE_BIG_CTRL;
246
-		reg_buf->isp_size[ISP2X_ID_RAWAE3] = size;
247
-		reg_buf->isp_offset[ISP2X_ID_RAWAE3] = offset;
248
-		memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + RAWAE_BIG3_BASE, size);
249
-		offset += size;
250
-
251
-		size = ISP2X_RAWAEBIG_MEAN_NUM * sizeof(tmp_statsbuf->params.rawae3.data[0]);
252
-		reg_buf->isp_size[ISP2X_ID_RAWAE3] += size;
253
-		reg_buf->isp_stats_size[ISP2X_ID_RAWAE3] = size;
254
-		if (tmp_statsbuf->frame_id == reg_buf->frame_id)
255
-			memcpy(&reg_buf->reg[offset], &tmp_statsbuf->params.rawae3.data[0], size);
256
-		else
257
-			memset(&reg_buf->reg[offset], 0, size);
258
-		offset += size;
259
-	}
260
-
261
-	if (rkisp_debug_reg & ISP2X_MODULE_RAWAWB) {
262
-		size = 4 + ISP_RAWAWB_RAM_CTRL - ISP_RAWAWB_CTRL;
263
-		reg_buf->isp_size[ISP2X_ID_RAWAWB] = size;
264
-		reg_buf->isp_offset[ISP2X_ID_RAWAWB] = offset;
265
-		memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_RAWAWB_CTRL, size);
266
-		offset += size;
267
-
268
-		size = ISP2X_RAWAWB_RAMDATA_NUM * sizeof(tmp_statsbuf->params.rawawb.ramdata[0]);
269
-		reg_buf->isp_size[ISP2X_ID_RAWAWB] += size;
270
-		reg_buf->isp_stats_size[ISP2X_ID_RAWAWB] = size;
271
-		if (tmp_statsbuf->frame_id == reg_buf->frame_id)
272
-			memcpy(&reg_buf->reg[offset], &tmp_statsbuf->params.rawawb.ramdata[0], size);
273
-		else
274
-			memset(&reg_buf->reg[offset], 0, size);
275
-		offset += size;
276
-	}
277
-
278
-	if (rkisp_debug_reg & ISP2X_MODULE_RAWHIST0) {
279
-		size = 4 + ISP_RAWHIST_LITE_WEIGHT - ISP_RAWHIST_LITE_CTRL;
280
-		reg_buf->isp_size[ISP2X_ID_RAWHIST0] = size;
281
-		reg_buf->isp_offset[ISP2X_ID_RAWHIST0] = offset;
282
-		memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_RAWHIST_LITE_CTRL, size);
283
-		offset += size;
284
-
285
-		size = ISP2X_HIST_BIN_N_MAX * sizeof(tmp_statsbuf->params.rawhist0.hist_bin[0]);
286
-		reg_buf->isp_size[ISP2X_ID_RAWHIST0] += size;
287
-		reg_buf->isp_stats_size[ISP2X_ID_RAWHIST0] = size;
288
-		if (tmp_statsbuf->frame_id == reg_buf->frame_id)
289
-			memcpy(&reg_buf->reg[offset], &tmp_statsbuf->params.rawhist0.hist_bin[0], size);
290
-		else
291
-			memset(&reg_buf->reg[offset], 0, size);
292
-		offset += size;
293
-	}
294
-
295
-	if (rkisp_debug_reg & ISP2X_MODULE_RAWHIST1) {
296
-		size = 4 + ISP_RAWHIST_BIG_WEIGHT_BASE - ISP_RAWHIST_BIG_CTRL;
297
-		reg_buf->isp_size[ISP2X_ID_RAWHIST1] = size;
298
-		reg_buf->isp_offset[ISP2X_ID_RAWHIST1] = offset;
299
-		memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_RAWHIST_BIG1_BASE, size);
300
-		offset += size;
301
-
302
-		size = ISP2X_HIST_BIN_N_MAX * sizeof(tmp_statsbuf->params.rawhist1.hist_bin[0]);
303
-		reg_buf->isp_size[ISP2X_ID_RAWHIST1] += size;
304
-		reg_buf->isp_stats_size[ISP2X_ID_RAWHIST1] = size;
305
-		if (tmp_statsbuf->frame_id == reg_buf->frame_id)
306
-			memcpy(&reg_buf->reg[offset], &tmp_statsbuf->params.rawhist1.hist_bin[0], size);
307
-		else
308
-			memset(&reg_buf->reg[offset], 0, size);
309
-		offset += size;
310
-	}
311
-
312
-	if (rkisp_debug_reg & ISP2X_MODULE_RAWHIST2) {
313
-		size = 4 + ISP_RAWHIST_BIG_WEIGHT_BASE - ISP_RAWHIST_BIG_CTRL;
314
-		reg_buf->isp_size[ISP2X_ID_RAWHIST2] = size;
315
-		reg_buf->isp_offset[ISP2X_ID_RAWHIST2] = offset;
316
-		memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_RAWHIST_BIG2_BASE, size);
317
-		offset += size;
318
-
319
-		size = ISP2X_HIST_BIN_N_MAX * sizeof(tmp_statsbuf->params.rawhist2.hist_bin[0]);
320
-		reg_buf->isp_size[ISP2X_ID_RAWHIST2] += size;
321
-		reg_buf->isp_stats_size[ISP2X_ID_RAWHIST2] = size;
322
-		if (tmp_statsbuf->frame_id == reg_buf->frame_id)
323
-			memcpy(&reg_buf->reg[offset], &tmp_statsbuf->params.rawhist2.hist_bin[0], size);
324
-		else
325
-			memset(&reg_buf->reg[offset], 0, size);
326
-		offset += size;
327
-	}
328
-
329
-	if (rkisp_debug_reg & ISP2X_MODULE_RAWHIST3) {
330
-		size = 4 + ISP_RAWHIST_BIG_WEIGHT_BASE - ISP_RAWHIST_BIG_CTRL;
331
-		reg_buf->isp_size[ISP2X_ID_RAWHIST3] = size;
332
-		reg_buf->isp_offset[ISP2X_ID_RAWHIST3] = offset;
333
-		memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_RAWHIST_BIG3_BASE, size);
334
-		offset += size;
335
-
336
-		size = ISP2X_HIST_BIN_N_MAX * sizeof(tmp_statsbuf->params.rawhist3.hist_bin[0]);
337
-		reg_buf->isp_size[ISP2X_ID_RAWHIST3] += size;
338
-		reg_buf->isp_stats_size[ISP2X_ID_RAWHIST3] = size;
339
-		if (tmp_statsbuf->frame_id == reg_buf->frame_id)
340
-			memcpy(&reg_buf->reg[offset], &tmp_statsbuf->params.rawhist3.hist_bin[0], size);
341
-		else
342
-			memset(&reg_buf->reg[offset], 0, size);
343
-		offset += size;
344
-	}
345
-
346
-	if (rkisp_debug_reg & ISP2X_MODULE_HDRMGE) {
347
-		size = 4 + ISP_HDRMGE_OVER_Y16 - ISP_HDRMGE_CTRL;
348
-		reg_buf->isp_size[ISP2X_ID_HDRMGE] = size;
349
-		reg_buf->isp_offset[ISP2X_ID_HDRMGE] = offset;
350
-		memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_HDRMGE_CTRL, size);
351
-		offset += size;
352
-	}
353
-
354
-	if (rkisp_debug_reg & ISP2X_MODULE_RAWNR) {
355
-		size = 4 + ISP_RAWNR_RGBAIN_FLIP - ISP_RAWNR_CTRL;
356
-		reg_buf->isp_size[ISP2X_ID_RAWNR] = size;
357
-		reg_buf->isp_offset[ISP2X_ID_RAWNR] = offset;
358
-		memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_RAWNR_CTRL, size);
359
-		offset += size;
360
-	}
361
-
362
-	if (rkisp_debug_reg & ISP2X_MODULE_HDRTMO) {
363
-		size = 4 + ISP_HDRTMO_HIST_RO31 - ISP_HDRTMO_CTRL;
364
-		reg_buf->isp_size[ISP2X_ID_HDRTMO] = size;
365
-		reg_buf->isp_offset[ISP2X_ID_HDRTMO] = offset;
366
-		memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_HDRTMO_CTRL, size);
367
-		offset += size;
368
-	}
369
-
370
-	if (rkisp_debug_reg & ISP2X_MODULE_GIC) {
371
-		size = 4 + ISP_GIC_NOISE_CTRL1 - ISP_GIC_CONTROL;
372
-		reg_buf->isp_size[ISP2X_ID_GIC] = size;
373
-		reg_buf->isp_offset[ISP2X_ID_GIC] = offset;
374
-		memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_GIC_CONTROL, size);
375
-		offset += size;
376
-	}
377
-
378
-	if (rkisp_debug_reg & ISP2X_MODULE_DHAZ) {
379
-		size = 4 + ISP_DHAZ_HIST_REG95 - ISP_DHAZ_CTRL;
380
-		reg_buf->isp_size[ISP2X_ID_DHAZ] = size;
381
-		reg_buf->isp_offset[ISP2X_ID_DHAZ] = offset;
382
-		memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_DHAZ_CTRL, size);
383
-		offset += size;
384
-	}
385
-
386
-	if (rkisp_debug_reg & ISP2X_MODULE_3DLUT) {
387
-		size = 4 + ISP_3DLUT_UPDATE - ISP_3DLUT_CTRL;
388
-		reg_buf->isp_size[ISP2X_ID_3DLUT] = size;
389
-		reg_buf->isp_offset[ISP2X_ID_3DLUT] = offset;
390
-		memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_3DLUT_CTRL, size);
391
-		offset += size;
392
-	}
393
-
394
-	if (rkisp_debug_reg & ISP2X_MODULE_LDCH) {
395
-		size = 4 + ISP_LDCH_STS - ISP_LDCH_STS;
396
-		reg_buf->isp_size[ISP2X_ID_LDCH] = size;
397
-		reg_buf->isp_offset[ISP2X_ID_LDCH] = offset;
398
-		memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_LDCH_STS, size);
399
-		offset += size;
400
-	}
401
-
402
-	if (rkisp_debug_reg & ISP2X_MODULE_GAIN) {
403
-		size = 4 + ISP_GAIN_LUT8 - ISP_GAIN_CTRL;
404
-		reg_buf->isp_size[ISP2X_ID_GAIN] = size;
405
-		reg_buf->isp_offset[ISP2X_ID_GAIN] = offset;
406
-		memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_GAIN_CTRL, size);
407
-		offset += size;
408
-	}
409
-
410
-	if (rkisp_debug_reg & ISP2X_MODULE_DEBAYER) {
411
-		size = 4 + ISP_DEBAYER_C_FILTER - ISP_DEBAYER_CONTROL;
412
-		reg_buf->isp_size[ISP2X_ID_DEBAYER] = size;
413
-		reg_buf->isp_offset[ISP2X_ID_DEBAYER] = offset;
414
-		memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_DEBAYER_CONTROL, size);
415
-		offset += size;
416
-	}
417
-
418
-	reg_buf->reg_size = offset;
419
-}
420
-
421
-static void rkisp_bridge_try_sendtohal(struct rkisp_device *dev)
422
-{
423
-	struct rkisp_hw_dev *hw = dev->hw_dev;
424
-	struct rkisp_bridge_device *br_dev = &dev->br_dev;
425
-	struct rkisp_ispp_buf *cur_fbcgain = dev->cur_fbcgain;
426
-	struct rkisp_buffer *cur_spbuf = dev->cur_spbuf;
427
-	struct isp2x_ispgain_buf *buf;
428
-	struct rkisp_bridge_buf *bdgbuf;
429
-	struct vb2_buffer *vb2_buf;
430
-	u32 *vaddr, size;
431
-	u64 pic_ts, gain_ts, sp_ts;
432
-
433
-	if (cur_fbcgain && cur_spbuf) {
434
-		if ((cur_fbcgain->frame_id == cur_spbuf->vb.sequence) &&
435
-		    (cur_fbcgain->index == cur_spbuf->dev_id)) {
436
-			vb2_buf = &cur_spbuf->vb.vb2_buf;
437
-			cur_fbcgain->buf_idx = vb2_buf->index;
438
-			buf = vb2_plane_vaddr(vb2_buf, 1);
439
-			buf->gain_dmaidx = cur_fbcgain->gain_dmaidx;
440
-			buf->mfbc_dmaidx = cur_fbcgain->mfbc_dmaidx;
441
-			buf->gain_size = cur_fbcgain->gain_size;
442
-			buf->mfbc_size = cur_fbcgain->mfbc_size;
443
-			buf->frame_id = cur_fbcgain->frame_id;
444
-			bdgbuf = to_bridge_buf(cur_fbcgain);
445
-			rkisp_finish_buffer(dev, &bdgbuf->dummy[GROUP_BUF_GAIN]);
446
-			vb2_buffer_done(&cur_spbuf->vb.vb2_buf, VB2_BUF_STATE_DONE);
447
-			list_add_tail(&cur_fbcgain->list, &hw->rpt_list);
448
-			dev->cur_fbcgain = NULL;
449
-			dev->cur_spbuf = NULL;
450
-			v4l2_dbg(3, rkisp_debug, &br_dev->sd,
451
-				 "%s send mfbcgain buf to hal, frame_id %d\n",
452
-				 __func__, cur_fbcgain->frame_id);
453
-
454
-			bdgbuf = to_bridge_buf(cur_fbcgain);
455
-			vaddr = bdgbuf->dummy[GROUP_BUF_PIC].vaddr;
456
-			size = bdgbuf->dummy[GROUP_BUF_PIC].size;
457
-			pic_ts = *(u64 *)(vaddr + size / 4 - 2);
458
-
459
-			vaddr = bdgbuf->dummy[GROUP_BUF_GAIN].vaddr;
460
-			size = bdgbuf->dummy[GROUP_BUF_GAIN].size;
461
-			gain_ts = *(u64 *)(vaddr + size / 4 - 2);
462
-
463
-			size = vb2_plane_size(&cur_spbuf->vb.vb2_buf, 0);
464
-			vaddr = (u32 *)vb2_plane_vaddr(&cur_spbuf->vb.vb2_buf, 0);
465
-			sp_ts = *(u64 *)(vaddr + size / 4 - 2);
466
-			if (abs(pic_ts - gain_ts) > 5000000LL || abs(pic_ts - sp_ts) > 5000000LL ||
467
-			    abs(gain_ts - sp_ts) > 5000000LL) {
468
-				v4l2_info(&br_dev->sd,
469
-					"%s: frame %d, timestamp is not match (pic_ts %lld, gain_ts %lld, sp_ts %lld)\n",
470
-					__func__, cur_fbcgain->frame_id, pic_ts, gain_ts, sp_ts);
471
-			}
472
-		} else {
473
-			v4l2_info(&br_dev->sd,
474
-				  "%s frame_id(%d, %d) or dev_id(%d, %d) is not match\n",
475
-				  __func__,
476
-				  cur_fbcgain->frame_id, cur_spbuf->vb.sequence,
477
-				  cur_fbcgain->index, cur_spbuf->dev_id);
478
-		}
479
-	}
480
-}
481
-
482
-static void rkisp_bridge_save_fbcgain(struct rkisp_device *dev, struct rkisp_ispp_buf *fbcgain)
483
-{
484
-	struct rkisp_hw_dev *hw = dev->hw_dev;
485
-	struct rkisp_bridge_device *br_dev = &dev->br_dev;
486
-	unsigned long lock_flags = 0;
487
-
488
-	spin_lock_irqsave(&hw->buf_lock, lock_flags);
489
-	if (dev->cur_fbcgain) {
490
-		v4l2_dbg(1, rkisp_debug, &br_dev->sd,
491
-			 "%s old mfbcgain buf is exit, frame_id %d\n",
492
-			 __func__, dev->cur_fbcgain->frame_id);
493
-		list_add_tail(&dev->cur_fbcgain->list, &hw->list);
494
-		dev->cur_fbcgain = NULL;
495
-		br_dev->dbg.frameloss++;
496
-	}
497
-	dev->cur_fbcgain = fbcgain;
498
-	rkisp_bridge_try_sendtohal(dev);
499
-	spin_unlock_irqrestore(&hw->buf_lock, lock_flags);
500
-}
501
-
502
-static void rkisp_bridge_work(struct work_struct *work)
503
-{
504
-	struct rkisp_bridge_work *br_wk =
505
-		container_of(work, struct rkisp_bridge_work, work);
506
-	struct rkisp_bridge_device *dev = br_wk->dev;
507
-
508
-	struct rkisp_ispp_reg *reg_buf = (struct rkisp_ispp_reg *)br_wk->param;
509
-
510
-	dump_dbg_reg(dev, reg_buf);
511
-
512
-	kfree(br_wk);
513
-}
514
-
515
-static int frame_end(struct rkisp_bridge_device *dev, bool en, u32 state)
516
-{
517
-	struct rkisp_device *ispdev = dev->ispdev;
518
-	struct rkisp_hw_dev *hw = ispdev->hw_dev;
519
-	struct v4l2_subdev *sd = v4l2_get_subdev_hostdata(&dev->sd);
520
-	unsigned long lock_flags = 0;
521
-	u64 ns = ktime_get_ns();
522
-	struct rkisp_bridge_buf *buf;
523
-
524
-	if (state == FRAME_IRQ && ispdev->cap_dev.is_done_early)
525
-		return 0;
526
-	dev->frame_early = false;
527
-	rkisp_dmarx_get_frame(dev->ispdev, &dev->dbg.id, NULL, NULL, true);
528
-	dev->dbg.interval = ns - dev->dbg.timestamp;
529
-	dev->dbg.timestamp = ns;
530
-	if (hw->cur_buf && hw->nxt_buf) {
531
-		if (!en) {
532
-			spin_lock_irqsave(&hw->buf_lock, lock_flags);
533
-			list_add_tail(&hw->cur_buf->list, &hw->list);
534
-			spin_unlock_irqrestore(&hw->buf_lock, lock_flags);
535
-		} else if (dev->ispdev->skip_frame > 0) {
536
-			dev->ispdev->skip_frame--;
537
-			spin_lock_irqsave(&hw->buf_lock, lock_flags);
538
-			list_add_tail(&hw->cur_buf->list, &hw->list);
539
-			spin_unlock_irqrestore(&hw->buf_lock, lock_flags);
540
-		} else {
541
-			u64 sof_ns = 0;
542
-			struct rkisp_ispp_reg *reg_buf = NULL;
543
-
544
-			ns = 0;
545
-			rkisp_dmarx_get_frame(dev->ispdev,
546
-				&hw->cur_buf->frame_id, &sof_ns, &ns, true);
547
-			if (!sof_ns)
548
-				sof_ns = 0;
549
-			if (!ns)
550
-				ns = ktime_get_ns();
551
-			hw->cur_buf->frame_timestamp = ns;
552
-			hw->cur_buf->index = dev->ispdev->dev_id;
553
-			v4l2_subdev_call(sd, core, ioctl, RKISP_ISPP_CMD_REQUEST_REGBUF,
554
-					 &reg_buf);
555
-			if (reg_buf) {
556
-				struct rkisp_bridge_work *br_wk;
557
-
558
-				br_wk = kzalloc(sizeof(struct rkisp_bridge_work), GFP_ATOMIC);
559
-				if (br_wk) {
560
-					reg_buf->stat = ISP_ISPP_INUSE;
561
-					reg_buf->dev_id = hw->cur_buf->index;
562
-					reg_buf->frame_id = hw->cur_buf->frame_id;
563
-					reg_buf->sof_timestamp = sof_ns;
564
-					reg_buf->frame_timestamp = hw->cur_buf->frame_timestamp;
565
-					reg_buf->exposure = dev->ispdev->params_vdev.exposure;
566
-
567
-					br_wk->dev = dev;
568
-					br_wk->param = (void *)reg_buf;
569
-					INIT_WORK((struct work_struct *)&br_wk->work,
570
-						  rkisp_bridge_work);
571
-					if (!queue_work(dev->wq, (struct work_struct *)&br_wk->work)) {
572
-						v4l2_err(&dev->sd, "queue work failed\n");
573
-						kfree(br_wk);
574
-					}
575
-				}
576
-			}
577
-
578
-			if (dev->ispdev->send_fbcgain) {
579
-				u32 *vaddr, size;
580
-
581
-				buf = to_bridge_buf(hw->cur_buf);
582
-				vaddr = buf->dummy[GROUP_BUF_PIC].vaddr;
583
-				size = buf->dummy[GROUP_BUF_PIC].size;
584
-				*(u64 *)(vaddr + size / 4 - 2) = ktime_get_ns();
585
-
586
-				vaddr = buf->dummy[GROUP_BUF_GAIN].vaddr;
587
-				size = buf->dummy[GROUP_BUF_GAIN].size;
588
-				*(u64 *)(vaddr + size / 4 - 2) = ktime_get_ns();
589
-				hw->cur_buf->mfbc_dmaidx = hw->cur_buf->didx[GROUP_BUF_PIC];
590
-				hw->cur_buf->gain_dmaidx = hw->cur_buf->didx[GROUP_BUF_GAIN];
591
-				hw->cur_buf->is_move_judge = true;
592
-				rkisp_bridge_save_fbcgain(dev->ispdev, hw->cur_buf);
593
-			} else {
594
-				hw->cur_buf->is_move_judge = false;
595
-				v4l2_subdev_call(sd, video, s_rx_buffer, hw->cur_buf, NULL);
596
-			}
597
-		}
598
-		hw->cur_buf = NULL;
599
-	} else {
600
-		v4l2_dbg(1, rkisp_debug, &dev->sd, "no buf, lost frame:%d\n", dev->dbg.id);
601
-		dev->dbg.frameloss++;
602
-	}
603
-
604
-	if (hw->nxt_buf) {
605
-		hw->cur_buf = hw->nxt_buf;
606
-		hw->nxt_buf = NULL;
607
-	}
608
-
609
-	return 0;
610
-}
611
-
612
-static enum hrtimer_restart rkisp_bridge_frame_done_early(struct hrtimer *timer)
613
-{
614
-	struct rkisp_bridge_device *br =
615
-		container_of(timer, struct rkisp_bridge_device, frame_qst);
616
-	struct rkisp_device *dev = br->ispdev;
617
-	enum hrtimer_restart ret = HRTIMER_NORESTART;
618
-	u32 ycnt, line = dev->cap_dev.wait_line;
619
-	u32 seq, time, max_time = 1000000;
620
-	u64 ns = ktime_get_ns();
621
-
622
-	time = (u32)(ns - br->fs_ns);
623
-	ycnt = rkisp_read(dev, ISP_MPFBC_ENC_POS, true) & 0x3ff;
624
-	ycnt *= 8;
625
-	rkisp_dmarx_get_frame(dev, &seq, NULL, NULL, true);
626
-	if (!br->en || dev->isp_state == ISP_STOP) {
627
-		goto end;
628
-	} else if (ycnt < line) {
629
-		if (!ycnt)
630
-			ns = max_time;
631
-		else
632
-			ns = time * (line - ycnt) / ycnt;
633
-		if (ns > max_time)
634
-			ns = max_time;
635
-		hrtimer_forward(timer, timer->base->get_time(), ns_to_ktime(ns));
636
-		ret = HRTIMER_RESTART;
637
-	} else {
638
-		v4l2_dbg(3, rkisp_debug, &dev->v4l2_dev,
639
-			 "%s seq:%d line:%d ycnt:%d time:%dus\n",
640
-			 __func__, seq, line, ycnt, time / 1000);
641
-		frame_end(br, br->en, FRAME_WORK);
642
-	}
643
-end:
644
-	return ret;
645
-}
646
-
647
-static int config_gain(struct rkisp_bridge_device *dev)
648
-{
649
-	u32 w = dev->crop.width;
650
-	u32 h = dev->crop.height;
651
-	u32 val;
652
-
653
-	val = ALIGN(w, 64) * ALIGN(h, 128) >> 4;
654
-	rkisp_write(dev->ispdev, MI_GAIN_WR_SIZE, val, false);
655
-	val = ALIGN((w + 3) >> 2, 16);
656
-	rkisp_write(dev->ispdev, MI_GAIN_WR_LENGTH, val, false);
657
-	rkisp_set_bits(dev->ispdev, MI_WR_CTRL2,
658
-		       0, SW_GAIN_WR_AUTOUPD, true);
659
-	return 0;
660
-}
661
-
662
-static int config_mpfbc(struct rkisp_bridge_device *dev)
663
-{
664
-	struct rkisp_hw_dev *hw = dev->ispdev->hw_dev;
665
-	u32 h = hw->max_in.h ? hw->max_in.h : dev->crop.height;
666
-	u32 ctrl = 0;
667
-
668
-	if (dev->work_mode & ISP_ISPP_QUICK) {
669
-		rkisp_set_bits(dev->ispdev, CTRL_SWS_CFG,
670
-			       0, SW_ISP2PP_PIPE_EN, true);
671
-		ctrl = SW_MPFBC_MAINISP_MODE;
672
-		if (dev->ispdev->hw_dev->nxt_buf)
673
-			ctrl |= SW_MPFBC_PINGPONG_EN;
674
-	}
675
-
676
-	rkisp_write(dev->ispdev, ISP_MPFBC_VIR_WIDTH, 0, true);
677
-	rkisp_write(dev->ispdev, ISP_MPFBC_VIR_HEIGHT, ALIGN(h, 16), true);
678
-
679
-	ctrl |= (dev->work_mode & ISP_ISPP_422) | SW_MPFBC_EN;
680
-	rkisp_write(dev->ispdev, ISP_MPFBC_BASE, ctrl, true);
681
-	rkisp_set_bits(dev->ispdev, MI_WR_CTRL, MI_LUM_BURST_MASK,
682
-		       MI_MIPI_LUM_BURST16, true);
683
-	dev->ispdev->irq_ends_mask |= ISP_FRAME_MPFBC;
684
-	return 0;
685
-}
686
-
687
-static void disable_mpfbc(struct rkisp_bridge_device *dev)
688
-{
689
-	if (dev->ispdev->hw_dev->is_single)
690
-		rkisp_clear_bits(dev->ispdev, ISP_MPFBC_BASE,
691
-				 SW_MPFBC_EN, true);
692
-}
693
-
694
-static bool is_stopped_mpfbc(struct rkisp_bridge_device *dev)
695
-{
696
-	bool en = true;
697
-
698
-	if (dev->ispdev->hw_dev->is_single)
699
-		en = is_mpfbc_stopped(dev->ispdev->base_addr);
700
-	return en;
701
-}
702
-
703
-static struct rkisp_bridge_ops mpfbc_ops = {
704
-	.config = config_mpfbc,
705
-	.disable = disable_mpfbc,
706
-	.is_stopped = is_stopped_mpfbc,
707
-};
708
-
709
-static struct rkisp_bridge_config mpfbc_cfg = {
710
-	.frame_end_id = MI_MPFBC_FRAME,
711
-	.reg = {
712
-		.y0_base = ISP_MPFBC_HEAD_PTR,
713
-		.uv0_base = ISP_MPFBC_PAYL_PTR,
714
-		.y1_base = ISP_MPFBC_HEAD_PTR2,
715
-		.uv1_base = ISP_MPFBC_PAYL_PTR2,
716
-		.g0_base = MI_GAIN_WR_BASE,
717
-		.g1_base = MI_GAIN_WR_BASE2,
718
-
719
-		.y0_base_shd = ISP_MPFBC_HEAD_PTR,
720
-		.uv0_base_shd = ISP_MPFBC_PAYL_PTR,
721
-		.g0_base_shd = MI_GAIN_WR_BASE_SHD,
722
-	},
723
-};
724
-
725
-static int config_mp(struct rkisp_bridge_device *dev)
726
-{
727
-	u32 w = dev->crop.width;
728
-	u32 h = dev->crop.height;
729
-	u32 val;
730
-
731
-	if (dev->work_mode & ISP_ISPP_QUICK) {
732
-		rkisp_set_bits(dev->ispdev, CTRL_SWS_CFG, 0,
733
-			       SW_ISP2PP_PIPE_EN, true);
734
-		if (dev->ispdev->hw_dev->nxt_buf)
735
-			rkisp_set_bits(dev->ispdev, CIF_MI_CTRL, 0,
736
-				       CIF_MI_MP_PINGPONG_ENABLE, true);
737
-	}
738
-
739
-	val = w * h;
740
-	rkisp_write(dev->ispdev, CIF_MI_MP_Y_SIZE_INIT, val, false);
741
-	val = (dev->work_mode & ISP_ISPP_422) ? val : val / 2;
742
-	rkisp_write(dev->ispdev, CIF_MI_MP_CB_SIZE_INIT, val, false);
743
-	rkisp_write(dev->ispdev, CIF_MI_MP_CR_SIZE_INIT, 0, false);
744
-	rkisp_write(dev->ispdev, CIF_MI_MP_Y_OFFS_CNT_INIT, 0, false);
745
-	rkisp_write(dev->ispdev, CIF_MI_MP_CB_OFFS_CNT_INIT, 0, false);
746
-	rkisp_write(dev->ispdev, CIF_MI_MP_CR_OFFS_CNT_INIT, 0, false);
747
-
748
-	rkisp_write(dev->ispdev, ISP_MPFBC_BASE,
749
-		    dev->work_mode & ISP_ISPP_422, true);
750
-	rkisp_set_bits(dev->ispdev, CIF_MI_CTRL, MI_CTRL_MP_FMT_MASK,
751
-		       MI_CTRL_MP_WRITE_YUV_SPLA | CIF_MI_CTRL_MP_ENABLE |
752
-		       CIF_MI_MP_AUTOUPDATE_ENABLE, true);
753
-	dev->ispdev->irq_ends_mask |= ISP_FRAME_MP;
754
-	return 0;
755
-}
756
-
757
-static void disable_mp(struct rkisp_bridge_device *dev)
758
-{
759
-	if (dev->ispdev->hw_dev->is_single)
760
-		rkisp_clear_bits(dev->ispdev, CIF_MI_CTRL,
761
-				 CIF_MI_CTRL_MP_ENABLE |
762
-				 CIF_MI_CTRL_RAW_ENABLE, true);
763
-}
764
-
765
-static bool is_stopped_mp(struct rkisp_bridge_device *dev)
766
-{
767
-	bool en = true;
768
-
769
-	if (dev->ispdev->hw_dev->is_single)
770
-		en = mp_is_stream_stopped(dev->ispdev->base_addr);
771
-	return en;
772
-}
773
-
774
-static struct rkisp_bridge_ops mp_ops = {
775
-	.config = config_mp,
776
-	.disable = disable_mp,
777
-	.is_stopped = is_stopped_mp,
778
-};
779
-
780
-static struct rkisp_bridge_config mp_cfg = {
781
-	.frame_end_id = MI_MP_FRAME,
782
-	.reg = {
783
-		.y0_base = MI_MP_WR_Y_BASE,
784
-		.uv0_base = MI_MP_WR_CB_BASE,
785
-		.y1_base = MI_MP_WR_Y_BASE2,
786
-		.uv1_base = MI_MP_WR_CB_BASE2,
787
-		.g0_base = MI_GAIN_WR_BASE,
788
-		.g1_base = MI_GAIN_WR_BASE2,
789
-
790
-		.y0_base_shd = MI_MP_WR_Y_BASE_SHD,
791
-		.uv0_base_shd = MI_MP_WR_CB_BASE_SHD,
792
-		.g0_base_shd = MI_GAIN_WR_BASE_SHD,
793
-	},
794
-};
795
26
 
796
27
 static void free_bridge_buf(struct rkisp_bridge_device *dev)
797
28
 {
..
..
@@ -859,6 +90,7 @@
859
90
 	struct rkisp_dummy_buffer *dummy;
860
91
 	int i, j, val, ret = 0;
861
92
 	unsigned long lock_flags = 0;
93
+	bool is_direct = (hw->isp_ver == ISP_V20) ? true : false;
862
94
 
863
95
 	spin_lock_irqsave(&hw->buf_lock, lock_flags);
864
96
 	if (++hw->buf_init_cnt > 1) {
..
..
@@ -875,6 +107,8 @@
875
107
 	for (i = 0; i < dev->buf_num; i++) {
876
108
 		buf = &hw->bufs[i];
877
109
 		for (j = 0; j < GROUP_BUF_MAX; j++) {
110
+			if (j && hw->isp_ver == ISP_V30)
111
+				continue;
878
112
 			dummy = &buf->dummy[j];
879
113
 			dummy->is_need_vaddr = true;
880
114
 			dummy->is_need_dbuf = true;
..
..
@@ -896,7 +130,8 @@
896
130
 	for (i = 0; i < hw->dev_num; i++) {
897
131
 		struct rkisp_device *isp = hw->isp[i];
898
132
 
899
-		if (!(isp->isp_inp & INP_CSI))
133
+		if (!isp ||
134
+		    (isp && !(isp->isp_inp & INP_CSI)))
900
135
 			continue;
901
136
 		ret = rkisp_alloc_common_dummy_buf(isp);
902
137
 		if (ret < 0)
..
..
@@ -909,11 +144,13 @@
909
144
 	list_del(&hw->cur_buf->list);
910
145
 	buf = to_bridge_buf(hw->cur_buf);
911
146
 	val = buf->dummy[GROUP_BUF_PIC].dma_addr;
912
-	rkisp_write(dev->ispdev, dev->cfg->reg.y0_base, val, true);
147
+	rkisp_write(dev->ispdev, dev->cfg->reg.y0_base, val, is_direct);
913
148
 	val += dev->cfg->offset;
914
-	rkisp_write(dev->ispdev, dev->cfg->reg.uv0_base, val, true);
915
-	val = buf->dummy[GROUP_BUF_GAIN].dma_addr;
916
-	rkisp_write(dev->ispdev, dev->cfg->reg.g0_base, val, true);
149
+	rkisp_write(dev->ispdev, dev->cfg->reg.uv0_base, val, is_direct);
150
+	if (hw->isp_ver == ISP_V20) {
151
+		val = buf->dummy[GROUP_BUF_GAIN].dma_addr;
152
+		rkisp_write(dev->ispdev, dev->cfg->reg.g0_base, val, is_direct);
153
+	}
917
154
 
918
155
 	if (!list_empty(&hw->list)) {
919
156
 		hw->nxt_buf = list_first_entry(&hw->list,
..
..
@@ -957,7 +194,7 @@
957
194
 	u32 w = hw->max_in.w ? hw->max_in.w : dev->crop.width;
958
195
 	u32 h = hw->max_in.h ? hw->max_in.h : dev->crop.height;
959
196
 	u32 offs = w * h;
960
-	u32 pic_size = 0, gain_size;
197
+	u32 pic_size = 0, gain_size = 0;
961
198
 
962
199
 	if (dev->work_mode == ISP_ISPP_INIT_FAIL) {
963
200
 		free_bridge_buf(dev);
..
..
@@ -976,15 +213,14 @@
976
213
 		 "work mode:0x%x buf num:%d\n",
977
214
 		 dev->work_mode, dev->buf_num);
978
215
 
979
-	if (dev->work_mode & ISP_ISPP_FBC) {
980
-		dev->ops = &mpfbc_ops;
981
-		dev->cfg = &mpfbc_cfg;
216
+	if (hw->isp_ver == ISP_V20) {
217
+		gain_size = ALIGN(w, 64) * ALIGN(h, 128) >> 4;
218
+		rkisp_bridge_init_ops_v20(dev);
982
219
 	} else {
983
-		dev->ops = &mp_ops;
984
-		dev->cfg = &mp_cfg;
220
+		dev->work_mode &= ~(ISP_ISPP_FBC | ISP_ISPP_QUICK);
221
+		rkisp_bridge_init_ops_v30(dev);
985
222
 	}
986
223
 
987
-	gain_size = ALIGN(w, 64) * ALIGN(h, 128) >> 4;
988
224
 	if (dev->work_mode & ISP_ISPP_FBC) {
989
225
 		w = ALIGN(w, 16);
990
226
 		h = ALIGN(h, 16);
..
..
@@ -997,105 +233,11 @@
997
233
 		pic_size += w * h * 3 >> 1;
998
234
 	dev->cfg->offset = offs;
999
235
 
1000
-	pic_size += RKISP_MOTION_DECT_TS_SIZE;
1001
-	gain_size += RKISP_MOTION_DECT_TS_SIZE;
236
+	if (hw->isp_ver == ISP_V20) {
237
+		pic_size += RKISP_MOTION_DECT_TS_SIZE;
238
+		gain_size += RKISP_MOTION_DECT_TS_SIZE;
239
+	}
1002
240
 	return init_buf(dev, pic_size, gain_size);
1003
-}
1004
-
1005
-static void crop_on(struct rkisp_bridge_device *dev)
1006
-{
1007
-	struct rkisp_device *ispdev = dev->ispdev;
1008
-	u32 src_w = ispdev->isp_sdev.out_crop.width;
1009
-	u32 src_h = ispdev->isp_sdev.out_crop.height;
1010
-	u32 dest_w = dev->crop.width;
1011
-	u32 dest_h = dev->crop.height;
1012
-	u32 left = dev->crop.left;
1013
-	u32 top = dev->crop.top;
1014
-	u32 ctrl = CIF_DUAL_CROP_CFG_UPD;
1015
-
1016
-	if (ispdev->isp_ver == ISP_V20 &&
1017
-	    ispdev->rd_mode == HDR_RDBK_FRAME1 &&
1018
-	    ispdev->isp_sdev.in_fmt.fmt_type == FMT_BAYER)
1019
-		src_h += RKMODULE_EXTEND_LINE;
1020
-
1021
-	rkisp_write(ispdev, CIF_DUAL_CROP_M_H_OFFS, left, false);
1022
-	rkisp_write(ispdev, CIF_DUAL_CROP_M_V_OFFS, top, false);
1023
-	rkisp_write(ispdev, CIF_DUAL_CROP_M_H_SIZE, dest_w, false);
1024
-	rkisp_write(ispdev, CIF_DUAL_CROP_M_V_SIZE, dest_h, false);
1025
-	ctrl |= rkisp_read(ispdev, CIF_DUAL_CROP_CTRL, true);
1026
-	if (src_w == dest_w && src_h == dest_h)
1027
-		ctrl &= ~(CIF_DUAL_CROP_MP_MODE_YUV | CIF_DUAL_CROP_MP_MODE_RAW);
1028
-	else
1029
-		ctrl |= CIF_DUAL_CROP_MP_MODE_YUV;
1030
-	rkisp_write(ispdev, CIF_DUAL_CROP_CTRL, ctrl, false);
1031
-}
1032
-
1033
-static void crop_off(struct rkisp_bridge_device *dev)
1034
-{
1035
-	struct rkisp_device *ispdev = dev->ispdev;
1036
-	u32 ctrl = CIF_DUAL_CROP_GEN_CFG_UPD;
1037
-
1038
-	ctrl = rkisp_read(ispdev, CIF_DUAL_CROP_CTRL, true);
1039
-	ctrl &= ~(CIF_DUAL_CROP_MP_MODE_YUV | CIF_DUAL_CROP_MP_MODE_RAW);
1040
-	rkisp_write(ispdev, CIF_DUAL_CROP_CTRL, ctrl, false);
1041
-}
1042
-
1043
-static int bridge_start(struct rkisp_bridge_device *dev)
1044
-{
1045
-	struct rkisp_device *ispdev = dev->ispdev;
1046
-	struct rkisp_stream *sp_stream;
1047
-
1048
-	sp_stream = &dev->ispdev->cap_dev.stream[RKISP_STREAM_SP];
1049
-	crop_on(dev);
1050
-	config_gain(dev);
1051
-	dev->ops->config(dev);
1052
-	rkisp_start_spstream(sp_stream);
1053
-
1054
-	dev->ispdev->skip_frame = 0;
1055
-	dev->en = true;
1056
-
1057
-	ispdev->cap_dev.is_done_early = false;
1058
-	if (ispdev->send_fbcgain)
1059
-		ispdev->cap_dev.wait_line = 0;
1060
-	if (ispdev->cap_dev.wait_line) {
1061
-		if (ispdev->cap_dev.wait_line < dev->crop.height / 4)
1062
-			ispdev->cap_dev.wait_line = dev->crop.height / 4;
1063
-		ispdev->cap_dev.is_done_early = true;
1064
-	}
1065
-	return 0;
1066
-}
1067
-
1068
-static int bridge_stop(struct rkisp_bridge_device *dev)
1069
-{
1070
-	struct rkisp_stream *sp_stream;
1071
-	int ret;
1072
-	u32 irq;
1073
-
1074
-	sp_stream = &dev->ispdev->cap_dev.stream[RKISP_STREAM_SP];
1075
-	dev->stopping = true;
1076
-	dev->ops->disable(dev);
1077
-	rkisp_stop_spstream(sp_stream);
1078
-	hdr_stop_dmatx(dev->ispdev);
1079
-	ret = wait_event_timeout(dev->done, !dev->en,
1080
-				 msecs_to_jiffies(1000));
1081
-	if (!ret)
1082
-		v4l2_warn(&dev->sd,
1083
-			  "%s timeout ret:%d\n", __func__, ret);
1084
-	crop_off(dev);
1085
-	dev->stopping = false;
1086
-	dev->en = false;
1087
-	irq = dev->cfg->frame_end_id;
1088
-	irq = (irq == MI_MPFBC_FRAME) ? ISP_FRAME_MPFBC : ISP_FRAME_MP;
1089
-	dev->ispdev->irq_ends_mask &= ~irq;
1090
-	drain_workqueue(dev->wq);
1091
-
1092
-	/* make sure ispp last frame done */
1093
-	if (dev->work_mode & ISP_ISPP_QUICK) {
1094
-		rkisp_clear_bits(dev->ispdev, MI_IMSC,
1095
-				 dev->cfg->frame_end_id, true);
1096
-		usleep_range(20000, 25000);
1097
-	}
1098
-	return 0;
1099
241
 }
1100
242
 
1101
243
 static int bridge_start_stream(struct v4l2_subdev *sd)
..
..
@@ -1128,8 +270,7 @@
1128
270
 	if (ret < 0)
1129
271
 		goto free_buf;
1130
272
 
1131
-	hdr_config_dmatx(dev->ispdev);
1132
-	ret = bridge_start(dev);
273
+	ret = dev->ops->start(dev);
1133
274
 	if (ret)
1134
275
 		goto close_pipe;
1135
276
 
..
..
@@ -1146,7 +287,7 @@
1146
287
 pipe_stream_off:
1147
288
 	dev->ispdev->pipe.set_stream(&dev->ispdev->pipe, false);
1148
289
 stop_bridge:
1149
-	bridge_stop(dev);
290
+	dev->ops->stop(dev);
1150
291
 close_pipe:
1151
292
 	dev->ispdev->pipe.close(&dev->ispdev->pipe);
1152
293
 	hdr_destroy_buf(dev->ispdev);
..
..
@@ -1166,7 +307,7 @@
1166
307
 {
1167
308
 	struct rkisp_bridge_device *dev = v4l2_get_subdevdata(sd);
1168
309
 
1169
-	bridge_stop(dev);
310
+	dev->ops->stop(dev);
1170
311
 	media_pipeline_stop(&sd->entity);
1171
312
 	dev->ispdev->pipe.set_stream(&dev->ispdev->pipe, false);
1172
313
 	dev->ispdev->pipe.close(&dev->ispdev->pipe);
..
..
@@ -1294,9 +435,9 @@
1294
435
 		 "%s %d\n", __func__, on);
1295
436
 
1296
437
 	if (on)
1297
-		ret = v4l2_pipeline_pm_use(&sd->entity, 1);
438
+		ret = v4l2_pipeline_pm_get(&sd->entity);
1298
439
 	else
1299
-		ret = v4l2_pipeline_pm_use(&sd->entity, 0);
440
+		v4l2_pipeline_pm_put(&sd->entity);
1300
441
 
1301
442
 	return ret;
1302
443
 }
..
..
@@ -1350,157 +491,14 @@
1350
491
 	.pad = &bridge_pad_ops,
1351
492
 };
1352
493
 
1353
-int rkisp_bridge_get_fbcbuf_fd(struct rkisp_device *dev, struct isp2x_buf_idxfd *idxfd)
1354
-{
1355
-	struct rkisp_hw_dev *hw = dev->hw_dev;
1356
-	struct rkisp_bridge_device *br_dev = &dev->br_dev;
1357
-	struct rkisp_bridge_buf *buf;
1358
-	struct rkisp_dummy_buffer *dummy;
1359
-	unsigned long lock_flags = 0;
1360
-	int i, j, buf_idx;
1361
-
1362
-	spin_lock_irqsave(&hw->buf_lock, lock_flags);
1363
-	if (!hw->is_buf_init) {
1364
-		spin_unlock_irqrestore(&hw->buf_lock, lock_flags);
1365
-		return -EAGAIN;
1366
-	}
1367
-	spin_unlock_irqrestore(&hw->buf_lock, lock_flags);
1368
-
1369
-	buf_idx = 0;
1370
-	for (i = 0; i < br_dev->buf_num; i++) {
1371
-		buf = &hw->bufs[i];
1372
-		for (j = 0; j < GROUP_BUF_MAX; j++) {
1373
-			dummy = &buf->dummy[j];
1374
-			buf->dbufs.dfd[j] = dma_buf_fd(dummy->dbuf, O_CLOEXEC);
1375
-			get_dma_buf(buf->dbufs.dbuf[j]);
1376
-			idxfd->index[buf_idx] = buf->dbufs.didx[j];
1377
-			idxfd->dmafd[buf_idx] = buf->dbufs.dfd[j];
1378
-			buf_idx++;
1379
-		}
1380
-	}
1381
-
1382
-	idxfd->buf_num = buf_idx;
1383
-
1384
-	return 0;
1385
-}
1386
-
1387
-void rkisp_bridge_sendtopp_buffer(struct rkisp_device *dev, u32 dev_id, u32 buf_idx)
1388
-{
1389
-	struct rkisp_hw_dev *hw = dev->hw_dev;
1390
-	struct rkisp_bridge_device *br_dev = &dev->br_dev;
1391
-	struct v4l2_subdev *sd = v4l2_get_subdev_hostdata(&br_dev->sd);
1392
-	struct rkisp_ispp_buf *cur_buf, *cur_buf_tmp, *find_buf;
1393
-	struct rkisp_bridge_buf *buf;
1394
-	unsigned long lock_flags = 0;
1395
-	bool find_flg = false;
1396
-	u32 *vaddr, size;
1397
-	u64 pic_ts, gain_ts;
1398
-
1399
-	spin_lock_irqsave(&hw->buf_lock, lock_flags);
1400
-	list_for_each_entry(cur_buf, &hw->rpt_list, list) {
1401
-		if (cur_buf->index == dev_id && cur_buf->buf_idx == buf_idx) {
1402
-			find_flg = true;
1403
-			break;
1404
-		}
1405
-	}
1406
-
1407
-	if (find_flg) {
1408
-		list_del(&cur_buf->list);
1409
-		find_buf = cur_buf;
1410
-		list_for_each_entry_safe(cur_buf, cur_buf_tmp, &hw->rpt_list, list) {
1411
-			if ((cur_buf->frame_id < find_buf->frame_id) &&
1412
-				(cur_buf->index == find_buf->index)) {
1413
-				list_del_init(&cur_buf->list);
1414
-				v4l2_dbg(3, rkisp_debug, &br_dev->sd,
1415
-					 "%s send buffer to pp, frame_id %d\n",
1416
-					 __func__, cur_buf->frame_id);
1417
-
1418
-				buf = to_bridge_buf(cur_buf);
1419
-				rkisp_prepare_buffer(dev, &buf->dummy[GROUP_BUF_GAIN]);
1420
-				vaddr = buf->dummy[GROUP_BUF_PIC].vaddr;
1421
-				size = buf->dummy[GROUP_BUF_PIC].size;
1422
-				pic_ts = *(u64 *)(vaddr + size / 4 - 2);
1423
-
1424
-				vaddr = buf->dummy[GROUP_BUF_GAIN].vaddr;
1425
-				size = buf->dummy[GROUP_BUF_GAIN].size;
1426
-				gain_ts = *(u64 *)(vaddr + size / 4 - 2);
1427
-				if (abs(pic_ts - gain_ts) > 5000000LL) {
1428
-					v4l2_info(&br_dev->sd,
1429
-						"%s: frame %d, timestamp is not match (pic_ts %lld, gain_ts %lld)",
1430
-						__func__, cur_buf->frame_id, pic_ts, gain_ts);
1431
-				}
1432
-				cur_buf->is_move_judge = true;
1433
-				v4l2_subdev_call(sd, video, s_rx_buffer, cur_buf, NULL);
1434
-			}
1435
-		}
1436
-
1437
-		v4l2_dbg(3, rkisp_debug, &br_dev->sd,
1438
-			 "%s send buffer to pp, frame_id %d\n",
1439
-			 __func__, find_buf->frame_id);
1440
-
1441
-		buf = to_bridge_buf(find_buf);
1442
-		rkisp_prepare_buffer(dev, &buf->dummy[GROUP_BUF_GAIN]);
1443
-		vaddr = buf->dummy[GROUP_BUF_PIC].vaddr;
1444
-		size = buf->dummy[GROUP_BUF_PIC].size;
1445
-		pic_ts = *(u64 *)(vaddr + size / 4 - 2);
1446
-
1447
-		vaddr = buf->dummy[GROUP_BUF_GAIN].vaddr;
1448
-		size = buf->dummy[GROUP_BUF_GAIN].size;
1449
-		gain_ts = *(u64 *)(vaddr + size / 4 - 2);
1450
-		if (abs(pic_ts - gain_ts) > 5000000LL) {
1451
-			v4l2_info(&br_dev->sd,
1452
-				"%s: frame %d, timestamp is not match (pic_ts %lld, gain_ts %lld)",
1453
-				__func__, find_buf->frame_id, pic_ts, gain_ts);
1454
-		}
1455
-		find_buf->is_move_judge = true;
1456
-		v4l2_subdev_call(sd, video, s_rx_buffer, find_buf, NULL);
1457
-	}
1458
-	spin_unlock_irqrestore(&hw->buf_lock, lock_flags);
1459
-}
1460
-
1461
-void rkisp_bridge_save_spbuf(struct rkisp_device *dev, struct rkisp_buffer *sp_buf)
1462
-{
1463
-	struct rkisp_hw_dev *hw = dev->hw_dev;
1464
-	struct rkisp_bridge_device *br_dev = &dev->br_dev;
1465
-	unsigned long lock_flags = 0;
1466
-
1467
-	spin_lock_irqsave(&hw->buf_lock, lock_flags);
1468
-	if (dev->cur_spbuf) {
1469
-		v4l2_dbg(1, rkisp_debug, &br_dev->sd,
1470
-			 "%s old sp buf is exit, frame_id %d\n",
1471
-			 __func__, dev->cur_spbuf->vb.sequence);
1472
-		rkisp_spbuf_queue(&dev->cap_dev.stream[RKISP_STREAM_SP], dev->cur_spbuf);
1473
-		dev->cur_spbuf = NULL;
1474
-		dev->cap_dev.stream[RKISP_STREAM_SP].dbg.frameloss++;
1475
-	}
1476
-	dev->cur_spbuf = sp_buf;
1477
-	rkisp_bridge_try_sendtohal(dev);
1478
-	spin_unlock_irqrestore(&hw->buf_lock, lock_flags);
1479
-}
1480
-
1481
-void rkisp_bridge_stop_spstream(struct rkisp_device *dev)
1482
-{
1483
-	struct rkisp_hw_dev *hw = dev->hw_dev;
1484
-	unsigned long lock_flags = 0;
1485
-
1486
-	spin_lock_irqsave(&hw->buf_lock, lock_flags);
1487
-	if (dev->cur_spbuf) {
1488
-		rkisp_spbuf_queue(&dev->cap_dev.stream[RKISP_STREAM_SP], dev->cur_spbuf);
1489
-		dev->cur_spbuf = NULL;
1490
-	}
1491
-	spin_unlock_irqrestore(&hw->buf_lock, lock_flags);
1492
-}
1493
-
1494
494
 void rkisp_bridge_update_mi(struct rkisp_device *dev, u32 isp_mis)
1495
495
 {
1496
496
 	struct rkisp_bridge_device *br = &dev->br_dev;
1497
497
 	struct rkisp_hw_dev *hw = dev->hw_dev;
1498
-	struct rkisp_bridge_buf *buf;
1499
498
 	unsigned long lock_flags = 0;
1500
-	u32 val;
1501
499
 
1502
-	if (dev->isp_ver != ISP_V20 || !br->en ||
1503
-	    br->work_mode & ISP_ISPP_QUICK ||
500
+	if ((dev->isp_ver != ISP_V20 && dev->isp_ver != ISP_V30) ||
501
+	    !br->en || br->work_mode & ISP_ISPP_QUICK ||
1504
502
 	    isp_mis & CIF_ISP_FRAME)
1505
503
 		return;
1506
504
 
..
..
@@ -1513,27 +511,7 @@
1513
511
 	}
1514
512
 	spin_unlock_irqrestore(&hw->buf_lock, lock_flags);
1515
513
 
1516
-	if (hw->nxt_buf) {
1517
-		buf = to_bridge_buf(hw->nxt_buf);
1518
-		val = buf->dummy[GROUP_BUF_PIC].dma_addr;
1519
-		rkisp_write(dev, br->cfg->reg.y0_base, val, true);
1520
-		val += br->cfg->offset;
1521
-		rkisp_write(dev, br->cfg->reg.uv0_base, val, true);
1522
-		val = buf->dummy[GROUP_BUF_GAIN].dma_addr;
1523
-		rkisp_write(dev, br->cfg->reg.g0_base, val, true);
1524
-	}
1525
-
1526
-	if (dev->cap_dev.is_done_early && !br->frame_early) {
1527
-		br->frame_early = true;
1528
-		hrtimer_start(&br->frame_qst, ns_to_ktime(1000000), HRTIMER_MODE_REL);
1529
-	}
1530
-
1531
-	v4l2_dbg(2, rkisp_debug, &br->sd,
1532
-		 "update pic(shd:0x%x base:0x%x) gain(shd:0x%x base:0x%x)\n",
1533
-		 rkisp_read(dev, br->cfg->reg.y0_base_shd, true),
1534
-		 rkisp_read(dev, br->cfg->reg.y0_base, true),
1535
-		 rkisp_read(dev, br->cfg->reg.g0_base_shd, true),
1536
-		 rkisp_read(dev, br->cfg->reg.g0_base, true));
514
+	br->ops->update_mi(br);
1537
515
 }
1538
516
 
1539
517
 void rkisp_bridge_isr(u32 *mis_val, struct rkisp_device *dev)
..
..
@@ -1554,21 +532,31 @@
1554
532
 	*mis_val &= ~irq;
1555
533
 	writel(irq, base + CIF_MI_ICR);
1556
534
 
1557
-	if (bridge->stopping) {
1558
-		if (bridge->ops->is_stopped(bridge)) {
1559
-			bridge->en = false;
1560
-			bridge->stopping = false;
1561
-			wake_up(&bridge->done);
535
+	irq = (irq == MI_MPFBC_FRAME) ? ISP_FRAME_MPFBC : ISP_FRAME_MP;
536
+	bridge->ops->frame_end(bridge, FRAME_IRQ);
537
+
538
+	rkisp_check_idle(dev, irq);
539
+}
540
+
541
+static int check_remote_node(struct rkisp_device *ispdev)
542
+{
543
+	struct device *dev = ispdev->dev;
544
+	struct device_node *parent = dev->of_node;
545
+	struct device_node *remote = NULL;
546
+	int i, j;
547
+
548
+	for (i = 0; i < 3; i++) {
549
+		for (j = 0; j < 2; j++) {
550
+			remote = of_graph_get_remote_node(parent, i, j);
551
+			if (!remote)
552
+				continue;
553
+			of_node_put(remote);
554
+			if (strstr(of_node_full_name(remote), "ispp"))
555
+				return 0;
1562
556
 		}
1563
557
 	}
1564
558
 
1565
-	irq = (irq == MI_MPFBC_FRAME) ? ISP_FRAME_MPFBC : ISP_FRAME_MP;
1566
-	if (!(bridge->work_mode & ISP_ISPP_QUICK)) {
1567
-		frame_end(bridge, bridge->en, FRAME_IRQ);
1568
-		if (!bridge->en)
1569
-			dev->irq_ends_mask &= ~irq;
1570
-	}
1571
-	rkisp_check_idle(dev, irq);
559
+	return -ENODEV;
1572
560
 }
1573
561
 
1574
562
 int rkisp_register_bridge_subdev(struct rkisp_device *dev,
..
..
@@ -1580,7 +568,8 @@
1580
568
 	int ret;
1581
569
 
1582
570
 	memset(bridge, 0, sizeof(*bridge));
1583
-	if (dev->isp_ver != ISP_V20)
571
+	if ((dev->isp_ver != ISP_V20 && dev->isp_ver != ISP_V30) ||
572
+	    check_remote_node(dev) < 0)
1584
573
 		return 0;
1585
574
 
1586
575
 	bridge->ispdev = dev;
..
..
@@ -1612,7 +601,6 @@
1612
601
 	bridge->wq = alloc_workqueue("rkisp bridge workqueue",
1613
602
 				     WQ_UNBOUND | WQ_MEM_RECLAIM, 1);
1614
603
 	hrtimer_init(&bridge->frame_qst, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
1615
-	bridge->frame_qst.function = rkisp_bridge_frame_done_early;
1616
604
 	return ret;
1617
605
 
1618
606
 free_media:
..
..
@@ -1624,7 +612,8 @@
1624
612
 {
1625
613
 	struct v4l2_subdev *sd = &dev->br_dev.sd;
1626
614
 
1627
-	if (dev->isp_ver != ISP_V20)
615
+	if ((dev->isp_ver != ISP_V20 && dev->isp_ver != ISP_V30) ||
616
+	    check_remote_node(dev) < 0)
1628
617
 		return;
1629
618
 	v4l2_device_unregister_subdev(sd);
1630
619
 	media_entity_cleanup(&sd->entity);