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);
}
