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