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