static int jpeg_m2m_release(struct file *file)
{
struct jpeg_ctx *ctx = file->private_data;
unsigned long flags;
spin_lock_irqsave(&ctx->slock, flags);
if (test_bit(0, &ctx->dev->hw_run) == 0)
del_timer_sync(&ctx->dev->watchdog_timer);
v4l2_m2m_ctx_release(ctx->m2m_ctx);
spin_unlock_irqrestore(&ctx->slock, flags);
#ifdef CONFIG_PM_RUNTIME
#if defined (CONFIG_CPU_EXYNOS5250)
ctx->dev->vb2->suspend(ctx->dev->alloc_ctx);
#ifdef CONFIG_BUSFREQ_OPP
/* Unlock bus frequency */
dev_unlock(ctx->dev->bus_dev, &ctx->dev->plat_dev->dev);
#endif
#else
pm_runtime_put_sync(&ctx->dev->plat_dev->dev);
#endif
#endif
clk_disable(ctx->dev->clk);
kfree(ctx);
return 0;
}
static int hva_release(struct file *file)
{
struct hva_ctx *ctx = fh_to_ctx(file->private_data);
struct hva_dev *hva = ctx_to_hdev(ctx);
struct device *dev = ctx_to_dev(ctx);
const struct hva_enc *enc = ctx->enc;
if (enc) {
dev_dbg(dev, "%s %s encoder closed\n", ctx->name, enc->name);
enc->close(ctx);
ctx->enc = NULL;
/* clear instance context in instances array */
hva->instances[ctx->id] = NULL;
hva->nb_of_instances--;
}
v4l2_m2m_ctx_release(ctx->fh.m2m_ctx);
v4l2_ctrl_handler_free(&ctx->ctrl_handler);
v4l2_fh_del(&ctx->fh);
v4l2_fh_exit(&ctx->fh);
dev_info(dev, "%s encoder instance released\n", ctx->name);
kfree(ctx);
return 0;
}
static int nxp_video_release(struct file *file)
{
struct nxp_video *me = video_drvdata(file);
u32 pad;
struct v4l2_subdev *sd;
int ret = 0;
me->open_count--;
if (me->open_count == 0) {
sd = _get_remote_subdev(me,
me->type == NXP_VIDEO_TYPE_OUT ?
V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE : V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE,
&pad);
if (sd) {
ret = v4l2_subdev_call(sd, core, s_power, 0);
if (ret < 0) {
pr_err("%s: failed to subdev_call s_power(ret: %d)\n", __func__, ret);
return ret;
}
}
if (me->vbq)
vb2_queue_release(me->vbq);
if (me->m2m_ctx) {
v4l2_m2m_ctx_release(me->m2m_ctx);
me->m2m_ctx = NULL;
}
}
file->private_data = 0;
return ret;
}
static int bdisp_release(struct file *file)
{
struct bdisp_ctx *ctx = fh_to_ctx(file->private_data);
struct bdisp_dev *bdisp = ctx->bdisp_dev;
dev_dbg(bdisp->dev, "%s\n", __func__);
if (mutex_lock_interruptible(&bdisp->lock))
return -ERESTARTSYS;
v4l2_m2m_ctx_release(ctx->fh.m2m_ctx);
bdisp_ctrls_delete(ctx);
v4l2_fh_del(&ctx->fh);
v4l2_fh_exit(&ctx->fh);
if (--bdisp->m2m.refcnt <= 0)
clear_bit(ST_M2M_OPEN, &bdisp->state);
bdisp_hw_free_nodes(ctx);
kfree(ctx);
mutex_unlock(&bdisp->lock);
return 0;
}
static int gsc_m2m_release(struct file *file)
{
struct gsc_ctx *ctx = fh_to_ctx(file->private_data);
struct gsc_dev *gsc = ctx->gsc_dev;
gsc_dbg("pid: %d, state: 0x%lx, refcnt= %d",
task_pid_nr(current), gsc->state, gsc->m2m.refcnt);
v4l2_m2m_ctx_release(ctx->m2m_ctx);
gsc_ctrls_delete(ctx);
v4l2_fh_del(&ctx->fh);
v4l2_fh_exit(&ctx->fh);
if (--gsc->m2m.refcnt <= 0)
clear_bit(ST_M2M_OPEN, &gsc->state);
/* This is unnormal case */
if (gsc->protected_content) {
int id = gsc->id + 3;
gsc_err("DRM should be disabled before device close");
exynos_smc(SMC_PROTECTION_SET, 0, id, 0);
gsc_set_protected_content(gsc, false);
}
kfree(ctx);
return 0;
}
static int gsc_m2m_release(struct file *file)
{
struct gsc_ctx *ctx = fh_to_ctx(file->private_data);
struct gsc_dev *gsc = ctx->gsc_dev;
gsc_dbg("pid: %d, state: 0x%lx, refcnt= %d",
task_pid_nr(current), gsc->state, gsc->m2m.refcnt);
/* if we didn't properly sequence with the secure side to turn off
* content protection, we may be left in a very bad state and the
* only way to recover this reliably is to reboot.
*/
BUG_ON(gsc->protected_content);
kfree(ctx->m2m_ctx->cap_q_ctx.q.name);
kfree(ctx->m2m_ctx->out_q_ctx.q.name);
v4l2_m2m_ctx_release(ctx->m2m_ctx);
gsc_ctrls_delete(ctx);
v4l2_fh_del(&ctx->fh);
v4l2_fh_exit(&ctx->fh);
if (--gsc->m2m.refcnt <= 0)
clear_bit(ST_M2M_OPEN, &gsc->state);
kfree(ctx);
return 0;
}
void unregister_nxp_video(struct nxp_video *me)
{
if (me->m2m_ctx) {
v4l2_m2m_ctx_release(me->m2m_ctx);
me->m2m_ctx = NULL;
}
video_unregister_device(&me->vdev);
}
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 int rot_release(struct file *file)
{
struct rot_ctx *ctx = file->private_data;
struct rot_dev *rot = ctx->rot_dev;
rot_dbg("refcnt= %d", atomic_read(&rot->m2m.in_use));
v4l2_m2m_ctx_release(ctx->m2m_ctx);
kfree(ctx);
atomic_dec(&rot->m2m.in_use);
return 0;
}
static int s5p_jpeg_release(struct file *file)
{
struct s5p_jpeg *jpeg = video_drvdata(file);
struct s5p_jpeg_ctx *ctx = fh_to_ctx(file->private_data);
mutex_lock(&jpeg->lock);
v4l2_m2m_ctx_release(ctx->m2m_ctx);
mutex_unlock(&jpeg->lock);
v4l2_ctrl_handler_free(&ctx->ctrl_handler);
v4l2_fh_del(&ctx->fh);
v4l2_fh_exit(&ctx->fh);
kfree(ctx);
return 0;
}
static int jpeg_hx_m2m_release(struct file *file)
{
struct jpeg_ctx *ctx = file->private_data;
v4l2_m2m_ctx_release(ctx->m2m_ctx);
#ifdef CONFIG_BUSFREQ_OPP
/* Unlock bus frequency */
dev_unlock(ctx->dev->bus_dev, &ctx->dev->plat_dev->dev);
#endif
ctx->dev->vb2->suspend(ctx->dev->alloc_ctx);
clk_disable(ctx->dev->clk);
clk_disable(ctx->dev->sclk_clk);
kfree(ctx);
return 0;
}
static int rockchip_vpu_release(struct file *filp)
{
struct rockchip_vpu_ctx *ctx =
container_of(filp->private_data, struct rockchip_vpu_ctx, fh);
/*
* No need for extra locking because this was the last reference
* to this file.
*/
v4l2_m2m_ctx_release(ctx->fh.m2m_ctx);
v4l2_fh_del(&ctx->fh);
v4l2_fh_exit(&ctx->fh);
v4l2_ctrl_handler_free(&ctx->ctrl_handler);
kfree(ctx);
return 0;
}
/*
* msm_jpegdma_release - Fd device release method.
* @file: Pointer to file struct.
*/
static int msm_jpegdma_release(struct file *file)
{
struct jpegdma_ctx *ctx = msm_jpegdma_ctx_from_fh(file->private_data);
atomic_set(&ctx->active, 0);
complete_all(&ctx->completion);
v4l2_m2m_ctx_release(ctx->m2m_ctx);
v4l2_fh_del(&ctx->fh);
v4l2_fh_exit(&ctx->fh);
kfree(ctx);
if (cam_config_ahb_clk(CAM_AHB_CLIENT_JPEG,
CAMERA_AHB_SUSPEND_VOTE) < 0)
pr_err("%s: failed to remove vote for AHB\n", __func__);
return 0;
}
static int gsc_m2m_release(struct file *file)
{
struct gsc_ctx *ctx = fh_to_ctx(file->private_data);
struct gsc_dev *gsc = ctx->gsc_dev;
gsc_dbg("pid: %d, state: 0x%lx, refcnt= %d",
task_pid_nr(current), gsc->state, gsc->m2m.refcnt);
v4l2_m2m_ctx_release(ctx->m2m_ctx);
gsc_ctrls_delete(ctx);
v4l2_fh_del(&ctx->fh);
v4l2_fh_exit(&ctx->fh);
if (--gsc->m2m.refcnt <= 0)
clear_bit(ST_M2M_OPEN, &gsc->state);
kfree(ctx);
return 0;
}
static int fimc_m2m_release(struct file *file)
{
struct fimc_ctx *ctx = fh_to_ctx(file->private_data);
struct fimc_dev *fimc = ctx->fimc_dev;
dbg("pid: %d, state: 0x%lx, refcnt= %d",
task_pid_nr(current), fimc->state, fimc->m2m.refcnt);
mutex_lock(&fimc->lock);
v4l2_m2m_ctx_release(ctx->m2m_ctx);
fimc_ctrls_delete(ctx);
v4l2_fh_del(&ctx->fh);
v4l2_fh_exit(&ctx->fh);
if (--fimc->m2m.refcnt <= 0)
clear_bit(ST_M2M_RUN, &fimc->state);
kfree(ctx);
mutex_unlock(&fimc->lock);
return 0;
}
static int hva_release(struct file *file)
{
struct hva_ctx *ctx = fh_to_ctx(file->private_data);
struct hva_dev *hva = ctx_to_hdev(ctx);
struct device *dev = ctx_to_dev(ctx);
const struct hva_enc *enc = ctx->enc;
if (enc) {
dev_dbg(dev, "%s %s encoder closed\n", ctx->name, enc->name);
enc->close(ctx);
ctx->enc = NULL;
/* clear instance context in instances array */
hva->instances[ctx->id] = NULL;
hva->nb_of_instances--;
}
/* trace a summary of instance before closing (debug purpose) */
hva_dbg_summary(ctx);
v4l2_m2m_ctx_release(ctx->fh.m2m_ctx);
v4l2_ctrl_handler_free(&ctx->ctrl_handler);
v4l2_fh_del(&ctx->fh);
v4l2_fh_exit(&ctx->fh);
#ifdef CONFIG_VIDEO_STI_HVA_DEBUGFS
hva_dbg_ctx_remove(ctx);
#endif
dev_info(dev, "%s encoder instance released\n", ctx->name);
kfree(ctx);
return 0;
}
static int fimc_m2m_open(struct file *file)
{
struct fimc_dev *fimc = video_drvdata(file);
struct fimc_ctx *ctx;
int ret = -EBUSY;
pr_debug("pid: %d, state: %#lx\n", task_pid_nr(current), fimc->state);
if (mutex_lock_interruptible(&fimc->lock))
return -ERESTARTSYS;
/*
* Don't allow simultaneous open() of the mem-to-mem and the
* capture video node that belong to same FIMC IP instance.
*/
if (test_bit(ST_CAPT_BUSY, &fimc->state))
goto unlock;
ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
if (!ctx) {
ret = -ENOMEM;
goto unlock;
}
v4l2_fh_init(&ctx->fh, &fimc->m2m.vfd);
ctx->fimc_dev = fimc;
/* Default color format */
ctx->s_frame.fmt = fimc_get_format(0);
ctx->d_frame.fmt = fimc_get_format(0);
ret = fimc_ctrls_create(ctx);
if (ret)
goto error_fh;
/* Use separate control handler per file handle */
ctx->fh.ctrl_handler = &ctx->ctrls.handler;
file->private_data = &ctx->fh;
v4l2_fh_add(&ctx->fh);
/* Setup the device context for memory-to-memory mode */
ctx->state = FIMC_CTX_M2M;
ctx->flags = 0;
ctx->in_path = FIMC_IO_DMA;
ctx->out_path = FIMC_IO_DMA;
ctx->scaler.enabled = 1;
ctx->m2m_ctx = v4l2_m2m_ctx_init(fimc->m2m.m2m_dev, ctx, queue_init);
if (IS_ERR(ctx->m2m_ctx)) {
ret = PTR_ERR(ctx->m2m_ctx);
goto error_c;
}
if (fimc->m2m.refcnt++ == 0)
set_bit(ST_M2M_RUN, &fimc->state);
ret = fimc_m2m_set_default_format(ctx);
if (ret < 0)
goto error_m2m_ctx;
mutex_unlock(&fimc->lock);
return 0;
error_m2m_ctx:
v4l2_m2m_ctx_release(ctx->m2m_ctx);
error_c:
fimc_ctrls_delete(ctx);
error_fh:
v4l2_fh_del(&ctx->fh);
v4l2_fh_exit(&ctx->fh);
kfree(ctx);
unlock:
mutex_unlock(&fimc->lock);
return ret;
}
