xref: /openbmc/linux/drivers/media/i2c/adv7180.c (revision c819e2cf)
1 /*
2  * adv7180.c Analog Devices ADV7180 video decoder driver
3  * Copyright (c) 2009 Intel Corporation
4  * Copyright (C) 2013 Cogent Embedded, Inc.
5  * Copyright (C) 2013 Renesas Solutions Corp.
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License version 2 as
9  * 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  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19  */
20 
21 #include <linux/module.h>
22 #include <linux/init.h>
23 #include <linux/errno.h>
24 #include <linux/kernel.h>
25 #include <linux/interrupt.h>
26 #include <linux/i2c.h>
27 #include <linux/slab.h>
28 #include <media/v4l2-ioctl.h>
29 #include <linux/videodev2.h>
30 #include <media/v4l2-device.h>
31 #include <media/v4l2-ctrls.h>
32 #include <linux/mutex.h>
33 
34 #define ADV7180_INPUT_CONTROL_REG			0x00
35 #define ADV7180_INPUT_CONTROL_AD_PAL_BG_NTSC_J_SECAM	0x00
36 #define ADV7180_INPUT_CONTROL_AD_PAL_BG_NTSC_J_SECAM_PED 0x10
37 #define ADV7180_INPUT_CONTROL_AD_PAL_N_NTSC_J_SECAM	0x20
38 #define ADV7180_INPUT_CONTROL_AD_PAL_N_NTSC_M_SECAM	0x30
39 #define ADV7180_INPUT_CONTROL_NTSC_J			0x40
40 #define ADV7180_INPUT_CONTROL_NTSC_M			0x50
41 #define ADV7180_INPUT_CONTROL_PAL60			0x60
42 #define ADV7180_INPUT_CONTROL_NTSC_443			0x70
43 #define ADV7180_INPUT_CONTROL_PAL_BG			0x80
44 #define ADV7180_INPUT_CONTROL_PAL_N			0x90
45 #define ADV7180_INPUT_CONTROL_PAL_M			0xa0
46 #define ADV7180_INPUT_CONTROL_PAL_M_PED			0xb0
47 #define ADV7180_INPUT_CONTROL_PAL_COMB_N		0xc0
48 #define ADV7180_INPUT_CONTROL_PAL_COMB_N_PED		0xd0
49 #define ADV7180_INPUT_CONTROL_PAL_SECAM			0xe0
50 #define ADV7180_INPUT_CONTROL_PAL_SECAM_PED		0xf0
51 #define ADV7180_INPUT_CONTROL_INSEL_MASK		0x0f
52 
53 #define ADV7180_EXTENDED_OUTPUT_CONTROL_REG		0x04
54 #define ADV7180_EXTENDED_OUTPUT_CONTROL_NTSCDIS		0xC5
55 
56 #define ADV7180_AUTODETECT_ENABLE_REG			0x07
57 #define ADV7180_AUTODETECT_DEFAULT			0x7f
58 /* Contrast */
59 #define ADV7180_CON_REG		0x08	/*Unsigned */
60 #define ADV7180_CON_MIN		0
61 #define ADV7180_CON_DEF		128
62 #define ADV7180_CON_MAX		255
63 /* Brightness*/
64 #define ADV7180_BRI_REG		0x0a	/*Signed */
65 #define ADV7180_BRI_MIN		-128
66 #define ADV7180_BRI_DEF		0
67 #define ADV7180_BRI_MAX		127
68 /* Hue */
69 #define ADV7180_HUE_REG		0x0b	/*Signed, inverted */
70 #define ADV7180_HUE_MIN		-127
71 #define ADV7180_HUE_DEF		0
72 #define ADV7180_HUE_MAX		128
73 
74 #define ADV7180_ADI_CTRL_REG				0x0e
75 #define ADV7180_ADI_CTRL_IRQ_SPACE			0x20
76 
77 #define ADV7180_PWR_MAN_REG		0x0f
78 #define ADV7180_PWR_MAN_ON		0x04
79 #define ADV7180_PWR_MAN_OFF		0x24
80 #define ADV7180_PWR_MAN_RES		0x80
81 
82 #define ADV7180_STATUS1_REG				0x10
83 #define ADV7180_STATUS1_IN_LOCK		0x01
84 #define ADV7180_STATUS1_AUTOD_MASK	0x70
85 #define ADV7180_STATUS1_AUTOD_NTSM_M_J	0x00
86 #define ADV7180_STATUS1_AUTOD_NTSC_4_43 0x10
87 #define ADV7180_STATUS1_AUTOD_PAL_M	0x20
88 #define ADV7180_STATUS1_AUTOD_PAL_60	0x30
89 #define ADV7180_STATUS1_AUTOD_PAL_B_G	0x40
90 #define ADV7180_STATUS1_AUTOD_SECAM	0x50
91 #define ADV7180_STATUS1_AUTOD_PAL_COMB	0x60
92 #define ADV7180_STATUS1_AUTOD_SECAM_525	0x70
93 
94 #define ADV7180_IDENT_REG 0x11
95 #define ADV7180_ID_7180 0x18
96 
97 #define ADV7180_ICONF1_ADI		0x40
98 #define ADV7180_ICONF1_ACTIVE_LOW	0x01
99 #define ADV7180_ICONF1_PSYNC_ONLY	0x10
100 #define ADV7180_ICONF1_ACTIVE_TO_CLR	0xC0
101 /* Saturation */
102 #define ADV7180_SD_SAT_CB_REG	0xe3	/*Unsigned */
103 #define ADV7180_SD_SAT_CR_REG	0xe4	/*Unsigned */
104 #define ADV7180_SAT_MIN		0
105 #define ADV7180_SAT_DEF		128
106 #define ADV7180_SAT_MAX		255
107 
108 #define ADV7180_IRQ1_LOCK	0x01
109 #define ADV7180_IRQ1_UNLOCK	0x02
110 #define ADV7180_ISR1_ADI	0x42
111 #define ADV7180_ICR1_ADI	0x43
112 #define ADV7180_IMR1_ADI	0x44
113 #define ADV7180_IMR2_ADI	0x48
114 #define ADV7180_IRQ3_AD_CHANGE	0x08
115 #define ADV7180_ISR3_ADI	0x4A
116 #define ADV7180_ICR3_ADI	0x4B
117 #define ADV7180_IMR3_ADI	0x4C
118 #define ADV7180_IMR4_ADI	0x50
119 
120 #define ADV7180_NTSC_V_BIT_END_REG	0xE6
121 #define ADV7180_NTSC_V_BIT_END_MANUAL_NVEND	0x4F
122 
123 struct adv7180_state {
124 	struct v4l2_ctrl_handler ctrl_hdl;
125 	struct v4l2_subdev	sd;
126 	struct mutex		mutex; /* mutual excl. when accessing chip */
127 	int			irq;
128 	v4l2_std_id		curr_norm;
129 	bool			autodetect;
130 	bool			powered;
131 	u8			input;
132 };
133 #define to_adv7180_sd(_ctrl) (&container_of(_ctrl->handler,		\
134 					    struct adv7180_state,	\
135 					    ctrl_hdl)->sd)
136 
137 static v4l2_std_id adv7180_std_to_v4l2(u8 status1)
138 {
139 	/* in case V4L2_IN_ST_NO_SIGNAL */
140 	if (!(status1 & ADV7180_STATUS1_IN_LOCK))
141 		return V4L2_STD_UNKNOWN;
142 
143 	switch (status1 & ADV7180_STATUS1_AUTOD_MASK) {
144 	case ADV7180_STATUS1_AUTOD_NTSM_M_J:
145 		return V4L2_STD_NTSC;
146 	case ADV7180_STATUS1_AUTOD_NTSC_4_43:
147 		return V4L2_STD_NTSC_443;
148 	case ADV7180_STATUS1_AUTOD_PAL_M:
149 		return V4L2_STD_PAL_M;
150 	case ADV7180_STATUS1_AUTOD_PAL_60:
151 		return V4L2_STD_PAL_60;
152 	case ADV7180_STATUS1_AUTOD_PAL_B_G:
153 		return V4L2_STD_PAL;
154 	case ADV7180_STATUS1_AUTOD_SECAM:
155 		return V4L2_STD_SECAM;
156 	case ADV7180_STATUS1_AUTOD_PAL_COMB:
157 		return V4L2_STD_PAL_Nc | V4L2_STD_PAL_N;
158 	case ADV7180_STATUS1_AUTOD_SECAM_525:
159 		return V4L2_STD_SECAM;
160 	default:
161 		return V4L2_STD_UNKNOWN;
162 	}
163 }
164 
165 static int v4l2_std_to_adv7180(v4l2_std_id std)
166 {
167 	if (std == V4L2_STD_PAL_60)
168 		return ADV7180_INPUT_CONTROL_PAL60;
169 	if (std == V4L2_STD_NTSC_443)
170 		return ADV7180_INPUT_CONTROL_NTSC_443;
171 	if (std == V4L2_STD_PAL_N)
172 		return ADV7180_INPUT_CONTROL_PAL_N;
173 	if (std == V4L2_STD_PAL_M)
174 		return ADV7180_INPUT_CONTROL_PAL_M;
175 	if (std == V4L2_STD_PAL_Nc)
176 		return ADV7180_INPUT_CONTROL_PAL_COMB_N;
177 
178 	if (std & V4L2_STD_PAL)
179 		return ADV7180_INPUT_CONTROL_PAL_BG;
180 	if (std & V4L2_STD_NTSC)
181 		return ADV7180_INPUT_CONTROL_NTSC_M;
182 	if (std & V4L2_STD_SECAM)
183 		return ADV7180_INPUT_CONTROL_PAL_SECAM;
184 
185 	return -EINVAL;
186 }
187 
188 static u32 adv7180_status_to_v4l2(u8 status1)
189 {
190 	if (!(status1 & ADV7180_STATUS1_IN_LOCK))
191 		return V4L2_IN_ST_NO_SIGNAL;
192 
193 	return 0;
194 }
195 
196 static int __adv7180_status(struct i2c_client *client, u32 *status,
197 			    v4l2_std_id *std)
198 {
199 	int status1 = i2c_smbus_read_byte_data(client, ADV7180_STATUS1_REG);
200 
201 	if (status1 < 0)
202 		return status1;
203 
204 	if (status)
205 		*status = adv7180_status_to_v4l2(status1);
206 	if (std)
207 		*std = adv7180_std_to_v4l2(status1);
208 
209 	return 0;
210 }
211 
212 static inline struct adv7180_state *to_state(struct v4l2_subdev *sd)
213 {
214 	return container_of(sd, struct adv7180_state, sd);
215 }
216 
217 static int adv7180_querystd(struct v4l2_subdev *sd, v4l2_std_id *std)
218 {
219 	struct adv7180_state *state = to_state(sd);
220 	int err = mutex_lock_interruptible(&state->mutex);
221 	if (err)
222 		return err;
223 
224 	/* when we are interrupt driven we know the state */
225 	if (!state->autodetect || state->irq > 0)
226 		*std = state->curr_norm;
227 	else
228 		err = __adv7180_status(v4l2_get_subdevdata(sd), NULL, std);
229 
230 	mutex_unlock(&state->mutex);
231 	return err;
232 }
233 
234 static int adv7180_s_routing(struct v4l2_subdev *sd, u32 input,
235 			     u32 output, u32 config)
236 {
237 	struct adv7180_state *state = to_state(sd);
238 	int ret = mutex_lock_interruptible(&state->mutex);
239 	struct i2c_client *client = v4l2_get_subdevdata(sd);
240 
241 	if (ret)
242 		return ret;
243 
244 	/* We cannot discriminate between LQFP and 40-pin LFCSP, so accept
245 	 * all inputs and let the card driver take care of validation
246 	 */
247 	if ((input & ADV7180_INPUT_CONTROL_INSEL_MASK) != input)
248 		goto out;
249 
250 	ret = i2c_smbus_read_byte_data(client, ADV7180_INPUT_CONTROL_REG);
251 
252 	if (ret < 0)
253 		goto out;
254 
255 	ret &= ~ADV7180_INPUT_CONTROL_INSEL_MASK;
256 	ret = i2c_smbus_write_byte_data(client,
257 					ADV7180_INPUT_CONTROL_REG, ret | input);
258 	state->input = input;
259 out:
260 	mutex_unlock(&state->mutex);
261 	return ret;
262 }
263 
264 static int adv7180_g_input_status(struct v4l2_subdev *sd, u32 *status)
265 {
266 	struct adv7180_state *state = to_state(sd);
267 	int ret = mutex_lock_interruptible(&state->mutex);
268 	if (ret)
269 		return ret;
270 
271 	ret = __adv7180_status(v4l2_get_subdevdata(sd), status, NULL);
272 	mutex_unlock(&state->mutex);
273 	return ret;
274 }
275 
276 static int adv7180_s_std(struct v4l2_subdev *sd, v4l2_std_id std)
277 {
278 	struct adv7180_state *state = to_state(sd);
279 	struct i2c_client *client = v4l2_get_subdevdata(sd);
280 	int ret = mutex_lock_interruptible(&state->mutex);
281 	if (ret)
282 		return ret;
283 
284 	/* all standards -> autodetect */
285 	if (std == V4L2_STD_ALL) {
286 		ret =
287 		    i2c_smbus_write_byte_data(client, ADV7180_INPUT_CONTROL_REG,
288 				ADV7180_INPUT_CONTROL_AD_PAL_BG_NTSC_J_SECAM
289 					      | state->input);
290 		if (ret < 0)
291 			goto out;
292 
293 		__adv7180_status(client, NULL, &state->curr_norm);
294 		state->autodetect = true;
295 	} else {
296 		ret = v4l2_std_to_adv7180(std);
297 		if (ret < 0)
298 			goto out;
299 
300 		ret = i2c_smbus_write_byte_data(client,
301 						ADV7180_INPUT_CONTROL_REG,
302 						ret | state->input);
303 		if (ret < 0)
304 			goto out;
305 
306 		state->curr_norm = std;
307 		state->autodetect = false;
308 	}
309 	ret = 0;
310 out:
311 	mutex_unlock(&state->mutex);
312 	return ret;
313 }
314 
315 static int adv7180_set_power(struct adv7180_state *state,
316 	struct i2c_client *client, bool on)
317 {
318 	u8 val;
319 
320 	if (on)
321 		val = ADV7180_PWR_MAN_ON;
322 	else
323 		val = ADV7180_PWR_MAN_OFF;
324 
325 	return i2c_smbus_write_byte_data(client, ADV7180_PWR_MAN_REG, val);
326 }
327 
328 static int adv7180_s_power(struct v4l2_subdev *sd, int on)
329 {
330 	struct adv7180_state *state = to_state(sd);
331 	struct i2c_client *client = v4l2_get_subdevdata(sd);
332 	int ret;
333 
334 	ret = mutex_lock_interruptible(&state->mutex);
335 	if (ret)
336 		return ret;
337 
338 	ret = adv7180_set_power(state, client, on);
339 	if (ret == 0)
340 		state->powered = on;
341 
342 	mutex_unlock(&state->mutex);
343 	return ret;
344 }
345 
346 static int adv7180_s_ctrl(struct v4l2_ctrl *ctrl)
347 {
348 	struct v4l2_subdev *sd = to_adv7180_sd(ctrl);
349 	struct adv7180_state *state = to_state(sd);
350 	struct i2c_client *client = v4l2_get_subdevdata(sd);
351 	int ret = mutex_lock_interruptible(&state->mutex);
352 	int val;
353 
354 	if (ret)
355 		return ret;
356 	val = ctrl->val;
357 	switch (ctrl->id) {
358 	case V4L2_CID_BRIGHTNESS:
359 		ret = i2c_smbus_write_byte_data(client, ADV7180_BRI_REG, val);
360 		break;
361 	case V4L2_CID_HUE:
362 		/*Hue is inverted according to HSL chart */
363 		ret = i2c_smbus_write_byte_data(client, ADV7180_HUE_REG, -val);
364 		break;
365 	case V4L2_CID_CONTRAST:
366 		ret = i2c_smbus_write_byte_data(client, ADV7180_CON_REG, val);
367 		break;
368 	case V4L2_CID_SATURATION:
369 		/*
370 		 *This could be V4L2_CID_BLUE_BALANCE/V4L2_CID_RED_BALANCE
371 		 *Let's not confuse the user, everybody understands saturation
372 		 */
373 		ret = i2c_smbus_write_byte_data(client, ADV7180_SD_SAT_CB_REG,
374 						val);
375 		if (ret < 0)
376 			break;
377 		ret = i2c_smbus_write_byte_data(client, ADV7180_SD_SAT_CR_REG,
378 						val);
379 		break;
380 	default:
381 		ret = -EINVAL;
382 	}
383 
384 	mutex_unlock(&state->mutex);
385 	return ret;
386 }
387 
388 static const struct v4l2_ctrl_ops adv7180_ctrl_ops = {
389 	.s_ctrl = adv7180_s_ctrl,
390 };
391 
392 static int adv7180_init_controls(struct adv7180_state *state)
393 {
394 	v4l2_ctrl_handler_init(&state->ctrl_hdl, 4);
395 
396 	v4l2_ctrl_new_std(&state->ctrl_hdl, &adv7180_ctrl_ops,
397 			  V4L2_CID_BRIGHTNESS, ADV7180_BRI_MIN,
398 			  ADV7180_BRI_MAX, 1, ADV7180_BRI_DEF);
399 	v4l2_ctrl_new_std(&state->ctrl_hdl, &adv7180_ctrl_ops,
400 			  V4L2_CID_CONTRAST, ADV7180_CON_MIN,
401 			  ADV7180_CON_MAX, 1, ADV7180_CON_DEF);
402 	v4l2_ctrl_new_std(&state->ctrl_hdl, &adv7180_ctrl_ops,
403 			  V4L2_CID_SATURATION, ADV7180_SAT_MIN,
404 			  ADV7180_SAT_MAX, 1, ADV7180_SAT_DEF);
405 	v4l2_ctrl_new_std(&state->ctrl_hdl, &adv7180_ctrl_ops,
406 			  V4L2_CID_HUE, ADV7180_HUE_MIN,
407 			  ADV7180_HUE_MAX, 1, ADV7180_HUE_DEF);
408 	state->sd.ctrl_handler = &state->ctrl_hdl;
409 	if (state->ctrl_hdl.error) {
410 		int err = state->ctrl_hdl.error;
411 
412 		v4l2_ctrl_handler_free(&state->ctrl_hdl);
413 		return err;
414 	}
415 	v4l2_ctrl_handler_setup(&state->ctrl_hdl);
416 
417 	return 0;
418 }
419 static void adv7180_exit_controls(struct adv7180_state *state)
420 {
421 	v4l2_ctrl_handler_free(&state->ctrl_hdl);
422 }
423 
424 static int adv7180_enum_mbus_fmt(struct v4l2_subdev *sd, unsigned int index,
425 				 u32 *code)
426 {
427 	if (index > 0)
428 		return -EINVAL;
429 
430 	*code = MEDIA_BUS_FMT_YUYV8_2X8;
431 
432 	return 0;
433 }
434 
435 static int adv7180_mbus_fmt(struct v4l2_subdev *sd,
436 			    struct v4l2_mbus_framefmt *fmt)
437 {
438 	struct adv7180_state *state = to_state(sd);
439 
440 	fmt->code = MEDIA_BUS_FMT_YUYV8_2X8;
441 	fmt->colorspace = V4L2_COLORSPACE_SMPTE170M;
442 	fmt->field = V4L2_FIELD_INTERLACED;
443 	fmt->width = 720;
444 	fmt->height = state->curr_norm & V4L2_STD_525_60 ? 480 : 576;
445 
446 	return 0;
447 }
448 
449 static int adv7180_g_mbus_config(struct v4l2_subdev *sd,
450 				 struct v4l2_mbus_config *cfg)
451 {
452 	/*
453 	 * The ADV7180 sensor supports BT.601/656 output modes.
454 	 * The BT.656 is default and not yet configurable by s/w.
455 	 */
456 	cfg->flags = V4L2_MBUS_MASTER | V4L2_MBUS_PCLK_SAMPLE_RISING |
457 		     V4L2_MBUS_DATA_ACTIVE_HIGH;
458 	cfg->type = V4L2_MBUS_BT656;
459 
460 	return 0;
461 }
462 
463 static const struct v4l2_subdev_video_ops adv7180_video_ops = {
464 	.s_std = adv7180_s_std,
465 	.querystd = adv7180_querystd,
466 	.g_input_status = adv7180_g_input_status,
467 	.s_routing = adv7180_s_routing,
468 	.enum_mbus_fmt = adv7180_enum_mbus_fmt,
469 	.try_mbus_fmt = adv7180_mbus_fmt,
470 	.g_mbus_fmt = adv7180_mbus_fmt,
471 	.s_mbus_fmt = adv7180_mbus_fmt,
472 	.g_mbus_config = adv7180_g_mbus_config,
473 };
474 
475 static const struct v4l2_subdev_core_ops adv7180_core_ops = {
476 	.s_power = adv7180_s_power,
477 };
478 
479 static const struct v4l2_subdev_ops adv7180_ops = {
480 	.core = &adv7180_core_ops,
481 	.video = &adv7180_video_ops,
482 };
483 
484 static irqreturn_t adv7180_irq(int irq, void *devid)
485 {
486 	struct adv7180_state *state = devid;
487 	struct i2c_client *client = v4l2_get_subdevdata(&state->sd);
488 	u8 isr3;
489 
490 	mutex_lock(&state->mutex);
491 	i2c_smbus_write_byte_data(client, ADV7180_ADI_CTRL_REG,
492 				  ADV7180_ADI_CTRL_IRQ_SPACE);
493 	isr3 = i2c_smbus_read_byte_data(client, ADV7180_ISR3_ADI);
494 	/* clear */
495 	i2c_smbus_write_byte_data(client, ADV7180_ICR3_ADI, isr3);
496 	i2c_smbus_write_byte_data(client, ADV7180_ADI_CTRL_REG, 0);
497 
498 	if (isr3 & ADV7180_IRQ3_AD_CHANGE && state->autodetect)
499 		__adv7180_status(client, NULL, &state->curr_norm);
500 	mutex_unlock(&state->mutex);
501 
502 	return IRQ_HANDLED;
503 }
504 
505 static int init_device(struct i2c_client *client, struct adv7180_state *state)
506 {
507 	int ret;
508 
509 	/* Initialize adv7180 */
510 	/* Enable autodetection */
511 	if (state->autodetect) {
512 		ret =
513 		    i2c_smbus_write_byte_data(client, ADV7180_INPUT_CONTROL_REG,
514 				ADV7180_INPUT_CONTROL_AD_PAL_BG_NTSC_J_SECAM
515 					      | state->input);
516 		if (ret < 0)
517 			return ret;
518 
519 		ret =
520 		    i2c_smbus_write_byte_data(client,
521 					      ADV7180_AUTODETECT_ENABLE_REG,
522 					      ADV7180_AUTODETECT_DEFAULT);
523 		if (ret < 0)
524 			return ret;
525 	} else {
526 		ret = v4l2_std_to_adv7180(state->curr_norm);
527 		if (ret < 0)
528 			return ret;
529 
530 		ret =
531 		    i2c_smbus_write_byte_data(client, ADV7180_INPUT_CONTROL_REG,
532 					      ret | state->input);
533 		if (ret < 0)
534 			return ret;
535 
536 	}
537 	/* ITU-R BT.656-4 compatible */
538 	ret = i2c_smbus_write_byte_data(client,
539 			ADV7180_EXTENDED_OUTPUT_CONTROL_REG,
540 			ADV7180_EXTENDED_OUTPUT_CONTROL_NTSCDIS);
541 	if (ret < 0)
542 		return ret;
543 
544 	/* Manually set V bit end position in NTSC mode */
545 	ret = i2c_smbus_write_byte_data(client,
546 					ADV7180_NTSC_V_BIT_END_REG,
547 					ADV7180_NTSC_V_BIT_END_MANUAL_NVEND);
548 	if (ret < 0)
549 		return ret;
550 
551 	/* read current norm */
552 	__adv7180_status(client, NULL, &state->curr_norm);
553 
554 	/* register for interrupts */
555 	if (state->irq > 0) {
556 		ret = request_threaded_irq(state->irq, NULL, adv7180_irq,
557 					   IRQF_ONESHOT, KBUILD_MODNAME, state);
558 		if (ret)
559 			return ret;
560 
561 		ret = i2c_smbus_write_byte_data(client, ADV7180_ADI_CTRL_REG,
562 						ADV7180_ADI_CTRL_IRQ_SPACE);
563 		if (ret < 0)
564 			goto err;
565 
566 		/* config the Interrupt pin to be active low */
567 		ret = i2c_smbus_write_byte_data(client, ADV7180_ICONF1_ADI,
568 						ADV7180_ICONF1_ACTIVE_LOW |
569 						ADV7180_ICONF1_PSYNC_ONLY);
570 		if (ret < 0)
571 			goto err;
572 
573 		ret = i2c_smbus_write_byte_data(client, ADV7180_IMR1_ADI, 0);
574 		if (ret < 0)
575 			goto err;
576 
577 		ret = i2c_smbus_write_byte_data(client, ADV7180_IMR2_ADI, 0);
578 		if (ret < 0)
579 			goto err;
580 
581 		/* enable AD change interrupts interrupts */
582 		ret = i2c_smbus_write_byte_data(client, ADV7180_IMR3_ADI,
583 						ADV7180_IRQ3_AD_CHANGE);
584 		if (ret < 0)
585 			goto err;
586 
587 		ret = i2c_smbus_write_byte_data(client, ADV7180_IMR4_ADI, 0);
588 		if (ret < 0)
589 			goto err;
590 
591 		ret = i2c_smbus_write_byte_data(client, ADV7180_ADI_CTRL_REG,
592 						0);
593 		if (ret < 0)
594 			goto err;
595 	}
596 
597 	return 0;
598 
599 err:
600 	free_irq(state->irq, state);
601 	return ret;
602 }
603 
604 static int adv7180_probe(struct i2c_client *client,
605 			 const struct i2c_device_id *id)
606 {
607 	struct adv7180_state *state;
608 	struct v4l2_subdev *sd;
609 	int ret;
610 
611 	/* Check if the adapter supports the needed features */
612 	if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
613 		return -EIO;
614 
615 	v4l_info(client, "chip found @ 0x%02x (%s)\n",
616 		 client->addr, client->adapter->name);
617 
618 	state = devm_kzalloc(&client->dev, sizeof(*state), GFP_KERNEL);
619 	if (state == NULL) {
620 		ret = -ENOMEM;
621 		goto err;
622 	}
623 
624 	state->irq = client->irq;
625 	mutex_init(&state->mutex);
626 	state->autodetect = true;
627 	state->powered = true;
628 	state->input = 0;
629 	sd = &state->sd;
630 	v4l2_i2c_subdev_init(sd, client, &adv7180_ops);
631 
632 	ret = adv7180_init_controls(state);
633 	if (ret)
634 		goto err_unreg_subdev;
635 	ret = init_device(client, state);
636 	if (ret)
637 		goto err_free_ctrl;
638 
639 	ret = v4l2_async_register_subdev(sd);
640 	if (ret)
641 		goto err_free_irq;
642 
643 	return 0;
644 
645 err_free_irq:
646 	if (state->irq > 0)
647 		free_irq(client->irq, state);
648 err_free_ctrl:
649 	adv7180_exit_controls(state);
650 err_unreg_subdev:
651 	mutex_destroy(&state->mutex);
652 err:
653 	return ret;
654 }
655 
656 static int adv7180_remove(struct i2c_client *client)
657 {
658 	struct v4l2_subdev *sd = i2c_get_clientdata(client);
659 	struct adv7180_state *state = to_state(sd);
660 
661 	v4l2_async_unregister_subdev(sd);
662 
663 	if (state->irq > 0)
664 		free_irq(client->irq, state);
665 
666 	adv7180_exit_controls(state);
667 	mutex_destroy(&state->mutex);
668 	return 0;
669 }
670 
671 static const struct i2c_device_id adv7180_id[] = {
672 	{KBUILD_MODNAME, 0},
673 	{},
674 };
675 
676 #ifdef CONFIG_PM_SLEEP
677 static int adv7180_suspend(struct device *dev)
678 {
679 	struct i2c_client *client = to_i2c_client(dev);
680 	struct v4l2_subdev *sd = i2c_get_clientdata(client);
681 	struct adv7180_state *state = to_state(sd);
682 
683 	return adv7180_set_power(state, client, false);
684 }
685 
686 static int adv7180_resume(struct device *dev)
687 {
688 	struct i2c_client *client = to_i2c_client(dev);
689 	struct v4l2_subdev *sd = i2c_get_clientdata(client);
690 	struct adv7180_state *state = to_state(sd);
691 	int ret;
692 
693 	if (state->powered) {
694 		ret = adv7180_set_power(state, client, true);
695 		if (ret)
696 			return ret;
697 	}
698 	ret = init_device(client, state);
699 	if (ret < 0)
700 		return ret;
701 	return 0;
702 }
703 
704 static SIMPLE_DEV_PM_OPS(adv7180_pm_ops, adv7180_suspend, adv7180_resume);
705 #define ADV7180_PM_OPS (&adv7180_pm_ops)
706 
707 #else
708 #define ADV7180_PM_OPS NULL
709 #endif
710 
711 MODULE_DEVICE_TABLE(i2c, adv7180_id);
712 
713 static struct i2c_driver adv7180_driver = {
714 	.driver = {
715 		   .owner = THIS_MODULE,
716 		   .name = KBUILD_MODNAME,
717 		   .pm = ADV7180_PM_OPS,
718 		   },
719 	.probe = adv7180_probe,
720 	.remove = adv7180_remove,
721 	.id_table = adv7180_id,
722 };
723 
724 module_i2c_driver(adv7180_driver);
725 
726 MODULE_DESCRIPTION("Analog Devices ADV7180 video decoder driver");
727 MODULE_AUTHOR("Mocean Laboratories");
728 MODULE_LICENSE("GPL v2");
729