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