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