自学教程：C++ v4l2_ctrl_handler_free函数代码示例

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