1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * V4L2 sensor driver for Aptina MT9V111 image sensor
4 * Copyright (C) 2018 Jacopo Mondi <jacopo@jmondi.org>
5 *
6 * Based on mt9v032 driver
7 * Copyright (C) 2010, Laurent Pinchart <laurent.pinchart@ideasonboard.com>
8 * Copyright (C) 2008, Guennadi Liakhovetski <kernel@pengutronix.de>
9 *
10 * Based on mt9v011 driver
11 * Copyright (c) 2009 Mauro Carvalho Chehab <mchehab@kernel.org>
12 */
13
14 #include <linux/clk.h>
15 #include <linux/delay.h>
16 #include <linux/gpio/consumer.h>
17 #include <linux/i2c.h>
18 #include <linux/of.h>
19 #include <linux/slab.h>
20 #include <linux/videodev2.h>
21 #include <linux/v4l2-mediabus.h>
22 #include <linux/module.h>
23
24 #include <media/v4l2-ctrls.h>
25 #include <media/v4l2-device.h>
26 #include <media/v4l2-fwnode.h>
27 #include <media/v4l2-image-sizes.h>
28 #include <media/v4l2-subdev.h>
29
30 /*
31 * MT9V111 is a 1/4-Inch CMOS digital image sensor with an integrated
32 * Image Flow Processing (IFP) engine and a sensor core loosely based on
33 * MT9V011.
34 *
35 * The IFP can produce several output image formats from the sensor core
36 * output. This driver currently supports only YUYV format permutations.
37 *
38 * The driver allows manual frame rate control through s_frame_interval subdev
39 * operation or V4L2_CID_V/HBLANK controls, but it is known that the
40 * auto-exposure algorithm might modify the programmed frame rate. While the
41 * driver initially programs the sensor with auto-exposure and
42 * auto-white-balancing enabled, it is possible to disable them and more
43 * precisely control the frame rate.
44 *
45 * While it seems possible to instruct the auto-exposure control algorithm to
46 * respect a programmed frame rate when adjusting the pixel integration time,
47 * registers controlling this feature are not documented in the public
48 * available sensor manual used to develop this driver (09005aef80e90084,
49 * MT9V111_1.fm - Rev. G 1/05 EN).
50 */
51
52 #define MT9V111_CHIP_ID_HIGH 0x82
53 #define MT9V111_CHIP_ID_LOW 0x3a
54
55 #define MT9V111_R01_ADDR_SPACE 0x01
56 #define MT9V111_R01_IFP 0x01
57 #define MT9V111_R01_CORE 0x04
58
59 #define MT9V111_IFP_R06_OPMODE_CTRL 0x06
60 #define MT9V111_IFP_R06_OPMODE_CTRL_AWB_EN BIT(1)
61 #define MT9V111_IFP_R06_OPMODE_CTRL_AE_EN BIT(14)
62 #define MT9V111_IFP_R07_IFP_RESET 0x07
63 #define MT9V111_IFP_R07_IFP_RESET_MASK BIT(0)
64 #define MT9V111_IFP_R08_OUTFMT_CTRL 0x08
65 #define MT9V111_IFP_R08_OUTFMT_CTRL_FLICKER BIT(11)
66 #define MT9V111_IFP_R08_OUTFMT_CTRL_PCLK BIT(5)
67 #define MT9V111_IFP_R3A_OUTFMT_CTRL2 0x3a
68 #define MT9V111_IFP_R3A_OUTFMT_CTRL2_SWAP_CBCR BIT(0)
69 #define MT9V111_IFP_R3A_OUTFMT_CTRL2_SWAP_YC BIT(1)
70 #define MT9V111_IFP_R3A_OUTFMT_CTRL2_SWAP_MASK GENMASK(2, 0)
71 #define MT9V111_IFP_RA5_HPAN 0xa5
72 #define MT9V111_IFP_RA6_HZOOM 0xa6
73 #define MT9V111_IFP_RA7_HOUT 0xa7
74 #define MT9V111_IFP_RA8_VPAN 0xa8
75 #define MT9V111_IFP_RA9_VZOOM 0xa9
76 #define MT9V111_IFP_RAA_VOUT 0xaa
77 #define MT9V111_IFP_DECIMATION_MASK GENMASK(9, 0)
78 #define MT9V111_IFP_DECIMATION_FREEZE BIT(15)
79
80 #define MT9V111_CORE_R03_WIN_HEIGHT 0x03
81 #define MT9V111_CORE_R03_WIN_V_OFFS 2
82 #define MT9V111_CORE_R04_WIN_WIDTH 0x04
83 #define MT9V111_CORE_R04_WIN_H_OFFS 114
84 #define MT9V111_CORE_R05_HBLANK 0x05
85 #define MT9V111_CORE_R05_MIN_HBLANK 0x09
86 #define MT9V111_CORE_R05_MAX_HBLANK GENMASK(9, 0)
87 #define MT9V111_CORE_R05_DEF_HBLANK 0x26
88 #define MT9V111_CORE_R06_VBLANK 0x06
89 #define MT9V111_CORE_R06_MIN_VBLANK 0x03
90 #define MT9V111_CORE_R06_MAX_VBLANK GENMASK(11, 0)
91 #define MT9V111_CORE_R06_DEF_VBLANK 0x04
92 #define MT9V111_CORE_R07_OUT_CTRL 0x07
93 #define MT9V111_CORE_R07_OUT_CTRL_SAMPLE BIT(4)
94 #define MT9V111_CORE_R09_PIXEL_INT 0x09
95 #define MT9V111_CORE_R09_PIXEL_INT_MASK GENMASK(11, 0)
96 #define MT9V111_CORE_R0D_CORE_RESET 0x0d
97 #define MT9V111_CORE_R0D_CORE_RESET_MASK BIT(0)
98 #define MT9V111_CORE_RFF_CHIP_VER 0xff
99
100 #define MT9V111_PIXEL_ARRAY_WIDTH 640
101 #define MT9V111_PIXEL_ARRAY_HEIGHT 480
102
103 #define MT9V111_MAX_CLKIN 27000000
104
105 /* The default sensor configuration at startup time. */
106 static const struct v4l2_mbus_framefmt mt9v111_def_fmt = {
107 .width = 640,
108 .height = 480,
109 .code = MEDIA_BUS_FMT_UYVY8_2X8,
110 .field = V4L2_FIELD_NONE,
111 .colorspace = V4L2_COLORSPACE_SRGB,
112 .ycbcr_enc = V4L2_YCBCR_ENC_601,
113 .quantization = V4L2_QUANTIZATION_LIM_RANGE,
114 .xfer_func = V4L2_XFER_FUNC_SRGB,
115 };
116
117 struct mt9v111_dev {
118 struct device *dev;
119 struct i2c_client *client;
120
121 u8 addr_space;
122
123 struct v4l2_subdev sd;
124 #if IS_ENABLED(CONFIG_MEDIA_CONTROLLER)
125 struct media_pad pad;
126 #endif
127
128 struct v4l2_ctrl *auto_awb;
129 struct v4l2_ctrl *auto_exp;
130 struct v4l2_ctrl *hblank;
131 struct v4l2_ctrl *vblank;
132 struct v4l2_ctrl_handler ctrls;
133
134 /* Output image format and sizes. */
135 struct v4l2_mbus_framefmt fmt;
136 unsigned int fps;
137
138 /* Protects power up/down sequences. */
139 struct mutex pwr_mutex;
140 int pwr_count;
141
142 /* Protects stream on/off sequences. */
143 struct mutex stream_mutex;
144 bool streaming;
145
146 /* Flags to mark HW settings as not yet applied. */
147 bool pending;
148
149 /* Clock provider and system clock frequency. */
150 struct clk *clk;
151 u32 sysclk;
152
153 struct gpio_desc *oe;
154 struct gpio_desc *standby;
155 struct gpio_desc *reset;
156 };
157
158 #define sd_to_mt9v111(__sd) container_of((__sd), struct mt9v111_dev, sd)
159
160 /*
161 * mt9v111_mbus_fmt - List all media bus formats supported by the driver.
162 *
163 * Only list the media bus code here. The image sizes are freely configurable
164 * in the pixel array sizes range.
165 *
166 * The desired frame interval, in the supported frame interval range, is
167 * obtained by configuring blanking as the sensor does not have a PLL but
168 * only a fixed clock divider that generates the output pixel clock.
169 */
170 static struct mt9v111_mbus_fmt {
171 u32 code;
172 } mt9v111_formats[] = {
173 {
174 .code = MEDIA_BUS_FMT_UYVY8_2X8,
175 },
176 {
177 .code = MEDIA_BUS_FMT_YUYV8_2X8,
178 },
179 {
180 .code = MEDIA_BUS_FMT_VYUY8_2X8,
181 },
182 {
183 .code = MEDIA_BUS_FMT_YVYU8_2X8,
184 },
185 };
186
187 static u32 mt9v111_frame_intervals[] = {5, 10, 15, 20, 30};
188
189 /*
190 * mt9v111_frame_sizes - List sensor's supported resolutions.
191 *
192 * Resolution generated through decimation in the IFP block from the
193 * full VGA pixel array.
194 */
195 static struct v4l2_rect mt9v111_frame_sizes[] = {
196 {
197 .width = 640,
198 .height = 480,
199 },
200 {
201 .width = 352,
202 .height = 288
203 },
204 {
205 .width = 320,
206 .height = 240,
207 },
208 {
209 .width = 176,
210 .height = 144,
211 },
212 {
213 .width = 160,
214 .height = 120,
215 },
216 };
217
218 /* --- Device I/O access --- */
219
__mt9v111_read(struct i2c_client * c,u8 reg,u16 * val)220 static int __mt9v111_read(struct i2c_client *c, u8 reg, u16 *val)
221 {
222 struct i2c_msg msg[2];
223 __be16 buf;
224 int ret;
225
226 msg[0].addr = c->addr;
227 msg[0].flags = 0;
228 msg[0].len = 1;
229 msg[0].buf = ®
230
231 msg[1].addr = c->addr;
232 msg[1].flags = I2C_M_RD;
233 msg[1].len = 2;
234 msg[1].buf = (char *)&buf;
235
236 ret = i2c_transfer(c->adapter, msg, 2);
237 if (ret < 0) {
238 dev_err(&c->dev, "i2c read transfer error: %d\n", ret);
239 return ret;
240 }
241
242 *val = be16_to_cpu(buf);
243
244 dev_dbg(&c->dev, "%s: %x=%x\n", __func__, reg, *val);
245
246 return 0;
247 }
248
__mt9v111_write(struct i2c_client * c,u8 reg,u16 val)249 static int __mt9v111_write(struct i2c_client *c, u8 reg, u16 val)
250 {
251 struct i2c_msg msg;
252 u8 buf[3] = { 0 };
253 int ret;
254
255 buf[0] = reg;
256 buf[1] = val >> 8;
257 buf[2] = val & 0xff;
258
259 msg.addr = c->addr;
260 msg.flags = 0;
261 msg.len = 3;
262 msg.buf = (char *)buf;
263
264 dev_dbg(&c->dev, "%s: %x = %x%x\n", __func__, reg, buf[1], buf[2]);
265
266 ret = i2c_transfer(c->adapter, &msg, 1);
267 if (ret < 0) {
268 dev_err(&c->dev, "i2c write transfer error: %d\n", ret);
269 return ret;
270 }
271
272 return 0;
273 }
274
__mt9v111_addr_space_select(struct i2c_client * c,u16 addr_space)275 static int __mt9v111_addr_space_select(struct i2c_client *c, u16 addr_space)
276 {
277 struct v4l2_subdev *sd = i2c_get_clientdata(c);
278 struct mt9v111_dev *mt9v111 = sd_to_mt9v111(sd);
279 u16 val;
280 int ret;
281
282 if (mt9v111->addr_space == addr_space)
283 return 0;
284
285 ret = __mt9v111_write(c, MT9V111_R01_ADDR_SPACE, addr_space);
286 if (ret)
287 return ret;
288
289 /* Verify address space has been updated */
290 ret = __mt9v111_read(c, MT9V111_R01_ADDR_SPACE, &val);
291 if (ret)
292 return ret;
293
294 if (val != addr_space)
295 return -EINVAL;
296
297 mt9v111->addr_space = addr_space;
298
299 return 0;
300 }
301
mt9v111_read(struct i2c_client * c,u8 addr_space,u8 reg,u16 * val)302 static int mt9v111_read(struct i2c_client *c, u8 addr_space, u8 reg, u16 *val)
303 {
304 int ret;
305
306 /* Select register address space first. */
307 ret = __mt9v111_addr_space_select(c, addr_space);
308 if (ret)
309 return ret;
310
311 ret = __mt9v111_read(c, reg, val);
312 if (ret)
313 return ret;
314
315 return 0;
316 }
317
mt9v111_write(struct i2c_client * c,u8 addr_space,u8 reg,u16 val)318 static int mt9v111_write(struct i2c_client *c, u8 addr_space, u8 reg, u16 val)
319 {
320 int ret;
321
322 /* Select register address space first. */
323 ret = __mt9v111_addr_space_select(c, addr_space);
324 if (ret)
325 return ret;
326
327 ret = __mt9v111_write(c, reg, val);
328 if (ret)
329 return ret;
330
331 return 0;
332 }
333
mt9v111_update(struct i2c_client * c,u8 addr_space,u8 reg,u16 mask,u16 val)334 static int mt9v111_update(struct i2c_client *c, u8 addr_space, u8 reg,
335 u16 mask, u16 val)
336 {
337 u16 current_val;
338 int ret;
339
340 /* Select register address space first. */
341 ret = __mt9v111_addr_space_select(c, addr_space);
342 if (ret)
343 return ret;
344
345 /* Read the current register value, then update it. */
346 ret = __mt9v111_read(c, reg, ¤t_val);
347 if (ret)
348 return ret;
349
350 current_val &= ~mask;
351 current_val |= (val & mask);
352 ret = __mt9v111_write(c, reg, current_val);
353 if (ret)
354 return ret;
355
356 return 0;
357 }
358
359 /* --- Sensor HW operations --- */
360
__mt9v111_power_on(struct v4l2_subdev * sd)361 static int __mt9v111_power_on(struct v4l2_subdev *sd)
362 {
363 struct mt9v111_dev *mt9v111 = sd_to_mt9v111(sd);
364 int ret;
365
366 ret = clk_prepare_enable(mt9v111->clk);
367 if (ret)
368 return ret;
369
370 clk_set_rate(mt9v111->clk, mt9v111->sysclk);
371
372 gpiod_set_value(mt9v111->standby, 0);
373 usleep_range(500, 1000);
374
375 gpiod_set_value(mt9v111->oe, 1);
376 usleep_range(500, 1000);
377
378 return 0;
379 }
380
__mt9v111_power_off(struct v4l2_subdev * sd)381 static int __mt9v111_power_off(struct v4l2_subdev *sd)
382 {
383 struct mt9v111_dev *mt9v111 = sd_to_mt9v111(sd);
384
385 gpiod_set_value(mt9v111->oe, 0);
386 usleep_range(500, 1000);
387
388 gpiod_set_value(mt9v111->standby, 1);
389 usleep_range(500, 1000);
390
391 clk_disable_unprepare(mt9v111->clk);
392
393 return 0;
394 }
395
__mt9v111_hw_reset(struct mt9v111_dev * mt9v111)396 static int __mt9v111_hw_reset(struct mt9v111_dev *mt9v111)
397 {
398 if (!mt9v111->reset)
399 return -EINVAL;
400
401 gpiod_set_value(mt9v111->reset, 1);
402 usleep_range(500, 1000);
403
404 gpiod_set_value(mt9v111->reset, 0);
405 usleep_range(500, 1000);
406
407 return 0;
408 }
409
__mt9v111_sw_reset(struct mt9v111_dev * mt9v111)410 static int __mt9v111_sw_reset(struct mt9v111_dev *mt9v111)
411 {
412 struct i2c_client *c = mt9v111->client;
413 int ret;
414
415 /* Software reset core and IFP blocks. */
416
417 ret = mt9v111_update(c, MT9V111_R01_CORE,
418 MT9V111_CORE_R0D_CORE_RESET,
419 MT9V111_CORE_R0D_CORE_RESET_MASK, 1);
420 if (ret)
421 return ret;
422 usleep_range(500, 1000);
423
424 ret = mt9v111_update(c, MT9V111_R01_CORE,
425 MT9V111_CORE_R0D_CORE_RESET,
426 MT9V111_CORE_R0D_CORE_RESET_MASK, 0);
427 if (ret)
428 return ret;
429 usleep_range(500, 1000);
430
431 ret = mt9v111_update(c, MT9V111_R01_IFP,
432 MT9V111_IFP_R07_IFP_RESET,
433 MT9V111_IFP_R07_IFP_RESET_MASK, 1);
434 if (ret)
435 return ret;
436 usleep_range(500, 1000);
437
438 ret = mt9v111_update(c, MT9V111_R01_IFP,
439 MT9V111_IFP_R07_IFP_RESET,
440 MT9V111_IFP_R07_IFP_RESET_MASK, 0);
441 if (ret)
442 return ret;
443 usleep_range(500, 1000);
444
445 return 0;
446 }
447
mt9v111_calc_frame_rate(struct mt9v111_dev * mt9v111,struct v4l2_fract * tpf)448 static int mt9v111_calc_frame_rate(struct mt9v111_dev *mt9v111,
449 struct v4l2_fract *tpf)
450 {
451 unsigned int fps = tpf->numerator ?
452 tpf->denominator / tpf->numerator :
453 tpf->denominator;
454 unsigned int best_diff;
455 unsigned int frm_cols;
456 unsigned int row_pclk;
457 unsigned int best_fps;
458 unsigned int pclk;
459 unsigned int diff;
460 unsigned int idx;
461 unsigned int hb;
462 unsigned int vb;
463 unsigned int i;
464 int ret;
465
466 /* Approximate to the closest supported frame interval. */
467 best_diff = ~0L;
468 for (i = 0, idx = 0; i < ARRAY_SIZE(mt9v111_frame_intervals); i++) {
469 diff = abs(fps - mt9v111_frame_intervals[i]);
470 if (diff < best_diff) {
471 idx = i;
472 best_diff = diff;
473 }
474 }
475 fps = mt9v111_frame_intervals[idx];
476
477 /*
478 * The sensor does not provide a PLL circuitry and pixel clock is
479 * generated dividing the master clock source by two.
480 *
481 * Trow = (W + Hblank + 114) * 2 * (1 / SYSCLK)
482 * TFrame = Trow * (H + Vblank + 2)
483 *
484 * FPS = (SYSCLK / 2) / (Trow * (H + Vblank + 2))
485 *
486 * This boils down to tune H and V blanks to best approximate the
487 * above equation.
488 *
489 * Test all available H/V blank values, until we reach the
490 * desired frame rate.
491 */
492 best_fps = vb = hb = 0;
493 pclk = DIV_ROUND_CLOSEST(mt9v111->sysclk, 2);
494 row_pclk = MT9V111_PIXEL_ARRAY_WIDTH + 7 + MT9V111_CORE_R04_WIN_H_OFFS;
495 frm_cols = MT9V111_PIXEL_ARRAY_HEIGHT + 7 + MT9V111_CORE_R03_WIN_V_OFFS;
496
497 best_diff = ~0L;
498 for (vb = MT9V111_CORE_R06_MIN_VBLANK;
499 vb < MT9V111_CORE_R06_MAX_VBLANK; vb++) {
500 for (hb = MT9V111_CORE_R05_MIN_HBLANK;
501 hb < MT9V111_CORE_R05_MAX_HBLANK; hb += 10) {
502 unsigned int t_frame = (row_pclk + hb) *
503 (frm_cols + vb);
504 unsigned int t_fps = DIV_ROUND_CLOSEST(pclk, t_frame);
505
506 diff = abs(fps - t_fps);
507 if (diff < best_diff) {
508 best_diff = diff;
509 best_fps = t_fps;
510
511 if (diff == 0)
512 break;
513 }
514 }
515
516 if (diff == 0)
517 break;
518 }
519
520 ret = v4l2_ctrl_s_ctrl_int64(mt9v111->hblank, hb);
521 if (ret)
522 return ret;
523
524 ret = v4l2_ctrl_s_ctrl_int64(mt9v111->vblank, vb);
525 if (ret)
526 return ret;
527
528 tpf->numerator = 1;
529 tpf->denominator = best_fps;
530
531 return 0;
532 }
533
mt9v111_hw_config(struct mt9v111_dev * mt9v111)534 static int mt9v111_hw_config(struct mt9v111_dev *mt9v111)
535 {
536 struct i2c_client *c = mt9v111->client;
537 unsigned int ret;
538 u16 outfmtctrl2;
539
540 /* Force device reset. */
541 ret = __mt9v111_hw_reset(mt9v111);
542 if (ret == -EINVAL)
543 ret = __mt9v111_sw_reset(mt9v111);
544 if (ret)
545 return ret;
546
547 /* Configure internal clock sample rate. */
548 ret = mt9v111->sysclk < DIV_ROUND_CLOSEST(MT9V111_MAX_CLKIN, 2) ?
549 mt9v111_update(c, MT9V111_R01_CORE,
550 MT9V111_CORE_R07_OUT_CTRL,
551 MT9V111_CORE_R07_OUT_CTRL_SAMPLE, 1) :
552 mt9v111_update(c, MT9V111_R01_CORE,
553 MT9V111_CORE_R07_OUT_CTRL,
554 MT9V111_CORE_R07_OUT_CTRL_SAMPLE, 0);
555 if (ret)
556 return ret;
557
558 /*
559 * Configure output image format components ordering.
560 *
561 * TODO: IFP block can also output several RGB permutations, we only
562 * support YUYV permutations at the moment.
563 */
564 switch (mt9v111->fmt.code) {
565 case MEDIA_BUS_FMT_YUYV8_2X8:
566 outfmtctrl2 = MT9V111_IFP_R3A_OUTFMT_CTRL2_SWAP_YC;
567 break;
568 case MEDIA_BUS_FMT_VYUY8_2X8:
569 outfmtctrl2 = MT9V111_IFP_R3A_OUTFMT_CTRL2_SWAP_CBCR;
570 break;
571 case MEDIA_BUS_FMT_YVYU8_2X8:
572 outfmtctrl2 = MT9V111_IFP_R3A_OUTFMT_CTRL2_SWAP_YC |
573 MT9V111_IFP_R3A_OUTFMT_CTRL2_SWAP_CBCR;
574 break;
575 case MEDIA_BUS_FMT_UYVY8_2X8:
576 default:
577 outfmtctrl2 = 0;
578 break;
579 }
580
581 ret = mt9v111_update(c, MT9V111_R01_IFP, MT9V111_IFP_R3A_OUTFMT_CTRL2,
582 MT9V111_IFP_R3A_OUTFMT_CTRL2_SWAP_MASK,
583 outfmtctrl2);
584 if (ret)
585 return ret;
586
587 /*
588 * Do not change default sensor's core configuration:
589 * output the whole 640x480 pixel array, skip 18 columns and 6 rows.
590 *
591 * Instead, control the output image size through IFP block.
592 *
593 * TODO: No zoom&pan support. Currently we control the output image
594 * size only through decimation, with no zoom support.
595 */
596 ret = mt9v111_write(c, MT9V111_R01_IFP, MT9V111_IFP_RA5_HPAN,
597 MT9V111_IFP_DECIMATION_FREEZE);
598 if (ret)
599 return ret;
600
601 ret = mt9v111_write(c, MT9V111_R01_IFP, MT9V111_IFP_RA8_VPAN,
602 MT9V111_IFP_DECIMATION_FREEZE);
603 if (ret)
604 return ret;
605
606 ret = mt9v111_write(c, MT9V111_R01_IFP, MT9V111_IFP_RA6_HZOOM,
607 MT9V111_IFP_DECIMATION_FREEZE |
608 MT9V111_PIXEL_ARRAY_WIDTH);
609 if (ret)
610 return ret;
611
612 ret = mt9v111_write(c, MT9V111_R01_IFP, MT9V111_IFP_RA9_VZOOM,
613 MT9V111_IFP_DECIMATION_FREEZE |
614 MT9V111_PIXEL_ARRAY_HEIGHT);
615 if (ret)
616 return ret;
617
618 ret = mt9v111_write(c, MT9V111_R01_IFP, MT9V111_IFP_RA7_HOUT,
619 MT9V111_IFP_DECIMATION_FREEZE |
620 mt9v111->fmt.width);
621 if (ret)
622 return ret;
623
624 ret = mt9v111_write(c, MT9V111_R01_IFP, MT9V111_IFP_RAA_VOUT,
625 mt9v111->fmt.height);
626 if (ret)
627 return ret;
628
629 /* Apply controls to set auto exp, auto awb and timings */
630 ret = v4l2_ctrl_handler_setup(&mt9v111->ctrls);
631 if (ret)
632 return ret;
633
634 /*
635 * Set pixel integration time to the whole frame time.
636 * This value controls the shutter delay when running with AE
637 * disabled. If longer than frame time, it affects the output
638 * frame rate.
639 */
640 return mt9v111_write(c, MT9V111_R01_CORE, MT9V111_CORE_R09_PIXEL_INT,
641 MT9V111_PIXEL_ARRAY_HEIGHT);
642 }
643
644 /* --- V4L2 subdev operations --- */
645
mt9v111_s_power(struct v4l2_subdev * sd,int on)646 static int mt9v111_s_power(struct v4l2_subdev *sd, int on)
647 {
648 struct mt9v111_dev *mt9v111 = sd_to_mt9v111(sd);
649 int pwr_count;
650 int ret = 0;
651
652 mutex_lock(&mt9v111->pwr_mutex);
653
654 /*
655 * Make sure we're transitioning from 0 to 1, or viceversa,
656 * before actually changing the power state.
657 */
658 pwr_count = mt9v111->pwr_count;
659 pwr_count += on ? 1 : -1;
660 if (pwr_count == !!on) {
661 ret = on ? __mt9v111_power_on(sd) :
662 __mt9v111_power_off(sd);
663 if (!ret)
664 /* All went well, updated power counter. */
665 mt9v111->pwr_count = pwr_count;
666
667 mutex_unlock(&mt9v111->pwr_mutex);
668
669 return ret;
670 }
671
672 /*
673 * Update power counter to keep track of how many nested calls we
674 * received.
675 */
676 WARN_ON(pwr_count < 0 || pwr_count > 1);
677 mt9v111->pwr_count = pwr_count;
678
679 mutex_unlock(&mt9v111->pwr_mutex);
680
681 return ret;
682 }
683
mt9v111_s_stream(struct v4l2_subdev * subdev,int enable)684 static int mt9v111_s_stream(struct v4l2_subdev *subdev, int enable)
685 {
686 struct mt9v111_dev *mt9v111 = sd_to_mt9v111(subdev);
687 int ret;
688
689 mutex_lock(&mt9v111->stream_mutex);
690
691 if (mt9v111->streaming == enable) {
692 mutex_unlock(&mt9v111->stream_mutex);
693 return 0;
694 }
695
696 ret = mt9v111_s_power(subdev, enable);
697 if (ret)
698 goto error_unlock;
699
700 if (enable && mt9v111->pending) {
701 ret = mt9v111_hw_config(mt9v111);
702 if (ret)
703 goto error_unlock;
704
705 /*
706 * No need to update control here as far as only H/VBLANK are
707 * supported and immediately programmed to registers in .s_ctrl
708 */
709
710 mt9v111->pending = false;
711 }
712
713 mt9v111->streaming = enable ? true : false;
714 mutex_unlock(&mt9v111->stream_mutex);
715
716 return 0;
717
718 error_unlock:
719 mutex_unlock(&mt9v111->stream_mutex);
720
721 return ret;
722 }
723
mt9v111_s_frame_interval(struct v4l2_subdev * sd,struct v4l2_subdev_frame_interval * ival)724 static int mt9v111_s_frame_interval(struct v4l2_subdev *sd,
725 struct v4l2_subdev_frame_interval *ival)
726 {
727 struct mt9v111_dev *mt9v111 = sd_to_mt9v111(sd);
728 struct v4l2_fract *tpf = &ival->interval;
729 unsigned int fps = tpf->numerator ?
730 tpf->denominator / tpf->numerator :
731 tpf->denominator;
732 unsigned int max_fps;
733
734 if (!tpf->numerator)
735 tpf->numerator = 1;
736
737 mutex_lock(&mt9v111->stream_mutex);
738
739 if (mt9v111->streaming) {
740 mutex_unlock(&mt9v111->stream_mutex);
741 return -EBUSY;
742 }
743
744 if (mt9v111->fps == fps) {
745 mutex_unlock(&mt9v111->stream_mutex);
746 return 0;
747 }
748
749 /* Make sure frame rate/image sizes constraints are respected. */
750 if (mt9v111->fmt.width < QVGA_WIDTH &&
751 mt9v111->fmt.height < QVGA_HEIGHT)
752 max_fps = 90;
753 else if (mt9v111->fmt.width < CIF_WIDTH &&
754 mt9v111->fmt.height < CIF_HEIGHT)
755 max_fps = 60;
756 else
757 max_fps = mt9v111->sysclk <
758 DIV_ROUND_CLOSEST(MT9V111_MAX_CLKIN, 2) ? 15 :
759 30;
760
761 if (fps > max_fps) {
762 mutex_unlock(&mt9v111->stream_mutex);
763 return -EINVAL;
764 }
765
766 mt9v111_calc_frame_rate(mt9v111, tpf);
767
768 mt9v111->fps = fps;
769 mt9v111->pending = true;
770
771 mutex_unlock(&mt9v111->stream_mutex);
772
773 return 0;
774 }
775
mt9v111_g_frame_interval(struct v4l2_subdev * sd,struct v4l2_subdev_frame_interval * ival)776 static int mt9v111_g_frame_interval(struct v4l2_subdev *sd,
777 struct v4l2_subdev_frame_interval *ival)
778 {
779 struct mt9v111_dev *mt9v111 = sd_to_mt9v111(sd);
780 struct v4l2_fract *tpf = &ival->interval;
781
782 mutex_lock(&mt9v111->stream_mutex);
783
784 tpf->numerator = 1;
785 tpf->denominator = mt9v111->fps;
786
787 mutex_unlock(&mt9v111->stream_mutex);
788
789 return 0;
790 }
791
__mt9v111_get_pad_format(struct mt9v111_dev * mt9v111,struct v4l2_subdev_state * sd_state,unsigned int pad,enum v4l2_subdev_format_whence which)792 static struct v4l2_mbus_framefmt *__mt9v111_get_pad_format(
793 struct mt9v111_dev *mt9v111,
794 struct v4l2_subdev_state *sd_state,
795 unsigned int pad,
796 enum v4l2_subdev_format_whence which)
797 {
798 switch (which) {
799 case V4L2_SUBDEV_FORMAT_TRY:
800 #if IS_ENABLED(CONFIG_VIDEO_V4L2_SUBDEV_API)
801 return v4l2_subdev_get_try_format(&mt9v111->sd, sd_state, pad);
802 #else
803 return &sd_state->pads->try_fmt;
804 #endif
805 case V4L2_SUBDEV_FORMAT_ACTIVE:
806 return &mt9v111->fmt;
807 default:
808 return NULL;
809 }
810 }
811
mt9v111_enum_mbus_code(struct v4l2_subdev * subdev,struct v4l2_subdev_state * sd_state,struct v4l2_subdev_mbus_code_enum * code)812 static int mt9v111_enum_mbus_code(struct v4l2_subdev *subdev,
813 struct v4l2_subdev_state *sd_state,
814 struct v4l2_subdev_mbus_code_enum *code)
815 {
816 if (code->pad || code->index > ARRAY_SIZE(mt9v111_formats) - 1)
817 return -EINVAL;
818
819 code->code = mt9v111_formats[code->index].code;
820
821 return 0;
822 }
823
mt9v111_enum_frame_interval(struct v4l2_subdev * sd,struct v4l2_subdev_state * sd_state,struct v4l2_subdev_frame_interval_enum * fie)824 static int mt9v111_enum_frame_interval(struct v4l2_subdev *sd,
825 struct v4l2_subdev_state *sd_state,
826 struct v4l2_subdev_frame_interval_enum *fie)
827 {
828 unsigned int i;
829
830 if (fie->pad || fie->index >= ARRAY_SIZE(mt9v111_frame_intervals))
831 return -EINVAL;
832
833 for (i = 0; i < ARRAY_SIZE(mt9v111_frame_sizes); i++)
834 if (fie->width == mt9v111_frame_sizes[i].width &&
835 fie->height == mt9v111_frame_sizes[i].height)
836 break;
837
838 if (i == ARRAY_SIZE(mt9v111_frame_sizes))
839 return -EINVAL;
840
841 fie->interval.numerator = 1;
842 fie->interval.denominator = mt9v111_frame_intervals[fie->index];
843
844 return 0;
845 }
846
mt9v111_enum_frame_size(struct v4l2_subdev * subdev,struct v4l2_subdev_state * sd_state,struct v4l2_subdev_frame_size_enum * fse)847 static int mt9v111_enum_frame_size(struct v4l2_subdev *subdev,
848 struct v4l2_subdev_state *sd_state,
849 struct v4l2_subdev_frame_size_enum *fse)
850 {
851 if (fse->pad || fse->index >= ARRAY_SIZE(mt9v111_frame_sizes))
852 return -EINVAL;
853
854 fse->min_width = mt9v111_frame_sizes[fse->index].width;
855 fse->max_width = mt9v111_frame_sizes[fse->index].width;
856 fse->min_height = mt9v111_frame_sizes[fse->index].height;
857 fse->max_height = mt9v111_frame_sizes[fse->index].height;
858
859 return 0;
860 }
861
mt9v111_get_format(struct v4l2_subdev * subdev,struct v4l2_subdev_state * sd_state,struct v4l2_subdev_format * format)862 static int mt9v111_get_format(struct v4l2_subdev *subdev,
863 struct v4l2_subdev_state *sd_state,
864 struct v4l2_subdev_format *format)
865 {
866 struct mt9v111_dev *mt9v111 = sd_to_mt9v111(subdev);
867
868 if (format->pad)
869 return -EINVAL;
870
871 mutex_lock(&mt9v111->stream_mutex);
872 format->format = *__mt9v111_get_pad_format(mt9v111, sd_state,
873 format->pad,
874 format->which);
875 mutex_unlock(&mt9v111->stream_mutex);
876
877 return 0;
878 }
879
mt9v111_set_format(struct v4l2_subdev * subdev,struct v4l2_subdev_state * sd_state,struct v4l2_subdev_format * format)880 static int mt9v111_set_format(struct v4l2_subdev *subdev,
881 struct v4l2_subdev_state *sd_state,
882 struct v4l2_subdev_format *format)
883 {
884 struct mt9v111_dev *mt9v111 = sd_to_mt9v111(subdev);
885 struct v4l2_mbus_framefmt new_fmt;
886 struct v4l2_mbus_framefmt *__fmt;
887 unsigned int best_fit = ~0L;
888 unsigned int idx = 0;
889 unsigned int i;
890
891 mutex_lock(&mt9v111->stream_mutex);
892 if (mt9v111->streaming) {
893 mutex_unlock(&mt9v111->stream_mutex);
894 return -EBUSY;
895 }
896
897 if (format->pad) {
898 mutex_unlock(&mt9v111->stream_mutex);
899 return -EINVAL;
900 }
901
902 /* Update mbus format code and sizes. */
903 for (i = 0; i < ARRAY_SIZE(mt9v111_formats); i++) {
904 if (format->format.code == mt9v111_formats[i].code) {
905 new_fmt.code = mt9v111_formats[i].code;
906 break;
907 }
908 }
909 if (i == ARRAY_SIZE(mt9v111_formats))
910 new_fmt.code = mt9v111_formats[0].code;
911
912 for (i = 0; i < ARRAY_SIZE(mt9v111_frame_sizes); i++) {
913 unsigned int fit = abs(mt9v111_frame_sizes[i].width -
914 format->format.width) +
915 abs(mt9v111_frame_sizes[i].height -
916 format->format.height);
917 if (fit < best_fit) {
918 best_fit = fit;
919 idx = i;
920
921 if (fit == 0)
922 break;
923 }
924 }
925 new_fmt.width = mt9v111_frame_sizes[idx].width;
926 new_fmt.height = mt9v111_frame_sizes[idx].height;
927
928 /* Update the device (or pad) format if it has changed. */
929 __fmt = __mt9v111_get_pad_format(mt9v111, sd_state, format->pad,
930 format->which);
931
932 /* Format hasn't changed, stop here. */
933 if (__fmt->code == new_fmt.code &&
934 __fmt->width == new_fmt.width &&
935 __fmt->height == new_fmt.height)
936 goto done;
937
938 /* Update the format and sizes, then mark changes as pending. */
939 __fmt->code = new_fmt.code;
940 __fmt->width = new_fmt.width;
941 __fmt->height = new_fmt.height;
942
943 if (format->which == V4L2_SUBDEV_FORMAT_ACTIVE)
944 mt9v111->pending = true;
945
946 dev_dbg(mt9v111->dev, "%s: mbus_code: %x - (%ux%u)\n",
947 __func__, __fmt->code, __fmt->width, __fmt->height);
948
949 done:
950 format->format = *__fmt;
951
952 mutex_unlock(&mt9v111->stream_mutex);
953
954 return 0;
955 }
956
mt9v111_init_cfg(struct v4l2_subdev * subdev,struct v4l2_subdev_state * sd_state)957 static int mt9v111_init_cfg(struct v4l2_subdev *subdev,
958 struct v4l2_subdev_state *sd_state)
959 {
960 sd_state->pads->try_fmt = mt9v111_def_fmt;
961
962 return 0;
963 }
964
965 static const struct v4l2_subdev_core_ops mt9v111_core_ops = {
966 .s_power = mt9v111_s_power,
967 };
968
969 static const struct v4l2_subdev_video_ops mt9v111_video_ops = {
970 .s_stream = mt9v111_s_stream,
971 .s_frame_interval = mt9v111_s_frame_interval,
972 .g_frame_interval = mt9v111_g_frame_interval,
973 };
974
975 static const struct v4l2_subdev_pad_ops mt9v111_pad_ops = {
976 .init_cfg = mt9v111_init_cfg,
977 .enum_mbus_code = mt9v111_enum_mbus_code,
978 .enum_frame_size = mt9v111_enum_frame_size,
979 .enum_frame_interval = mt9v111_enum_frame_interval,
980 .get_fmt = mt9v111_get_format,
981 .set_fmt = mt9v111_set_format,
982 };
983
984 static const struct v4l2_subdev_ops mt9v111_ops = {
985 .core = &mt9v111_core_ops,
986 .video = &mt9v111_video_ops,
987 .pad = &mt9v111_pad_ops,
988 };
989
990 #if IS_ENABLED(CONFIG_MEDIA_CONTROLLER)
991 static const struct media_entity_operations mt9v111_subdev_entity_ops = {
992 .link_validate = v4l2_subdev_link_validate,
993 };
994 #endif
995
996 /* --- V4L2 ctrl --- */
mt9v111_s_ctrl(struct v4l2_ctrl * ctrl)997 static int mt9v111_s_ctrl(struct v4l2_ctrl *ctrl)
998 {
999 struct mt9v111_dev *mt9v111 = container_of(ctrl->handler,
1000 struct mt9v111_dev,
1001 ctrls);
1002 int ret;
1003
1004 mutex_lock(&mt9v111->pwr_mutex);
1005 /*
1006 * If sensor is powered down, just cache new control values,
1007 * no actual register access.
1008 */
1009 if (!mt9v111->pwr_count) {
1010 mt9v111->pending = true;
1011 mutex_unlock(&mt9v111->pwr_mutex);
1012 return 0;
1013 }
1014 mutex_unlock(&mt9v111->pwr_mutex);
1015
1016 /*
1017 * Flickering control gets disabled if both auto exp and auto awb
1018 * are disabled too. If any of the two is enabled, enable it.
1019 *
1020 * Disabling flickering when ae and awb are off allows a more precise
1021 * control of the programmed frame rate.
1022 */
1023 if (mt9v111->auto_exp->is_new || mt9v111->auto_awb->is_new) {
1024 if (mt9v111->auto_exp->val == V4L2_EXPOSURE_MANUAL &&
1025 mt9v111->auto_awb->val == V4L2_WHITE_BALANCE_MANUAL)
1026 ret = mt9v111_update(mt9v111->client, MT9V111_R01_IFP,
1027 MT9V111_IFP_R08_OUTFMT_CTRL,
1028 MT9V111_IFP_R08_OUTFMT_CTRL_FLICKER,
1029 0);
1030 else
1031 ret = mt9v111_update(mt9v111->client, MT9V111_R01_IFP,
1032 MT9V111_IFP_R08_OUTFMT_CTRL,
1033 MT9V111_IFP_R08_OUTFMT_CTRL_FLICKER,
1034 1);
1035 if (ret)
1036 return ret;
1037 }
1038
1039 ret = -EINVAL;
1040 switch (ctrl->id) {
1041 case V4L2_CID_AUTO_WHITE_BALANCE:
1042 ret = mt9v111_update(mt9v111->client, MT9V111_R01_IFP,
1043 MT9V111_IFP_R06_OPMODE_CTRL,
1044 MT9V111_IFP_R06_OPMODE_CTRL_AWB_EN,
1045 ctrl->val == V4L2_WHITE_BALANCE_AUTO ?
1046 MT9V111_IFP_R06_OPMODE_CTRL_AWB_EN : 0);
1047 break;
1048 case V4L2_CID_EXPOSURE_AUTO:
1049 ret = mt9v111_update(mt9v111->client, MT9V111_R01_IFP,
1050 MT9V111_IFP_R06_OPMODE_CTRL,
1051 MT9V111_IFP_R06_OPMODE_CTRL_AE_EN,
1052 ctrl->val == V4L2_EXPOSURE_AUTO ?
1053 MT9V111_IFP_R06_OPMODE_CTRL_AE_EN : 0);
1054 break;
1055 case V4L2_CID_HBLANK:
1056 ret = mt9v111_update(mt9v111->client, MT9V111_R01_CORE,
1057 MT9V111_CORE_R05_HBLANK,
1058 MT9V111_CORE_R05_MAX_HBLANK,
1059 mt9v111->hblank->val);
1060 break;
1061 case V4L2_CID_VBLANK:
1062 ret = mt9v111_update(mt9v111->client, MT9V111_R01_CORE,
1063 MT9V111_CORE_R06_VBLANK,
1064 MT9V111_CORE_R06_MAX_VBLANK,
1065 mt9v111->vblank->val);
1066 break;
1067 }
1068
1069 return ret;
1070 }
1071
1072 static const struct v4l2_ctrl_ops mt9v111_ctrl_ops = {
1073 .s_ctrl = mt9v111_s_ctrl,
1074 };
1075
mt9v111_chip_probe(struct mt9v111_dev * mt9v111)1076 static int mt9v111_chip_probe(struct mt9v111_dev *mt9v111)
1077 {
1078 int ret;
1079 u16 val;
1080
1081 ret = __mt9v111_power_on(&mt9v111->sd);
1082 if (ret)
1083 return ret;
1084
1085 ret = mt9v111_read(mt9v111->client, MT9V111_R01_CORE,
1086 MT9V111_CORE_RFF_CHIP_VER, &val);
1087 if (ret)
1088 goto power_off;
1089
1090 if ((val >> 8) != MT9V111_CHIP_ID_HIGH &&
1091 (val & 0xff) != MT9V111_CHIP_ID_LOW) {
1092 dev_err(mt9v111->dev,
1093 "Unable to identify MT9V111 chip: 0x%2x%2x\n",
1094 val >> 8, val & 0xff);
1095 ret = -EIO;
1096 goto power_off;
1097 }
1098
1099 dev_dbg(mt9v111->dev, "Chip identified: 0x%2x%2x\n",
1100 val >> 8, val & 0xff);
1101
1102 power_off:
1103 __mt9v111_power_off(&mt9v111->sd);
1104
1105 return ret;
1106 }
1107
mt9v111_probe(struct i2c_client * client)1108 static int mt9v111_probe(struct i2c_client *client)
1109 {
1110 struct mt9v111_dev *mt9v111;
1111 struct v4l2_fract tpf;
1112 int ret;
1113
1114 mt9v111 = devm_kzalloc(&client->dev, sizeof(*mt9v111), GFP_KERNEL);
1115 if (!mt9v111)
1116 return -ENOMEM;
1117
1118 mt9v111->dev = &client->dev;
1119 mt9v111->client = client;
1120
1121 mt9v111->clk = devm_clk_get(&client->dev, NULL);
1122 if (IS_ERR(mt9v111->clk))
1123 return PTR_ERR(mt9v111->clk);
1124
1125 mt9v111->sysclk = clk_get_rate(mt9v111->clk);
1126 if (mt9v111->sysclk > MT9V111_MAX_CLKIN)
1127 return -EINVAL;
1128
1129 mt9v111->oe = devm_gpiod_get_optional(&client->dev, "enable",
1130 GPIOD_OUT_LOW);
1131 if (IS_ERR(mt9v111->oe)) {
1132 dev_err(&client->dev, "Unable to get GPIO \"enable\": %ld\n",
1133 PTR_ERR(mt9v111->oe));
1134 return PTR_ERR(mt9v111->oe);
1135 }
1136
1137 mt9v111->standby = devm_gpiod_get_optional(&client->dev, "standby",
1138 GPIOD_OUT_HIGH);
1139 if (IS_ERR(mt9v111->standby)) {
1140 dev_err(&client->dev, "Unable to get GPIO \"standby\": %ld\n",
1141 PTR_ERR(mt9v111->standby));
1142 return PTR_ERR(mt9v111->standby);
1143 }
1144
1145 mt9v111->reset = devm_gpiod_get_optional(&client->dev, "reset",
1146 GPIOD_OUT_LOW);
1147 if (IS_ERR(mt9v111->reset)) {
1148 dev_err(&client->dev, "Unable to get GPIO \"reset\": %ld\n",
1149 PTR_ERR(mt9v111->reset));
1150 return PTR_ERR(mt9v111->reset);
1151 }
1152
1153 mutex_init(&mt9v111->pwr_mutex);
1154 mutex_init(&mt9v111->stream_mutex);
1155
1156 v4l2_ctrl_handler_init(&mt9v111->ctrls, 5);
1157
1158 mt9v111->auto_awb = v4l2_ctrl_new_std(&mt9v111->ctrls,
1159 &mt9v111_ctrl_ops,
1160 V4L2_CID_AUTO_WHITE_BALANCE,
1161 0, 1, 1,
1162 V4L2_WHITE_BALANCE_AUTO);
1163 mt9v111->auto_exp = v4l2_ctrl_new_std_menu(&mt9v111->ctrls,
1164 &mt9v111_ctrl_ops,
1165 V4L2_CID_EXPOSURE_AUTO,
1166 V4L2_EXPOSURE_MANUAL,
1167 0, V4L2_EXPOSURE_AUTO);
1168 mt9v111->hblank = v4l2_ctrl_new_std(&mt9v111->ctrls, &mt9v111_ctrl_ops,
1169 V4L2_CID_HBLANK,
1170 MT9V111_CORE_R05_MIN_HBLANK,
1171 MT9V111_CORE_R05_MAX_HBLANK, 1,
1172 MT9V111_CORE_R05_DEF_HBLANK);
1173 mt9v111->vblank = v4l2_ctrl_new_std(&mt9v111->ctrls, &mt9v111_ctrl_ops,
1174 V4L2_CID_VBLANK,
1175 MT9V111_CORE_R06_MIN_VBLANK,
1176 MT9V111_CORE_R06_MAX_VBLANK, 1,
1177 MT9V111_CORE_R06_DEF_VBLANK);
1178
1179 /* PIXEL_RATE is fixed: just expose it to user space. */
1180 v4l2_ctrl_new_std(&mt9v111->ctrls, &mt9v111_ctrl_ops,
1181 V4L2_CID_PIXEL_RATE, 0,
1182 DIV_ROUND_CLOSEST(mt9v111->sysclk, 2), 1,
1183 DIV_ROUND_CLOSEST(mt9v111->sysclk, 2));
1184
1185 if (mt9v111->ctrls.error) {
1186 ret = mt9v111->ctrls.error;
1187 goto error_free_ctrls;
1188 }
1189 mt9v111->sd.ctrl_handler = &mt9v111->ctrls;
1190
1191 /* Start with default configuration: 640x480 UYVY. */
1192 mt9v111->fmt = mt9v111_def_fmt;
1193
1194 /* Re-calculate blankings for 640x480@15fps. */
1195 mt9v111->fps = 15;
1196 tpf.numerator = 1;
1197 tpf.denominator = mt9v111->fps;
1198 mt9v111_calc_frame_rate(mt9v111, &tpf);
1199
1200 mt9v111->pwr_count = 0;
1201 mt9v111->addr_space = MT9V111_R01_IFP;
1202 mt9v111->pending = true;
1203
1204 v4l2_i2c_subdev_init(&mt9v111->sd, client, &mt9v111_ops);
1205
1206 #if IS_ENABLED(CONFIG_MEDIA_CONTROLLER)
1207 mt9v111->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
1208 mt9v111->sd.entity.ops = &mt9v111_subdev_entity_ops;
1209 mt9v111->sd.entity.function = MEDIA_ENT_F_CAM_SENSOR;
1210
1211 mt9v111->pad.flags = MEDIA_PAD_FL_SOURCE;
1212 ret = media_entity_pads_init(&mt9v111->sd.entity, 1, &mt9v111->pad);
1213 if (ret)
1214 goto error_free_entity;
1215 #endif
1216
1217 ret = mt9v111_chip_probe(mt9v111);
1218 if (ret)
1219 goto error_free_entity;
1220
1221 ret = v4l2_async_register_subdev(&mt9v111->sd);
1222 if (ret)
1223 goto error_free_entity;
1224
1225 return 0;
1226
1227 error_free_entity:
1228 #if IS_ENABLED(CONFIG_MEDIA_CONTROLLER)
1229 media_entity_cleanup(&mt9v111->sd.entity);
1230 #endif
1231
1232 error_free_ctrls:
1233 v4l2_ctrl_handler_free(&mt9v111->ctrls);
1234
1235 mutex_destroy(&mt9v111->pwr_mutex);
1236 mutex_destroy(&mt9v111->stream_mutex);
1237
1238 return ret;
1239 }
1240
mt9v111_remove(struct i2c_client * client)1241 static void mt9v111_remove(struct i2c_client *client)
1242 {
1243 struct v4l2_subdev *sd = i2c_get_clientdata(client);
1244 struct mt9v111_dev *mt9v111 = sd_to_mt9v111(sd);
1245
1246 v4l2_async_unregister_subdev(sd);
1247
1248 #if IS_ENABLED(CONFIG_MEDIA_CONTROLLER)
1249 media_entity_cleanup(&sd->entity);
1250 #endif
1251
1252 v4l2_ctrl_handler_free(&mt9v111->ctrls);
1253
1254 mutex_destroy(&mt9v111->pwr_mutex);
1255 mutex_destroy(&mt9v111->stream_mutex);
1256 }
1257
1258 static const struct of_device_id mt9v111_of_match[] = {
1259 { .compatible = "aptina,mt9v111", },
1260 { /* sentinel */ },
1261 };
1262
1263 static struct i2c_driver mt9v111_driver = {
1264 .driver = {
1265 .name = "mt9v111",
1266 .of_match_table = mt9v111_of_match,
1267 },
1268 .probe = mt9v111_probe,
1269 .remove = mt9v111_remove,
1270 };
1271
1272 module_i2c_driver(mt9v111_driver);
1273
1274 MODULE_DESCRIPTION("V4L2 sensor driver for Aptina MT9V111");
1275 MODULE_AUTHOR("Jacopo Mondi <jacopo@jmondi.org>");
1276 MODULE_LICENSE("GPL v2");
1277
