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