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