1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29#include <linux/clk.h>
30#include <linux/delay.h>
31#include <linux/device.h>
32#include <linux/gpio.h>
33#include <linux/module.h>
34#include <linux/regulator/consumer.h>
35#include <linux/slab.h>
36#include <linux/smiapp.h>
37#include <linux/v4l2-mediabus.h>
38#include <media/v4l2-device.h>
39
40#include "smiapp.h"
41
42#define SMIAPP_ALIGN_DIM(dim, flags) \
43 ((flags) & V4L2_SEL_FLAG_GE \
44 ? ALIGN((dim), 2) \
45 : (dim) & ~1)
46
47
48
49
50static const struct smiapp_module_ident smiapp_module_idents[] = {
51 SMIAPP_IDENT_L(0x01, 0x022b, -1, "vs6555"),
52 SMIAPP_IDENT_L(0x01, 0x022e, -1, "vw6558"),
53 SMIAPP_IDENT_L(0x07, 0x7698, -1, "ovm7698"),
54 SMIAPP_IDENT_L(0x0b, 0x4242, -1, "smiapp-003"),
55 SMIAPP_IDENT_L(0x0c, 0x208a, -1, "tcm8330md"),
56 SMIAPP_IDENT_LQ(0x0c, 0x2134, -1, "tcm8500md", &smiapp_tcm8500md_quirk),
57 SMIAPP_IDENT_L(0x0c, 0x213e, -1, "et8en2"),
58 SMIAPP_IDENT_L(0x0c, 0x2184, -1, "tcm8580md"),
59 SMIAPP_IDENT_LQ(0x0c, 0x560f, -1, "jt8ew9", &smiapp_jt8ew9_quirk),
60 SMIAPP_IDENT_LQ(0x10, 0x4141, -1, "jt8ev1", &smiapp_jt8ev1_quirk),
61 SMIAPP_IDENT_LQ(0x10, 0x4241, -1, "imx125es", &smiapp_imx125es_quirk),
62};
63
64
65
66
67
68
69
70static int smiapp_read_frame_fmt(struct smiapp_sensor *sensor)
71{
72 struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
73 u32 fmt_model_type, fmt_model_subtype, ncol_desc, nrow_desc;
74 unsigned int i;
75 int rval;
76 int line_count = 0;
77 int embedded_start = -1, embedded_end = -1;
78 int image_start = 0;
79
80 rval = smiapp_read(sensor, SMIAPP_REG_U8_FRAME_FORMAT_MODEL_TYPE,
81 &fmt_model_type);
82 if (rval)
83 return rval;
84
85 rval = smiapp_read(sensor, SMIAPP_REG_U8_FRAME_FORMAT_MODEL_SUBTYPE,
86 &fmt_model_subtype);
87 if (rval)
88 return rval;
89
90 ncol_desc = (fmt_model_subtype
91 & SMIAPP_FRAME_FORMAT_MODEL_SUBTYPE_NCOLS_MASK)
92 >> SMIAPP_FRAME_FORMAT_MODEL_SUBTYPE_NCOLS_SHIFT;
93 nrow_desc = fmt_model_subtype
94 & SMIAPP_FRAME_FORMAT_MODEL_SUBTYPE_NROWS_MASK;
95
96 dev_dbg(&client->dev, "format_model_type %s\n",
97 fmt_model_type == SMIAPP_FRAME_FORMAT_MODEL_TYPE_2BYTE
98 ? "2 byte" :
99 fmt_model_type == SMIAPP_FRAME_FORMAT_MODEL_TYPE_4BYTE
100 ? "4 byte" : "is simply bad");
101
102 for (i = 0; i < ncol_desc + nrow_desc; i++) {
103 u32 desc;
104 u32 pixelcode;
105 u32 pixels;
106 char *which;
107 char *what;
108
109 if (fmt_model_type == SMIAPP_FRAME_FORMAT_MODEL_TYPE_2BYTE) {
110 rval = smiapp_read(
111 sensor,
112 SMIAPP_REG_U16_FRAME_FORMAT_DESCRIPTOR_2(i),
113 &desc);
114 if (rval)
115 return rval;
116
117 pixelcode =
118 (desc
119 & SMIAPP_FRAME_FORMAT_DESC_2_PIXELCODE_MASK)
120 >> SMIAPP_FRAME_FORMAT_DESC_2_PIXELCODE_SHIFT;
121 pixels = desc & SMIAPP_FRAME_FORMAT_DESC_2_PIXELS_MASK;
122 } else if (fmt_model_type
123 == SMIAPP_FRAME_FORMAT_MODEL_TYPE_4BYTE) {
124 rval = smiapp_read(
125 sensor,
126 SMIAPP_REG_U32_FRAME_FORMAT_DESCRIPTOR_4(i),
127 &desc);
128 if (rval)
129 return rval;
130
131 pixelcode =
132 (desc
133 & SMIAPP_FRAME_FORMAT_DESC_4_PIXELCODE_MASK)
134 >> SMIAPP_FRAME_FORMAT_DESC_4_PIXELCODE_SHIFT;
135 pixels = desc & SMIAPP_FRAME_FORMAT_DESC_4_PIXELS_MASK;
136 } else {
137 dev_dbg(&client->dev,
138 "invalid frame format model type %d\n",
139 fmt_model_type);
140 return -EINVAL;
141 }
142
143 if (i < ncol_desc)
144 which = "columns";
145 else
146 which = "rows";
147
148 switch (pixelcode) {
149 case SMIAPP_FRAME_FORMAT_DESC_PIXELCODE_EMBEDDED:
150 what = "embedded";
151 break;
152 case SMIAPP_FRAME_FORMAT_DESC_PIXELCODE_DUMMY:
153 what = "dummy";
154 break;
155 case SMIAPP_FRAME_FORMAT_DESC_PIXELCODE_BLACK:
156 what = "black";
157 break;
158 case SMIAPP_FRAME_FORMAT_DESC_PIXELCODE_DARK:
159 what = "dark";
160 break;
161 case SMIAPP_FRAME_FORMAT_DESC_PIXELCODE_VISIBLE:
162 what = "visible";
163 break;
164 default:
165 what = "invalid";
166 dev_dbg(&client->dev, "pixelcode %d\n", pixelcode);
167 break;
168 }
169
170 dev_dbg(&client->dev, "%s pixels: %d %s\n",
171 what, pixels, which);
172
173 if (i < ncol_desc)
174 continue;
175
176
177 if (pixelcode
178 == SMIAPP_FRAME_FORMAT_DESC_PIXELCODE_EMBEDDED) {
179 embedded_start = line_count;
180 } else {
181 if (pixelcode == SMIAPP_FRAME_FORMAT_DESC_PIXELCODE_VISIBLE
182 || pixels >= sensor->limits[SMIAPP_LIMIT_MIN_FRAME_LENGTH_LINES] / 2)
183 image_start = line_count;
184 if (embedded_start != -1 && embedded_end == -1)
185 embedded_end = line_count;
186 }
187 line_count += pixels;
188 }
189
190 if (embedded_start == -1 || embedded_end == -1) {
191 embedded_start = 0;
192 embedded_end = 0;
193 }
194
195 dev_dbg(&client->dev, "embedded data from lines %d to %d\n",
196 embedded_start, embedded_end);
197 dev_dbg(&client->dev, "image data starts at line %d\n", image_start);
198
199 return 0;
200}
201
202static int smiapp_pll_configure(struct smiapp_sensor *sensor)
203{
204 struct smiapp_pll *pll = &sensor->pll;
205 int rval;
206
207 rval = smiapp_write(
208 sensor, SMIAPP_REG_U16_VT_PIX_CLK_DIV, pll->vt_pix_clk_div);
209 if (rval < 0)
210 return rval;
211
212 rval = smiapp_write(
213 sensor, SMIAPP_REG_U16_VT_SYS_CLK_DIV, pll->vt_sys_clk_div);
214 if (rval < 0)
215 return rval;
216
217 rval = smiapp_write(
218 sensor, SMIAPP_REG_U16_PRE_PLL_CLK_DIV, pll->pre_pll_clk_div);
219 if (rval < 0)
220 return rval;
221
222 rval = smiapp_write(
223 sensor, SMIAPP_REG_U16_PLL_MULTIPLIER, pll->pll_multiplier);
224 if (rval < 0)
225 return rval;
226
227
228 rval = smiapp_write(
229 sensor, SMIAPP_REG_U32_REQUESTED_LINK_BIT_RATE_MBPS,
230 DIV_ROUND_UP(pll->op_sys_clk_freq_hz, 1000000 / 256 / 256));
231 if (rval < 0 || sensor->minfo.smiapp_profile == SMIAPP_PROFILE_0)
232 return rval;
233
234 rval = smiapp_write(
235 sensor, SMIAPP_REG_U16_OP_PIX_CLK_DIV, pll->op_pix_clk_div);
236 if (rval < 0)
237 return rval;
238
239 return smiapp_write(
240 sensor, SMIAPP_REG_U16_OP_SYS_CLK_DIV, pll->op_sys_clk_div);
241}
242
243static int smiapp_pll_update(struct smiapp_sensor *sensor)
244{
245 struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
246 struct smiapp_pll_limits lim = {
247 .min_pre_pll_clk_div = sensor->limits[SMIAPP_LIMIT_MIN_PRE_PLL_CLK_DIV],
248 .max_pre_pll_clk_div = sensor->limits[SMIAPP_LIMIT_MAX_PRE_PLL_CLK_DIV],
249 .min_pll_ip_freq_hz = sensor->limits[SMIAPP_LIMIT_MIN_PLL_IP_FREQ_HZ],
250 .max_pll_ip_freq_hz = sensor->limits[SMIAPP_LIMIT_MAX_PLL_IP_FREQ_HZ],
251 .min_pll_multiplier = sensor->limits[SMIAPP_LIMIT_MIN_PLL_MULTIPLIER],
252 .max_pll_multiplier = sensor->limits[SMIAPP_LIMIT_MAX_PLL_MULTIPLIER],
253 .min_pll_op_freq_hz = sensor->limits[SMIAPP_LIMIT_MIN_PLL_OP_FREQ_HZ],
254 .max_pll_op_freq_hz = sensor->limits[SMIAPP_LIMIT_MAX_PLL_OP_FREQ_HZ],
255
256 .op.min_sys_clk_div = sensor->limits[SMIAPP_LIMIT_MIN_OP_SYS_CLK_DIV],
257 .op.max_sys_clk_div = sensor->limits[SMIAPP_LIMIT_MAX_OP_SYS_CLK_DIV],
258 .op.min_pix_clk_div = sensor->limits[SMIAPP_LIMIT_MIN_OP_PIX_CLK_DIV],
259 .op.max_pix_clk_div = sensor->limits[SMIAPP_LIMIT_MAX_OP_PIX_CLK_DIV],
260 .op.min_sys_clk_freq_hz = sensor->limits[SMIAPP_LIMIT_MIN_OP_SYS_CLK_FREQ_HZ],
261 .op.max_sys_clk_freq_hz = sensor->limits[SMIAPP_LIMIT_MAX_OP_SYS_CLK_FREQ_HZ],
262 .op.min_pix_clk_freq_hz = sensor->limits[SMIAPP_LIMIT_MIN_OP_PIX_CLK_FREQ_HZ],
263 .op.max_pix_clk_freq_hz = sensor->limits[SMIAPP_LIMIT_MAX_OP_PIX_CLK_FREQ_HZ],
264
265 .vt.min_sys_clk_div = sensor->limits[SMIAPP_LIMIT_MIN_VT_SYS_CLK_DIV],
266 .vt.max_sys_clk_div = sensor->limits[SMIAPP_LIMIT_MAX_VT_SYS_CLK_DIV],
267 .vt.min_pix_clk_div = sensor->limits[SMIAPP_LIMIT_MIN_VT_PIX_CLK_DIV],
268 .vt.max_pix_clk_div = sensor->limits[SMIAPP_LIMIT_MAX_VT_PIX_CLK_DIV],
269 .vt.min_sys_clk_freq_hz = sensor->limits[SMIAPP_LIMIT_MIN_VT_SYS_CLK_FREQ_HZ],
270 .vt.max_sys_clk_freq_hz = sensor->limits[SMIAPP_LIMIT_MAX_VT_SYS_CLK_FREQ_HZ],
271 .vt.min_pix_clk_freq_hz = sensor->limits[SMIAPP_LIMIT_MIN_VT_PIX_CLK_FREQ_HZ],
272 .vt.max_pix_clk_freq_hz = sensor->limits[SMIAPP_LIMIT_MAX_VT_PIX_CLK_FREQ_HZ],
273
274 .min_line_length_pck_bin = sensor->limits[SMIAPP_LIMIT_MIN_LINE_LENGTH_PCK_BIN],
275 .min_line_length_pck = sensor->limits[SMIAPP_LIMIT_MIN_LINE_LENGTH_PCK],
276 };
277 struct smiapp_pll *pll = &sensor->pll;
278 int rval;
279
280 if (sensor->minfo.smiapp_profile == SMIAPP_PROFILE_0) {
281
282
283
284
285
286
287 lim.op = lim.vt;
288 }
289
290 pll->binning_horizontal = sensor->binning_horizontal;
291 pll->binning_vertical = sensor->binning_vertical;
292 pll->link_freq =
293 sensor->link_freq->qmenu_int[sensor->link_freq->val];
294 pll->scale_m = sensor->scale_m;
295 pll->bits_per_pixel = sensor->csi_format->compressed;
296
297 rval = smiapp_pll_calculate(&client->dev, &lim, pll);
298 if (rval < 0)
299 return rval;
300
301 __v4l2_ctrl_s_ctrl_int64(sensor->pixel_rate_parray,
302 pll->vt_pix_clk_freq_hz);
303 __v4l2_ctrl_s_ctrl_int64(sensor->pixel_rate_csi, pll->pixel_rate_csi);
304
305 return 0;
306}
307
308
309
310
311
312
313
314
315static void __smiapp_update_exposure_limits(struct smiapp_sensor *sensor)
316{
317 struct v4l2_ctrl *ctrl = sensor->exposure;
318 int max;
319
320 max = sensor->pixel_array->crop[SMIAPP_PA_PAD_SRC].height
321 + sensor->vblank->val
322 - sensor->limits[SMIAPP_LIMIT_COARSE_INTEGRATION_TIME_MAX_MARGIN];
323
324 __v4l2_ctrl_modify_range(ctrl, ctrl->minimum, max, ctrl->step, max);
325}
326
327
328
329
330
331
332
333
334
335static const struct smiapp_csi_data_format smiapp_csi_data_formats[] = {
336 { V4L2_MBUS_FMT_SGRBG12_1X12, 12, 12, SMIAPP_PIXEL_ORDER_GRBG, },
337 { V4L2_MBUS_FMT_SRGGB12_1X12, 12, 12, SMIAPP_PIXEL_ORDER_RGGB, },
338 { V4L2_MBUS_FMT_SBGGR12_1X12, 12, 12, SMIAPP_PIXEL_ORDER_BGGR, },
339 { V4L2_MBUS_FMT_SGBRG12_1X12, 12, 12, SMIAPP_PIXEL_ORDER_GBRG, },
340 { V4L2_MBUS_FMT_SGRBG10_1X10, 10, 10, SMIAPP_PIXEL_ORDER_GRBG, },
341 { V4L2_MBUS_FMT_SRGGB10_1X10, 10, 10, SMIAPP_PIXEL_ORDER_RGGB, },
342 { V4L2_MBUS_FMT_SBGGR10_1X10, 10, 10, SMIAPP_PIXEL_ORDER_BGGR, },
343 { V4L2_MBUS_FMT_SGBRG10_1X10, 10, 10, SMIAPP_PIXEL_ORDER_GBRG, },
344 { V4L2_MBUS_FMT_SGRBG10_DPCM8_1X8, 10, 8, SMIAPP_PIXEL_ORDER_GRBG, },
345 { V4L2_MBUS_FMT_SRGGB10_DPCM8_1X8, 10, 8, SMIAPP_PIXEL_ORDER_RGGB, },
346 { V4L2_MBUS_FMT_SBGGR10_DPCM8_1X8, 10, 8, SMIAPP_PIXEL_ORDER_BGGR, },
347 { V4L2_MBUS_FMT_SGBRG10_DPCM8_1X8, 10, 8, SMIAPP_PIXEL_ORDER_GBRG, },
348 { V4L2_MBUS_FMT_SGRBG8_1X8, 8, 8, SMIAPP_PIXEL_ORDER_GRBG, },
349 { V4L2_MBUS_FMT_SRGGB8_1X8, 8, 8, SMIAPP_PIXEL_ORDER_RGGB, },
350 { V4L2_MBUS_FMT_SBGGR8_1X8, 8, 8, SMIAPP_PIXEL_ORDER_BGGR, },
351 { V4L2_MBUS_FMT_SGBRG8_1X8, 8, 8, SMIAPP_PIXEL_ORDER_GBRG, },
352};
353
354const char *pixel_order_str[] = { "GRBG", "RGGB", "BGGR", "GBRG" };
355
356#define to_csi_format_idx(fmt) (((unsigned long)(fmt) \
357 - (unsigned long)smiapp_csi_data_formats) \
358 / sizeof(*smiapp_csi_data_formats))
359
360static u32 smiapp_pixel_order(struct smiapp_sensor *sensor)
361{
362 struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
363 int flip = 0;
364
365 if (sensor->hflip) {
366 if (sensor->hflip->val)
367 flip |= SMIAPP_IMAGE_ORIENTATION_HFLIP;
368
369 if (sensor->vflip->val)
370 flip |= SMIAPP_IMAGE_ORIENTATION_VFLIP;
371 }
372
373 flip ^= sensor->hvflip_inv_mask;
374
375 dev_dbg(&client->dev, "flip %d\n", flip);
376 return sensor->default_pixel_order ^ flip;
377}
378
379static void smiapp_update_mbus_formats(struct smiapp_sensor *sensor)
380{
381 struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
382 unsigned int csi_format_idx =
383 to_csi_format_idx(sensor->csi_format) & ~3;
384 unsigned int internal_csi_format_idx =
385 to_csi_format_idx(sensor->internal_csi_format) & ~3;
386 unsigned int pixel_order = smiapp_pixel_order(sensor);
387
388 sensor->mbus_frame_fmts =
389 sensor->default_mbus_frame_fmts << pixel_order;
390 sensor->csi_format =
391 &smiapp_csi_data_formats[csi_format_idx + pixel_order];
392 sensor->internal_csi_format =
393 &smiapp_csi_data_formats[internal_csi_format_idx
394 + pixel_order];
395
396 BUG_ON(max(internal_csi_format_idx, csi_format_idx) + pixel_order
397 >= ARRAY_SIZE(smiapp_csi_data_formats));
398
399 dev_dbg(&client->dev, "new pixel order %s\n",
400 pixel_order_str[pixel_order]);
401}
402
403static const char * const smiapp_test_patterns[] = {
404 "Disabled",
405 "Solid Colour",
406 "Eight Vertical Colour Bars",
407 "Colour Bars With Fade to Grey",
408 "Pseudorandom Sequence (PN9)",
409};
410
411static int smiapp_set_ctrl(struct v4l2_ctrl *ctrl)
412{
413 struct smiapp_sensor *sensor =
414 container_of(ctrl->handler, struct smiapp_subdev, ctrl_handler)
415 ->sensor;
416 u32 orient = 0;
417 int exposure;
418 int rval;
419
420 switch (ctrl->id) {
421 case V4L2_CID_ANALOGUE_GAIN:
422 return smiapp_write(
423 sensor,
424 SMIAPP_REG_U16_ANALOGUE_GAIN_CODE_GLOBAL, ctrl->val);
425
426 case V4L2_CID_EXPOSURE:
427 return smiapp_write(
428 sensor,
429 SMIAPP_REG_U16_COARSE_INTEGRATION_TIME, ctrl->val);
430
431 case V4L2_CID_HFLIP:
432 case V4L2_CID_VFLIP:
433 if (sensor->streaming)
434 return -EBUSY;
435
436 if (sensor->hflip->val)
437 orient |= SMIAPP_IMAGE_ORIENTATION_HFLIP;
438
439 if (sensor->vflip->val)
440 orient |= SMIAPP_IMAGE_ORIENTATION_VFLIP;
441
442 orient ^= sensor->hvflip_inv_mask;
443 rval = smiapp_write(sensor,
444 SMIAPP_REG_U8_IMAGE_ORIENTATION,
445 orient);
446 if (rval < 0)
447 return rval;
448
449 smiapp_update_mbus_formats(sensor);
450
451 return 0;
452
453 case V4L2_CID_VBLANK:
454 exposure = sensor->exposure->val;
455
456 __smiapp_update_exposure_limits(sensor);
457
458 if (exposure > sensor->exposure->maximum) {
459 sensor->exposure->val =
460 sensor->exposure->maximum;
461 rval = smiapp_set_ctrl(
462 sensor->exposure);
463 if (rval < 0)
464 return rval;
465 }
466
467 return smiapp_write(
468 sensor, SMIAPP_REG_U16_FRAME_LENGTH_LINES,
469 sensor->pixel_array->crop[SMIAPP_PA_PAD_SRC].height
470 + ctrl->val);
471
472 case V4L2_CID_HBLANK:
473 return smiapp_write(
474 sensor, SMIAPP_REG_U16_LINE_LENGTH_PCK,
475 sensor->pixel_array->crop[SMIAPP_PA_PAD_SRC].width
476 + ctrl->val);
477
478 case V4L2_CID_LINK_FREQ:
479 if (sensor->streaming)
480 return -EBUSY;
481
482 return smiapp_pll_update(sensor);
483
484 case V4L2_CID_TEST_PATTERN: {
485 unsigned int i;
486
487 for (i = 0; i < ARRAY_SIZE(sensor->test_data); i++)
488 v4l2_ctrl_activate(
489 sensor->test_data[i],
490 ctrl->val ==
491 V4L2_SMIAPP_TEST_PATTERN_MODE_SOLID_COLOUR);
492
493 return smiapp_write(
494 sensor, SMIAPP_REG_U16_TEST_PATTERN_MODE, ctrl->val);
495 }
496
497 case V4L2_CID_TEST_PATTERN_RED:
498 return smiapp_write(
499 sensor, SMIAPP_REG_U16_TEST_DATA_RED, ctrl->val);
500
501 case V4L2_CID_TEST_PATTERN_GREENR:
502 return smiapp_write(
503 sensor, SMIAPP_REG_U16_TEST_DATA_GREENR, ctrl->val);
504
505 case V4L2_CID_TEST_PATTERN_BLUE:
506 return smiapp_write(
507 sensor, SMIAPP_REG_U16_TEST_DATA_BLUE, ctrl->val);
508
509 case V4L2_CID_TEST_PATTERN_GREENB:
510 return smiapp_write(
511 sensor, SMIAPP_REG_U16_TEST_DATA_GREENB, ctrl->val);
512
513 case V4L2_CID_PIXEL_RATE:
514
515 return 0;
516
517 default:
518 return -EINVAL;
519 }
520}
521
522static const struct v4l2_ctrl_ops smiapp_ctrl_ops = {
523 .s_ctrl = smiapp_set_ctrl,
524};
525
526static int smiapp_init_controls(struct smiapp_sensor *sensor)
527{
528 struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
529 unsigned int max, i;
530 int rval;
531
532 rval = v4l2_ctrl_handler_init(&sensor->pixel_array->ctrl_handler, 12);
533 if (rval)
534 return rval;
535 sensor->pixel_array->ctrl_handler.lock = &sensor->mutex;
536
537 sensor->analog_gain = v4l2_ctrl_new_std(
538 &sensor->pixel_array->ctrl_handler, &smiapp_ctrl_ops,
539 V4L2_CID_ANALOGUE_GAIN,
540 sensor->limits[SMIAPP_LIMIT_ANALOGUE_GAIN_CODE_MIN],
541 sensor->limits[SMIAPP_LIMIT_ANALOGUE_GAIN_CODE_MAX],
542 max(sensor->limits[SMIAPP_LIMIT_ANALOGUE_GAIN_CODE_STEP], 1U),
543 sensor->limits[SMIAPP_LIMIT_ANALOGUE_GAIN_CODE_MIN]);
544
545
546 sensor->exposure = v4l2_ctrl_new_std(
547 &sensor->pixel_array->ctrl_handler, &smiapp_ctrl_ops,
548 V4L2_CID_EXPOSURE, 0, 0, 1, 0);
549
550 sensor->hflip = v4l2_ctrl_new_std(
551 &sensor->pixel_array->ctrl_handler, &smiapp_ctrl_ops,
552 V4L2_CID_HFLIP, 0, 1, 1, 0);
553 sensor->vflip = v4l2_ctrl_new_std(
554 &sensor->pixel_array->ctrl_handler, &smiapp_ctrl_ops,
555 V4L2_CID_VFLIP, 0, 1, 1, 0);
556
557 sensor->vblank = v4l2_ctrl_new_std(
558 &sensor->pixel_array->ctrl_handler, &smiapp_ctrl_ops,
559 V4L2_CID_VBLANK, 0, 1, 1, 0);
560
561 if (sensor->vblank)
562 sensor->vblank->flags |= V4L2_CTRL_FLAG_UPDATE;
563
564 sensor->hblank = v4l2_ctrl_new_std(
565 &sensor->pixel_array->ctrl_handler, &smiapp_ctrl_ops,
566 V4L2_CID_HBLANK, 0, 1, 1, 0);
567
568 if (sensor->hblank)
569 sensor->hblank->flags |= V4L2_CTRL_FLAG_UPDATE;
570
571 sensor->pixel_rate_parray = v4l2_ctrl_new_std(
572 &sensor->pixel_array->ctrl_handler, &smiapp_ctrl_ops,
573 V4L2_CID_PIXEL_RATE, 1, INT_MAX, 1, 1);
574
575 v4l2_ctrl_new_std_menu_items(&sensor->pixel_array->ctrl_handler,
576 &smiapp_ctrl_ops, V4L2_CID_TEST_PATTERN,
577 ARRAY_SIZE(smiapp_test_patterns) - 1,
578 0, 0, smiapp_test_patterns);
579
580 for (i = 0; i < ARRAY_SIZE(sensor->test_data); i++) {
581 int max_value = (1 << sensor->csi_format->width) - 1;
582 sensor->test_data[i] =
583 v4l2_ctrl_new_std(
584 &sensor->pixel_array->ctrl_handler,
585 &smiapp_ctrl_ops, V4L2_CID_TEST_PATTERN_RED + i,
586 0, max_value, 1, max_value);
587 }
588
589 if (sensor->pixel_array->ctrl_handler.error) {
590 dev_err(&client->dev,
591 "pixel array controls initialization failed (%d)\n",
592 sensor->pixel_array->ctrl_handler.error);
593 rval = sensor->pixel_array->ctrl_handler.error;
594 goto error;
595 }
596
597 sensor->pixel_array->sd.ctrl_handler =
598 &sensor->pixel_array->ctrl_handler;
599
600 v4l2_ctrl_cluster(2, &sensor->hflip);
601
602 rval = v4l2_ctrl_handler_init(&sensor->src->ctrl_handler, 0);
603 if (rval)
604 goto error;
605 sensor->src->ctrl_handler.lock = &sensor->mutex;
606
607 for (max = 0; sensor->platform_data->op_sys_clock[max + 1]; max++);
608
609 sensor->link_freq = v4l2_ctrl_new_int_menu(
610 &sensor->src->ctrl_handler, &smiapp_ctrl_ops,
611 V4L2_CID_LINK_FREQ, max, 0,
612 sensor->platform_data->op_sys_clock);
613
614 sensor->pixel_rate_csi = v4l2_ctrl_new_std(
615 &sensor->src->ctrl_handler, &smiapp_ctrl_ops,
616 V4L2_CID_PIXEL_RATE, 1, INT_MAX, 1, 1);
617
618 if (sensor->src->ctrl_handler.error) {
619 dev_err(&client->dev,
620 "src controls initialization failed (%d)\n",
621 sensor->src->ctrl_handler.error);
622 rval = sensor->src->ctrl_handler.error;
623 goto error;
624 }
625
626 sensor->src->sd.ctrl_handler =
627 &sensor->src->ctrl_handler;
628
629 return 0;
630
631error:
632 v4l2_ctrl_handler_free(&sensor->pixel_array->ctrl_handler);
633 v4l2_ctrl_handler_free(&sensor->src->ctrl_handler);
634
635 return rval;
636}
637
638static void smiapp_free_controls(struct smiapp_sensor *sensor)
639{
640 unsigned int i;
641
642 for (i = 0; i < sensor->ssds_used; i++)
643 v4l2_ctrl_handler_free(&sensor->ssds[i].ctrl_handler);
644}
645
646static int smiapp_get_limits(struct smiapp_sensor *sensor, int const *limit,
647 unsigned int n)
648{
649 struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
650 unsigned int i;
651 u32 val;
652 int rval;
653
654 for (i = 0; i < n; i++) {
655 rval = smiapp_read(
656 sensor, smiapp_reg_limits[limit[i]].addr, &val);
657 if (rval)
658 return rval;
659 sensor->limits[limit[i]] = val;
660 dev_dbg(&client->dev, "0x%8.8x \"%s\" = %u, 0x%x\n",
661 smiapp_reg_limits[limit[i]].addr,
662 smiapp_reg_limits[limit[i]].what, val, val);
663 }
664
665 return 0;
666}
667
668static int smiapp_get_all_limits(struct smiapp_sensor *sensor)
669{
670 unsigned int i;
671 int rval;
672
673 for (i = 0; i < SMIAPP_LIMIT_LAST; i++) {
674 rval = smiapp_get_limits(sensor, &i, 1);
675 if (rval < 0)
676 return rval;
677 }
678
679 if (sensor->limits[SMIAPP_LIMIT_SCALER_N_MIN] == 0)
680 smiapp_replace_limit(sensor, SMIAPP_LIMIT_SCALER_N_MIN, 16);
681
682 return 0;
683}
684
685static int smiapp_get_limits_binning(struct smiapp_sensor *sensor)
686{
687 struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
688 static u32 const limits[] = {
689 SMIAPP_LIMIT_MIN_FRAME_LENGTH_LINES_BIN,
690 SMIAPP_LIMIT_MAX_FRAME_LENGTH_LINES_BIN,
691 SMIAPP_LIMIT_MIN_LINE_LENGTH_PCK_BIN,
692 SMIAPP_LIMIT_MAX_LINE_LENGTH_PCK_BIN,
693 SMIAPP_LIMIT_MIN_LINE_BLANKING_PCK_BIN,
694 SMIAPP_LIMIT_FINE_INTEGRATION_TIME_MIN_BIN,
695 SMIAPP_LIMIT_FINE_INTEGRATION_TIME_MAX_MARGIN_BIN,
696 };
697 static u32 const limits_replace[] = {
698 SMIAPP_LIMIT_MIN_FRAME_LENGTH_LINES,
699 SMIAPP_LIMIT_MAX_FRAME_LENGTH_LINES,
700 SMIAPP_LIMIT_MIN_LINE_LENGTH_PCK,
701 SMIAPP_LIMIT_MAX_LINE_LENGTH_PCK,
702 SMIAPP_LIMIT_MIN_LINE_BLANKING_PCK,
703 SMIAPP_LIMIT_FINE_INTEGRATION_TIME_MIN,
704 SMIAPP_LIMIT_FINE_INTEGRATION_TIME_MAX_MARGIN,
705 };
706 unsigned int i;
707 int rval;
708
709 if (sensor->limits[SMIAPP_LIMIT_BINNING_CAPABILITY] ==
710 SMIAPP_BINNING_CAPABILITY_NO) {
711 for (i = 0; i < ARRAY_SIZE(limits); i++)
712 sensor->limits[limits[i]] =
713 sensor->limits[limits_replace[i]];
714
715 return 0;
716 }
717
718 rval = smiapp_get_limits(sensor, limits, ARRAY_SIZE(limits));
719 if (rval < 0)
720 return rval;
721
722
723
724
725
726 if (sensor->limits[SMIAPP_LIMIT_MIN_FRAME_LENGTH_LINES_BIN]
727 && sensor->limits[SMIAPP_LIMIT_MIN_LINE_LENGTH_PCK_BIN]
728 && sensor->limits[SMIAPP_LIMIT_MIN_LINE_BLANKING_PCK_BIN])
729 return 0;
730
731 for (i = 0; i < ARRAY_SIZE(limits); i++) {
732 dev_dbg(&client->dev,
733 "replace limit 0x%8.8x \"%s\" = %d, 0x%x\n",
734 smiapp_reg_limits[limits[i]].addr,
735 smiapp_reg_limits[limits[i]].what,
736 sensor->limits[limits_replace[i]],
737 sensor->limits[limits_replace[i]]);
738 sensor->limits[limits[i]] =
739 sensor->limits[limits_replace[i]];
740 }
741
742 return 0;
743}
744
745static int smiapp_get_mbus_formats(struct smiapp_sensor *sensor)
746{
747 struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
748 unsigned int type, n;
749 unsigned int i, pixel_order;
750 int rval;
751
752 rval = smiapp_read(
753 sensor, SMIAPP_REG_U8_DATA_FORMAT_MODEL_TYPE, &type);
754 if (rval)
755 return rval;
756
757 dev_dbg(&client->dev, "data_format_model_type %d\n", type);
758
759 rval = smiapp_read(sensor, SMIAPP_REG_U8_PIXEL_ORDER,
760 &pixel_order);
761 if (rval)
762 return rval;
763
764 if (pixel_order >= ARRAY_SIZE(pixel_order_str)) {
765 dev_dbg(&client->dev, "bad pixel order %d\n", pixel_order);
766 return -EINVAL;
767 }
768
769 dev_dbg(&client->dev, "pixel order %d (%s)\n", pixel_order,
770 pixel_order_str[pixel_order]);
771
772 switch (type) {
773 case SMIAPP_DATA_FORMAT_MODEL_TYPE_NORMAL:
774 n = SMIAPP_DATA_FORMAT_MODEL_TYPE_NORMAL_N;
775 break;
776 case SMIAPP_DATA_FORMAT_MODEL_TYPE_EXTENDED:
777 n = SMIAPP_DATA_FORMAT_MODEL_TYPE_EXTENDED_N;
778 break;
779 default:
780 return -EINVAL;
781 }
782
783 sensor->default_pixel_order = pixel_order;
784 sensor->mbus_frame_fmts = 0;
785
786 for (i = 0; i < n; i++) {
787 unsigned int fmt, j;
788
789 rval = smiapp_read(
790 sensor,
791 SMIAPP_REG_U16_DATA_FORMAT_DESCRIPTOR(i), &fmt);
792 if (rval)
793 return rval;
794
795 dev_dbg(&client->dev, "%u: bpp %u, compressed %u\n",
796 i, fmt >> 8, (u8)fmt);
797
798 for (j = 0; j < ARRAY_SIZE(smiapp_csi_data_formats); j++) {
799 const struct smiapp_csi_data_format *f =
800 &smiapp_csi_data_formats[j];
801
802 if (f->pixel_order != SMIAPP_PIXEL_ORDER_GRBG)
803 continue;
804
805 if (f->width != fmt >> 8 || f->compressed != (u8)fmt)
806 continue;
807
808 dev_dbg(&client->dev, "jolly good! %d\n", j);
809
810 sensor->default_mbus_frame_fmts |= 1 << j;
811 if (!sensor->csi_format
812 || f->width > sensor->csi_format->width
813 || (f->width == sensor->csi_format->width
814 && f->compressed
815 > sensor->csi_format->compressed)) {
816 sensor->csi_format = f;
817 sensor->internal_csi_format = f;
818 }
819 }
820 }
821
822 if (!sensor->csi_format) {
823 dev_err(&client->dev, "no supported mbus code found\n");
824 return -EINVAL;
825 }
826
827 smiapp_update_mbus_formats(sensor);
828
829 return 0;
830}
831
832static void smiapp_update_blanking(struct smiapp_sensor *sensor)
833{
834 struct v4l2_ctrl *vblank = sensor->vblank;
835 struct v4l2_ctrl *hblank = sensor->hblank;
836 int min, max;
837
838 min = max_t(int,
839 sensor->limits[SMIAPP_LIMIT_MIN_FRAME_BLANKING_LINES],
840 sensor->limits[SMIAPP_LIMIT_MIN_FRAME_LENGTH_LINES_BIN] -
841 sensor->pixel_array->crop[SMIAPP_PA_PAD_SRC].height);
842 max = sensor->limits[SMIAPP_LIMIT_MAX_FRAME_LENGTH_LINES_BIN] -
843 sensor->pixel_array->crop[SMIAPP_PA_PAD_SRC].height;
844
845 __v4l2_ctrl_modify_range(vblank, min, max, vblank->step, min);
846
847 min = max_t(int,
848 sensor->limits[SMIAPP_LIMIT_MIN_LINE_LENGTH_PCK_BIN] -
849 sensor->pixel_array->crop[SMIAPP_PA_PAD_SRC].width,
850 sensor->limits[SMIAPP_LIMIT_MIN_LINE_BLANKING_PCK_BIN]);
851 max = sensor->limits[SMIAPP_LIMIT_MAX_LINE_LENGTH_PCK_BIN] -
852 sensor->pixel_array->crop[SMIAPP_PA_PAD_SRC].width;
853
854 __v4l2_ctrl_modify_range(hblank, min, max, hblank->step, min);
855
856 __smiapp_update_exposure_limits(sensor);
857}
858
859static int smiapp_update_mode(struct smiapp_sensor *sensor)
860{
861 struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
862 unsigned int binning_mode;
863 int rval;
864
865 dev_dbg(&client->dev, "frame size: %dx%d\n",
866 sensor->src->crop[SMIAPP_PAD_SRC].width,
867 sensor->src->crop[SMIAPP_PAD_SRC].height);
868 dev_dbg(&client->dev, "csi format width: %d\n",
869 sensor->csi_format->width);
870
871
872 if (sensor->binning_horizontal == 1 &&
873 sensor->binning_vertical == 1) {
874 binning_mode = 0;
875 } else {
876 u8 binning_type =
877 (sensor->binning_horizontal << 4)
878 | sensor->binning_vertical;
879
880 rval = smiapp_write(
881 sensor, SMIAPP_REG_U8_BINNING_TYPE, binning_type);
882 if (rval < 0)
883 return rval;
884
885 binning_mode = 1;
886 }
887 rval = smiapp_write(sensor, SMIAPP_REG_U8_BINNING_MODE, binning_mode);
888 if (rval < 0)
889 return rval;
890
891
892 rval = smiapp_get_limits_binning(sensor);
893 if (rval < 0)
894 return rval;
895
896 rval = smiapp_pll_update(sensor);
897 if (rval < 0)
898 return rval;
899
900
901 smiapp_update_blanking(sensor);
902
903 dev_dbg(&client->dev, "vblank\t\t%d\n", sensor->vblank->val);
904 dev_dbg(&client->dev, "hblank\t\t%d\n", sensor->hblank->val);
905
906 dev_dbg(&client->dev, "real timeperframe\t100/%d\n",
907 sensor->pll.vt_pix_clk_freq_hz /
908 ((sensor->pixel_array->crop[SMIAPP_PA_PAD_SRC].width
909 + sensor->hblank->val) *
910 (sensor->pixel_array->crop[SMIAPP_PA_PAD_SRC].height
911 + sensor->vblank->val) / 100));
912
913 return 0;
914}
915
916
917
918
919
920
921static int smiapp_read_nvm(struct smiapp_sensor *sensor,
922 unsigned char *nvm)
923{
924 u32 i, s, p, np, v;
925 int rval = 0, rval2;
926
927 np = sensor->nvm_size / SMIAPP_NVM_PAGE_SIZE;
928 for (p = 0; p < np; p++) {
929 rval = smiapp_write(
930 sensor,
931 SMIAPP_REG_U8_DATA_TRANSFER_IF_1_PAGE_SELECT, p);
932 if (rval)
933 goto out;
934
935 rval = smiapp_write(sensor,
936 SMIAPP_REG_U8_DATA_TRANSFER_IF_1_CTRL,
937 SMIAPP_DATA_TRANSFER_IF_1_CTRL_EN |
938 SMIAPP_DATA_TRANSFER_IF_1_CTRL_RD_EN);
939 if (rval)
940 goto out;
941
942 for (i = 0; i < 1000; i++) {
943 rval = smiapp_read(
944 sensor,
945 SMIAPP_REG_U8_DATA_TRANSFER_IF_1_STATUS, &s);
946
947 if (rval)
948 goto out;
949
950 if (s & SMIAPP_DATA_TRANSFER_IF_1_STATUS_RD_READY)
951 break;
952
953 if (--i == 0) {
954 rval = -ETIMEDOUT;
955 goto out;
956 }
957
958 }
959
960 for (i = 0; i < SMIAPP_NVM_PAGE_SIZE; i++) {
961 rval = smiapp_read(
962 sensor,
963 SMIAPP_REG_U8_DATA_TRANSFER_IF_1_DATA_0 + i,
964 &v);
965 if (rval)
966 goto out;
967
968 *nvm++ = v;
969 }
970 }
971
972out:
973 rval2 = smiapp_write(sensor, SMIAPP_REG_U8_DATA_TRANSFER_IF_1_CTRL, 0);
974 if (rval < 0)
975 return rval;
976 else
977 return rval2;
978}
979
980
981
982
983
984
985static int smiapp_change_cci_addr(struct smiapp_sensor *sensor)
986{
987 struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
988 int rval;
989 u32 val;
990
991 client->addr = sensor->platform_data->i2c_addr_dfl;
992
993 rval = smiapp_write(sensor,
994 SMIAPP_REG_U8_CCI_ADDRESS_CONTROL,
995 sensor->platform_data->i2c_addr_alt << 1);
996 if (rval)
997 return rval;
998
999 client->addr = sensor->platform_data->i2c_addr_alt;
1000
1001
1002 rval = smiapp_read(sensor, SMIAPP_REG_U8_CCI_ADDRESS_CONTROL, &val);
1003 if (rval)
1004 return rval;
1005
1006 if (val != sensor->platform_data->i2c_addr_alt << 1)
1007 return -ENODEV;
1008
1009 return 0;
1010}
1011
1012
1013
1014
1015
1016
1017static int smiapp_setup_flash_strobe(struct smiapp_sensor *sensor)
1018{
1019 struct smiapp_flash_strobe_parms *strobe_setup;
1020 unsigned int ext_freq = sensor->platform_data->ext_clk;
1021 u32 tmp;
1022 u32 strobe_adjustment;
1023 u32 strobe_width_high_rs;
1024 int rval;
1025
1026 strobe_setup = sensor->platform_data->strobe_setup;
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097 tmp = div_u64(1000000ULL * ((1 << 16) - 1) * ((1 << 8) - 1) -
1098 1000000 + 1, ext_freq);
1099 strobe_setup->strobe_width_high_us =
1100 clamp_t(u32, strobe_setup->strobe_width_high_us, 1, tmp);
1101
1102 tmp = div_u64(((u64)strobe_setup->strobe_width_high_us * (u64)ext_freq +
1103 1000000 - 1), 1000000ULL);
1104 strobe_adjustment = (tmp + (1 << 16) - 1 - 1) / ((1 << 16) - 1);
1105 strobe_width_high_rs = (tmp + strobe_adjustment - 1) /
1106 strobe_adjustment;
1107
1108 rval = smiapp_write(sensor, SMIAPP_REG_U8_FLASH_MODE_RS,
1109 strobe_setup->mode);
1110 if (rval < 0)
1111 goto out;
1112
1113 rval = smiapp_write(sensor, SMIAPP_REG_U8_FLASH_STROBE_ADJUSTMENT,
1114 strobe_adjustment);
1115 if (rval < 0)
1116 goto out;
1117
1118 rval = smiapp_write(
1119 sensor, SMIAPP_REG_U16_TFLASH_STROBE_WIDTH_HIGH_RS_CTRL,
1120 strobe_width_high_rs);
1121 if (rval < 0)
1122 goto out;
1123
1124 rval = smiapp_write(sensor, SMIAPP_REG_U16_TFLASH_STROBE_DELAY_RS_CTRL,
1125 strobe_setup->strobe_delay);
1126 if (rval < 0)
1127 goto out;
1128
1129 rval = smiapp_write(sensor, SMIAPP_REG_U16_FLASH_STROBE_START_POINT,
1130 strobe_setup->stobe_start_point);
1131 if (rval < 0)
1132 goto out;
1133
1134 rval = smiapp_write(sensor, SMIAPP_REG_U8_FLASH_TRIGGER_RS,
1135 strobe_setup->trigger);
1136
1137out:
1138 sensor->platform_data->strobe_setup->trigger = 0;
1139
1140 return rval;
1141}
1142
1143
1144
1145
1146
1147static int smiapp_power_on(struct smiapp_sensor *sensor)
1148{
1149 struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
1150 unsigned int sleep;
1151 int rval;
1152
1153 rval = regulator_enable(sensor->vana);
1154 if (rval) {
1155 dev_err(&client->dev, "failed to enable vana regulator\n");
1156 return rval;
1157 }
1158 usleep_range(1000, 1000);
1159
1160 if (sensor->platform_data->set_xclk)
1161 rval = sensor->platform_data->set_xclk(
1162 &sensor->src->sd, sensor->platform_data->ext_clk);
1163 else
1164 rval = clk_prepare_enable(sensor->ext_clk);
1165 if (rval < 0) {
1166 dev_dbg(&client->dev, "failed to enable xclk\n");
1167 goto out_xclk_fail;
1168 }
1169 usleep_range(1000, 1000);
1170
1171 if (gpio_is_valid(sensor->platform_data->xshutdown))
1172 gpio_set_value(sensor->platform_data->xshutdown, 1);
1173
1174 sleep = SMIAPP_RESET_DELAY(sensor->platform_data->ext_clk);
1175 usleep_range(sleep, sleep);
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188 if (sensor->platform_data->i2c_addr_alt) {
1189 rval = smiapp_change_cci_addr(sensor);
1190 if (rval) {
1191 dev_err(&client->dev, "cci address change error\n");
1192 goto out_cci_addr_fail;
1193 }
1194 }
1195
1196 rval = smiapp_write(sensor, SMIAPP_REG_U8_SOFTWARE_RESET,
1197 SMIAPP_SOFTWARE_RESET);
1198 if (rval < 0) {
1199 dev_err(&client->dev, "software reset failed\n");
1200 goto out_cci_addr_fail;
1201 }
1202
1203 if (sensor->platform_data->i2c_addr_alt) {
1204 rval = smiapp_change_cci_addr(sensor);
1205 if (rval) {
1206 dev_err(&client->dev, "cci address change error\n");
1207 goto out_cci_addr_fail;
1208 }
1209 }
1210
1211 rval = smiapp_write(sensor, SMIAPP_REG_U16_COMPRESSION_MODE,
1212 SMIAPP_COMPRESSION_MODE_SIMPLE_PREDICTOR);
1213 if (rval) {
1214 dev_err(&client->dev, "compression mode set failed\n");
1215 goto out_cci_addr_fail;
1216 }
1217
1218 rval = smiapp_write(
1219 sensor, SMIAPP_REG_U16_EXTCLK_FREQUENCY_MHZ,
1220 sensor->platform_data->ext_clk / (1000000 / (1 << 8)));
1221 if (rval) {
1222 dev_err(&client->dev, "extclk frequency set failed\n");
1223 goto out_cci_addr_fail;
1224 }
1225
1226 rval = smiapp_write(sensor, SMIAPP_REG_U8_CSI_LANE_MODE,
1227 sensor->platform_data->lanes - 1);
1228 if (rval) {
1229 dev_err(&client->dev, "csi lane mode set failed\n");
1230 goto out_cci_addr_fail;
1231 }
1232
1233 rval = smiapp_write(sensor, SMIAPP_REG_U8_FAST_STANDBY_CTRL,
1234 SMIAPP_FAST_STANDBY_CTRL_IMMEDIATE);
1235 if (rval) {
1236 dev_err(&client->dev, "fast standby set failed\n");
1237 goto out_cci_addr_fail;
1238 }
1239
1240 rval = smiapp_write(sensor, SMIAPP_REG_U8_CSI_SIGNALLING_MODE,
1241 sensor->platform_data->csi_signalling_mode);
1242 if (rval) {
1243 dev_err(&client->dev, "csi signalling mode set failed\n");
1244 goto out_cci_addr_fail;
1245 }
1246
1247
1248 rval = smiapp_write(sensor, SMIAPP_REG_U8_DPHY_CTRL,
1249 SMIAPP_DPHY_CTRL_UI);
1250 if (rval < 0)
1251 return rval;
1252
1253 rval = smiapp_call_quirk(sensor, post_poweron);
1254 if (rval) {
1255 dev_err(&client->dev, "post_poweron quirks failed\n");
1256 goto out_cci_addr_fail;
1257 }
1258
1259
1260 if (!sensor->pixel_array)
1261 return 0;
1262
1263 rval = v4l2_ctrl_handler_setup(
1264 &sensor->pixel_array->ctrl_handler);
1265 if (rval)
1266 goto out_cci_addr_fail;
1267
1268 rval = v4l2_ctrl_handler_setup(&sensor->src->ctrl_handler);
1269 if (rval)
1270 goto out_cci_addr_fail;
1271
1272 mutex_lock(&sensor->mutex);
1273 rval = smiapp_update_mode(sensor);
1274 mutex_unlock(&sensor->mutex);
1275 if (rval < 0)
1276 goto out_cci_addr_fail;
1277
1278 return 0;
1279
1280out_cci_addr_fail:
1281 if (gpio_is_valid(sensor->platform_data->xshutdown))
1282 gpio_set_value(sensor->platform_data->xshutdown, 0);
1283 if (sensor->platform_data->set_xclk)
1284 sensor->platform_data->set_xclk(&sensor->src->sd, 0);
1285 else
1286 clk_disable_unprepare(sensor->ext_clk);
1287
1288out_xclk_fail:
1289 regulator_disable(sensor->vana);
1290 return rval;
1291}
1292
1293static void smiapp_power_off(struct smiapp_sensor *sensor)
1294{
1295
1296
1297
1298
1299
1300
1301
1302 if (sensor->platform_data->i2c_addr_alt)
1303 smiapp_write(sensor,
1304 SMIAPP_REG_U8_SOFTWARE_RESET,
1305 SMIAPP_SOFTWARE_RESET);
1306
1307 if (gpio_is_valid(sensor->platform_data->xshutdown))
1308 gpio_set_value(sensor->platform_data->xshutdown, 0);
1309 if (sensor->platform_data->set_xclk)
1310 sensor->platform_data->set_xclk(&sensor->src->sd, 0);
1311 else
1312 clk_disable_unprepare(sensor->ext_clk);
1313 usleep_range(5000, 5000);
1314 regulator_disable(sensor->vana);
1315 sensor->streaming = false;
1316}
1317
1318static int smiapp_set_power(struct v4l2_subdev *subdev, int on)
1319{
1320 struct smiapp_sensor *sensor = to_smiapp_sensor(subdev);
1321 int ret = 0;
1322
1323 mutex_lock(&sensor->power_mutex);
1324
1325 if (on && !sensor->power_count) {
1326
1327 ret = smiapp_power_on(sensor);
1328 if (ret < 0)
1329 goto out;
1330 } else if (!on && sensor->power_count == 1) {
1331 smiapp_power_off(sensor);
1332 }
1333
1334
1335 sensor->power_count += on ? 1 : -1;
1336 WARN_ON(sensor->power_count < 0);
1337
1338out:
1339 mutex_unlock(&sensor->power_mutex);
1340 return ret;
1341}
1342
1343
1344
1345
1346
1347static int smiapp_start_streaming(struct smiapp_sensor *sensor)
1348{
1349 struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
1350 int rval;
1351
1352 mutex_lock(&sensor->mutex);
1353
1354 rval = smiapp_write(sensor, SMIAPP_REG_U16_CSI_DATA_FORMAT,
1355 (sensor->csi_format->width << 8) |
1356 sensor->csi_format->compressed);
1357 if (rval)
1358 goto out;
1359
1360 rval = smiapp_pll_configure(sensor);
1361 if (rval)
1362 goto out;
1363
1364
1365 rval = smiapp_write(sensor, SMIAPP_REG_U16_X_ADDR_START,
1366 sensor->pixel_array->crop[SMIAPP_PA_PAD_SRC].left);
1367 if (rval < 0)
1368 goto out;
1369
1370 rval = smiapp_write(sensor, SMIAPP_REG_U16_Y_ADDR_START,
1371 sensor->pixel_array->crop[SMIAPP_PA_PAD_SRC].top);
1372 if (rval < 0)
1373 goto out;
1374
1375
1376 rval = smiapp_write(
1377 sensor, SMIAPP_REG_U16_X_ADDR_END,
1378 sensor->pixel_array->crop[SMIAPP_PA_PAD_SRC].left
1379 + sensor->pixel_array->crop[SMIAPP_PA_PAD_SRC].width - 1);
1380 if (rval < 0)
1381 goto out;
1382
1383 rval = smiapp_write(
1384 sensor, SMIAPP_REG_U16_Y_ADDR_END,
1385 sensor->pixel_array->crop[SMIAPP_PA_PAD_SRC].top
1386 + sensor->pixel_array->crop[SMIAPP_PA_PAD_SRC].height - 1);
1387 if (rval < 0)
1388 goto out;
1389
1390
1391
1392
1393
1394
1395
1396 if (sensor->limits[SMIAPP_LIMIT_DIGITAL_CROP_CAPABILITY]
1397 == SMIAPP_DIGITAL_CROP_CAPABILITY_INPUT_CROP) {
1398 rval = smiapp_write(
1399 sensor, SMIAPP_REG_U16_DIGITAL_CROP_X_OFFSET,
1400 sensor->scaler->crop[SMIAPP_PAD_SINK].left);
1401 if (rval < 0)
1402 goto out;
1403
1404 rval = smiapp_write(
1405 sensor, SMIAPP_REG_U16_DIGITAL_CROP_Y_OFFSET,
1406 sensor->scaler->crop[SMIAPP_PAD_SINK].top);
1407 if (rval < 0)
1408 goto out;
1409
1410 rval = smiapp_write(
1411 sensor, SMIAPP_REG_U16_DIGITAL_CROP_IMAGE_WIDTH,
1412 sensor->scaler->crop[SMIAPP_PAD_SINK].width);
1413 if (rval < 0)
1414 goto out;
1415
1416 rval = smiapp_write(
1417 sensor, SMIAPP_REG_U16_DIGITAL_CROP_IMAGE_HEIGHT,
1418 sensor->scaler->crop[SMIAPP_PAD_SINK].height);
1419 if (rval < 0)
1420 goto out;
1421 }
1422
1423
1424 if (sensor->limits[SMIAPP_LIMIT_SCALING_CAPABILITY]
1425 != SMIAPP_SCALING_CAPABILITY_NONE) {
1426 rval = smiapp_write(sensor, SMIAPP_REG_U16_SCALING_MODE,
1427 sensor->scaling_mode);
1428 if (rval < 0)
1429 goto out;
1430
1431 rval = smiapp_write(sensor, SMIAPP_REG_U16_SCALE_M,
1432 sensor->scale_m);
1433 if (rval < 0)
1434 goto out;
1435 }
1436
1437
1438 rval = smiapp_write(sensor, SMIAPP_REG_U16_X_OUTPUT_SIZE,
1439 sensor->src->crop[SMIAPP_PAD_SRC].width);
1440 if (rval < 0)
1441 goto out;
1442 rval = smiapp_write(sensor, SMIAPP_REG_U16_Y_OUTPUT_SIZE,
1443 sensor->src->crop[SMIAPP_PAD_SRC].height);
1444 if (rval < 0)
1445 goto out;
1446
1447 if ((sensor->flash_capability &
1448 (SMIAPP_FLASH_MODE_CAPABILITY_SINGLE_STROBE |
1449 SMIAPP_FLASH_MODE_CAPABILITY_MULTIPLE_STROBE)) &&
1450 sensor->platform_data->strobe_setup != NULL &&
1451 sensor->platform_data->strobe_setup->trigger != 0) {
1452 rval = smiapp_setup_flash_strobe(sensor);
1453 if (rval)
1454 goto out;
1455 }
1456
1457 rval = smiapp_call_quirk(sensor, pre_streamon);
1458 if (rval) {
1459 dev_err(&client->dev, "pre_streamon quirks failed\n");
1460 goto out;
1461 }
1462
1463 rval = smiapp_write(sensor, SMIAPP_REG_U8_MODE_SELECT,
1464 SMIAPP_MODE_SELECT_STREAMING);
1465
1466out:
1467 mutex_unlock(&sensor->mutex);
1468
1469 return rval;
1470}
1471
1472static int smiapp_stop_streaming(struct smiapp_sensor *sensor)
1473{
1474 struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
1475 int rval;
1476
1477 mutex_lock(&sensor->mutex);
1478 rval = smiapp_write(sensor, SMIAPP_REG_U8_MODE_SELECT,
1479 SMIAPP_MODE_SELECT_SOFTWARE_STANDBY);
1480 if (rval)
1481 goto out;
1482
1483 rval = smiapp_call_quirk(sensor, post_streamoff);
1484 if (rval)
1485 dev_err(&client->dev, "post_streamoff quirks failed\n");
1486
1487out:
1488 mutex_unlock(&sensor->mutex);
1489 return rval;
1490}
1491
1492
1493
1494
1495
1496static int smiapp_set_stream(struct v4l2_subdev *subdev, int enable)
1497{
1498 struct smiapp_sensor *sensor = to_smiapp_sensor(subdev);
1499 int rval;
1500
1501 if (sensor->streaming == enable)
1502 return 0;
1503
1504 if (enable) {
1505 sensor->streaming = true;
1506 rval = smiapp_start_streaming(sensor);
1507 if (rval < 0)
1508 sensor->streaming = false;
1509 } else {
1510 rval = smiapp_stop_streaming(sensor);
1511 sensor->streaming = false;
1512 }
1513
1514 return rval;
1515}
1516
1517static int smiapp_enum_mbus_code(struct v4l2_subdev *subdev,
1518 struct v4l2_subdev_fh *fh,
1519 struct v4l2_subdev_mbus_code_enum *code)
1520{
1521 struct i2c_client *client = v4l2_get_subdevdata(subdev);
1522 struct smiapp_sensor *sensor = to_smiapp_sensor(subdev);
1523 unsigned int i;
1524 int idx = -1;
1525 int rval = -EINVAL;
1526
1527 mutex_lock(&sensor->mutex);
1528
1529 dev_err(&client->dev, "subdev %s, pad %d, index %d\n",
1530 subdev->name, code->pad, code->index);
1531
1532 if (subdev != &sensor->src->sd || code->pad != SMIAPP_PAD_SRC) {
1533 if (code->index)
1534 goto out;
1535
1536 code->code = sensor->internal_csi_format->code;
1537 rval = 0;
1538 goto out;
1539 }
1540
1541 for (i = 0; i < ARRAY_SIZE(smiapp_csi_data_formats); i++) {
1542 if (sensor->mbus_frame_fmts & (1 << i))
1543 idx++;
1544
1545 if (idx == code->index) {
1546 code->code = smiapp_csi_data_formats[i].code;
1547 dev_err(&client->dev, "found index %d, i %d, code %x\n",
1548 code->index, i, code->code);
1549 rval = 0;
1550 break;
1551 }
1552 }
1553
1554out:
1555 mutex_unlock(&sensor->mutex);
1556
1557 return rval;
1558}
1559
1560static u32 __smiapp_get_mbus_code(struct v4l2_subdev *subdev,
1561 unsigned int pad)
1562{
1563 struct smiapp_sensor *sensor = to_smiapp_sensor(subdev);
1564
1565 if (subdev == &sensor->src->sd && pad == SMIAPP_PAD_SRC)
1566 return sensor->csi_format->code;
1567 else
1568 return sensor->internal_csi_format->code;
1569}
1570
1571static int __smiapp_get_format(struct v4l2_subdev *subdev,
1572 struct v4l2_subdev_fh *fh,
1573 struct v4l2_subdev_format *fmt)
1574{
1575 struct smiapp_subdev *ssd = to_smiapp_subdev(subdev);
1576
1577 if (fmt->which == V4L2_SUBDEV_FORMAT_TRY) {
1578 fmt->format = *v4l2_subdev_get_try_format(fh, fmt->pad);
1579 } else {
1580 struct v4l2_rect *r;
1581
1582 if (fmt->pad == ssd->source_pad)
1583 r = &ssd->crop[ssd->source_pad];
1584 else
1585 r = &ssd->sink_fmt;
1586
1587 fmt->format.code = __smiapp_get_mbus_code(subdev, fmt->pad);
1588 fmt->format.width = r->width;
1589 fmt->format.height = r->height;
1590 fmt->format.field = V4L2_FIELD_NONE;
1591 }
1592
1593 return 0;
1594}
1595
1596static int smiapp_get_format(struct v4l2_subdev *subdev,
1597 struct v4l2_subdev_fh *fh,
1598 struct v4l2_subdev_format *fmt)
1599{
1600 struct smiapp_sensor *sensor = to_smiapp_sensor(subdev);
1601 int rval;
1602
1603 mutex_lock(&sensor->mutex);
1604 rval = __smiapp_get_format(subdev, fh, fmt);
1605 mutex_unlock(&sensor->mutex);
1606
1607 return rval;
1608}
1609
1610static void smiapp_get_crop_compose(struct v4l2_subdev *subdev,
1611 struct v4l2_subdev_fh *fh,
1612 struct v4l2_rect **crops,
1613 struct v4l2_rect **comps, int which)
1614{
1615 struct smiapp_subdev *ssd = to_smiapp_subdev(subdev);
1616 unsigned int i;
1617
1618 if (which == V4L2_SUBDEV_FORMAT_ACTIVE) {
1619 if (crops)
1620 for (i = 0; i < subdev->entity.num_pads; i++)
1621 crops[i] = &ssd->crop[i];
1622 if (comps)
1623 *comps = &ssd->compose;
1624 } else {
1625 if (crops) {
1626 for (i = 0; i < subdev->entity.num_pads; i++) {
1627 crops[i] = v4l2_subdev_get_try_crop(fh, i);
1628 BUG_ON(!crops[i]);
1629 }
1630 }
1631 if (comps) {
1632 *comps = v4l2_subdev_get_try_compose(fh,
1633 SMIAPP_PAD_SINK);
1634 BUG_ON(!*comps);
1635 }
1636 }
1637}
1638
1639
1640static void smiapp_propagate(struct v4l2_subdev *subdev,
1641 struct v4l2_subdev_fh *fh, int which,
1642 int target)
1643{
1644 struct smiapp_sensor *sensor = to_smiapp_sensor(subdev);
1645 struct smiapp_subdev *ssd = to_smiapp_subdev(subdev);
1646 struct v4l2_rect *comp, *crops[SMIAPP_PADS];
1647
1648 smiapp_get_crop_compose(subdev, fh, crops, &comp, which);
1649
1650 switch (target) {
1651 case V4L2_SEL_TGT_CROP:
1652 comp->width = crops[SMIAPP_PAD_SINK]->width;
1653 comp->height = crops[SMIAPP_PAD_SINK]->height;
1654 if (which == V4L2_SUBDEV_FORMAT_ACTIVE) {
1655 if (ssd == sensor->scaler) {
1656 sensor->scale_m =
1657 sensor->limits[
1658 SMIAPP_LIMIT_SCALER_N_MIN];
1659 sensor->scaling_mode =
1660 SMIAPP_SCALING_MODE_NONE;
1661 } else if (ssd == sensor->binner) {
1662 sensor->binning_horizontal = 1;
1663 sensor->binning_vertical = 1;
1664 }
1665 }
1666
1667 case V4L2_SEL_TGT_COMPOSE:
1668 *crops[SMIAPP_PAD_SRC] = *comp;
1669 break;
1670 default:
1671 BUG();
1672 }
1673}
1674
1675static const struct smiapp_csi_data_format
1676*smiapp_validate_csi_data_format(struct smiapp_sensor *sensor, u32 code)
1677{
1678 const struct smiapp_csi_data_format *csi_format = sensor->csi_format;
1679 unsigned int i;
1680
1681 for (i = 0; i < ARRAY_SIZE(smiapp_csi_data_formats); i++) {
1682 if (sensor->mbus_frame_fmts & (1 << i)
1683 && smiapp_csi_data_formats[i].code == code)
1684 return &smiapp_csi_data_formats[i];
1685 }
1686
1687 return csi_format;
1688}
1689
1690static int smiapp_set_format(struct v4l2_subdev *subdev,
1691 struct v4l2_subdev_fh *fh,
1692 struct v4l2_subdev_format *fmt)
1693{
1694 struct smiapp_sensor *sensor = to_smiapp_sensor(subdev);
1695 struct smiapp_subdev *ssd = to_smiapp_subdev(subdev);
1696 struct v4l2_rect *crops[SMIAPP_PADS];
1697
1698 mutex_lock(&sensor->mutex);
1699
1700
1701
1702
1703
1704 if (fmt->pad == ssd->source_pad) {
1705 u32 code = fmt->format.code;
1706 int rval = __smiapp_get_format(subdev, fh, fmt);
1707 bool range_changed = false;
1708 unsigned int i;
1709
1710 if (!rval && subdev == &sensor->src->sd) {
1711 const struct smiapp_csi_data_format *csi_format =
1712 smiapp_validate_csi_data_format(sensor, code);
1713
1714 if (fmt->which == V4L2_SUBDEV_FORMAT_ACTIVE) {
1715 if (csi_format->width !=
1716 sensor->csi_format->width)
1717 range_changed = true;
1718
1719 sensor->csi_format = csi_format;
1720 }
1721
1722 fmt->format.code = csi_format->code;
1723 }
1724
1725 mutex_unlock(&sensor->mutex);
1726 if (rval || !range_changed)
1727 return rval;
1728
1729 for (i = 0; i < ARRAY_SIZE(sensor->test_data); i++)
1730 v4l2_ctrl_modify_range(
1731 sensor->test_data[i],
1732 0, (1 << sensor->csi_format->width) - 1, 1, 0);
1733
1734 return 0;
1735 }
1736
1737
1738 fmt->format.code = __smiapp_get_mbus_code(subdev, fmt->pad);
1739 fmt->format.width &= ~1;
1740 fmt->format.height &= ~1;
1741 fmt->format.field = V4L2_FIELD_NONE;
1742
1743 fmt->format.width =
1744 clamp(fmt->format.width,
1745 sensor->limits[SMIAPP_LIMIT_MIN_X_OUTPUT_SIZE],
1746 sensor->limits[SMIAPP_LIMIT_MAX_X_OUTPUT_SIZE]);
1747 fmt->format.height =
1748 clamp(fmt->format.height,
1749 sensor->limits[SMIAPP_LIMIT_MIN_Y_OUTPUT_SIZE],
1750 sensor->limits[SMIAPP_LIMIT_MAX_Y_OUTPUT_SIZE]);
1751
1752 smiapp_get_crop_compose(subdev, fh, crops, NULL, fmt->which);
1753
1754 crops[ssd->sink_pad]->left = 0;
1755 crops[ssd->sink_pad]->top = 0;
1756 crops[ssd->sink_pad]->width = fmt->format.width;
1757 crops[ssd->sink_pad]->height = fmt->format.height;
1758 if (fmt->which == V4L2_SUBDEV_FORMAT_ACTIVE)
1759 ssd->sink_fmt = *crops[ssd->sink_pad];
1760 smiapp_propagate(subdev, fh, fmt->which,
1761 V4L2_SEL_TGT_CROP);
1762
1763 mutex_unlock(&sensor->mutex);
1764
1765 return 0;
1766}
1767
1768
1769
1770
1771
1772#define SCALING_GOODNESS 100000
1773#define SCALING_GOODNESS_EXTREME 100000000
1774static int scaling_goodness(struct v4l2_subdev *subdev, int w, int ask_w,
1775 int h, int ask_h, u32 flags)
1776{
1777 struct smiapp_sensor *sensor = to_smiapp_sensor(subdev);
1778 struct i2c_client *client = v4l2_get_subdevdata(subdev);
1779 int val = 0;
1780
1781 w &= ~1;
1782 ask_w &= ~1;
1783 h &= ~1;
1784 ask_h &= ~1;
1785
1786 if (flags & V4L2_SEL_FLAG_GE) {
1787 if (w < ask_w)
1788 val -= SCALING_GOODNESS;
1789 if (h < ask_h)
1790 val -= SCALING_GOODNESS;
1791 }
1792
1793 if (flags & V4L2_SEL_FLAG_LE) {
1794 if (w > ask_w)
1795 val -= SCALING_GOODNESS;
1796 if (h > ask_h)
1797 val -= SCALING_GOODNESS;
1798 }
1799
1800 val -= abs(w - ask_w);
1801 val -= abs(h - ask_h);
1802
1803 if (w < sensor->limits[SMIAPP_LIMIT_MIN_X_OUTPUT_SIZE])
1804 val -= SCALING_GOODNESS_EXTREME;
1805
1806 dev_dbg(&client->dev, "w %d ask_w %d h %d ask_h %d goodness %d\n",
1807 w, ask_h, h, ask_h, val);
1808
1809 return val;
1810}
1811
1812static void smiapp_set_compose_binner(struct v4l2_subdev *subdev,
1813 struct v4l2_subdev_fh *fh,
1814 struct v4l2_subdev_selection *sel,
1815 struct v4l2_rect **crops,
1816 struct v4l2_rect *comp)
1817{
1818 struct smiapp_sensor *sensor = to_smiapp_sensor(subdev);
1819 unsigned int i;
1820 unsigned int binh = 1, binv = 1;
1821 int best = scaling_goodness(
1822 subdev,
1823 crops[SMIAPP_PAD_SINK]->width, sel->r.width,
1824 crops[SMIAPP_PAD_SINK]->height, sel->r.height, sel->flags);
1825
1826 for (i = 0; i < sensor->nbinning_subtypes; i++) {
1827 int this = scaling_goodness(
1828 subdev,
1829 crops[SMIAPP_PAD_SINK]->width
1830 / sensor->binning_subtypes[i].horizontal,
1831 sel->r.width,
1832 crops[SMIAPP_PAD_SINK]->height
1833 / sensor->binning_subtypes[i].vertical,
1834 sel->r.height, sel->flags);
1835
1836 if (this > best) {
1837 binh = sensor->binning_subtypes[i].horizontal;
1838 binv = sensor->binning_subtypes[i].vertical;
1839 best = this;
1840 }
1841 }
1842 if (sel->which == V4L2_SUBDEV_FORMAT_ACTIVE) {
1843 sensor->binning_vertical = binv;
1844 sensor->binning_horizontal = binh;
1845 }
1846
1847 sel->r.width = (crops[SMIAPP_PAD_SINK]->width / binh) & ~1;
1848 sel->r.height = (crops[SMIAPP_PAD_SINK]->height / binv) & ~1;
1849}
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860static void smiapp_set_compose_scaler(struct v4l2_subdev *subdev,
1861 struct v4l2_subdev_fh *fh,
1862 struct v4l2_subdev_selection *sel,
1863 struct v4l2_rect **crops,
1864 struct v4l2_rect *comp)
1865{
1866 struct i2c_client *client = v4l2_get_subdevdata(subdev);
1867 struct smiapp_sensor *sensor = to_smiapp_sensor(subdev);
1868 u32 min, max, a, b, max_m;
1869 u32 scale_m = sensor->limits[SMIAPP_LIMIT_SCALER_N_MIN];
1870 int mode = SMIAPP_SCALING_MODE_HORIZONTAL;
1871 u32 try[4];
1872 u32 ntry = 0;
1873 unsigned int i;
1874 int best = INT_MIN;
1875
1876 sel->r.width = min_t(unsigned int, sel->r.width,
1877 crops[SMIAPP_PAD_SINK]->width);
1878 sel->r.height = min_t(unsigned int, sel->r.height,
1879 crops[SMIAPP_PAD_SINK]->height);
1880
1881 a = crops[SMIAPP_PAD_SINK]->width
1882 * sensor->limits[SMIAPP_LIMIT_SCALER_N_MIN] / sel->r.width;
1883 b = crops[SMIAPP_PAD_SINK]->height
1884 * sensor->limits[SMIAPP_LIMIT_SCALER_N_MIN] / sel->r.height;
1885 max_m = crops[SMIAPP_PAD_SINK]->width
1886 * sensor->limits[SMIAPP_LIMIT_SCALER_N_MIN]
1887 / sensor->limits[SMIAPP_LIMIT_MIN_X_OUTPUT_SIZE];
1888
1889 a = clamp(a, sensor->limits[SMIAPP_LIMIT_SCALER_M_MIN],
1890 sensor->limits[SMIAPP_LIMIT_SCALER_M_MAX]);
1891 b = clamp(b, sensor->limits[SMIAPP_LIMIT_SCALER_M_MIN],
1892 sensor->limits[SMIAPP_LIMIT_SCALER_M_MAX]);
1893 max_m = clamp(max_m, sensor->limits[SMIAPP_LIMIT_SCALER_M_MIN],
1894 sensor->limits[SMIAPP_LIMIT_SCALER_M_MAX]);
1895
1896 dev_dbg(&client->dev, "scaling: a %d b %d max_m %d\n", a, b, max_m);
1897
1898 min = min(max_m, min(a, b));
1899 max = min(max_m, max(a, b));
1900
1901 try[ntry] = min;
1902 ntry++;
1903 if (min != max) {
1904 try[ntry] = max;
1905 ntry++;
1906 }
1907 if (max != max_m) {
1908 try[ntry] = min + 1;
1909 ntry++;
1910 if (min != max) {
1911 try[ntry] = max + 1;
1912 ntry++;
1913 }
1914 }
1915
1916 for (i = 0; i < ntry; i++) {
1917 int this = scaling_goodness(
1918 subdev,
1919 crops[SMIAPP_PAD_SINK]->width
1920 / try[i]
1921 * sensor->limits[SMIAPP_LIMIT_SCALER_N_MIN],
1922 sel->r.width,
1923 crops[SMIAPP_PAD_SINK]->height,
1924 sel->r.height,
1925 sel->flags);
1926
1927 dev_dbg(&client->dev, "trying factor %d (%d)\n", try[i], i);
1928
1929 if (this > best) {
1930 scale_m = try[i];
1931 mode = SMIAPP_SCALING_MODE_HORIZONTAL;
1932 best = this;
1933 }
1934
1935 if (sensor->limits[SMIAPP_LIMIT_SCALING_CAPABILITY]
1936 == SMIAPP_SCALING_CAPABILITY_HORIZONTAL)
1937 continue;
1938
1939 this = scaling_goodness(
1940 subdev, crops[SMIAPP_PAD_SINK]->width
1941 / try[i]
1942 * sensor->limits[SMIAPP_LIMIT_SCALER_N_MIN],
1943 sel->r.width,
1944 crops[SMIAPP_PAD_SINK]->height
1945 / try[i]
1946 * sensor->limits[SMIAPP_LIMIT_SCALER_N_MIN],
1947 sel->r.height,
1948 sel->flags);
1949
1950 if (this > best) {
1951 scale_m = try[i];
1952 mode = SMIAPP_SCALING_MODE_BOTH;
1953 best = this;
1954 }
1955 }
1956
1957 sel->r.width =
1958 (crops[SMIAPP_PAD_SINK]->width
1959 / scale_m
1960 * sensor->limits[SMIAPP_LIMIT_SCALER_N_MIN]) & ~1;
1961 if (mode == SMIAPP_SCALING_MODE_BOTH)
1962 sel->r.height =
1963 (crops[SMIAPP_PAD_SINK]->height
1964 / scale_m
1965 * sensor->limits[SMIAPP_LIMIT_SCALER_N_MIN])
1966 & ~1;
1967 else
1968 sel->r.height = crops[SMIAPP_PAD_SINK]->height;
1969
1970 if (sel->which == V4L2_SUBDEV_FORMAT_ACTIVE) {
1971 sensor->scale_m = scale_m;
1972 sensor->scaling_mode = mode;
1973 }
1974}
1975
1976static int smiapp_set_compose(struct v4l2_subdev *subdev,
1977 struct v4l2_subdev_fh *fh,
1978 struct v4l2_subdev_selection *sel)
1979{
1980 struct smiapp_sensor *sensor = to_smiapp_sensor(subdev);
1981 struct smiapp_subdev *ssd = to_smiapp_subdev(subdev);
1982 struct v4l2_rect *comp, *crops[SMIAPP_PADS];
1983
1984 smiapp_get_crop_compose(subdev, fh, crops, &comp, sel->which);
1985
1986 sel->r.top = 0;
1987 sel->r.left = 0;
1988
1989 if (ssd == sensor->binner)
1990 smiapp_set_compose_binner(subdev, fh, sel, crops, comp);
1991 else
1992 smiapp_set_compose_scaler(subdev, fh, sel, crops, comp);
1993
1994 *comp = sel->r;
1995 smiapp_propagate(subdev, fh, sel->which,
1996 V4L2_SEL_TGT_COMPOSE);
1997
1998 if (sel->which == V4L2_SUBDEV_FORMAT_ACTIVE)
1999 return smiapp_update_mode(sensor);
2000
2001 return 0;
2002}
2003
2004static int __smiapp_sel_supported(struct v4l2_subdev *subdev,
2005 struct v4l2_subdev_selection *sel)
2006{
2007 struct smiapp_sensor *sensor = to_smiapp_sensor(subdev);
2008 struct smiapp_subdev *ssd = to_smiapp_subdev(subdev);
2009
2010
2011 switch (sel->target) {
2012 case V4L2_SEL_TGT_CROP:
2013 case V4L2_SEL_TGT_CROP_BOUNDS:
2014 if (ssd == sensor->pixel_array
2015 && sel->pad == SMIAPP_PA_PAD_SRC)
2016 return 0;
2017 if (ssd == sensor->src
2018 && sel->pad == SMIAPP_PAD_SRC)
2019 return 0;
2020 if (ssd == sensor->scaler
2021 && sel->pad == SMIAPP_PAD_SINK
2022 && sensor->limits[SMIAPP_LIMIT_DIGITAL_CROP_CAPABILITY]
2023 == SMIAPP_DIGITAL_CROP_CAPABILITY_INPUT_CROP)
2024 return 0;
2025 return -EINVAL;
2026 case V4L2_SEL_TGT_COMPOSE:
2027 case V4L2_SEL_TGT_COMPOSE_BOUNDS:
2028 if (sel->pad == ssd->source_pad)
2029 return -EINVAL;
2030 if (ssd == sensor->binner)
2031 return 0;
2032 if (ssd == sensor->scaler
2033 && sensor->limits[SMIAPP_LIMIT_SCALING_CAPABILITY]
2034 != SMIAPP_SCALING_CAPABILITY_NONE)
2035 return 0;
2036
2037 default:
2038 return -EINVAL;
2039 }
2040}
2041
2042static int smiapp_set_crop(struct v4l2_subdev *subdev,
2043 struct v4l2_subdev_fh *fh,
2044 struct v4l2_subdev_selection *sel)
2045{
2046 struct smiapp_sensor *sensor = to_smiapp_sensor(subdev);
2047 struct smiapp_subdev *ssd = to_smiapp_subdev(subdev);
2048 struct v4l2_rect *src_size, *crops[SMIAPP_PADS];
2049 struct v4l2_rect _r;
2050
2051 smiapp_get_crop_compose(subdev, fh, crops, NULL, sel->which);
2052
2053 if (sel->which == V4L2_SUBDEV_FORMAT_ACTIVE) {
2054 if (sel->pad == ssd->sink_pad)
2055 src_size = &ssd->sink_fmt;
2056 else
2057 src_size = &ssd->compose;
2058 } else {
2059 if (sel->pad == ssd->sink_pad) {
2060 _r.left = 0;
2061 _r.top = 0;
2062 _r.width = v4l2_subdev_get_try_format(fh, sel->pad)
2063 ->width;
2064 _r.height = v4l2_subdev_get_try_format(fh, sel->pad)
2065 ->height;
2066 src_size = &_r;
2067 } else {
2068 src_size =
2069 v4l2_subdev_get_try_compose(
2070 fh, ssd->sink_pad);
2071 }
2072 }
2073
2074 if (ssd == sensor->src && sel->pad == SMIAPP_PAD_SRC) {
2075 sel->r.left = 0;
2076 sel->r.top = 0;
2077 }
2078
2079 sel->r.width = min(sel->r.width, src_size->width);
2080 sel->r.height = min(sel->r.height, src_size->height);
2081
2082 sel->r.left = min_t(int, sel->r.left, src_size->width - sel->r.width);
2083 sel->r.top = min_t(int, sel->r.top, src_size->height - sel->r.height);
2084
2085 *crops[sel->pad] = sel->r;
2086
2087 if (ssd != sensor->pixel_array && sel->pad == SMIAPP_PAD_SINK)
2088 smiapp_propagate(subdev, fh, sel->which,
2089 V4L2_SEL_TGT_CROP);
2090
2091 return 0;
2092}
2093
2094static int __smiapp_get_selection(struct v4l2_subdev *subdev,
2095 struct v4l2_subdev_fh *fh,
2096 struct v4l2_subdev_selection *sel)
2097{
2098 struct smiapp_sensor *sensor = to_smiapp_sensor(subdev);
2099 struct smiapp_subdev *ssd = to_smiapp_subdev(subdev);
2100 struct v4l2_rect *comp, *crops[SMIAPP_PADS];
2101 struct v4l2_rect sink_fmt;
2102 int ret;
2103
2104 ret = __smiapp_sel_supported(subdev, sel);
2105 if (ret)
2106 return ret;
2107
2108 smiapp_get_crop_compose(subdev, fh, crops, &comp, sel->which);
2109
2110 if (sel->which == V4L2_SUBDEV_FORMAT_ACTIVE) {
2111 sink_fmt = ssd->sink_fmt;
2112 } else {
2113 struct v4l2_mbus_framefmt *fmt =
2114 v4l2_subdev_get_try_format(fh, ssd->sink_pad);
2115
2116 sink_fmt.left = 0;
2117 sink_fmt.top = 0;
2118 sink_fmt.width = fmt->width;
2119 sink_fmt.height = fmt->height;
2120 }
2121
2122 switch (sel->target) {
2123 case V4L2_SEL_TGT_CROP_BOUNDS:
2124 if (ssd == sensor->pixel_array) {
2125 sel->r.width =
2126 sensor->limits[SMIAPP_LIMIT_X_ADDR_MAX] + 1;
2127 sel->r.height =
2128 sensor->limits[SMIAPP_LIMIT_Y_ADDR_MAX] + 1;
2129 } else if (sel->pad == ssd->sink_pad) {
2130 sel->r = sink_fmt;
2131 } else {
2132 sel->r = *comp;
2133 }
2134 break;
2135 case V4L2_SEL_TGT_CROP:
2136 case V4L2_SEL_TGT_COMPOSE_BOUNDS:
2137 sel->r = *crops[sel->pad];
2138 break;
2139 case V4L2_SEL_TGT_COMPOSE:
2140 sel->r = *comp;
2141 break;
2142 }
2143
2144 return 0;
2145}
2146
2147static int smiapp_get_selection(struct v4l2_subdev *subdev,
2148 struct v4l2_subdev_fh *fh,
2149 struct v4l2_subdev_selection *sel)
2150{
2151 struct smiapp_sensor *sensor = to_smiapp_sensor(subdev);
2152 int rval;
2153
2154 mutex_lock(&sensor->mutex);
2155 rval = __smiapp_get_selection(subdev, fh, sel);
2156 mutex_unlock(&sensor->mutex);
2157
2158 return rval;
2159}
2160static int smiapp_set_selection(struct v4l2_subdev *subdev,
2161 struct v4l2_subdev_fh *fh,
2162 struct v4l2_subdev_selection *sel)
2163{
2164 struct smiapp_sensor *sensor = to_smiapp_sensor(subdev);
2165 int ret;
2166
2167 ret = __smiapp_sel_supported(subdev, sel);
2168 if (ret)
2169 return ret;
2170
2171 mutex_lock(&sensor->mutex);
2172
2173 sel->r.left = max(0, sel->r.left & ~1);
2174 sel->r.top = max(0, sel->r.top & ~1);
2175 sel->r.width = SMIAPP_ALIGN_DIM(sel->r.width, sel->flags);
2176 sel->r.height = SMIAPP_ALIGN_DIM(sel->r.height, sel->flags);
2177
2178 sel->r.width = max_t(unsigned int,
2179 sensor->limits[SMIAPP_LIMIT_MIN_X_OUTPUT_SIZE],
2180 sel->r.width);
2181 sel->r.height = max_t(unsigned int,
2182 sensor->limits[SMIAPP_LIMIT_MIN_Y_OUTPUT_SIZE],
2183 sel->r.height);
2184
2185 switch (sel->target) {
2186 case V4L2_SEL_TGT_CROP:
2187 ret = smiapp_set_crop(subdev, fh, sel);
2188 break;
2189 case V4L2_SEL_TGT_COMPOSE:
2190 ret = smiapp_set_compose(subdev, fh, sel);
2191 break;
2192 default:
2193 ret = -EINVAL;
2194 }
2195
2196 mutex_unlock(&sensor->mutex);
2197 return ret;
2198}
2199
2200static int smiapp_get_skip_frames(struct v4l2_subdev *subdev, u32 *frames)
2201{
2202 struct smiapp_sensor *sensor = to_smiapp_sensor(subdev);
2203
2204 *frames = sensor->frame_skip;
2205 return 0;
2206}
2207
2208
2209
2210
2211
2212static ssize_t
2213smiapp_sysfs_nvm_read(struct device *dev, struct device_attribute *attr,
2214 char *buf)
2215{
2216 struct v4l2_subdev *subdev = i2c_get_clientdata(to_i2c_client(dev));
2217 struct i2c_client *client = v4l2_get_subdevdata(subdev);
2218 struct smiapp_sensor *sensor = to_smiapp_sensor(subdev);
2219 unsigned int nbytes;
2220
2221 if (!sensor->dev_init_done)
2222 return -EBUSY;
2223
2224 if (!sensor->nvm_size) {
2225
2226 sensor->nvm_size = sensor->platform_data->nvm_size;
2227 if (smiapp_set_power(subdev, 1) < 0)
2228 return -ENODEV;
2229 if (smiapp_read_nvm(sensor, sensor->nvm)) {
2230 dev_err(&client->dev, "nvm read failed\n");
2231 return -ENODEV;
2232 }
2233 smiapp_set_power(subdev, 0);
2234 }
2235
2236
2237
2238
2239 nbytes = min_t(unsigned int, sensor->nvm_size, PAGE_SIZE);
2240 memcpy(buf, sensor->nvm, nbytes);
2241
2242 return nbytes;
2243}
2244static DEVICE_ATTR(nvm, S_IRUGO, smiapp_sysfs_nvm_read, NULL);
2245
2246static ssize_t
2247smiapp_sysfs_ident_read(struct device *dev, struct device_attribute *attr,
2248 char *buf)
2249{
2250 struct v4l2_subdev *subdev = i2c_get_clientdata(to_i2c_client(dev));
2251 struct smiapp_sensor *sensor = to_smiapp_sensor(subdev);
2252 struct smiapp_module_info *minfo = &sensor->minfo;
2253
2254 return snprintf(buf, PAGE_SIZE, "%2.2x%4.4x%2.2x\n",
2255 minfo->manufacturer_id, minfo->model_id,
2256 minfo->revision_number_major) + 1;
2257}
2258
2259static DEVICE_ATTR(ident, S_IRUGO, smiapp_sysfs_ident_read, NULL);
2260
2261
2262
2263
2264
2265static int smiapp_identify_module(struct v4l2_subdev *subdev)
2266{
2267 struct smiapp_sensor *sensor = to_smiapp_sensor(subdev);
2268 struct i2c_client *client = v4l2_get_subdevdata(subdev);
2269 struct smiapp_module_info *minfo = &sensor->minfo;
2270 unsigned int i;
2271 int rval = 0;
2272
2273 minfo->name = SMIAPP_NAME;
2274
2275
2276 rval = smiapp_read_8only(sensor, SMIAPP_REG_U8_MANUFACTURER_ID,
2277 &minfo->manufacturer_id);
2278 if (!rval)
2279 rval = smiapp_read_8only(sensor, SMIAPP_REG_U16_MODEL_ID,
2280 &minfo->model_id);
2281 if (!rval)
2282 rval = smiapp_read_8only(sensor,
2283 SMIAPP_REG_U8_REVISION_NUMBER_MAJOR,
2284 &minfo->revision_number_major);
2285 if (!rval)
2286 rval = smiapp_read_8only(sensor,
2287 SMIAPP_REG_U8_REVISION_NUMBER_MINOR,
2288 &minfo->revision_number_minor);
2289 if (!rval)
2290 rval = smiapp_read_8only(sensor,
2291 SMIAPP_REG_U8_MODULE_DATE_YEAR,
2292 &minfo->module_year);
2293 if (!rval)
2294 rval = smiapp_read_8only(sensor,
2295 SMIAPP_REG_U8_MODULE_DATE_MONTH,
2296 &minfo->module_month);
2297 if (!rval)
2298 rval = smiapp_read_8only(sensor, SMIAPP_REG_U8_MODULE_DATE_DAY,
2299 &minfo->module_day);
2300
2301
2302 if (!rval)
2303 rval = smiapp_read_8only(sensor,
2304 SMIAPP_REG_U8_SENSOR_MANUFACTURER_ID,
2305 &minfo->sensor_manufacturer_id);
2306 if (!rval)
2307 rval = smiapp_read_8only(sensor,
2308 SMIAPP_REG_U16_SENSOR_MODEL_ID,
2309 &minfo->sensor_model_id);
2310 if (!rval)
2311 rval = smiapp_read_8only(sensor,
2312 SMIAPP_REG_U8_SENSOR_REVISION_NUMBER,
2313 &minfo->sensor_revision_number);
2314 if (!rval)
2315 rval = smiapp_read_8only(sensor,
2316 SMIAPP_REG_U8_SENSOR_FIRMWARE_VERSION,
2317 &minfo->sensor_firmware_version);
2318
2319
2320 if (!rval)
2321 rval = smiapp_read_8only(sensor, SMIAPP_REG_U8_SMIA_VERSION,
2322 &minfo->smia_version);
2323 if (!rval)
2324 rval = smiapp_read_8only(sensor, SMIAPP_REG_U8_SMIAPP_VERSION,
2325 &minfo->smiapp_version);
2326
2327 if (rval) {
2328 dev_err(&client->dev, "sensor detection failed\n");
2329 return -ENODEV;
2330 }
2331
2332 dev_dbg(&client->dev, "module 0x%2.2x-0x%4.4x\n",
2333 minfo->manufacturer_id, minfo->model_id);
2334
2335 dev_dbg(&client->dev,
2336 "module revision 0x%2.2x-0x%2.2x date %2.2d-%2.2d-%2.2d\n",
2337 minfo->revision_number_major, minfo->revision_number_minor,
2338 minfo->module_year, minfo->module_month, minfo->module_day);
2339
2340 dev_dbg(&client->dev, "sensor 0x%2.2x-0x%4.4x\n",
2341 minfo->sensor_manufacturer_id, minfo->sensor_model_id);
2342
2343 dev_dbg(&client->dev,
2344 "sensor revision 0x%2.2x firmware version 0x%2.2x\n",
2345 minfo->sensor_revision_number, minfo->sensor_firmware_version);
2346
2347 dev_dbg(&client->dev, "smia version %2.2d smiapp version %2.2d\n",
2348 minfo->smia_version, minfo->smiapp_version);
2349
2350
2351
2352
2353
2354
2355 if (!minfo->manufacturer_id && !minfo->model_id) {
2356 minfo->manufacturer_id = minfo->sensor_manufacturer_id;
2357 minfo->model_id = minfo->sensor_model_id;
2358 minfo->revision_number_major = minfo->sensor_revision_number;
2359 }
2360
2361 for (i = 0; i < ARRAY_SIZE(smiapp_module_idents); i++) {
2362 if (smiapp_module_idents[i].manufacturer_id
2363 != minfo->manufacturer_id)
2364 continue;
2365 if (smiapp_module_idents[i].model_id != minfo->model_id)
2366 continue;
2367 if (smiapp_module_idents[i].flags
2368 & SMIAPP_MODULE_IDENT_FLAG_REV_LE) {
2369 if (smiapp_module_idents[i].revision_number_major
2370 < minfo->revision_number_major)
2371 continue;
2372 } else {
2373 if (smiapp_module_idents[i].revision_number_major
2374 != minfo->revision_number_major)
2375 continue;
2376 }
2377
2378 minfo->name = smiapp_module_idents[i].name;
2379 minfo->quirk = smiapp_module_idents[i].quirk;
2380 break;
2381 }
2382
2383 if (i >= ARRAY_SIZE(smiapp_module_idents))
2384 dev_warn(&client->dev,
2385 "no quirks for this module; let's hope it's fully compliant\n");
2386
2387 dev_dbg(&client->dev, "the sensor is called %s, ident %2.2x%4.4x%2.2x\n",
2388 minfo->name, minfo->manufacturer_id, minfo->model_id,
2389 minfo->revision_number_major);
2390
2391 strlcpy(subdev->name, sensor->minfo.name, sizeof(subdev->name));
2392
2393 return 0;
2394}
2395
2396static const struct v4l2_subdev_ops smiapp_ops;
2397static const struct v4l2_subdev_internal_ops smiapp_internal_ops;
2398static const struct media_entity_operations smiapp_entity_ops;
2399
2400static int smiapp_registered(struct v4l2_subdev *subdev)
2401{
2402 struct smiapp_sensor *sensor = to_smiapp_sensor(subdev);
2403 struct i2c_client *client = v4l2_get_subdevdata(subdev);
2404 struct smiapp_pll *pll = &sensor->pll;
2405 struct smiapp_subdev *last = NULL;
2406 u32 tmp;
2407 unsigned int i;
2408 int rval;
2409
2410 sensor->vana = devm_regulator_get(&client->dev, "vana");
2411 if (IS_ERR(sensor->vana)) {
2412 dev_err(&client->dev, "could not get regulator for vana\n");
2413 return PTR_ERR(sensor->vana);
2414 }
2415
2416 if (!sensor->platform_data->set_xclk) {
2417 sensor->ext_clk = devm_clk_get(&client->dev, "ext_clk");
2418 if (IS_ERR(sensor->ext_clk)) {
2419 dev_err(&client->dev, "could not get clock\n");
2420 return PTR_ERR(sensor->ext_clk);
2421 }
2422
2423 rval = clk_set_rate(sensor->ext_clk,
2424 sensor->platform_data->ext_clk);
2425 if (rval < 0) {
2426 dev_err(&client->dev,
2427 "unable to set clock freq to %u\n",
2428 sensor->platform_data->ext_clk);
2429 return rval;
2430 }
2431 }
2432
2433 if (gpio_is_valid(sensor->platform_data->xshutdown)) {
2434 rval = devm_gpio_request_one(
2435 &client->dev, sensor->platform_data->xshutdown, 0,
2436 "SMIA++ xshutdown");
2437 if (rval < 0) {
2438 dev_err(&client->dev,
2439 "unable to acquire reset gpio %d\n",
2440 sensor->platform_data->xshutdown);
2441 return rval;
2442 }
2443 }
2444
2445 rval = smiapp_power_on(sensor);
2446 if (rval)
2447 return -ENODEV;
2448
2449 rval = smiapp_identify_module(subdev);
2450 if (rval) {
2451 rval = -ENODEV;
2452 goto out_power_off;
2453 }
2454
2455 rval = smiapp_get_all_limits(sensor);
2456 if (rval) {
2457 rval = -ENODEV;
2458 goto out_power_off;
2459 }
2460
2461
2462
2463
2464
2465
2466
2467
2468
2469
2470
2471
2472
2473
2474 if (sensor->platform_data->module_board_orient ==
2475 SMIAPP_MODULE_BOARD_ORIENT_180)
2476 sensor->hvflip_inv_mask = SMIAPP_IMAGE_ORIENTATION_HFLIP |
2477 SMIAPP_IMAGE_ORIENTATION_VFLIP;
2478
2479 rval = smiapp_call_quirk(sensor, limits);
2480 if (rval) {
2481 dev_err(&client->dev, "limits quirks failed\n");
2482 goto out_power_off;
2483 }
2484
2485 rval = smiapp_get_mbus_formats(sensor);
2486 if (rval) {
2487 rval = -ENODEV;
2488 goto out_power_off;
2489 }
2490
2491 if (sensor->limits[SMIAPP_LIMIT_BINNING_CAPABILITY]) {
2492 u32 val;
2493
2494 rval = smiapp_read(sensor,
2495 SMIAPP_REG_U8_BINNING_SUBTYPES, &val);
2496 if (rval < 0) {
2497 rval = -ENODEV;
2498 goto out_power_off;
2499 }
2500 sensor->nbinning_subtypes = min_t(u8, val,
2501 SMIAPP_BINNING_SUBTYPES);
2502
2503 for (i = 0; i < sensor->nbinning_subtypes; i++) {
2504 rval = smiapp_read(
2505 sensor, SMIAPP_REG_U8_BINNING_TYPE_n(i), &val);
2506 if (rval < 0) {
2507 rval = -ENODEV;
2508 goto out_power_off;
2509 }
2510 sensor->binning_subtypes[i] =
2511 *(struct smiapp_binning_subtype *)&val;
2512
2513 dev_dbg(&client->dev, "binning %xx%x\n",
2514 sensor->binning_subtypes[i].horizontal,
2515 sensor->binning_subtypes[i].vertical);
2516 }
2517 }
2518 sensor->binning_horizontal = 1;
2519 sensor->binning_vertical = 1;
2520
2521 if (device_create_file(&client->dev, &dev_attr_ident) != 0) {
2522 dev_err(&client->dev, "sysfs ident entry creation failed\n");
2523 rval = -ENOENT;
2524 goto out_power_off;
2525 }
2526
2527
2528
2529 if (sensor->minfo.smiapp_version && sensor->platform_data->nvm_size) {
2530 sensor->nvm = devm_kzalloc(&client->dev,
2531 sensor->platform_data->nvm_size, GFP_KERNEL);
2532 if (sensor->nvm == NULL) {
2533 dev_err(&client->dev, "nvm buf allocation failed\n");
2534 rval = -ENOMEM;
2535 goto out_ident_release;
2536 }
2537
2538 if (device_create_file(&client->dev, &dev_attr_nvm) != 0) {
2539 dev_err(&client->dev, "sysfs nvm entry failed\n");
2540 rval = -EBUSY;
2541 goto out_ident_release;
2542 }
2543 }
2544
2545
2546 if (!sensor->limits[SMIAPP_LIMIT_MIN_OP_SYS_CLK_DIV] ||
2547 !sensor->limits[SMIAPP_LIMIT_MAX_OP_SYS_CLK_DIV] ||
2548 !sensor->limits[SMIAPP_LIMIT_MIN_OP_PIX_CLK_DIV] ||
2549 !sensor->limits[SMIAPP_LIMIT_MAX_OP_PIX_CLK_DIV]) {
2550 sensor->minfo.smiapp_profile = SMIAPP_PROFILE_0;
2551 } else if (sensor->limits[SMIAPP_LIMIT_SCALING_CAPABILITY]
2552 != SMIAPP_SCALING_CAPABILITY_NONE) {
2553 if (sensor->limits[SMIAPP_LIMIT_SCALING_CAPABILITY]
2554 == SMIAPP_SCALING_CAPABILITY_HORIZONTAL)
2555 sensor->minfo.smiapp_profile = SMIAPP_PROFILE_1;
2556 else
2557 sensor->minfo.smiapp_profile = SMIAPP_PROFILE_2;
2558 sensor->scaler = &sensor->ssds[sensor->ssds_used];
2559 sensor->ssds_used++;
2560 } else if (sensor->limits[SMIAPP_LIMIT_DIGITAL_CROP_CAPABILITY]
2561 == SMIAPP_DIGITAL_CROP_CAPABILITY_INPUT_CROP) {
2562 sensor->scaler = &sensor->ssds[sensor->ssds_used];
2563 sensor->ssds_used++;
2564 }
2565 sensor->binner = &sensor->ssds[sensor->ssds_used];
2566 sensor->ssds_used++;
2567 sensor->pixel_array = &sensor->ssds[sensor->ssds_used];
2568 sensor->ssds_used++;
2569
2570 sensor->scale_m = sensor->limits[SMIAPP_LIMIT_SCALER_N_MIN];
2571
2572 for (i = 0; i < SMIAPP_SUBDEVS; i++) {
2573 struct {
2574 struct smiapp_subdev *ssd;
2575 char *name;
2576 } const __this[] = {
2577 { sensor->scaler, "scaler", },
2578 { sensor->binner, "binner", },
2579 { sensor->pixel_array, "pixel array", },
2580 }, *_this = &__this[i];
2581 struct smiapp_subdev *this = _this->ssd;
2582
2583 if (!this)
2584 continue;
2585
2586 if (this != sensor->src)
2587 v4l2_subdev_init(&this->sd, &smiapp_ops);
2588
2589 this->sensor = sensor;
2590
2591 if (this == sensor->pixel_array) {
2592 this->npads = 1;
2593 } else {
2594 this->npads = 2;
2595 this->source_pad = 1;
2596 }
2597
2598 snprintf(this->sd.name,
2599 sizeof(this->sd.name), "%s %s %d-%4.4x",
2600 sensor->minfo.name, _this->name,
2601 i2c_adapter_id(client->adapter), client->addr);
2602
2603 this->sink_fmt.width =
2604 sensor->limits[SMIAPP_LIMIT_X_ADDR_MAX] + 1;
2605 this->sink_fmt.height =
2606 sensor->limits[SMIAPP_LIMIT_Y_ADDR_MAX] + 1;
2607 this->compose.width = this->sink_fmt.width;
2608 this->compose.height = this->sink_fmt.height;
2609 this->crop[this->source_pad] = this->compose;
2610 this->pads[this->source_pad].flags = MEDIA_PAD_FL_SOURCE;
2611 if (this != sensor->pixel_array) {
2612 this->crop[this->sink_pad] = this->compose;
2613 this->pads[this->sink_pad].flags = MEDIA_PAD_FL_SINK;
2614 }
2615
2616 this->sd.entity.ops = &smiapp_entity_ops;
2617
2618 if (last == NULL) {
2619 last = this;
2620 continue;
2621 }
2622
2623 this->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
2624 this->sd.internal_ops = &smiapp_internal_ops;
2625 this->sd.owner = THIS_MODULE;
2626 v4l2_set_subdevdata(&this->sd, client);
2627
2628 rval = media_entity_init(&this->sd.entity,
2629 this->npads, this->pads, 0);
2630 if (rval) {
2631 dev_err(&client->dev,
2632 "media_entity_init failed\n");
2633 goto out_nvm_release;
2634 }
2635
2636 rval = media_entity_create_link(&this->sd.entity,
2637 this->source_pad,
2638 &last->sd.entity,
2639 last->sink_pad,
2640 MEDIA_LNK_FL_ENABLED |
2641 MEDIA_LNK_FL_IMMUTABLE);
2642 if (rval) {
2643 dev_err(&client->dev,
2644 "media_entity_create_link failed\n");
2645 goto out_nvm_release;
2646 }
2647
2648 rval = v4l2_device_register_subdev(sensor->src->sd.v4l2_dev,
2649 &this->sd);
2650 if (rval) {
2651 dev_err(&client->dev,
2652 "v4l2_device_register_subdev failed\n");
2653 goto out_nvm_release;
2654 }
2655
2656 last = this;
2657 }
2658
2659 dev_dbg(&client->dev, "profile %d\n", sensor->minfo.smiapp_profile);
2660
2661 sensor->pixel_array->sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV_SENSOR;
2662
2663
2664 smiapp_read_frame_fmt(sensor);
2665 rval = smiapp_init_controls(sensor);
2666 if (rval < 0)
2667 goto out_nvm_release;
2668
2669
2670 pll->bus_type = SMIAPP_PLL_BUS_TYPE_CSI2;
2671 pll->csi2.lanes = sensor->platform_data->lanes;
2672 pll->ext_clk_freq_hz = sensor->platform_data->ext_clk;
2673 pll->flags = smiapp_call_quirk(sensor, pll_flags);
2674
2675
2676 if (sensor->minfo.smiapp_profile == SMIAPP_PROFILE_0)
2677 pll->flags |= SMIAPP_PLL_FLAG_NO_OP_CLOCKS;
2678 pll->scale_n = sensor->limits[SMIAPP_LIMIT_SCALER_N_MIN];
2679
2680 rval = smiapp_update_mode(sensor);
2681 if (rval) {
2682 dev_err(&client->dev, "update mode failed\n");
2683 goto out_nvm_release;
2684 }
2685
2686 sensor->streaming = false;
2687 sensor->dev_init_done = true;
2688
2689
2690 rval = smiapp_read(sensor, SMIAPP_REG_U8_FLASH_MODE_CAPABILITY, &tmp);
2691 sensor->flash_capability = tmp;
2692 if (rval)
2693 goto out_nvm_release;
2694
2695 smiapp_power_off(sensor);
2696
2697 return 0;
2698
2699out_nvm_release:
2700 device_remove_file(&client->dev, &dev_attr_nvm);
2701
2702out_ident_release:
2703 device_remove_file(&client->dev, &dev_attr_ident);
2704
2705out_power_off:
2706 smiapp_power_off(sensor);
2707 return rval;
2708}
2709
2710static int smiapp_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
2711{
2712 struct smiapp_subdev *ssd = to_smiapp_subdev(sd);
2713 struct smiapp_sensor *sensor = ssd->sensor;
2714 u32 mbus_code =
2715 smiapp_csi_data_formats[smiapp_pixel_order(sensor)].code;
2716 unsigned int i;
2717
2718 mutex_lock(&sensor->mutex);
2719
2720 for (i = 0; i < ssd->npads; i++) {
2721 struct v4l2_mbus_framefmt *try_fmt =
2722 v4l2_subdev_get_try_format(fh, i);
2723 struct v4l2_rect *try_crop = v4l2_subdev_get_try_crop(fh, i);
2724 struct v4l2_rect *try_comp;
2725
2726 try_fmt->width = sensor->limits[SMIAPP_LIMIT_X_ADDR_MAX] + 1;
2727 try_fmt->height = sensor->limits[SMIAPP_LIMIT_Y_ADDR_MAX] + 1;
2728 try_fmt->code = mbus_code;
2729 try_fmt->field = V4L2_FIELD_NONE;
2730
2731 try_crop->top = 0;
2732 try_crop->left = 0;
2733 try_crop->width = try_fmt->width;
2734 try_crop->height = try_fmt->height;
2735
2736 if (ssd != sensor->pixel_array)
2737 continue;
2738
2739 try_comp = v4l2_subdev_get_try_compose(fh, i);
2740 *try_comp = *try_crop;
2741 }
2742
2743 mutex_unlock(&sensor->mutex);
2744
2745 return smiapp_set_power(sd, 1);
2746}
2747
2748static int smiapp_close(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
2749{
2750 return smiapp_set_power(sd, 0);
2751}
2752
2753static const struct v4l2_subdev_video_ops smiapp_video_ops = {
2754 .s_stream = smiapp_set_stream,
2755};
2756
2757static const struct v4l2_subdev_core_ops smiapp_core_ops = {
2758 .s_power = smiapp_set_power,
2759};
2760
2761static const struct v4l2_subdev_pad_ops smiapp_pad_ops = {
2762 .enum_mbus_code = smiapp_enum_mbus_code,
2763 .get_fmt = smiapp_get_format,
2764 .set_fmt = smiapp_set_format,
2765 .get_selection = smiapp_get_selection,
2766 .set_selection = smiapp_set_selection,
2767};
2768
2769static const struct v4l2_subdev_sensor_ops smiapp_sensor_ops = {
2770 .g_skip_frames = smiapp_get_skip_frames,
2771};
2772
2773static const struct v4l2_subdev_ops smiapp_ops = {
2774 .core = &smiapp_core_ops,
2775 .video = &smiapp_video_ops,
2776 .pad = &smiapp_pad_ops,
2777 .sensor = &smiapp_sensor_ops,
2778};
2779
2780static const struct media_entity_operations smiapp_entity_ops = {
2781 .link_validate = v4l2_subdev_link_validate,
2782};
2783
2784static const struct v4l2_subdev_internal_ops smiapp_internal_src_ops = {
2785 .registered = smiapp_registered,
2786 .open = smiapp_open,
2787 .close = smiapp_close,
2788};
2789
2790static const struct v4l2_subdev_internal_ops smiapp_internal_ops = {
2791 .open = smiapp_open,
2792 .close = smiapp_close,
2793};
2794
2795
2796
2797
2798
2799#ifdef CONFIG_PM
2800
2801static int smiapp_suspend(struct device *dev)
2802{
2803 struct i2c_client *client = to_i2c_client(dev);
2804 struct v4l2_subdev *subdev = i2c_get_clientdata(client);
2805 struct smiapp_sensor *sensor = to_smiapp_sensor(subdev);
2806 bool streaming;
2807
2808 BUG_ON(mutex_is_locked(&sensor->mutex));
2809
2810 if (sensor->power_count == 0)
2811 return 0;
2812
2813 if (sensor->streaming)
2814 smiapp_stop_streaming(sensor);
2815
2816 streaming = sensor->streaming;
2817
2818 smiapp_power_off(sensor);
2819
2820
2821 sensor->streaming = streaming;
2822
2823 return 0;
2824}
2825
2826static int smiapp_resume(struct device *dev)
2827{
2828 struct i2c_client *client = to_i2c_client(dev);
2829 struct v4l2_subdev *subdev = i2c_get_clientdata(client);
2830 struct smiapp_sensor *sensor = to_smiapp_sensor(subdev);
2831 int rval;
2832
2833 if (sensor->power_count == 0)
2834 return 0;
2835
2836 rval = smiapp_power_on(sensor);
2837 if (rval)
2838 return rval;
2839
2840 if (sensor->streaming)
2841 rval = smiapp_start_streaming(sensor);
2842
2843 return rval;
2844}
2845
2846#else
2847
2848#define smiapp_suspend NULL
2849#define smiapp_resume NULL
2850
2851#endif
2852
2853static int smiapp_probe(struct i2c_client *client,
2854 const struct i2c_device_id *devid)
2855{
2856 struct smiapp_sensor *sensor;
2857
2858 if (client->dev.platform_data == NULL)
2859 return -ENODEV;
2860
2861 sensor = devm_kzalloc(&client->dev, sizeof(*sensor), GFP_KERNEL);
2862 if (sensor == NULL)
2863 return -ENOMEM;
2864
2865 sensor->platform_data = client->dev.platform_data;
2866 mutex_init(&sensor->mutex);
2867 mutex_init(&sensor->power_mutex);
2868 sensor->src = &sensor->ssds[sensor->ssds_used];
2869
2870 v4l2_i2c_subdev_init(&sensor->src->sd, client, &smiapp_ops);
2871 sensor->src->sd.internal_ops = &smiapp_internal_src_ops;
2872 sensor->src->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
2873 sensor->src->sensor = sensor;
2874
2875 sensor->src->pads[0].flags = MEDIA_PAD_FL_SOURCE;
2876 return media_entity_init(&sensor->src->sd.entity, 2,
2877 sensor->src->pads, 0);
2878}
2879
2880static int smiapp_remove(struct i2c_client *client)
2881{
2882 struct v4l2_subdev *subdev = i2c_get_clientdata(client);
2883 struct smiapp_sensor *sensor = to_smiapp_sensor(subdev);
2884 unsigned int i;
2885
2886 if (sensor->power_count) {
2887 if (gpio_is_valid(sensor->platform_data->xshutdown))
2888 gpio_set_value(sensor->platform_data->xshutdown, 0);
2889 if (sensor->platform_data->set_xclk)
2890 sensor->platform_data->set_xclk(&sensor->src->sd, 0);
2891 else
2892 clk_disable_unprepare(sensor->ext_clk);
2893 sensor->power_count = 0;
2894 }
2895
2896 device_remove_file(&client->dev, &dev_attr_ident);
2897 if (sensor->nvm)
2898 device_remove_file(&client->dev, &dev_attr_nvm);
2899
2900 for (i = 0; i < sensor->ssds_used; i++) {
2901 v4l2_device_unregister_subdev(&sensor->ssds[i].sd);
2902 media_entity_cleanup(&sensor->ssds[i].sd.entity);
2903 }
2904 smiapp_free_controls(sensor);
2905
2906 return 0;
2907}
2908
2909static const struct i2c_device_id smiapp_id_table[] = {
2910 { SMIAPP_NAME, 0 },
2911 { },
2912};
2913MODULE_DEVICE_TABLE(i2c, smiapp_id_table);
2914
2915static const struct dev_pm_ops smiapp_pm_ops = {
2916 .suspend = smiapp_suspend,
2917 .resume = smiapp_resume,
2918};
2919
2920static struct i2c_driver smiapp_i2c_driver = {
2921 .driver = {
2922 .name = SMIAPP_NAME,
2923 .pm = &smiapp_pm_ops,
2924 },
2925 .probe = smiapp_probe,
2926 .remove = smiapp_remove,
2927 .id_table = smiapp_id_table,
2928};
2929
2930module_i2c_driver(smiapp_i2c_driver);
2931
2932MODULE_AUTHOR("Sakari Ailus <sakari.ailus@iki.fi>");
2933MODULE_DESCRIPTION("Generic SMIA/SMIA++ camera module driver");
2934MODULE_LICENSE("GPL");
2935
