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
123struct 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
137static 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
165static 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
188static 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
196static 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
212static inline struct adv7180_state *to_state(struct v4l2_subdev *sd)
213{
214	return container_of(sd, struct adv7180_state, sd);
215}
216
217static 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
234static 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;
259out:
260	mutex_unlock(&state->mutex);
261	return ret;
262}
263
264static 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
276static 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;
310out:
311	mutex_unlock(&state->mutex);
312	return ret;
313}
314
315static 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
328static 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
346static 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
388static const struct v4l2_ctrl_ops adv7180_ctrl_ops = {
389	.s_ctrl = adv7180_s_ctrl,
390};
391
392static 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}
419static void adv7180_exit_controls(struct adv7180_state *state)
420{
421	v4l2_ctrl_handler_free(&state->ctrl_hdl);
422}
423
424static int adv7180_enum_mbus_fmt(struct v4l2_subdev *sd, unsigned int index,
425				 enum v4l2_mbus_pixelcode *code)
426{
427	if (index > 0)
428		return -EINVAL;
429
430	*code = V4L2_MBUS_FMT_YUYV8_2X8;
431
432	return 0;
433}
434
435static 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 = V4L2_MBUS_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
449static 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
463static 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
475static const struct v4l2_subdev_core_ops adv7180_core_ops = {
476	.s_power = adv7180_s_power,
477};
478
479static const struct v4l2_subdev_ops adv7180_ops = {
480	.core = &adv7180_core_ops,
481	.video = &adv7180_video_ops,
482};
483
484static 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
505static 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
599err:
600	free_irq(state->irq, state);
601	return ret;
602}
603
604static 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
645err_free_irq:
646	if (state->irq > 0)
647		free_irq(client->irq, state);
648err_free_ctrl:
649	adv7180_exit_controls(state);
650err_unreg_subdev:
651	mutex_destroy(&state->mutex);
652err:
653	return ret;
654}
655
656static 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
671static const struct i2c_device_id adv7180_id[] = {
672	{KBUILD_MODNAME, 0},
673	{},
674};
675
676#ifdef CONFIG_PM_SLEEP
677static 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
686static 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
704static 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
711MODULE_DEVICE_TABLE(i2c, adv7180_id);
712
713static 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
724module_i2c_driver(adv7180_driver);
725
726MODULE_DESCRIPTION("Analog Devices ADV7180 video decoder driver");
727MODULE_AUTHOR("Mocean Laboratories");
728MODULE_LICENSE("GPL v2");
729