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

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 int __init rtrack_init(void){	struct rtrack *rt = &rtrack_card;	struct v4l2_device *v4l2_dev = &rt->v4l2_dev;	int res;	strlcpy(v4l2_dev->name, "rtrack", sizeof(v4l2_dev->name));	rt->io = io;	if (rt->io == -1) {		v4l2_err(v4l2_dev, "you must set an I/O address with io=0x20f or 0x30f/n");		return -EINVAL;	}	if (!request_region(rt->io, 2, "rtrack")) {		v4l2_err(v4l2_dev, "port 0x%x already in use/n", rt->io);		return -EBUSY;	}	res = v4l2_device_register(NULL, v4l2_dev);	if (res < 0) {		release_region(rt->io, 2);		v4l2_err(v4l2_dev, "could not register v4l2_device/n");		return res;	}	strlcpy(rt->vdev.name, v4l2_dev->name, sizeof(rt->vdev.name));	rt->vdev.v4l2_dev = v4l2_dev;	rt->vdev.fops = &rtrack_fops;	rt->vdev.ioctl_ops = &rtrack_ioctl_ops;	rt->vdev.release = video_device_release_empty;	video_set_drvdata(&rt->vdev, rt);	if (video_register_device(&rt->vdev, VFL_TYPE_RADIO, radio_nr) < 0) {		v4l2_device_unregister(&rt->v4l2_dev);		release_region(rt->io, 2);		return -EINVAL;	}	v4l2_info(v4l2_dev, "AIMSlab RadioTrack/RadioReveal card driver./n");	/* Set up the I/O locking */	mutex_init(&rt->lock);	/* mute card - prevents noisy bootups */	/* this ensures that the volume is all the way down  */	outb(0x48, rt->io);		/* volume down but still "on"	*/	msleep(2000);	/* make sure it's totally down	*/	outb(0xc0, rt->io);		/* steady volume, mute card	*/	return 0;}

static int imx_vdic_remove(struct platform_device *pdev){	struct v4l2_subdev *sd = platform_get_drvdata(pdev);	struct vdic_priv *priv = v4l2_get_subdevdata(sd);	v4l2_info(sd, "Removing/n");	v4l2_async_unregister_subdev(sd);	mutex_destroy(&priv->lock);	media_entity_cleanup(&sd->entity);	return 0;}

static void vpfe_disable_clock(struct vpfe_device *vpfe_dev){	struct vpfe_config *vpfe_cfg = vpfe_dev->cfg;	int i;	for (i = 0; i < vpfe_cfg->num_clocks; i++) {		clk_disable(vpfe_dev->clks[i]);		clk_put(vpfe_dev->clks[i]);	}	kzfree(vpfe_dev->clks);	v4l2_info(vpfe_dev->pdev->driver, "vpfe capture clocks disabled/n");}

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 imx_ic_remove(struct platform_device *pdev){	struct v4l2_subdev *sd = platform_get_drvdata(pdev);	struct imx_ic_priv *priv = container_of(sd, struct imx_ic_priv, sd);	v4l2_info(sd, "Removing/n");	ic_ops[priv->task_id]->remove(priv);	v4l2_async_unregister_subdev(sd);	media_entity_cleanup(&sd->entity);	return 0;}

