xref: /openbmc/linux/drivers/media/i2c/ccs/ccs-core.c (revision 9659281c)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * drivers/media/i2c/ccs/ccs-core.c
4  *
5  * Generic driver for MIPI CCS/SMIA/SMIA++ compliant camera sensors
6  *
7  * Copyright (C) 2020 Intel Corporation
8  * Copyright (C) 2010--2012 Nokia Corporation
9  * Contact: Sakari Ailus <sakari.ailus@linux.intel.com>
10  *
11  * Based on smiapp driver by Vimarsh Zutshi
12  * Based on jt8ev1.c by Vimarsh Zutshi
13  * Based on smia-sensor.c by Tuukka Toivonen <tuukkat76@gmail.com>
14  */
15 
16 #include <linux/clk.h>
17 #include <linux/delay.h>
18 #include <linux/device.h>
19 #include <linux/firmware.h>
20 #include <linux/gpio.h>
21 #include <linux/gpio/consumer.h>
22 #include <linux/module.h>
23 #include <linux/pm_runtime.h>
24 #include <linux/property.h>
25 #include <linux/regulator/consumer.h>
26 #include <linux/slab.h>
27 #include <linux/smiapp.h>
28 #include <linux/v4l2-mediabus.h>
29 #include <media/v4l2-fwnode.h>
30 #include <media/v4l2-device.h>
31 #include <uapi/linux/ccs.h>
32 
33 #include "ccs.h"
34 
35 #define CCS_ALIGN_DIM(dim, flags)	\
36 	((flags) & V4L2_SEL_FLAG_GE	\
37 	 ? ALIGN((dim), 2)		\
38 	 : (dim) & ~1)
39 
40 static struct ccs_limit_offset {
41 	u16	lim;
42 	u16	info;
43 } ccs_limit_offsets[CCS_L_LAST + 1];
44 
45 /*
46  * ccs_module_idents - supported camera modules
47  */
48 static const struct ccs_module_ident ccs_module_idents[] = {
49 	CCS_IDENT_L(0x01, 0x022b, -1, "vs6555"),
50 	CCS_IDENT_L(0x01, 0x022e, -1, "vw6558"),
51 	CCS_IDENT_L(0x07, 0x7698, -1, "ovm7698"),
52 	CCS_IDENT_L(0x0b, 0x4242, -1, "smiapp-003"),
53 	CCS_IDENT_L(0x0c, 0x208a, -1, "tcm8330md"),
54 	CCS_IDENT_LQ(0x0c, 0x2134, -1, "tcm8500md", &smiapp_tcm8500md_quirk),
55 	CCS_IDENT_L(0x0c, 0x213e, -1, "et8en2"),
56 	CCS_IDENT_L(0x0c, 0x2184, -1, "tcm8580md"),
57 	CCS_IDENT_LQ(0x0c, 0x560f, -1, "jt8ew9", &smiapp_jt8ew9_quirk),
58 	CCS_IDENT_LQ(0x10, 0x4141, -1, "jt8ev1", &smiapp_jt8ev1_quirk),
59 	CCS_IDENT_LQ(0x10, 0x4241, -1, "imx125es", &smiapp_imx125es_quirk),
60 };
61 
62 #define CCS_DEVICE_FLAG_IS_SMIA		BIT(0)
63 
64 struct ccs_device {
65 	unsigned char flags;
66 };
67 
68 static const char * const ccs_regulators[] = { "vcore", "vio", "vana" };
69 
70 /*
71  *
72  * Dynamic Capability Identification
73  *
74  */
75 
76 static void ccs_assign_limit(void *ptr, unsigned int width, u32 val)
77 {
78 	switch (width) {
79 	case sizeof(u8):
80 		*(u8 *)ptr = val;
81 		break;
82 	case sizeof(u16):
83 		*(u16 *)ptr = val;
84 		break;
85 	case sizeof(u32):
86 		*(u32 *)ptr = val;
87 		break;
88 	}
89 }
90 
91 static int ccs_limit_ptr(struct ccs_sensor *sensor, unsigned int limit,
92 			 unsigned int offset, void **__ptr)
93 {
94 	const struct ccs_limit *linfo;
95 
96 	if (WARN_ON(limit >= CCS_L_LAST))
97 		return -EINVAL;
98 
99 	linfo = &ccs_limits[ccs_limit_offsets[limit].info];
100 
101 	if (WARN_ON(!sensor->ccs_limits) ||
102 	    WARN_ON(offset + ccs_reg_width(linfo->reg) >
103 		    ccs_limit_offsets[limit + 1].lim))
104 		return -EINVAL;
105 
106 	*__ptr = sensor->ccs_limits + ccs_limit_offsets[limit].lim + offset;
107 
108 	return 0;
109 }
110 
111 void ccs_replace_limit(struct ccs_sensor *sensor,
112 		       unsigned int limit, unsigned int offset, u32 val)
113 {
114 	struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
115 	const struct ccs_limit *linfo;
116 	void *ptr;
117 	int ret;
118 
119 	ret = ccs_limit_ptr(sensor, limit, offset, &ptr);
120 	if (ret)
121 		return;
122 
123 	linfo = &ccs_limits[ccs_limit_offsets[limit].info];
124 
125 	dev_dbg(&client->dev, "quirk: 0x%8.8x \"%s\" %u = %d, 0x%x\n",
126 		linfo->reg, linfo->name, offset, val, val);
127 
128 	ccs_assign_limit(ptr, ccs_reg_width(linfo->reg), val);
129 }
130 
131 u32 ccs_get_limit(struct ccs_sensor *sensor, unsigned int limit,
132 		  unsigned int offset)
133 {
134 	void *ptr;
135 	u32 val;
136 	int ret;
137 
138 	ret = ccs_limit_ptr(sensor, limit, offset, &ptr);
139 	if (ret)
140 		return 0;
141 
142 	switch (ccs_reg_width(ccs_limits[ccs_limit_offsets[limit].info].reg)) {
143 	case sizeof(u8):
144 		val = *(u8 *)ptr;
145 		break;
146 	case sizeof(u16):
147 		val = *(u16 *)ptr;
148 		break;
149 	case sizeof(u32):
150 		val = *(u32 *)ptr;
151 		break;
152 	default:
153 		WARN_ON(1);
154 		return 0;
155 	}
156 
157 	return ccs_reg_conv(sensor, ccs_limits[limit].reg, val);
158 }
159 
160 static int ccs_read_all_limits(struct ccs_sensor *sensor)
161 {
162 	struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
163 	void *ptr, *alloc, *end;
164 	unsigned int i, l;
165 	int ret;
166 
167 	kfree(sensor->ccs_limits);
168 	sensor->ccs_limits = NULL;
169 
170 	alloc = kzalloc(ccs_limit_offsets[CCS_L_LAST].lim, GFP_KERNEL);
171 	if (!alloc)
172 		return -ENOMEM;
173 
174 	end = alloc + ccs_limit_offsets[CCS_L_LAST].lim;
175 
176 	for (i = 0, l = 0, ptr = alloc; ccs_limits[i].size; i++) {
177 		u32 reg = ccs_limits[i].reg;
178 		unsigned int width = ccs_reg_width(reg);
179 		unsigned int j;
180 
181 		if (l == CCS_L_LAST) {
182 			dev_err(&client->dev,
183 				"internal error --- end of limit array\n");
184 			ret = -EINVAL;
185 			goto out_err;
186 		}
187 
188 		for (j = 0; j < ccs_limits[i].size / width;
189 		     j++, reg += width, ptr += width) {
190 			u32 val;
191 
192 			ret = ccs_read_addr_noconv(sensor, reg, &val);
193 			if (ret)
194 				goto out_err;
195 
196 			if (ptr + width > end) {
197 				dev_err(&client->dev,
198 					"internal error --- no room for regs\n");
199 				ret = -EINVAL;
200 				goto out_err;
201 			}
202 
203 			if (!val && j)
204 				break;
205 
206 			ccs_assign_limit(ptr, width, val);
207 
208 			dev_dbg(&client->dev, "0x%8.8x \"%s\" = %u, 0x%x\n",
209 				reg, ccs_limits[i].name, val, val);
210 		}
211 
212 		if (ccs_limits[i].flags & CCS_L_FL_SAME_REG)
213 			continue;
214 
215 		l++;
216 		ptr = alloc + ccs_limit_offsets[l].lim;
217 	}
218 
219 	if (l != CCS_L_LAST) {
220 		dev_err(&client->dev,
221 			"internal error --- insufficient limits\n");
222 		ret = -EINVAL;
223 		goto out_err;
224 	}
225 
226 	sensor->ccs_limits = alloc;
227 
228 	if (CCS_LIM(sensor, SCALER_N_MIN) < 16)
229 		ccs_replace_limit(sensor, CCS_L_SCALER_N_MIN, 0, 16);
230 
231 	return 0;
232 
233 out_err:
234 	kfree(alloc);
235 
236 	return ret;
237 }
238 
239 static int ccs_read_frame_fmt(struct ccs_sensor *sensor)
240 {
241 	struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
242 	u8 fmt_model_type, fmt_model_subtype, ncol_desc, nrow_desc;
243 	unsigned int i;
244 	int pixel_count = 0;
245 	int line_count = 0;
246 
247 	fmt_model_type = CCS_LIM(sensor, FRAME_FORMAT_MODEL_TYPE);
248 	fmt_model_subtype = CCS_LIM(sensor, FRAME_FORMAT_MODEL_SUBTYPE);
249 
250 	ncol_desc = (fmt_model_subtype
251 		     & CCS_FRAME_FORMAT_MODEL_SUBTYPE_COLUMNS_MASK)
252 		>> CCS_FRAME_FORMAT_MODEL_SUBTYPE_COLUMNS_SHIFT;
253 	nrow_desc = fmt_model_subtype
254 		& CCS_FRAME_FORMAT_MODEL_SUBTYPE_ROWS_MASK;
255 
256 	dev_dbg(&client->dev, "format_model_type %s\n",
257 		fmt_model_type == CCS_FRAME_FORMAT_MODEL_TYPE_2_BYTE
258 		? "2 byte" :
259 		fmt_model_type == CCS_FRAME_FORMAT_MODEL_TYPE_4_BYTE
260 		? "4 byte" : "is simply bad");
261 
262 	dev_dbg(&client->dev, "%u column and %u row descriptors\n",
263 		ncol_desc, nrow_desc);
264 
265 	for (i = 0; i < ncol_desc + nrow_desc; i++) {
266 		u32 desc;
267 		u32 pixelcode;
268 		u32 pixels;
269 		char *which;
270 		char *what;
271 
272 		if (fmt_model_type == CCS_FRAME_FORMAT_MODEL_TYPE_2_BYTE) {
273 			desc = CCS_LIM_AT(sensor, FRAME_FORMAT_DESCRIPTOR, i);
274 
275 			pixelcode =
276 				(desc
277 				 & CCS_FRAME_FORMAT_DESCRIPTOR_PCODE_MASK)
278 				>> CCS_FRAME_FORMAT_DESCRIPTOR_PCODE_SHIFT;
279 			pixels = desc & CCS_FRAME_FORMAT_DESCRIPTOR_PIXELS_MASK;
280 		} else if (fmt_model_type
281 			   == CCS_FRAME_FORMAT_MODEL_TYPE_4_BYTE) {
282 			desc = CCS_LIM_AT(sensor, FRAME_FORMAT_DESCRIPTOR_4, i);
283 
284 			pixelcode =
285 				(desc
286 				 & CCS_FRAME_FORMAT_DESCRIPTOR_4_PCODE_MASK)
287 				>> CCS_FRAME_FORMAT_DESCRIPTOR_4_PCODE_SHIFT;
288 			pixels = desc &
289 				CCS_FRAME_FORMAT_DESCRIPTOR_4_PIXELS_MASK;
290 		} else {
291 			dev_dbg(&client->dev,
292 				"invalid frame format model type %d\n",
293 				fmt_model_type);
294 			return -EINVAL;
295 		}
296 
297 		if (i < ncol_desc)
298 			which = "columns";
299 		else
300 			which = "rows";
301 
302 		switch (pixelcode) {
303 		case CCS_FRAME_FORMAT_DESCRIPTOR_PCODE_EMBEDDED:
304 			what = "embedded";
305 			break;
306 		case CCS_FRAME_FORMAT_DESCRIPTOR_PCODE_DUMMY_PIXEL:
307 			what = "dummy";
308 			break;
309 		case CCS_FRAME_FORMAT_DESCRIPTOR_PCODE_BLACK_PIXEL:
310 			what = "black";
311 			break;
312 		case CCS_FRAME_FORMAT_DESCRIPTOR_PCODE_DARK_PIXEL:
313 			what = "dark";
314 			break;
315 		case CCS_FRAME_FORMAT_DESCRIPTOR_PCODE_VISIBLE_PIXEL:
316 			what = "visible";
317 			break;
318 		default:
319 			what = "invalid";
320 			break;
321 		}
322 
323 		dev_dbg(&client->dev,
324 			"%s pixels: %d %s (pixelcode %u)\n",
325 			what, pixels, which, pixelcode);
326 
327 		if (i < ncol_desc) {
328 			if (pixelcode ==
329 			    CCS_FRAME_FORMAT_DESCRIPTOR_PCODE_VISIBLE_PIXEL)
330 				sensor->visible_pixel_start = pixel_count;
331 			pixel_count += pixels;
332 			continue;
333 		}
334 
335 		/* Handle row descriptors */
336 		switch (pixelcode) {
337 		case CCS_FRAME_FORMAT_DESCRIPTOR_PCODE_EMBEDDED:
338 			if (sensor->embedded_end)
339 				break;
340 			sensor->embedded_start = line_count;
341 			sensor->embedded_end = line_count + pixels;
342 			break;
343 		case CCS_FRAME_FORMAT_DESCRIPTOR_PCODE_VISIBLE_PIXEL:
344 			sensor->image_start = line_count;
345 			break;
346 		}
347 		line_count += pixels;
348 	}
349 
350 	if (sensor->embedded_end > sensor->image_start) {
351 		dev_dbg(&client->dev,
352 			"adjusting image start line to %u (was %u)\n",
353 			sensor->embedded_end, sensor->image_start);
354 		sensor->image_start = sensor->embedded_end;
355 	}
356 
357 	dev_dbg(&client->dev, "embedded data from lines %d to %d\n",
358 		sensor->embedded_start, sensor->embedded_end);
359 	dev_dbg(&client->dev, "image data starts at line %d\n",
360 		sensor->image_start);
361 
362 	return 0;
363 }
364 
365 static int ccs_pll_configure(struct ccs_sensor *sensor)
366 {
367 	struct ccs_pll *pll = &sensor->pll;
368 	int rval;
369 
370 	rval = ccs_write(sensor, VT_PIX_CLK_DIV, pll->vt_bk.pix_clk_div);
371 	if (rval < 0)
372 		return rval;
373 
374 	rval = ccs_write(sensor, VT_SYS_CLK_DIV, pll->vt_bk.sys_clk_div);
375 	if (rval < 0)
376 		return rval;
377 
378 	rval = ccs_write(sensor, PRE_PLL_CLK_DIV, pll->vt_fr.pre_pll_clk_div);
379 	if (rval < 0)
380 		return rval;
381 
382 	rval = ccs_write(sensor, PLL_MULTIPLIER, pll->vt_fr.pll_multiplier);
383 	if (rval < 0)
384 		return rval;
385 
386 	if (!(CCS_LIM(sensor, PHY_CTRL_CAPABILITY) &
387 	      CCS_PHY_CTRL_CAPABILITY_AUTO_PHY_CTL)) {
388 		/* Lane op clock ratio does not apply here. */
389 		rval = ccs_write(sensor, REQUESTED_LINK_RATE,
390 				 DIV_ROUND_UP(pll->op_bk.sys_clk_freq_hz,
391 					      1000000 / 256 / 256) *
392 				 (pll->flags & CCS_PLL_FLAG_LANE_SPEED_MODEL ?
393 				  sensor->pll.csi2.lanes : 1) <<
394 				 (pll->flags & CCS_PLL_FLAG_OP_SYS_DDR ?
395 				  1 : 0));
396 		if (rval < 0)
397 			return rval;
398 	}
399 
400 	if (sensor->pll.flags & CCS_PLL_FLAG_NO_OP_CLOCKS)
401 		return 0;
402 
403 	rval = ccs_write(sensor, OP_PIX_CLK_DIV, pll->op_bk.pix_clk_div);
404 	if (rval < 0)
405 		return rval;
406 
407 	rval = ccs_write(sensor, OP_SYS_CLK_DIV, pll->op_bk.sys_clk_div);
408 	if (rval < 0)
409 		return rval;
410 
411 	if (!(pll->flags & CCS_PLL_FLAG_DUAL_PLL))
412 		return 0;
413 
414 	rval = ccs_write(sensor, PLL_MODE, CCS_PLL_MODE_DUAL);
415 	if (rval < 0)
416 		return rval;
417 
418 	rval = ccs_write(sensor, OP_PRE_PLL_CLK_DIV,
419 			 pll->op_fr.pre_pll_clk_div);
420 	if (rval < 0)
421 		return rval;
422 
423 	return ccs_write(sensor, OP_PLL_MULTIPLIER, pll->op_fr.pll_multiplier);
424 }
425 
426 static int ccs_pll_try(struct ccs_sensor *sensor, struct ccs_pll *pll)
427 {
428 	struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
429 	struct ccs_pll_limits lim = {
430 		.vt_fr = {
431 			.min_pre_pll_clk_div = CCS_LIM(sensor, MIN_PRE_PLL_CLK_DIV),
432 			.max_pre_pll_clk_div = CCS_LIM(sensor, MAX_PRE_PLL_CLK_DIV),
433 			.min_pll_ip_clk_freq_hz = CCS_LIM(sensor, MIN_PLL_IP_CLK_FREQ_MHZ),
434 			.max_pll_ip_clk_freq_hz = CCS_LIM(sensor, MAX_PLL_IP_CLK_FREQ_MHZ),
435 			.min_pll_multiplier = CCS_LIM(sensor, MIN_PLL_MULTIPLIER),
436 			.max_pll_multiplier = CCS_LIM(sensor, MAX_PLL_MULTIPLIER),
437 			.min_pll_op_clk_freq_hz = CCS_LIM(sensor, MIN_PLL_OP_CLK_FREQ_MHZ),
438 			.max_pll_op_clk_freq_hz = CCS_LIM(sensor, MAX_PLL_OP_CLK_FREQ_MHZ),
439 		},
440 		.op_fr = {
441 			.min_pre_pll_clk_div = CCS_LIM(sensor, MIN_OP_PRE_PLL_CLK_DIV),
442 			.max_pre_pll_clk_div = CCS_LIM(sensor, MAX_OP_PRE_PLL_CLK_DIV),
443 			.min_pll_ip_clk_freq_hz = CCS_LIM(sensor, MIN_OP_PLL_IP_CLK_FREQ_MHZ),
444 			.max_pll_ip_clk_freq_hz = CCS_LIM(sensor, MAX_OP_PLL_IP_CLK_FREQ_MHZ),
445 			.min_pll_multiplier = CCS_LIM(sensor, MIN_OP_PLL_MULTIPLIER),
446 			.max_pll_multiplier = CCS_LIM(sensor, MAX_OP_PLL_MULTIPLIER),
447 			.min_pll_op_clk_freq_hz = CCS_LIM(sensor, MIN_OP_PLL_OP_CLK_FREQ_MHZ),
448 			.max_pll_op_clk_freq_hz = CCS_LIM(sensor, MAX_OP_PLL_OP_CLK_FREQ_MHZ),
449 		},
450 		.op_bk = {
451 			 .min_sys_clk_div = CCS_LIM(sensor, MIN_OP_SYS_CLK_DIV),
452 			 .max_sys_clk_div = CCS_LIM(sensor, MAX_OP_SYS_CLK_DIV),
453 			 .min_pix_clk_div = CCS_LIM(sensor, MIN_OP_PIX_CLK_DIV),
454 			 .max_pix_clk_div = CCS_LIM(sensor, MAX_OP_PIX_CLK_DIV),
455 			 .min_sys_clk_freq_hz = CCS_LIM(sensor, MIN_OP_SYS_CLK_FREQ_MHZ),
456 			 .max_sys_clk_freq_hz = CCS_LIM(sensor, MAX_OP_SYS_CLK_FREQ_MHZ),
457 			 .min_pix_clk_freq_hz = CCS_LIM(sensor, MIN_OP_PIX_CLK_FREQ_MHZ),
458 			 .max_pix_clk_freq_hz = CCS_LIM(sensor, MAX_OP_PIX_CLK_FREQ_MHZ),
459 		 },
460 		.vt_bk = {
461 			 .min_sys_clk_div = CCS_LIM(sensor, MIN_VT_SYS_CLK_DIV),
462 			 .max_sys_clk_div = CCS_LIM(sensor, MAX_VT_SYS_CLK_DIV),
463 			 .min_pix_clk_div = CCS_LIM(sensor, MIN_VT_PIX_CLK_DIV),
464 			 .max_pix_clk_div = CCS_LIM(sensor, MAX_VT_PIX_CLK_DIV),
465 			 .min_sys_clk_freq_hz = CCS_LIM(sensor, MIN_VT_SYS_CLK_FREQ_MHZ),
466 			 .max_sys_clk_freq_hz = CCS_LIM(sensor, MAX_VT_SYS_CLK_FREQ_MHZ),
467 			 .min_pix_clk_freq_hz = CCS_LIM(sensor, MIN_VT_PIX_CLK_FREQ_MHZ),
468 			 .max_pix_clk_freq_hz = CCS_LIM(sensor, MAX_VT_PIX_CLK_FREQ_MHZ),
469 		 },
470 		.min_line_length_pck_bin = CCS_LIM(sensor, MIN_LINE_LENGTH_PCK_BIN),
471 		.min_line_length_pck = CCS_LIM(sensor, MIN_LINE_LENGTH_PCK),
472 	};
473 
474 	return ccs_pll_calculate(&client->dev, &lim, pll);
475 }
476 
477 static int ccs_pll_update(struct ccs_sensor *sensor)
478 {
479 	struct ccs_pll *pll = &sensor->pll;
480 	int rval;
481 
482 	pll->binning_horizontal = sensor->binning_horizontal;
483 	pll->binning_vertical = sensor->binning_vertical;
484 	pll->link_freq =
485 		sensor->link_freq->qmenu_int[sensor->link_freq->val];
486 	pll->scale_m = sensor->scale_m;
487 	pll->bits_per_pixel = sensor->csi_format->compressed;
488 
489 	rval = ccs_pll_try(sensor, pll);
490 	if (rval < 0)
491 		return rval;
492 
493 	__v4l2_ctrl_s_ctrl_int64(sensor->pixel_rate_parray,
494 				 pll->pixel_rate_pixel_array);
495 	__v4l2_ctrl_s_ctrl_int64(sensor->pixel_rate_csi, pll->pixel_rate_csi);
496 
497 	return 0;
498 }
499 
500 
501 /*
502  *
503  * V4L2 Controls handling
504  *
505  */
506 
507 static void __ccs_update_exposure_limits(struct ccs_sensor *sensor)
508 {
509 	struct v4l2_ctrl *ctrl = sensor->exposure;
510 	int max;
511 
512 	max = sensor->pixel_array->crop[CCS_PA_PAD_SRC].height
513 		+ sensor->vblank->val
514 		- CCS_LIM(sensor, COARSE_INTEGRATION_TIME_MAX_MARGIN);
515 
516 	__v4l2_ctrl_modify_range(ctrl, ctrl->minimum, max, ctrl->step, max);
517 }
518 
519 /*
520  * Order matters.
521  *
522  * 1. Bits-per-pixel, descending.
523  * 2. Bits-per-pixel compressed, descending.
524  * 3. Pixel order, same as in pixel_order_str. Formats for all four pixel
525  *    orders must be defined.
526  */
527 static const struct ccs_csi_data_format ccs_csi_data_formats[] = {
528 	{ MEDIA_BUS_FMT_SGRBG16_1X16, 16, 16, CCS_PIXEL_ORDER_GRBG, },
529 	{ MEDIA_BUS_FMT_SRGGB16_1X16, 16, 16, CCS_PIXEL_ORDER_RGGB, },
530 	{ MEDIA_BUS_FMT_SBGGR16_1X16, 16, 16, CCS_PIXEL_ORDER_BGGR, },
531 	{ MEDIA_BUS_FMT_SGBRG16_1X16, 16, 16, CCS_PIXEL_ORDER_GBRG, },
532 	{ MEDIA_BUS_FMT_SGRBG14_1X14, 14, 14, CCS_PIXEL_ORDER_GRBG, },
533 	{ MEDIA_BUS_FMT_SRGGB14_1X14, 14, 14, CCS_PIXEL_ORDER_RGGB, },
534 	{ MEDIA_BUS_FMT_SBGGR14_1X14, 14, 14, CCS_PIXEL_ORDER_BGGR, },
535 	{ MEDIA_BUS_FMT_SGBRG14_1X14, 14, 14, CCS_PIXEL_ORDER_GBRG, },
536 	{ MEDIA_BUS_FMT_SGRBG12_1X12, 12, 12, CCS_PIXEL_ORDER_GRBG, },
537 	{ MEDIA_BUS_FMT_SRGGB12_1X12, 12, 12, CCS_PIXEL_ORDER_RGGB, },
538 	{ MEDIA_BUS_FMT_SBGGR12_1X12, 12, 12, CCS_PIXEL_ORDER_BGGR, },
539 	{ MEDIA_BUS_FMT_SGBRG12_1X12, 12, 12, CCS_PIXEL_ORDER_GBRG, },
540 	{ MEDIA_BUS_FMT_SGRBG10_1X10, 10, 10, CCS_PIXEL_ORDER_GRBG, },
541 	{ MEDIA_BUS_FMT_SRGGB10_1X10, 10, 10, CCS_PIXEL_ORDER_RGGB, },
542 	{ MEDIA_BUS_FMT_SBGGR10_1X10, 10, 10, CCS_PIXEL_ORDER_BGGR, },
543 	{ MEDIA_BUS_FMT_SGBRG10_1X10, 10, 10, CCS_PIXEL_ORDER_GBRG, },
544 	{ MEDIA_BUS_FMT_SGRBG10_DPCM8_1X8, 10, 8, CCS_PIXEL_ORDER_GRBG, },
545 	{ MEDIA_BUS_FMT_SRGGB10_DPCM8_1X8, 10, 8, CCS_PIXEL_ORDER_RGGB, },
546 	{ MEDIA_BUS_FMT_SBGGR10_DPCM8_1X8, 10, 8, CCS_PIXEL_ORDER_BGGR, },
547 	{ MEDIA_BUS_FMT_SGBRG10_DPCM8_1X8, 10, 8, CCS_PIXEL_ORDER_GBRG, },
548 	{ MEDIA_BUS_FMT_SGRBG8_1X8, 8, 8, CCS_PIXEL_ORDER_GRBG, },
549 	{ MEDIA_BUS_FMT_SRGGB8_1X8, 8, 8, CCS_PIXEL_ORDER_RGGB, },
550 	{ MEDIA_BUS_FMT_SBGGR8_1X8, 8, 8, CCS_PIXEL_ORDER_BGGR, },
551 	{ MEDIA_BUS_FMT_SGBRG8_1X8, 8, 8, CCS_PIXEL_ORDER_GBRG, },
552 };
553 
554 static const char *pixel_order_str[] = { "GRBG", "RGGB", "BGGR", "GBRG" };
555 
556 #define to_csi_format_idx(fmt) (((unsigned long)(fmt)			\
557 				 - (unsigned long)ccs_csi_data_formats) \
558 				/ sizeof(*ccs_csi_data_formats))
559 
560 static u32 ccs_pixel_order(struct ccs_sensor *sensor)
561 {
562 	struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
563 	int flip = 0;
564 
565 	if (sensor->hflip) {
566 		if (sensor->hflip->val)
567 			flip |= CCS_IMAGE_ORIENTATION_HORIZONTAL_MIRROR;
568 
569 		if (sensor->vflip->val)
570 			flip |= CCS_IMAGE_ORIENTATION_VERTICAL_FLIP;
571 	}
572 
573 	flip ^= sensor->hvflip_inv_mask;
574 
575 	dev_dbg(&client->dev, "flip %d\n", flip);
576 	return sensor->default_pixel_order ^ flip;
577 }
578 
579 static void ccs_update_mbus_formats(struct ccs_sensor *sensor)
580 {
581 	struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
582 	unsigned int csi_format_idx =
583 		to_csi_format_idx(sensor->csi_format) & ~3;
584 	unsigned int internal_csi_format_idx =
585 		to_csi_format_idx(sensor->internal_csi_format) & ~3;
586 	unsigned int pixel_order = ccs_pixel_order(sensor);
587 
588 	if (WARN_ON_ONCE(max(internal_csi_format_idx, csi_format_idx) +
589 			 pixel_order >= ARRAY_SIZE(ccs_csi_data_formats)))
590 		return;
591 
592 	sensor->mbus_frame_fmts =
593 		sensor->default_mbus_frame_fmts << pixel_order;
594 	sensor->csi_format =
595 		&ccs_csi_data_formats[csi_format_idx + pixel_order];
596 	sensor->internal_csi_format =
597 		&ccs_csi_data_formats[internal_csi_format_idx
598 					 + pixel_order];
599 
600 	dev_dbg(&client->dev, "new pixel order %s\n",
601 		pixel_order_str[pixel_order]);
602 }
603 
604 static const char * const ccs_test_patterns[] = {
605 	"Disabled",
606 	"Solid Colour",
607 	"Eight Vertical Colour Bars",
608 	"Colour Bars With Fade to Grey",
609 	"Pseudorandom Sequence (PN9)",
610 };
611 
612 static int ccs_set_ctrl(struct v4l2_ctrl *ctrl)
613 {
614 	struct ccs_sensor *sensor =
615 		container_of(ctrl->handler, struct ccs_subdev, ctrl_handler)
616 			->sensor;
617 	struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
618 	int pm_status;
619 	u32 orient = 0;
620 	unsigned int i;
621 	int exposure;
622 	int rval;
623 
624 	switch (ctrl->id) {
625 	case V4L2_CID_HFLIP:
626 	case V4L2_CID_VFLIP:
627 		if (sensor->streaming)
628 			return -EBUSY;
629 
630 		if (sensor->hflip->val)
631 			orient |= CCS_IMAGE_ORIENTATION_HORIZONTAL_MIRROR;
632 
633 		if (sensor->vflip->val)
634 			orient |= CCS_IMAGE_ORIENTATION_VERTICAL_FLIP;
635 
636 		orient ^= sensor->hvflip_inv_mask;
637 
638 		ccs_update_mbus_formats(sensor);
639 
640 		break;
641 	case V4L2_CID_VBLANK:
642 		exposure = sensor->exposure->val;
643 
644 		__ccs_update_exposure_limits(sensor);
645 
646 		if (exposure > sensor->exposure->maximum) {
647 			sensor->exposure->val =	sensor->exposure->maximum;
648 			rval = ccs_set_ctrl(sensor->exposure);
649 			if (rval < 0)
650 				return rval;
651 		}
652 
653 		break;
654 	case V4L2_CID_LINK_FREQ:
655 		if (sensor->streaming)
656 			return -EBUSY;
657 
658 		rval = ccs_pll_update(sensor);
659 		if (rval)
660 			return rval;
661 
662 		return 0;
663 	case V4L2_CID_TEST_PATTERN:
664 		for (i = 0; i < ARRAY_SIZE(sensor->test_data); i++)
665 			v4l2_ctrl_activate(
666 				sensor->test_data[i],
667 				ctrl->val ==
668 				V4L2_SMIAPP_TEST_PATTERN_MODE_SOLID_COLOUR);
669 
670 		break;
671 	}
672 
673 	pm_status = pm_runtime_get_if_active(&client->dev, true);
674 	if (!pm_status)
675 		return 0;
676 
677 	switch (ctrl->id) {
678 	case V4L2_CID_ANALOGUE_GAIN:
679 		rval = ccs_write(sensor, ANALOG_GAIN_CODE_GLOBAL, ctrl->val);
680 
681 		break;
682 
683 	case V4L2_CID_CCS_ANALOGUE_LINEAR_GAIN:
684 		rval = ccs_write(sensor, ANALOG_LINEAR_GAIN_GLOBAL, ctrl->val);
685 
686 		break;
687 
688 	case V4L2_CID_CCS_ANALOGUE_EXPONENTIAL_GAIN:
689 		rval = ccs_write(sensor, ANALOG_EXPONENTIAL_GAIN_GLOBAL,
690 				 ctrl->val);
691 
692 		break;
693 
694 	case V4L2_CID_DIGITAL_GAIN:
695 		if (CCS_LIM(sensor, DIGITAL_GAIN_CAPABILITY) ==
696 		    CCS_DIGITAL_GAIN_CAPABILITY_GLOBAL) {
697 			rval = ccs_write(sensor, DIGITAL_GAIN_GLOBAL,
698 					 ctrl->val);
699 			break;
700 		}
701 
702 		rval = ccs_write_addr(sensor,
703 				      SMIAPP_REG_U16_DIGITAL_GAIN_GREENR,
704 				      ctrl->val);
705 		if (rval)
706 			break;
707 
708 		rval = ccs_write_addr(sensor,
709 				      SMIAPP_REG_U16_DIGITAL_GAIN_RED,
710 				      ctrl->val);
711 		if (rval)
712 			break;
713 
714 		rval = ccs_write_addr(sensor,
715 				      SMIAPP_REG_U16_DIGITAL_GAIN_BLUE,
716 				      ctrl->val);
717 		if (rval)
718 			break;
719 
720 		rval = ccs_write_addr(sensor,
721 				      SMIAPP_REG_U16_DIGITAL_GAIN_GREENB,
722 				      ctrl->val);
723 
724 		break;
725 	case V4L2_CID_EXPOSURE:
726 		rval = ccs_write(sensor, COARSE_INTEGRATION_TIME, ctrl->val);
727 
728 		break;
729 	case V4L2_CID_HFLIP:
730 	case V4L2_CID_VFLIP:
731 		rval = ccs_write(sensor, IMAGE_ORIENTATION, orient);
732 
733 		break;
734 	case V4L2_CID_VBLANK:
735 		rval = ccs_write(sensor, FRAME_LENGTH_LINES,
736 				 sensor->pixel_array->crop[
737 					 CCS_PA_PAD_SRC].height
738 				 + ctrl->val);
739 
740 		break;
741 	case V4L2_CID_HBLANK:
742 		rval = ccs_write(sensor, LINE_LENGTH_PCK,
743 				 sensor->pixel_array->crop[CCS_PA_PAD_SRC].width
744 				 + ctrl->val);
745 
746 		break;
747 	case V4L2_CID_TEST_PATTERN:
748 		rval = ccs_write(sensor, TEST_PATTERN_MODE, ctrl->val);
749 
750 		break;
751 	case V4L2_CID_TEST_PATTERN_RED:
752 		rval = ccs_write(sensor, TEST_DATA_RED, ctrl->val);
753 
754 		break;
755 	case V4L2_CID_TEST_PATTERN_GREENR:
756 		rval = ccs_write(sensor, TEST_DATA_GREENR, ctrl->val);
757 
758 		break;
759 	case V4L2_CID_TEST_PATTERN_BLUE:
760 		rval = ccs_write(sensor, TEST_DATA_BLUE, ctrl->val);
761 
762 		break;
763 	case V4L2_CID_TEST_PATTERN_GREENB:
764 		rval = ccs_write(sensor, TEST_DATA_GREENB, ctrl->val);
765 
766 		break;
767 	case V4L2_CID_CCS_SHADING_CORRECTION:
768 		rval = ccs_write(sensor, SHADING_CORRECTION_EN,
769 				 ctrl->val ? CCS_SHADING_CORRECTION_EN_ENABLE :
770 				 0);
771 
772 		if (!rval && sensor->luminance_level)
773 			v4l2_ctrl_activate(sensor->luminance_level, ctrl->val);
774 
775 		break;
776 	case V4L2_CID_CCS_LUMINANCE_CORRECTION_LEVEL:
777 		rval = ccs_write(sensor, LUMINANCE_CORRECTION_LEVEL, ctrl->val);
778 
779 		break;
780 	case V4L2_CID_PIXEL_RATE:
781 		/* For v4l2_ctrl_s_ctrl_int64() used internally. */
782 		rval = 0;
783 
784 		break;
785 	default:
786 		rval = -EINVAL;
787 	}
788 
789 	if (pm_status > 0) {
790 		pm_runtime_mark_last_busy(&client->dev);
791 		pm_runtime_put_autosuspend(&client->dev);
792 	}
793 
794 	return rval;
795 }
796 
797 static const struct v4l2_ctrl_ops ccs_ctrl_ops = {
798 	.s_ctrl = ccs_set_ctrl,
799 };
800 
801 static int ccs_init_controls(struct ccs_sensor *sensor)
802 {
803 	struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
804 	int rval;
805 
806 	rval = v4l2_ctrl_handler_init(&sensor->pixel_array->ctrl_handler, 17);
807 	if (rval)
808 		return rval;
809 
810 	sensor->pixel_array->ctrl_handler.lock = &sensor->mutex;
811 
812 	switch (CCS_LIM(sensor, ANALOG_GAIN_CAPABILITY)) {
813 	case CCS_ANALOG_GAIN_CAPABILITY_GLOBAL: {
814 		struct {
815 			const char *name;
816 			u32 id;
817 			s32 value;
818 		} const gain_ctrls[] = {
819 			{ "Analogue Gain m0", V4L2_CID_CCS_ANALOGUE_GAIN_M0,
820 			  CCS_LIM(sensor, ANALOG_GAIN_M0), },
821 			{ "Analogue Gain c0", V4L2_CID_CCS_ANALOGUE_GAIN_C0,
822 			  CCS_LIM(sensor, ANALOG_GAIN_C0), },
823 			{ "Analogue Gain m1", V4L2_CID_CCS_ANALOGUE_GAIN_M1,
824 			  CCS_LIM(sensor, ANALOG_GAIN_M1), },
825 			{ "Analogue Gain c1", V4L2_CID_CCS_ANALOGUE_GAIN_C1,
826 			  CCS_LIM(sensor, ANALOG_GAIN_C1), },
827 		};
828 		struct v4l2_ctrl_config ctrl_cfg = {
829 			.type = V4L2_CTRL_TYPE_INTEGER,
830 			.ops = &ccs_ctrl_ops,
831 			.flags = V4L2_CTRL_FLAG_READ_ONLY,
832 			.step = 1,
833 		};
834 		unsigned int i;
835 
836 		for (i = 0; i < ARRAY_SIZE(gain_ctrls); i++) {
837 			ctrl_cfg.name = gain_ctrls[i].name;
838 			ctrl_cfg.id = gain_ctrls[i].id;
839 			ctrl_cfg.min = ctrl_cfg.max = ctrl_cfg.def =
840 				gain_ctrls[i].value;
841 
842 			v4l2_ctrl_new_custom(&sensor->pixel_array->ctrl_handler,
843 					     &ctrl_cfg, NULL);
844 		}
845 
846 		v4l2_ctrl_new_std(&sensor->pixel_array->ctrl_handler,
847 				  &ccs_ctrl_ops, V4L2_CID_ANALOGUE_GAIN,
848 				  CCS_LIM(sensor, ANALOG_GAIN_CODE_MIN),
849 				  CCS_LIM(sensor, ANALOG_GAIN_CODE_MAX),
850 				  max(CCS_LIM(sensor, ANALOG_GAIN_CODE_STEP),
851 				      1U),
852 				  CCS_LIM(sensor, ANALOG_GAIN_CODE_MIN));
853 	}
854 		break;
855 
856 	case CCS_ANALOG_GAIN_CAPABILITY_ALTERNATE_GLOBAL: {
857 		struct {
858 			const char *name;
859 			u32 id;
860 			u16 min, max, step;
861 		} const gain_ctrls[] = {
862 			{
863 				"Analogue Linear Gain",
864 				V4L2_CID_CCS_ANALOGUE_LINEAR_GAIN,
865 				CCS_LIM(sensor, ANALOG_LINEAR_GAIN_MIN),
866 				CCS_LIM(sensor, ANALOG_LINEAR_GAIN_MAX),
867 				max(CCS_LIM(sensor,
868 					    ANALOG_LINEAR_GAIN_STEP_SIZE),
869 				    1U),
870 			},
871 			{
872 				"Analogue Exponential Gain",
873 				V4L2_CID_CCS_ANALOGUE_EXPONENTIAL_GAIN,
874 				CCS_LIM(sensor, ANALOG_EXPONENTIAL_GAIN_MIN),
875 				CCS_LIM(sensor, ANALOG_EXPONENTIAL_GAIN_MAX),
876 				max(CCS_LIM(sensor,
877 					    ANALOG_EXPONENTIAL_GAIN_STEP_SIZE),
878 				    1U),
879 			},
880 		};
881 		struct v4l2_ctrl_config ctrl_cfg = {
882 			.type = V4L2_CTRL_TYPE_INTEGER,
883 			.ops = &ccs_ctrl_ops,
884 		};
885 		unsigned int i;
886 
887 		for (i = 0; i < ARRAY_SIZE(gain_ctrls); i++) {
888 			ctrl_cfg.name = gain_ctrls[i].name;
889 			ctrl_cfg.min = ctrl_cfg.def = gain_ctrls[i].min;
890 			ctrl_cfg.max = gain_ctrls[i].max;
891 			ctrl_cfg.step = gain_ctrls[i].step;
892 			ctrl_cfg.id = gain_ctrls[i].id;
893 
894 			v4l2_ctrl_new_custom(&sensor->pixel_array->ctrl_handler,
895 					     &ctrl_cfg, NULL);
896 		}
897 	}
898 	}
899 
900 	if (CCS_LIM(sensor, SHADING_CORRECTION_CAPABILITY) &
901 	    (CCS_SHADING_CORRECTION_CAPABILITY_COLOR_SHADING |
902 	     CCS_SHADING_CORRECTION_CAPABILITY_LUMINANCE_CORRECTION)) {
903 		const struct v4l2_ctrl_config ctrl_cfg = {
904 			.name = "Shading Correction",
905 			.type = V4L2_CTRL_TYPE_BOOLEAN,
906 			.id = V4L2_CID_CCS_SHADING_CORRECTION,
907 			.ops = &ccs_ctrl_ops,
908 			.max = 1,
909 			.step = 1,
910 		};
911 
912 		v4l2_ctrl_new_custom(&sensor->pixel_array->ctrl_handler,
913 				     &ctrl_cfg, NULL);
914 	}
915 
916 	if (CCS_LIM(sensor, SHADING_CORRECTION_CAPABILITY) &
917 	    CCS_SHADING_CORRECTION_CAPABILITY_LUMINANCE_CORRECTION) {
918 		const struct v4l2_ctrl_config ctrl_cfg = {
919 			.name = "Luminance Correction Level",
920 			.type = V4L2_CTRL_TYPE_BOOLEAN,
921 			.id = V4L2_CID_CCS_LUMINANCE_CORRECTION_LEVEL,
922 			.ops = &ccs_ctrl_ops,
923 			.max = 255,
924 			.step = 1,
925 			.def = 128,
926 		};
927 
928 		sensor->luminance_level =
929 			v4l2_ctrl_new_custom(&sensor->pixel_array->ctrl_handler,
930 					     &ctrl_cfg, NULL);
931 	}
932 
933 	if (CCS_LIM(sensor, DIGITAL_GAIN_CAPABILITY) ==
934 	    CCS_DIGITAL_GAIN_CAPABILITY_GLOBAL ||
935 	    CCS_LIM(sensor, DIGITAL_GAIN_CAPABILITY) ==
936 	    SMIAPP_DIGITAL_GAIN_CAPABILITY_PER_CHANNEL)
937 		v4l2_ctrl_new_std(&sensor->pixel_array->ctrl_handler,
938 				  &ccs_ctrl_ops, V4L2_CID_DIGITAL_GAIN,
939 				  CCS_LIM(sensor, DIGITAL_GAIN_MIN),
940 				  CCS_LIM(sensor, DIGITAL_GAIN_MAX),
941 				  max(CCS_LIM(sensor, DIGITAL_GAIN_STEP_SIZE),
942 				      1U),
943 				  0x100);
944 
945 	/* Exposure limits will be updated soon, use just something here. */
946 	sensor->exposure = v4l2_ctrl_new_std(
947 		&sensor->pixel_array->ctrl_handler, &ccs_ctrl_ops,
948 		V4L2_CID_EXPOSURE, 0, 0, 1, 0);
949 
950 	sensor->hflip = v4l2_ctrl_new_std(
951 		&sensor->pixel_array->ctrl_handler, &ccs_ctrl_ops,
952 		V4L2_CID_HFLIP, 0, 1, 1, 0);
953 	sensor->vflip = v4l2_ctrl_new_std(
954 		&sensor->pixel_array->ctrl_handler, &ccs_ctrl_ops,
955 		V4L2_CID_VFLIP, 0, 1, 1, 0);
956 
957 	sensor->vblank = v4l2_ctrl_new_std(
958 		&sensor->pixel_array->ctrl_handler, &ccs_ctrl_ops,
959 		V4L2_CID_VBLANK, 0, 1, 1, 0);
960 
961 	if (sensor->vblank)
962 		sensor->vblank->flags |= V4L2_CTRL_FLAG_UPDATE;
963 
964 	sensor->hblank = v4l2_ctrl_new_std(
965 		&sensor->pixel_array->ctrl_handler, &ccs_ctrl_ops,
966 		V4L2_CID_HBLANK, 0, 1, 1, 0);
967 
968 	if (sensor->hblank)
969 		sensor->hblank->flags |= V4L2_CTRL_FLAG_UPDATE;
970 
971 	sensor->pixel_rate_parray = v4l2_ctrl_new_std(
972 		&sensor->pixel_array->ctrl_handler, &ccs_ctrl_ops,
973 		V4L2_CID_PIXEL_RATE, 1, INT_MAX, 1, 1);
974 
975 	v4l2_ctrl_new_std_menu_items(&sensor->pixel_array->ctrl_handler,
976 				     &ccs_ctrl_ops, V4L2_CID_TEST_PATTERN,
977 				     ARRAY_SIZE(ccs_test_patterns) - 1,
978 				     0, 0, ccs_test_patterns);
979 
980 	if (sensor->pixel_array->ctrl_handler.error) {
981 		dev_err(&client->dev,
982 			"pixel array controls initialization failed (%d)\n",
983 			sensor->pixel_array->ctrl_handler.error);
984 		return sensor->pixel_array->ctrl_handler.error;
985 	}
986 
987 	sensor->pixel_array->sd.ctrl_handler =
988 		&sensor->pixel_array->ctrl_handler;
989 
990 	v4l2_ctrl_cluster(2, &sensor->hflip);
991 
992 	rval = v4l2_ctrl_handler_init(&sensor->src->ctrl_handler, 0);
993 	if (rval)
994 		return rval;
995 
996 	sensor->src->ctrl_handler.lock = &sensor->mutex;
997 
998 	sensor->pixel_rate_csi = v4l2_ctrl_new_std(
999 		&sensor->src->ctrl_handler, &ccs_ctrl_ops,
1000 		V4L2_CID_PIXEL_RATE, 1, INT_MAX, 1, 1);
1001 
1002 	if (sensor->src->ctrl_handler.error) {
1003 		dev_err(&client->dev,
1004 			"src controls initialization failed (%d)\n",
1005 			sensor->src->ctrl_handler.error);
1006 		return sensor->src->ctrl_handler.error;
1007 	}
1008 
1009 	sensor->src->sd.ctrl_handler = &sensor->src->ctrl_handler;
1010 
1011 	return 0;
1012 }
1013 
1014 /*
1015  * For controls that require information on available media bus codes
1016  * and linke frequencies.
1017  */
1018 static int ccs_init_late_controls(struct ccs_sensor *sensor)
1019 {
1020 	unsigned long *valid_link_freqs = &sensor->valid_link_freqs[
1021 		sensor->csi_format->compressed - sensor->compressed_min_bpp];
1022 	unsigned int i;
1023 
1024 	for (i = 0; i < ARRAY_SIZE(sensor->test_data); i++) {
1025 		int max_value = (1 << sensor->csi_format->width) - 1;
1026 
1027 		sensor->test_data[i] = v4l2_ctrl_new_std(
1028 				&sensor->pixel_array->ctrl_handler,
1029 				&ccs_ctrl_ops, V4L2_CID_TEST_PATTERN_RED + i,
1030 				0, max_value, 1, max_value);
1031 	}
1032 
1033 	sensor->link_freq = v4l2_ctrl_new_int_menu(
1034 		&sensor->src->ctrl_handler, &ccs_ctrl_ops,
1035 		V4L2_CID_LINK_FREQ, __fls(*valid_link_freqs),
1036 		__ffs(*valid_link_freqs), sensor->hwcfg.op_sys_clock);
1037 
1038 	return sensor->src->ctrl_handler.error;
1039 }
1040 
1041 static void ccs_free_controls(struct ccs_sensor *sensor)
1042 {
1043 	unsigned int i;
1044 
1045 	for (i = 0; i < sensor->ssds_used; i++)
1046 		v4l2_ctrl_handler_free(&sensor->ssds[i].ctrl_handler);
1047 }
1048 
1049 static int ccs_get_mbus_formats(struct ccs_sensor *sensor)
1050 {
1051 	struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
1052 	struct ccs_pll *pll = &sensor->pll;
1053 	u8 compressed_max_bpp = 0;
1054 	unsigned int type, n;
1055 	unsigned int i, pixel_order;
1056 	int rval;
1057 
1058 	type = CCS_LIM(sensor, DATA_FORMAT_MODEL_TYPE);
1059 
1060 	dev_dbg(&client->dev, "data_format_model_type %d\n", type);
1061 
1062 	rval = ccs_read(sensor, PIXEL_ORDER, &pixel_order);
1063 	if (rval)
1064 		return rval;
1065 
1066 	if (pixel_order >= ARRAY_SIZE(pixel_order_str)) {
1067 		dev_dbg(&client->dev, "bad pixel order %d\n", pixel_order);
1068 		return -EINVAL;
1069 	}
1070 
1071 	dev_dbg(&client->dev, "pixel order %d (%s)\n", pixel_order,
1072 		pixel_order_str[pixel_order]);
1073 
1074 	switch (type) {
1075 	case CCS_DATA_FORMAT_MODEL_TYPE_NORMAL:
1076 		n = SMIAPP_DATA_FORMAT_MODEL_TYPE_NORMAL_N;
1077 		break;
1078 	case CCS_DATA_FORMAT_MODEL_TYPE_EXTENDED:
1079 		n = CCS_LIM_DATA_FORMAT_DESCRIPTOR_MAX_N + 1;
1080 		break;
1081 	default:
1082 		return -EINVAL;
1083 	}
1084 
1085 	sensor->default_pixel_order = pixel_order;
1086 	sensor->mbus_frame_fmts = 0;
1087 
1088 	for (i = 0; i < n; i++) {
1089 		unsigned int fmt, j;
1090 
1091 		fmt = CCS_LIM_AT(sensor, DATA_FORMAT_DESCRIPTOR, i);
1092 
1093 		dev_dbg(&client->dev, "%u: bpp %u, compressed %u\n",
1094 			i, fmt >> 8, (u8)fmt);
1095 
1096 		for (j = 0; j < ARRAY_SIZE(ccs_csi_data_formats); j++) {
1097 			const struct ccs_csi_data_format *f =
1098 				&ccs_csi_data_formats[j];
1099 
1100 			if (f->pixel_order != CCS_PIXEL_ORDER_GRBG)
1101 				continue;
1102 
1103 			if (f->width != fmt >>
1104 			    CCS_DATA_FORMAT_DESCRIPTOR_UNCOMPRESSED_SHIFT ||
1105 			    f->compressed !=
1106 			    (fmt & CCS_DATA_FORMAT_DESCRIPTOR_COMPRESSED_MASK))
1107 				continue;
1108 
1109 			dev_dbg(&client->dev, "jolly good! %d\n", j);
1110 
1111 			sensor->default_mbus_frame_fmts |= 1 << j;
1112 		}
1113 	}
1114 
1115 	/* Figure out which BPP values can be used with which formats. */
1116 	pll->binning_horizontal = 1;
1117 	pll->binning_vertical = 1;
1118 	pll->scale_m = sensor->scale_m;
1119 
1120 	for (i = 0; i < ARRAY_SIZE(ccs_csi_data_formats); i++) {
1121 		sensor->compressed_min_bpp =
1122 			min(ccs_csi_data_formats[i].compressed,
1123 			    sensor->compressed_min_bpp);
1124 		compressed_max_bpp =
1125 			max(ccs_csi_data_formats[i].compressed,
1126 			    compressed_max_bpp);
1127 	}
1128 
1129 	sensor->valid_link_freqs = devm_kcalloc(
1130 		&client->dev,
1131 		compressed_max_bpp - sensor->compressed_min_bpp + 1,
1132 		sizeof(*sensor->valid_link_freqs), GFP_KERNEL);
1133 	if (!sensor->valid_link_freqs)
1134 		return -ENOMEM;
1135 
1136 	for (i = 0; i < ARRAY_SIZE(ccs_csi_data_formats); i++) {
1137 		const struct ccs_csi_data_format *f =
1138 			&ccs_csi_data_formats[i];
1139 		unsigned long *valid_link_freqs =
1140 			&sensor->valid_link_freqs[
1141 				f->compressed - sensor->compressed_min_bpp];
1142 		unsigned int j;
1143 
1144 		if (!(sensor->default_mbus_frame_fmts & 1 << i))
1145 			continue;
1146 
1147 		pll->bits_per_pixel = f->compressed;
1148 
1149 		for (j = 0; sensor->hwcfg.op_sys_clock[j]; j++) {
1150 			pll->link_freq = sensor->hwcfg.op_sys_clock[j];
1151 
1152 			rval = ccs_pll_try(sensor, pll);
1153 			dev_dbg(&client->dev, "link freq %u Hz, bpp %u %s\n",
1154 				pll->link_freq, pll->bits_per_pixel,
1155 				rval ? "not ok" : "ok");
1156 			if (rval)
1157 				continue;
1158 
1159 			set_bit(j, valid_link_freqs);
1160 		}
1161 
1162 		if (!*valid_link_freqs) {
1163 			dev_info(&client->dev,
1164 				 "no valid link frequencies for %u bpp\n",
1165 				 f->compressed);
1166 			sensor->default_mbus_frame_fmts &= ~BIT(i);
1167 			continue;
1168 		}
1169 
1170 		if (!sensor->csi_format
1171 		    || f->width > sensor->csi_format->width
1172 		    || (f->width == sensor->csi_format->width
1173 			&& f->compressed > sensor->csi_format->compressed)) {
1174 			sensor->csi_format = f;
1175 			sensor->internal_csi_format = f;
1176 		}
1177 	}
1178 
1179 	if (!sensor->csi_format) {
1180 		dev_err(&client->dev, "no supported mbus code found\n");
1181 		return -EINVAL;
1182 	}
1183 
1184 	ccs_update_mbus_formats(sensor);
1185 
1186 	return 0;
1187 }
1188 
1189 static void ccs_update_blanking(struct ccs_sensor *sensor)
1190 {
1191 	struct v4l2_ctrl *vblank = sensor->vblank;
1192 	struct v4l2_ctrl *hblank = sensor->hblank;
1193 	u16 min_fll, max_fll, min_llp, max_llp, min_lbp;
1194 	int min, max;
1195 
1196 	if (sensor->binning_vertical > 1 || sensor->binning_horizontal > 1) {
1197 		min_fll = CCS_LIM(sensor, MIN_FRAME_LENGTH_LINES_BIN);
1198 		max_fll = CCS_LIM(sensor, MAX_FRAME_LENGTH_LINES_BIN);
1199 		min_llp = CCS_LIM(sensor, MIN_LINE_LENGTH_PCK_BIN);
1200 		max_llp = CCS_LIM(sensor, MAX_LINE_LENGTH_PCK_BIN);
1201 		min_lbp = CCS_LIM(sensor, MIN_LINE_BLANKING_PCK_BIN);
1202 	} else {
1203 		min_fll = CCS_LIM(sensor, MIN_FRAME_LENGTH_LINES);
1204 		max_fll = CCS_LIM(sensor, MAX_FRAME_LENGTH_LINES);
1205 		min_llp = CCS_LIM(sensor, MIN_LINE_LENGTH_PCK);
1206 		max_llp = CCS_LIM(sensor, MAX_LINE_LENGTH_PCK);
1207 		min_lbp = CCS_LIM(sensor, MIN_LINE_BLANKING_PCK);
1208 	}
1209 
1210 	min = max_t(int,
1211 		    CCS_LIM(sensor, MIN_FRAME_BLANKING_LINES),
1212 		    min_fll - sensor->pixel_array->crop[CCS_PA_PAD_SRC].height);
1213 	max = max_fll -	sensor->pixel_array->crop[CCS_PA_PAD_SRC].height;
1214 
1215 	__v4l2_ctrl_modify_range(vblank, min, max, vblank->step, min);
1216 
1217 	min = max_t(int,
1218 		    min_llp - sensor->pixel_array->crop[CCS_PA_PAD_SRC].width,
1219 		    min_lbp);
1220 	max = max_llp - sensor->pixel_array->crop[CCS_PA_PAD_SRC].width;
1221 
1222 	__v4l2_ctrl_modify_range(hblank, min, max, hblank->step, min);
1223 
1224 	__ccs_update_exposure_limits(sensor);
1225 }
1226 
1227 static int ccs_pll_blanking_update(struct ccs_sensor *sensor)
1228 {
1229 	struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
1230 	int rval;
1231 
1232 	rval = ccs_pll_update(sensor);
1233 	if (rval < 0)
1234 		return rval;
1235 
1236 	/* Output from pixel array, including blanking */
1237 	ccs_update_blanking(sensor);
1238 
1239 	dev_dbg(&client->dev, "vblank\t\t%d\n", sensor->vblank->val);
1240 	dev_dbg(&client->dev, "hblank\t\t%d\n", sensor->hblank->val);
1241 
1242 	dev_dbg(&client->dev, "real timeperframe\t100/%d\n",
1243 		sensor->pll.pixel_rate_pixel_array /
1244 		((sensor->pixel_array->crop[CCS_PA_PAD_SRC].width
1245 		  + sensor->hblank->val) *
1246 		 (sensor->pixel_array->crop[CCS_PA_PAD_SRC].height
1247 		  + sensor->vblank->val) / 100));
1248 
1249 	return 0;
1250 }
1251 
1252 /*
1253  *
1254  * SMIA++ NVM handling
1255  *
1256  */
1257 
1258 static int ccs_read_nvm_page(struct ccs_sensor *sensor, u32 p, u8 *nvm,
1259 			     u8 *status)
1260 {
1261 	unsigned int i;
1262 	int rval;
1263 	u32 s;
1264 
1265 	*status = 0;
1266 
1267 	rval = ccs_write(sensor, DATA_TRANSFER_IF_1_PAGE_SELECT, p);
1268 	if (rval)
1269 		return rval;
1270 
1271 	rval = ccs_write(sensor, DATA_TRANSFER_IF_1_CTRL,
1272 			 CCS_DATA_TRANSFER_IF_1_CTRL_ENABLE);
1273 	if (rval)
1274 		return rval;
1275 
1276 	rval = ccs_read(sensor, DATA_TRANSFER_IF_1_STATUS, &s);
1277 	if (rval)
1278 		return rval;
1279 
1280 	if (s & CCS_DATA_TRANSFER_IF_1_STATUS_IMPROPER_IF_USAGE) {
1281 		*status = s;
1282 		return -ENODATA;
1283 	}
1284 
1285 	if (CCS_LIM(sensor, DATA_TRANSFER_IF_CAPABILITY) &
1286 	    CCS_DATA_TRANSFER_IF_CAPABILITY_POLLING) {
1287 		for (i = 1000; i > 0; i--) {
1288 			if (s & CCS_DATA_TRANSFER_IF_1_STATUS_READ_IF_READY)
1289 				break;
1290 
1291 			rval = ccs_read(sensor, DATA_TRANSFER_IF_1_STATUS, &s);
1292 			if (rval)
1293 				return rval;
1294 		}
1295 
1296 		if (!i)
1297 			return -ETIMEDOUT;
1298 	}
1299 
1300 	for (i = 0; i <= CCS_LIM_DATA_TRANSFER_IF_1_DATA_MAX_P; i++) {
1301 		u32 v;
1302 
1303 		rval = ccs_read(sensor, DATA_TRANSFER_IF_1_DATA(i), &v);
1304 		if (rval)
1305 			return rval;
1306 
1307 		*nvm++ = v;
1308 	}
1309 
1310 	return 0;
1311 }
1312 
1313 static int ccs_read_nvm(struct ccs_sensor *sensor, unsigned char *nvm,
1314 			size_t nvm_size)
1315 {
1316 	u8 status = 0;
1317 	u32 p;
1318 	int rval = 0, rval2;
1319 
1320 	for (p = 0; p < nvm_size / (CCS_LIM_DATA_TRANSFER_IF_1_DATA_MAX_P + 1)
1321 		     && !rval; p++) {
1322 		rval = ccs_read_nvm_page(sensor, p, nvm, &status);
1323 		nvm += CCS_LIM_DATA_TRANSFER_IF_1_DATA_MAX_P + 1;
1324 	}
1325 
1326 	if (rval == -ENODATA &&
1327 	    status & CCS_DATA_TRANSFER_IF_1_STATUS_IMPROPER_IF_USAGE)
1328 		rval = 0;
1329 
1330 	rval2 = ccs_write(sensor, DATA_TRANSFER_IF_1_CTRL, 0);
1331 	if (rval < 0)
1332 		return rval;
1333 	else
1334 		return rval2 ?: p * (CCS_LIM_DATA_TRANSFER_IF_1_DATA_MAX_P + 1);
1335 }
1336 
1337 /*
1338  *
1339  * SMIA++ CCI address control
1340  *
1341  */
1342 static int ccs_change_cci_addr(struct ccs_sensor *sensor)
1343 {
1344 	struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
1345 	int rval;
1346 	u32 val;
1347 
1348 	client->addr = sensor->hwcfg.i2c_addr_dfl;
1349 
1350 	rval = ccs_write(sensor, CCI_ADDRESS_CTRL,
1351 			 sensor->hwcfg.i2c_addr_alt << 1);
1352 	if (rval)
1353 		return rval;
1354 
1355 	client->addr = sensor->hwcfg.i2c_addr_alt;
1356 
1357 	/* verify addr change went ok */
1358 	rval = ccs_read(sensor, CCI_ADDRESS_CTRL, &val);
1359 	if (rval)
1360 		return rval;
1361 
1362 	if (val != sensor->hwcfg.i2c_addr_alt << 1)
1363 		return -ENODEV;
1364 
1365 	return 0;
1366 }
1367 
1368 /*
1369  *
1370  * SMIA++ Mode Control
1371  *
1372  */
1373 static int ccs_setup_flash_strobe(struct ccs_sensor *sensor)
1374 {
1375 	struct ccs_flash_strobe_parms *strobe_setup;
1376 	unsigned int ext_freq = sensor->hwcfg.ext_clk;
1377 	u32 tmp;
1378 	u32 strobe_adjustment;
1379 	u32 strobe_width_high_rs;
1380 	int rval;
1381 
1382 	strobe_setup = sensor->hwcfg.strobe_setup;
1383 
1384 	/*
1385 	 * How to calculate registers related to strobe length. Please
1386 	 * do not change, or if you do at least know what you're
1387 	 * doing. :-)
1388 	 *
1389 	 * Sakari Ailus <sakari.ailus@linux.intel.com> 2010-10-25
1390 	 *
1391 	 * flash_strobe_length [us] / 10^6 = (tFlash_strobe_width_ctrl
1392 	 *	/ EXTCLK freq [Hz]) * flash_strobe_adjustment
1393 	 *
1394 	 * tFlash_strobe_width_ctrl E N, [1 - 0xffff]
1395 	 * flash_strobe_adjustment E N, [1 - 0xff]
1396 	 *
1397 	 * The formula above is written as below to keep it on one
1398 	 * line:
1399 	 *
1400 	 * l / 10^6 = w / e * a
1401 	 *
1402 	 * Let's mark w * a by x:
1403 	 *
1404 	 * x = w * a
1405 	 *
1406 	 * Thus, we get:
1407 	 *
1408 	 * x = l * e / 10^6
1409 	 *
1410 	 * The strobe width must be at least as long as requested,
1411 	 * thus rounding upwards is needed.
1412 	 *
1413 	 * x = (l * e + 10^6 - 1) / 10^6
1414 	 * -----------------------------
1415 	 *
1416 	 * Maximum possible accuracy is wanted at all times. Thus keep
1417 	 * a as small as possible.
1418 	 *
1419 	 * Calculate a, assuming maximum w, with rounding upwards:
1420 	 *
1421 	 * a = (x + (2^16 - 1) - 1) / (2^16 - 1)
1422 	 * -------------------------------------
1423 	 *
1424 	 * Thus, we also get w, with that a, with rounding upwards:
1425 	 *
1426 	 * w = (x + a - 1) / a
1427 	 * -------------------
1428 	 *
1429 	 * To get limits:
1430 	 *
1431 	 * x E [1, (2^16 - 1) * (2^8 - 1)]
1432 	 *
1433 	 * Substituting maximum x to the original formula (with rounding),
1434 	 * the maximum l is thus
1435 	 *
1436 	 * (2^16 - 1) * (2^8 - 1) * 10^6 = l * e + 10^6 - 1
1437 	 *
1438 	 * l = (10^6 * (2^16 - 1) * (2^8 - 1) - 10^6 + 1) / e
1439 	 * --------------------------------------------------
1440 	 *
1441 	 * flash_strobe_length must be clamped between 1 and
1442 	 * (10^6 * (2^16 - 1) * (2^8 - 1) - 10^6 + 1) / EXTCLK freq.
1443 	 *
1444 	 * Then,
1445 	 *
1446 	 * flash_strobe_adjustment = ((flash_strobe_length *
1447 	 *	EXTCLK freq + 10^6 - 1) / 10^6 + (2^16 - 1) - 1) / (2^16 - 1)
1448 	 *
1449 	 * tFlash_strobe_width_ctrl = ((flash_strobe_length *
1450 	 *	EXTCLK freq + 10^6 - 1) / 10^6 +
1451 	 *	flash_strobe_adjustment - 1) / flash_strobe_adjustment
1452 	 */
1453 	tmp = div_u64(1000000ULL * ((1 << 16) - 1) * ((1 << 8) - 1) -
1454 		      1000000 + 1, ext_freq);
1455 	strobe_setup->strobe_width_high_us =
1456 		clamp_t(u32, strobe_setup->strobe_width_high_us, 1, tmp);
1457 
1458 	tmp = div_u64(((u64)strobe_setup->strobe_width_high_us * (u64)ext_freq +
1459 			1000000 - 1), 1000000ULL);
1460 	strobe_adjustment = (tmp + (1 << 16) - 1 - 1) / ((1 << 16) - 1);
1461 	strobe_width_high_rs = (tmp + strobe_adjustment - 1) /
1462 				strobe_adjustment;
1463 
1464 	rval = ccs_write(sensor, FLASH_MODE_RS, strobe_setup->mode);
1465 	if (rval < 0)
1466 		goto out;
1467 
1468 	rval = ccs_write(sensor, FLASH_STROBE_ADJUSTMENT, strobe_adjustment);
1469 	if (rval < 0)
1470 		goto out;
1471 
1472 	rval = ccs_write(sensor, TFLASH_STROBE_WIDTH_HIGH_RS_CTRL,
1473 			 strobe_width_high_rs);
1474 	if (rval < 0)
1475 		goto out;
1476 
1477 	rval = ccs_write(sensor, TFLASH_STROBE_DELAY_RS_CTRL,
1478 			 strobe_setup->strobe_delay);
1479 	if (rval < 0)
1480 		goto out;
1481 
1482 	rval = ccs_write(sensor, FLASH_STROBE_START_POINT,
1483 			 strobe_setup->stobe_start_point);
1484 	if (rval < 0)
1485 		goto out;
1486 
1487 	rval = ccs_write(sensor, FLASH_TRIGGER_RS, strobe_setup->trigger);
1488 
1489 out:
1490 	sensor->hwcfg.strobe_setup->trigger = 0;
1491 
1492 	return rval;
1493 }
1494 
1495 /* -----------------------------------------------------------------------------
1496  * Power management
1497  */
1498 
1499 static int ccs_write_msr_regs(struct ccs_sensor *sensor)
1500 {
1501 	int rval;
1502 
1503 	rval = ccs_write_data_regs(sensor,
1504 				   sensor->sdata.sensor_manufacturer_regs,
1505 				   sensor->sdata.num_sensor_manufacturer_regs);
1506 	if (rval)
1507 		return rval;
1508 
1509 	return ccs_write_data_regs(sensor,
1510 				   sensor->mdata.module_manufacturer_regs,
1511 				   sensor->mdata.num_module_manufacturer_regs);
1512 }
1513 
1514 static int ccs_update_phy_ctrl(struct ccs_sensor *sensor)
1515 {
1516 	struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
1517 	u8 val;
1518 
1519 	if (!sensor->ccs_limits)
1520 		return 0;
1521 
1522 	if (CCS_LIM(sensor, PHY_CTRL_CAPABILITY) &
1523 	    CCS_PHY_CTRL_CAPABILITY_AUTO_PHY_CTL) {
1524 		val = CCS_PHY_CTRL_AUTO;
1525 	} else if (CCS_LIM(sensor, PHY_CTRL_CAPABILITY) &
1526 		   CCS_PHY_CTRL_CAPABILITY_UI_PHY_CTL) {
1527 		val = CCS_PHY_CTRL_UI;
1528 	} else {
1529 		dev_err(&client->dev, "manual PHY control not supported\n");
1530 		return -EINVAL;
1531 	}
1532 
1533 	return ccs_write(sensor, PHY_CTRL, val);
1534 }
1535 
1536 static int ccs_power_on(struct device *dev)
1537 {
1538 	struct v4l2_subdev *subdev = dev_get_drvdata(dev);
1539 	struct ccs_subdev *ssd = to_ccs_subdev(subdev);
1540 	/*
1541 	 * The sub-device related to the I2C device is always the
1542 	 * source one, i.e. ssds[0].
1543 	 */
1544 	struct ccs_sensor *sensor =
1545 		container_of(ssd, struct ccs_sensor, ssds[0]);
1546 	const struct ccs_device *ccsdev = device_get_match_data(dev);
1547 	int rval;
1548 
1549 	rval = regulator_bulk_enable(ARRAY_SIZE(ccs_regulators),
1550 				     sensor->regulators);
1551 	if (rval) {
1552 		dev_err(dev, "failed to enable vana regulator\n");
1553 		return rval;
1554 	}
1555 
1556 	if (sensor->reset || sensor->xshutdown || sensor->ext_clk) {
1557 		unsigned int sleep;
1558 
1559 		rval = clk_prepare_enable(sensor->ext_clk);
1560 		if (rval < 0) {
1561 			dev_dbg(dev, "failed to enable xclk\n");
1562 			goto out_xclk_fail;
1563 		}
1564 
1565 		gpiod_set_value(sensor->reset, 0);
1566 		gpiod_set_value(sensor->xshutdown, 1);
1567 
1568 		if (ccsdev->flags & CCS_DEVICE_FLAG_IS_SMIA)
1569 			sleep = SMIAPP_RESET_DELAY(sensor->hwcfg.ext_clk);
1570 		else
1571 			sleep = 5000;
1572 
1573 		usleep_range(sleep, sleep);
1574 	}
1575 
1576 	/*
1577 	 * Failures to respond to the address change command have been noticed.
1578 	 * Those failures seem to be caused by the sensor requiring a longer
1579 	 * boot time than advertised. An additional 10ms delay seems to work
1580 	 * around the issue, but the SMIA++ I2C write retry hack makes the delay
1581 	 * unnecessary. The failures need to be investigated to find a proper
1582 	 * fix, and a delay will likely need to be added here if the I2C write
1583 	 * retry hack is reverted before the root cause of the boot time issue
1584 	 * is found.
1585 	 */
1586 
1587 	if (!sensor->reset && !sensor->xshutdown) {
1588 		u8 retry = 100;
1589 		u32 reset;
1590 
1591 		rval = ccs_write(sensor, SOFTWARE_RESET, CCS_SOFTWARE_RESET_ON);
1592 		if (rval < 0) {
1593 			dev_err(dev, "software reset failed\n");
1594 			goto out_cci_addr_fail;
1595 		}
1596 
1597 		do {
1598 			rval = ccs_read(sensor, SOFTWARE_RESET, &reset);
1599 			reset = !rval && reset == CCS_SOFTWARE_RESET_OFF;
1600 			if (reset)
1601 				break;
1602 
1603 			usleep_range(1000, 2000);
1604 		} while (--retry);
1605 
1606 		if (!reset)
1607 			return -EIO;
1608 	}
1609 
1610 	if (sensor->hwcfg.i2c_addr_alt) {
1611 		rval = ccs_change_cci_addr(sensor);
1612 		if (rval) {
1613 			dev_err(dev, "cci address change error\n");
1614 			goto out_cci_addr_fail;
1615 		}
1616 	}
1617 
1618 	rval = ccs_write(sensor, COMPRESSION_MODE,
1619 			 CCS_COMPRESSION_MODE_DPCM_PCM_SIMPLE);
1620 	if (rval) {
1621 		dev_err(dev, "compression mode set failed\n");
1622 		goto out_cci_addr_fail;
1623 	}
1624 
1625 	rval = ccs_write(sensor, EXTCLK_FREQUENCY_MHZ,
1626 			 sensor->hwcfg.ext_clk / (1000000 / (1 << 8)));
1627 	if (rval) {
1628 		dev_err(dev, "extclk frequency set failed\n");
1629 		goto out_cci_addr_fail;
1630 	}
1631 
1632 	rval = ccs_write(sensor, CSI_LANE_MODE, sensor->hwcfg.lanes - 1);
1633 	if (rval) {
1634 		dev_err(dev, "csi lane mode set failed\n");
1635 		goto out_cci_addr_fail;
1636 	}
1637 
1638 	rval = ccs_write(sensor, FAST_STANDBY_CTRL,
1639 			 CCS_FAST_STANDBY_CTRL_FRAME_TRUNCATION);
1640 	if (rval) {
1641 		dev_err(dev, "fast standby set failed\n");
1642 		goto out_cci_addr_fail;
1643 	}
1644 
1645 	rval = ccs_write(sensor, CSI_SIGNALING_MODE,
1646 			 sensor->hwcfg.csi_signalling_mode);
1647 	if (rval) {
1648 		dev_err(dev, "csi signalling mode set failed\n");
1649 		goto out_cci_addr_fail;
1650 	}
1651 
1652 	rval = ccs_update_phy_ctrl(sensor);
1653 	if (rval < 0)
1654 		goto out_cci_addr_fail;
1655 
1656 	rval = ccs_write_msr_regs(sensor);
1657 	if (rval)
1658 		goto out_cci_addr_fail;
1659 
1660 	rval = ccs_call_quirk(sensor, post_poweron);
1661 	if (rval) {
1662 		dev_err(dev, "post_poweron quirks failed\n");
1663 		goto out_cci_addr_fail;
1664 	}
1665 
1666 	return 0;
1667 
1668 out_cci_addr_fail:
1669 	gpiod_set_value(sensor->reset, 1);
1670 	gpiod_set_value(sensor->xshutdown, 0);
1671 	clk_disable_unprepare(sensor->ext_clk);
1672 
1673 out_xclk_fail:
1674 	regulator_bulk_disable(ARRAY_SIZE(ccs_regulators),
1675 			       sensor->regulators);
1676 
1677 	return rval;
1678 }
1679 
1680 static int ccs_power_off(struct device *dev)
1681 {
1682 	struct v4l2_subdev *subdev = dev_get_drvdata(dev);
1683 	struct ccs_subdev *ssd = to_ccs_subdev(subdev);
1684 	struct ccs_sensor *sensor =
1685 		container_of(ssd, struct ccs_sensor, ssds[0]);
1686 
1687 	/*
1688 	 * Currently power/clock to lens are enable/disabled separately
1689 	 * but they are essentially the same signals. So if the sensor is
1690 	 * powered off while the lens is powered on the sensor does not
1691 	 * really see a power off and next time the cci address change
1692 	 * will fail. So do a soft reset explicitly here.
1693 	 */
1694 	if (sensor->hwcfg.i2c_addr_alt)
1695 		ccs_write(sensor, SOFTWARE_RESET, CCS_SOFTWARE_RESET_ON);
1696 
1697 	gpiod_set_value(sensor->reset, 1);
1698 	gpiod_set_value(sensor->xshutdown, 0);
1699 	clk_disable_unprepare(sensor->ext_clk);
1700 	usleep_range(5000, 5000);
1701 	regulator_bulk_disable(ARRAY_SIZE(ccs_regulators),
1702 			       sensor->regulators);
1703 	sensor->streaming = false;
1704 
1705 	return 0;
1706 }
1707 
1708 /* -----------------------------------------------------------------------------
1709  * Video stream management
1710  */
1711 
1712 static int ccs_start_streaming(struct ccs_sensor *sensor)
1713 {
1714 	struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
1715 	unsigned int binning_mode;
1716 	int rval;
1717 
1718 	mutex_lock(&sensor->mutex);
1719 
1720 	rval = ccs_write(sensor, CSI_DATA_FORMAT,
1721 			 (sensor->csi_format->width << 8) |
1722 			 sensor->csi_format->compressed);
1723 	if (rval)
1724 		goto out;
1725 
1726 	/* Binning configuration */
1727 	if (sensor->binning_horizontal == 1 &&
1728 	    sensor->binning_vertical == 1) {
1729 		binning_mode = 0;
1730 	} else {
1731 		u8 binning_type =
1732 			(sensor->binning_horizontal << 4)
1733 			| sensor->binning_vertical;
1734 
1735 		rval = ccs_write(sensor, BINNING_TYPE, binning_type);
1736 		if (rval < 0)
1737 			goto out;
1738 
1739 		binning_mode = 1;
1740 	}
1741 	rval = ccs_write(sensor, BINNING_MODE, binning_mode);
1742 	if (rval < 0)
1743 		goto out;
1744 
1745 	/* Set up PLL */
1746 	rval = ccs_pll_configure(sensor);
1747 	if (rval)
1748 		goto out;
1749 
1750 	/* Analog crop start coordinates */
1751 	rval = ccs_write(sensor, X_ADDR_START,
1752 			 sensor->pixel_array->crop[CCS_PA_PAD_SRC].left);
1753 	if (rval < 0)
1754 		goto out;
1755 
1756 	rval = ccs_write(sensor, Y_ADDR_START,
1757 			 sensor->pixel_array->crop[CCS_PA_PAD_SRC].top);
1758 	if (rval < 0)
1759 		goto out;
1760 
1761 	/* Analog crop end coordinates */
1762 	rval = ccs_write(
1763 		sensor, X_ADDR_END,
1764 		sensor->pixel_array->crop[CCS_PA_PAD_SRC].left
1765 		+ sensor->pixel_array->crop[CCS_PA_PAD_SRC].width - 1);
1766 	if (rval < 0)
1767 		goto out;
1768 
1769 	rval = ccs_write(
1770 		sensor, Y_ADDR_END,
1771 		sensor->pixel_array->crop[CCS_PA_PAD_SRC].top
1772 		+ sensor->pixel_array->crop[CCS_PA_PAD_SRC].height - 1);
1773 	if (rval < 0)
1774 		goto out;
1775 
1776 	/*
1777 	 * Output from pixel array, including blanking, is set using
1778 	 * controls below. No need to set here.
1779 	 */
1780 
1781 	/* Digital crop */
1782 	if (CCS_LIM(sensor, DIGITAL_CROP_CAPABILITY)
1783 	    == CCS_DIGITAL_CROP_CAPABILITY_INPUT_CROP) {
1784 		rval = ccs_write(
1785 			sensor, DIGITAL_CROP_X_OFFSET,
1786 			sensor->scaler->crop[CCS_PAD_SINK].left);
1787 		if (rval < 0)
1788 			goto out;
1789 
1790 		rval = ccs_write(
1791 			sensor, DIGITAL_CROP_Y_OFFSET,
1792 			sensor->scaler->crop[CCS_PAD_SINK].top);
1793 		if (rval < 0)
1794 			goto out;
1795 
1796 		rval = ccs_write(
1797 			sensor, DIGITAL_CROP_IMAGE_WIDTH,
1798 			sensor->scaler->crop[CCS_PAD_SINK].width);
1799 		if (rval < 0)
1800 			goto out;
1801 
1802 		rval = ccs_write(
1803 			sensor, DIGITAL_CROP_IMAGE_HEIGHT,
1804 			sensor->scaler->crop[CCS_PAD_SINK].height);
1805 		if (rval < 0)
1806 			goto out;
1807 	}
1808 
1809 	/* Scaling */
1810 	if (CCS_LIM(sensor, SCALING_CAPABILITY)
1811 	    != CCS_SCALING_CAPABILITY_NONE) {
1812 		rval = ccs_write(sensor, SCALING_MODE, sensor->scaling_mode);
1813 		if (rval < 0)
1814 			goto out;
1815 
1816 		rval = ccs_write(sensor, SCALE_M, sensor->scale_m);
1817 		if (rval < 0)
1818 			goto out;
1819 	}
1820 
1821 	/* Output size from sensor */
1822 	rval = ccs_write(sensor, X_OUTPUT_SIZE,
1823 			 sensor->src->crop[CCS_PAD_SRC].width);
1824 	if (rval < 0)
1825 		goto out;
1826 	rval = ccs_write(sensor, Y_OUTPUT_SIZE,
1827 			 sensor->src->crop[CCS_PAD_SRC].height);
1828 	if (rval < 0)
1829 		goto out;
1830 
1831 	if (CCS_LIM(sensor, FLASH_MODE_CAPABILITY) &
1832 	    (CCS_FLASH_MODE_CAPABILITY_SINGLE_STROBE |
1833 	     SMIAPP_FLASH_MODE_CAPABILITY_MULTIPLE_STROBE) &&
1834 	    sensor->hwcfg.strobe_setup != NULL &&
1835 	    sensor->hwcfg.strobe_setup->trigger != 0) {
1836 		rval = ccs_setup_flash_strobe(sensor);
1837 		if (rval)
1838 			goto out;
1839 	}
1840 
1841 	rval = ccs_call_quirk(sensor, pre_streamon);
1842 	if (rval) {
1843 		dev_err(&client->dev, "pre_streamon quirks failed\n");
1844 		goto out;
1845 	}
1846 
1847 	rval = ccs_write(sensor, MODE_SELECT, CCS_MODE_SELECT_STREAMING);
1848 
1849 out:
1850 	mutex_unlock(&sensor->mutex);
1851 
1852 	return rval;
1853 }
1854 
1855 static int ccs_stop_streaming(struct ccs_sensor *sensor)
1856 {
1857 	struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
1858 	int rval;
1859 
1860 	mutex_lock(&sensor->mutex);
1861 	rval = ccs_write(sensor, MODE_SELECT, CCS_MODE_SELECT_SOFTWARE_STANDBY);
1862 	if (rval)
1863 		goto out;
1864 
1865 	rval = ccs_call_quirk(sensor, post_streamoff);
1866 	if (rval)
1867 		dev_err(&client->dev, "post_streamoff quirks failed\n");
1868 
1869 out:
1870 	mutex_unlock(&sensor->mutex);
1871 	return rval;
1872 }
1873 
1874 /* -----------------------------------------------------------------------------
1875  * V4L2 subdev video operations
1876  */
1877 
1878 static int ccs_pm_get_init(struct ccs_sensor *sensor)
1879 {
1880 	struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
1881 	int rval;
1882 
1883 	/*
1884 	 * It can't use pm_runtime_resume_and_get() here, as the driver
1885 	 * relies at the returned value to detect if the device was already
1886 	 * active or not.
1887 	 */
1888 	rval = pm_runtime_get_sync(&client->dev);
1889 	if (rval < 0)
1890 		goto error;
1891 
1892 	/* Device was already active, so don't set controls */
1893 	if (rval == 1)
1894 		return 0;
1895 
1896 	/* Restore V4L2 controls to the previously suspended device */
1897 	rval = v4l2_ctrl_handler_setup(&sensor->pixel_array->ctrl_handler);
1898 	if (rval)
1899 		goto error;
1900 
1901 	rval = v4l2_ctrl_handler_setup(&sensor->src->ctrl_handler);
1902 	if (rval)
1903 		goto error;
1904 
1905 	/* Keep PM runtime usage_count incremented on success */
1906 	return 0;
1907 error:
1908 	pm_runtime_put(&client->dev);
1909 	return rval;
1910 }
1911 
1912 static int ccs_set_stream(struct v4l2_subdev *subdev, int enable)
1913 {
1914 	struct ccs_sensor *sensor = to_ccs_sensor(subdev);
1915 	struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
1916 	int rval;
1917 
1918 	if (sensor->streaming == enable)
1919 		return 0;
1920 
1921 	if (!enable) {
1922 		ccs_stop_streaming(sensor);
1923 		sensor->streaming = false;
1924 		pm_runtime_mark_last_busy(&client->dev);
1925 		pm_runtime_put_autosuspend(&client->dev);
1926 
1927 		return 0;
1928 	}
1929 
1930 	rval = ccs_pm_get_init(sensor);
1931 	if (rval)
1932 		return rval;
1933 
1934 	sensor->streaming = true;
1935 
1936 	rval = ccs_start_streaming(sensor);
1937 	if (rval < 0) {
1938 		sensor->streaming = false;
1939 		pm_runtime_mark_last_busy(&client->dev);
1940 		pm_runtime_put_autosuspend(&client->dev);
1941 	}
1942 
1943 	return rval;
1944 }
1945 
1946 static int ccs_enum_mbus_code(struct v4l2_subdev *subdev,
1947 			      struct v4l2_subdev_state *sd_state,
1948 			      struct v4l2_subdev_mbus_code_enum *code)
1949 {
1950 	struct i2c_client *client = v4l2_get_subdevdata(subdev);
1951 	struct ccs_sensor *sensor = to_ccs_sensor(subdev);
1952 	unsigned int i;
1953 	int idx = -1;
1954 	int rval = -EINVAL;
1955 
1956 	mutex_lock(&sensor->mutex);
1957 
1958 	dev_err(&client->dev, "subdev %s, pad %d, index %d\n",
1959 		subdev->name, code->pad, code->index);
1960 
1961 	if (subdev != &sensor->src->sd || code->pad != CCS_PAD_SRC) {
1962 		if (code->index)
1963 			goto out;
1964 
1965 		code->code = sensor->internal_csi_format->code;
1966 		rval = 0;
1967 		goto out;
1968 	}
1969 
1970 	for (i = 0; i < ARRAY_SIZE(ccs_csi_data_formats); i++) {
1971 		if (sensor->mbus_frame_fmts & (1 << i))
1972 			idx++;
1973 
1974 		if (idx == code->index) {
1975 			code->code = ccs_csi_data_formats[i].code;
1976 			dev_err(&client->dev, "found index %d, i %d, code %x\n",
1977 				code->index, i, code->code);
1978 			rval = 0;
1979 			break;
1980 		}
1981 	}
1982 
1983 out:
1984 	mutex_unlock(&sensor->mutex);
1985 
1986 	return rval;
1987 }
1988 
1989 static u32 __ccs_get_mbus_code(struct v4l2_subdev *subdev, unsigned int pad)
1990 {
1991 	struct ccs_sensor *sensor = to_ccs_sensor(subdev);
1992 
1993 	if (subdev == &sensor->src->sd && pad == CCS_PAD_SRC)
1994 		return sensor->csi_format->code;
1995 	else
1996 		return sensor->internal_csi_format->code;
1997 }
1998 
1999 static int __ccs_get_format(struct v4l2_subdev *subdev,
2000 			    struct v4l2_subdev_state *sd_state,
2001 			    struct v4l2_subdev_format *fmt)
2002 {
2003 	struct ccs_subdev *ssd = to_ccs_subdev(subdev);
2004 
2005 	if (fmt->which == V4L2_SUBDEV_FORMAT_TRY) {
2006 		fmt->format = *v4l2_subdev_get_try_format(subdev, sd_state,
2007 							  fmt->pad);
2008 	} else {
2009 		struct v4l2_rect *r;
2010 
2011 		if (fmt->pad == ssd->source_pad)
2012 			r = &ssd->crop[ssd->source_pad];
2013 		else
2014 			r = &ssd->sink_fmt;
2015 
2016 		fmt->format.code = __ccs_get_mbus_code(subdev, fmt->pad);
2017 		fmt->format.width = r->width;
2018 		fmt->format.height = r->height;
2019 		fmt->format.field = V4L2_FIELD_NONE;
2020 	}
2021 
2022 	return 0;
2023 }
2024 
2025 static int ccs_get_format(struct v4l2_subdev *subdev,
2026 			  struct v4l2_subdev_state *sd_state,
2027 			  struct v4l2_subdev_format *fmt)
2028 {
2029 	struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2030 	int rval;
2031 
2032 	mutex_lock(&sensor->mutex);
2033 	rval = __ccs_get_format(subdev, sd_state, fmt);
2034 	mutex_unlock(&sensor->mutex);
2035 
2036 	return rval;
2037 }
2038 
2039 static void ccs_get_crop_compose(struct v4l2_subdev *subdev,
2040 				 struct v4l2_subdev_state *sd_state,
2041 				 struct v4l2_rect **crops,
2042 				 struct v4l2_rect **comps, int which)
2043 {
2044 	struct ccs_subdev *ssd = to_ccs_subdev(subdev);
2045 	unsigned int i;
2046 
2047 	if (which == V4L2_SUBDEV_FORMAT_ACTIVE) {
2048 		if (crops)
2049 			for (i = 0; i < subdev->entity.num_pads; i++)
2050 				crops[i] = &ssd->crop[i];
2051 		if (comps)
2052 			*comps = &ssd->compose;
2053 	} else {
2054 		if (crops) {
2055 			for (i = 0; i < subdev->entity.num_pads; i++)
2056 				crops[i] = v4l2_subdev_get_try_crop(subdev,
2057 								    sd_state,
2058 								    i);
2059 		}
2060 		if (comps)
2061 			*comps = v4l2_subdev_get_try_compose(subdev, sd_state,
2062 							     CCS_PAD_SINK);
2063 	}
2064 }
2065 
2066 /* Changes require propagation only on sink pad. */
2067 static void ccs_propagate(struct v4l2_subdev *subdev,
2068 			  struct v4l2_subdev_state *sd_state, int which,
2069 			  int target)
2070 {
2071 	struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2072 	struct ccs_subdev *ssd = to_ccs_subdev(subdev);
2073 	struct v4l2_rect *comp, *crops[CCS_PADS];
2074 
2075 	ccs_get_crop_compose(subdev, sd_state, crops, &comp, which);
2076 
2077 	switch (target) {
2078 	case V4L2_SEL_TGT_CROP:
2079 		comp->width = crops[CCS_PAD_SINK]->width;
2080 		comp->height = crops[CCS_PAD_SINK]->height;
2081 		if (which == V4L2_SUBDEV_FORMAT_ACTIVE) {
2082 			if (ssd == sensor->scaler) {
2083 				sensor->scale_m = CCS_LIM(sensor, SCALER_N_MIN);
2084 				sensor->scaling_mode =
2085 					CCS_SCALING_MODE_NO_SCALING;
2086 			} else if (ssd == sensor->binner) {
2087 				sensor->binning_horizontal = 1;
2088 				sensor->binning_vertical = 1;
2089 			}
2090 		}
2091 		fallthrough;
2092 	case V4L2_SEL_TGT_COMPOSE:
2093 		*crops[CCS_PAD_SRC] = *comp;
2094 		break;
2095 	default:
2096 		WARN_ON_ONCE(1);
2097 	}
2098 }
2099 
2100 static const struct ccs_csi_data_format
2101 *ccs_validate_csi_data_format(struct ccs_sensor *sensor, u32 code)
2102 {
2103 	unsigned int i;
2104 
2105 	for (i = 0; i < ARRAY_SIZE(ccs_csi_data_formats); i++) {
2106 		if (sensor->mbus_frame_fmts & (1 << i) &&
2107 		    ccs_csi_data_formats[i].code == code)
2108 			return &ccs_csi_data_formats[i];
2109 	}
2110 
2111 	return sensor->csi_format;
2112 }
2113 
2114 static int ccs_set_format_source(struct v4l2_subdev *subdev,
2115 				 struct v4l2_subdev_state *sd_state,
2116 				 struct v4l2_subdev_format *fmt)
2117 {
2118 	struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2119 	const struct ccs_csi_data_format *csi_format,
2120 		*old_csi_format = sensor->csi_format;
2121 	unsigned long *valid_link_freqs;
2122 	u32 code = fmt->format.code;
2123 	unsigned int i;
2124 	int rval;
2125 
2126 	rval = __ccs_get_format(subdev, sd_state, fmt);
2127 	if (rval)
2128 		return rval;
2129 
2130 	/*
2131 	 * Media bus code is changeable on src subdev's source pad. On
2132 	 * other source pads we just get format here.
2133 	 */
2134 	if (subdev != &sensor->src->sd)
2135 		return 0;
2136 
2137 	csi_format = ccs_validate_csi_data_format(sensor, code);
2138 
2139 	fmt->format.code = csi_format->code;
2140 
2141 	if (fmt->which != V4L2_SUBDEV_FORMAT_ACTIVE)
2142 		return 0;
2143 
2144 	sensor->csi_format = csi_format;
2145 
2146 	if (csi_format->width != old_csi_format->width)
2147 		for (i = 0; i < ARRAY_SIZE(sensor->test_data); i++)
2148 			__v4l2_ctrl_modify_range(
2149 				sensor->test_data[i], 0,
2150 				(1 << csi_format->width) - 1, 1, 0);
2151 
2152 	if (csi_format->compressed == old_csi_format->compressed)
2153 		return 0;
2154 
2155 	valid_link_freqs =
2156 		&sensor->valid_link_freqs[sensor->csi_format->compressed
2157 					  - sensor->compressed_min_bpp];
2158 
2159 	__v4l2_ctrl_modify_range(
2160 		sensor->link_freq, 0,
2161 		__fls(*valid_link_freqs), ~*valid_link_freqs,
2162 		__ffs(*valid_link_freqs));
2163 
2164 	return ccs_pll_update(sensor);
2165 }
2166 
2167 static int ccs_set_format(struct v4l2_subdev *subdev,
2168 			  struct v4l2_subdev_state *sd_state,
2169 			  struct v4l2_subdev_format *fmt)
2170 {
2171 	struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2172 	struct ccs_subdev *ssd = to_ccs_subdev(subdev);
2173 	struct v4l2_rect *crops[CCS_PADS];
2174 
2175 	mutex_lock(&sensor->mutex);
2176 
2177 	if (fmt->pad == ssd->source_pad) {
2178 		int rval;
2179 
2180 		rval = ccs_set_format_source(subdev, sd_state, fmt);
2181 
2182 		mutex_unlock(&sensor->mutex);
2183 
2184 		return rval;
2185 	}
2186 
2187 	/* Sink pad. Width and height are changeable here. */
2188 	fmt->format.code = __ccs_get_mbus_code(subdev, fmt->pad);
2189 	fmt->format.width &= ~1;
2190 	fmt->format.height &= ~1;
2191 	fmt->format.field = V4L2_FIELD_NONE;
2192 
2193 	fmt->format.width =
2194 		clamp(fmt->format.width,
2195 		      CCS_LIM(sensor, MIN_X_OUTPUT_SIZE),
2196 		      CCS_LIM(sensor, MAX_X_OUTPUT_SIZE));
2197 	fmt->format.height =
2198 		clamp(fmt->format.height,
2199 		      CCS_LIM(sensor, MIN_Y_OUTPUT_SIZE),
2200 		      CCS_LIM(sensor, MAX_Y_OUTPUT_SIZE));
2201 
2202 	ccs_get_crop_compose(subdev, sd_state, crops, NULL, fmt->which);
2203 
2204 	crops[ssd->sink_pad]->left = 0;
2205 	crops[ssd->sink_pad]->top = 0;
2206 	crops[ssd->sink_pad]->width = fmt->format.width;
2207 	crops[ssd->sink_pad]->height = fmt->format.height;
2208 	if (fmt->which == V4L2_SUBDEV_FORMAT_ACTIVE)
2209 		ssd->sink_fmt = *crops[ssd->sink_pad];
2210 	ccs_propagate(subdev, sd_state, fmt->which, V4L2_SEL_TGT_CROP);
2211 
2212 	mutex_unlock(&sensor->mutex);
2213 
2214 	return 0;
2215 }
2216 
2217 /*
2218  * Calculate goodness of scaled image size compared to expected image
2219  * size and flags provided.
2220  */
2221 #define SCALING_GOODNESS		100000
2222 #define SCALING_GOODNESS_EXTREME	100000000
2223 static int scaling_goodness(struct v4l2_subdev *subdev, int w, int ask_w,
2224 			    int h, int ask_h, u32 flags)
2225 {
2226 	struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2227 	struct i2c_client *client = v4l2_get_subdevdata(subdev);
2228 	int val = 0;
2229 
2230 	w &= ~1;
2231 	ask_w &= ~1;
2232 	h &= ~1;
2233 	ask_h &= ~1;
2234 
2235 	if (flags & V4L2_SEL_FLAG_GE) {
2236 		if (w < ask_w)
2237 			val -= SCALING_GOODNESS;
2238 		if (h < ask_h)
2239 			val -= SCALING_GOODNESS;
2240 	}
2241 
2242 	if (flags & V4L2_SEL_FLAG_LE) {
2243 		if (w > ask_w)
2244 			val -= SCALING_GOODNESS;
2245 		if (h > ask_h)
2246 			val -= SCALING_GOODNESS;
2247 	}
2248 
2249 	val -= abs(w - ask_w);
2250 	val -= abs(h - ask_h);
2251 
2252 	if (w < CCS_LIM(sensor, MIN_X_OUTPUT_SIZE))
2253 		val -= SCALING_GOODNESS_EXTREME;
2254 
2255 	dev_dbg(&client->dev, "w %d ask_w %d h %d ask_h %d goodness %d\n",
2256 		w, ask_w, h, ask_h, val);
2257 
2258 	return val;
2259 }
2260 
2261 static void ccs_set_compose_binner(struct v4l2_subdev *subdev,
2262 				   struct v4l2_subdev_state *sd_state,
2263 				   struct v4l2_subdev_selection *sel,
2264 				   struct v4l2_rect **crops,
2265 				   struct v4l2_rect *comp)
2266 {
2267 	struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2268 	unsigned int i;
2269 	unsigned int binh = 1, binv = 1;
2270 	int best = scaling_goodness(
2271 		subdev,
2272 		crops[CCS_PAD_SINK]->width, sel->r.width,
2273 		crops[CCS_PAD_SINK]->height, sel->r.height, sel->flags);
2274 
2275 	for (i = 0; i < sensor->nbinning_subtypes; i++) {
2276 		int this = scaling_goodness(
2277 			subdev,
2278 			crops[CCS_PAD_SINK]->width
2279 			/ sensor->binning_subtypes[i].horizontal,
2280 			sel->r.width,
2281 			crops[CCS_PAD_SINK]->height
2282 			/ sensor->binning_subtypes[i].vertical,
2283 			sel->r.height, sel->flags);
2284 
2285 		if (this > best) {
2286 			binh = sensor->binning_subtypes[i].horizontal;
2287 			binv = sensor->binning_subtypes[i].vertical;
2288 			best = this;
2289 		}
2290 	}
2291 	if (sel->which == V4L2_SUBDEV_FORMAT_ACTIVE) {
2292 		sensor->binning_vertical = binv;
2293 		sensor->binning_horizontal = binh;
2294 	}
2295 
2296 	sel->r.width = (crops[CCS_PAD_SINK]->width / binh) & ~1;
2297 	sel->r.height = (crops[CCS_PAD_SINK]->height / binv) & ~1;
2298 }
2299 
2300 /*
2301  * Calculate best scaling ratio and mode for given output resolution.
2302  *
2303  * Try all of these: horizontal ratio, vertical ratio and smallest
2304  * size possible (horizontally).
2305  *
2306  * Also try whether horizontal scaler or full scaler gives a better
2307  * result.
2308  */
2309 static void ccs_set_compose_scaler(struct v4l2_subdev *subdev,
2310 				   struct v4l2_subdev_state *sd_state,
2311 				   struct v4l2_subdev_selection *sel,
2312 				   struct v4l2_rect **crops,
2313 				   struct v4l2_rect *comp)
2314 {
2315 	struct i2c_client *client = v4l2_get_subdevdata(subdev);
2316 	struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2317 	u32 min, max, a, b, max_m;
2318 	u32 scale_m = CCS_LIM(sensor, SCALER_N_MIN);
2319 	int mode = CCS_SCALING_MODE_HORIZONTAL;
2320 	u32 try[4];
2321 	u32 ntry = 0;
2322 	unsigned int i;
2323 	int best = INT_MIN;
2324 
2325 	sel->r.width = min_t(unsigned int, sel->r.width,
2326 			     crops[CCS_PAD_SINK]->width);
2327 	sel->r.height = min_t(unsigned int, sel->r.height,
2328 			      crops[CCS_PAD_SINK]->height);
2329 
2330 	a = crops[CCS_PAD_SINK]->width
2331 		* CCS_LIM(sensor, SCALER_N_MIN) / sel->r.width;
2332 	b = crops[CCS_PAD_SINK]->height
2333 		* CCS_LIM(sensor, SCALER_N_MIN) / sel->r.height;
2334 	max_m = crops[CCS_PAD_SINK]->width
2335 		* CCS_LIM(sensor, SCALER_N_MIN)
2336 		/ CCS_LIM(sensor, MIN_X_OUTPUT_SIZE);
2337 
2338 	a = clamp(a, CCS_LIM(sensor, SCALER_M_MIN),
2339 		  CCS_LIM(sensor, SCALER_M_MAX));
2340 	b = clamp(b, CCS_LIM(sensor, SCALER_M_MIN),
2341 		  CCS_LIM(sensor, SCALER_M_MAX));
2342 	max_m = clamp(max_m, CCS_LIM(sensor, SCALER_M_MIN),
2343 		      CCS_LIM(sensor, SCALER_M_MAX));
2344 
2345 	dev_dbg(&client->dev, "scaling: a %d b %d max_m %d\n", a, b, max_m);
2346 
2347 	min = min(max_m, min(a, b));
2348 	max = min(max_m, max(a, b));
2349 
2350 	try[ntry] = min;
2351 	ntry++;
2352 	if (min != max) {
2353 		try[ntry] = max;
2354 		ntry++;
2355 	}
2356 	if (max != max_m) {
2357 		try[ntry] = min + 1;
2358 		ntry++;
2359 		if (min != max) {
2360 			try[ntry] = max + 1;
2361 			ntry++;
2362 		}
2363 	}
2364 
2365 	for (i = 0; i < ntry; i++) {
2366 		int this = scaling_goodness(
2367 			subdev,
2368 			crops[CCS_PAD_SINK]->width
2369 			/ try[i] * CCS_LIM(sensor, SCALER_N_MIN),
2370 			sel->r.width,
2371 			crops[CCS_PAD_SINK]->height,
2372 			sel->r.height,
2373 			sel->flags);
2374 
2375 		dev_dbg(&client->dev, "trying factor %d (%d)\n", try[i], i);
2376 
2377 		if (this > best) {
2378 			scale_m = try[i];
2379 			mode = CCS_SCALING_MODE_HORIZONTAL;
2380 			best = this;
2381 		}
2382 
2383 		if (CCS_LIM(sensor, SCALING_CAPABILITY)
2384 		    == CCS_SCALING_CAPABILITY_HORIZONTAL)
2385 			continue;
2386 
2387 		this = scaling_goodness(
2388 			subdev, crops[CCS_PAD_SINK]->width
2389 			/ try[i]
2390 			* CCS_LIM(sensor, SCALER_N_MIN),
2391 			sel->r.width,
2392 			crops[CCS_PAD_SINK]->height
2393 			/ try[i]
2394 			* CCS_LIM(sensor, SCALER_N_MIN),
2395 			sel->r.height,
2396 			sel->flags);
2397 
2398 		if (this > best) {
2399 			scale_m = try[i];
2400 			mode = SMIAPP_SCALING_MODE_BOTH;
2401 			best = this;
2402 		}
2403 	}
2404 
2405 	sel->r.width =
2406 		(crops[CCS_PAD_SINK]->width
2407 		 / scale_m
2408 		 * CCS_LIM(sensor, SCALER_N_MIN)) & ~1;
2409 	if (mode == SMIAPP_SCALING_MODE_BOTH)
2410 		sel->r.height =
2411 			(crops[CCS_PAD_SINK]->height
2412 			 / scale_m
2413 			 * CCS_LIM(sensor, SCALER_N_MIN))
2414 			& ~1;
2415 	else
2416 		sel->r.height = crops[CCS_PAD_SINK]->height;
2417 
2418 	if (sel->which == V4L2_SUBDEV_FORMAT_ACTIVE) {
2419 		sensor->scale_m = scale_m;
2420 		sensor->scaling_mode = mode;
2421 	}
2422 }
2423 /* We're only called on source pads. This function sets scaling. */
2424 static int ccs_set_compose(struct v4l2_subdev *subdev,
2425 			   struct v4l2_subdev_state *sd_state,
2426 			   struct v4l2_subdev_selection *sel)
2427 {
2428 	struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2429 	struct ccs_subdev *ssd = to_ccs_subdev(subdev);
2430 	struct v4l2_rect *comp, *crops[CCS_PADS];
2431 
2432 	ccs_get_crop_compose(subdev, sd_state, crops, &comp, sel->which);
2433 
2434 	sel->r.top = 0;
2435 	sel->r.left = 0;
2436 
2437 	if (ssd == sensor->binner)
2438 		ccs_set_compose_binner(subdev, sd_state, sel, crops, comp);
2439 	else
2440 		ccs_set_compose_scaler(subdev, sd_state, sel, crops, comp);
2441 
2442 	*comp = sel->r;
2443 	ccs_propagate(subdev, sd_state, sel->which, V4L2_SEL_TGT_COMPOSE);
2444 
2445 	if (sel->which == V4L2_SUBDEV_FORMAT_ACTIVE)
2446 		return ccs_pll_blanking_update(sensor);
2447 
2448 	return 0;
2449 }
2450 
2451 static int __ccs_sel_supported(struct v4l2_subdev *subdev,
2452 			       struct v4l2_subdev_selection *sel)
2453 {
2454 	struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2455 	struct ccs_subdev *ssd = to_ccs_subdev(subdev);
2456 
2457 	/* We only implement crop in three places. */
2458 	switch (sel->target) {
2459 	case V4L2_SEL_TGT_CROP:
2460 	case V4L2_SEL_TGT_CROP_BOUNDS:
2461 		if (ssd == sensor->pixel_array && sel->pad == CCS_PA_PAD_SRC)
2462 			return 0;
2463 		if (ssd == sensor->src && sel->pad == CCS_PAD_SRC)
2464 			return 0;
2465 		if (ssd == sensor->scaler && sel->pad == CCS_PAD_SINK &&
2466 		    CCS_LIM(sensor, DIGITAL_CROP_CAPABILITY)
2467 		    == CCS_DIGITAL_CROP_CAPABILITY_INPUT_CROP)
2468 			return 0;
2469 		return -EINVAL;
2470 	case V4L2_SEL_TGT_NATIVE_SIZE:
2471 		if (ssd == sensor->pixel_array && sel->pad == CCS_PA_PAD_SRC)
2472 			return 0;
2473 		return -EINVAL;
2474 	case V4L2_SEL_TGT_COMPOSE:
2475 	case V4L2_SEL_TGT_COMPOSE_BOUNDS:
2476 		if (sel->pad == ssd->source_pad)
2477 			return -EINVAL;
2478 		if (ssd == sensor->binner)
2479 			return 0;
2480 		if (ssd == sensor->scaler && CCS_LIM(sensor, SCALING_CAPABILITY)
2481 		    != CCS_SCALING_CAPABILITY_NONE)
2482 			return 0;
2483 		fallthrough;
2484 	default:
2485 		return -EINVAL;
2486 	}
2487 }
2488 
2489 static int ccs_set_crop(struct v4l2_subdev *subdev,
2490 			struct v4l2_subdev_state *sd_state,
2491 			struct v4l2_subdev_selection *sel)
2492 {
2493 	struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2494 	struct ccs_subdev *ssd = to_ccs_subdev(subdev);
2495 	struct v4l2_rect *src_size, *crops[CCS_PADS];
2496 	struct v4l2_rect _r;
2497 
2498 	ccs_get_crop_compose(subdev, sd_state, crops, NULL, sel->which);
2499 
2500 	if (sel->which == V4L2_SUBDEV_FORMAT_ACTIVE) {
2501 		if (sel->pad == ssd->sink_pad)
2502 			src_size = &ssd->sink_fmt;
2503 		else
2504 			src_size = &ssd->compose;
2505 	} else {
2506 		if (sel->pad == ssd->sink_pad) {
2507 			_r.left = 0;
2508 			_r.top = 0;
2509 			_r.width = v4l2_subdev_get_try_format(subdev,
2510 							      sd_state,
2511 							      sel->pad)
2512 				->width;
2513 			_r.height = v4l2_subdev_get_try_format(subdev,
2514 							       sd_state,
2515 							       sel->pad)
2516 				->height;
2517 			src_size = &_r;
2518 		} else {
2519 			src_size = v4l2_subdev_get_try_compose(
2520 				subdev, sd_state, ssd->sink_pad);
2521 		}
2522 	}
2523 
2524 	if (ssd == sensor->src && sel->pad == CCS_PAD_SRC) {
2525 		sel->r.left = 0;
2526 		sel->r.top = 0;
2527 	}
2528 
2529 	sel->r.width = min(sel->r.width, src_size->width);
2530 	sel->r.height = min(sel->r.height, src_size->height);
2531 
2532 	sel->r.left = min_t(int, sel->r.left, src_size->width - sel->r.width);
2533 	sel->r.top = min_t(int, sel->r.top, src_size->height - sel->r.height);
2534 
2535 	*crops[sel->pad] = sel->r;
2536 
2537 	if (ssd != sensor->pixel_array && sel->pad == CCS_PAD_SINK)
2538 		ccs_propagate(subdev, sd_state, sel->which, V4L2_SEL_TGT_CROP);
2539 
2540 	return 0;
2541 }
2542 
2543 static void ccs_get_native_size(struct ccs_subdev *ssd, struct v4l2_rect *r)
2544 {
2545 	r->top = 0;
2546 	r->left = 0;
2547 	r->width = CCS_LIM(ssd->sensor, X_ADDR_MAX) + 1;
2548 	r->height = CCS_LIM(ssd->sensor, Y_ADDR_MAX) + 1;
2549 }
2550 
2551 static int __ccs_get_selection(struct v4l2_subdev *subdev,
2552 			       struct v4l2_subdev_state *sd_state,
2553 			       struct v4l2_subdev_selection *sel)
2554 {
2555 	struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2556 	struct ccs_subdev *ssd = to_ccs_subdev(subdev);
2557 	struct v4l2_rect *comp, *crops[CCS_PADS];
2558 	struct v4l2_rect sink_fmt;
2559 	int ret;
2560 
2561 	ret = __ccs_sel_supported(subdev, sel);
2562 	if (ret)
2563 		return ret;
2564 
2565 	ccs_get_crop_compose(subdev, sd_state, crops, &comp, sel->which);
2566 
2567 	if (sel->which == V4L2_SUBDEV_FORMAT_ACTIVE) {
2568 		sink_fmt = ssd->sink_fmt;
2569 	} else {
2570 		struct v4l2_mbus_framefmt *fmt =
2571 			v4l2_subdev_get_try_format(subdev, sd_state,
2572 						   ssd->sink_pad);
2573 
2574 		sink_fmt.left = 0;
2575 		sink_fmt.top = 0;
2576 		sink_fmt.width = fmt->width;
2577 		sink_fmt.height = fmt->height;
2578 	}
2579 
2580 	switch (sel->target) {
2581 	case V4L2_SEL_TGT_CROP_BOUNDS:
2582 	case V4L2_SEL_TGT_NATIVE_SIZE:
2583 		if (ssd == sensor->pixel_array)
2584 			ccs_get_native_size(ssd, &sel->r);
2585 		else if (sel->pad == ssd->sink_pad)
2586 			sel->r = sink_fmt;
2587 		else
2588 			sel->r = *comp;
2589 		break;
2590 	case V4L2_SEL_TGT_CROP:
2591 	case V4L2_SEL_TGT_COMPOSE_BOUNDS:
2592 		sel->r = *crops[sel->pad];
2593 		break;
2594 	case V4L2_SEL_TGT_COMPOSE:
2595 		sel->r = *comp;
2596 		break;
2597 	}
2598 
2599 	return 0;
2600 }
2601 
2602 static int ccs_get_selection(struct v4l2_subdev *subdev,
2603 			     struct v4l2_subdev_state *sd_state,
2604 			     struct v4l2_subdev_selection *sel)
2605 {
2606 	struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2607 	int rval;
2608 
2609 	mutex_lock(&sensor->mutex);
2610 	rval = __ccs_get_selection(subdev, sd_state, sel);
2611 	mutex_unlock(&sensor->mutex);
2612 
2613 	return rval;
2614 }
2615 
2616 static int ccs_set_selection(struct v4l2_subdev *subdev,
2617 			     struct v4l2_subdev_state *sd_state,
2618 			     struct v4l2_subdev_selection *sel)
2619 {
2620 	struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2621 	int ret;
2622 
2623 	ret = __ccs_sel_supported(subdev, sel);
2624 	if (ret)
2625 		return ret;
2626 
2627 	mutex_lock(&sensor->mutex);
2628 
2629 	sel->r.left = max(0, sel->r.left & ~1);
2630 	sel->r.top = max(0, sel->r.top & ~1);
2631 	sel->r.width = CCS_ALIGN_DIM(sel->r.width, sel->flags);
2632 	sel->r.height =	CCS_ALIGN_DIM(sel->r.height, sel->flags);
2633 
2634 	sel->r.width = max_t(unsigned int, CCS_LIM(sensor, MIN_X_OUTPUT_SIZE),
2635 			     sel->r.width);
2636 	sel->r.height = max_t(unsigned int, CCS_LIM(sensor, MIN_Y_OUTPUT_SIZE),
2637 			      sel->r.height);
2638 
2639 	switch (sel->target) {
2640 	case V4L2_SEL_TGT_CROP:
2641 		ret = ccs_set_crop(subdev, sd_state, sel);
2642 		break;
2643 	case V4L2_SEL_TGT_COMPOSE:
2644 		ret = ccs_set_compose(subdev, sd_state, sel);
2645 		break;
2646 	default:
2647 		ret = -EINVAL;
2648 	}
2649 
2650 	mutex_unlock(&sensor->mutex);
2651 	return ret;
2652 }
2653 
2654 static int ccs_get_skip_frames(struct v4l2_subdev *subdev, u32 *frames)
2655 {
2656 	struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2657 
2658 	*frames = sensor->frame_skip;
2659 	return 0;
2660 }
2661 
2662 static int ccs_get_skip_top_lines(struct v4l2_subdev *subdev, u32 *lines)
2663 {
2664 	struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2665 
2666 	*lines = sensor->image_start;
2667 
2668 	return 0;
2669 }
2670 
2671 /* -----------------------------------------------------------------------------
2672  * sysfs attributes
2673  */
2674 
2675 static ssize_t
2676 ccs_sysfs_nvm_read(struct device *dev, struct device_attribute *attr,
2677 		   char *buf)
2678 {
2679 	struct v4l2_subdev *subdev = i2c_get_clientdata(to_i2c_client(dev));
2680 	struct i2c_client *client = v4l2_get_subdevdata(subdev);
2681 	struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2682 	int rval;
2683 
2684 	if (!sensor->dev_init_done)
2685 		return -EBUSY;
2686 
2687 	rval = ccs_pm_get_init(sensor);
2688 	if (rval < 0)
2689 		return -ENODEV;
2690 
2691 	rval = ccs_read_nvm(sensor, buf, PAGE_SIZE);
2692 	if (rval < 0) {
2693 		pm_runtime_put(&client->dev);
2694 		dev_err(&client->dev, "nvm read failed\n");
2695 		return -ENODEV;
2696 	}
2697 
2698 	pm_runtime_mark_last_busy(&client->dev);
2699 	pm_runtime_put_autosuspend(&client->dev);
2700 
2701 	/*
2702 	 * NVM is still way below a PAGE_SIZE, so we can safely
2703 	 * assume this for now.
2704 	 */
2705 	return rval;
2706 }
2707 static DEVICE_ATTR(nvm, S_IRUGO, ccs_sysfs_nvm_read, NULL);
2708 
2709 static ssize_t
2710 ccs_sysfs_ident_read(struct device *dev, struct device_attribute *attr,
2711 		     char *buf)
2712 {
2713 	struct v4l2_subdev *subdev = i2c_get_clientdata(to_i2c_client(dev));
2714 	struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2715 	struct ccs_module_info *minfo = &sensor->minfo;
2716 
2717 	if (minfo->mipi_manufacturer_id)
2718 		return snprintf(buf, PAGE_SIZE, "%4.4x%4.4x%2.2x\n",
2719 				minfo->mipi_manufacturer_id, minfo->model_id,
2720 				minfo->revision_number) + 1;
2721 	else
2722 		return snprintf(buf, PAGE_SIZE, "%2.2x%4.4x%2.2x\n",
2723 				minfo->smia_manufacturer_id, minfo->model_id,
2724 				minfo->revision_number) + 1;
2725 }
2726 
2727 static DEVICE_ATTR(ident, S_IRUGO, ccs_sysfs_ident_read, NULL);
2728 
2729 /* -----------------------------------------------------------------------------
2730  * V4L2 subdev core operations
2731  */
2732 
2733 static int ccs_identify_module(struct ccs_sensor *sensor)
2734 {
2735 	struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
2736 	struct ccs_module_info *minfo = &sensor->minfo;
2737 	unsigned int i;
2738 	u32 rev;
2739 	int rval = 0;
2740 
2741 	/* Module info */
2742 	rval = ccs_read(sensor, MODULE_MANUFACTURER_ID,
2743 			&minfo->mipi_manufacturer_id);
2744 	if (!rval && !minfo->mipi_manufacturer_id)
2745 		rval = ccs_read_addr_8only(sensor,
2746 					   SMIAPP_REG_U8_MANUFACTURER_ID,
2747 					   &minfo->smia_manufacturer_id);
2748 	if (!rval)
2749 		rval = ccs_read_addr_8only(sensor, CCS_R_MODULE_MODEL_ID,
2750 					   &minfo->model_id);
2751 	if (!rval)
2752 		rval = ccs_read_addr_8only(sensor,
2753 					   CCS_R_MODULE_REVISION_NUMBER_MAJOR,
2754 					   &rev);
2755 	if (!rval) {
2756 		rval = ccs_read_addr_8only(sensor,
2757 					   CCS_R_MODULE_REVISION_NUMBER_MINOR,
2758 					   &minfo->revision_number);
2759 		minfo->revision_number |= rev << 8;
2760 	}
2761 	if (!rval)
2762 		rval = ccs_read_addr_8only(sensor, CCS_R_MODULE_DATE_YEAR,
2763 					   &minfo->module_year);
2764 	if (!rval)
2765 		rval = ccs_read_addr_8only(sensor, CCS_R_MODULE_DATE_MONTH,
2766 					   &minfo->module_month);
2767 	if (!rval)
2768 		rval = ccs_read_addr_8only(sensor, CCS_R_MODULE_DATE_DAY,
2769 					   &minfo->module_day);
2770 
2771 	/* Sensor info */
2772 	if (!rval)
2773 		rval = ccs_read(sensor, SENSOR_MANUFACTURER_ID,
2774 				&minfo->sensor_mipi_manufacturer_id);
2775 	if (!rval && !minfo->sensor_mipi_manufacturer_id)
2776 		rval = ccs_read_addr_8only(sensor,
2777 					   CCS_R_SENSOR_MANUFACTURER_ID,
2778 					   &minfo->sensor_smia_manufacturer_id);
2779 	if (!rval)
2780 		rval = ccs_read_addr_8only(sensor,
2781 					   CCS_R_SENSOR_MODEL_ID,
2782 					   &minfo->sensor_model_id);
2783 	if (!rval)
2784 		rval = ccs_read_addr_8only(sensor,
2785 					   CCS_R_SENSOR_REVISION_NUMBER,
2786 					   &minfo->sensor_revision_number);
2787 	if (!rval)
2788 		rval = ccs_read_addr_8only(sensor,
2789 					   CCS_R_SENSOR_FIRMWARE_VERSION,
2790 					   &minfo->sensor_firmware_version);
2791 
2792 	/* SMIA */
2793 	if (!rval)
2794 		rval = ccs_read(sensor, MIPI_CCS_VERSION, &minfo->ccs_version);
2795 	if (!rval && !minfo->ccs_version)
2796 		rval = ccs_read_addr_8only(sensor, SMIAPP_REG_U8_SMIA_VERSION,
2797 					   &minfo->smia_version);
2798 	if (!rval && !minfo->ccs_version)
2799 		rval = ccs_read_addr_8only(sensor, SMIAPP_REG_U8_SMIAPP_VERSION,
2800 					   &minfo->smiapp_version);
2801 
2802 	if (rval) {
2803 		dev_err(&client->dev, "sensor detection failed\n");
2804 		return -ENODEV;
2805 	}
2806 
2807 	if (minfo->mipi_manufacturer_id)
2808 		dev_dbg(&client->dev, "MIPI CCS module 0x%4.4x-0x%4.4x\n",
2809 			minfo->mipi_manufacturer_id, minfo->model_id);
2810 	else
2811 		dev_dbg(&client->dev, "SMIA module 0x%2.2x-0x%4.4x\n",
2812 			minfo->smia_manufacturer_id, minfo->model_id);
2813 
2814 	dev_dbg(&client->dev,
2815 		"module revision 0x%4.4x date %2.2d-%2.2d-%2.2d\n",
2816 		minfo->revision_number, minfo->module_year, minfo->module_month,
2817 		minfo->module_day);
2818 
2819 	if (minfo->sensor_mipi_manufacturer_id)
2820 		dev_dbg(&client->dev, "MIPI CCS sensor 0x%4.4x-0x%4.4x\n",
2821 			minfo->sensor_mipi_manufacturer_id,
2822 			minfo->sensor_model_id);
2823 	else
2824 		dev_dbg(&client->dev, "SMIA sensor 0x%2.2x-0x%4.4x\n",
2825 			minfo->sensor_smia_manufacturer_id,
2826 			minfo->sensor_model_id);
2827 
2828 	dev_dbg(&client->dev,
2829 		"sensor revision 0x%2.2x firmware version 0x%2.2x\n",
2830 		minfo->sensor_revision_number, minfo->sensor_firmware_version);
2831 
2832 	if (minfo->ccs_version) {
2833 		dev_dbg(&client->dev, "MIPI CCS version %u.%u",
2834 			(minfo->ccs_version & CCS_MIPI_CCS_VERSION_MAJOR_MASK)
2835 			>> CCS_MIPI_CCS_VERSION_MAJOR_SHIFT,
2836 			(minfo->ccs_version & CCS_MIPI_CCS_VERSION_MINOR_MASK));
2837 		minfo->name = CCS_NAME;
2838 	} else {
2839 		dev_dbg(&client->dev,
2840 			"smia version %2.2d smiapp version %2.2d\n",
2841 			minfo->smia_version, minfo->smiapp_version);
2842 		minfo->name = SMIAPP_NAME;
2843 	}
2844 
2845 	/*
2846 	 * Some modules have bad data in the lvalues below. Hope the
2847 	 * rvalues have better stuff. The lvalues are module
2848 	 * parameters whereas the rvalues are sensor parameters.
2849 	 */
2850 	if (minfo->sensor_smia_manufacturer_id &&
2851 	    !minfo->smia_manufacturer_id && !minfo->model_id) {
2852 		minfo->smia_manufacturer_id =
2853 			minfo->sensor_smia_manufacturer_id;
2854 		minfo->model_id = minfo->sensor_model_id;
2855 		minfo->revision_number = minfo->sensor_revision_number;
2856 	}
2857 
2858 	for (i = 0; i < ARRAY_SIZE(ccs_module_idents); i++) {
2859 		if (ccs_module_idents[i].mipi_manufacturer_id &&
2860 		    ccs_module_idents[i].mipi_manufacturer_id
2861 		    != minfo->mipi_manufacturer_id)
2862 			continue;
2863 		if (ccs_module_idents[i].smia_manufacturer_id &&
2864 		    ccs_module_idents[i].smia_manufacturer_id
2865 		    != minfo->smia_manufacturer_id)
2866 			continue;
2867 		if (ccs_module_idents[i].model_id != minfo->model_id)
2868 			continue;
2869 		if (ccs_module_idents[i].flags
2870 		    & CCS_MODULE_IDENT_FLAG_REV_LE) {
2871 			if (ccs_module_idents[i].revision_number_major
2872 			    < (minfo->revision_number >> 8))
2873 				continue;
2874 		} else {
2875 			if (ccs_module_idents[i].revision_number_major
2876 			    != (minfo->revision_number >> 8))
2877 				continue;
2878 		}
2879 
2880 		minfo->name = ccs_module_idents[i].name;
2881 		minfo->quirk = ccs_module_idents[i].quirk;
2882 		break;
2883 	}
2884 
2885 	if (i >= ARRAY_SIZE(ccs_module_idents))
2886 		dev_warn(&client->dev,
2887 			 "no quirks for this module; let's hope it's fully compliant\n");
2888 
2889 	dev_dbg(&client->dev, "the sensor is called %s\n", minfo->name);
2890 
2891 	return 0;
2892 }
2893 
2894 static const struct v4l2_subdev_ops ccs_ops;
2895 static const struct v4l2_subdev_internal_ops ccs_internal_ops;
2896 static const struct media_entity_operations ccs_entity_ops;
2897 
2898 static int ccs_register_subdev(struct ccs_sensor *sensor,
2899 			       struct ccs_subdev *ssd,
2900 			       struct ccs_subdev *sink_ssd,
2901 			       u16 source_pad, u16 sink_pad, u32 link_flags)
2902 {
2903 	struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
2904 	int rval;
2905 
2906 	if (!sink_ssd)
2907 		return 0;
2908 
2909 	rval = media_entity_pads_init(&ssd->sd.entity, ssd->npads, ssd->pads);
2910 	if (rval) {
2911 		dev_err(&client->dev, "media_entity_pads_init failed\n");
2912 		return rval;
2913 	}
2914 
2915 	rval = v4l2_device_register_subdev(sensor->src->sd.v4l2_dev, &ssd->sd);
2916 	if (rval) {
2917 		dev_err(&client->dev, "v4l2_device_register_subdev failed\n");
2918 		return rval;
2919 	}
2920 
2921 	rval = media_create_pad_link(&ssd->sd.entity, source_pad,
2922 				     &sink_ssd->sd.entity, sink_pad,
2923 				     link_flags);
2924 	if (rval) {
2925 		dev_err(&client->dev, "media_create_pad_link failed\n");
2926 		v4l2_device_unregister_subdev(&ssd->sd);
2927 		return rval;
2928 	}
2929 
2930 	return 0;
2931 }
2932 
2933 static void ccs_unregistered(struct v4l2_subdev *subdev)
2934 {
2935 	struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2936 	unsigned int i;
2937 
2938 	for (i = 1; i < sensor->ssds_used; i++)
2939 		v4l2_device_unregister_subdev(&sensor->ssds[i].sd);
2940 }
2941 
2942 static int ccs_registered(struct v4l2_subdev *subdev)
2943 {
2944 	struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2945 	int rval;
2946 
2947 	if (sensor->scaler) {
2948 		rval = ccs_register_subdev(sensor, sensor->binner,
2949 					   sensor->scaler,
2950 					   CCS_PAD_SRC, CCS_PAD_SINK,
2951 					   MEDIA_LNK_FL_ENABLED |
2952 					   MEDIA_LNK_FL_IMMUTABLE);
2953 		if (rval < 0)
2954 			return rval;
2955 	}
2956 
2957 	rval = ccs_register_subdev(sensor, sensor->pixel_array, sensor->binner,
2958 				   CCS_PA_PAD_SRC, CCS_PAD_SINK,
2959 				   MEDIA_LNK_FL_ENABLED |
2960 				   MEDIA_LNK_FL_IMMUTABLE);
2961 	if (rval)
2962 		goto out_err;
2963 
2964 	return 0;
2965 
2966 out_err:
2967 	ccs_unregistered(subdev);
2968 
2969 	return rval;
2970 }
2971 
2972 static void ccs_cleanup(struct ccs_sensor *sensor)
2973 {
2974 	struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
2975 
2976 	device_remove_file(&client->dev, &dev_attr_nvm);
2977 	device_remove_file(&client->dev, &dev_attr_ident);
2978 
2979 	ccs_free_controls(sensor);
2980 }
2981 
2982 static void ccs_create_subdev(struct ccs_sensor *sensor,
2983 			      struct ccs_subdev *ssd, const char *name,
2984 			      unsigned short num_pads, u32 function)
2985 {
2986 	struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
2987 
2988 	if (!ssd)
2989 		return;
2990 
2991 	if (ssd != sensor->src)
2992 		v4l2_subdev_init(&ssd->sd, &ccs_ops);
2993 
2994 	ssd->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
2995 	ssd->sd.entity.function = function;
2996 	ssd->sensor = sensor;
2997 
2998 	ssd->npads = num_pads;
2999 	ssd->source_pad = num_pads - 1;
3000 
3001 	v4l2_i2c_subdev_set_name(&ssd->sd, client, sensor->minfo.name, name);
3002 
3003 	ccs_get_native_size(ssd, &ssd->sink_fmt);
3004 
3005 	ssd->compose.width = ssd->sink_fmt.width;
3006 	ssd->compose.height = ssd->sink_fmt.height;
3007 	ssd->crop[ssd->source_pad] = ssd->compose;
3008 	ssd->pads[ssd->source_pad].flags = MEDIA_PAD_FL_SOURCE;
3009 	if (ssd != sensor->pixel_array) {
3010 		ssd->crop[ssd->sink_pad] = ssd->compose;
3011 		ssd->pads[ssd->sink_pad].flags = MEDIA_PAD_FL_SINK;
3012 	}
3013 
3014 	ssd->sd.entity.ops = &ccs_entity_ops;
3015 
3016 	if (ssd == sensor->src)
3017 		return;
3018 
3019 	ssd->sd.internal_ops = &ccs_internal_ops;
3020 	ssd->sd.owner = THIS_MODULE;
3021 	ssd->sd.dev = &client->dev;
3022 	v4l2_set_subdevdata(&ssd->sd, client);
3023 }
3024 
3025 static int ccs_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
3026 {
3027 	struct ccs_subdev *ssd = to_ccs_subdev(sd);
3028 	struct ccs_sensor *sensor = ssd->sensor;
3029 	unsigned int i;
3030 
3031 	mutex_lock(&sensor->mutex);
3032 
3033 	for (i = 0; i < ssd->npads; i++) {
3034 		struct v4l2_mbus_framefmt *try_fmt =
3035 			v4l2_subdev_get_try_format(sd, fh->state, i);
3036 		struct v4l2_rect *try_crop =
3037 			v4l2_subdev_get_try_crop(sd, fh->state, i);
3038 		struct v4l2_rect *try_comp;
3039 
3040 		ccs_get_native_size(ssd, try_crop);
3041 
3042 		try_fmt->width = try_crop->width;
3043 		try_fmt->height = try_crop->height;
3044 		try_fmt->code = sensor->internal_csi_format->code;
3045 		try_fmt->field = V4L2_FIELD_NONE;
3046 
3047 		if (ssd != sensor->pixel_array)
3048 			continue;
3049 
3050 		try_comp = v4l2_subdev_get_try_compose(sd, fh->state, i);
3051 		*try_comp = *try_crop;
3052 	}
3053 
3054 	mutex_unlock(&sensor->mutex);
3055 
3056 	return 0;
3057 }
3058 
3059 static const struct v4l2_subdev_video_ops ccs_video_ops = {
3060 	.s_stream = ccs_set_stream,
3061 };
3062 
3063 static const struct v4l2_subdev_pad_ops ccs_pad_ops = {
3064 	.enum_mbus_code = ccs_enum_mbus_code,
3065 	.get_fmt = ccs_get_format,
3066 	.set_fmt = ccs_set_format,
3067 	.get_selection = ccs_get_selection,
3068 	.set_selection = ccs_set_selection,
3069 };
3070 
3071 static const struct v4l2_subdev_sensor_ops ccs_sensor_ops = {
3072 	.g_skip_frames = ccs_get_skip_frames,
3073 	.g_skip_top_lines = ccs_get_skip_top_lines,
3074 };
3075 
3076 static const struct v4l2_subdev_ops ccs_ops = {
3077 	.video = &ccs_video_ops,
3078 	.pad = &ccs_pad_ops,
3079 	.sensor = &ccs_sensor_ops,
3080 };
3081 
3082 static const struct media_entity_operations ccs_entity_ops = {
3083 	.link_validate = v4l2_subdev_link_validate,
3084 };
3085 
3086 static const struct v4l2_subdev_internal_ops ccs_internal_src_ops = {
3087 	.registered = ccs_registered,
3088 	.unregistered = ccs_unregistered,
3089 	.open = ccs_open,
3090 };
3091 
3092 static const struct v4l2_subdev_internal_ops ccs_internal_ops = {
3093 	.open = ccs_open,
3094 };
3095 
3096 /* -----------------------------------------------------------------------------
3097  * I2C Driver
3098  */
3099 
3100 static int __maybe_unused ccs_suspend(struct device *dev)
3101 {
3102 	struct i2c_client *client = to_i2c_client(dev);
3103 	struct v4l2_subdev *subdev = i2c_get_clientdata(client);
3104 	struct ccs_sensor *sensor = to_ccs_sensor(subdev);
3105 	bool streaming = sensor->streaming;
3106 	int rval;
3107 
3108 	rval = pm_runtime_resume_and_get(dev);
3109 	if (rval < 0)
3110 		return rval;
3111 
3112 	if (sensor->streaming)
3113 		ccs_stop_streaming(sensor);
3114 
3115 	/* save state for resume */
3116 	sensor->streaming = streaming;
3117 
3118 	return 0;
3119 }
3120 
3121 static int __maybe_unused ccs_resume(struct device *dev)
3122 {
3123 	struct i2c_client *client = to_i2c_client(dev);
3124 	struct v4l2_subdev *subdev = i2c_get_clientdata(client);
3125 	struct ccs_sensor *sensor = to_ccs_sensor(subdev);
3126 	int rval = 0;
3127 
3128 	pm_runtime_put(dev);
3129 
3130 	if (sensor->streaming)
3131 		rval = ccs_start_streaming(sensor);
3132 
3133 	return rval;
3134 }
3135 
3136 static int ccs_get_hwconfig(struct ccs_sensor *sensor, struct device *dev)
3137 {
3138 	struct ccs_hwconfig *hwcfg = &sensor->hwcfg;
3139 	struct v4l2_fwnode_endpoint bus_cfg = { .bus_type = V4L2_MBUS_UNKNOWN };
3140 	struct fwnode_handle *ep;
3141 	struct fwnode_handle *fwnode = dev_fwnode(dev);
3142 	u32 rotation;
3143 	int i;
3144 	int rval;
3145 
3146 	ep = fwnode_graph_get_endpoint_by_id(fwnode, 0, 0,
3147 					     FWNODE_GRAPH_ENDPOINT_NEXT);
3148 	if (!ep)
3149 		return -ENODEV;
3150 
3151 	/*
3152 	 * Note that we do need to rely on detecting the bus type between CSI-2
3153 	 * D-PHY and CCP2 as the old bindings did not require it.
3154 	 */
3155 	rval = v4l2_fwnode_endpoint_alloc_parse(ep, &bus_cfg);
3156 	if (rval)
3157 		goto out_err;
3158 
3159 	switch (bus_cfg.bus_type) {
3160 	case V4L2_MBUS_CSI2_DPHY:
3161 		hwcfg->csi_signalling_mode = CCS_CSI_SIGNALING_MODE_CSI_2_DPHY;
3162 		hwcfg->lanes = bus_cfg.bus.mipi_csi2.num_data_lanes;
3163 		break;
3164 	case V4L2_MBUS_CSI2_CPHY:
3165 		hwcfg->csi_signalling_mode = CCS_CSI_SIGNALING_MODE_CSI_2_CPHY;
3166 		hwcfg->lanes = bus_cfg.bus.mipi_csi2.num_data_lanes;
3167 		break;
3168 	case V4L2_MBUS_CSI1:
3169 	case V4L2_MBUS_CCP2:
3170 		hwcfg->csi_signalling_mode = (bus_cfg.bus.mipi_csi1.strobe) ?
3171 		SMIAPP_CSI_SIGNALLING_MODE_CCP2_DATA_STROBE :
3172 		SMIAPP_CSI_SIGNALLING_MODE_CCP2_DATA_CLOCK;
3173 		hwcfg->lanes = 1;
3174 		break;
3175 	default:
3176 		dev_err(dev, "unsupported bus %u\n", bus_cfg.bus_type);
3177 		rval = -EINVAL;
3178 		goto out_err;
3179 	}
3180 
3181 	dev_dbg(dev, "lanes %u\n", hwcfg->lanes);
3182 
3183 	rval = fwnode_property_read_u32(fwnode, "rotation", &rotation);
3184 	if (!rval) {
3185 		switch (rotation) {
3186 		case 180:
3187 			hwcfg->module_board_orient =
3188 				CCS_MODULE_BOARD_ORIENT_180;
3189 			fallthrough;
3190 		case 0:
3191 			break;
3192 		default:
3193 			dev_err(dev, "invalid rotation %u\n", rotation);
3194 			rval = -EINVAL;
3195 			goto out_err;
3196 		}
3197 	}
3198 
3199 	rval = fwnode_property_read_u32(dev_fwnode(dev), "clock-frequency",
3200 					&hwcfg->ext_clk);
3201 	if (rval)
3202 		dev_info(dev, "can't get clock-frequency\n");
3203 
3204 	dev_dbg(dev, "clk %d, mode %d\n", hwcfg->ext_clk,
3205 		hwcfg->csi_signalling_mode);
3206 
3207 	if (!bus_cfg.nr_of_link_frequencies) {
3208 		dev_warn(dev, "no link frequencies defined\n");
3209 		rval = -EINVAL;
3210 		goto out_err;
3211 	}
3212 
3213 	hwcfg->op_sys_clock = devm_kcalloc(
3214 		dev, bus_cfg.nr_of_link_frequencies + 1 /* guardian */,
3215 		sizeof(*hwcfg->op_sys_clock), GFP_KERNEL);
3216 	if (!hwcfg->op_sys_clock) {
3217 		rval = -ENOMEM;
3218 		goto out_err;
3219 	}
3220 
3221 	for (i = 0; i < bus_cfg.nr_of_link_frequencies; i++) {
3222 		hwcfg->op_sys_clock[i] = bus_cfg.link_frequencies[i];
3223 		dev_dbg(dev, "freq %d: %lld\n", i, hwcfg->op_sys_clock[i]);
3224 	}
3225 
3226 	v4l2_fwnode_endpoint_free(&bus_cfg);
3227 	fwnode_handle_put(ep);
3228 
3229 	return 0;
3230 
3231 out_err:
3232 	v4l2_fwnode_endpoint_free(&bus_cfg);
3233 	fwnode_handle_put(ep);
3234 
3235 	return rval;
3236 }
3237 
3238 static int ccs_probe(struct i2c_client *client)
3239 {
3240 	struct ccs_sensor *sensor;
3241 	const struct firmware *fw;
3242 	char filename[40];
3243 	unsigned int i;
3244 	int rval;
3245 
3246 	sensor = devm_kzalloc(&client->dev, sizeof(*sensor), GFP_KERNEL);
3247 	if (sensor == NULL)
3248 		return -ENOMEM;
3249 
3250 	rval = ccs_get_hwconfig(sensor, &client->dev);
3251 	if (rval)
3252 		return rval;
3253 
3254 	sensor->src = &sensor->ssds[sensor->ssds_used];
3255 
3256 	v4l2_i2c_subdev_init(&sensor->src->sd, client, &ccs_ops);
3257 	sensor->src->sd.internal_ops = &ccs_internal_src_ops;
3258 
3259 	sensor->regulators = devm_kcalloc(&client->dev,
3260 					  ARRAY_SIZE(ccs_regulators),
3261 					  sizeof(*sensor->regulators),
3262 					  GFP_KERNEL);
3263 	if (!sensor->regulators)
3264 		return -ENOMEM;
3265 
3266 	for (i = 0; i < ARRAY_SIZE(ccs_regulators); i++)
3267 		sensor->regulators[i].supply = ccs_regulators[i];
3268 
3269 	rval = devm_regulator_bulk_get(&client->dev, ARRAY_SIZE(ccs_regulators),
3270 				       sensor->regulators);
3271 	if (rval) {
3272 		dev_err(&client->dev, "could not get regulators\n");
3273 		return rval;
3274 	}
3275 
3276 	sensor->ext_clk = devm_clk_get(&client->dev, NULL);
3277 	if (PTR_ERR(sensor->ext_clk) == -ENOENT) {
3278 		dev_info(&client->dev, "no clock defined, continuing...\n");
3279 		sensor->ext_clk = NULL;
3280 	} else if (IS_ERR(sensor->ext_clk)) {
3281 		dev_err(&client->dev, "could not get clock (%ld)\n",
3282 			PTR_ERR(sensor->ext_clk));
3283 		return -EPROBE_DEFER;
3284 	}
3285 
3286 	if (sensor->ext_clk) {
3287 		if (sensor->hwcfg.ext_clk) {
3288 			unsigned long rate;
3289 
3290 			rval = clk_set_rate(sensor->ext_clk,
3291 					    sensor->hwcfg.ext_clk);
3292 			if (rval < 0) {
3293 				dev_err(&client->dev,
3294 					"unable to set clock freq to %u\n",
3295 					sensor->hwcfg.ext_clk);
3296 				return rval;
3297 			}
3298 
3299 			rate = clk_get_rate(sensor->ext_clk);
3300 			if (rate != sensor->hwcfg.ext_clk) {
3301 				dev_err(&client->dev,
3302 					"can't set clock freq, asked for %u but got %lu\n",
3303 					sensor->hwcfg.ext_clk, rate);
3304 				return -EINVAL;
3305 			}
3306 		} else {
3307 			sensor->hwcfg.ext_clk = clk_get_rate(sensor->ext_clk);
3308 			dev_dbg(&client->dev, "obtained clock freq %u\n",
3309 				sensor->hwcfg.ext_clk);
3310 		}
3311 	} else if (sensor->hwcfg.ext_clk) {
3312 		dev_dbg(&client->dev, "assuming clock freq %u\n",
3313 			sensor->hwcfg.ext_clk);
3314 	} else {
3315 		dev_err(&client->dev, "unable to obtain clock freq\n");
3316 		return -EINVAL;
3317 	}
3318 
3319 	if (!sensor->hwcfg.ext_clk) {
3320 		dev_err(&client->dev, "cannot work with xclk frequency 0\n");
3321 		return -EINVAL;
3322 	}
3323 
3324 	sensor->reset = devm_gpiod_get_optional(&client->dev, "reset",
3325 						GPIOD_OUT_HIGH);
3326 	if (IS_ERR(sensor->reset))
3327 		return PTR_ERR(sensor->reset);
3328 	/* Support old users that may have used "xshutdown" property. */
3329 	if (!sensor->reset)
3330 		sensor->xshutdown = devm_gpiod_get_optional(&client->dev,
3331 							    "xshutdown",
3332 							    GPIOD_OUT_LOW);
3333 	if (IS_ERR(sensor->xshutdown))
3334 		return PTR_ERR(sensor->xshutdown);
3335 
3336 	rval = ccs_power_on(&client->dev);
3337 	if (rval < 0)
3338 		return rval;
3339 
3340 	mutex_init(&sensor->mutex);
3341 
3342 	rval = ccs_identify_module(sensor);
3343 	if (rval) {
3344 		rval = -ENODEV;
3345 		goto out_power_off;
3346 	}
3347 
3348 	rval = snprintf(filename, sizeof(filename),
3349 			"ccs/ccs-sensor-%4.4x-%4.4x-%4.4x.fw",
3350 			sensor->minfo.sensor_mipi_manufacturer_id,
3351 			sensor->minfo.sensor_model_id,
3352 			sensor->minfo.sensor_revision_number);
3353 	if (rval >= sizeof(filename)) {
3354 		rval = -ENOMEM;
3355 		goto out_power_off;
3356 	}
3357 
3358 	rval = request_firmware(&fw, filename, &client->dev);
3359 	if (!rval) {
3360 		ccs_data_parse(&sensor->sdata, fw->data, fw->size, &client->dev,
3361 			       true);
3362 		release_firmware(fw);
3363 	}
3364 
3365 	rval = snprintf(filename, sizeof(filename),
3366 			"ccs/ccs-module-%4.4x-%4.4x-%4.4x.fw",
3367 			sensor->minfo.mipi_manufacturer_id,
3368 			sensor->minfo.model_id,
3369 			sensor->minfo.revision_number);
3370 	if (rval >= sizeof(filename)) {
3371 		rval = -ENOMEM;
3372 		goto out_release_sdata;
3373 	}
3374 
3375 	rval = request_firmware(&fw, filename, &client->dev);
3376 	if (!rval) {
3377 		ccs_data_parse(&sensor->mdata, fw->data, fw->size, &client->dev,
3378 			       true);
3379 		release_firmware(fw);
3380 	}
3381 
3382 	rval = ccs_read_all_limits(sensor);
3383 	if (rval)
3384 		goto out_release_mdata;
3385 
3386 	rval = ccs_read_frame_fmt(sensor);
3387 	if (rval) {
3388 		rval = -ENODEV;
3389 		goto out_free_ccs_limits;
3390 	}
3391 
3392 	rval = ccs_update_phy_ctrl(sensor);
3393 	if (rval < 0)
3394 		goto out_free_ccs_limits;
3395 
3396 	/*
3397 	 * Handle Sensor Module orientation on the board.
3398 	 *
3399 	 * The application of H-FLIP and V-FLIP on the sensor is modified by
3400 	 * the sensor orientation on the board.
3401 	 *
3402 	 * For CCS_BOARD_SENSOR_ORIENT_180 the default behaviour is to set
3403 	 * both H-FLIP and V-FLIP for normal operation which also implies
3404 	 * that a set/unset operation for user space HFLIP and VFLIP v4l2
3405 	 * controls will need to be internally inverted.
3406 	 *
3407 	 * Rotation also changes the bayer pattern.
3408 	 */
3409 	if (sensor->hwcfg.module_board_orient ==
3410 	    CCS_MODULE_BOARD_ORIENT_180)
3411 		sensor->hvflip_inv_mask =
3412 			CCS_IMAGE_ORIENTATION_HORIZONTAL_MIRROR |
3413 			CCS_IMAGE_ORIENTATION_VERTICAL_FLIP;
3414 
3415 	rval = ccs_call_quirk(sensor, limits);
3416 	if (rval) {
3417 		dev_err(&client->dev, "limits quirks failed\n");
3418 		goto out_free_ccs_limits;
3419 	}
3420 
3421 	if (CCS_LIM(sensor, BINNING_CAPABILITY)) {
3422 		sensor->nbinning_subtypes =
3423 			min_t(u8, CCS_LIM(sensor, BINNING_SUB_TYPES),
3424 			      CCS_LIM_BINNING_SUB_TYPE_MAX_N);
3425 
3426 		for (i = 0; i < sensor->nbinning_subtypes; i++) {
3427 			sensor->binning_subtypes[i].horizontal =
3428 				CCS_LIM_AT(sensor, BINNING_SUB_TYPE, i) >>
3429 				CCS_BINNING_SUB_TYPE_COLUMN_SHIFT;
3430 			sensor->binning_subtypes[i].vertical =
3431 				CCS_LIM_AT(sensor, BINNING_SUB_TYPE, i) &
3432 				CCS_BINNING_SUB_TYPE_ROW_MASK;
3433 
3434 			dev_dbg(&client->dev, "binning %xx%x\n",
3435 				sensor->binning_subtypes[i].horizontal,
3436 				sensor->binning_subtypes[i].vertical);
3437 		}
3438 	}
3439 	sensor->binning_horizontal = 1;
3440 	sensor->binning_vertical = 1;
3441 
3442 	if (device_create_file(&client->dev, &dev_attr_ident) != 0) {
3443 		dev_err(&client->dev, "sysfs ident entry creation failed\n");
3444 		rval = -ENOENT;
3445 		goto out_free_ccs_limits;
3446 	}
3447 
3448 	if (sensor->minfo.smiapp_version &&
3449 	    CCS_LIM(sensor, DATA_TRANSFER_IF_CAPABILITY) &
3450 	    CCS_DATA_TRANSFER_IF_CAPABILITY_SUPPORTED) {
3451 		if (device_create_file(&client->dev, &dev_attr_nvm) != 0) {
3452 			dev_err(&client->dev, "sysfs nvm entry failed\n");
3453 			rval = -EBUSY;
3454 			goto out_cleanup;
3455 		}
3456 	}
3457 
3458 	if (!CCS_LIM(sensor, MIN_OP_SYS_CLK_DIV) ||
3459 	    !CCS_LIM(sensor, MAX_OP_SYS_CLK_DIV) ||
3460 	    !CCS_LIM(sensor, MIN_OP_PIX_CLK_DIV) ||
3461 	    !CCS_LIM(sensor, MAX_OP_PIX_CLK_DIV)) {
3462 		/* No OP clock branch */
3463 		sensor->pll.flags |= CCS_PLL_FLAG_NO_OP_CLOCKS;
3464 	} else if (CCS_LIM(sensor, SCALING_CAPABILITY)
3465 		   != CCS_SCALING_CAPABILITY_NONE ||
3466 		   CCS_LIM(sensor, DIGITAL_CROP_CAPABILITY)
3467 		   == CCS_DIGITAL_CROP_CAPABILITY_INPUT_CROP) {
3468 		/* We have a scaler or digital crop. */
3469 		sensor->scaler = &sensor->ssds[sensor->ssds_used];
3470 		sensor->ssds_used++;
3471 	}
3472 	sensor->binner = &sensor->ssds[sensor->ssds_used];
3473 	sensor->ssds_used++;
3474 	sensor->pixel_array = &sensor->ssds[sensor->ssds_used];
3475 	sensor->ssds_used++;
3476 
3477 	sensor->scale_m = CCS_LIM(sensor, SCALER_N_MIN);
3478 
3479 	/* prepare PLL configuration input values */
3480 	sensor->pll.bus_type = CCS_PLL_BUS_TYPE_CSI2_DPHY;
3481 	sensor->pll.csi2.lanes = sensor->hwcfg.lanes;
3482 	if (CCS_LIM(sensor, CLOCK_CALCULATION) &
3483 	    CCS_CLOCK_CALCULATION_LANE_SPEED) {
3484 		sensor->pll.flags |= CCS_PLL_FLAG_LANE_SPEED_MODEL;
3485 		if (CCS_LIM(sensor, CLOCK_CALCULATION) &
3486 		    CCS_CLOCK_CALCULATION_LINK_DECOUPLED) {
3487 			sensor->pll.vt_lanes =
3488 				CCS_LIM(sensor, NUM_OF_VT_LANES) + 1;
3489 			sensor->pll.op_lanes =
3490 				CCS_LIM(sensor, NUM_OF_OP_LANES) + 1;
3491 			sensor->pll.flags |= CCS_PLL_FLAG_LINK_DECOUPLED;
3492 		} else {
3493 			sensor->pll.vt_lanes = sensor->pll.csi2.lanes;
3494 			sensor->pll.op_lanes = sensor->pll.csi2.lanes;
3495 		}
3496 	}
3497 	if (CCS_LIM(sensor, CLOCK_TREE_PLL_CAPABILITY) &
3498 	    CCS_CLOCK_TREE_PLL_CAPABILITY_EXT_DIVIDER)
3499 		sensor->pll.flags |= CCS_PLL_FLAG_EXT_IP_PLL_DIVIDER;
3500 	if (CCS_LIM(sensor, CLOCK_TREE_PLL_CAPABILITY) &
3501 	    CCS_CLOCK_TREE_PLL_CAPABILITY_FLEXIBLE_OP_PIX_CLK_DIV)
3502 		sensor->pll.flags |= CCS_PLL_FLAG_FLEXIBLE_OP_PIX_CLK_DIV;
3503 	if (CCS_LIM(sensor, FIFO_SUPPORT_CAPABILITY) &
3504 	    CCS_FIFO_SUPPORT_CAPABILITY_DERATING)
3505 		sensor->pll.flags |= CCS_PLL_FLAG_FIFO_DERATING;
3506 	if (CCS_LIM(sensor, FIFO_SUPPORT_CAPABILITY) &
3507 	    CCS_FIFO_SUPPORT_CAPABILITY_DERATING_OVERRATING)
3508 		sensor->pll.flags |= CCS_PLL_FLAG_FIFO_DERATING |
3509 				     CCS_PLL_FLAG_FIFO_OVERRATING;
3510 	if (CCS_LIM(sensor, CLOCK_TREE_PLL_CAPABILITY) &
3511 	    CCS_CLOCK_TREE_PLL_CAPABILITY_DUAL_PLL) {
3512 		if (CCS_LIM(sensor, CLOCK_TREE_PLL_CAPABILITY) &
3513 		    CCS_CLOCK_TREE_PLL_CAPABILITY_SINGLE_PLL) {
3514 			u32 v;
3515 
3516 			/* Use sensor default in PLL mode selection */
3517 			rval = ccs_read(sensor, PLL_MODE, &v);
3518 			if (rval)
3519 				goto out_cleanup;
3520 
3521 			if (v == CCS_PLL_MODE_DUAL)
3522 				sensor->pll.flags |= CCS_PLL_FLAG_DUAL_PLL;
3523 		} else {
3524 			sensor->pll.flags |= CCS_PLL_FLAG_DUAL_PLL;
3525 		}
3526 		if (CCS_LIM(sensor, CLOCK_CALCULATION) &
3527 		    CCS_CLOCK_CALCULATION_DUAL_PLL_OP_SYS_DDR)
3528 			sensor->pll.flags |= CCS_PLL_FLAG_OP_SYS_DDR;
3529 		if (CCS_LIM(sensor, CLOCK_CALCULATION) &
3530 		    CCS_CLOCK_CALCULATION_DUAL_PLL_OP_PIX_DDR)
3531 			sensor->pll.flags |= CCS_PLL_FLAG_OP_PIX_DDR;
3532 	}
3533 	sensor->pll.op_bits_per_lane = CCS_LIM(sensor, OP_BITS_PER_LANE);
3534 	sensor->pll.ext_clk_freq_hz = sensor->hwcfg.ext_clk;
3535 	sensor->pll.scale_n = CCS_LIM(sensor, SCALER_N_MIN);
3536 
3537 	ccs_create_subdev(sensor, sensor->scaler, " scaler", 2,
3538 			  MEDIA_ENT_F_PROC_VIDEO_SCALER);
3539 	ccs_create_subdev(sensor, sensor->binner, " binner", 2,
3540 			  MEDIA_ENT_F_PROC_VIDEO_SCALER);
3541 	ccs_create_subdev(sensor, sensor->pixel_array, " pixel_array", 1,
3542 			  MEDIA_ENT_F_CAM_SENSOR);
3543 
3544 	rval = ccs_init_controls(sensor);
3545 	if (rval < 0)
3546 		goto out_cleanup;
3547 
3548 	rval = ccs_call_quirk(sensor, init);
3549 	if (rval)
3550 		goto out_cleanup;
3551 
3552 	rval = ccs_get_mbus_formats(sensor);
3553 	if (rval) {
3554 		rval = -ENODEV;
3555 		goto out_cleanup;
3556 	}
3557 
3558 	rval = ccs_init_late_controls(sensor);
3559 	if (rval) {
3560 		rval = -ENODEV;
3561 		goto out_cleanup;
3562 	}
3563 
3564 	mutex_lock(&sensor->mutex);
3565 	rval = ccs_pll_blanking_update(sensor);
3566 	mutex_unlock(&sensor->mutex);
3567 	if (rval) {
3568 		dev_err(&client->dev, "update mode failed\n");
3569 		goto out_cleanup;
3570 	}
3571 
3572 	sensor->streaming = false;
3573 	sensor->dev_init_done = true;
3574 
3575 	rval = media_entity_pads_init(&sensor->src->sd.entity, 2,
3576 				 sensor->src->pads);
3577 	if (rval < 0)
3578 		goto out_media_entity_cleanup;
3579 
3580 	rval = ccs_write_msr_regs(sensor);
3581 	if (rval)
3582 		goto out_media_entity_cleanup;
3583 
3584 	pm_runtime_set_active(&client->dev);
3585 	pm_runtime_get_noresume(&client->dev);
3586 	pm_runtime_enable(&client->dev);
3587 
3588 	rval = v4l2_async_register_subdev_sensor(&sensor->src->sd);
3589 	if (rval < 0)
3590 		goto out_disable_runtime_pm;
3591 
3592 	pm_runtime_set_autosuspend_delay(&client->dev, 1000);
3593 	pm_runtime_use_autosuspend(&client->dev);
3594 	pm_runtime_put_autosuspend(&client->dev);
3595 
3596 	return 0;
3597 
3598 out_disable_runtime_pm:
3599 	pm_runtime_put_noidle(&client->dev);
3600 	pm_runtime_disable(&client->dev);
3601 
3602 out_media_entity_cleanup:
3603 	media_entity_cleanup(&sensor->src->sd.entity);
3604 
3605 out_cleanup:
3606 	ccs_cleanup(sensor);
3607 
3608 out_release_mdata:
3609 	kvfree(sensor->mdata.backing);
3610 
3611 out_release_sdata:
3612 	kvfree(sensor->sdata.backing);
3613 
3614 out_free_ccs_limits:
3615 	kfree(sensor->ccs_limits);
3616 
3617 out_power_off:
3618 	ccs_power_off(&client->dev);
3619 	mutex_destroy(&sensor->mutex);
3620 
3621 	return rval;
3622 }
3623 
3624 static int ccs_remove(struct i2c_client *client)
3625 {
3626 	struct v4l2_subdev *subdev = i2c_get_clientdata(client);
3627 	struct ccs_sensor *sensor = to_ccs_sensor(subdev);
3628 	unsigned int i;
3629 
3630 	v4l2_async_unregister_subdev(subdev);
3631 
3632 	pm_runtime_disable(&client->dev);
3633 	if (!pm_runtime_status_suspended(&client->dev))
3634 		ccs_power_off(&client->dev);
3635 	pm_runtime_set_suspended(&client->dev);
3636 
3637 	for (i = 0; i < sensor->ssds_used; i++) {
3638 		v4l2_device_unregister_subdev(&sensor->ssds[i].sd);
3639 		media_entity_cleanup(&sensor->ssds[i].sd.entity);
3640 	}
3641 	ccs_cleanup(sensor);
3642 	mutex_destroy(&sensor->mutex);
3643 	kfree(sensor->ccs_limits);
3644 	kvfree(sensor->sdata.backing);
3645 	kvfree(sensor->mdata.backing);
3646 
3647 	return 0;
3648 }
3649 
3650 static const struct ccs_device smia_device = {
3651 	.flags = CCS_DEVICE_FLAG_IS_SMIA,
3652 };
3653 
3654 static const struct ccs_device ccs_device = {};
3655 
3656 static const struct acpi_device_id ccs_acpi_table[] = {
3657 	{ .id = "MIPI0200", .driver_data = (unsigned long)&ccs_device },
3658 	{ },
3659 };
3660 MODULE_DEVICE_TABLE(acpi, ccs_acpi_table);
3661 
3662 static const struct of_device_id ccs_of_table[] = {
3663 	{ .compatible = "mipi-ccs-1.1", .data = &ccs_device },
3664 	{ .compatible = "mipi-ccs-1.0", .data = &ccs_device },
3665 	{ .compatible = "mipi-ccs", .data = &ccs_device },
3666 	{ .compatible = "nokia,smia", .data = &smia_device },
3667 	{ },
3668 };
3669 MODULE_DEVICE_TABLE(of, ccs_of_table);
3670 
3671 static const struct dev_pm_ops ccs_pm_ops = {
3672 	SET_SYSTEM_SLEEP_PM_OPS(ccs_suspend, ccs_resume)
3673 	SET_RUNTIME_PM_OPS(ccs_power_off, ccs_power_on, NULL)
3674 };
3675 
3676 static struct i2c_driver ccs_i2c_driver = {
3677 	.driver	= {
3678 		.acpi_match_table = ccs_acpi_table,
3679 		.of_match_table = ccs_of_table,
3680 		.name = CCS_NAME,
3681 		.pm = &ccs_pm_ops,
3682 	},
3683 	.probe_new = ccs_probe,
3684 	.remove	= ccs_remove,
3685 };
3686 
3687 static int ccs_module_init(void)
3688 {
3689 	unsigned int i, l;
3690 
3691 	for (i = 0, l = 0; ccs_limits[i].size && l < CCS_L_LAST; i++) {
3692 		if (!(ccs_limits[i].flags & CCS_L_FL_SAME_REG)) {
3693 			ccs_limit_offsets[l + 1].lim =
3694 				ALIGN(ccs_limit_offsets[l].lim +
3695 				      ccs_limits[i].size,
3696 				      ccs_reg_width(ccs_limits[i + 1].reg));
3697 			ccs_limit_offsets[l].info = i;
3698 			l++;
3699 		} else {
3700 			ccs_limit_offsets[l].lim += ccs_limits[i].size;
3701 		}
3702 	}
3703 
3704 	if (WARN_ON(ccs_limits[i].size))
3705 		return -EINVAL;
3706 
3707 	if (WARN_ON(l != CCS_L_LAST))
3708 		return -EINVAL;
3709 
3710 	return i2c_register_driver(THIS_MODULE, &ccs_i2c_driver);
3711 }
3712 
3713 static void ccs_module_cleanup(void)
3714 {
3715 	i2c_del_driver(&ccs_i2c_driver);
3716 }
3717 
3718 module_init(ccs_module_init);
3719 module_exit(ccs_module_cleanup);
3720 
3721 MODULE_AUTHOR("Sakari Ailus <sakari.ailus@linux.intel.com>");
3722 MODULE_DESCRIPTION("Generic MIPI CCS/SMIA/SMIA++ camera sensor driver");
3723 MODULE_LICENSE("GPL v2");
3724 MODULE_ALIAS("smiapp");
3725