1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Support for OmniVision OV2722 1080p HD camera sensor.
4  *
5  * Copyright (c) 2013 Intel Corporation. All Rights Reserved.
6  *
7  * This program is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License version
9  * 2 as published by the Free Software Foundation.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  */
17 
18 #include <linux/module.h>
19 #include <linux/types.h>
20 #include <linux/kernel.h>
21 #include <linux/mm.h>
22 #include <linux/string.h>
23 #include <linux/errno.h>
24 #include <linux/init.h>
25 #include <linux/kmod.h>
26 #include <linux/device.h>
27 #include <linux/delay.h>
28 #include <linux/slab.h>
29 #include <linux/i2c.h>
30 #include <linux/moduleparam.h>
31 #include <media/v4l2-device.h>
32 #include "../include/linux/atomisp_gmin_platform.h"
33 #include <linux/acpi.h>
34 #include <linux/io.h>
35 
36 #include "ov2722.h"
37 
38 /* i2c read/write stuff */
ov2722_read_reg(struct i2c_client * client,u16 data_length,u16 reg,u16 * val)39 static int ov2722_read_reg(struct i2c_client *client,
40 			   u16 data_length, u16 reg, u16 *val)
41 {
42 	int err;
43 	struct i2c_msg msg[2];
44 	unsigned char data[6];
45 
46 	if (!client->adapter) {
47 		dev_err(&client->dev, "%s error, no client->adapter\n",
48 			__func__);
49 		return -ENODEV;
50 	}
51 
52 	if (data_length != OV2722_8BIT && data_length != OV2722_16BIT &&
53 	    data_length != OV2722_32BIT) {
54 		dev_err(&client->dev, "%s error, invalid data length\n",
55 			__func__);
56 		return -EINVAL;
57 	}
58 
59 	memset(msg, 0, sizeof(msg));
60 
61 	msg[0].addr = client->addr;
62 	msg[0].flags = 0;
63 	msg[0].len = I2C_MSG_LENGTH;
64 	msg[0].buf = data;
65 
66 	/* high byte goes out first */
67 	data[0] = (u8)(reg >> 8);
68 	data[1] = (u8)(reg & 0xff);
69 
70 	msg[1].addr = client->addr;
71 	msg[1].len = data_length;
72 	msg[1].flags = I2C_M_RD;
73 	msg[1].buf = data;
74 
75 	err = i2c_transfer(client->adapter, msg, 2);
76 	if (err != 2) {
77 		if (err >= 0)
78 			err = -EIO;
79 		dev_err(&client->dev,
80 			"read from offset 0x%x error %d", reg, err);
81 		return err;
82 	}
83 
84 	*val = 0;
85 	/* high byte comes first */
86 	if (data_length == OV2722_8BIT)
87 		*val = (u8)data[0];
88 	else if (data_length == OV2722_16BIT)
89 		*val = be16_to_cpu(*(__be16 *)&data[0]);
90 	else
91 		*val = be32_to_cpu(*(__be32 *)&data[0]);
92 
93 	return 0;
94 }
95 
ov2722_i2c_write(struct i2c_client * client,u16 len,u8 * data)96 static int ov2722_i2c_write(struct i2c_client *client, u16 len, u8 *data)
97 {
98 	struct i2c_msg msg;
99 	const int num_msg = 1;
100 	int ret;
101 
102 	msg.addr = client->addr;
103 	msg.flags = 0;
104 	msg.len = len;
105 	msg.buf = data;
106 	ret = i2c_transfer(client->adapter, &msg, 1);
107 
108 	return ret == num_msg ? 0 : -EIO;
109 }
110 
ov2722_write_reg(struct i2c_client * client,u16 data_length,u16 reg,u16 val)111 static int ov2722_write_reg(struct i2c_client *client, u16 data_length,
112 			    u16 reg, u16 val)
113 {
114 	int ret;
115 	unsigned char data[4] = {0};
116 	__be16 *wreg = (__be16 *)data;
117 	const u16 len = data_length + sizeof(u16); /* 16-bit address + data */
118 
119 	if (data_length != OV2722_8BIT && data_length != OV2722_16BIT) {
120 		dev_err(&client->dev,
121 			"%s error, invalid data_length\n", __func__);
122 		return -EINVAL;
123 	}
124 
125 	/* high byte goes out first */
126 	*wreg = cpu_to_be16(reg);
127 
128 	if (data_length == OV2722_8BIT) {
129 		data[2] = (u8)(val);
130 	} else {
131 		/* OV2722_16BIT */
132 		__be16 *wdata = (__be16 *)&data[2];
133 
134 		*wdata = cpu_to_be16(val);
135 	}
136 
137 	ret = ov2722_i2c_write(client, len, data);
138 	if (ret)
139 		dev_err(&client->dev,
140 			"write error: wrote 0x%x to offset 0x%x error %d",
141 			val, reg, ret);
142 
143 	return ret;
144 }
145 
146 /*
147  * ov2722_write_reg_array - Initializes a list of OV2722 registers
148  * @client: i2c driver client structure
149  * @reglist: list of registers to be written
150  *
151  * This function initializes a list of registers. When consecutive addresses
152  * are found in a row on the list, this function creates a buffer and sends
153  * consecutive data in a single i2c_transfer().
154  *
155  * __ov2722_flush_reg_array, __ov2722_buf_reg_array() and
156  * __ov2722_write_reg_is_consecutive() are internal functions to
157  * ov2722_write_reg_array_fast() and should be not used anywhere else.
158  *
159  */
160 
__ov2722_flush_reg_array(struct i2c_client * client,struct ov2722_write_ctrl * ctrl)161 static int __ov2722_flush_reg_array(struct i2c_client *client,
162 				    struct ov2722_write_ctrl *ctrl)
163 {
164 	u16 size;
165 	__be16 *data16 = (void *)&ctrl->buffer.addr;
166 
167 	if (ctrl->index == 0)
168 		return 0;
169 
170 	size = sizeof(u16) + ctrl->index; /* 16-bit address + data */
171 	*data16 = cpu_to_be16(ctrl->buffer.addr);
172 	ctrl->index = 0;
173 
174 	return ov2722_i2c_write(client, size, (u8 *)&ctrl->buffer);
175 }
176 
__ov2722_buf_reg_array(struct i2c_client * client,struct ov2722_write_ctrl * ctrl,const struct ov2722_reg * next)177 static int __ov2722_buf_reg_array(struct i2c_client *client,
178 				  struct ov2722_write_ctrl *ctrl,
179 				  const struct ov2722_reg *next)
180 {
181 	int size;
182 	__be16 *data16;
183 
184 	switch (next->type) {
185 	case OV2722_8BIT:
186 		size = 1;
187 		ctrl->buffer.data[ctrl->index] = (u8)next->val;
188 		break;
189 	case OV2722_16BIT:
190 		size = 2;
191 		data16 = (void *)&ctrl->buffer.data[ctrl->index];
192 		*data16 = cpu_to_be16((u16)next->val);
193 		break;
194 	default:
195 		return -EINVAL;
196 	}
197 
198 	/* When first item is added, we need to store its starting address */
199 	if (ctrl->index == 0)
200 		ctrl->buffer.addr = next->reg;
201 
202 	ctrl->index += size;
203 
204 	/*
205 	 * Buffer cannot guarantee free space for u32? Better flush it to avoid
206 	 * possible lack of memory for next item.
207 	 */
208 	if (ctrl->index + sizeof(u16) >= OV2722_MAX_WRITE_BUF_SIZE)
209 		return __ov2722_flush_reg_array(client, ctrl);
210 
211 	return 0;
212 }
213 
__ov2722_write_reg_is_consecutive(struct i2c_client * client,struct ov2722_write_ctrl * ctrl,const struct ov2722_reg * next)214 static int __ov2722_write_reg_is_consecutive(struct i2c_client *client,
215 					     struct ov2722_write_ctrl *ctrl,
216 					     const struct ov2722_reg *next)
217 {
218 	if (ctrl->index == 0)
219 		return 1;
220 
221 	return ctrl->buffer.addr + ctrl->index == next->reg;
222 }
223 
ov2722_write_reg_array(struct i2c_client * client,const struct ov2722_reg * reglist)224 static int ov2722_write_reg_array(struct i2c_client *client,
225 				  const struct ov2722_reg *reglist)
226 {
227 	const struct ov2722_reg *next = reglist;
228 	struct ov2722_write_ctrl ctrl;
229 	int err;
230 
231 	ctrl.index = 0;
232 	for (; next->type != OV2722_TOK_TERM; next++) {
233 		switch (next->type & OV2722_TOK_MASK) {
234 		case OV2722_TOK_DELAY:
235 			err = __ov2722_flush_reg_array(client, &ctrl);
236 			if (err)
237 				return err;
238 			msleep(next->val);
239 			break;
240 		default:
241 			/*
242 			 * If next address is not consecutive, data needs to be
243 			 * flushed before proceed.
244 			 */
245 			if (!__ov2722_write_reg_is_consecutive(client, &ctrl,
246 							       next)) {
247 				err = __ov2722_flush_reg_array(client, &ctrl);
248 				if (err)
249 					return err;
250 			}
251 			err = __ov2722_buf_reg_array(client, &ctrl, next);
252 			if (err) {
253 				dev_err(&client->dev, "%s: write error, aborted\n",
254 					__func__);
255 				return err;
256 			}
257 			break;
258 		}
259 	}
260 
261 	return __ov2722_flush_reg_array(client, &ctrl);
262 }
263 
__ov2722_set_exposure(struct v4l2_subdev * sd,int coarse_itg,int gain,int digitgain)264 static long __ov2722_set_exposure(struct v4l2_subdev *sd, int coarse_itg,
265 				  int gain, int digitgain)
266 
267 {
268 	struct i2c_client *client = v4l2_get_subdevdata(sd);
269 	struct ov2722_device *dev = to_ov2722_sensor(sd);
270 	u16 hts, vts;
271 	int ret;
272 
273 	dev_dbg(&client->dev, "set_exposure without group hold\n");
274 
275 	/* clear VTS_DIFF on manual mode */
276 	ret = ov2722_write_reg(client, OV2722_16BIT, OV2722_VTS_DIFF_H, 0);
277 	if (ret)
278 		return ret;
279 
280 	hts = dev->pixels_per_line;
281 	vts = dev->lines_per_frame;
282 
283 	if ((coarse_itg + OV2722_COARSE_INTG_TIME_MAX_MARGIN) > vts)
284 		vts = coarse_itg + OV2722_COARSE_INTG_TIME_MAX_MARGIN;
285 
286 	coarse_itg <<= 4;
287 	digitgain <<= 2;
288 
289 	ret = ov2722_write_reg(client, OV2722_16BIT,
290 			       OV2722_VTS_H, vts);
291 	if (ret)
292 		return ret;
293 
294 	ret = ov2722_write_reg(client, OV2722_16BIT,
295 			       OV2722_HTS_H, hts);
296 	if (ret)
297 		return ret;
298 
299 	/* set exposure */
300 	ret = ov2722_write_reg(client, OV2722_8BIT,
301 			       OV2722_AEC_PK_EXPO_L,
302 			       coarse_itg & 0xff);
303 	if (ret)
304 		return ret;
305 
306 	ret = ov2722_write_reg(client, OV2722_16BIT,
307 			       OV2722_AEC_PK_EXPO_H,
308 			       (coarse_itg >> 8) & 0xfff);
309 	if (ret)
310 		return ret;
311 
312 	/* set analog gain */
313 	ret = ov2722_write_reg(client, OV2722_16BIT,
314 			       OV2722_AGC_ADJ_H, gain);
315 	if (ret)
316 		return ret;
317 
318 	/* set digital gain */
319 	ret = ov2722_write_reg(client, OV2722_16BIT,
320 			       OV2722_MWB_GAIN_R_H, digitgain);
321 	if (ret)
322 		return ret;
323 
324 	ret = ov2722_write_reg(client, OV2722_16BIT,
325 			       OV2722_MWB_GAIN_G_H, digitgain);
326 	if (ret)
327 		return ret;
328 
329 	ret = ov2722_write_reg(client, OV2722_16BIT,
330 			       OV2722_MWB_GAIN_B_H, digitgain);
331 
332 	return ret;
333 }
334 
ov2722_set_exposure(struct v4l2_subdev * sd,int exposure,int gain,int digitgain)335 static int ov2722_set_exposure(struct v4l2_subdev *sd, int exposure,
336 			       int gain, int digitgain)
337 {
338 	struct ov2722_device *dev = to_ov2722_sensor(sd);
339 	int ret;
340 
341 	mutex_lock(&dev->input_lock);
342 	ret = __ov2722_set_exposure(sd, exposure, gain, digitgain);
343 	mutex_unlock(&dev->input_lock);
344 
345 	return ret;
346 }
347 
ov2722_s_exposure(struct v4l2_subdev * sd,struct atomisp_exposure * exposure)348 static long ov2722_s_exposure(struct v4l2_subdev *sd,
349 			      struct atomisp_exposure *exposure)
350 {
351 	int exp = exposure->integration_time[0];
352 	int gain = exposure->gain[0];
353 	int digitgain = exposure->gain[1];
354 
355 	/* we should not accept the invalid value below. */
356 	if (gain == 0) {
357 		struct i2c_client *client = v4l2_get_subdevdata(sd);
358 
359 		v4l2_err(client, "%s: invalid value\n", __func__);
360 		return -EINVAL;
361 	}
362 
363 	return ov2722_set_exposure(sd, exp, gain, digitgain);
364 }
365 
ov2722_ioctl(struct v4l2_subdev * sd,unsigned int cmd,void * arg)366 static long ov2722_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg)
367 {
368 	switch (cmd) {
369 	case ATOMISP_IOC_S_EXPOSURE:
370 		return ov2722_s_exposure(sd, arg);
371 	default:
372 		return -EINVAL;
373 	}
374 	return 0;
375 }
376 
377 /* This returns the exposure time being used. This should only be used
378  * for filling in EXIF data, not for actual image processing.
379  */
ov2722_q_exposure(struct v4l2_subdev * sd,s32 * value)380 static int ov2722_q_exposure(struct v4l2_subdev *sd, s32 *value)
381 {
382 	struct i2c_client *client = v4l2_get_subdevdata(sd);
383 	u16 reg_v, reg_v2;
384 	int ret;
385 
386 	/* get exposure */
387 	ret = ov2722_read_reg(client, OV2722_8BIT,
388 			      OV2722_AEC_PK_EXPO_L,
389 			      &reg_v);
390 	if (ret)
391 		goto err;
392 
393 	ret = ov2722_read_reg(client, OV2722_8BIT,
394 			      OV2722_AEC_PK_EXPO_M,
395 			      &reg_v2);
396 	if (ret)
397 		goto err;
398 
399 	reg_v += reg_v2 << 8;
400 	ret = ov2722_read_reg(client, OV2722_8BIT,
401 			      OV2722_AEC_PK_EXPO_H,
402 			      &reg_v2);
403 	if (ret)
404 		goto err;
405 
406 	*value = reg_v + (((u32)reg_v2 << 16));
407 err:
408 	return ret;
409 }
410 
ov2722_g_volatile_ctrl(struct v4l2_ctrl * ctrl)411 static int ov2722_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
412 {
413 	struct ov2722_device *dev =
414 	    container_of(ctrl->handler, struct ov2722_device, ctrl_handler);
415 	int ret = 0;
416 	unsigned int val;
417 
418 	switch (ctrl->id) {
419 	case V4L2_CID_EXPOSURE_ABSOLUTE:
420 		ret = ov2722_q_exposure(&dev->sd, &ctrl->val);
421 		break;
422 	case V4L2_CID_LINK_FREQ:
423 		val = dev->res->mipi_freq;
424 		if (val == 0)
425 			return -EINVAL;
426 
427 		ctrl->val = val * 1000;	/* To Hz */
428 		break;
429 	default:
430 		ret = -EINVAL;
431 	}
432 
433 	return ret;
434 }
435 
436 static const struct v4l2_ctrl_ops ctrl_ops = {
437 	.g_volatile_ctrl = ov2722_g_volatile_ctrl
438 };
439 
440 static const struct v4l2_ctrl_config ov2722_controls[] = {
441 	{
442 		.ops = &ctrl_ops,
443 		.id = V4L2_CID_EXPOSURE_ABSOLUTE,
444 		.type = V4L2_CTRL_TYPE_INTEGER,
445 		.name = "exposure",
446 		.min = 0x0,
447 		.max = 0xffff,
448 		.step = 0x01,
449 		.def = 0x00,
450 		.flags = 0,
451 	},
452 	{
453 		.ops = &ctrl_ops,
454 		.id = V4L2_CID_LINK_FREQ,
455 		.name = "Link Frequency",
456 		.type = V4L2_CTRL_TYPE_INTEGER,
457 		.min = 1,
458 		.max = 1500000 * 1000,
459 		.step = 1,
460 		.def = 1,
461 		.flags = V4L2_CTRL_FLAG_VOLATILE | V4L2_CTRL_FLAG_READ_ONLY,
462 	},
463 };
464 
ov2722_init(struct v4l2_subdev * sd)465 static int ov2722_init(struct v4l2_subdev *sd)
466 {
467 	struct ov2722_device *dev = to_ov2722_sensor(sd);
468 
469 	mutex_lock(&dev->input_lock);
470 
471 	/* restore settings */
472 	ov2722_res = ov2722_res_preview;
473 	N_RES = N_RES_PREVIEW;
474 
475 	mutex_unlock(&dev->input_lock);
476 
477 	return 0;
478 }
479 
power_ctrl(struct v4l2_subdev * sd,bool flag)480 static int power_ctrl(struct v4l2_subdev *sd, bool flag)
481 {
482 	int ret = -1;
483 	struct ov2722_device *dev = to_ov2722_sensor(sd);
484 
485 	if (!dev || !dev->platform_data)
486 		return -ENODEV;
487 
488 	if (flag) {
489 		ret = dev->platform_data->v1p8_ctrl(sd, 1);
490 		if (ret == 0) {
491 			ret = dev->platform_data->v2p8_ctrl(sd, 1);
492 			if (ret)
493 				dev->platform_data->v1p8_ctrl(sd, 0);
494 		}
495 	} else {
496 		ret = dev->platform_data->v1p8_ctrl(sd, 0);
497 		ret |= dev->platform_data->v2p8_ctrl(sd, 0);
498 	}
499 
500 	return ret;
501 }
502 
gpio_ctrl(struct v4l2_subdev * sd,bool flag)503 static int gpio_ctrl(struct v4l2_subdev *sd, bool flag)
504 {
505 	struct ov2722_device *dev = to_ov2722_sensor(sd);
506 	int ret = -1;
507 
508 	if (!dev || !dev->platform_data)
509 		return -ENODEV;
510 
511 	/* Note: the GPIO order is asymmetric: always RESET#
512 	 * before PWDN# when turning it on or off.
513 	 */
514 	ret = dev->platform_data->gpio0_ctrl(sd, flag);
515 	ret |= dev->platform_data->gpio1_ctrl(sd, flag);
516 	return ret;
517 }
518 
power_up(struct v4l2_subdev * sd)519 static int power_up(struct v4l2_subdev *sd)
520 {
521 	struct ov2722_device *dev = to_ov2722_sensor(sd);
522 	struct i2c_client *client = v4l2_get_subdevdata(sd);
523 	int ret;
524 
525 	if (!dev->platform_data) {
526 		dev_err(&client->dev,
527 			"no camera_sensor_platform_data");
528 		return -ENODEV;
529 	}
530 
531 	if (dev->power_on == 1)
532 		return 0; /* Already on */
533 
534 	/* power control */
535 	ret = power_ctrl(sd, 1);
536 	if (ret)
537 		goto fail_power;
538 
539 	/* according to DS, at least 5ms is needed between DOVDD and PWDN */
540 	usleep_range(5000, 6000);
541 
542 	/* gpio ctrl */
543 	ret = gpio_ctrl(sd, 1);
544 	if (ret) {
545 		ret = gpio_ctrl(sd, 0);
546 		if (ret)
547 			goto fail_power;
548 	}
549 
550 	/* flis clock control */
551 	ret = dev->platform_data->flisclk_ctrl(sd, 1);
552 	if (ret)
553 		goto fail_clk;
554 
555 	/* according to DS, 20ms is needed between PWDN and i2c access */
556 	msleep(20);
557 
558 	dev->power_on = 1;
559 	return 0;
560 
561 fail_clk:
562 	gpio_ctrl(sd, 0);
563 fail_power:
564 	power_ctrl(sd, 0);
565 	dev_err(&client->dev, "sensor power-up failed\n");
566 
567 	return ret;
568 }
569 
power_down(struct v4l2_subdev * sd)570 static int power_down(struct v4l2_subdev *sd)
571 {
572 	struct ov2722_device *dev = to_ov2722_sensor(sd);
573 	struct i2c_client *client = v4l2_get_subdevdata(sd);
574 	int ret = 0;
575 
576 	if (!dev->platform_data) {
577 		dev_err(&client->dev,
578 			"no camera_sensor_platform_data");
579 		return -ENODEV;
580 	}
581 
582 	if (dev->power_on == 0)
583 		return 0; /* Already off */
584 
585 	ret = dev->platform_data->flisclk_ctrl(sd, 0);
586 	if (ret)
587 		dev_err(&client->dev, "flisclk failed\n");
588 
589 	/* gpio ctrl */
590 	ret = gpio_ctrl(sd, 0);
591 	if (ret) {
592 		ret = gpio_ctrl(sd, 0);
593 		if (ret)
594 			dev_err(&client->dev, "gpio failed 2\n");
595 	}
596 
597 	/* power control */
598 	ret = power_ctrl(sd, 0);
599 	if (ret)
600 		dev_err(&client->dev, "vprog failed.\n");
601 
602 	dev->power_on = 0;
603 	return ret;
604 }
605 
ov2722_s_power(struct v4l2_subdev * sd,int on)606 static int ov2722_s_power(struct v4l2_subdev *sd, int on)
607 {
608 	int ret;
609 
610 	if (on == 0)
611 		return power_down(sd);
612 
613 	ret = power_up(sd);
614 	if (!ret)
615 		return ov2722_init(sd);
616 
617 	return ret;
618 }
619 
620 /* TODO: remove it. */
startup(struct v4l2_subdev * sd)621 static int startup(struct v4l2_subdev *sd)
622 {
623 	struct ov2722_device *dev = to_ov2722_sensor(sd);
624 	struct i2c_client *client = v4l2_get_subdevdata(sd);
625 	int ret = 0;
626 
627 	ret = ov2722_write_reg(client, OV2722_8BIT,
628 			       OV2722_SW_RESET, 0x01);
629 	if (ret) {
630 		dev_err(&client->dev, "ov2722 reset err.\n");
631 		return ret;
632 	}
633 
634 	ret = ov2722_write_reg_array(client, dev->res->regs);
635 	if (ret) {
636 		dev_err(&client->dev, "ov2722 write register err.\n");
637 		return ret;
638 	}
639 
640 	return ret;
641 }
642 
ov2722_set_fmt(struct v4l2_subdev * sd,struct v4l2_subdev_state * sd_state,struct v4l2_subdev_format * format)643 static int ov2722_set_fmt(struct v4l2_subdev *sd,
644 			  struct v4l2_subdev_state *sd_state,
645 			  struct v4l2_subdev_format *format)
646 {
647 	struct v4l2_mbus_framefmt *fmt = &format->format;
648 	struct ov2722_device *dev = to_ov2722_sensor(sd);
649 	struct i2c_client *client = v4l2_get_subdevdata(sd);
650 	struct ov2722_resolution *res;
651 	struct camera_mipi_info *ov2722_info = NULL;
652 	int ret = 0;
653 
654 	if (format->pad)
655 		return -EINVAL;
656 	if (!fmt)
657 		return -EINVAL;
658 	ov2722_info = v4l2_get_subdev_hostdata(sd);
659 	if (!ov2722_info)
660 		return -EINVAL;
661 
662 	res = v4l2_find_nearest_size(ov2722_res_preview,
663 				     ARRAY_SIZE(ov2722_res_preview), width,
664 				     height, fmt->width, fmt->height);
665 	if (!res)
666 		res = &ov2722_res_preview[N_RES - 1];
667 
668 	fmt->width = res->width;
669 	fmt->height = res->height;
670 	dev->res = res;
671 
672 	fmt->code = MEDIA_BUS_FMT_SGRBG10_1X10;
673 	if (format->which == V4L2_SUBDEV_FORMAT_TRY) {
674 		sd_state->pads->try_fmt = *fmt;
675 		return 0;
676 	}
677 
678 	mutex_lock(&dev->input_lock);
679 
680 	/* s_power has not been called yet for std v4l2 clients (camorama) */
681 	power_up(sd);
682 
683 	dev->pixels_per_line = dev->res->pixels_per_line;
684 	dev->lines_per_frame = dev->res->lines_per_frame;
685 
686 	ret = startup(sd);
687 	if (ret) {
688 		int i = 0;
689 
690 		dev_err(&client->dev, "ov2722 startup err, retry to power up\n");
691 		for (i = 0; i < OV2722_POWER_UP_RETRY_NUM; i++) {
692 			dev_err(&client->dev,
693 				"ov2722 retry to power up %d/%d times, result: ",
694 				i + 1, OV2722_POWER_UP_RETRY_NUM);
695 			power_down(sd);
696 			ret = power_up(sd);
697 			if (ret) {
698 				dev_err(&client->dev, "power up failed, continue\n");
699 				continue;
700 			}
701 			ret = startup(sd);
702 			if (ret) {
703 				dev_err(&client->dev, " startup FAILED!\n");
704 			} else {
705 				dev_err(&client->dev, " startup SUCCESS!\n");
706 				break;
707 			}
708 		}
709 		if (ret) {
710 			dev_err(&client->dev, "ov2722 startup err\n");
711 			goto err;
712 		}
713 	}
714 
715 err:
716 	mutex_unlock(&dev->input_lock);
717 	return ret;
718 }
719 
ov2722_get_fmt(struct v4l2_subdev * sd,struct v4l2_subdev_state * sd_state,struct v4l2_subdev_format * format)720 static int ov2722_get_fmt(struct v4l2_subdev *sd,
721 			  struct v4l2_subdev_state *sd_state,
722 			  struct v4l2_subdev_format *format)
723 {
724 	struct v4l2_mbus_framefmt *fmt = &format->format;
725 	struct ov2722_device *dev = to_ov2722_sensor(sd);
726 
727 	if (format->pad)
728 		return -EINVAL;
729 	if (!fmt)
730 		return -EINVAL;
731 
732 	fmt->width = dev->res->width;
733 	fmt->height = dev->res->height;
734 	fmt->code = MEDIA_BUS_FMT_SBGGR10_1X10;
735 
736 	return 0;
737 }
738 
ov2722_detect(struct i2c_client * client)739 static int ov2722_detect(struct i2c_client *client)
740 {
741 	struct i2c_adapter *adapter = client->adapter;
742 	u16 high = 0, low = 0;
743 	u16 id;
744 	u8 revision;
745 
746 	if (!i2c_check_functionality(adapter, I2C_FUNC_I2C))
747 		return -ENODEV;
748 
749 	ov2722_read_reg(client, OV2722_8BIT,
750 			OV2722_SC_CMMN_CHIP_ID_H, &high);
751 	ov2722_read_reg(client, OV2722_8BIT,
752 			OV2722_SC_CMMN_CHIP_ID_L, &low);
753 	id = (high << 8) | low;
754 
755 	if ((id != OV2722_ID) && (id != OV2720_ID)) {
756 		dev_err(&client->dev, "sensor ID error\n");
757 		return -ENODEV;
758 	}
759 
760 	high = 0;
761 	ov2722_read_reg(client, OV2722_8BIT,
762 			OV2722_SC_CMMN_SUB_ID, &high);
763 	revision = (u8)high & 0x0f;
764 
765 	dev_dbg(&client->dev, "sensor_revision = 0x%x\n", revision);
766 	dev_dbg(&client->dev, "detect ov2722 success\n");
767 	return 0;
768 }
769 
ov2722_s_stream(struct v4l2_subdev * sd,int enable)770 static int ov2722_s_stream(struct v4l2_subdev *sd, int enable)
771 {
772 	struct ov2722_device *dev = to_ov2722_sensor(sd);
773 	struct i2c_client *client = v4l2_get_subdevdata(sd);
774 	int ret;
775 
776 	mutex_lock(&dev->input_lock);
777 
778 	ret = ov2722_write_reg(client, OV2722_8BIT, OV2722_SW_STREAM,
779 			       enable ? OV2722_START_STREAMING :
780 			       OV2722_STOP_STREAMING);
781 
782 	mutex_unlock(&dev->input_lock);
783 	return ret;
784 }
785 
ov2722_s_config(struct v4l2_subdev * sd,int irq,void * platform_data)786 static int ov2722_s_config(struct v4l2_subdev *sd,
787 			   int irq, void *platform_data)
788 {
789 	struct ov2722_device *dev = to_ov2722_sensor(sd);
790 	struct i2c_client *client = v4l2_get_subdevdata(sd);
791 	int ret = 0;
792 
793 	if (!platform_data)
794 		return -ENODEV;
795 
796 	dev->platform_data =
797 	    (struct camera_sensor_platform_data *)platform_data;
798 
799 	mutex_lock(&dev->input_lock);
800 
801 	/* power off the module, then power on it in future
802 	 * as first power on by board may not fulfill the
803 	 * power on sequqence needed by the module
804 	 */
805 	ret = power_down(sd);
806 	if (ret) {
807 		dev_err(&client->dev, "ov2722 power-off err.\n");
808 		goto fail_power_off;
809 	}
810 
811 	ret = power_up(sd);
812 	if (ret) {
813 		dev_err(&client->dev, "ov2722 power-up err.\n");
814 		goto fail_power_on;
815 	}
816 
817 	ret = dev->platform_data->csi_cfg(sd, 1);
818 	if (ret)
819 		goto fail_csi_cfg;
820 
821 	/* config & detect sensor */
822 	ret = ov2722_detect(client);
823 	if (ret) {
824 		dev_err(&client->dev, "ov2722_detect err s_config.\n");
825 		goto fail_csi_cfg;
826 	}
827 
828 	/* turn off sensor, after probed */
829 	ret = power_down(sd);
830 	if (ret) {
831 		dev_err(&client->dev, "ov2722 power-off err.\n");
832 		goto fail_csi_cfg;
833 	}
834 	mutex_unlock(&dev->input_lock);
835 
836 	return 0;
837 
838 fail_csi_cfg:
839 	dev->platform_data->csi_cfg(sd, 0);
840 fail_power_on:
841 	power_down(sd);
842 	dev_err(&client->dev, "sensor power-gating failed\n");
843 fail_power_off:
844 	mutex_unlock(&dev->input_lock);
845 	return ret;
846 }
847 
ov2722_g_frame_interval(struct v4l2_subdev * sd,struct v4l2_subdev_frame_interval * interval)848 static int ov2722_g_frame_interval(struct v4l2_subdev *sd,
849 				   struct v4l2_subdev_frame_interval *interval)
850 {
851 	struct ov2722_device *dev = to_ov2722_sensor(sd);
852 
853 	interval->interval.numerator = 1;
854 	interval->interval.denominator = dev->res->fps;
855 
856 	return 0;
857 }
858 
ov2722_enum_mbus_code(struct v4l2_subdev * sd,struct v4l2_subdev_state * sd_state,struct v4l2_subdev_mbus_code_enum * code)859 static int ov2722_enum_mbus_code(struct v4l2_subdev *sd,
860 				 struct v4l2_subdev_state *sd_state,
861 				 struct v4l2_subdev_mbus_code_enum *code)
862 {
863 	if (code->index >= MAX_FMTS)
864 		return -EINVAL;
865 
866 	code->code = MEDIA_BUS_FMT_SBGGR10_1X10;
867 	return 0;
868 }
869 
ov2722_enum_frame_size(struct v4l2_subdev * sd,struct v4l2_subdev_state * sd_state,struct v4l2_subdev_frame_size_enum * fse)870 static int ov2722_enum_frame_size(struct v4l2_subdev *sd,
871 				  struct v4l2_subdev_state *sd_state,
872 				  struct v4l2_subdev_frame_size_enum *fse)
873 {
874 	int index = fse->index;
875 
876 	if (index >= N_RES)
877 		return -EINVAL;
878 
879 	fse->min_width = ov2722_res[index].width;
880 	fse->min_height = ov2722_res[index].height;
881 	fse->max_width = ov2722_res[index].width;
882 	fse->max_height = ov2722_res[index].height;
883 
884 	return 0;
885 }
886 
ov2722_g_skip_frames(struct v4l2_subdev * sd,u32 * frames)887 static int ov2722_g_skip_frames(struct v4l2_subdev *sd, u32 *frames)
888 {
889 	struct ov2722_device *dev = to_ov2722_sensor(sd);
890 
891 	mutex_lock(&dev->input_lock);
892 	*frames = dev->res->skip_frames;
893 	mutex_unlock(&dev->input_lock);
894 
895 	return 0;
896 }
897 
898 static const struct v4l2_subdev_sensor_ops ov2722_sensor_ops = {
899 	.g_skip_frames	= ov2722_g_skip_frames,
900 };
901 
902 static const struct v4l2_subdev_video_ops ov2722_video_ops = {
903 	.s_stream = ov2722_s_stream,
904 	.g_frame_interval = ov2722_g_frame_interval,
905 };
906 
907 static const struct v4l2_subdev_core_ops ov2722_core_ops = {
908 	.s_power = ov2722_s_power,
909 	.ioctl = ov2722_ioctl,
910 };
911 
912 static const struct v4l2_subdev_pad_ops ov2722_pad_ops = {
913 	.enum_mbus_code = ov2722_enum_mbus_code,
914 	.enum_frame_size = ov2722_enum_frame_size,
915 	.get_fmt = ov2722_get_fmt,
916 	.set_fmt = ov2722_set_fmt,
917 };
918 
919 static const struct v4l2_subdev_ops ov2722_ops = {
920 	.core = &ov2722_core_ops,
921 	.video = &ov2722_video_ops,
922 	.pad = &ov2722_pad_ops,
923 	.sensor = &ov2722_sensor_ops,
924 };
925 
ov2722_remove(struct i2c_client * client)926 static void ov2722_remove(struct i2c_client *client)
927 {
928 	struct v4l2_subdev *sd = i2c_get_clientdata(client);
929 	struct ov2722_device *dev = to_ov2722_sensor(sd);
930 
931 	dev->platform_data->csi_cfg(sd, 0);
932 	v4l2_ctrl_handler_free(&dev->ctrl_handler);
933 	v4l2_device_unregister_subdev(sd);
934 
935 	atomisp_gmin_remove_subdev(sd);
936 
937 	media_entity_cleanup(&dev->sd.entity);
938 	kfree(dev);
939 }
940 
__ov2722_init_ctrl_handler(struct ov2722_device * dev)941 static int __ov2722_init_ctrl_handler(struct ov2722_device *dev)
942 {
943 	struct v4l2_ctrl_handler *hdl;
944 	unsigned int i;
945 
946 	hdl = &dev->ctrl_handler;
947 	v4l2_ctrl_handler_init(&dev->ctrl_handler, ARRAY_SIZE(ov2722_controls));
948 	for (i = 0; i < ARRAY_SIZE(ov2722_controls); i++)
949 		v4l2_ctrl_new_custom(&dev->ctrl_handler, &ov2722_controls[i],
950 				     NULL);
951 
952 	dev->link_freq = v4l2_ctrl_find(&dev->ctrl_handler, V4L2_CID_LINK_FREQ);
953 
954 	if (dev->ctrl_handler.error || !dev->link_freq)
955 		return dev->ctrl_handler.error;
956 
957 	dev->sd.ctrl_handler = hdl;
958 
959 	return 0;
960 }
961 
ov2722_probe(struct i2c_client * client)962 static int ov2722_probe(struct i2c_client *client)
963 {
964 	struct ov2722_device *dev;
965 	void *ovpdev;
966 	int ret;
967 
968 	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
969 	if (!dev)
970 		return -ENOMEM;
971 
972 	mutex_init(&dev->input_lock);
973 	dev->power_on = -1;
974 
975 	dev->res = &ov2722_res_preview[0];
976 	v4l2_i2c_subdev_init(&dev->sd, client, &ov2722_ops);
977 
978 	ovpdev = gmin_camera_platform_data(&dev->sd,
979 					   ATOMISP_INPUT_FORMAT_RAW_10,
980 					   atomisp_bayer_order_grbg);
981 
982 	ret = ov2722_s_config(&dev->sd, client->irq, ovpdev);
983 	if (ret)
984 		goto out_free;
985 
986 	ret = __ov2722_init_ctrl_handler(dev);
987 	if (ret)
988 		goto out_ctrl_handler_free;
989 
990 	dev->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
991 	dev->pad.flags = MEDIA_PAD_FL_SOURCE;
992 	dev->format.code = MEDIA_BUS_FMT_SBGGR10_1X10;
993 	dev->sd.entity.function = MEDIA_ENT_F_CAM_SENSOR;
994 
995 	ret = media_entity_pads_init(&dev->sd.entity, 1, &dev->pad);
996 	if (ret)
997 		ov2722_remove(client);
998 
999 	return atomisp_register_i2c_module(&dev->sd, ovpdev, RAW_CAMERA);
1000 
1001 out_ctrl_handler_free:
1002 	v4l2_ctrl_handler_free(&dev->ctrl_handler);
1003 
1004 out_free:
1005 	atomisp_gmin_remove_subdev(&dev->sd);
1006 	v4l2_device_unregister_subdev(&dev->sd);
1007 	kfree(dev);
1008 	return ret;
1009 }
1010 
1011 static const struct acpi_device_id ov2722_acpi_match[] = {
1012 	{ "INT33FB" },
1013 	{},
1014 };
1015 MODULE_DEVICE_TABLE(acpi, ov2722_acpi_match);
1016 
1017 static struct i2c_driver ov2722_driver = {
1018 	.driver = {
1019 		.name = "ov2722",
1020 		.acpi_match_table = ov2722_acpi_match,
1021 	},
1022 	.probe = ov2722_probe,
1023 	.remove = ov2722_remove,
1024 };
1025 module_i2c_driver(ov2722_driver);
1026 
1027 MODULE_AUTHOR("Wei Liu <wei.liu@intel.com>");
1028 MODULE_DESCRIPTION("A low-level driver for OmniVision 2722 sensors");
1029 MODULE_LICENSE("GPL");
1030