/** * __fimc_md_create_fimc_links - create links to all FIMC entities * @fmd: fimc media device * @source: the source entity to create links to all fimc entities from * @sensor: sensor subdev linked to FIMC[fimc_id] entity, may be null * @pad: the source entity pad index * @fimc_id: index of the fimc device for which link should be enabled */static int __fimc_md_create_fimc_links(struct fimc_md *fmd,				       struct media_entity *source,				       struct v4l2_subdev *sensor,				       int pad, int fimc_id){	struct fimc_sensor_info *s_info;	struct media_entity *sink;	unsigned int flags;	int ret, i;	for (i = 0; i < FIMC_MAX_DEVS; i++) {		if (!fmd->fimc[i])			break;		/*		 * Some FIMC variants are not fitted with camera capture		 * interface. Skip creating a link from sensor for those.		 */		if (sensor->grp_id == SENSOR_GROUP_ID &&		    !fmd->fimc[i]->variant->has_cam_if)			continue;		flags = (i == fimc_id) ? MEDIA_LNK_FL_ENABLED : 0;		sink = &fmd->fimc[i]->vid_cap.subdev->entity;		ret = media_entity_create_link(source, pad, sink,					      FIMC_SD_PAD_SINK, flags);		if (ret)			return ret;		/* Notify FIMC capture subdev entity */		ret = media_entity_call(sink, link_setup, &sink->pads[0],					&source->pads[pad], flags);		if (ret)			break;		v4l2_info(&fmd->v4l2_dev, "created link [%s] %c> [%s]",			  source->name, flags ? '=' : '-', sink->name);		if (flags == 0)			continue;		s_info = v4l2_get_subdev_hostdata(sensor);		if (!WARN_ON(s_info == NULL)) {			unsigned long irq_flags;			spin_lock_irqsave(&fmd->slock, irq_flags);			s_info->host = fmd->fimc[i];			spin_unlock_irqrestore(&fmd->slock, irq_flags);		}	}	return 0;}

static int g2d_remove(struct platform_device *pdev){	struct g2d_dev *dev = platform_get_drvdata(pdev);	v4l2_info(&dev->v4l2_dev, "Removing " G2D_NAME);	v4l2_m2m_release(dev->m2m_dev);	video_unregister_device(dev->vfd);	v4l2_device_unregister(&dev->v4l2_dev);	vb2_dma_contig_cleanup_ctx(dev->alloc_ctx);	clk_unprepare(dev->gate);	clk_put(dev->gate);	clk_unprepare(dev->clk);	clk_put(dev->clk);	return 0;}

/* * vpfe_remove : It un-registers device from V4L2 driver */static int vpfe_remove(struct platform_device *pdev){	struct vpfe_device *vpfe_dev = platform_get_drvdata(pdev);	v4l2_info(pdev->dev.driver, "vpfe_remove/n");	kzfree(vpfe_dev->sd);	vpfe_detach_irq(vpfe_dev);	vpfe_unregister_entities(vpfe_dev);	vpfe_cleanup_modules(vpfe_dev, pdev);	v4l2_device_unregister(&vpfe_dev->v4l2_dev);	vpfe_disable_clock(vpfe_dev);	kzfree(vpfe_dev);	return 0;}

static int mt9v011_probe(struct i2c_client *c,			 const struct i2c_device_id *id){	u16 version;	struct mt9v011 *core;	struct v4l2_subdev *sd;	/* Check if the adapter supports the needed features */	if (!i2c_check_functionality(c->adapter,	     I2C_FUNC_SMBUS_READ_BYTE | I2C_FUNC_SMBUS_WRITE_BYTE_DATA))		return -EIO;	core = kzalloc(sizeof(struct mt9v011), GFP_KERNEL);	if (!core)		return -ENOMEM;	sd = &core->sd;	v4l2_i2c_subdev_init(sd, c, &mt9v011_ops);	/* Check if the sensor is really a MT9V011 */	version = mt9v011_read(sd, R00_MT9V011_CHIP_VERSION);	if ((version != MT9V011_VERSION) &&	    (version != MT9V011_REV_B_VERSION)) {		v4l2_info(sd, "*** unknown micron chip detected (0x%04x)./n",			  version);		kfree(core);		return -EINVAL;	}	core->global_gain = 0x0024;	core->exposure = 0x01fc;	core->width  = 640;	core->height = 480;	core->xtal = 27000000;	/* Hz */	if (c->dev.platform_data) {		struct mt9v011_platform_data *pdata = c->dev.platform_data;		core->xtal = pdata->xtal;		v4l2_dbg(1, debug, sd, "xtal set to %d.%03d MHz/n",			core->xtal / 1000000, (core->xtal / 1000) % 1000);	}	v4l_info(c, "chip found @ 0x%02x (%s - chip version 0x%04x)/n",		 c->addr << 1, c->adapter->name, version);	return 0;}

