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