1 // SPDX-License-Identifier: (GPL-2.0+ OR MIT)
2 /*
3  * Rockchip ISP1 Driver - ISP Subdevice
4  *
5  * Copyright (C) 2019 Collabora, Ltd.
6  *
7  * Based on Rockchip ISP1 driver by Rockchip Electronics Co., Ltd.
8  * Copyright (C) 2017 Rockchip Electronics Co., Ltd.
9  */
10 
11 #include <linux/iopoll.h>
12 #include <linux/pm_runtime.h>
13 #include <linux/videodev2.h>
14 #include <linux/vmalloc.h>
15 
16 #include <media/v4l2-event.h>
17 
18 #include "rkisp1-common.h"
19 
20 #define RKISP1_DEF_SINK_PAD_FMT MEDIA_BUS_FMT_SRGGB10_1X10
21 #define RKISP1_DEF_SRC_PAD_FMT MEDIA_BUS_FMT_YUYV8_2X8
22 
23 #define RKISP1_ISP_DEV_NAME	RKISP1_DRIVER_NAME "_isp"
24 
25 /*
26  * NOTE: MIPI controller and input MUX are also configured in this file.
27  * This is because ISP Subdev describes not only ISP submodule (input size,
28  * format, output size, format), but also a virtual route device.
29  */
30 
31 /*
32  * There are many variables named with format/frame in below code,
33  * please see here for their meaning.
34  * Cropping in the sink pad defines the image region from the sensor.
35  * Cropping in the source pad defines the region for the Image Stabilizer (IS)
36  *
37  * Cropping regions of ISP
38  *
39  * +---------------------------------------------------------+
40  * | Sensor image                                            |
41  * | +---------------------------------------------------+   |
42  * | | CIF_ISP_ACQ (for black level)                     |   |
43  * | | sink pad format                                   |   |
44  * | | +--------------------------------------------+    |   |
45  * | | |    CIF_ISP_OUT                             |    |   |
46  * | | |    sink pad crop                           |    |   |
47  * | | |    +---------------------------------+     |    |   |
48  * | | |    |   CIF_ISP_IS                    |     |    |   |
49  * | | |    |   source pad crop and format    |     |    |   |
50  * | | |    +---------------------------------+     |    |   |
51  * | | +--------------------------------------------+    |   |
52  * | +---------------------------------------------------+   |
53  * +---------------------------------------------------------+
54  */
55 
56 /* ----------------------------------------------------------------------------
57  * Helpers
58  */
59 
60 static struct v4l2_mbus_framefmt *
61 rkisp1_isp_get_pad_fmt(struct rkisp1_isp *isp,
62 		       struct v4l2_subdev_state *sd_state,
63 		       unsigned int pad, u32 which)
64 {
65 	struct v4l2_subdev_state state = {
66 		.pads = isp->pad_cfg
67 	};
68 
69 	if (which == V4L2_SUBDEV_FORMAT_TRY)
70 		return v4l2_subdev_get_try_format(&isp->sd, sd_state, pad);
71 	else
72 		return v4l2_subdev_get_try_format(&isp->sd, &state, pad);
73 }
74 
75 static struct v4l2_rect *
76 rkisp1_isp_get_pad_crop(struct rkisp1_isp *isp,
77 			struct v4l2_subdev_state *sd_state,
78 			unsigned int pad, u32 which)
79 {
80 	struct v4l2_subdev_state state = {
81 		.pads = isp->pad_cfg
82 	};
83 
84 	if (which == V4L2_SUBDEV_FORMAT_TRY)
85 		return v4l2_subdev_get_try_crop(&isp->sd, sd_state, pad);
86 	else
87 		return v4l2_subdev_get_try_crop(&isp->sd, &state, pad);
88 }
89 
90 /* ----------------------------------------------------------------------------
91  * Camera Interface registers configurations
92  */
93 
94 /*
95  * Image Stabilization.
96  * This should only be called when configuring CIF
97  * or at the frame end interrupt
98  */
99 static void rkisp1_config_ism(struct rkisp1_isp *isp)
100 {
101 	const struct v4l2_rect *src_crop =
102 		rkisp1_isp_get_pad_crop(isp, NULL,
103 					RKISP1_ISP_PAD_SOURCE_VIDEO,
104 					V4L2_SUBDEV_FORMAT_ACTIVE);
105 	struct rkisp1_device *rkisp1 = isp->rkisp1;
106 	u32 val;
107 
108 	rkisp1_write(rkisp1, RKISP1_CIF_ISP_IS_RECENTER, 0);
109 	rkisp1_write(rkisp1, RKISP1_CIF_ISP_IS_MAX_DX, 0);
110 	rkisp1_write(rkisp1, RKISP1_CIF_ISP_IS_MAX_DY, 0);
111 	rkisp1_write(rkisp1, RKISP1_CIF_ISP_IS_DISPLACE, 0);
112 	rkisp1_write(rkisp1, RKISP1_CIF_ISP_IS_H_OFFS, src_crop->left);
113 	rkisp1_write(rkisp1, RKISP1_CIF_ISP_IS_V_OFFS, src_crop->top);
114 	rkisp1_write(rkisp1, RKISP1_CIF_ISP_IS_H_SIZE, src_crop->width);
115 	rkisp1_write(rkisp1, RKISP1_CIF_ISP_IS_V_SIZE, src_crop->height);
116 
117 	/* IS(Image Stabilization) is always on, working as output crop */
118 	rkisp1_write(rkisp1, RKISP1_CIF_ISP_IS_CTRL, 1);
119 	val = rkisp1_read(rkisp1, RKISP1_CIF_ISP_CTRL);
120 	val |= RKISP1_CIF_ISP_CTRL_ISP_CFG_UPD;
121 	rkisp1_write(rkisp1, RKISP1_CIF_ISP_CTRL, val);
122 }
123 
124 /*
125  * configure ISP blocks with input format, size......
126  */
127 static int rkisp1_config_isp(struct rkisp1_isp *isp,
128 			     enum v4l2_mbus_type mbus_type, u32 mbus_flags)
129 {
130 	struct rkisp1_device *rkisp1 = isp->rkisp1;
131 	u32 isp_ctrl = 0, irq_mask = 0, acq_mult = 0, acq_prop = 0;
132 	const struct rkisp1_mbus_info *sink_fmt = isp->sink_fmt;
133 	const struct rkisp1_mbus_info *src_fmt = isp->src_fmt;
134 	const struct v4l2_mbus_framefmt *sink_frm;
135 	const struct v4l2_rect *sink_crop;
136 
137 	sink_frm = rkisp1_isp_get_pad_fmt(isp, NULL,
138 					  RKISP1_ISP_PAD_SINK_VIDEO,
139 					  V4L2_SUBDEV_FORMAT_ACTIVE);
140 	sink_crop = rkisp1_isp_get_pad_crop(isp, NULL,
141 					    RKISP1_ISP_PAD_SINK_VIDEO,
142 					    V4L2_SUBDEV_FORMAT_ACTIVE);
143 
144 	if (sink_fmt->pixel_enc == V4L2_PIXEL_ENC_BAYER) {
145 		acq_mult = 1;
146 		if (src_fmt->pixel_enc == V4L2_PIXEL_ENC_BAYER) {
147 			if (mbus_type == V4L2_MBUS_BT656)
148 				isp_ctrl = RKISP1_CIF_ISP_CTRL_ISP_MODE_RAW_PICT_ITU656;
149 			else
150 				isp_ctrl = RKISP1_CIF_ISP_CTRL_ISP_MODE_RAW_PICT;
151 		} else {
152 			rkisp1_write(rkisp1, RKISP1_CIF_ISP_DEMOSAIC,
153 				     RKISP1_CIF_ISP_DEMOSAIC_TH(0xc));
154 
155 			if (mbus_type == V4L2_MBUS_BT656)
156 				isp_ctrl = RKISP1_CIF_ISP_CTRL_ISP_MODE_BAYER_ITU656;
157 			else
158 				isp_ctrl = RKISP1_CIF_ISP_CTRL_ISP_MODE_BAYER_ITU601;
159 		}
160 	} else if (sink_fmt->pixel_enc == V4L2_PIXEL_ENC_YUV) {
161 		acq_mult = 2;
162 		if (mbus_type == V4L2_MBUS_CSI2_DPHY) {
163 			isp_ctrl = RKISP1_CIF_ISP_CTRL_ISP_MODE_ITU601;
164 		} else {
165 			if (mbus_type == V4L2_MBUS_BT656)
166 				isp_ctrl = RKISP1_CIF_ISP_CTRL_ISP_MODE_ITU656;
167 			else
168 				isp_ctrl = RKISP1_CIF_ISP_CTRL_ISP_MODE_ITU601;
169 		}
170 
171 		irq_mask |= RKISP1_CIF_ISP_DATA_LOSS;
172 	}
173 
174 	/* Set up input acquisition properties */
175 	if (mbus_type == V4L2_MBUS_BT656 || mbus_type == V4L2_MBUS_PARALLEL) {
176 		if (mbus_flags & V4L2_MBUS_PCLK_SAMPLE_RISING)
177 			acq_prop |= RKISP1_CIF_ISP_ACQ_PROP_POS_EDGE;
178 
179 		switch (sink_fmt->bus_width) {
180 		case 8:
181 			acq_prop |= RKISP1_CIF_ISP_ACQ_PROP_IN_SEL_8B_ZERO;
182 			break;
183 		case 10:
184 			acq_prop |= RKISP1_CIF_ISP_ACQ_PROP_IN_SEL_10B_ZERO;
185 			break;
186 		case 12:
187 			acq_prop |= RKISP1_CIF_ISP_ACQ_PROP_IN_SEL_12B;
188 			break;
189 		default:
190 			dev_err(rkisp1->dev, "Invalid bus width %u\n",
191 				sink_fmt->bus_width);
192 			return -EINVAL;
193 		}
194 	}
195 
196 	if (mbus_type == V4L2_MBUS_PARALLEL) {
197 		if (mbus_flags & V4L2_MBUS_VSYNC_ACTIVE_LOW)
198 			acq_prop |= RKISP1_CIF_ISP_ACQ_PROP_VSYNC_LOW;
199 
200 		if (mbus_flags & V4L2_MBUS_HSYNC_ACTIVE_LOW)
201 			acq_prop |= RKISP1_CIF_ISP_ACQ_PROP_HSYNC_LOW;
202 	}
203 
204 	rkisp1_write(rkisp1, RKISP1_CIF_ISP_CTRL, isp_ctrl);
205 	rkisp1_write(rkisp1, RKISP1_CIF_ISP_ACQ_PROP,
206 		     acq_prop | sink_fmt->yuv_seq |
207 		     RKISP1_CIF_ISP_ACQ_PROP_BAYER_PAT(sink_fmt->bayer_pat) |
208 		     RKISP1_CIF_ISP_ACQ_PROP_FIELD_SEL_ALL);
209 	rkisp1_write(rkisp1, RKISP1_CIF_ISP_ACQ_NR_FRAMES, 0);
210 
211 	/* Acquisition Size */
212 	rkisp1_write(rkisp1, RKISP1_CIF_ISP_ACQ_H_OFFS, 0);
213 	rkisp1_write(rkisp1, RKISP1_CIF_ISP_ACQ_V_OFFS, 0);
214 	rkisp1_write(rkisp1, RKISP1_CIF_ISP_ACQ_H_SIZE,
215 		     acq_mult * sink_frm->width);
216 	rkisp1_write(rkisp1, RKISP1_CIF_ISP_ACQ_V_SIZE, sink_frm->height);
217 
218 	/* ISP Out Area */
219 	rkisp1_write(rkisp1, RKISP1_CIF_ISP_OUT_H_OFFS, sink_crop->left);
220 	rkisp1_write(rkisp1, RKISP1_CIF_ISP_OUT_V_OFFS, sink_crop->top);
221 	rkisp1_write(rkisp1, RKISP1_CIF_ISP_OUT_H_SIZE, sink_crop->width);
222 	rkisp1_write(rkisp1, RKISP1_CIF_ISP_OUT_V_SIZE, sink_crop->height);
223 
224 	irq_mask |= RKISP1_CIF_ISP_FRAME | RKISP1_CIF_ISP_V_START |
225 		    RKISP1_CIF_ISP_PIC_SIZE_ERROR;
226 	rkisp1_write(rkisp1, RKISP1_CIF_ISP_IMSC, irq_mask);
227 
228 	if (src_fmt->pixel_enc == V4L2_PIXEL_ENC_BAYER) {
229 		rkisp1_params_disable(&rkisp1->params);
230 	} else {
231 		struct v4l2_mbus_framefmt *src_frm;
232 
233 		src_frm = rkisp1_isp_get_pad_fmt(isp, NULL,
234 						 RKISP1_ISP_PAD_SOURCE_VIDEO,
235 						 V4L2_SUBDEV_FORMAT_ACTIVE);
236 		rkisp1_params_pre_configure(&rkisp1->params, sink_fmt->bayer_pat,
237 					    src_frm->quantization,
238 					    src_frm->ycbcr_enc);
239 	}
240 
241 	return 0;
242 }
243 
244 /* Configure MUX */
245 static void rkisp1_config_path(struct rkisp1_isp *isp,
246 			       enum v4l2_mbus_type mbus_type)
247 {
248 	struct rkisp1_device *rkisp1 = isp->rkisp1;
249 	u32 dpcl = rkisp1_read(rkisp1, RKISP1_CIF_VI_DPCL);
250 
251 	if (mbus_type == V4L2_MBUS_BT656 || mbus_type == V4L2_MBUS_PARALLEL)
252 		dpcl |= RKISP1_CIF_VI_DPCL_IF_SEL_PARALLEL;
253 	else if (mbus_type == V4L2_MBUS_CSI2_DPHY)
254 		dpcl |= RKISP1_CIF_VI_DPCL_IF_SEL_MIPI;
255 
256 	rkisp1_write(rkisp1, RKISP1_CIF_VI_DPCL, dpcl);
257 }
258 
259 /* Hardware configure Entry */
260 static int rkisp1_config_cif(struct rkisp1_isp *isp,
261 			     enum v4l2_mbus_type mbus_type, u32 mbus_flags)
262 {
263 	int ret;
264 
265 	ret = rkisp1_config_isp(isp, mbus_type, mbus_flags);
266 	if (ret)
267 		return ret;
268 
269 	rkisp1_config_path(isp, mbus_type);
270 	rkisp1_config_ism(isp);
271 
272 	return 0;
273 }
274 
275 static void rkisp1_isp_stop(struct rkisp1_isp *isp)
276 {
277 	struct rkisp1_device *rkisp1 = isp->rkisp1;
278 	u32 val;
279 
280 	/*
281 	 * ISP(mi) stop in mi frame end -> Stop ISP(mipi) ->
282 	 * Stop ISP(isp) ->wait for ISP isp off
283 	 */
284 	/* stop and clear MI and ISP interrupts */
285 	rkisp1_write(rkisp1, RKISP1_CIF_ISP_IMSC, 0);
286 	rkisp1_write(rkisp1, RKISP1_CIF_ISP_ICR, ~0);
287 
288 	rkisp1_write(rkisp1, RKISP1_CIF_MI_IMSC, 0);
289 	rkisp1_write(rkisp1, RKISP1_CIF_MI_ICR, ~0);
290 
291 	/* stop ISP */
292 	val = rkisp1_read(rkisp1, RKISP1_CIF_ISP_CTRL);
293 	val &= ~(RKISP1_CIF_ISP_CTRL_ISP_INFORM_ENABLE |
294 		 RKISP1_CIF_ISP_CTRL_ISP_ENABLE);
295 	rkisp1_write(rkisp1, RKISP1_CIF_ISP_CTRL, val);
296 
297 	val = rkisp1_read(rkisp1,	RKISP1_CIF_ISP_CTRL);
298 	rkisp1_write(rkisp1, RKISP1_CIF_ISP_CTRL,
299 		     val | RKISP1_CIF_ISP_CTRL_ISP_CFG_UPD);
300 
301 	readx_poll_timeout(readl, rkisp1->base_addr + RKISP1_CIF_ISP_RIS,
302 			   val, val & RKISP1_CIF_ISP_OFF, 20, 100);
303 	rkisp1_write(rkisp1, RKISP1_CIF_VI_IRCL,
304 		     RKISP1_CIF_VI_IRCL_MIPI_SW_RST |
305 		     RKISP1_CIF_VI_IRCL_ISP_SW_RST);
306 	rkisp1_write(rkisp1, RKISP1_CIF_VI_IRCL, 0x0);
307 }
308 
309 static void rkisp1_config_clk(struct rkisp1_isp *isp)
310 {
311 	struct rkisp1_device *rkisp1 = isp->rkisp1;
312 
313 	u32 val = RKISP1_CIF_VI_ICCL_ISP_CLK | RKISP1_CIF_VI_ICCL_CP_CLK |
314 		  RKISP1_CIF_VI_ICCL_MRSZ_CLK | RKISP1_CIF_VI_ICCL_SRSZ_CLK |
315 		  RKISP1_CIF_VI_ICCL_JPEG_CLK | RKISP1_CIF_VI_ICCL_MI_CLK |
316 		  RKISP1_CIF_VI_ICCL_IE_CLK | RKISP1_CIF_VI_ICCL_MIPI_CLK |
317 		  RKISP1_CIF_VI_ICCL_DCROP_CLK;
318 
319 	rkisp1_write(rkisp1, RKISP1_CIF_VI_ICCL, val);
320 
321 	/* ensure sp and mp can run at the same time in V12 */
322 	if (rkisp1->info->isp_ver == RKISP1_V12) {
323 		val = RKISP1_CIF_CLK_CTRL_MI_Y12 | RKISP1_CIF_CLK_CTRL_MI_SP |
324 		      RKISP1_CIF_CLK_CTRL_MI_RAW0 | RKISP1_CIF_CLK_CTRL_MI_RAW1 |
325 		      RKISP1_CIF_CLK_CTRL_MI_READ | RKISP1_CIF_CLK_CTRL_MI_RAWRD |
326 		      RKISP1_CIF_CLK_CTRL_CP | RKISP1_CIF_CLK_CTRL_IE;
327 		rkisp1_write(rkisp1, RKISP1_CIF_VI_ISP_CLK_CTRL_V12, val);
328 	}
329 }
330 
331 static void rkisp1_isp_start(struct rkisp1_isp *isp)
332 {
333 	struct rkisp1_device *rkisp1 = isp->rkisp1;
334 	u32 val;
335 
336 	rkisp1_config_clk(isp);
337 
338 	/* Activate ISP */
339 	val = rkisp1_read(rkisp1, RKISP1_CIF_ISP_CTRL);
340 	val |= RKISP1_CIF_ISP_CTRL_ISP_CFG_UPD |
341 	       RKISP1_CIF_ISP_CTRL_ISP_ENABLE |
342 	       RKISP1_CIF_ISP_CTRL_ISP_INFORM_ENABLE;
343 	rkisp1_write(rkisp1, RKISP1_CIF_ISP_CTRL, val);
344 
345 	if (isp->src_fmt->pixel_enc != V4L2_PIXEL_ENC_BAYER)
346 		rkisp1_params_post_configure(&rkisp1->params);
347 }
348 
349 /* ----------------------------------------------------------------------------
350  * Subdev pad operations
351  */
352 
353 static inline struct rkisp1_isp *to_rkisp1_isp(struct v4l2_subdev *sd)
354 {
355 	return container_of(sd, struct rkisp1_isp, sd);
356 }
357 
358 static int rkisp1_isp_enum_mbus_code(struct v4l2_subdev *sd,
359 				     struct v4l2_subdev_state *sd_state,
360 				     struct v4l2_subdev_mbus_code_enum *code)
361 {
362 	unsigned int i, dir;
363 	int pos = 0;
364 
365 	if (code->pad == RKISP1_ISP_PAD_SINK_VIDEO) {
366 		dir = RKISP1_ISP_SD_SINK;
367 	} else if (code->pad == RKISP1_ISP_PAD_SOURCE_VIDEO) {
368 		dir = RKISP1_ISP_SD_SRC;
369 	} else {
370 		if (code->index > 0)
371 			return -EINVAL;
372 		code->code = MEDIA_BUS_FMT_METADATA_FIXED;
373 		return 0;
374 	}
375 
376 	for (i = 0; ; i++) {
377 		const struct rkisp1_mbus_info *fmt =
378 			rkisp1_mbus_info_get_by_index(i);
379 
380 		if (!fmt)
381 			return -EINVAL;
382 
383 		if (fmt->direction & dir)
384 			pos++;
385 
386 		if (code->index == pos - 1) {
387 			code->code = fmt->mbus_code;
388 			if (fmt->pixel_enc == V4L2_PIXEL_ENC_YUV &&
389 			    dir == RKISP1_ISP_SD_SRC)
390 				code->flags =
391 					V4L2_SUBDEV_MBUS_CODE_CSC_QUANTIZATION;
392 			return 0;
393 		}
394 	}
395 
396 	return -EINVAL;
397 }
398 
399 static int rkisp1_isp_enum_frame_size(struct v4l2_subdev *sd,
400 				      struct v4l2_subdev_state *sd_state,
401 				      struct v4l2_subdev_frame_size_enum *fse)
402 {
403 	const struct rkisp1_mbus_info *mbus_info;
404 
405 	if (fse->pad == RKISP1_ISP_PAD_SINK_PARAMS ||
406 	    fse->pad == RKISP1_ISP_PAD_SOURCE_STATS)
407 		return -ENOTTY;
408 
409 	if (fse->index > 0)
410 		return -EINVAL;
411 
412 	mbus_info = rkisp1_mbus_info_get_by_code(fse->code);
413 	if (!mbus_info)
414 		return -EINVAL;
415 
416 	if (!(mbus_info->direction & RKISP1_ISP_SD_SINK) &&
417 	    fse->pad == RKISP1_ISP_PAD_SINK_VIDEO)
418 		return -EINVAL;
419 
420 	if (!(mbus_info->direction & RKISP1_ISP_SD_SRC) &&
421 	    fse->pad == RKISP1_ISP_PAD_SOURCE_VIDEO)
422 		return -EINVAL;
423 
424 	fse->min_width = RKISP1_ISP_MIN_WIDTH;
425 	fse->max_width = RKISP1_ISP_MAX_WIDTH;
426 	fse->min_height = RKISP1_ISP_MIN_HEIGHT;
427 	fse->max_height = RKISP1_ISP_MAX_HEIGHT;
428 
429 	return 0;
430 }
431 
432 static int rkisp1_isp_init_config(struct v4l2_subdev *sd,
433 				  struct v4l2_subdev_state *sd_state)
434 {
435 	struct v4l2_mbus_framefmt *sink_fmt, *src_fmt;
436 	struct v4l2_rect *sink_crop, *src_crop;
437 
438 	/* Video. */
439 	sink_fmt = v4l2_subdev_get_try_format(sd, sd_state,
440 					      RKISP1_ISP_PAD_SINK_VIDEO);
441 	sink_fmt->width = RKISP1_DEFAULT_WIDTH;
442 	sink_fmt->height = RKISP1_DEFAULT_HEIGHT;
443 	sink_fmt->field = V4L2_FIELD_NONE;
444 	sink_fmt->code = RKISP1_DEF_SINK_PAD_FMT;
445 	sink_fmt->colorspace = V4L2_COLORSPACE_RAW;
446 	sink_fmt->xfer_func = V4L2_XFER_FUNC_NONE;
447 	sink_fmt->ycbcr_enc = V4L2_YCBCR_ENC_601;
448 	sink_fmt->quantization = V4L2_QUANTIZATION_FULL_RANGE;
449 
450 	sink_crop = v4l2_subdev_get_try_crop(sd, sd_state,
451 					     RKISP1_ISP_PAD_SINK_VIDEO);
452 	sink_crop->width = RKISP1_DEFAULT_WIDTH;
453 	sink_crop->height = RKISP1_DEFAULT_HEIGHT;
454 	sink_crop->left = 0;
455 	sink_crop->top = 0;
456 
457 	src_fmt = v4l2_subdev_get_try_format(sd, sd_state,
458 					     RKISP1_ISP_PAD_SOURCE_VIDEO);
459 	*src_fmt = *sink_fmt;
460 	src_fmt->code = RKISP1_DEF_SRC_PAD_FMT;
461 	src_fmt->colorspace = V4L2_COLORSPACE_SRGB;
462 	src_fmt->xfer_func = V4L2_XFER_FUNC_SRGB;
463 	src_fmt->ycbcr_enc = V4L2_YCBCR_ENC_601;
464 	src_fmt->quantization = V4L2_QUANTIZATION_LIM_RANGE;
465 
466 	src_crop = v4l2_subdev_get_try_crop(sd, sd_state,
467 					    RKISP1_ISP_PAD_SOURCE_VIDEO);
468 	*src_crop = *sink_crop;
469 
470 	/* Parameters and statistics. */
471 	sink_fmt = v4l2_subdev_get_try_format(sd, sd_state,
472 					      RKISP1_ISP_PAD_SINK_PARAMS);
473 	src_fmt = v4l2_subdev_get_try_format(sd, sd_state,
474 					     RKISP1_ISP_PAD_SOURCE_STATS);
475 	sink_fmt->width = 0;
476 	sink_fmt->height = 0;
477 	sink_fmt->field = V4L2_FIELD_NONE;
478 	sink_fmt->code = MEDIA_BUS_FMT_METADATA_FIXED;
479 	*src_fmt = *sink_fmt;
480 
481 	return 0;
482 }
483 
484 static void rkisp1_isp_set_src_fmt(struct rkisp1_isp *isp,
485 				   struct v4l2_subdev_state *sd_state,
486 				   struct v4l2_mbus_framefmt *format,
487 				   unsigned int which)
488 {
489 	const struct rkisp1_mbus_info *sink_info;
490 	const struct rkisp1_mbus_info *src_info;
491 	struct v4l2_mbus_framefmt *sink_fmt;
492 	struct v4l2_mbus_framefmt *src_fmt;
493 	const struct v4l2_rect *src_crop;
494 	bool set_csc;
495 
496 	sink_fmt = rkisp1_isp_get_pad_fmt(isp, sd_state,
497 					  RKISP1_ISP_PAD_SINK_VIDEO, which);
498 	src_fmt = rkisp1_isp_get_pad_fmt(isp, sd_state,
499 					 RKISP1_ISP_PAD_SOURCE_VIDEO, which);
500 	src_crop = rkisp1_isp_get_pad_crop(isp, sd_state,
501 					   RKISP1_ISP_PAD_SOURCE_VIDEO, which);
502 
503 	/*
504 	 * Media bus code. The ISP can operate in pass-through mode (Bayer in,
505 	 * Bayer out or YUV in, YUV out) or process Bayer data to YUV, but
506 	 * can't convert from YUV to Bayer.
507 	 */
508 	sink_info = rkisp1_mbus_info_get_by_code(sink_fmt->code);
509 
510 	src_fmt->code = format->code;
511 	src_info = rkisp1_mbus_info_get_by_code(src_fmt->code);
512 	if (!src_info || !(src_info->direction & RKISP1_ISP_SD_SRC)) {
513 		src_fmt->code = RKISP1_DEF_SRC_PAD_FMT;
514 		src_info = rkisp1_mbus_info_get_by_code(src_fmt->code);
515 	}
516 
517 	if (sink_info->pixel_enc == V4L2_PIXEL_ENC_YUV &&
518 	    src_info->pixel_enc == V4L2_PIXEL_ENC_BAYER) {
519 		src_fmt->code = sink_fmt->code;
520 		src_info = sink_info;
521 	}
522 
523 	/*
524 	 * The source width and height must be identical to the source crop
525 	 * size.
526 	 */
527 	src_fmt->width  = src_crop->width;
528 	src_fmt->height = src_crop->height;
529 
530 	/*
531 	 * Copy the color space for the sink pad. When converting from Bayer to
532 	 * YUV, default to a limited quantization range.
533 	 */
534 	src_fmt->colorspace = sink_fmt->colorspace;
535 	src_fmt->xfer_func = sink_fmt->xfer_func;
536 	src_fmt->ycbcr_enc = sink_fmt->ycbcr_enc;
537 
538 	if (sink_info->pixel_enc == V4L2_PIXEL_ENC_BAYER &&
539 	    src_info->pixel_enc == V4L2_PIXEL_ENC_YUV)
540 		src_fmt->quantization = V4L2_QUANTIZATION_LIM_RANGE;
541 	else
542 		src_fmt->quantization = sink_fmt->quantization;
543 
544 	/*
545 	 * Allow setting the source color space fields when the SET_CSC flag is
546 	 * set and the source format is YUV. If the sink format is YUV, don't
547 	 * set the color primaries, transfer function or YCbCr encoding as the
548 	 * ISP is bypassed in that case and passes YUV data through without
549 	 * modifications.
550 	 *
551 	 * The color primaries and transfer function are configured through the
552 	 * cross-talk matrix and tone curve respectively. Settings for those
553 	 * hardware blocks are conveyed through the ISP parameters buffer, as
554 	 * they need to combine color space information with other image tuning
555 	 * characteristics and can't thus be computed by the kernel based on the
556 	 * color space. The source pad colorspace and xfer_func fields are thus
557 	 * ignored by the driver, but can be set by userspace to propagate
558 	 * accurate color space information down the pipeline.
559 	 */
560 	set_csc = format->flags & V4L2_MBUS_FRAMEFMT_SET_CSC;
561 
562 	if (set_csc && src_info->pixel_enc == V4L2_PIXEL_ENC_YUV) {
563 		if (sink_info->pixel_enc == V4L2_PIXEL_ENC_BAYER) {
564 			if (format->colorspace != V4L2_COLORSPACE_DEFAULT)
565 				src_fmt->colorspace = format->colorspace;
566 			if (format->xfer_func != V4L2_XFER_FUNC_DEFAULT)
567 				src_fmt->xfer_func = format->xfer_func;
568 			if (format->ycbcr_enc != V4L2_YCBCR_ENC_DEFAULT)
569 				src_fmt->ycbcr_enc = format->ycbcr_enc;
570 		}
571 
572 		if (format->quantization != V4L2_QUANTIZATION_DEFAULT)
573 			src_fmt->quantization = format->quantization;
574 	}
575 
576 	*format = *src_fmt;
577 
578 	/*
579 	 * Restore the SET_CSC flag if it was set to indicate support for the
580 	 * CSC setting API.
581 	 */
582 	if (set_csc)
583 		format->flags |= V4L2_MBUS_FRAMEFMT_SET_CSC;
584 
585 	/* Store the source format info when setting the active format. */
586 	if (which == V4L2_SUBDEV_FORMAT_ACTIVE)
587 		isp->src_fmt = src_info;
588 }
589 
590 static void rkisp1_isp_set_src_crop(struct rkisp1_isp *isp,
591 				    struct v4l2_subdev_state *sd_state,
592 				    struct v4l2_rect *r, unsigned int which)
593 {
594 	struct v4l2_mbus_framefmt *src_fmt;
595 	const struct v4l2_rect *sink_crop;
596 	struct v4l2_rect *src_crop;
597 
598 	src_crop = rkisp1_isp_get_pad_crop(isp, sd_state,
599 					   RKISP1_ISP_PAD_SOURCE_VIDEO,
600 					   which);
601 	sink_crop = rkisp1_isp_get_pad_crop(isp, sd_state,
602 					    RKISP1_ISP_PAD_SINK_VIDEO,
603 					    which);
604 
605 	src_crop->left = ALIGN(r->left, 2);
606 	src_crop->width = ALIGN(r->width, 2);
607 	src_crop->top = r->top;
608 	src_crop->height = r->height;
609 	rkisp1_sd_adjust_crop_rect(src_crop, sink_crop);
610 
611 	*r = *src_crop;
612 
613 	/* Propagate to out format */
614 	src_fmt = rkisp1_isp_get_pad_fmt(isp, sd_state,
615 					 RKISP1_ISP_PAD_SOURCE_VIDEO, which);
616 	rkisp1_isp_set_src_fmt(isp, sd_state, src_fmt, which);
617 }
618 
619 static void rkisp1_isp_set_sink_crop(struct rkisp1_isp *isp,
620 				     struct v4l2_subdev_state *sd_state,
621 				     struct v4l2_rect *r, unsigned int which)
622 {
623 	struct v4l2_rect *sink_crop, *src_crop;
624 	const struct v4l2_mbus_framefmt *sink_fmt;
625 
626 	sink_crop = rkisp1_isp_get_pad_crop(isp, sd_state,
627 					    RKISP1_ISP_PAD_SINK_VIDEO,
628 					    which);
629 	sink_fmt = rkisp1_isp_get_pad_fmt(isp, sd_state,
630 					  RKISP1_ISP_PAD_SINK_VIDEO,
631 					  which);
632 
633 	sink_crop->left = ALIGN(r->left, 2);
634 	sink_crop->width = ALIGN(r->width, 2);
635 	sink_crop->top = r->top;
636 	sink_crop->height = r->height;
637 	rkisp1_sd_adjust_crop(sink_crop, sink_fmt);
638 
639 	*r = *sink_crop;
640 
641 	/* Propagate to out crop */
642 	src_crop = rkisp1_isp_get_pad_crop(isp, sd_state,
643 					   RKISP1_ISP_PAD_SOURCE_VIDEO, which);
644 	rkisp1_isp_set_src_crop(isp, sd_state, src_crop, which);
645 }
646 
647 static void rkisp1_isp_set_sink_fmt(struct rkisp1_isp *isp,
648 				    struct v4l2_subdev_state *sd_state,
649 				    struct v4l2_mbus_framefmt *format,
650 				    unsigned int which)
651 {
652 	const struct rkisp1_mbus_info *mbus_info;
653 	struct v4l2_mbus_framefmt *sink_fmt;
654 	struct v4l2_rect *sink_crop;
655 	bool is_yuv;
656 
657 	sink_fmt = rkisp1_isp_get_pad_fmt(isp, sd_state,
658 					  RKISP1_ISP_PAD_SINK_VIDEO,
659 					  which);
660 	sink_fmt->code = format->code;
661 	mbus_info = rkisp1_mbus_info_get_by_code(sink_fmt->code);
662 	if (!mbus_info || !(mbus_info->direction & RKISP1_ISP_SD_SINK)) {
663 		sink_fmt->code = RKISP1_DEF_SINK_PAD_FMT;
664 		mbus_info = rkisp1_mbus_info_get_by_code(sink_fmt->code);
665 	}
666 	if (which == V4L2_SUBDEV_FORMAT_ACTIVE)
667 		isp->sink_fmt = mbus_info;
668 
669 	sink_fmt->width = clamp_t(u32, format->width,
670 				  RKISP1_ISP_MIN_WIDTH,
671 				  RKISP1_ISP_MAX_WIDTH);
672 	sink_fmt->height = clamp_t(u32, format->height,
673 				   RKISP1_ISP_MIN_HEIGHT,
674 				   RKISP1_ISP_MAX_HEIGHT);
675 
676 	/*
677 	 * Adjust the color space fields. Accept any color primaries and
678 	 * transfer function for both YUV and Bayer. For YUV any YCbCr encoding
679 	 * and quantization range is also accepted. For Bayer formats, the YCbCr
680 	 * encoding isn't applicable, and the quantization range can only be
681 	 * full.
682 	 */
683 	is_yuv = mbus_info->pixel_enc == V4L2_PIXEL_ENC_YUV;
684 
685 	sink_fmt->colorspace = format->colorspace ? :
686 			       (is_yuv ? V4L2_COLORSPACE_SRGB :
687 				V4L2_COLORSPACE_RAW);
688 	sink_fmt->xfer_func = format->xfer_func ? :
689 			      V4L2_MAP_XFER_FUNC_DEFAULT(sink_fmt->colorspace);
690 	if (is_yuv) {
691 		sink_fmt->ycbcr_enc = format->ycbcr_enc ? :
692 			V4L2_MAP_YCBCR_ENC_DEFAULT(sink_fmt->colorspace);
693 		sink_fmt->quantization = format->quantization ? :
694 			V4L2_MAP_QUANTIZATION_DEFAULT(false, sink_fmt->colorspace,
695 						      sink_fmt->ycbcr_enc);
696 	} else {
697 		/*
698 		 * The YCbCr encoding isn't applicable for non-YUV formats, but
699 		 * V4L2 has no "no encoding" value. Hardcode it to Rec. 601, it
700 		 * should be ignored by userspace.
701 		 */
702 		sink_fmt->ycbcr_enc = V4L2_YCBCR_ENC_601;
703 		sink_fmt->quantization = V4L2_QUANTIZATION_FULL_RANGE;
704 	}
705 
706 	*format = *sink_fmt;
707 
708 	/* Propagate to in crop */
709 	sink_crop = rkisp1_isp_get_pad_crop(isp, sd_state,
710 					    RKISP1_ISP_PAD_SINK_VIDEO,
711 					    which);
712 	rkisp1_isp_set_sink_crop(isp, sd_state, sink_crop, which);
713 }
714 
715 static int rkisp1_isp_get_fmt(struct v4l2_subdev *sd,
716 			      struct v4l2_subdev_state *sd_state,
717 			      struct v4l2_subdev_format *fmt)
718 {
719 	struct rkisp1_isp *isp = to_rkisp1_isp(sd);
720 
721 	mutex_lock(&isp->ops_lock);
722 	fmt->format = *rkisp1_isp_get_pad_fmt(isp, sd_state, fmt->pad,
723 					      fmt->which);
724 	mutex_unlock(&isp->ops_lock);
725 	return 0;
726 }
727 
728 static int rkisp1_isp_set_fmt(struct v4l2_subdev *sd,
729 			      struct v4l2_subdev_state *sd_state,
730 			      struct v4l2_subdev_format *fmt)
731 {
732 	struct rkisp1_isp *isp = to_rkisp1_isp(sd);
733 
734 	mutex_lock(&isp->ops_lock);
735 	if (fmt->pad == RKISP1_ISP_PAD_SINK_VIDEO)
736 		rkisp1_isp_set_sink_fmt(isp, sd_state, &fmt->format,
737 					fmt->which);
738 	else if (fmt->pad == RKISP1_ISP_PAD_SOURCE_VIDEO)
739 		rkisp1_isp_set_src_fmt(isp, sd_state, &fmt->format,
740 				       fmt->which);
741 	else
742 		fmt->format = *rkisp1_isp_get_pad_fmt(isp, sd_state, fmt->pad,
743 						      fmt->which);
744 
745 	mutex_unlock(&isp->ops_lock);
746 	return 0;
747 }
748 
749 static int rkisp1_isp_get_selection(struct v4l2_subdev *sd,
750 				    struct v4l2_subdev_state *sd_state,
751 				    struct v4l2_subdev_selection *sel)
752 {
753 	struct rkisp1_isp *isp = to_rkisp1_isp(sd);
754 	int ret = 0;
755 
756 	if (sel->pad != RKISP1_ISP_PAD_SOURCE_VIDEO &&
757 	    sel->pad != RKISP1_ISP_PAD_SINK_VIDEO)
758 		return -EINVAL;
759 
760 	mutex_lock(&isp->ops_lock);
761 	switch (sel->target) {
762 	case V4L2_SEL_TGT_CROP_BOUNDS:
763 		if (sel->pad == RKISP1_ISP_PAD_SINK_VIDEO) {
764 			struct v4l2_mbus_framefmt *fmt;
765 
766 			fmt = rkisp1_isp_get_pad_fmt(isp, sd_state, sel->pad,
767 						     sel->which);
768 			sel->r.height = fmt->height;
769 			sel->r.width = fmt->width;
770 			sel->r.left = 0;
771 			sel->r.top = 0;
772 		} else {
773 			sel->r = *rkisp1_isp_get_pad_crop(isp, sd_state,
774 							  RKISP1_ISP_PAD_SINK_VIDEO,
775 							  sel->which);
776 		}
777 		break;
778 	case V4L2_SEL_TGT_CROP:
779 		sel->r = *rkisp1_isp_get_pad_crop(isp, sd_state, sel->pad,
780 						  sel->which);
781 		break;
782 	default:
783 		ret = -EINVAL;
784 	}
785 	mutex_unlock(&isp->ops_lock);
786 	return ret;
787 }
788 
789 static int rkisp1_isp_set_selection(struct v4l2_subdev *sd,
790 				    struct v4l2_subdev_state *sd_state,
791 				    struct v4l2_subdev_selection *sel)
792 {
793 	struct rkisp1_isp *isp = to_rkisp1_isp(sd);
794 	int ret = 0;
795 
796 	if (sel->target != V4L2_SEL_TGT_CROP)
797 		return -EINVAL;
798 
799 	dev_dbg(isp->rkisp1->dev, "%s: pad: %d sel(%d,%d)/%dx%d\n", __func__,
800 		sel->pad, sel->r.left, sel->r.top, sel->r.width, sel->r.height);
801 	mutex_lock(&isp->ops_lock);
802 	if (sel->pad == RKISP1_ISP_PAD_SINK_VIDEO)
803 		rkisp1_isp_set_sink_crop(isp, sd_state, &sel->r, sel->which);
804 	else if (sel->pad == RKISP1_ISP_PAD_SOURCE_VIDEO)
805 		rkisp1_isp_set_src_crop(isp, sd_state, &sel->r, sel->which);
806 	else
807 		ret = -EINVAL;
808 
809 	mutex_unlock(&isp->ops_lock);
810 	return ret;
811 }
812 
813 static int rkisp1_subdev_link_validate(struct media_link *link)
814 {
815 	if (link->sink->index == RKISP1_ISP_PAD_SINK_PARAMS)
816 		return 0;
817 
818 	return v4l2_subdev_link_validate(link);
819 }
820 
821 static const struct v4l2_subdev_pad_ops rkisp1_isp_pad_ops = {
822 	.enum_mbus_code = rkisp1_isp_enum_mbus_code,
823 	.enum_frame_size = rkisp1_isp_enum_frame_size,
824 	.get_selection = rkisp1_isp_get_selection,
825 	.set_selection = rkisp1_isp_set_selection,
826 	.init_cfg = rkisp1_isp_init_config,
827 	.get_fmt = rkisp1_isp_get_fmt,
828 	.set_fmt = rkisp1_isp_set_fmt,
829 	.link_validate = v4l2_subdev_link_validate_default,
830 };
831 
832 /* ----------------------------------------------------------------------------
833  * Stream operations
834  */
835 
836 static int rkisp1_isp_s_stream(struct v4l2_subdev *sd, int enable)
837 {
838 	struct rkisp1_isp *isp = to_rkisp1_isp(sd);
839 	struct rkisp1_device *rkisp1 = isp->rkisp1;
840 	struct media_pad *source_pad;
841 	struct media_pad *sink_pad;
842 	enum v4l2_mbus_type mbus_type;
843 	u32 mbus_flags;
844 	int ret;
845 
846 	if (!enable) {
847 		v4l2_subdev_call(rkisp1->source, video, s_stream, false);
848 		rkisp1_isp_stop(isp);
849 		return 0;
850 	}
851 
852 	sink_pad = &isp->pads[RKISP1_ISP_PAD_SINK_VIDEO];
853 	source_pad = media_pad_remote_pad_unique(sink_pad);
854 	if (IS_ERR(source_pad)) {
855 		dev_dbg(rkisp1->dev, "Failed to get source for ISP: %ld\n",
856 			PTR_ERR(source_pad));
857 		return -EPIPE;
858 	}
859 
860 	rkisp1->source = media_entity_to_v4l2_subdev(source_pad->entity);
861 	if (!rkisp1->source) {
862 		/* This should really not happen, so is not worth a message. */
863 		return -EPIPE;
864 	}
865 
866 	if (rkisp1->source == &rkisp1->csi.sd) {
867 		mbus_type = V4L2_MBUS_CSI2_DPHY;
868 		mbus_flags = 0;
869 	} else {
870 		const struct rkisp1_sensor_async *asd;
871 		struct v4l2_async_connection *asc;
872 
873 		asc = v4l2_async_connection_unique(rkisp1->source);
874 		if (!asc)
875 			return -EPIPE;
876 
877 		asd = container_of(asc, struct rkisp1_sensor_async, asd);
878 
879 		mbus_type = asd->mbus_type;
880 		mbus_flags = asd->mbus_flags;
881 	}
882 
883 	isp->frame_sequence = -1;
884 	mutex_lock(&isp->ops_lock);
885 	ret = rkisp1_config_cif(isp, mbus_type, mbus_flags);
886 	if (ret)
887 		goto mutex_unlock;
888 
889 	rkisp1_isp_start(isp);
890 
891 	ret = v4l2_subdev_call(rkisp1->source, video, s_stream, true);
892 	if (ret) {
893 		rkisp1_isp_stop(isp);
894 		goto mutex_unlock;
895 	}
896 
897 mutex_unlock:
898 	mutex_unlock(&isp->ops_lock);
899 	return ret;
900 }
901 
902 static int rkisp1_isp_subs_evt(struct v4l2_subdev *sd, struct v4l2_fh *fh,
903 			       struct v4l2_event_subscription *sub)
904 {
905 	if (sub->type != V4L2_EVENT_FRAME_SYNC)
906 		return -EINVAL;
907 
908 	/* V4L2_EVENT_FRAME_SYNC doesn't require an id, so zero should be set */
909 	if (sub->id != 0)
910 		return -EINVAL;
911 
912 	return v4l2_event_subscribe(fh, sub, 0, NULL);
913 }
914 
915 static const struct media_entity_operations rkisp1_isp_media_ops = {
916 	.link_validate = rkisp1_subdev_link_validate,
917 };
918 
919 static const struct v4l2_subdev_video_ops rkisp1_isp_video_ops = {
920 	.s_stream = rkisp1_isp_s_stream,
921 };
922 
923 static const struct v4l2_subdev_core_ops rkisp1_isp_core_ops = {
924 	.subscribe_event = rkisp1_isp_subs_evt,
925 	.unsubscribe_event = v4l2_event_subdev_unsubscribe,
926 };
927 
928 static const struct v4l2_subdev_ops rkisp1_isp_ops = {
929 	.core = &rkisp1_isp_core_ops,
930 	.video = &rkisp1_isp_video_ops,
931 	.pad = &rkisp1_isp_pad_ops,
932 };
933 
934 int rkisp1_isp_register(struct rkisp1_device *rkisp1)
935 {
936 	struct v4l2_subdev_state state = {
937 		.pads = rkisp1->isp.pad_cfg
938 	};
939 	struct rkisp1_isp *isp = &rkisp1->isp;
940 	struct media_pad *pads = isp->pads;
941 	struct v4l2_subdev *sd = &isp->sd;
942 	int ret;
943 
944 	isp->rkisp1 = rkisp1;
945 
946 	v4l2_subdev_init(sd, &rkisp1_isp_ops);
947 	sd->flags |= V4L2_SUBDEV_FL_HAS_DEVNODE | V4L2_SUBDEV_FL_HAS_EVENTS;
948 	sd->entity.ops = &rkisp1_isp_media_ops;
949 	sd->entity.function = MEDIA_ENT_F_PROC_VIDEO_PIXEL_FORMATTER;
950 	sd->owner = THIS_MODULE;
951 	strscpy(sd->name, RKISP1_ISP_DEV_NAME, sizeof(sd->name));
952 
953 	pads[RKISP1_ISP_PAD_SINK_VIDEO].flags = MEDIA_PAD_FL_SINK |
954 						MEDIA_PAD_FL_MUST_CONNECT;
955 	pads[RKISP1_ISP_PAD_SINK_PARAMS].flags = MEDIA_PAD_FL_SINK;
956 	pads[RKISP1_ISP_PAD_SOURCE_VIDEO].flags = MEDIA_PAD_FL_SOURCE;
957 	pads[RKISP1_ISP_PAD_SOURCE_STATS].flags = MEDIA_PAD_FL_SOURCE;
958 
959 	isp->sink_fmt = rkisp1_mbus_info_get_by_code(RKISP1_DEF_SINK_PAD_FMT);
960 	isp->src_fmt = rkisp1_mbus_info_get_by_code(RKISP1_DEF_SRC_PAD_FMT);
961 
962 	mutex_init(&isp->ops_lock);
963 	ret = media_entity_pads_init(&sd->entity, RKISP1_ISP_PAD_MAX, pads);
964 	if (ret)
965 		goto error;
966 
967 	ret = v4l2_device_register_subdev(&rkisp1->v4l2_dev, sd);
968 	if (ret) {
969 		dev_err(rkisp1->dev, "Failed to register isp subdev\n");
970 		goto error;
971 	}
972 
973 	rkisp1_isp_init_config(sd, &state);
974 
975 	return 0;
976 
977 error:
978 	media_entity_cleanup(&sd->entity);
979 	mutex_destroy(&isp->ops_lock);
980 	isp->sd.v4l2_dev = NULL;
981 	return ret;
982 }
983 
984 void rkisp1_isp_unregister(struct rkisp1_device *rkisp1)
985 {
986 	struct rkisp1_isp *isp = &rkisp1->isp;
987 
988 	if (!isp->sd.v4l2_dev)
989 		return;
990 
991 	v4l2_device_unregister_subdev(&isp->sd);
992 	media_entity_cleanup(&isp->sd.entity);
993 	mutex_destroy(&isp->ops_lock);
994 }
995 
996 /* ----------------------------------------------------------------------------
997  * Interrupt handlers
998  */
999 
1000 static void rkisp1_isp_queue_event_sof(struct rkisp1_isp *isp)
1001 {
1002 	struct v4l2_event event = {
1003 		.type = V4L2_EVENT_FRAME_SYNC,
1004 	};
1005 
1006 	event.u.frame_sync.frame_sequence = isp->frame_sequence;
1007 	v4l2_event_queue(isp->sd.devnode, &event);
1008 }
1009 
1010 irqreturn_t rkisp1_isp_isr(int irq, void *ctx)
1011 {
1012 	struct device *dev = ctx;
1013 	struct rkisp1_device *rkisp1 = dev_get_drvdata(dev);
1014 	u32 status, isp_err;
1015 
1016 	status = rkisp1_read(rkisp1, RKISP1_CIF_ISP_MIS);
1017 	if (!status)
1018 		return IRQ_NONE;
1019 
1020 	rkisp1_write(rkisp1, RKISP1_CIF_ISP_ICR, status);
1021 
1022 	/* Vertical sync signal, starting generating new frame */
1023 	if (status & RKISP1_CIF_ISP_V_START) {
1024 		rkisp1->isp.frame_sequence++;
1025 		rkisp1_isp_queue_event_sof(&rkisp1->isp);
1026 		if (status & RKISP1_CIF_ISP_FRAME) {
1027 			WARN_ONCE(1, "irq delay is too long, buffers might not be in sync\n");
1028 			rkisp1->debug.irq_delay++;
1029 		}
1030 	}
1031 	if (status & RKISP1_CIF_ISP_PIC_SIZE_ERROR) {
1032 		/* Clear pic_size_error */
1033 		isp_err = rkisp1_read(rkisp1, RKISP1_CIF_ISP_ERR);
1034 		if (isp_err & RKISP1_CIF_ISP_ERR_INFORM_SIZE)
1035 			rkisp1->debug.inform_size_error++;
1036 		if (isp_err & RKISP1_CIF_ISP_ERR_IS_SIZE)
1037 			rkisp1->debug.img_stabilization_size_error++;
1038 		if (isp_err & RKISP1_CIF_ISP_ERR_OUTFORM_SIZE)
1039 			rkisp1->debug.outform_size_error++;
1040 		rkisp1_write(rkisp1, RKISP1_CIF_ISP_ERR_CLR, isp_err);
1041 	} else if (status & RKISP1_CIF_ISP_DATA_LOSS) {
1042 		/* keep track of data_loss in debugfs */
1043 		rkisp1->debug.data_loss++;
1044 	}
1045 
1046 	if (status & RKISP1_CIF_ISP_FRAME) {
1047 		u32 isp_ris;
1048 
1049 		/* New frame from the sensor received */
1050 		isp_ris = rkisp1_read(rkisp1, RKISP1_CIF_ISP_RIS);
1051 		if (isp_ris & RKISP1_STATS_MEAS_MASK)
1052 			rkisp1_stats_isr(&rkisp1->stats, isp_ris);
1053 		/*
1054 		 * Then update changed configs. Some of them involve
1055 		 * lot of register writes. Do those only one per frame.
1056 		 * Do the updates in the order of the processing flow.
1057 		 */
1058 		rkisp1_params_isr(rkisp1);
1059 	}
1060 
1061 	return IRQ_HANDLED;
1062 }
1063