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;
}
void cpia2_camera_release(struct v4l2_device *v4l2_dev)
{
struct camera_data *cam =
container_of(v4l2_dev, struct camera_data, v4l2_dev);
v4l2_ctrl_handler_free(&cam->hdl);
v4l2_device_unregister(&cam->v4l2_dev);
kfree(cam);
}
void solo_v4l2_exit(struct solo_dev *solo_dev)
{
if (solo_dev->vfd == NULL)
return;
video_unregister_device(solo_dev->vfd);
v4l2_ctrl_handler_free(&solo_dev->disp_hdl);
solo_dev->vfd = NULL;
}
/*
* m5mols_init_controls - initialization using v4l2_ctrl.
*/
static int m5mols_init_controls(struct m5mols_info *info)
{
struct v4l2_subdev *sd = &info->sd;
struct i2c_client *client = v4l2_get_subdevdata(sd);
u16 max_ex_mon;
int ret;
/* check minimum & maximum of M5MOLS controls */
ret = i2c_r16_ae(sd, CAT3_MAX_GAIN_MON, (u32 *)&max_ex_mon);
if (ret)
return ret;
/* set the controls using v4l2 control frameworks */
v4l2_ctrl_handler_init(&info->handle, 9);
info->colorfx = v4l2_ctrl_new_std_menu(&info->handle,
&m5mols_ctrl_ops, V4L2_CID_COLORFX,
9, 1, V4L2_COLORFX_NONE);
info->autoexposure = v4l2_ctrl_new_std_menu(&info->handle,
&m5mols_ctrl_ops, V4L2_CID_EXPOSURE_AUTO,
1, 0, V4L2_EXPOSURE_AUTO);
info->exposure = v4l2_ctrl_new_std(&info->handle,
&m5mols_ctrl_ops, V4L2_CID_EXPOSURE,
0, max_ex_mon, 1, (int)max_ex_mon/2);
info->autofocus = v4l2_ctrl_new_std(&info->handle,
&m5mols_ctrl_ops, V4L2_CID_FOCUS_AUTO,
0, 1, 1, 0);
info->autowb = v4l2_ctrl_new_std(&info->handle,
&m5mols_ctrl_ops, V4L2_CID_AUTO_WHITE_BALANCE,
0, 1, 1, 1);
info->saturation = v4l2_ctrl_new_std(&info->handle,
&m5mols_ctrl_ops, V4L2_CID_SATURATION,
0, 6, 1, 3);
info->zoom = v4l2_ctrl_new_std(&info->handle,
&m5mols_ctrl_ops, V4L2_CID_ZOOM_ABSOLUTE,
0, 70, 1, 0);
info->jpeg_size = v4l2_ctrl_new_custom(&info->handle,
&ctrl_private[0],
NULL);
info->encoded_size = v4l2_ctrl_new_custom(&info->handle,
&ctrl_private[1],
NULL);
sd->ctrl_handler = &info->handle;
if (info->handle.error) {
dev_err(&client->dev, "Failed to init controls, %d\n", ret);
v4l2_ctrl_handler_free(&info->handle);
return info->handle.error;
}
v4l2_ctrl_cluster(2, &info->autoexposure);
/* If above ctrl value is not good image, so it is better that not set */
v4l2_ctrl_handler_setup(&info->handle);
return 0;
}
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);
}
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 void au0828_usb_v4l2_release(struct v4l2_device *v4l2_dev)
{
struct au0828_dev *dev =
container_of(v4l2_dev, struct au0828_dev, v4l2_dev);
v4l2_ctrl_handler_free(&dev->v4l2_ctrl_hdl);
v4l2_device_unregister(&dev->v4l2_dev);
au0828_usb_release(dev);
}
static void pwc_video_release(struct v4l2_device *v)
{
struct pwc_device *pdev = container_of(v, struct pwc_device, v4l2_dev);
v4l2_ctrl_handler_free(&pdev->ctrl_handler);
v4l2_device_unregister(&pdev->v4l2_dev);
kfree(pdev->ctrl_buf);
kfree(pdev);
}
void solo_v4l2_exit(struct solo_dev *solo_dev)
{
if (solo_dev->vfd == NULL)
return;
video_unregister_device(solo_dev->vfd);
vb2_dma_contig_cleanup_ctx(solo_dev->alloc_ctx);
v4l2_ctrl_handler_free(&solo_dev->disp_hdl);
solo_dev->vfd = NULL;
}
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;
}
void vsp1_entity_destroy(struct vsp1_entity *entity)
{
if (entity->video)
vsp1_video_cleanup(entity->video);
if (entity->subdev.ctrl_handler)
v4l2_ctrl_handler_free(entity->subdev.ctrl_handler);
media_entity_cleanup(&entity->subdev.entity);
mutex_destroy(&entity->lock);
}
static void __exit fmi_exit(void)
{
struct fmi *fmi = &fmi_card;
v4l2_ctrl_handler_free(&fmi->hdl);
video_unregister_device(&fmi->vdev);
v4l2_device_unregister(&fmi->v4l2_dev);
release_region(fmi->io, 2);
if (dev && pnp_attached)
pnp_device_detach(dev);
}
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 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;
}
void rvin_v4l2_remove(struct rvin_dev *vin)
{
v4l2_info(&vin->v4l2_dev, "Removing %s\n",
video_device_node_name(&vin->vdev));
/* Checks internaly if handlers have been init or not */
v4l2_ctrl_handler_free(&vin->ctrl_handler);
/* Checks internaly if vdev have been init or not */
video_unregister_device(&vin->vdev);
}
static int sensor_subdev_close(struct v4l2_subdev *sd,
struct v4l2_subdev_fh *fh)
{
struct sensor_info *info = to_sensor(sd);
v4l2_dbg(1, sensor_debug, sd, "%s", __func__);
v4l2_ctrl_handler_free(&info->handle);
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 s5p_jpeg_release(struct file *file)
{
struct s5p_jpeg_ctx *ctx = fh_to_ctx(file->private_data);
v4l2_m2m_ctx_release(ctx->m2m_ctx);
v4l2_ctrl_handler_free(&ctx->ctrl_handler);
v4l2_fh_del(&ctx->fh);
v4l2_fh_exit(&ctx->fh);
kfree(ctx);
return 0;
}
static struct v4l2_flash *__v4l2_flash_init(
struct device *dev, struct fwnode_handle *fwn,
struct led_classdev_flash *fled_cdev, struct led_classdev *iled_cdev,
const struct v4l2_flash_ops *ops, struct v4l2_flash_config *config)
{
struct v4l2_flash *v4l2_flash;
struct v4l2_subdev *sd;
int ret;
if (!config)
return ERR_PTR(-EINVAL);
v4l2_flash = devm_kzalloc(dev, sizeof(*v4l2_flash), GFP_KERNEL);
if (!v4l2_flash)
return ERR_PTR(-ENOMEM);
sd = &v4l2_flash->sd;
v4l2_flash->fled_cdev = fled_cdev;
v4l2_flash->iled_cdev = iled_cdev;
v4l2_flash->ops = ops;
sd->dev = dev;
sd->fwnode = fwn ? fwn : dev_fwnode(dev);
v4l2_subdev_init(sd, &v4l2_flash_subdev_ops);
sd->internal_ops = &v4l2_flash_subdev_internal_ops;
sd->flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
strlcpy(sd->name, config->dev_name, sizeof(sd->name));
ret = media_entity_pads_init(&sd->entity, 0, NULL);
if (ret < 0)
return ERR_PTR(ret);
sd->entity.function = MEDIA_ENT_F_FLASH;
ret = v4l2_flash_init_controls(v4l2_flash, config);
if (ret < 0)
goto err_init_controls;
fwnode_handle_get(sd->fwnode);
ret = v4l2_async_register_subdev(sd);
if (ret < 0)
goto err_async_register_sd;
return v4l2_flash;
err_async_register_sd:
fwnode_handle_put(sd->fwnode);
v4l2_ctrl_handler_free(sd->ctrl_handler);
err_init_controls:
media_entity_cleanup(&sd->entity);
return ERR_PTR(ret);
}
static int g2d_release(struct file *file)
{
struct g2d_dev *dev = video_drvdata(file);
struct g2d_ctx *ctx = fh2ctx(file->private_data);
v4l2_ctrl_handler_free(&ctx->ctrl_handler);
v4l2_fh_del(&ctx->fh);
v4l2_fh_exit(&ctx->fh);
kfree(ctx);
v4l2_info(&dev->v4l2_dev, "instance closed\n");
return 0;
}
static void cx18_remove(struct pci_dev *pci_dev)
{
struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
struct cx18 *cx = to_cx18(v4l2_dev);
int i;
CX18_DEBUG_INFO("Removing Card\n");
flush_request_modules(cx);
/* Stop all captures */
CX18_DEBUG_INFO("Stopping all streams\n");
if (atomic_read(&cx->tot_capturing) > 0)
cx18_stop_all_captures(cx);
/* Stop interrupts that cause incoming work to be queued */
cx18_sw1_irq_disable(cx, IRQ_CPU_TO_EPU | IRQ_APU_TO_EPU);
/* Incoming work can cause outgoing work, so clean up incoming first */
cx18_cancel_in_work_orders(cx);
cx18_cancel_out_work_orders(cx);
/* Stop ack interrupts that may have been needed for work to finish */
cx18_sw2_irq_disable(cx, IRQ_CPU_TO_EPU_ACK | IRQ_APU_TO_EPU_ACK);
cx18_halt_firmware(cx);
destroy_workqueue(cx->in_work_queue);
cx18_streams_cleanup(cx, 1);
exit_cx18_i2c(cx);
free_irq(cx->pci_dev->irq, (void *)cx);
cx18_iounmap(cx);
release_mem_region(cx->base_addr, CX18_MEM_SIZE);
pci_disable_device(cx->pci_dev);
if (cx->vbi.sliced_mpeg_data[0] != NULL)
for (i = 0; i < CX18_VBI_FRAMES; i++)
kfree(cx->vbi.sliced_mpeg_data[i]);
v4l2_ctrl_handler_free(&cx->av_state.hdl);
CX18_INFO("Removed %s\n", cx->card_name);
v4l2_device_unregister(v4l2_dev);
kfree(cx);
}
/*
* sensor_init_controls - initialization using v4l2_ctrl.
*/
static int sensor_init_controls(struct sensor_info *info)
{
struct v4l2_subdev *sd = &info->sd;
int num_of_ctl_hint = ARRAY_SIZE(ctrl_private);
/* set the controls using v4l2 control frameworks */
v4l2_ctrl_handler_init(&info->handle, num_of_ctl_hint);
/* Vision mode only support simple AE */
info->ae_target = v4l2_ctrl_new_custom(&info->handle,
&ctrl_private[0], NULL);
info->ae_weight[0] = v4l2_ctrl_new_custom(&info->handle,
&ctrl_private[1], NULL);
info->ae_weight[1] = v4l2_ctrl_new_custom(&info->handle,
&ctrl_private[2], NULL);
info->ae_weight[2] = v4l2_ctrl_new_custom(&info->handle,
&ctrl_private[3], NULL);
info->ae_weight[3] = v4l2_ctrl_new_custom(&info->handle,
&ctrl_private[4], NULL);
info->ae_weight[4] = v4l2_ctrl_new_custom(&info->handle,
&ctrl_private[5], NULL);
info->ae_weight[5] = v4l2_ctrl_new_custom(&info->handle,
&ctrl_private[6], NULL);
info->ae_weight[6] = v4l2_ctrl_new_custom(&info->handle,
&ctrl_private[7], NULL);
info->ae_weight[7] = v4l2_ctrl_new_custom(&info->handle,
&ctrl_private[8], NULL);
info->rg_weight = v4l2_ctrl_new_custom(&info->handle,
&ctrl_private[9], NULL);
info->ae_speed = v4l2_ctrl_new_custom(&info->handle,
&ctrl_private[10], NULL);
info->shutter = v4l2_ctrl_new_custom(&info->handle,
&ctrl_private[11], NULL);
info->gain = v4l2_ctrl_new_custom(&info->handle,
&ctrl_private[12], NULL);
info->bit_converting = v4l2_ctrl_new_custom(&info->handle,
&ctrl_private[13], NULL);
info->autoexposure = v4l2_ctrl_new_custom(&info->handle,
&ctrl_private[14], NULL);
info->framerate = v4l2_ctrl_new_custom(&info->handle,
&ctrl_private[15], NULL);
sd->ctrl_handler = &info->handle;
if (info->handle.error) {
sensor_err("Failed to init controls, %d\n", info->handle.error);
v4l2_ctrl_handler_free(&info->handle);
return info->handle.error;
}
return 0;
}
static void si470x_usb_release(struct v4l2_device *v4l2_dev)
{
struct si470x_device *radio =
container_of(v4l2_dev, struct si470x_device, v4l2_dev);
usb_free_urb(radio->int_in_urb);
v4l2_ctrl_handler_free(&radio->hdl);
v4l2_device_unregister(&radio->v4l2_dev);
kfree(radio->int_in_buffer);
kfree(radio->buffer);
kfree(radio->usb_buf);
kfree(radio);
}
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 int empress_fini(struct saa7134_dev *dev)
{
pr_debug("%s: %s\n", dev->name, __func__);
if (NULL == dev->empress_dev)
return 0;
flush_work(&dev->empress_workqueue);
video_unregister_device(dev->empress_dev);
vb2_queue_release(&dev->empress_vbq);
v4l2_ctrl_handler_free(&dev->empress_ctrl_handler);
dev->empress_dev = NULL;
return 0;
}
static int aksensor_remove(struct i2c_client *client)
{
struct aksensor_priv *priv = to_aksensor(client);
if (NULL != cur_sensor_info->handler) {
cur_sensor_info->handler->cam_close_func();
cur_sensor_info->handler = NULL;
}
v4l2_device_unregister_subdev(&priv->subdev);
v4l2_ctrl_handler_free(&priv->hdl);
kfree(priv);
return 0;
}
static int radio_isa_common_remove(struct radio_isa_card *isa,
unsigned region_size)
{
const struct radio_isa_ops *ops = isa->drv->ops;
ops->s_mute_volume(isa, true, isa->volume ? isa->volume->cur.val : 0);
video_unregister_device(&isa->vdev);
v4l2_ctrl_handler_free(&isa->hdl);
v4l2_device_unregister(&isa->v4l2_dev);
release_region(isa->io, region_size);
v4l2_info(&isa->v4l2_dev, "Removed radio card %s\n", isa->drv->card);
kfree(isa);
return 0;
}
static int mt9v011_remove(struct i2c_client *c)
{
struct v4l2_subdev *sd = i2c_get_clientdata(c);
struct mt9v011 *core = to_mt9v011(sd);
v4l2_dbg(1, debug, sd,
"mt9v011.c: removing mt9v011 adapter on address 0x%x\n",
c->addr << 1);
v4l2_device_unregister_subdev(sd);
v4l2_ctrl_handler_free(&core->ctrls);
kfree(to_mt9v011(sd));
return 0;
}
static int sensor_remove(struct i2c_client *client)
{
struct v4l2_subdev *sd = i2c_get_clientdata(client);
struct sensor_info *info = to_sensor(sd);
v4l2_device_unregister_subdev(sd);
v4l2_ctrl_handler_free(&info->handle);
free_irq(info->pdata->irq, sd);
gpio_free(info->pdata->gpio_rst);
media_entity_cleanup(&sd->entity);
kfree(info);
return 0;
}