static int imx_media_remove(struct platform_device *pdev){	struct imx_media_dev *imxmd =		(struct imx_media_dev *)platform_get_drvdata(pdev);	v4l2_info(&imxmd->v4l2_dev, "Removing imx-media/n");	v4l2_async_notifier_unregister(&imxmd->notifier);	imx_media_unregister_ipu_internal_subdevs(imxmd);	v4l2_async_notifier_cleanup(&imxmd->notifier);	media_device_unregister(&imxmd->md);	v4l2_device_unregister(&imxmd->v4l2_dev);	media_device_cleanup(&imxmd->md);	return 0;}

int rvin_v4l2_register(struct rvin_dev *vin){	struct video_device *vdev = &vin->vdev;	int ret;	vin->v4l2_dev.notify = rvin_notify;	/* video node */	vdev->v4l2_dev = &vin->v4l2_dev;	vdev->queue = &vin->queue;	snprintf(vdev->name, sizeof(vdev->name), "VIN%u output", vin->id);	vdev->release = video_device_release_empty;	vdev->lock = &vin->lock;	vdev->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING |		V4L2_CAP_READWRITE;	/* Set a default format */	vin->format.pixelformat	= RVIN_DEFAULT_FORMAT;	vin->format.width = RVIN_DEFAULT_WIDTH;	vin->format.height = RVIN_DEFAULT_HEIGHT;	vin->format.field = RVIN_DEFAULT_FIELD;	vin->format.colorspace = RVIN_DEFAULT_COLORSPACE;	if (vin->info->use_mc) {		vdev->fops = &rvin_mc_fops;		vdev->ioctl_ops = &rvin_mc_ioctl_ops;	} else {		vdev->fops = &rvin_fops;		vdev->ioctl_ops = &rvin_ioctl_ops;		rvin_reset_format(vin);	}	rvin_format_align(vin, &vin->format);	ret = video_register_device(&vin->vdev, VFL_TYPE_GRABBER, -1);	if (ret) {		vin_err(vin, "Failed to register video device/n");		return ret;	}	video_set_drvdata(&vin->vdev, vin);	v4l2_info(&vin->v4l2_dev, "Device registered as %s/n",		  video_device_node_name(&vin->vdev));	return ret;}

static int __init rtrack2_init(void){	struct rtrack2 *dev = &rtrack2_card;	struct v4l2_device *v4l2_dev = &dev->v4l2_dev;	int res;	strlcpy(v4l2_dev->name, "rtrack2", sizeof(v4l2_dev->name));	dev->io = io;	if (dev->io == -1) {		v4l2_err(v4l2_dev, "You must set an I/O address with io=0x20c or io=0x30c/n");		return -EINVAL;	}	if (!request_region(dev->io, 4, "rtrack2")) {		v4l2_err(v4l2_dev, "port 0x%x already in use/n", dev->io);		return -EBUSY;	}	res = v4l2_device_register(NULL, v4l2_dev);	if (res < 0) {		release_region(dev->io, 4);		v4l2_err(v4l2_dev, "Could not register v4l2_device/n");		return res;	}	strlcpy(dev->vdev.name, v4l2_dev->name, sizeof(dev->vdev.name));	dev->vdev.v4l2_dev = v4l2_dev;	dev->vdev.fops = &rtrack2_fops;	dev->vdev.ioctl_ops = &rtrack2_ioctl_ops;	dev->vdev.release = video_device_release_empty;	video_set_drvdata(&dev->vdev, dev);	mutex_init(&dev->lock);	if (video_register_device(&dev->vdev, VFL_TYPE_RADIO, radio_nr) < 0) {		v4l2_device_unregister(v4l2_dev);		release_region(dev->io, 4);		return -EINVAL;	}	v4l2_info(v4l2_dev, "AIMSlab Radiotrack II card driver./n");		outb(1, dev->io);	dev->muted = 1;	return 0;}

