/******************************************************************************
*
* cpia2_open
*
*****************************************************************************/
static int cpia2_open(struct file *file)
{
struct camera_data *cam = video_drvdata(file);
int retval;
if (mutex_lock_interruptible(&cam->v4l2_lock))
return -ERESTARTSYS;
retval = v4l2_fh_open(file);
if (retval)
goto open_unlock;
if (v4l2_fh_is_singular_file(file)) {
if (cpia2_allocate_buffers(cam)) {
v4l2_fh_release(file);
retval = -ENOMEM;
goto open_unlock;
}
/* reset the camera */
if (cpia2_reset_camera(cam) < 0) {
v4l2_fh_release(file);
retval = -EIO;
goto open_unlock;
}
cam->APP_len = 0;
cam->COM_len = 0;
}
cpia2_dbg_dump_registers(cam);
open_unlock:
mutex_unlock(&cam->v4l2_lock);
return retval;
}
/******************************************************************************
*
* cpia2_open
*
*****************************************************************************/
static int cpia2_open(struct file *file)
{
struct camera_data *cam = video_drvdata(file);
int retval = v4l2_fh_open(file);
if (retval)
return retval;
if (v4l2_fh_is_singular_file(file)) {
if (cpia2_allocate_buffers(cam)) {
v4l2_fh_release(file);
return -ENOMEM;
}
/* reset the camera */
if (cpia2_reset_camera(cam) < 0) {
v4l2_fh_release(file);
return -EIO;
}
cam->APP_len = 0;
cam->COM_len = 0;
}
cpia2_dbg_dump_registers(cam);
return 0;
}
static int fimc_capture_close(struct file *file)
{
struct fimc_dev *fimc = video_drvdata(file);
int ret;
dbg("pid: %d, state: 0x%lx", task_pid_nr(current), fimc->state);
if (mutex_lock_interruptible(&fimc->lock))
return -ERESTARTSYS;
if (--fimc->vid_cap.refcnt == 0) {
clear_bit(ST_CAPT_BUSY, &fimc->state);
fimc_stop_capture(fimc, false);
fimc_pipeline_call(fimc, close, &fimc->pipeline);
clear_bit(ST_CAPT_SUSPENDED, &fimc->state);
}
pm_runtime_put(&fimc->pdev->dev);
if (fimc->vid_cap.refcnt == 0) {
vb2_queue_release(&fimc->vid_cap.vbq);
fimc_ctrls_delete(fimc->vid_cap.ctx);
}
ret = v4l2_fh_release(file);
mutex_unlock(&fimc->lock);
return ret;
}
static int fimc_lite_close(struct file *file)
{
struct fimc_lite *fimc = video_drvdata(file);
int ret;
if (mutex_lock_interruptible(&fimc->lock))
return -ERESTARTSYS;
if (--fimc->ref_count == 0 && fimc->out_path == FIMC_IO_DMA) {
clear_bit(ST_FLITE_IN_USE, &fimc->state);
fimc_lite_stop_capture(fimc, false);
fimc_pipeline_shutdown(&fimc->pipeline);
clear_bit(ST_FLITE_SUSPENDED, &fimc->state);
}
pm_runtime_put(&fimc->pdev->dev);
platform_sysmmu_off(&fimc->pdev->dev);
if (fimc->ref_count == 0)
vb2_queue_release(&fimc->vb_queue);
ret = v4l2_fh_release(file);
mutex_unlock(&fimc->lock);
return ret;
}
static int gsc_capture_close(struct file *file)
{
struct gsc_dev *gsc = video_drvdata(file);
struct vb2_queue *q = &gsc->cap.vbq;
int ret = 0;
gsc_dbg("pid: %d, state: 0x%lx", task_pid_nr(current), gsc->state);
if (q->streaming)
gsc_capture_stop_streaming(q);
if (--gsc->cap.refcnt == 0) {
clear_bit(ST_CAPT_OPEN, &gsc->state);
gsc_dbg("G-Scaler h/w disable control");
clear_bit(ST_CAPT_RUN, &gsc->state);
vb2_queue_release(&gsc->cap.vbq);
gsc_ctrls_delete(gsc->cap.ctx);
ret = gsc_clk_disable_for_wb(gsc);
if (ret)
return ret;
}
pm_runtime_put_sync(&gsc->pdev->dev);
return v4l2_fh_release(file);
}
static int fimc_lite_open(struct file *file)
{
struct fimc_lite *fimc = video_drvdata(file);
int ret;
if (mutex_lock_interruptible(&fimc->lock))
return -ERESTARTSYS;
set_bit(ST_FLITE_IN_USE, &fimc->state);
ret = pm_runtime_get_sync(&fimc->pdev->dev);
if (ret < 0)
goto done;
ret = v4l2_fh_open(file);
if (ret < 0)
goto done;
if (++fimc->ref_count == 1 && fimc->out_path == FIMC_IO_DMA) {
ret = fimc_pipeline_call(fimc, open, &fimc->pipeline,
&fimc->vfd.entity, true);
if (ret < 0) {
pm_runtime_put_sync(&fimc->pdev->dev);
fimc->ref_count--;
v4l2_fh_release(file);
clear_bit(ST_FLITE_IN_USE, &fimc->state);
}
fimc_lite_clear_event_counters(fimc);
}
done:
mutex_unlock(&fimc->lock);
return ret;
}
static int rvin_open(struct file *file)
{
struct rvin_dev *vin = video_drvdata(file);
int ret;
mutex_lock(&vin->lock);
file->private_data = vin;
ret = v4l2_fh_open(file);
if (ret)
goto unlock;
if (!v4l2_fh_is_singular_file(file))
goto unlock;
if (rvin_initialize_device(file)) {
v4l2_fh_release(file);
ret = -ENODEV;
}
unlock:
mutex_unlock(&vin->lock);
return ret;
}
static int pwc_video_close(struct file *file)
{
struct pwc_device *pdev = video_drvdata(file);
if (pdev->capt_file == file) {
vb2_queue_release(&pdev->vb_queue);
pdev->capt_file = NULL;
}
return v4l2_fh_release(file);
}
static int gsc_capture_open(struct file *file)
{
struct gsc_dev *gsc = video_drvdata(file);
int ret = v4l2_fh_open(file);
if (ret)
return ret;
if (gsc_m2m_opened(gsc) || gsc_out_opened(gsc) || gsc_cap_opened(gsc)) {
v4l2_fh_release(file);
return -EBUSY;
}
set_bit(ST_CAPT_OPEN, &gsc->state);
pm_runtime_get_sync(&gsc->pdev->dev);
if (++gsc->cap.refcnt == 1) {
ret = gsc_cap_pipeline_initialize(gsc, &gsc->cap.vfd->entity, true);
if (ret < 0) {
gsc_err("gsc pipeline initialization failed\n");
goto err;
}
ret = gsc_capture_ctrls_create(gsc);
if (ret) {
gsc_err("failed to create controls\n");
goto err;
}
}
gsc_dbg("pid: %d, state: 0x%lx", task_pid_nr(current), gsc->state);
return 0;
err:
pm_runtime_put_sync(&gsc->pdev->dev);
v4l2_fh_release(file);
clear_bit(ST_CAPT_OPEN, &gsc->state);
return ret;
}
int _vb2_fop_release(struct file *file, struct mutex *lock)
{
struct video_device *vdev = video_devdata(file);
if (lock)
mutex_lock(lock);
if (file->private_data == vdev->queue->owner) {
vb2_queue_release(vdev->queue);
vdev->queue->owner = NULL;
}
if (lock)
mutex_unlock(lock);
return v4l2_fh_release(file);
}
static int fimc_lite_open(struct file *file)
{
struct fimc_lite *fimc = video_drvdata(file);
struct media_entity *me = &fimc->ve.vdev.entity;
int ret;
mutex_lock(&fimc->lock);
if (atomic_read(&fimc->out_path) != FIMC_IO_DMA) {
ret = -EBUSY;
goto unlock;
}
set_bit(ST_FLITE_IN_USE, &fimc->state);
ret = pm_runtime_get_sync(&fimc->pdev->dev);
if (ret < 0)
goto unlock;
ret = v4l2_fh_open(file);
if (ret < 0)
goto err_pm;
if (!v4l2_fh_is_singular_file(file) ||
atomic_read(&fimc->out_path) != FIMC_IO_DMA)
goto unlock;
mutex_lock(&me->parent->graph_mutex);
ret = fimc_pipeline_call(&fimc->ve, open, me, true);
/* Mark video pipeline ending at this video node as in use. */
if (ret == 0)
me->use_count++;
mutex_unlock(&me->parent->graph_mutex);
if (!ret) {
fimc_lite_clear_event_counters(fimc);
goto unlock;
}
v4l2_fh_release(file);
err_pm:
pm_runtime_put_sync(&fimc->pdev->dev);
clear_bit(ST_FLITE_IN_USE, &fimc->state);
unlock:
mutex_unlock(&fimc->lock);
return ret;
}
static int fimc_capture_open(struct file *file)
{
struct fimc_dev *fimc = video_drvdata(file);
int ret = -EBUSY;
dbg("pid: %d, state: 0x%lx", task_pid_nr(current), fimc->state);
if (mutex_lock_interruptible(&fimc->lock))
return -ERESTARTSYS;
if (fimc_m2m_active(fimc))
goto unlock;
set_bit(ST_CAPT_BUSY, &fimc->state);
ret = pm_runtime_get_sync(&fimc->pdev->dev);
if (ret < 0)
goto unlock;
ret = v4l2_fh_open(file);
if (ret) {
pm_runtime_put(&fimc->pdev->dev);
goto unlock;
}
if (++fimc->vid_cap.refcnt == 1) {
ret = fimc_pipeline_call(fimc, open, &fimc->pipeline,
&fimc->vid_cap.vfd.entity, true);
if (!ret && !fimc->vid_cap.user_subdev_api)
ret = fimc_capture_set_default_format(fimc);
if (!ret)
ret = fimc_capture_ctrls_create(fimc);
if (ret < 0) {
clear_bit(ST_CAPT_BUSY, &fimc->state);
pm_runtime_put_sync(&fimc->pdev->dev);
fimc->vid_cap.refcnt--;
v4l2_fh_release(file);
}
}
unlock:
mutex_unlock(&fimc->lock);
return ret;
}
static int xvip_dma_release(struct file *file)
{
struct xvip_dma *dma = video_drvdata(file);
struct v4l2_fh *vfh = file->private_data;
mutex_lock(&dma->lock);
if (dma->queue.owner == vfh) {
vb2_queue_release(&dma->queue);
dma->queue.owner = NULL;
}
mutex_unlock(&dma->lock);
v4l2_fh_release(file);
file->private_data = NULL;
return 0;
}
static int mxr_video_release(struct file *file)
{
struct mxr_layer *layer = video_drvdata(file);
mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
/* initialize alpha blending variables */
layer->layer_blend_en = 0;
layer->layer_alpha = 0;
layer->pixel_blend_en = 0;
layer->chroma_en = 0;
layer->chroma_val = 0;
if (v4l2_fh_is_singular_file(file))
vb2_queue_release(&layer->vb_queue);
v4l2_fh_release(file);
return 0;
}
static int fimc_capture_close(struct file *file)
{
struct fimc_dev *fimc = video_drvdata(file);
dbg("pid: %d, state: 0x%lx", task_pid_nr(current), fimc->state);
if (--fimc->vid_cap.refcnt == 0) {
clear_bit(ST_CAPT_BUSY, &fimc->state);
fimc_stop_capture(fimc, false);
fimc_pipeline_shutdown(fimc);
clear_bit(ST_CAPT_SUSPENDED, &fimc->state);
}
pm_runtime_put(&fimc->pdev->dev);
if (fimc->vid_cap.refcnt == 0) {
vb2_queue_release(&fimc->vid_cap.vbq);
fimc_ctrls_delete(fimc->vid_cap.ctx);
}
return v4l2_fh_release(file);
}
/******************************************************************************
*
* cpia2_close
*
*****************************************************************************/
static int cpia2_close(struct file *file)
{
struct video_device *dev = video_devdata(file);
struct camera_data *cam = video_get_drvdata(dev);
if (video_is_registered(&cam->vdev) && v4l2_fh_is_singular_file(file)) {
cpia2_usb_stream_stop(cam);
/* save camera state for later open */
cpia2_save_camera_state(cam);
cpia2_set_low_power(cam);
cpia2_free_buffers(cam);
}
if (cam->stream_fh == file->private_data) {
cam->stream_fh = NULL;
cam->mmapped = 0;
}
return v4l2_fh_release(file);
}
static int video_open(struct file *file)
{
struct video_device *vdev = video_devdata(file);
struct camss_video *video = video_drvdata(file);
struct v4l2_fh *vfh;
int ret;
mutex_lock(&video->lock);
vfh = kzalloc(sizeof(*vfh), GFP_KERNEL);
if (vfh == NULL) {
ret = -ENOMEM;
goto error_alloc;
}
v4l2_fh_init(vfh, vdev);
v4l2_fh_add(vfh);
file->private_data = vfh;
ret = v4l2_pipeline_pm_use(&vdev->entity, 1);
if (ret < 0) {
dev_err(video->camss->dev, "Failed to power up pipeline: %d\n",
ret);
goto error_pm_use;
}
mutex_unlock(&video->lock);
return 0;
error_pm_use:
v4l2_fh_release(file);
error_alloc:
mutex_unlock(&video->lock);
return ret;
}
static int gsc_capture_close(struct file *file)
{
struct gsc_dev *gsc = video_drvdata(file);
gsc_dbg("pid: %d, state: 0x%lx", task_pid_nr(current), gsc->state);
if (--gsc->cap.refcnt == 0) {
clear_bit(ST_CAPT_OPEN, &gsc->state);
gsc_dbg("G-Scaler h/w disable control");
gsc_hw_enable_control(gsc, false);
clear_bit(ST_CAPT_STREAM, &gsc->state);
gsc_cap_pipeline_shutdown(gsc);
}
if (gsc->cap.refcnt == 0) {
vb2_queue_release(&gsc->cap.vbq);
gsc_ctrls_delete(gsc->cap.ctx);
}
pm_runtime_put_sync(&gsc->pdev->dev);
return v4l2_fh_release(file);
}
static int mxr_video_open(struct file *file)
{
struct mxr_layer *layer = video_drvdata(file);
struct mxr_device *mdev = layer->mdev;
int ret = 0;
mxr_dbg(mdev, "%s:%d\n", __func__, __LINE__);
/* assure device probe is finished */
wait_for_device_probe();
/* creating context for file descriptor */
ret = v4l2_fh_open(file);
if (ret) {
mxr_err(mdev, "v4l2_fh_open failed\n");
return ret;
}
/* leaving if layer is already initialized */
if (!v4l2_fh_is_singular_file(file))
return 0;
ret = vb2_queue_init(&layer->vb_queue);
if (ret != 0) {
mxr_err(mdev, "failed to initialize vb2 queue\n");
goto fail_fh_open;
}
/* set default format, first on the list */
layer->fmt = layer->fmt_array[0];
/* setup default geometry */
mxr_layer_default_geo(layer);
return 0;
fail_fh_open:
v4l2_fh_release(file);
return ret;
}
static int isp_video_open(struct file *file)
{
struct fimc_isp *isp = video_drvdata(file);
struct exynos_video_entity *ve = &isp->video_capture.ve;
struct media_entity *me = &ve->vdev.entity;
int ret;
if (mutex_lock_interruptible(&isp->video_lock))
return -ERESTARTSYS;
ret = v4l2_fh_open(file);
if (ret < 0)
goto unlock;
ret = pm_runtime_get_sync(&isp->pdev->dev);
if (ret < 0)
goto rel_fh;
if (v4l2_fh_is_singular_file(file)) {
mutex_lock(&me->graph_obj.mdev->graph_mutex);
ret = fimc_pipeline_call(ve, open, me, true);
/* Mark the video pipeline as in use. */
if (ret == 0)
me->use_count++;
mutex_unlock(&me->graph_obj.mdev->graph_mutex);
}
if (!ret)
goto unlock;
rel_fh:
v4l2_fh_release(file);
unlock:
mutex_unlock(&isp->video_lock);
return ret;
}
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 fimc_lite_close(struct file *file)
{
struct fimc_lite *fimc = video_drvdata(file);
int ret;
mutex_lock(&fimc->lock);
if (--fimc->ref_count == 0 && fimc->out_path == FIMC_IO_DMA) {
clear_bit(ST_FLITE_IN_USE, &fimc->state);
fimc_lite_stop_capture(fimc, false);
fimc_pipeline_call(fimc, close, &fimc->pipeline);
clear_bit(ST_FLITE_SUSPENDED, &fimc->state);
}
pm_runtime_put(&fimc->pdev->dev);
if (fimc->ref_count == 0)
vb2_queue_release(&fimc->vb_queue);
ret = v4l2_fh_release(file);
mutex_unlock(&fimc->lock);
return ret;
}
static int fimc_capture_open(struct file *file)
{
struct fimc_dev *fimc = video_drvdata(file);
int ret = v4l2_fh_open(file);
if (ret)
return ret;
dbg("pid: %d, state: 0x%lx", task_pid_nr(current), fimc->state);
/* Return if the corresponding video mem2mem node is already opened. */
if (fimc_m2m_active(fimc))
return -EBUSY;
set_bit(ST_CAPT_BUSY, &fimc->state);
pm_runtime_get_sync(&fimc->pdev->dev);
if (++fimc->vid_cap.refcnt == 1) {
ret = fimc_pipeline_initialize(fimc,
&fimc->vid_cap.vfd->entity, true);
if (ret < 0) {
dev_err(&fimc->pdev->dev,
"Video pipeline initialization failed\n");
pm_runtime_put_sync(&fimc->pdev->dev);
fimc->vid_cap.refcnt--;
v4l2_fh_release(file);
clear_bit(ST_CAPT_BUSY, &fimc->state);
return ret;
}
ret = fimc_capture_ctrls_create(fimc);
if (!ret && !fimc->vid_cap.user_subdev_api)
ret = fimc_capture_set_default_format(fimc);
}
return ret;
}
int si470x_fops_release(struct file *file)
{
return v4l2_fh_release(file);
}
//在open函数中初始化buffer队列，则在close函数中销毁buffer队列。
static int myvivi_close(struct file *file)
{
del_timer(&myvivi_timer);
return v4l2_fh_release(file);
}
