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