static int __devinit mdev_probe(struct platform_device *pdev){	struct v4l2_device *v4l2_dev;	struct exynos_md *mdev;	int ret;	mdev = kzalloc(sizeof(struct exynos_md), GFP_KERNEL);	if (!mdev)		return -ENOMEM;	mdev->id = pdev->id;	mdev->pdev = pdev;	spin_lock_init(&mdev->slock);	snprintf(mdev->media_dev.model, sizeof(mdev->media_dev.model), "%s%d",		 dev_name(&pdev->dev), mdev->id);	mdev->media_dev.dev = &pdev->dev;	v4l2_dev = &mdev->v4l2_dev;	v4l2_dev->mdev = &mdev->media_dev;	snprintf(v4l2_dev->name, sizeof(v4l2_dev->name), "%s",		 dev_name(&pdev->dev));	ret = v4l2_device_register(&pdev->dev, &mdev->v4l2_dev);	if (ret < 0) {		v4l2_err(v4l2_dev, "Failed to register v4l2_device: %d/n", ret);		goto err_v4l2_reg;	}	ret = media_device_register(&mdev->media_dev);	if (ret < 0) {		v4l2_err(v4l2_dev, "Failed to register media device: %d/n", ret);		goto err_mdev_reg;	}	platform_set_drvdata(pdev, mdev);	v4l2_info(v4l2_dev, "Media%d[0x%08x] was registered successfully/n",		  mdev->id, (unsigned int)mdev);	return 0;err_mdev_reg:	v4l2_device_unregister(&mdev->v4l2_dev);err_v4l2_reg:	kfree(mdev);	return ret;}

static int rockchip_vpu_video_device_register(struct rockchip_vpu_dev *vpu){	const struct of_device_id *match;	struct video_device *vfd;	int function, ret;	match = of_match_node(of_rockchip_vpu_match, vpu->dev->of_node);	vfd = video_device_alloc();	if (!vfd) {		v4l2_err(&vpu->v4l2_dev, "Failed to allocate video device/n");		return -ENOMEM;	}	vfd->fops = &rockchip_vpu_fops;	vfd->release = video_device_release;	vfd->lock = &vpu->vpu_mutex;	vfd->v4l2_dev = &vpu->v4l2_dev;	vfd->vfl_dir = VFL_DIR_M2M;	vfd->device_caps = V4L2_CAP_STREAMING | V4L2_CAP_VIDEO_M2M_MPLANE;	vfd->ioctl_ops = &rockchip_vpu_enc_ioctl_ops;	snprintf(vfd->name, sizeof(vfd->name), "%s-enc", match->compatible);	vpu->vfd_enc = vfd;	video_set_drvdata(vfd, vpu);	ret = video_register_device(vfd, VFL_TYPE_GRABBER, 0);	if (ret) {		v4l2_err(&vpu->v4l2_dev, "Failed to register video device/n");		goto err_free_dev;	}	v4l2_info(&vpu->v4l2_dev, "registered as /dev/video%d/n", vfd->num);	function = MEDIA_ENT_F_PROC_VIDEO_ENCODER;	ret = v4l2_m2m_register_media_controller(vpu->m2m_dev, vfd, function);	if (ret) {		v4l2_err(&vpu->v4l2_dev, "Failed to init mem2mem media controller/n");		goto err_unreg_video;	}	return 0;err_unreg_video:	video_unregister_device(vfd);err_free_dev:	video_device_release(vfd);	return ret;}

/* async subdev bound notifier */static int imx_media_subdev_bound(struct v4l2_async_notifier *notifier,				  struct v4l2_subdev *sd,				  struct v4l2_async_subdev *asd){	struct imx_media_dev *imxmd = notifier2dev(notifier);	int ret;	if (sd->grp_id & IMX_MEDIA_GRP_ID_IPU_CSI) {		/* register the IPU internal subdevs */		ret = imx_media_register_ipu_internal_subdevs(imxmd, sd);		if (ret)			return ret;	}	v4l2_info(&imxmd->v4l2_dev, "subdev %s bound/n", sd->name);	return 0;}

