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