static void fimc_md_unregister_entities(struct fimc_md *fmd) { int i; for (i = 0; i < FIMC_MAX_DEVS; i++) { struct fimc_dev *dev = fmd->fimc[i]; if (dev == NULL) continue; v4l2_device_unregister_subdev(&dev->vid_cap.subdev); dev->vid_cap.ve.pipe = NULL; fmd->fimc[i] = NULL; } for (i = 0; i < FIMC_LITE_MAX_DEVS; i++) { struct fimc_lite *dev = fmd->fimc_lite[i]; if (dev == NULL) continue; v4l2_device_unregister_subdev(&dev->subdev); dev->ve.pipe = NULL; fmd->fimc_lite[i] = NULL; } for (i = 0; i < CSIS_MAX_ENTITIES; i++) { if (fmd->csis[i].sd == NULL) continue; v4l2_device_unregister_subdev(fmd->csis[i].sd); fmd->csis[i].sd = NULL; } if (fmd->fimc_is) v4l2_device_unregister_subdev(&fmd->fimc_is->isp.subdev); v4l2_info(&fmd->v4l2_dev, "Unregistered all entities\n"); }
static void fimc_md_unregister_entities(struct fimc_md *fmd) { int i; for (i = 0; i < FIMC_MAX_DEVS; i++) { if (fmd->fimc[i] == NULL) continue; v4l2_device_unregister_subdev(&fmd->fimc[i]->vid_cap.subdev); fmd->fimc[i]->pipeline_ops = NULL; fmd->fimc[i] = NULL; } for (i = 0; i < FIMC_LITE_MAX_DEVS; i++) { if (fmd->fimc_lite[i] == NULL) continue; v4l2_device_unregister_subdev(&fmd->fimc_lite[i]->subdev); fmd->fimc[i]->pipeline_ops = NULL; fmd->fimc_lite[i] = NULL; } for (i = 0; i < CSIS_MAX_ENTITIES; i++) { if (fmd->csis[i].sd == NULL) continue; v4l2_device_unregister_subdev(fmd->csis[i].sd); module_put(fmd->csis[i].sd->owner); fmd->csis[i].sd = NULL; } for (i = 0; i < fmd->num_sensors; i++) { if (fmd->sensor[i].subdev == NULL) continue; fimc_md_unregister_sensor(fmd->sensor[i].subdev); fmd->sensor[i].subdev = NULL; } }
static int adv7180_remove(struct i2c_client *client) { struct v4l2_subdev *sd = i2c_get_clientdata(client); struct adv7180_state *state = to_state(sd); if (state->cvbs_irq > 0) { free_irq(state->cvbs_irq,state); if (cancel_work_sync(&state->cvbs_work)) { /* * Work was pending, therefore we need to enable * IRQ here to balance the disable_irq() done in the * interrupt handler. */ enable_irq(state->cvbs_irq); } } if (state->ycrcb_irq > 0) { free_irq(state->ycrcb_irq,state); if (cancel_work_sync(&state->ycrcb_work)) { /* * Work was pending, therefore we need to enable * IRQ here to balance the disable_irq() done in the * interrupt handler. */ enable_irq(state->ycrcb_irq); } } mutex_destroy(&state->mutex); v4l2_device_unregister_subdev(sd); kfree(to_state(sd)); return 0; }
static int lm3554_remove(struct i2c_client *client) { struct v4l2_subdev *sd = i2c_get_clientdata(client); struct lm3554 *flash = to_lm3554(sd); int ret; media_entity_cleanup(&flash->sd.entity); v4l2_ctrl_handler_free(&flash->ctrl_handler); v4l2_device_unregister_subdev(sd); atomisp_gmin_remove_subdev(sd); del_timer_sync(&flash->flash_off_delay); ret = lm3554_gpio_uninit(client); if (ret < 0) goto fail; kfree(flash); return 0; fail: dev_err(&client->dev, "gpio request/direction_output fail"); return ret; }
void omap4iss_csi2_unregister_entities(struct iss_csi2_device *csi2) { media_entity_cleanup(&csi2->subdev.entity); v4l2_device_unregister_subdev(&csi2->subdev); omap4iss_video_unregister(&csi2->video_out); }
void omap4iss_ipipeif_unregister_entities(struct iss_ipipeif_device *ipipeif) { media_entity_cleanup(&ipipeif->subdev.entity); v4l2_device_unregister_subdev(&ipipeif->subdev); omap4iss_video_unregister(&ipipeif->video_out); }
static int tda9840_remove(struct i2c_client *client) { struct v4l2_subdev *sd = i2c_get_clientdata(client); v4l2_device_unregister_subdev(sd); return 0; }
void isp_csi2_unregister_entities(struct isp_csi2_device *csi2) { media_entity_cleanup(&csi2->subdev.entity); v4l2_device_unregister_subdev(&csi2->subdev); v4l2_ctrl_handler_free(&csi2->ctrls); isp_video_unregister(&csi2->video_out); }
static int ak881x_remove(struct i2c_client *client) { struct ak881x *ak881x = to_ak881x(client); v4l2_device_unregister_subdev(&ak881x->subdev); return 0; }
static int adv7180_remove(struct i2c_client *client) { struct v4l2_subdev *sd = i2c_get_clientdata(client); v4l2_device_unregister_subdev(sd); kfree(to_state(sd)); return 0; }
void atomisp_subdev_unregister_entities(struct atomisp_sub_device *asd) { atomisp_subdev_cleanup_entities(asd); v4l2_device_unregister_subdev(&asd->subdev); atomisp_video_unregister(&asd->video_in); atomisp_video_unregister(&asd->video_out_preview); atomisp_video_unregister(&asd->video_out_vf); atomisp_video_unregister(&asd->video_out_capture); }
void atomisp_subdev_unregister_entities(struct atomisp_sub_device *isp_subdev) { media_entity_cleanup(&isp_subdev->subdev.entity); v4l2_device_unregister_subdev(&isp_subdev->subdev); atomisp_video_unregister(&isp_subdev->video_in); atomisp_video_unregister(&isp_subdev->video_out_vf); atomisp_video_unregister(&isp_subdev->video_out_mo); }
void fimc_isp_subdev_destroy(struct fimc_isp *isp) { struct v4l2_subdev *sd = &isp->subdev; v4l2_device_unregister_subdev(sd); media_entity_cleanup(&sd->entity); v4l2_ctrl_handler_free(&isp->ctrls.handler); v4l2_set_subdevdata(sd, NULL); }
static int tw2804_remove(struct i2c_client *client) { struct v4l2_subdev *sd = i2c_get_clientdata(client); struct tw2804 *state = to_state(sd); v4l2_device_unregister_subdev(sd); v4l2_ctrl_handler_free(&state->hdl); return 0; }
static void fimc_lite_unregister_capture_subdev(struct fimc_lite *fimc) { struct v4l2_subdev *sd = &fimc->subdev; v4l2_device_unregister_subdev(sd); media_entity_cleanup(&sd->entity); v4l2_ctrl_handler_free(&fimc->ctrl_handler); v4l2_set_subdevdata(sd, NULL); }
static int ov9640_remove(struct i2c_client *client) { struct v4l2_subdev *sd = i2c_get_clientdata(client); struct ov9640_priv *priv = to_ov9640_sensor(sd); v4l2_device_unregister_subdev(&priv->subdev); v4l2_ctrl_handler_free(&priv->hdl); return 0; }
static int lm3646_remove(struct i2c_client *client) { struct lm3646_flash *flash = i2c_get_clientdata(client); v4l2_device_unregister_subdev(&flash->subdev_led); v4l2_ctrl_handler_free(&flash->ctrls_led); media_entity_cleanup(&flash->subdev_led.entity); return 0; }
static void ovisp_camera_free_client(struct ovisp_camera_dev *camdev, int index) { struct ovisp_camera_subdev *csd = &camdev->csd[index]; v4l2_device_unregister_subdev(csd->sd); i2c_unregister_device(v4l2_get_subdevdata(csd->sd)); i2c_put_adapter(csd->i2c_adap); clk_put(csd->mclk); }
int vpfe_resizer_register_entities(struct vpfe_resizer_device *resizer, struct v4l2_device *vdev) { int ret; unsigned int flags = 0; struct vpfe_device *vpfe_dev = to_vpfe_device(resizer); /* Register the subdev */ ret = v4l2_device_register_subdev(vdev, &resizer->subdev); if (ret < 0) { printk(KERN_ERR "failed to register resizer as v4l2-subdev\n"); return ret; } ret = vpfe_video_register(&resizer->video_in, vdev); if (ret) { printk(KERN_ERR "failed to register RSZ video-in device\n"); goto out_video_in_register; } resizer->video_in.vpfe_dev = vpfe_dev; ret = vpfe_video_register(&resizer->video_out, vdev); if (ret) { printk(KERN_ERR "failed to register RSZ video-out device\n"); goto out_video_out_register; } resizer->video_out.vpfe_dev = vpfe_dev; ret = media_entity_create_link(&resizer->video_in.video_dev.entity, 0, &resizer->subdev.entity, 0, flags); if (ret < 0) goto out_create_link; ret = media_entity_create_link(&resizer->subdev.entity, 1, &resizer->video_out.video_dev.entity, 0, flags); if (ret < 0) goto out_create_link; return 0; out_create_link: vpfe_video_unregister(&resizer->video_out); out_video_out_register: vpfe_video_unregister(&resizer->video_in); out_video_in_register: media_entity_cleanup(&resizer->subdev.entity); v4l2_device_unregister_subdev(&resizer->subdev); return ret; }
static int ad5823_remove(struct i2c_client *client) { struct v4l2_subdev *subdev = i2c_get_clientdata(client); struct ad5823 *vcm = to_ad5823(subdev); v4l2_device_unregister_subdev(subdev); v4l2_ctrl_handler_free(&vcm->ctrls); media_entity_cleanup(&vcm->subdev.entity); kfree(vcm); return 0; }
static int s5k6aafx_remove(struct i2c_client *client) { struct v4l2_subdev *sd = i2c_get_clientdata(client); FUNC_ENTR(); v4l2_device_unregister_subdev(sd); kfree(to_state(sd)); return 0; }
static void gsc_capture_destroy_subdev(struct gsc_dev *gsc) { struct v4l2_subdev *sd = gsc->cap.sd_cap; if (!sd) return; media_entity_cleanup(&sd->entity); v4l2_device_unregister_subdev(sd); kfree(sd); sd = NULL; }
void vpfe_resizer_unregister_entities(struct vpfe_resizer_device *vpfe_rsz) { /* unregister video devices */ vpfe_video_unregister(&vpfe_rsz->video_in); vpfe_video_unregister(&vpfe_rsz->video_out); /* cleanup entity */ media_entity_cleanup(&vpfe_rsz->subdev.entity); /* unregister subdev */ v4l2_device_unregister_subdev(&vpfe_rsz->subdev); }
static int __exit adp1653_remove(struct i2c_client *client) { struct v4l2_subdev *subdev = i2c_get_clientdata(client); struct adp1653_flash *flash = to_adp1653_flash(subdev); v4l2_device_unregister_subdev(&flash->subdev); v4l2_ctrl_handler_free(&flash->ctrls); media_entity_cleanup(&flash->subdev.entity); kfree(flash); return 0; }
static int mt9v011_remove(struct i2c_client *c) { struct v4l2_subdev *sd = i2c_get_clientdata(c); v4l2_dbg(1, debug, sd, "mt9v011.c: removing mt9v011 adapter on address 0x%x\n", c->addr << 1); v4l2_device_unregister_subdev(sd); kfree(to_mt9v011(sd)); return 0; }
static int as3645a_remove(struct i2c_client *client) { struct v4l2_subdev *subdev = i2c_get_clientdata(client); struct as3645a *flash = to_as3645a(subdev); v4l2_device_unregister_subdev(subdev); v4l2_ctrl_handler_free(&flash->ctrls); media_entity_cleanup(&flash->subdev.entity); mutex_destroy(&flash->power_lock); return 0; }
static int lm3559_probe(struct i2c_client *client, const struct i2c_device_id *id) { int err; struct lm3559 *flash; if (client->dev.platform_data == NULL) { dev_err(&client->dev, "no platform data\n"); return -ENODEV; } flash = kzalloc(sizeof(*flash), GFP_KERNEL); if (!flash) { dev_err(&client->dev, "out of memory\n"); return -ENOMEM; } flash->pdata = client->dev.platform_data; v4l2_i2c_subdev_init(&flash->sd, client, &lm3559_ops); flash->sd.internal_ops = &lm3559_internal_ops; flash->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE; flash->mode = ATOMISP_FLASH_MODE_OFF; err = media_entity_init(&flash->sd.entity, 0, NULL, 0); if (err) { dev_err(&client->dev, "error initialize a media entity.\n"); goto fail1; } flash->sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV_FLASH; mutex_init(&flash->power_lock); setup_timer(&flash->flash_off_delay, lm3559_flash_off_delay, (unsigned long)client); err = lm3559_gpio_init(client); if (err) { dev_err(&client->dev, "gpio request/direction_output fail"); goto fail2; } return 0; fail2: media_entity_cleanup(&flash->sd.entity); fail1: v4l2_device_unregister_subdev(&flash->sd); kfree(flash); return err; }
static int __devinit lm3554_probe(struct i2c_client *client, const struct i2c_device_id *id) { int err; struct lm3554_priv *p_lm3554_priv; p_lm3554_priv = kzalloc(sizeof(*p_lm3554_priv), GFP_KERNEL); if (!p_lm3554_priv) { dev_err(&client->dev, "out of memory\n"); return -ENOMEM; } p_lm3554_priv->platform_data = client->dev.platform_data; if (!p_lm3554_priv->platform_data) { dev_err(&client->dev, "no platform data\n"); kfree(p_lm3554_priv); return -ENODEV; } v4l2_i2c_subdev_init(&(p_lm3554_priv->sd), client, &lm3554_ops); p_lm3554_priv->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE; p_lm3554_priv->sd.entity.ops = &lm3554_entity_ops; p_lm3554_priv->timeout = LM3554_DEFAULT_TIMEOUT; p_lm3554_priv->mode = ATOMISP_FLASH_MODE_OFF; p_lm3554_priv->intensity = 0; err = media_entity_init(&p_lm3554_priv->sd.entity, 0, NULL, 0); if (err) { dev_err(&client->dev, "error initialize a media entity.\n"); goto fail1; } mutex_init(&p_lm3554_priv->i2c_mutex); setup_timer(&p_lm3554_priv->flash_off_delay, lm3554_flash_off_delay, (unsigned long)client); err = lm3554_detect(client); if (err) { dev_err(&client->dev, "device not found\n"); goto fail2; } return 0; fail2: media_entity_cleanup(&p_lm3554_priv->sd.entity); fail1: v4l2_device_unregister_subdev(&p_lm3554_priv->sd); kfree(p_lm3554_priv); return err; }
static int lm3560_remove(struct i2c_client *client) { struct lm3560_flash *flash = i2c_get_clientdata(client); unsigned int i; for (i = LM3560_LED0; i < LM3560_LED_MAX; i++) { v4l2_device_unregister_subdev(&flash->subdev_led[i]); v4l2_ctrl_handler_free(&flash->ctrls_led[i]); media_entity_cleanup(&flash->subdev_led[i].entity); } return 0; }
static void fimc_md_unregister_sensor(struct v4l2_subdev *sd) { struct i2c_client *client = v4l2_get_subdevdata(sd); struct i2c_adapter *adapter; if (!client) return; v4l2_device_unregister_subdev(sd); adapter = client->adapter; i2c_unregister_device(client); if (adapter) i2c_put_adapter(adapter); }