int fimc_register_m2m_device(struct fimc_dev *fimc,                             struct v4l2_device *v4l2_dev){    struct video_device *vfd = &fimc->m2m.vfd;    int ret;    fimc->v4l2_dev = v4l2_dev;    memset(vfd, 0, sizeof(*vfd));    vfd->fops = &fimc_m2m_fops;    vfd->ioctl_ops = &fimc_m2m_ioctl_ops;    vfd->v4l2_dev = v4l2_dev;    vfd->minor = -1;    vfd->release = video_device_release_empty;    vfd->lock = &fimc->lock;    vfd->vfl_dir = VFL_DIR_M2M;    snprintf(vfd->name, sizeof(vfd->name), "fimc.%d.m2m", fimc->id);    video_set_drvdata(vfd, fimc);    fimc->m2m.m2m_dev = v4l2_m2m_init(&m2m_ops);    if (IS_ERR(fimc->m2m.m2m_dev)) {        v4l2_err(v4l2_dev, "failed to initialize v4l2-m2m device/n");        return PTR_ERR(fimc->m2m.m2m_dev);    }    ret = media_entity_init(&vfd->entity, 0, NULL, 0);    if (ret)        goto err_me;    ret = video_register_device(vfd, VFL_TYPE_GRABBER, -1);    if (ret)        goto err_vd;    v4l2_info(v4l2_dev, "Registered %s as /dev/%s/n",              vfd->name, video_device_node_name(vfd));    return 0;err_vd:    media_entity_cleanup(&vfd->entity);err_me:    v4l2_m2m_release(fimc->m2m.m2m_dev);    return ret;}

int stk1160_video_register(struct stk1160 *dev){	int rc;	/* Initialize video_device with a template structure */	dev->vdev = v4l_template;	dev->vdev.debug = vidioc_debug;	dev->vdev.queue = &dev->vb_vidq;	/*	 * Provide mutexes for v4l2 core and for videobuf2 queue.	 * It will be used to protect *only* v4l2 ioctls.	 */	dev->vdev.lock = &dev->v4l_lock;	dev->vdev.queue->lock = &dev->vb_queue_lock;	/* This will be used to set video_device parent */	dev->vdev.v4l2_dev = &dev->v4l2_dev;	set_bit(V4L2_FL_USE_FH_PRIO, &dev->vdev.flags);	/* NTSC is default */	dev->norm = V4L2_STD_NTSC_M;	dev->width = 720;	dev->height = 480;	/* set default format */	dev->fmt = &format[0];	stk1160_set_std(dev);	v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_std,			dev->norm);	video_set_drvdata(&dev->vdev, dev);	rc = video_register_device(&dev->vdev, VFL_TYPE_GRABBER, -1);	if (rc < 0) {		stk1160_err("video_register_device failed (%d)/n", rc);		return rc;	}	v4l2_info(&dev->v4l2_dev, "V4L2 device registered as %s/n",		  video_device_node_name(&dev->vdev));	return 0;}

static int rockchip_vpu_remove(struct platform_device *pdev){	struct rockchip_vpu_dev *vpu = platform_get_drvdata(pdev);	v4l2_info(&vpu->v4l2_dev, "Removing %s/n", pdev->name);	media_device_unregister(&vpu->mdev);	v4l2_m2m_unregister_media_controller(vpu->m2m_dev);	v4l2_m2m_release(vpu->m2m_dev);	media_device_cleanup(&vpu->mdev);	if (vpu->vfd_enc) {		video_unregister_device(vpu->vfd_enc);		video_device_release(vpu->vfd_enc);	}	v4l2_device_unregister(&vpu->v4l2_dev);	clk_bulk_unprepare(vpu->variant->num_clocks, vpu->clocks);	pm_runtime_disable(vpu->dev);	return 0;}

