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 }; 406 407 static const struct v4l2_subdev_ops adv7180_ops = { 408 .core = &adv7180_core_ops, 409 .video = &adv7180_video_ops, 410 }; 411 412 static void adv7180_work(struct work_struct *work) 413 { 414 struct adv7180_state *state = container_of(work, struct adv7180_state, 415 work); 416 struct i2c_client *client = v4l2_get_subdevdata(&state->sd); 417 u8 isr3; 418 419 mutex_lock(&state->mutex); 420 i2c_smbus_write_byte_data(client, ADV7180_ADI_CTRL_REG, 421 ADV7180_ADI_CTRL_IRQ_SPACE); 422 isr3 = i2c_smbus_read_byte_data(client, ADV7180_ISR3_ADI); 423 /* clear */ 424 i2c_smbus_write_byte_data(client, ADV7180_ICR3_ADI, isr3); 425 i2c_smbus_write_byte_data(client, ADV7180_ADI_CTRL_REG, 0); 426 427 if (isr3 & ADV7180_IRQ3_AD_CHANGE && state->autodetect) 428 __adv7180_status(client, NULL, &state->curr_norm); 429 mutex_unlock(&state->mutex); 430 431 enable_irq(state->irq); 432 } 433 434 static irqreturn_t adv7180_irq(int irq, void *devid) 435 { 436 struct adv7180_state *state = devid; 437 438 schedule_work(&state->work); 439 440 disable_irq_nosync(state->irq); 441 442 return IRQ_HANDLED; 443 } 444 445 static int init_device(struct i2c_client *client, struct adv7180_state *state) 446 { 447 int ret; 448 449 /* Initialize adv7180 */ 450 /* Enable autodetection */ 451 if (state->autodetect) { 452 ret = 453 i2c_smbus_write_byte_data(client, ADV7180_INPUT_CONTROL_REG, 454 ADV7180_INPUT_CONTROL_AD_PAL_BG_NTSC_J_SECAM 455 | state->input); 456 if (ret < 0) 457 return ret; 458 459 ret = 460 i2c_smbus_write_byte_data(client, 461 ADV7180_AUTODETECT_ENABLE_REG, 462 ADV7180_AUTODETECT_DEFAULT); 463 if (ret < 0) 464 return ret; 465 } else { 466 ret = v4l2_std_to_adv7180(state->curr_norm); 467 if (ret < 0) 468 return ret; 469 470 ret = 471 i2c_smbus_write_byte_data(client, ADV7180_INPUT_CONTROL_REG, 472 ret | state->input); 473 if (ret < 0) 474 return ret; 475 476 } 477 /* ITU-R BT.656-4 compatible */ 478 ret = i2c_smbus_write_byte_data(client, 479 ADV7180_EXTENDED_OUTPUT_CONTROL_REG, 480 ADV7180_EXTENDED_OUTPUT_CONTROL_NTSCDIS); 481 if (ret < 0) 482 return ret; 483 484 /* Manually set V bit end position in NTSC mode */ 485 ret = i2c_smbus_write_byte_data(client, 486 ADV7180_NTSC_V_BIT_END_REG, 487 ADV7180_NTSC_V_BIT_END_MANUAL_NVEND); 488 if (ret < 0) 489 return ret; 490 491 /* read current norm */ 492 __adv7180_status(client, NULL, &state->curr_norm); 493 494 /* register for interrupts */ 495 if (state->irq > 0) { 496 ret = request_irq(state->irq, adv7180_irq, 0, KBUILD_MODNAME, 497 state); 498 if (ret) 499 return ret; 500 501 ret = i2c_smbus_write_byte_data(client, ADV7180_ADI_CTRL_REG, 502 ADV7180_ADI_CTRL_IRQ_SPACE); 503 if (ret < 0) 504 return ret; 505 506 /* config the Interrupt pin to be active low */ 507 ret = i2c_smbus_write_byte_data(client, ADV7180_ICONF1_ADI, 508 ADV7180_ICONF1_ACTIVE_LOW | 509 ADV7180_ICONF1_PSYNC_ONLY); 510 if (ret < 0) 511 return ret; 512 513 ret = i2c_smbus_write_byte_data(client, ADV7180_IMR1_ADI, 0); 514 if (ret < 0) 515 return ret; 516 517 ret = i2c_smbus_write_byte_data(client, ADV7180_IMR2_ADI, 0); 518 if (ret < 0) 519 return ret; 520 521 /* enable AD change interrupts interrupts */ 522 ret = i2c_smbus_write_byte_data(client, ADV7180_IMR3_ADI, 523 ADV7180_IRQ3_AD_CHANGE); 524 if (ret < 0) 525 return ret; 526 527 ret = i2c_smbus_write_byte_data(client, ADV7180_IMR4_ADI, 0); 528 if (ret < 0) 529 return ret; 530 531 ret = i2c_smbus_write_byte_data(client, ADV7180_ADI_CTRL_REG, 532 0); 533 if (ret < 0) 534 return ret; 535 } 536 537 return 0; 538 } 539 540 static int adv7180_probe(struct i2c_client *client, 541 const struct i2c_device_id *id) 542 { 543 struct adv7180_state *state; 544 struct v4l2_subdev *sd; 545 int ret; 546 547 /* Check if the adapter supports the needed features */ 548 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 549 return -EIO; 550 551 v4l_info(client, "chip found @ 0x%02x (%s)\n", 552 client->addr, client->adapter->name); 553 554 state = kzalloc(sizeof(struct adv7180_state), GFP_KERNEL); 555 if (state == NULL) { 556 ret = -ENOMEM; 557 goto err; 558 } 559 560 state->irq = client->irq; 561 INIT_WORK(&state->work, adv7180_work); 562 mutex_init(&state->mutex); 563 state->autodetect = true; 564 state->input = 0; 565 sd = &state->sd; 566 v4l2_i2c_subdev_init(sd, client, &adv7180_ops); 567 568 ret = adv7180_init_controls(state); 569 if (ret) 570 goto err_unreg_subdev; 571 ret = init_device(client, state); 572 if (ret) 573 goto err_free_ctrl; 574 return 0; 575 576 err_free_ctrl: 577 adv7180_exit_controls(state); 578 err_unreg_subdev: 579 mutex_destroy(&state->mutex); 580 v4l2_device_unregister_subdev(sd); 581 kfree(state); 582 err: 583 printk(KERN_ERR KBUILD_MODNAME ": Failed to probe: %d\n", ret); 584 return ret; 585 } 586 587 static int adv7180_remove(struct i2c_client *client) 588 { 589 struct v4l2_subdev *sd = i2c_get_clientdata(client); 590 struct adv7180_state *state = to_state(sd); 591 592 if (state->irq > 0) { 593 free_irq(client->irq, state); 594 if (cancel_work_sync(&state->work)) { 595 /* 596 * Work was pending, therefore we need to enable 597 * IRQ here to balance the disable_irq() done in the 598 * interrupt handler. 599 */ 600 enable_irq(state->irq); 601 } 602 } 603 604 mutex_destroy(&state->mutex); 605 v4l2_device_unregister_subdev(sd); 606 kfree(to_state(sd)); 607 return 0; 608 } 609 610 static const struct i2c_device_id adv7180_id[] = { 611 {KBUILD_MODNAME, 0}, 612 {}, 613 }; 614 615 #ifdef CONFIG_PM 616 static int adv7180_suspend(struct i2c_client *client, pm_message_t state) 617 { 618 int ret; 619 620 ret = i2c_smbus_write_byte_data(client, ADV7180_PWR_MAN_REG, 621 ADV7180_PWR_MAN_OFF); 622 if (ret < 0) 623 return ret; 624 return 0; 625 } 626 627 static int adv7180_resume(struct i2c_client *client) 628 { 629 struct v4l2_subdev *sd = i2c_get_clientdata(client); 630 struct adv7180_state *state = to_state(sd); 631 int ret; 632 633 ret = i2c_smbus_write_byte_data(client, ADV7180_PWR_MAN_REG, 634 ADV7180_PWR_MAN_ON); 635 if (ret < 0) 636 return ret; 637 ret = init_device(client, state); 638 if (ret < 0) 639 return ret; 640 return 0; 641 } 642 #endif 643 644 MODULE_DEVICE_TABLE(i2c, adv7180_id); 645 646 static struct i2c_driver adv7180_driver = { 647 .driver = { 648 .owner = THIS_MODULE, 649 .name = KBUILD_MODNAME, 650 }, 651 .probe = adv7180_probe, 652 .remove = adv7180_remove, 653 #ifdef CONFIG_PM 654 .suspend = adv7180_suspend, 655 .resume = adv7180_resume, 656 #endif 657 .id_table = adv7180_id, 658 }; 659 660 module_i2c_driver(adv7180_driver); 661 662 MODULE_DESCRIPTION("Analog Devices ADV7180 video decoder driver"); 663 MODULE_AUTHOR("Mocean Laboratories"); 664 MODULE_LICENSE("GPL v2"); 665