xref: /openbmc/linux/drivers/media/i2c/adv7183.c (revision 4f205687)
1 /*
2  * adv7183.c Analog Devices ADV7183 video decoder driver
3  *
4  * Copyright (c) 2011 Analog Devices Inc.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 as
8  * published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18  */
19 
20 #include <linux/delay.h>
21 #include <linux/errno.h>
22 #include <linux/gpio.h>
23 #include <linux/i2c.h>
24 #include <linux/init.h>
25 #include <linux/module.h>
26 #include <linux/slab.h>
27 #include <linux/types.h>
28 #include <linux/videodev2.h>
29 
30 #include <media/i2c/adv7183.h>
31 #include <media/v4l2-ctrls.h>
32 #include <media/v4l2-device.h>
33 
34 #include "adv7183_regs.h"
35 
36 struct adv7183 {
37 	struct v4l2_subdev sd;
38 	struct v4l2_ctrl_handler hdl;
39 
40 	v4l2_std_id std; /* Current set standard */
41 	u32 input;
42 	u32 output;
43 	unsigned reset_pin;
44 	unsigned oe_pin;
45 	struct v4l2_mbus_framefmt fmt;
46 };
47 
48 /* EXAMPLES USING 27 MHz CLOCK
49  * Mode 1 CVBS Input (Composite Video on AIN5)
50  * All standards are supported through autodetect, 8-bit, 4:2:2, ITU-R BT.656 output on P15 to P8.
51  */
52 static const unsigned char adv7183_init_regs[] = {
53 	ADV7183_IN_CTRL, 0x04,           /* CVBS input on AIN5 */
54 	ADV7183_DIGI_CLAMP_CTRL_1, 0x00, /* Slow down digital clamps */
55 	ADV7183_SHAP_FILT_CTRL, 0x41,    /* Set CSFM to SH1 */
56 	ADV7183_ADC_CTRL, 0x16,          /* Power down ADC 1 and ADC 2 */
57 	ADV7183_CTI_DNR_CTRL_4, 0x04,    /* Set DNR threshold to 4 for flat response */
58 	/* ADI recommended programming sequence */
59 	ADV7183_ADI_CTRL, 0x80,
60 	ADV7183_CTI_DNR_CTRL_4, 0x20,
61 	0x52, 0x18,
62 	0x58, 0xED,
63 	0x77, 0xC5,
64 	0x7C, 0x93,
65 	0x7D, 0x00,
66 	0xD0, 0x48,
67 	0xD5, 0xA0,
68 	0xD7, 0xEA,
69 	ADV7183_SD_SATURATION_CR, 0x3E,
70 	ADV7183_PAL_V_END, 0x3E,
71 	ADV7183_PAL_F_TOGGLE, 0x0F,
72 	ADV7183_ADI_CTRL, 0x00,
73 };
74 
75 static inline struct adv7183 *to_adv7183(struct v4l2_subdev *sd)
76 {
77 	return container_of(sd, struct adv7183, sd);
78 }
79 static inline struct v4l2_subdev *to_sd(struct v4l2_ctrl *ctrl)
80 {
81 	return &container_of(ctrl->handler, struct adv7183, hdl)->sd;
82 }
83 
84 static inline int adv7183_read(struct v4l2_subdev *sd, unsigned char reg)
85 {
86 	struct i2c_client *client = v4l2_get_subdevdata(sd);
87 
88 	return i2c_smbus_read_byte_data(client, reg);
89 }
90 
91 static inline int adv7183_write(struct v4l2_subdev *sd, unsigned char reg,
92 				unsigned char value)
93 {
94 	struct i2c_client *client = v4l2_get_subdevdata(sd);
95 
96 	return i2c_smbus_write_byte_data(client, reg, value);
97 }
98 
99 static int adv7183_writeregs(struct v4l2_subdev *sd,
100 		const unsigned char *regs, unsigned int num)
101 {
102 	unsigned char reg, data;
103 	unsigned int cnt = 0;
104 
105 	if (num & 0x1) {
106 		v4l2_err(sd, "invalid regs array\n");
107 		return -1;
108 	}
109 
110 	while (cnt < num) {
111 		reg = *regs++;
112 		data = *regs++;
113 		cnt += 2;
114 
115 		adv7183_write(sd, reg, data);
116 	}
117 	return 0;
118 }
119 
120 static int adv7183_log_status(struct v4l2_subdev *sd)
121 {
122 	struct adv7183 *decoder = to_adv7183(sd);
123 
124 	v4l2_info(sd, "adv7183: Input control = 0x%02x\n",
125 			adv7183_read(sd, ADV7183_IN_CTRL));
126 	v4l2_info(sd, "adv7183: Video selection = 0x%02x\n",
127 			adv7183_read(sd, ADV7183_VD_SEL));
128 	v4l2_info(sd, "adv7183: Output control = 0x%02x\n",
129 			adv7183_read(sd, ADV7183_OUT_CTRL));
130 	v4l2_info(sd, "adv7183: Extended output control = 0x%02x\n",
131 			adv7183_read(sd, ADV7183_EXT_OUT_CTRL));
132 	v4l2_info(sd, "adv7183: Autodetect enable = 0x%02x\n",
133 			adv7183_read(sd, ADV7183_AUTO_DET_EN));
134 	v4l2_info(sd, "adv7183: Contrast = 0x%02x\n",
135 			adv7183_read(sd, ADV7183_CONTRAST));
136 	v4l2_info(sd, "adv7183: Brightness = 0x%02x\n",
137 			adv7183_read(sd, ADV7183_BRIGHTNESS));
138 	v4l2_info(sd, "adv7183: Hue = 0x%02x\n",
139 			adv7183_read(sd, ADV7183_HUE));
140 	v4l2_info(sd, "adv7183: Default value Y = 0x%02x\n",
141 			adv7183_read(sd, ADV7183_DEF_Y));
142 	v4l2_info(sd, "adv7183: Default value C = 0x%02x\n",
143 			adv7183_read(sd, ADV7183_DEF_C));
144 	v4l2_info(sd, "adv7183: ADI control = 0x%02x\n",
145 			adv7183_read(sd, ADV7183_ADI_CTRL));
146 	v4l2_info(sd, "adv7183: Power Management = 0x%02x\n",
147 			adv7183_read(sd, ADV7183_POW_MANAGE));
148 	v4l2_info(sd, "adv7183: Status 1 2 and 3 = 0x%02x 0x%02x 0x%02x\n",
149 			adv7183_read(sd, ADV7183_STATUS_1),
150 			adv7183_read(sd, ADV7183_STATUS_2),
151 			adv7183_read(sd, ADV7183_STATUS_3));
152 	v4l2_info(sd, "adv7183: Ident = 0x%02x\n",
153 			adv7183_read(sd, ADV7183_IDENT));
154 	v4l2_info(sd, "adv7183: Analog clamp control = 0x%02x\n",
155 			adv7183_read(sd, ADV7183_ANAL_CLAMP_CTRL));
156 	v4l2_info(sd, "adv7183: Digital clamp control 1 = 0x%02x\n",
157 			adv7183_read(sd, ADV7183_DIGI_CLAMP_CTRL_1));
158 	v4l2_info(sd, "adv7183: Shaping filter control 1 and 2 = 0x%02x 0x%02x\n",
159 			adv7183_read(sd, ADV7183_SHAP_FILT_CTRL),
160 			adv7183_read(sd, ADV7183_SHAP_FILT_CTRL_2));
161 	v4l2_info(sd, "adv7183: Comb filter control = 0x%02x\n",
162 			adv7183_read(sd, ADV7183_COMB_FILT_CTRL));
163 	v4l2_info(sd, "adv7183: ADI control 2 = 0x%02x\n",
164 			adv7183_read(sd, ADV7183_ADI_CTRL_2));
165 	v4l2_info(sd, "adv7183: Pixel delay control = 0x%02x\n",
166 			adv7183_read(sd, ADV7183_PIX_DELAY_CTRL));
167 	v4l2_info(sd, "adv7183: Misc gain control = 0x%02x\n",
168 			adv7183_read(sd, ADV7183_MISC_GAIN_CTRL));
169 	v4l2_info(sd, "adv7183: AGC mode control = 0x%02x\n",
170 			adv7183_read(sd, ADV7183_AGC_MODE_CTRL));
171 	v4l2_info(sd, "adv7183: Chroma gain control 1 and 2 = 0x%02x 0x%02x\n",
172 			adv7183_read(sd, ADV7183_CHRO_GAIN_CTRL_1),
173 			adv7183_read(sd, ADV7183_CHRO_GAIN_CTRL_2));
174 	v4l2_info(sd, "adv7183: Luma gain control 1 and 2 = 0x%02x 0x%02x\n",
175 			adv7183_read(sd, ADV7183_LUMA_GAIN_CTRL_1),
176 			adv7183_read(sd, ADV7183_LUMA_GAIN_CTRL_2));
177 	v4l2_info(sd, "adv7183: Vsync field control 1 2 and 3 = 0x%02x 0x%02x 0x%02x\n",
178 			adv7183_read(sd, ADV7183_VS_FIELD_CTRL_1),
179 			adv7183_read(sd, ADV7183_VS_FIELD_CTRL_2),
180 			adv7183_read(sd, ADV7183_VS_FIELD_CTRL_3));
181 	v4l2_info(sd, "adv7183: Hsync position control 1 2 and 3 = 0x%02x 0x%02x 0x%02x\n",
182 			adv7183_read(sd, ADV7183_HS_POS_CTRL_1),
183 			adv7183_read(sd, ADV7183_HS_POS_CTRL_2),
184 			adv7183_read(sd, ADV7183_HS_POS_CTRL_3));
185 	v4l2_info(sd, "adv7183: Polarity = 0x%02x\n",
186 			adv7183_read(sd, ADV7183_POLARITY));
187 	v4l2_info(sd, "adv7183: ADC control = 0x%02x\n",
188 			adv7183_read(sd, ADV7183_ADC_CTRL));
189 	v4l2_info(sd, "adv7183: SD offset Cb and Cr = 0x%02x 0x%02x\n",
190 			adv7183_read(sd, ADV7183_SD_OFFSET_CB),
191 			adv7183_read(sd, ADV7183_SD_OFFSET_CR));
192 	v4l2_info(sd, "adv7183: SD saturation Cb and Cr = 0x%02x 0x%02x\n",
193 			adv7183_read(sd, ADV7183_SD_SATURATION_CB),
194 			adv7183_read(sd, ADV7183_SD_SATURATION_CR));
195 	v4l2_info(sd, "adv7183: Drive strength = 0x%02x\n",
196 			adv7183_read(sd, ADV7183_DRIVE_STR));
197 	v4l2_ctrl_handler_log_status(&decoder->hdl, sd->name);
198 	return 0;
199 }
200 
201 static int adv7183_g_std(struct v4l2_subdev *sd, v4l2_std_id *std)
202 {
203 	struct adv7183 *decoder = to_adv7183(sd);
204 
205 	*std = decoder->std;
206 	return 0;
207 }
208 
209 static int adv7183_s_std(struct v4l2_subdev *sd, v4l2_std_id std)
210 {
211 	struct adv7183 *decoder = to_adv7183(sd);
212 	int reg;
213 
214 	reg = adv7183_read(sd, ADV7183_IN_CTRL) & 0xF;
215 	if (std == V4L2_STD_PAL_60)
216 		reg |= 0x60;
217 	else if (std == V4L2_STD_NTSC_443)
218 		reg |= 0x70;
219 	else if (std == V4L2_STD_PAL_N)
220 		reg |= 0x90;
221 	else if (std == V4L2_STD_PAL_M)
222 		reg |= 0xA0;
223 	else if (std == V4L2_STD_PAL_Nc)
224 		reg |= 0xC0;
225 	else if (std & V4L2_STD_PAL)
226 		reg |= 0x80;
227 	else if (std & V4L2_STD_NTSC)
228 		reg |= 0x50;
229 	else if (std & V4L2_STD_SECAM)
230 		reg |= 0xE0;
231 	else
232 		return -EINVAL;
233 	adv7183_write(sd, ADV7183_IN_CTRL, reg);
234 
235 	decoder->std = std;
236 
237 	return 0;
238 }
239 
240 static int adv7183_reset(struct v4l2_subdev *sd, u32 val)
241 {
242 	int reg;
243 
244 	reg = adv7183_read(sd, ADV7183_POW_MANAGE) | 0x80;
245 	adv7183_write(sd, ADV7183_POW_MANAGE, reg);
246 	/* wait 5ms before any further i2c writes are performed */
247 	usleep_range(5000, 10000);
248 	return 0;
249 }
250 
251 static int adv7183_s_routing(struct v4l2_subdev *sd,
252 				u32 input, u32 output, u32 config)
253 {
254 	struct adv7183 *decoder = to_adv7183(sd);
255 	int reg;
256 
257 	if ((input > ADV7183_COMPONENT1) || (output > ADV7183_16BIT_OUT))
258 		return -EINVAL;
259 
260 	if (input != decoder->input) {
261 		decoder->input = input;
262 		reg = adv7183_read(sd, ADV7183_IN_CTRL) & 0xF0;
263 		switch (input) {
264 		case ADV7183_COMPOSITE1:
265 			reg |= 0x1;
266 			break;
267 		case ADV7183_COMPOSITE2:
268 			reg |= 0x2;
269 			break;
270 		case ADV7183_COMPOSITE3:
271 			reg |= 0x3;
272 			break;
273 		case ADV7183_COMPOSITE4:
274 			reg |= 0x4;
275 			break;
276 		case ADV7183_COMPOSITE5:
277 			reg |= 0x5;
278 			break;
279 		case ADV7183_COMPOSITE6:
280 			reg |= 0xB;
281 			break;
282 		case ADV7183_COMPOSITE7:
283 			reg |= 0xC;
284 			break;
285 		case ADV7183_COMPOSITE8:
286 			reg |= 0xD;
287 			break;
288 		case ADV7183_COMPOSITE9:
289 			reg |= 0xE;
290 			break;
291 		case ADV7183_COMPOSITE10:
292 			reg |= 0xF;
293 			break;
294 		case ADV7183_SVIDEO0:
295 			reg |= 0x6;
296 			break;
297 		case ADV7183_SVIDEO1:
298 			reg |= 0x7;
299 			break;
300 		case ADV7183_SVIDEO2:
301 			reg |= 0x8;
302 			break;
303 		case ADV7183_COMPONENT0:
304 			reg |= 0x9;
305 			break;
306 		case ADV7183_COMPONENT1:
307 			reg |= 0xA;
308 			break;
309 		default:
310 			break;
311 		}
312 		adv7183_write(sd, ADV7183_IN_CTRL, reg);
313 	}
314 
315 	if (output != decoder->output) {
316 		decoder->output = output;
317 		reg = adv7183_read(sd, ADV7183_OUT_CTRL) & 0xC0;
318 		switch (output) {
319 		case ADV7183_16BIT_OUT:
320 			reg |= 0x9;
321 			break;
322 		default:
323 			reg |= 0xC;
324 			break;
325 		}
326 		adv7183_write(sd, ADV7183_OUT_CTRL, reg);
327 	}
328 
329 	return 0;
330 }
331 
332 static int adv7183_s_ctrl(struct v4l2_ctrl *ctrl)
333 {
334 	struct v4l2_subdev *sd = to_sd(ctrl);
335 	int val = ctrl->val;
336 
337 	switch (ctrl->id) {
338 	case V4L2_CID_BRIGHTNESS:
339 		if (val < 0)
340 			val = 127 - val;
341 		adv7183_write(sd, ADV7183_BRIGHTNESS, val);
342 		break;
343 	case V4L2_CID_CONTRAST:
344 		adv7183_write(sd, ADV7183_CONTRAST, val);
345 		break;
346 	case V4L2_CID_SATURATION:
347 		adv7183_write(sd, ADV7183_SD_SATURATION_CB, val >> 8);
348 		adv7183_write(sd, ADV7183_SD_SATURATION_CR, (val & 0xFF));
349 		break;
350 	case V4L2_CID_HUE:
351 		adv7183_write(sd, ADV7183_SD_OFFSET_CB, val >> 8);
352 		adv7183_write(sd, ADV7183_SD_OFFSET_CR, (val & 0xFF));
353 		break;
354 	default:
355 		return -EINVAL;
356 	}
357 
358 	return 0;
359 }
360 
361 static int adv7183_querystd(struct v4l2_subdev *sd, v4l2_std_id *std)
362 {
363 	struct adv7183 *decoder = to_adv7183(sd);
364 	int reg;
365 
366 	/* enable autodetection block */
367 	reg = adv7183_read(sd, ADV7183_IN_CTRL) & 0xF;
368 	adv7183_write(sd, ADV7183_IN_CTRL, reg);
369 
370 	/* wait autodetection switch */
371 	mdelay(10);
372 
373 	/* get autodetection result */
374 	reg = adv7183_read(sd, ADV7183_STATUS_1);
375 	switch ((reg >> 0x4) & 0x7) {
376 	case 0:
377 		*std &= V4L2_STD_NTSC;
378 		break;
379 	case 1:
380 		*std &= V4L2_STD_NTSC_443;
381 		break;
382 	case 2:
383 		*std &= V4L2_STD_PAL_M;
384 		break;
385 	case 3:
386 		*std &= V4L2_STD_PAL_60;
387 		break;
388 	case 4:
389 		*std &= V4L2_STD_PAL;
390 		break;
391 	case 5:
392 		*std &= V4L2_STD_SECAM;
393 		break;
394 	case 6:
395 		*std &= V4L2_STD_PAL_Nc;
396 		break;
397 	case 7:
398 		*std &= V4L2_STD_SECAM;
399 		break;
400 	default:
401 		*std = V4L2_STD_UNKNOWN;
402 		break;
403 	}
404 
405 	/* after std detection, write back user set std */
406 	adv7183_s_std(sd, decoder->std);
407 	return 0;
408 }
409 
410 static int adv7183_g_input_status(struct v4l2_subdev *sd, u32 *status)
411 {
412 	int reg;
413 
414 	*status = V4L2_IN_ST_NO_SIGNAL;
415 	reg = adv7183_read(sd, ADV7183_STATUS_1);
416 	if (reg < 0)
417 		return reg;
418 	if (reg & 0x1)
419 		*status = 0;
420 	return 0;
421 }
422 
423 static int adv7183_enum_mbus_code(struct v4l2_subdev *sd,
424 		struct v4l2_subdev_pad_config *cfg,
425 		struct v4l2_subdev_mbus_code_enum *code)
426 {
427 	if (code->pad || code->index > 0)
428 		return -EINVAL;
429 
430 	code->code = MEDIA_BUS_FMT_UYVY8_2X8;
431 	return 0;
432 }
433 
434 static int adv7183_set_fmt(struct v4l2_subdev *sd,
435 		struct v4l2_subdev_pad_config *cfg,
436 		struct v4l2_subdev_format *format)
437 {
438 	struct adv7183 *decoder = to_adv7183(sd);
439 	struct v4l2_mbus_framefmt *fmt = &format->format;
440 
441 	if (format->pad)
442 		return -EINVAL;
443 
444 	fmt->code = MEDIA_BUS_FMT_UYVY8_2X8;
445 	fmt->colorspace = V4L2_COLORSPACE_SMPTE170M;
446 	if (decoder->std & V4L2_STD_525_60) {
447 		fmt->field = V4L2_FIELD_SEQ_TB;
448 		fmt->width = 720;
449 		fmt->height = 480;
450 	} else {
451 		fmt->field = V4L2_FIELD_SEQ_BT;
452 		fmt->width = 720;
453 		fmt->height = 576;
454 	}
455 	if (format->which == V4L2_SUBDEV_FORMAT_ACTIVE)
456 		decoder->fmt = *fmt;
457 	else
458 		cfg->try_fmt = *fmt;
459 	return 0;
460 }
461 
462 static int adv7183_get_fmt(struct v4l2_subdev *sd,
463 		struct v4l2_subdev_pad_config *cfg,
464 		struct v4l2_subdev_format *format)
465 {
466 	struct adv7183 *decoder = to_adv7183(sd);
467 
468 	if (format->pad)
469 		return -EINVAL;
470 
471 	format->format = decoder->fmt;
472 	return 0;
473 }
474 
475 static int adv7183_s_stream(struct v4l2_subdev *sd, int enable)
476 {
477 	struct adv7183 *decoder = to_adv7183(sd);
478 
479 	if (enable)
480 		gpio_set_value(decoder->oe_pin, 0);
481 	else
482 		gpio_set_value(decoder->oe_pin, 1);
483 	udelay(1);
484 	return 0;
485 }
486 
487 #ifdef CONFIG_VIDEO_ADV_DEBUG
488 static int adv7183_g_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg)
489 {
490 	reg->val = adv7183_read(sd, reg->reg & 0xff);
491 	reg->size = 1;
492 	return 0;
493 }
494 
495 static int adv7183_s_register(struct v4l2_subdev *sd, const struct v4l2_dbg_register *reg)
496 {
497 	adv7183_write(sd, reg->reg & 0xff, reg->val & 0xff);
498 	return 0;
499 }
500 #endif
501 
502 static const struct v4l2_ctrl_ops adv7183_ctrl_ops = {
503 	.s_ctrl = adv7183_s_ctrl,
504 };
505 
506 static const struct v4l2_subdev_core_ops adv7183_core_ops = {
507 	.log_status = adv7183_log_status,
508 	.reset = adv7183_reset,
509 #ifdef CONFIG_VIDEO_ADV_DEBUG
510 	.g_register = adv7183_g_register,
511 	.s_register = adv7183_s_register,
512 #endif
513 };
514 
515 static const struct v4l2_subdev_video_ops adv7183_video_ops = {
516 	.g_std = adv7183_g_std,
517 	.s_std = adv7183_s_std,
518 	.s_routing = adv7183_s_routing,
519 	.querystd = adv7183_querystd,
520 	.g_input_status = adv7183_g_input_status,
521 	.s_stream = adv7183_s_stream,
522 };
523 
524 static const struct v4l2_subdev_pad_ops adv7183_pad_ops = {
525 	.enum_mbus_code = adv7183_enum_mbus_code,
526 	.get_fmt = adv7183_get_fmt,
527 	.set_fmt = adv7183_set_fmt,
528 };
529 
530 static const struct v4l2_subdev_ops adv7183_ops = {
531 	.core = &adv7183_core_ops,
532 	.video = &adv7183_video_ops,
533 	.pad = &adv7183_pad_ops,
534 };
535 
536 static int adv7183_probe(struct i2c_client *client,
537 			const struct i2c_device_id *id)
538 {
539 	struct adv7183 *decoder;
540 	struct v4l2_subdev *sd;
541 	struct v4l2_ctrl_handler *hdl;
542 	int ret;
543 	struct v4l2_subdev_format fmt = {
544 		.which = V4L2_SUBDEV_FORMAT_ACTIVE,
545 	};
546 	const unsigned *pin_array;
547 
548 	/* Check if the adapter supports the needed features */
549 	if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
550 		return -EIO;
551 
552 	v4l_info(client, "chip found @ 0x%02x (%s)\n",
553 			client->addr << 1, client->adapter->name);
554 
555 	pin_array = client->dev.platform_data;
556 	if (pin_array == NULL)
557 		return -EINVAL;
558 
559 	decoder = devm_kzalloc(&client->dev, sizeof(*decoder), GFP_KERNEL);
560 	if (decoder == NULL)
561 		return -ENOMEM;
562 
563 	decoder->reset_pin = pin_array[0];
564 	decoder->oe_pin = pin_array[1];
565 
566 	if (devm_gpio_request_one(&client->dev, decoder->reset_pin,
567 				  GPIOF_OUT_INIT_LOW, "ADV7183 Reset")) {
568 		v4l_err(client, "failed to request GPIO %d\n", decoder->reset_pin);
569 		return -EBUSY;
570 	}
571 
572 	if (devm_gpio_request_one(&client->dev, decoder->oe_pin,
573 				  GPIOF_OUT_INIT_HIGH,
574 				  "ADV7183 Output Enable")) {
575 		v4l_err(client, "failed to request GPIO %d\n", decoder->oe_pin);
576 		return -EBUSY;
577 	}
578 
579 	sd = &decoder->sd;
580 	v4l2_i2c_subdev_init(sd, client, &adv7183_ops);
581 
582 	hdl = &decoder->hdl;
583 	v4l2_ctrl_handler_init(hdl, 4);
584 	v4l2_ctrl_new_std(hdl, &adv7183_ctrl_ops,
585 			V4L2_CID_BRIGHTNESS, -128, 127, 1, 0);
586 	v4l2_ctrl_new_std(hdl, &adv7183_ctrl_ops,
587 			V4L2_CID_CONTRAST, 0, 0xFF, 1, 0x80);
588 	v4l2_ctrl_new_std(hdl, &adv7183_ctrl_ops,
589 			V4L2_CID_SATURATION, 0, 0xFFFF, 1, 0x8080);
590 	v4l2_ctrl_new_std(hdl, &adv7183_ctrl_ops,
591 			V4L2_CID_HUE, 0, 0xFFFF, 1, 0x8080);
592 	/* hook the control handler into the driver */
593 	sd->ctrl_handler = hdl;
594 	if (hdl->error) {
595 		ret = hdl->error;
596 
597 		v4l2_ctrl_handler_free(hdl);
598 		return ret;
599 	}
600 
601 	/* v4l2 doesn't support an autodetect standard, pick PAL as default */
602 	decoder->std = V4L2_STD_PAL;
603 	decoder->input = ADV7183_COMPOSITE4;
604 	decoder->output = ADV7183_8BIT_OUT;
605 
606 	/* reset chip */
607 	/* reset pulse width at least 5ms */
608 	mdelay(10);
609 	gpio_set_value(decoder->reset_pin, 1);
610 	/* wait 5ms before any further i2c writes are performed */
611 	mdelay(5);
612 
613 	adv7183_writeregs(sd, adv7183_init_regs, ARRAY_SIZE(adv7183_init_regs));
614 	adv7183_s_std(sd, decoder->std);
615 	fmt.format.width = 720;
616 	fmt.format.height = 576;
617 	adv7183_set_fmt(sd, NULL, &fmt);
618 
619 	/* initialize the hardware to the default control values */
620 	ret = v4l2_ctrl_handler_setup(hdl);
621 	if (ret) {
622 		v4l2_ctrl_handler_free(hdl);
623 		return ret;
624 	}
625 
626 	return 0;
627 }
628 
629 static int adv7183_remove(struct i2c_client *client)
630 {
631 	struct v4l2_subdev *sd = i2c_get_clientdata(client);
632 
633 	v4l2_device_unregister_subdev(sd);
634 	v4l2_ctrl_handler_free(sd->ctrl_handler);
635 	return 0;
636 }
637 
638 static const struct i2c_device_id adv7183_id[] = {
639 	{"adv7183", 0},
640 	{},
641 };
642 
643 MODULE_DEVICE_TABLE(i2c, adv7183_id);
644 
645 static struct i2c_driver adv7183_driver = {
646 	.driver = {
647 		.owner  = THIS_MODULE,
648 		.name   = "adv7183",
649 	},
650 	.probe          = adv7183_probe,
651 	.remove         = adv7183_remove,
652 	.id_table       = adv7183_id,
653 };
654 
655 module_i2c_driver(adv7183_driver);
656 
657 MODULE_DESCRIPTION("Analog Devices ADV7183 video decoder driver");
658 MODULE_AUTHOR("Scott Jiang <Scott.Jiang.Linux@gmail.com>");
659 MODULE_LICENSE("GPL v2");
660