/** * m5mols_s_power - Main sensor power control function * * To prevent breaking the lens when the sensor is powered off the Soft-Landing * algorithm is called where available. The Soft-Landing algorithm availability * dependends on the firmware provider. */static int m5mols_s_power(struct v4l2_subdev *sd, int on){	struct m5mols_info *info = to_m5mols(sd);	int ret;	if (on) {		ret = m5mols_sensor_power(info, true);		if (!ret)			ret = m5mols_sensor_armboot(sd);		if (!ret)			ret = m5mols_init_controls(info);		if (ret)			return ret;		info->ffmt[M5MOLS_RESTYPE_MONITOR] =			m5mols_default_ffmt[M5MOLS_RESTYPE_MONITOR];		info->ffmt[M5MOLS_RESTYPE_CAPTURE] =			m5mols_default_ffmt[M5MOLS_RESTYPE_CAPTURE];		return ret;	}	if (is_manufacturer(info, REG_SAMSUNG_TECHWIN)) {		ret = m5mols_mode(info, REG_MONITOR);		if (!ret)			ret = m5mols_write(sd, AF_EXECUTE, REG_AF_STOP);		if (!ret)			ret = m5mols_write(sd, AF_MODE, REG_AF_POWEROFF);		if (!ret)			ret = m5mols_busy(sd, CAT_SYSTEM, CAT0_STATUS,					REG_AF_IDLE);		if (!ret)			v4l2_info(sd, "Success soft-landing lens/n");	}	ret = m5mols_sensor_power(info, false);	if (!ret) {		v4l2_ctrl_handler_free(&info->handle);		info->ctrl_sync = false;	}	return ret;}

static int s5c73m3_spi_probe(struct spi_device *spi){	int r;	struct s5c73m3 *state = container_of(spi->dev.driver, struct s5c73m3,					     spidrv.driver);	spi->bits_per_word = 32;	r = spi_setup(spi);	if (r < 0) {		dev_err(&spi->dev, "spi_setup() failed/n");		return r;	}	mutex_lock(&state->lock);	state->spi_dev = spi;	mutex_unlock(&state->lock);	v4l2_info(&state->sensor_sd, "S5C73M3 SPI probed successfully/n");	return 0;}

/* * Sensor subdevice helper functions */static struct v4l2_subdev *fimc_md_register_sensor(struct fimc_md *fmd,				   struct fimc_sensor_info *s_info){	struct i2c_adapter *adapter;	struct v4l2_subdev *sd = NULL;	if (!s_info || !fmd)		return NULL;	if(s_info->pdata->use_isp)	{		fmd->fimc[0]->is_s5k6a3 = true;		fmd->fimc[1]->is_s5k6a3 = true;		return fmd->fimc_is_subdev;	}	adapter = i2c_get_adapter(s_info->pdata->i2c_bus_num);	if (!adapter) {		v4l2_warn(&fmd->v4l2_dev,			  "Failed to get I2C adapter %d, deferring probe/n",			  s_info->pdata->i2c_bus_num);		return ERR_PTR(-EPROBE_DEFER);	}	sd = v4l2_i2c_new_subdev_board(&fmd->v4l2_dev, adapter,				       s_info->pdata->board_info, NULL);	if (IS_ERR_OR_NULL(sd)) {		i2c_put_adapter(adapter);		v4l2_warn(&fmd->v4l2_dev,			  "Failed to acquire subdev %s, deferring probe/n",			  s_info->pdata->board_info->type);		return ERR_PTR(-EPROBE_DEFER);	}	v4l2_set_subdev_hostdata(sd, s_info);	sd->grp_id = SENSOR_GROUP_ID;	v4l2_info(&fmd->v4l2_dev, "Registered sensor subdevice %s/n",		  s_info->pdata->board_info->type);	fmd->fimc[0]->is_m5mo = true;	fmd->fimc[1]->is_m5mo = true;	return sd;}

static int g2d_open(struct file *file){	struct g2d_dev *dev = video_drvdata(file);	struct g2d_ctx *ctx = NULL;	int ret = 0;	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);	if (!ctx)		return -ENOMEM;	ctx->dev = dev;	/* Set default formats */	ctx->in		= def_frame;	ctx->out	= def_frame;	if (mutex_lock_interruptible(&dev->mutex)) {		kfree(ctx);		return -ERESTARTSYS;	}	ctx->fh.m2m_ctx = v4l2_m2m_ctx_init(dev->m2m_dev, ctx, &queue_init);	if (IS_ERR(ctx->fh.m2m_ctx)) {		ret = PTR_ERR(ctx->fh.m2m_ctx);		mutex_unlock(&dev->mutex);		kfree(ctx);		return ret;	}	v4l2_fh_init(&ctx->fh, video_devdata(file));	file->private_data = &ctx->fh;	v4l2_fh_add(&ctx->fh);	g2d_setup_ctrls(ctx);	/* Write the default values to the ctx struct */	v4l2_ctrl_handler_setup(&ctx->ctrl_handler);	ctx->fh.ctrl_handler = &ctx->ctrl_handler;	mutex_unlock(&dev->mutex);	v4l2_info(&dev->v4l2_dev, "instance opened/n");	return 0;}

