/* * ADV7280 camera decoder driver, based on ADV7180 driver * * Copyright (c) 2014 Antmicro Ltd * Based on ADV7180 video decoder driver, * Copyright (c) 2009 Intel Corporation * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define DRIVER_NAME "adv7280" #define HW_DEINT /* Enable hardware deinterlacer */ #define CSI #define VPP_SLAVE_ADDRESS 0x42 #define CSI_SLAVE_ADDRESS 0x44 /* User Sub Map Regs */ #define ADV7280_INPUT_CONTROL 0x00 #define ADV7280_VIDEO_SELECTION_1 0x01 #define ADV7280_VIDEO_SELECTION_2 0x02 #define ADV7280_OUTPUT_CONTROL 0x03 #define ADV7280_EXTENDED_OUTPUT_CONTROL 0x04 #define ADV7280_AUTODETECT_ENABLE 0x07 #define ADV7280_ADI_CONTROL_1 0x0E #define ADV7280_POWER_MANAGEMENT 0x0F #define ADV7280_STATUS_1 0x10 #define ADV7280_IDENT 0x11 #define ADV7280_SHAPING_FILTER_CONTROL_1 0x17 #define ADV7280_ADI_CONTROL_2 0x1D #define ADV7280_PIXEL_DELAY_CONTROL 0x27 #define ADV7280_VPP_SLAVE_ADDRESS 0xFD #define ADV7280_CSI_TX_SLAVE_ADDRESS 0xFE #define ADV7280_OUTPUT_SYNC_SELECT_2 0x6B /* VPP regs (Video Postprocessor) */ #define VPP_DEINT_RESET 0x41 #define VPP_I2C_DEINT_ENABLE 0x55 #define VPP_ADV_TIMING_MODE_EN 0x5B /* CSI regs (Camera Serial Interface, MIPI-CSI2) */ #define CSI_CSITX_PWRDN 0x00 #define CSI_DPHY_PWRDN_CTL 0xDE /* other */ #define ADV7280_EXTENDED_OUTPUT_CONTROL_NTSCDIS 0xC5 #define ADV7280_AUTODETECT_DEFAULT 0x7f #define ADV7280_INPUT_CONTROL_COMPOSITE_IN1 0x00 #define ADV7280_INPUT_CONTROL_AD_PAL_BG_NTSC_J_SECAM 0x00 #define ADV7280_INPUT_CONTROL_NTSC_M 0x50 #define ADV7280_INPUT_CONTROL_PAL60 0x60 #define ADV7280_INPUT_CONTROL_NTSC_443 0x70 #define ADV7280_INPUT_CONTROL_PAL_BG 0x80 #define ADV7280_INPUT_CONTROL_PAL_N 0x90 #define ADV7280_INPUT_CONTROL_PAL_M 0xa0 #define ADV7280_INPUT_CONTROL_PAL_M_PED 0xb0 #define ADV7280_INPUT_CONTROL_PAL_COMB_N 0xc0 #define ADV7280_INPUT_CONTROL_PAL_COMB_N_PED 0xd0 #define ADV7280_INPUT_CONTROL_PAL_SECAM 0xe0 #define ADV7280_ADI_CTRL_IRQ_SPACE 0x20 #define ADV7280_STATUS1_IN_LOCK 0x01 #define ADV7280_STATUS1_AUTOD_MASK 0x70 #define ADV7280_STATUS1_AUTOD_NTSM_M_J 0x00 #define ADV7280_STATUS1_AUTOD_NTSC_4_43 0x10 #define ADV7280_STATUS1_AUTOD_PAL_M 0x20 #define ADV7280_STATUS1_AUTOD_PAL_60 0x30 #define ADV7280_STATUS1_AUTOD_PAL_B_G 0x40 #define ADV7280_STATUS1_AUTOD_SECAM 0x50 #define ADV7280_STATUS1_AUTOD_PAL_COMB 0x60 #define ADV7280_STATUS1_AUTOD_SECAM_525 0x70 #define ADV7280_ICONF1_ADI 0x40 #define ADV7280_ICONF1_ACTIVE_LOW 0x01 #define ADV7280_ICONF1_PSYNC_ONLY 0x10 #define ADV7280_IMR1_ADI 0x44 #define ADV7280_IMR2_ADI 0x48 #define ADV7280_IRQ3_AD_CHANGE 0x08 #define ADV7280_ISR3_ADI 0x4A #define ADV7280_ICR3_ADI 0x4B #define ADV7280_IMR3_ADI 0x4C #define ADV7280_IMR4_ADI 0x50 struct adv7280_state { struct v4l2_subdev sd; struct work_struct work; struct mutex mutex; /* mutual excl. when accessing chip */ int irq; v4l2_std_id curr_norm; bool autodetect; int active_input; }; static v4l2_std_id adv7280_std_to_v4l2(u8 status1) { switch (status1 & ADV7280_STATUS1_AUTOD_MASK) { case ADV7280_STATUS1_AUTOD_NTSM_M_J: return V4L2_STD_NTSC; case ADV7280_STATUS1_AUTOD_NTSC_4_43: return V4L2_STD_NTSC_443; case ADV7280_STATUS1_AUTOD_PAL_M: return V4L2_STD_PAL_M; case ADV7280_STATUS1_AUTOD_PAL_60: return V4L2_STD_PAL_60; case ADV7280_STATUS1_AUTOD_PAL_B_G: return V4L2_STD_PAL; case ADV7280_STATUS1_AUTOD_SECAM: return V4L2_STD_SECAM; case ADV7280_STATUS1_AUTOD_PAL_COMB: return V4L2_STD_PAL_Nc | V4L2_STD_PAL_N; case ADV7280_STATUS1_AUTOD_SECAM_525: return V4L2_STD_SECAM; default: return V4L2_STD_UNKNOWN; } } static int v4l2_std_to_adv7280(v4l2_std_id std) { if (std == V4L2_STD_PAL_60) return ADV7280_INPUT_CONTROL_PAL60; if (std == V4L2_STD_NTSC_443) return ADV7280_INPUT_CONTROL_NTSC_443; if (std == V4L2_STD_PAL_N) return ADV7280_INPUT_CONTROL_PAL_N; if (std == V4L2_STD_PAL_M) return ADV7280_INPUT_CONTROL_PAL_M; if (std == V4L2_STD_PAL_Nc) return ADV7280_INPUT_CONTROL_PAL_COMB_N; if (std & V4L2_STD_PAL) return ADV7280_INPUT_CONTROL_PAL_BG; if (std & V4L2_STD_NTSC) return ADV7280_INPUT_CONTROL_NTSC_M; if (std & V4L2_STD_SECAM) return ADV7280_INPUT_CONTROL_PAL_SECAM; return -EINVAL; } static int adv7280_write_reg(struct i2c_client *client, u8 reg, u8 val) { i2c_smbus_write_byte_data(client, reg, val); return 0; } static u32 adv7280_status_to_v4l2(u8 status1) { if (!(status1 & ADV7280_STATUS1_IN_LOCK)) return V4L2_IN_ST_NO_SIGNAL; return 0; } static int __adv7280_status(struct i2c_client *client, u32 *status, v4l2_std_id *std) { int status1 = i2c_smbus_read_byte_data(client, ADV7280_STATUS_1); if (status1 < 0) return status1; if (status) *status = adv7280_status_to_v4l2(status1); if (std) *std = adv7280_std_to_v4l2(status1); return 0; } static inline struct adv7280_state *to_state(struct v4l2_subdev *sd) { return container_of(sd, struct adv7280_state, sd); } static int adv7280_querystd(struct v4l2_subdev *sd, v4l2_std_id *std) { struct adv7280_state *state = to_state(sd); int err = mutex_lock_interruptible(&state->mutex); if (err) return err; /* when we are interrupt driven we know the state */ if (!state->autodetect || state->irq > 0) *std = state->curr_norm; else err = __adv7280_status(v4l2_get_subdevdata(sd), NULL, std); mutex_unlock(&state->mutex); return err; } static int adv7280_g_input_status(struct v4l2_subdev *sd, u32 *status) { struct adv7280_state *state = to_state(sd); int ret = mutex_lock_interruptible(&state->mutex); if (ret) return ret; ret = __adv7280_status(v4l2_get_subdevdata(sd), status, NULL); mutex_unlock(&state->mutex); return ret; } /* static int adv7280_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_dbg_chip_ident *chip) { struct i2c_client *client = v4l2_get_subdevdata(sd); return v4l2_chip_ident_i2c_client(client, chip, V4L2_IDENT_ADV7280, 0); } */ static int adv7280_s_std(struct v4l2_subdev *sd, v4l2_std_id std) { struct adv7280_state *state = to_state(sd); struct i2c_client *client = v4l2_get_subdevdata(sd); int ret = mutex_lock_interruptible(&state->mutex); if (ret) return ret; /* all standards -> autodetect */ if (std == V4L2_STD_ALL) { ret = adv7280_write_reg(client, ADV7280_INPUT_CONTROL, ADV7280_INPUT_CONTROL_AD_PAL_BG_NTSC_J_SECAM | (ADV7280_INPUT_CONTROL_COMPOSITE_IN1 + state->active_input)); if (ret < 0) goto out; __adv7280_status(client, NULL, &state->curr_norm); state->autodetect = true; } else { ret = v4l2_std_to_adv7280(std) | (ADV7280_INPUT_CONTROL_COMPOSITE_IN1 + state->active_input); if (ret < 0) goto out; ret = adv7280_write_reg(client, ADV7280_INPUT_CONTROL, ret); if (ret < 0) goto out; state->curr_norm = std; state->autodetect = false; } ret = 0; out: mutex_unlock(&state->mutex); return ret; } /* static int adv7280_set_bus_param(struct soc_camera_device *icd, unsigned long flags) { return 0; } */ /* Request bus settings on camera side */ /* static unsigned long adv7280_query_bus_param(struct soc_camera_device *icd) { struct soc_camera_link *icl = to_soc_camera_link(icd); unsigned long flags = SOCAM_PCLK_SAMPLE_RISING | SOCAM_MASTER | SOCAM_VSYNC_ACTIVE_HIGH | SOCAM_HSYNC_ACTIVE_HIGH | SOCAM_DATA_ACTIVE_HIGH | SOCAM_DATAWIDTH_8; return soc_camera_apply_sensor_flags(icl, flags); } */ static enum v4l2_mbus_pixelcode adv7280_codes[] = { V4L2_MBUS_FMT_UYVY8_2X8, }; static int adv7280_s_fmt(struct v4l2_subdev *sd, struct v4l2_mbus_framefmt *mf) { enum v4l2_colorspace cspace; enum v4l2_mbus_pixelcode code = mf->code; switch (code) { case V4L2_MBUS_FMT_UYVY8_2X8: cspace = V4L2_COLORSPACE_SMPTE170M; break; default: return -EINVAL; } mf->code = code; mf->colorspace = cspace; return adv7280_s_std(sd, V4L2_STD_ALL); } static int adv7280_try_fmt(struct v4l2_subdev *sd, struct v4l2_mbus_framefmt *mf) { #ifdef HW_DEINT mf->field = V4L2_FIELD_NONE; #else mf->field = V4L2_FIELD_INTERLACED_TB; #endif mf->code = V4L2_MBUS_FMT_UYVY8_2X8; mf->colorspace = V4L2_COLORSPACE_SMPTE170M; /* PAL, line aligned to 64B */ mf->width = 736; mf->height = 576; return 0; } static int adv7280_s_power(struct v4l2_subdev *sd, int on) { struct i2c_client *client = v4l2_get_subdevdata(sd); struct soc_camera_subdev_desc *scsd = soc_camera_i2c_to_desc(client); return soc_camera_set_power(&client->dev, scsd, on); } static int adv7280_enum_fmt(struct v4l2_subdev *sd, unsigned int index, enum v4l2_mbus_pixelcode *code) { if (index >= ARRAY_SIZE(adv7280_codes)) return -EINVAL; *code = adv7280_codes[index]; return 0; } /* static struct soc_camera_ops adv7280_ops = { .set_bus_param = adv7280_set_bus_param, .query_bus_param = adv7280_query_bus_param, }; */ static const struct v4l2_subdev_video_ops adv7280_video_ops = { .s_mbus_fmt = adv7280_s_fmt, .try_mbus_fmt = adv7280_try_fmt, .enum_mbus_fmt = adv7280_enum_fmt, .querystd = adv7280_querystd, .g_input_status = adv7280_g_input_status, }; static const struct v4l2_subdev_core_ops adv7280_core_ops = { //.g_chip_ident = adv7280_g_chip_ident, .s_std = adv7280_s_std, .s_power = adv7280_s_power, }; static const struct v4l2_subdev_ops adv7280_subdev_ops = { .core = &adv7280_core_ops, .video = &adv7280_video_ops, }; static void adv7280_work(struct work_struct *work) { struct adv7280_state *state = container_of(work, struct adv7280_state, work); struct i2c_client *client = v4l2_get_subdevdata(&state->sd); u8 isr3; mutex_lock(&state->mutex); adv7280_write_reg(client, ADV7280_ADI_CONTROL_1, ADV7280_ADI_CTRL_IRQ_SPACE); isr3 = i2c_smbus_read_byte_data(client, ADV7280_ISR3_ADI); /* clear */ adv7280_write_reg(client, ADV7280_ICR3_ADI, isr3); adv7280_write_reg(client, ADV7280_ADI_CONTROL_1, 0); if (isr3 & ADV7280_IRQ3_AD_CHANGE && state->autodetect) __adv7280_status(client, NULL, &state->curr_norm); mutex_unlock(&state->mutex); enable_irq(state->irq); } static irqreturn_t adv7280_irq(int irq, void *devid) { struct adv7280_state *state = devid; schedule_work(&state->work); disable_irq_nosync(state->irq); return IRQ_HANDLED; } static int vidioc_s_input(struct file *file, void *priv, unsigned int i) { struct soc_camera_device *icd = file->private_data; struct v4l2_subdev *sd = soc_camera_to_subdev(icd); struct adv7280_state *state = to_state(sd); struct i2c_client *client = v4l2_get_subdevdata(sd); u8 val; if (i < 6) { state->active_input = i; val = i2c_smbus_read_byte_data(client, ADV7280_INPUT_CONTROL); val &= 0xf0; val |= (ADV7280_INPUT_CONTROL_COMPOSITE_IN1 + state->active_input); return adv7280_write_reg(client, ADV7280_INPUT_CONTROL, val); } return -EINVAL; } static int vidioc_g_input(struct file *file, void *priv, unsigned int *i) { struct soc_camera_device *icd = file->private_data; struct v4l2_subdev *sd = soc_camera_to_subdev(icd); struct adv7280_state *state = to_state(sd); *i = state->active_input; return 0; } /* * Generic i2c probe * concerning the addresses: i2c wants 7 bit (without the r/w bit), so '>>1' */ static int adv7280_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct adv7280_state *state; struct soc_camera_device *icd = client->dev.platform_data; struct v4l2_subdev *sd; u8 ident; int ret; struct v4l2_ioctl_ops *ops; struct i2c_client vpp_client = { .flags = client->flags, .addr = VPP_SLAVE_ADDRESS, .name = "ADV7180_VPP_SLAVE", .adapter = client->adapter, .dev = client->dev, }; struct i2c_client csi_client = { .flags = client->flags, .addr = CSI_SLAVE_ADDRESS, .name = "ADV7180_CSI_SLAVE", .adapter = client->adapter, .dev = client->dev, }; printk("probe, id=%s\n", id->name); /* Check if the adapter supports the needed features */ if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) return -EIO; v4l_info(client, "chip found @ 0x%02x (%s)\n", client->addr << 1, client->adapter->name); state = kzalloc(sizeof(struct adv7280_state), GFP_KERNEL); if (state == NULL) { ret = -ENOMEM; goto err; } ident = i2c_smbus_read_byte_data(client, ADV7280_IDENT); v4l_info(client, "ident reg is 0x%02x\n", ident); state->irq = client->irq; INIT_WORK(&state->work, adv7280_work); mutex_init(&state->mutex); state->autodetect = true; state->active_input = 0; // input 1 sd = &state->sd; v4l2_i2c_subdev_init(sd, client, &adv7280_subdev_ops); //icd->ops = &adv7280_ops; /* Reset */ ret = adv7280_write_reg(client, ADV7280_POWER_MANAGEMENT, 0xA0); if (ret < 0) goto err_unreg_subdev; msleep(10); /* Initialize adv7280 */ /* Exit Power Down Mode */ ret = adv7280_write_reg(client, ADV7280_POWER_MANAGEMENT, 0x00); if (ret < 0) goto err_unreg_subdev; /* analog devices recommends */ ret = adv7280_write_reg(client, ADV7280_ADI_CONTROL_1, 0x80); if (ret < 0) goto err_unreg_subdev; /* analog devices recommends */ ret = adv7280_write_reg(client, 0x9C, 0x00); if (ret < 0) goto err_unreg_subdev; /* analog devices recommends */ ret = adv7280_write_reg(client, 0x9C, 0xFF); if (ret < 0) goto err_unreg_subdev; /* Enter User Sub Map */ ret = adv7280_write_reg(client, ADV7280_ADI_CONTROL_1, 0x00); if (ret < 0) goto err_unreg_subdev; /* Enable Pixel & Sync output drivers */ ret = adv7280_write_reg(client, ADV7280_OUTPUT_CONTROL, 0x0C); if (ret < 0) goto err_unreg_subdev; /* Power-up INTRQ, HS & VS pads */ ret = adv7280_write_reg(client, ADV7280_EXTENDED_OUTPUT_CONTROL, 0x07); if (ret < 0) goto err_unreg_subdev; /* Enable SH1 */ /* ret = adv7280_write_reg(client, ADV7280_SHAPING_FILTER_CONTROL_1, 0x41); if (ret < 0) goto err_unreg_subdev; */ /* Disable comb filtering */ /* ret = adv7280_write_reg(client, 0x39, 0x24); if (ret < 0) goto err_unreg_subdev; */ /* Enable LLC output driver */ ret = adv7280_write_reg(client, ADV7280_ADI_CONTROL_2, 0x40); if (ret < 0) goto err_unreg_subdev; /* VSYNC on VS/FIELD/SFL pin */ ret = adv7280_write_reg(client, ADV7280_OUTPUT_SYNC_SELECT_2, 0x01); if (ret < 0) goto err_unreg_subdev; /* Enable autodetection */ ret = adv7280_write_reg(client, ADV7280_INPUT_CONTROL, ADV7280_INPUT_CONTROL_AD_PAL_BG_NTSC_J_SECAM | (ADV7280_INPUT_CONTROL_COMPOSITE_IN1 + state->active_input)); if (ret < 0) goto err_unreg_subdev; ret = adv7280_write_reg(client, ADV7280_AUTODETECT_ENABLE, ADV7280_AUTODETECT_DEFAULT); if (ret < 0) goto err_unreg_subdev; /* ITU-R BT.656-4 compatible ret = adv7280_write_reg(client, ADV7280_EXTENDED_OUTPUT_CONTROL, ADV7280_EXTENDED_OUTPUT_CONTROL_NTSCDIS); if (ret < 0) goto err_unreg_subdev; */ /* analog devices recommends */ ret = adv7280_write_reg(client, 0x52, 0xCD); if (ret < 0) goto err_unreg_subdev; /* analog devices recommends */ ret = adv7280_write_reg(client, 0x80, 0x51); if (ret < 0) goto err_unreg_subdev; /* analog devices recommends */ ret = adv7280_write_reg(client, 0x81, 0x51); if (ret < 0) goto err_unreg_subdev; /* analog devices recommends */ ret = adv7280_write_reg(client, 0x82, 0x68); if (ret < 0) goto err_unreg_subdev; #ifdef HW_DEINT /* Set VPP Map */ ret = adv7280_write_reg(client, ADV7280_VPP_SLAVE_ADDRESS, (VPP_SLAVE_ADDRESS << 1)); if (ret < 0) goto err_unreg_subdev; /* VPP - not documented */ ret = adv7280_write_reg(&vpp_client, 0xA3, 0x00); if (ret < 0) goto err_unreg_subdev; /* VPP - Enbable Advanced Timing Mode */ ret = adv7280_write_reg(&vpp_client, VPP_ADV_TIMING_MODE_EN, 0x00); if (ret < 0) goto err_unreg_subdev; /* VPP - Enable Deinterlacer */ ret = adv7280_write_reg(&vpp_client, VPP_I2C_DEINT_ENABLE, 0x80); if (ret < 0) goto err_unreg_subdev; #endif #ifdef CSI /* Set CSI Map */ ret = adv7280_write_reg(client, ADV7280_CSI_TX_SLAVE_ADDRESS, (CSI_SLAVE_ADDRESS << 1)); if (ret < 0) goto err_unreg_subdev; /* Power up MIPI D-PHY */ ret = adv7280_write_reg(&csi_client, CSI_DPHY_PWRDN_CTL, 0x02); if (ret < 0) goto err_unreg_subdev; ret = adv7280_write_reg(&csi_client, 0x02 , 0x18); if (ret < 0) goto err_unreg_subdev; /* analog devices recommends */ ret = adv7280_write_reg(&csi_client, 0xD2 , 0xF7); if (ret < 0) goto err_unreg_subdev; /* analog devices recommends */ ret = adv7280_write_reg(&csi_client, 0xD8 , 0x65); if (ret < 0) goto err_unreg_subdev; /* analog devices recommends */ ret = adv7280_write_reg(&csi_client, 0xE0 , 0x09); if (ret < 0) goto err_unreg_subdev; /* analog devices recommends */ ret = adv7280_write_reg(&csi_client, 0x2C , 0x00); if (ret < 0) goto err_unreg_subdev; /* MIPI-CSI2 power up */ ret = adv7280_write_reg(&csi_client, CSI_CSITX_PWRDN , 0x00); if (ret < 0) goto err_unreg_subdev; #endif /* read current norm */ __adv7280_status(client, NULL, &state->curr_norm); /* register for interrupts */ if (state->irq > 0) { ret = request_irq(state->irq, adv7280_irq, 0, DRIVER_NAME, state); if (ret) goto err_unreg_subdev; ret = adv7280_write_reg(client, ADV7280_ADI_CONTROL_1, ADV7280_ADI_CTRL_IRQ_SPACE); if (ret < 0) goto err_unreg_subdev; /* config the Interrupt pin to be active low */ ret = adv7280_write_reg(client, ADV7280_ICONF1_ADI, ADV7280_ICONF1_ACTIVE_LOW | ADV7280_ICONF1_PSYNC_ONLY); if (ret < 0) goto err_unreg_subdev; ret = adv7280_write_reg(client, ADV7280_IMR1_ADI, 0); if (ret < 0) goto err_unreg_subdev; ret = adv7280_write_reg(client, ADV7280_IMR2_ADI, 0); if (ret < 0) goto err_unreg_subdev; /* enable AD change interrupts interrupts */ ret = adv7280_write_reg(client, ADV7280_IMR3_ADI, ADV7280_IRQ3_AD_CHANGE); if (ret < 0) goto err_unreg_subdev; ret = adv7280_write_reg(client, ADV7280_IMR4_ADI, 0); if (ret < 0) goto err_unreg_subdev; ret = adv7280_write_reg(client, ADV7280_ADI_CONTROL_1, 0); if (ret < 0) goto err_unreg_subdev; } /* * this is the only way to support more than one input as soc_camera * assumes in its own vidioc_s(g)_input implementation that only one * input is present we have to override that with our own handlers. */ /* ops = (struct v4l2_ioctl_ops*)icd->vdev->ioctl_ops; ops->vidioc_s_input = &vidioc_s_input; ops->vidioc_g_input = &vidioc_g_input; */ return 0; err_unreg_subdev: mutex_destroy(&state->mutex); v4l2_device_unregister_subdev(sd); kfree(state); err: printk(KERN_ERR DRIVER_NAME ": Failed to probe: %d\n", ret); return ret; } static int adv7280_remove(struct i2c_client *client) { struct v4l2_subdev *sd = i2c_get_clientdata(client); struct adv7280_state *state = to_state(sd); if (state->irq > 0) { free_irq(client->irq, state); if (cancel_work_sync(&state->work)) { /* * Work was pending, therefore we need to enable * IRQ here to balance the disable_irq() done in the * interrupt handler. */ enable_irq(state->irq); } } mutex_destroy(&state->mutex); v4l2_device_unregister_subdev(sd); kfree(to_state(sd)); return 0; } static const struct i2c_device_id adv7280_id[] = { {"adv7280", 0}, {"adv7280-M", 1}, {}, }; MODULE_DEVICE_TABLE(i2c, adv7280_id); static struct i2c_driver adv7280_driver = { .driver = { .owner = THIS_MODULE, .name = DRIVER_NAME, }, .probe = adv7280_probe, .remove = adv7280_remove, .id_table = adv7280_id, }; static __init int adv7280_init(void) { return i2c_add_driver(&adv7280_driver); } static __exit void adv7280_exit(void) { i2c_del_driver(&adv7280_driver); } module_init(adv7280_init); module_exit(adv7280_exit); MODULE_DESCRIPTION("Analog Devices ADV7280/ADV7280-M video decoder driver"); MODULE_AUTHOR("Wojciech Bieganski "); MODULE_LICENSE("GPL v2");