1 // SPDX-License-Identifier: (GPL-2.0+ OR MIT)
2 /*
3  * Rockchip ISP1 Driver - V4l resizer device
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 "rkisp1-common.h"
12 
13 #define RKISP1_RSZ_SP_DEV_NAME	RKISP1_DRIVER_NAME "_resizer_selfpath"
14 #define RKISP1_RSZ_MP_DEV_NAME	RKISP1_DRIVER_NAME "_resizer_mainpath"
15 
16 #define RKISP1_DEF_FMT MEDIA_BUS_FMT_YUYV8_2X8
17 #define RKISP1_DEF_PIXEL_ENC V4L2_PIXEL_ENC_YUV
18 
19 struct rkisp1_rsz_yuv_mbus_info {
20 	u32 mbus_code;
21 	u32 hdiv;
22 	u32 vdiv;
23 };
24 
25 static const struct rkisp1_rsz_yuv_mbus_info rkisp1_rsz_yuv_src_formats[] = {
26 	{
27 		.mbus_code	= MEDIA_BUS_FMT_YUYV8_2X8, /* YUV422 */
28 		.hdiv		= 2,
29 		.vdiv		= 1,
30 	},
31 	{
32 		.mbus_code	= MEDIA_BUS_FMT_YUYV8_1_5X8, /* YUV420 */
33 		.hdiv		= 2,
34 		.vdiv		= 2,
35 	},
36 };
37 
38 static const struct rkisp1_rsz_yuv_mbus_info *rkisp1_rsz_get_yuv_mbus_info(u32 mbus_code)
39 {
40 	unsigned int i;
41 
42 	for (i = 0; i < ARRAY_SIZE(rkisp1_rsz_yuv_src_formats); i++) {
43 		if (rkisp1_rsz_yuv_src_formats[i].mbus_code == mbus_code)
44 			return &rkisp1_rsz_yuv_src_formats[i];
45 	}
46 
47 	return NULL;
48 }
49 
50 enum rkisp1_shadow_regs_when {
51 	RKISP1_SHADOW_REGS_SYNC,
52 	RKISP1_SHADOW_REGS_ASYNC,
53 };
54 
55 struct rkisp1_rsz_config {
56 	/* constrains */
57 	const int max_rsz_width;
58 	const int max_rsz_height;
59 	const int min_rsz_width;
60 	const int min_rsz_height;
61 	/* registers */
62 	struct {
63 		u32 ctrl;
64 		u32 yuvmode_mask;
65 		u32 rawmode_mask;
66 		u32 h_offset;
67 		u32 v_offset;
68 		u32 h_size;
69 		u32 v_size;
70 	} dual_crop;
71 };
72 
73 static const struct rkisp1_rsz_config rkisp1_rsz_config_mp = {
74 	/* constraints */
75 	.max_rsz_width = RKISP1_RSZ_MP_SRC_MAX_WIDTH,
76 	.max_rsz_height = RKISP1_RSZ_MP_SRC_MAX_HEIGHT,
77 	.min_rsz_width = RKISP1_RSZ_SRC_MIN_WIDTH,
78 	.min_rsz_height = RKISP1_RSZ_SRC_MIN_HEIGHT,
79 	/* registers */
80 	.dual_crop = {
81 		.ctrl =			RKISP1_CIF_DUAL_CROP_CTRL,
82 		.yuvmode_mask =		RKISP1_CIF_DUAL_CROP_MP_MODE_YUV,
83 		.rawmode_mask =		RKISP1_CIF_DUAL_CROP_MP_MODE_RAW,
84 		.h_offset =		RKISP1_CIF_DUAL_CROP_M_H_OFFS,
85 		.v_offset =		RKISP1_CIF_DUAL_CROP_M_V_OFFS,
86 		.h_size =		RKISP1_CIF_DUAL_CROP_M_H_SIZE,
87 		.v_size =		RKISP1_CIF_DUAL_CROP_M_V_SIZE,
88 	},
89 };
90 
91 static const struct rkisp1_rsz_config rkisp1_rsz_config_sp = {
92 	/* constraints */
93 	.max_rsz_width = RKISP1_RSZ_SP_SRC_MAX_WIDTH,
94 	.max_rsz_height = RKISP1_RSZ_SP_SRC_MAX_HEIGHT,
95 	.min_rsz_width = RKISP1_RSZ_SRC_MIN_WIDTH,
96 	.min_rsz_height = RKISP1_RSZ_SRC_MIN_HEIGHT,
97 	/* registers */
98 	.dual_crop = {
99 		.ctrl =			RKISP1_CIF_DUAL_CROP_CTRL,
100 		.yuvmode_mask =		RKISP1_CIF_DUAL_CROP_SP_MODE_YUV,
101 		.rawmode_mask =		RKISP1_CIF_DUAL_CROP_SP_MODE_RAW,
102 		.h_offset =		RKISP1_CIF_DUAL_CROP_S_H_OFFS,
103 		.v_offset =		RKISP1_CIF_DUAL_CROP_S_V_OFFS,
104 		.h_size =		RKISP1_CIF_DUAL_CROP_S_H_SIZE,
105 		.v_size =		RKISP1_CIF_DUAL_CROP_S_V_SIZE,
106 	},
107 };
108 
109 static inline u32 rkisp1_rsz_read(struct rkisp1_resizer *rsz, u32 offset)
110 {
111 	return rkisp1_read(rsz->rkisp1, rsz->regs_base + offset);
112 }
113 
114 static inline void rkisp1_rsz_write(struct rkisp1_resizer *rsz, u32 offset,
115 				    u32 value)
116 {
117 	rkisp1_write(rsz->rkisp1, rsz->regs_base + offset, value);
118 }
119 
120 static struct v4l2_mbus_framefmt *
121 rkisp1_rsz_get_pad_fmt(struct rkisp1_resizer *rsz,
122 		       struct v4l2_subdev_state *sd_state,
123 		       unsigned int pad, u32 which)
124 {
125 	struct v4l2_subdev_state state = {
126 		.pads = rsz->pad_cfg,
127 	};
128 	if (which == V4L2_SUBDEV_FORMAT_TRY)
129 		return v4l2_subdev_get_try_format(&rsz->sd, sd_state, pad);
130 	else
131 		return v4l2_subdev_get_try_format(&rsz->sd, &state, pad);
132 }
133 
134 static struct v4l2_rect *
135 rkisp1_rsz_get_pad_crop(struct rkisp1_resizer *rsz,
136 			struct v4l2_subdev_state *sd_state,
137 			unsigned int pad, u32 which)
138 {
139 	struct v4l2_subdev_state state = {
140 		.pads = rsz->pad_cfg,
141 	};
142 	if (which == V4L2_SUBDEV_FORMAT_TRY)
143 		return v4l2_subdev_get_try_crop(&rsz->sd, sd_state, pad);
144 	else
145 		return v4l2_subdev_get_try_crop(&rsz->sd, &state, pad);
146 }
147 
148 /* ----------------------------------------------------------------------------
149  * Dual crop hw configs
150  */
151 
152 static void rkisp1_dcrop_disable(struct rkisp1_resizer *rsz,
153 				 enum rkisp1_shadow_regs_when when)
154 {
155 	u32 dc_ctrl = rkisp1_read(rsz->rkisp1, rsz->config->dual_crop.ctrl);
156 	u32 mask = ~(rsz->config->dual_crop.yuvmode_mask |
157 		     rsz->config->dual_crop.rawmode_mask);
158 
159 	dc_ctrl &= mask;
160 	if (when == RKISP1_SHADOW_REGS_ASYNC)
161 		dc_ctrl |= RKISP1_CIF_DUAL_CROP_GEN_CFG_UPD;
162 	else
163 		dc_ctrl |= RKISP1_CIF_DUAL_CROP_CFG_UPD;
164 	rkisp1_write(rsz->rkisp1, rsz->config->dual_crop.ctrl, dc_ctrl);
165 }
166 
167 /* configure dual-crop unit */
168 static void rkisp1_dcrop_config(struct rkisp1_resizer *rsz)
169 {
170 	struct rkisp1_device *rkisp1 = rsz->rkisp1;
171 	struct v4l2_mbus_framefmt *sink_fmt;
172 	struct v4l2_rect *sink_crop;
173 	u32 dc_ctrl;
174 
175 	sink_crop = rkisp1_rsz_get_pad_crop(rsz, NULL, RKISP1_RSZ_PAD_SINK,
176 					    V4L2_SUBDEV_FORMAT_ACTIVE);
177 	sink_fmt = rkisp1_rsz_get_pad_fmt(rsz, NULL, RKISP1_RSZ_PAD_SINK,
178 					  V4L2_SUBDEV_FORMAT_ACTIVE);
179 
180 	if (sink_crop->width == sink_fmt->width &&
181 	    sink_crop->height == sink_fmt->height &&
182 	    sink_crop->left == 0 && sink_crop->top == 0) {
183 		rkisp1_dcrop_disable(rsz, RKISP1_SHADOW_REGS_SYNC);
184 		dev_dbg(rkisp1->dev, "capture %d crop disabled\n", rsz->id);
185 		return;
186 	}
187 
188 	dc_ctrl = rkisp1_read(rkisp1, rsz->config->dual_crop.ctrl);
189 	rkisp1_write(rkisp1, rsz->config->dual_crop.h_offset, sink_crop->left);
190 	rkisp1_write(rkisp1, rsz->config->dual_crop.v_offset, sink_crop->top);
191 	rkisp1_write(rkisp1, rsz->config->dual_crop.h_size, sink_crop->width);
192 	rkisp1_write(rkisp1, rsz->config->dual_crop.v_size, sink_crop->height);
193 	dc_ctrl |= rsz->config->dual_crop.yuvmode_mask;
194 	dc_ctrl |= RKISP1_CIF_DUAL_CROP_CFG_UPD;
195 	rkisp1_write(rkisp1, rsz->config->dual_crop.ctrl, dc_ctrl);
196 
197 	dev_dbg(rkisp1->dev, "stream %d crop: %dx%d -> %dx%d\n", rsz->id,
198 		sink_fmt->width, sink_fmt->height,
199 		sink_crop->width, sink_crop->height);
200 }
201 
202 /* ----------------------------------------------------------------------------
203  * Resizer hw configs
204  */
205 
206 static void rkisp1_rsz_update_shadow(struct rkisp1_resizer *rsz,
207 				     enum rkisp1_shadow_regs_when when)
208 {
209 	u32 ctrl_cfg = rkisp1_rsz_read(rsz, RKISP1_CIF_RSZ_CTRL);
210 
211 	if (when == RKISP1_SHADOW_REGS_ASYNC)
212 		ctrl_cfg |= RKISP1_CIF_RSZ_CTRL_CFG_UPD_AUTO;
213 	else
214 		ctrl_cfg |= RKISP1_CIF_RSZ_CTRL_CFG_UPD;
215 
216 	rkisp1_rsz_write(rsz, RKISP1_CIF_RSZ_CTRL, ctrl_cfg);
217 }
218 
219 static u32 rkisp1_rsz_calc_ratio(u32 len_sink, u32 len_src)
220 {
221 	if (len_sink < len_src)
222 		return ((len_sink - 1) * RKISP1_CIF_RSZ_SCALER_FACTOR) /
223 		       (len_src - 1);
224 
225 	return ((len_src - 1) * RKISP1_CIF_RSZ_SCALER_FACTOR) /
226 	       (len_sink - 1) + 1;
227 }
228 
229 static void rkisp1_rsz_disable(struct rkisp1_resizer *rsz,
230 			       enum rkisp1_shadow_regs_when when)
231 {
232 	rkisp1_rsz_write(rsz, RKISP1_CIF_RSZ_CTRL, 0);
233 
234 	if (when == RKISP1_SHADOW_REGS_SYNC)
235 		rkisp1_rsz_update_shadow(rsz, when);
236 }
237 
238 static void rkisp1_rsz_config_regs(struct rkisp1_resizer *rsz,
239 				   struct v4l2_rect *sink_y,
240 				   struct v4l2_rect *sink_c,
241 				   struct v4l2_rect *src_y,
242 				   struct v4l2_rect *src_c,
243 				   enum rkisp1_shadow_regs_when when)
244 {
245 	u32 ratio, rsz_ctrl = 0;
246 	unsigned int i;
247 
248 	/* No phase offset */
249 	rkisp1_rsz_write(rsz, RKISP1_CIF_RSZ_PHASE_HY, 0);
250 	rkisp1_rsz_write(rsz, RKISP1_CIF_RSZ_PHASE_HC, 0);
251 	rkisp1_rsz_write(rsz, RKISP1_CIF_RSZ_PHASE_VY, 0);
252 	rkisp1_rsz_write(rsz, RKISP1_CIF_RSZ_PHASE_VC, 0);
253 
254 	/* Linear interpolation */
255 	for (i = 0; i < 64; i++) {
256 		rkisp1_rsz_write(rsz, RKISP1_CIF_RSZ_SCALE_LUT_ADDR, i);
257 		rkisp1_rsz_write(rsz, RKISP1_CIF_RSZ_SCALE_LUT, i);
258 	}
259 
260 	if (sink_y->width != src_y->width) {
261 		rsz_ctrl |= RKISP1_CIF_RSZ_CTRL_SCALE_HY_ENABLE;
262 		if (sink_y->width < src_y->width)
263 			rsz_ctrl |= RKISP1_CIF_RSZ_CTRL_SCALE_HY_UP;
264 		ratio = rkisp1_rsz_calc_ratio(sink_y->width, src_y->width);
265 		rkisp1_rsz_write(rsz, RKISP1_CIF_RSZ_SCALE_HY, ratio);
266 	}
267 
268 	if (sink_c->width != src_c->width) {
269 		rsz_ctrl |= RKISP1_CIF_RSZ_CTRL_SCALE_HC_ENABLE;
270 		if (sink_c->width < src_c->width)
271 			rsz_ctrl |= RKISP1_CIF_RSZ_CTRL_SCALE_HC_UP;
272 		ratio = rkisp1_rsz_calc_ratio(sink_c->width, src_c->width);
273 		rkisp1_rsz_write(rsz, RKISP1_CIF_RSZ_SCALE_HCB, ratio);
274 		rkisp1_rsz_write(rsz, RKISP1_CIF_RSZ_SCALE_HCR, ratio);
275 	}
276 
277 	if (sink_y->height != src_y->height) {
278 		rsz_ctrl |= RKISP1_CIF_RSZ_CTRL_SCALE_VY_ENABLE;
279 		if (sink_y->height < src_y->height)
280 			rsz_ctrl |= RKISP1_CIF_RSZ_CTRL_SCALE_VY_UP;
281 		ratio = rkisp1_rsz_calc_ratio(sink_y->height, src_y->height);
282 		rkisp1_rsz_write(rsz, RKISP1_CIF_RSZ_SCALE_VY, ratio);
283 	}
284 
285 	if (sink_c->height != src_c->height) {
286 		rsz_ctrl |= RKISP1_CIF_RSZ_CTRL_SCALE_VC_ENABLE;
287 		if (sink_c->height < src_c->height)
288 			rsz_ctrl |= RKISP1_CIF_RSZ_CTRL_SCALE_VC_UP;
289 		ratio = rkisp1_rsz_calc_ratio(sink_c->height, src_c->height);
290 		rkisp1_rsz_write(rsz, RKISP1_CIF_RSZ_SCALE_VC, ratio);
291 	}
292 
293 	rkisp1_rsz_write(rsz, RKISP1_CIF_RSZ_CTRL, rsz_ctrl);
294 
295 	rkisp1_rsz_update_shadow(rsz, when);
296 }
297 
298 static void rkisp1_rsz_config(struct rkisp1_resizer *rsz,
299 			      enum rkisp1_shadow_regs_when when)
300 {
301 	const struct rkisp1_rsz_yuv_mbus_info *sink_yuv_info, *src_yuv_info;
302 	struct v4l2_rect sink_y, sink_c, src_y, src_c;
303 	struct v4l2_mbus_framefmt *src_fmt, *sink_fmt;
304 	struct v4l2_rect *sink_crop;
305 
306 	sink_crop = rkisp1_rsz_get_pad_crop(rsz, NULL, RKISP1_RSZ_PAD_SINK,
307 					    V4L2_SUBDEV_FORMAT_ACTIVE);
308 	src_fmt = rkisp1_rsz_get_pad_fmt(rsz, NULL, RKISP1_RSZ_PAD_SRC,
309 					 V4L2_SUBDEV_FORMAT_ACTIVE);
310 	src_yuv_info = rkisp1_rsz_get_yuv_mbus_info(src_fmt->code);
311 	sink_fmt = rkisp1_rsz_get_pad_fmt(rsz, NULL, RKISP1_RSZ_PAD_SINK,
312 					  V4L2_SUBDEV_FORMAT_ACTIVE);
313 	sink_yuv_info = rkisp1_rsz_get_yuv_mbus_info(sink_fmt->code);
314 
315 	/*
316 	 * The resizer only works on yuv formats,
317 	 * so return if it is bayer format.
318 	 */
319 	if (rsz->pixel_enc == V4L2_PIXEL_ENC_BAYER) {
320 		rkisp1_rsz_disable(rsz, when);
321 		return;
322 	}
323 
324 	sink_y.width = sink_crop->width;
325 	sink_y.height = sink_crop->height;
326 	src_y.width = src_fmt->width;
327 	src_y.height = src_fmt->height;
328 
329 	sink_c.width = sink_y.width / sink_yuv_info->hdiv;
330 	sink_c.height = sink_y.height / sink_yuv_info->vdiv;
331 
332 	/*
333 	 * The resizer is used not only to change the dimensions of the frame
334 	 * but also to change the scale for YUV formats,
335 	 * (4:2:2 -> 4:2:0 for example). So the width/height of the CbCr
336 	 * streams should be set according to the media bus format in the src pad.
337 	 */
338 	src_c.width = src_y.width / src_yuv_info->hdiv;
339 	src_c.height = src_y.height / src_yuv_info->vdiv;
340 
341 	if (sink_c.width == src_c.width && sink_c.height == src_c.height) {
342 		rkisp1_rsz_disable(rsz, when);
343 		return;
344 	}
345 
346 	dev_dbg(rsz->rkisp1->dev, "stream %d rsz/scale: %dx%d -> %dx%d\n",
347 		rsz->id, sink_crop->width, sink_crop->height,
348 		src_fmt->width, src_fmt->height);
349 	dev_dbg(rsz->rkisp1->dev, "chroma scaling %dx%d -> %dx%d\n",
350 		sink_c.width, sink_c.height, src_c.width, src_c.height);
351 
352 	/* set values in the hw */
353 	rkisp1_rsz_config_regs(rsz, &sink_y, &sink_c, &src_y, &src_c, when);
354 }
355 
356 /* ----------------------------------------------------------------------------
357  * Subdev pad operations
358  */
359 
360 static int rkisp1_rsz_enum_mbus_code(struct v4l2_subdev *sd,
361 				     struct v4l2_subdev_state *sd_state,
362 				     struct v4l2_subdev_mbus_code_enum *code)
363 {
364 	struct rkisp1_resizer *rsz =
365 		container_of(sd, struct rkisp1_resizer, sd);
366 	struct v4l2_subdev_pad_config dummy_cfg;
367 	struct v4l2_subdev_state pad_state = {
368 		.pads = &dummy_cfg
369 	};
370 	u32 pad = code->pad;
371 	int ret;
372 
373 	if (code->pad == RKISP1_RSZ_PAD_SRC) {
374 		/* supported mbus codes on the src are the same as in the capture */
375 		struct rkisp1_capture *cap = &rsz->rkisp1->capture_devs[rsz->id];
376 
377 		return rkisp1_cap_enum_mbus_codes(cap, code);
378 	}
379 
380 	/*
381 	 * The selfpath capture doesn't support bayer formats. Therefore the selfpath resizer
382 	 * should support only YUV422 on the sink pad
383 	 */
384 	if (rsz->id == RKISP1_SELFPATH) {
385 		if (code->index > 0)
386 			return -EINVAL;
387 		code->code = MEDIA_BUS_FMT_YUYV8_2X8;
388 		return 0;
389 	}
390 
391 	/* supported mbus codes on the sink pad are the same as isp src pad */
392 	code->pad = RKISP1_ISP_PAD_SOURCE_VIDEO;
393 	ret = v4l2_subdev_call(&rsz->rkisp1->isp.sd, pad, enum_mbus_code,
394 			       &pad_state, code);
395 
396 	/* restore pad */
397 	code->pad = pad;
398 	code->flags = 0;
399 	return ret;
400 }
401 
402 static int rkisp1_rsz_init_config(struct v4l2_subdev *sd,
403 				  struct v4l2_subdev_state *sd_state)
404 {
405 	struct v4l2_mbus_framefmt *sink_fmt, *src_fmt;
406 	struct v4l2_rect *sink_crop;
407 
408 	sink_fmt = v4l2_subdev_get_try_format(sd, sd_state,
409 					      RKISP1_RSZ_PAD_SRC);
410 	sink_fmt->width = RKISP1_DEFAULT_WIDTH;
411 	sink_fmt->height = RKISP1_DEFAULT_HEIGHT;
412 	sink_fmt->field = V4L2_FIELD_NONE;
413 	sink_fmt->code = RKISP1_DEF_FMT;
414 	sink_fmt->colorspace = V4L2_COLORSPACE_SRGB;
415 	sink_fmt->xfer_func = V4L2_XFER_FUNC_SRGB;
416 	sink_fmt->ycbcr_enc = V4L2_YCBCR_ENC_601;
417 	sink_fmt->quantization = V4L2_QUANTIZATION_LIM_RANGE;
418 
419 	sink_crop = v4l2_subdev_get_try_crop(sd, sd_state,
420 					     RKISP1_RSZ_PAD_SINK);
421 	sink_crop->width = RKISP1_DEFAULT_WIDTH;
422 	sink_crop->height = RKISP1_DEFAULT_HEIGHT;
423 	sink_crop->left = 0;
424 	sink_crop->top = 0;
425 
426 	src_fmt = v4l2_subdev_get_try_format(sd, sd_state,
427 					     RKISP1_RSZ_PAD_SINK);
428 	*src_fmt = *sink_fmt;
429 
430 	/* NOTE: there is no crop in the source pad, only in the sink */
431 
432 	return 0;
433 }
434 
435 static void rkisp1_rsz_set_src_fmt(struct rkisp1_resizer *rsz,
436 				   struct v4l2_subdev_state *sd_state,
437 				   struct v4l2_mbus_framefmt *format,
438 				   unsigned int which)
439 {
440 	const struct rkisp1_mbus_info *sink_mbus_info;
441 	struct v4l2_mbus_framefmt *src_fmt, *sink_fmt;
442 
443 	sink_fmt = rkisp1_rsz_get_pad_fmt(rsz, sd_state, RKISP1_RSZ_PAD_SINK,
444 					  which);
445 	src_fmt = rkisp1_rsz_get_pad_fmt(rsz, sd_state, RKISP1_RSZ_PAD_SRC,
446 					 which);
447 	sink_mbus_info = rkisp1_mbus_info_get_by_code(sink_fmt->code);
448 
449 	/* for YUV formats, userspace can change the mbus code on the src pad if it is supported */
450 	if (sink_mbus_info->pixel_enc == V4L2_PIXEL_ENC_YUV &&
451 	    rkisp1_rsz_get_yuv_mbus_info(format->code))
452 		src_fmt->code = format->code;
453 
454 	src_fmt->width = clamp_t(u32, format->width,
455 				 rsz->config->min_rsz_width,
456 				 rsz->config->max_rsz_width);
457 	src_fmt->height = clamp_t(u32, format->height,
458 				  rsz->config->min_rsz_height,
459 				  rsz->config->max_rsz_height);
460 
461 	*format = *src_fmt;
462 }
463 
464 static void rkisp1_rsz_set_sink_crop(struct rkisp1_resizer *rsz,
465 				     struct v4l2_subdev_state *sd_state,
466 				     struct v4l2_rect *r,
467 				     unsigned int which)
468 {
469 	const struct rkisp1_mbus_info *mbus_info;
470 	struct v4l2_mbus_framefmt *sink_fmt;
471 	struct v4l2_rect *sink_crop;
472 
473 	sink_fmt = rkisp1_rsz_get_pad_fmt(rsz, sd_state, RKISP1_RSZ_PAD_SINK,
474 					  which);
475 	sink_crop = rkisp1_rsz_get_pad_crop(rsz, sd_state,
476 					    RKISP1_RSZ_PAD_SINK,
477 					    which);
478 
479 	/* Not crop for MP bayer raw data */
480 	mbus_info = rkisp1_mbus_info_get_by_code(sink_fmt->code);
481 
482 	if (rsz->id == RKISP1_MAINPATH &&
483 	    mbus_info->pixel_enc == V4L2_PIXEL_ENC_BAYER) {
484 		sink_crop->left = 0;
485 		sink_crop->top = 0;
486 		sink_crop->width = sink_fmt->width;
487 		sink_crop->height = sink_fmt->height;
488 
489 		*r = *sink_crop;
490 		return;
491 	}
492 
493 	sink_crop->left = ALIGN(r->left, 2);
494 	sink_crop->width = ALIGN(r->width, 2);
495 	sink_crop->top = r->top;
496 	sink_crop->height = r->height;
497 	rkisp1_sd_adjust_crop(sink_crop, sink_fmt);
498 
499 	*r = *sink_crop;
500 }
501 
502 static void rkisp1_rsz_set_sink_fmt(struct rkisp1_resizer *rsz,
503 				    struct v4l2_subdev_state *sd_state,
504 				    struct v4l2_mbus_framefmt *format,
505 				    unsigned int which)
506 {
507 	const struct rkisp1_mbus_info *mbus_info;
508 	struct v4l2_mbus_framefmt *sink_fmt, *src_fmt;
509 	struct v4l2_rect *sink_crop;
510 	bool is_yuv;
511 
512 	sink_fmt = rkisp1_rsz_get_pad_fmt(rsz, sd_state, RKISP1_RSZ_PAD_SINK,
513 					  which);
514 	src_fmt = rkisp1_rsz_get_pad_fmt(rsz, sd_state, RKISP1_RSZ_PAD_SRC,
515 					 which);
516 	sink_crop = rkisp1_rsz_get_pad_crop(rsz, sd_state,
517 					    RKISP1_RSZ_PAD_SINK,
518 					    which);
519 	if (rsz->id == RKISP1_SELFPATH)
520 		sink_fmt->code = MEDIA_BUS_FMT_YUYV8_2X8;
521 	else
522 		sink_fmt->code = format->code;
523 
524 	mbus_info = rkisp1_mbus_info_get_by_code(sink_fmt->code);
525 	if (!mbus_info || !(mbus_info->direction & RKISP1_ISP_SD_SRC)) {
526 		sink_fmt->code = RKISP1_DEF_FMT;
527 		mbus_info = rkisp1_mbus_info_get_by_code(sink_fmt->code);
528 	}
529 	if (which == V4L2_SUBDEV_FORMAT_ACTIVE)
530 		rsz->pixel_enc = mbus_info->pixel_enc;
531 
532 	sink_fmt->width = clamp_t(u32, format->width,
533 				  RKISP1_ISP_MIN_WIDTH,
534 				  RKISP1_ISP_MAX_WIDTH);
535 	sink_fmt->height = clamp_t(u32, format->height,
536 				   RKISP1_ISP_MIN_HEIGHT,
537 				   RKISP1_ISP_MAX_HEIGHT);
538 
539 	/*
540 	 * Adjust the color space fields. Accept any color primaries and
541 	 * transfer function for both YUV and Bayer. For YUV any YCbCr encoding
542 	 * and quantization range is also accepted. For Bayer formats, the YCbCr
543 	 * encoding isn't applicable, and the quantization range can only be
544 	 * full.
545 	 */
546 	is_yuv = mbus_info->pixel_enc == V4L2_PIXEL_ENC_YUV;
547 
548 	sink_fmt->colorspace = format->colorspace ? :
549 			       (is_yuv ? V4L2_COLORSPACE_SRGB :
550 				V4L2_COLORSPACE_RAW);
551 	sink_fmt->xfer_func = format->xfer_func ? :
552 			      V4L2_MAP_XFER_FUNC_DEFAULT(sink_fmt->colorspace);
553 	if (is_yuv) {
554 		sink_fmt->ycbcr_enc = format->ycbcr_enc ? :
555 			V4L2_MAP_YCBCR_ENC_DEFAULT(sink_fmt->colorspace);
556 		sink_fmt->quantization = format->quantization ? :
557 			V4L2_MAP_QUANTIZATION_DEFAULT(false, sink_fmt->colorspace,
558 						      sink_fmt->ycbcr_enc);
559 	} else {
560 		/*
561 		 * The YCbCr encoding isn't applicable for non-YUV formats, but
562 		 * V4L2 has no "no encoding" value. Hardcode it to Rec. 601, it
563 		 * should be ignored by userspace.
564 		 */
565 		sink_fmt->ycbcr_enc = V4L2_YCBCR_ENC_601;
566 		sink_fmt->quantization = V4L2_QUANTIZATION_FULL_RANGE;
567 	}
568 
569 	*format = *sink_fmt;
570 
571 	/* Propagate the media bus code and color space to the source pad. */
572 	src_fmt->code = sink_fmt->code;
573 	src_fmt->colorspace = sink_fmt->colorspace;
574 	src_fmt->xfer_func = sink_fmt->xfer_func;
575 	src_fmt->ycbcr_enc = sink_fmt->ycbcr_enc;
576 	src_fmt->quantization = sink_fmt->quantization;
577 
578 	/* Update sink crop */
579 	rkisp1_rsz_set_sink_crop(rsz, sd_state, sink_crop, which);
580 }
581 
582 static int rkisp1_rsz_get_fmt(struct v4l2_subdev *sd,
583 			      struct v4l2_subdev_state *sd_state,
584 			      struct v4l2_subdev_format *fmt)
585 {
586 	struct rkisp1_resizer *rsz =
587 		container_of(sd, struct rkisp1_resizer, sd);
588 
589 	mutex_lock(&rsz->ops_lock);
590 	fmt->format = *rkisp1_rsz_get_pad_fmt(rsz, sd_state, fmt->pad,
591 					      fmt->which);
592 	mutex_unlock(&rsz->ops_lock);
593 	return 0;
594 }
595 
596 static int rkisp1_rsz_set_fmt(struct v4l2_subdev *sd,
597 			      struct v4l2_subdev_state *sd_state,
598 			      struct v4l2_subdev_format *fmt)
599 {
600 	struct rkisp1_resizer *rsz =
601 		container_of(sd, struct rkisp1_resizer, sd);
602 
603 	mutex_lock(&rsz->ops_lock);
604 	if (fmt->pad == RKISP1_RSZ_PAD_SINK)
605 		rkisp1_rsz_set_sink_fmt(rsz, sd_state, &fmt->format,
606 					fmt->which);
607 	else
608 		rkisp1_rsz_set_src_fmt(rsz, sd_state, &fmt->format,
609 				       fmt->which);
610 
611 	mutex_unlock(&rsz->ops_lock);
612 	return 0;
613 }
614 
615 static int rkisp1_rsz_get_selection(struct v4l2_subdev *sd,
616 				    struct v4l2_subdev_state *sd_state,
617 				    struct v4l2_subdev_selection *sel)
618 {
619 	struct rkisp1_resizer *rsz =
620 		container_of(sd, struct rkisp1_resizer, sd);
621 	struct v4l2_mbus_framefmt *mf_sink;
622 	int ret = 0;
623 
624 	if (sel->pad == RKISP1_RSZ_PAD_SRC)
625 		return -EINVAL;
626 
627 	mutex_lock(&rsz->ops_lock);
628 	switch (sel->target) {
629 	case V4L2_SEL_TGT_CROP_BOUNDS:
630 		mf_sink = rkisp1_rsz_get_pad_fmt(rsz, sd_state,
631 						 RKISP1_RSZ_PAD_SINK,
632 						 sel->which);
633 		sel->r.height = mf_sink->height;
634 		sel->r.width = mf_sink->width;
635 		sel->r.left = 0;
636 		sel->r.top = 0;
637 		break;
638 	case V4L2_SEL_TGT_CROP:
639 		sel->r = *rkisp1_rsz_get_pad_crop(rsz, sd_state,
640 						  RKISP1_RSZ_PAD_SINK,
641 						  sel->which);
642 		break;
643 	default:
644 		ret = -EINVAL;
645 	}
646 
647 	mutex_unlock(&rsz->ops_lock);
648 	return ret;
649 }
650 
651 static int rkisp1_rsz_set_selection(struct v4l2_subdev *sd,
652 				    struct v4l2_subdev_state *sd_state,
653 				    struct v4l2_subdev_selection *sel)
654 {
655 	struct rkisp1_resizer *rsz =
656 		container_of(sd, struct rkisp1_resizer, sd);
657 
658 	if (sel->target != V4L2_SEL_TGT_CROP || sel->pad == RKISP1_RSZ_PAD_SRC)
659 		return -EINVAL;
660 
661 	dev_dbg(rsz->rkisp1->dev, "%s: pad: %d sel(%d,%d)/%dx%d\n", __func__,
662 		sel->pad, sel->r.left, sel->r.top, sel->r.width, sel->r.height);
663 
664 	mutex_lock(&rsz->ops_lock);
665 	rkisp1_rsz_set_sink_crop(rsz, sd_state, &sel->r, sel->which);
666 	mutex_unlock(&rsz->ops_lock);
667 
668 	return 0;
669 }
670 
671 static const struct media_entity_operations rkisp1_rsz_media_ops = {
672 	.link_validate = v4l2_subdev_link_validate,
673 };
674 
675 static const struct v4l2_subdev_pad_ops rkisp1_rsz_pad_ops = {
676 	.enum_mbus_code = rkisp1_rsz_enum_mbus_code,
677 	.get_selection = rkisp1_rsz_get_selection,
678 	.set_selection = rkisp1_rsz_set_selection,
679 	.init_cfg = rkisp1_rsz_init_config,
680 	.get_fmt = rkisp1_rsz_get_fmt,
681 	.set_fmt = rkisp1_rsz_set_fmt,
682 	.link_validate = v4l2_subdev_link_validate_default,
683 };
684 
685 /* ----------------------------------------------------------------------------
686  * Stream operations
687  */
688 
689 static int rkisp1_rsz_s_stream(struct v4l2_subdev *sd, int enable)
690 {
691 	struct rkisp1_resizer *rsz =
692 		container_of(sd, struct rkisp1_resizer, sd);
693 	struct rkisp1_device *rkisp1 = rsz->rkisp1;
694 	struct rkisp1_capture *other = &rkisp1->capture_devs[rsz->id ^ 1];
695 	enum rkisp1_shadow_regs_when when = RKISP1_SHADOW_REGS_SYNC;
696 
697 	if (!enable) {
698 		rkisp1_dcrop_disable(rsz, RKISP1_SHADOW_REGS_ASYNC);
699 		rkisp1_rsz_disable(rsz, RKISP1_SHADOW_REGS_ASYNC);
700 		return 0;
701 	}
702 
703 	if (other->is_streaming)
704 		when = RKISP1_SHADOW_REGS_ASYNC;
705 
706 	mutex_lock(&rsz->ops_lock);
707 	rkisp1_rsz_config(rsz, when);
708 	rkisp1_dcrop_config(rsz);
709 
710 	mutex_unlock(&rsz->ops_lock);
711 	return 0;
712 }
713 
714 static const struct v4l2_subdev_video_ops rkisp1_rsz_video_ops = {
715 	.s_stream = rkisp1_rsz_s_stream,
716 };
717 
718 static const struct v4l2_subdev_ops rkisp1_rsz_ops = {
719 	.video = &rkisp1_rsz_video_ops,
720 	.pad = &rkisp1_rsz_pad_ops,
721 };
722 
723 static void rkisp1_rsz_unregister(struct rkisp1_resizer *rsz)
724 {
725 	if (!rsz->rkisp1)
726 		return;
727 
728 	v4l2_device_unregister_subdev(&rsz->sd);
729 	media_entity_cleanup(&rsz->sd.entity);
730 	mutex_destroy(&rsz->ops_lock);
731 }
732 
733 static int rkisp1_rsz_register(struct rkisp1_resizer *rsz)
734 {
735 	struct v4l2_subdev_state state = {
736 		.pads = rsz->pad_cfg,
737 	};
738 	static const char * const dev_names[] = {
739 		RKISP1_RSZ_MP_DEV_NAME,
740 		RKISP1_RSZ_SP_DEV_NAME
741 	};
742 	struct media_pad *pads = rsz->pads;
743 	struct v4l2_subdev *sd = &rsz->sd;
744 	int ret;
745 
746 	if (rsz->id == RKISP1_SELFPATH) {
747 		rsz->regs_base = RKISP1_CIF_SRSZ_BASE;
748 		rsz->config = &rkisp1_rsz_config_sp;
749 	} else {
750 		rsz->regs_base = RKISP1_CIF_MRSZ_BASE;
751 		rsz->config = &rkisp1_rsz_config_mp;
752 	}
753 
754 	v4l2_subdev_init(sd, &rkisp1_rsz_ops);
755 	sd->flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
756 	sd->entity.ops = &rkisp1_rsz_media_ops;
757 	sd->entity.function = MEDIA_ENT_F_PROC_VIDEO_SCALER;
758 	sd->owner = THIS_MODULE;
759 	strscpy(sd->name, dev_names[rsz->id], sizeof(sd->name));
760 
761 	pads[RKISP1_RSZ_PAD_SINK].flags = MEDIA_PAD_FL_SINK |
762 					  MEDIA_PAD_FL_MUST_CONNECT;
763 	pads[RKISP1_RSZ_PAD_SRC].flags = MEDIA_PAD_FL_SOURCE |
764 					 MEDIA_PAD_FL_MUST_CONNECT;
765 
766 	rsz->pixel_enc = RKISP1_DEF_PIXEL_ENC;
767 
768 	mutex_init(&rsz->ops_lock);
769 	ret = media_entity_pads_init(&sd->entity, RKISP1_RSZ_PAD_MAX, pads);
770 	if (ret)
771 		goto error;
772 
773 	ret = v4l2_device_register_subdev(&rsz->rkisp1->v4l2_dev, sd);
774 	if (ret) {
775 		dev_err(sd->dev, "Failed to register resizer subdev\n");
776 		goto error;
777 	}
778 
779 	rkisp1_rsz_init_config(sd, &state);
780 	return 0;
781 
782 error:
783 	media_entity_cleanup(&sd->entity);
784 	mutex_destroy(&rsz->ops_lock);
785 	return ret;
786 }
787 
788 int rkisp1_resizer_devs_register(struct rkisp1_device *rkisp1)
789 {
790 	unsigned int i;
791 	int ret;
792 
793 	for (i = 0; i < ARRAY_SIZE(rkisp1->resizer_devs); i++) {
794 		struct rkisp1_resizer *rsz = &rkisp1->resizer_devs[i];
795 
796 		rsz->rkisp1 = rkisp1;
797 		rsz->id = i;
798 
799 		ret = rkisp1_rsz_register(rsz);
800 		if (ret) {
801 			rsz->rkisp1 = NULL;
802 			rkisp1_resizer_devs_unregister(rkisp1);
803 			return ret;
804 		}
805 	}
806 
807 	return 0;
808 }
809 
810 void rkisp1_resizer_devs_unregister(struct rkisp1_device *rkisp1)
811 {
812 	struct rkisp1_resizer *mp = &rkisp1->resizer_devs[RKISP1_MAINPATH];
813 	struct rkisp1_resizer *sp = &rkisp1->resizer_devs[RKISP1_SELFPATH];
814 
815 	rkisp1_rsz_unregister(mp);
816 	rkisp1_rsz_unregister(sp);
817 }
818