/* * Videobuf2 operations */static int queue_setup(struct vb2_queue *vq,#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 4, 0)			const struct v4l2_format *v4l2_fmt,#else			const void *parg,#endif			unsigned int *nbuffers, unsigned int *nplanes,			unsigned int sizes[], void *alloc_ctxs[]){	struct smi2021 *smi2021 = vb2_get_drv_priv(vq);	*nbuffers = clamp_t(unsigned int, *nbuffers, 4, 16);	sizes[0] = SMI2021_BYTES_PER_LINE * smi2021->cur_height;	/* This means a packed colorformat */	*nplanes = 1;	v4l2_info(&smi2021->v4l2_dev, "%s: buffer count %d, each %d bytes/n",				__func__, *nbuffers, sizes[0]);	return 0;}

static int csis_register_callback(struct device *dev, void *p){	struct v4l2_subdev *sd = dev_get_drvdata(dev);	struct platform_device *pdev;	struct fimc_md *fmd = p;	int id, ret;	if (!sd)		return 0;	pdev = v4l2_get_subdevdata(sd);	if (!pdev || pdev->id < 0 || pdev->id >= CSIS_MAX_ENTITIES)		return 0;	v4l2_info(sd, "csis%d sd: %s/n", pdev->id, sd->name);	id = pdev->id < 0 ? 0 : pdev->id;	fmd->csis[id].sd = sd;	sd->grp_id = CSIS_GROUP_ID;	ret = v4l2_device_register_subdev(&fmd->v4l2_dev, sd);	if (ret)		v4l2_err(&fmd->v4l2_dev,			 "Failed to register CSIS subdevice: %d/n", ret);	return ret;}

/* * si4713_checkrev - Checks if we are treating a device with the correct rev. * @sdev: si4713_device structure for the device we are communicating */static int si4713_checkrev(struct si4713_device *sdev){	struct i2c_client *client = v4l2_get_subdevdata(&sdev->sd);	int rval;	u8 resp[SI4713_GETREV_NRESP];	rval = si4713_send_command(sdev, SI4713_CMD_GET_REV,					NULL, 0,					resp, ARRAY_SIZE(resp),					DEFAULT_TIMEOUT);	if (rval < 0)		return rval;	if (resp[1] == SI4713_PRODUCT_NUMBER) {		v4l2_info(&sdev->sd, "chip found @ 0x%02x (%s)/n",				client->addr << 1, client->adapter->name);	} else {		v4l2_err(&sdev->sd, "Invalid product number/n");		rval = -EINVAL;	}	return rval;}

static struct v4l2_subdev *fimc_subdev_register(struct fimc_dev *fimc,        struct s5p_fimc_isp_info *isp_info){    struct i2c_adapter *i2c_adap;    struct fimc_vid_cap *vid_cap = &fimc->vid_cap;    struct v4l2_subdev *sd = NULL;    i2c_adap = i2c_get_adapter(isp_info->i2c_bus_num);    if (!i2c_adap)        return ERR_PTR(-ENOMEM);    sd = v4l2_i2c_new_subdev_board(&vid_cap->v4l2_dev, i2c_adap,                                   isp_info->board_info, NULL);    if (!sd) {        v4l2_err(&vid_cap->v4l2_dev, "failed to acquire subdev/n");        return NULL;    }    v4l2_info(&vid_cap->v4l2_dev, "subdevice %s registered successfuly/n",              isp_info->board_info->type);    return sd;}

/* * Sensor subdevice helper functions */static struct v4l2_subdev *fimc_md_register_sensor(struct fimc_md *fmd,						struct fimc_source_info *si){	struct i2c_adapter *adapter;	struct v4l2_subdev *sd = NULL;	if (!si || !fmd)		return NULL;	/*	 * If FIMC bus type is not Writeback FIFO assume it is same	 * as sensor_bus_type.	 */	si->fimc_bus_type = si->sensor_bus_type;	adapter = i2c_get_adapter(si->i2c_bus_num);	if (!adapter) {		v4l2_warn(&fmd->v4l2_dev,			  "Failed to get I2C adapter %d, deferring probe/n",			  si->i2c_bus_num);		return ERR_PTR(-EPROBE_DEFER);	}	sd = v4l2_i2c_new_subdev_board(&fmd->v4l2_dev, adapter,						si->board_info, NULL);	if (IS_ERR_OR_NULL(sd)) {		i2c_put_adapter(adapter);		v4l2_warn(&fmd->v4l2_dev,			  "Failed to acquire subdev %s, deferring probe/n",			  si->board_info->type);		return ERR_PTR(-EPROBE_DEFER);	}	v4l2_set_subdev_hostdata(sd, si);	sd->grp_id = GRP_ID_SENSOR;	v4l2_info(&fmd->v4l2_dev, "Registered sensor subdevice %s/n",		  sd->name);	return sd;}

static int vivid_fop_release(struct file *file){	struct vivid_dev *dev = video_drvdata(file);	struct video_device *vdev = video_devdata(file);	mutex_lock(&dev->mutex);	if (!no_error_inj && v4l2_fh_is_singular_file(file) &&	    !video_is_registered(vdev) && vivid_is_last_user(dev)) {		/*		 * I am the last user of this driver, and a disconnect		 * was forced (since this video_device is unregistered),		 * so re-register all video_device's again.		 */		v4l2_info(&dev->v4l2_dev, "reconnect/n");		set_bit(V4L2_FL_REGISTERED, &dev->vid_cap_dev.flags);		set_bit(V4L2_FL_REGISTERED, &dev->vid_out_dev.flags);		set_bit(V4L2_FL_REGISTERED, &dev->vbi_cap_dev.flags);		set_bit(V4L2_FL_REGISTERED, &dev->vbi_out_dev.flags);		set_bit(V4L2_FL_REGISTERED, &dev->sdr_cap_dev.flags);		set_bit(V4L2_FL_REGISTERED, &dev->radio_rx_dev.flags);		set_bit(V4L2_FL_REGISTERED, &dev->radio_tx_dev.flags);	}	mutex_unlock(&dev->mutex);	if (file->private_data == dev->overlay_cap_owner)		dev->overlay_cap_owner = NULL;	if (file->private_data == dev->radio_rx_rds_owner) {		dev->radio_rx_rds_last_block = 0;		dev->radio_rx_rds_owner = NULL;	}	if (file->private_data == dev->radio_tx_rds_owner) {		dev->radio_tx_rds_last_block = 0;		dev->radio_tx_rds_owner = NULL;	}	if (vdev->queue)		return vb2_fop_release(file);	return v4l2_fh_release(file);}

static int vivid_user_gen_s_ctrl(struct v4l2_ctrl *ctrl){	struct vivid_dev *dev = container_of(ctrl->handler, struct vivid_dev, ctrl_hdl_user_gen);	switch (ctrl->id) {	case VIVID_CID_DISCONNECT:		v4l2_info(&dev->v4l2_dev, "disconnect/n");		clear_bit(V4L2_FL_REGISTERED, &dev->vid_cap_dev.flags);		clear_bit(V4L2_FL_REGISTERED, &dev->vid_out_dev.flags);		clear_bit(V4L2_FL_REGISTERED, &dev->vbi_cap_dev.flags);		clear_bit(V4L2_FL_REGISTERED, &dev->vbi_out_dev.flags);		clear_bit(V4L2_FL_REGISTERED, &dev->sdr_cap_dev.flags);		clear_bit(V4L2_FL_REGISTERED, &dev->radio_rx_dev.flags);		clear_bit(V4L2_FL_REGISTERED, &dev->radio_tx_dev.flags);		break;	case VIVID_CID_CLEAR_FB:		vivid_clear_fb(dev);		break;	case VIVID_CID_BUTTON:		dev->button_pressed = 30;		break;	}	return 0;}