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; }
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 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 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 gsc_m2m_open(struct file *file) { struct gsc_dev *gsc = video_drvdata(file); struct gsc_ctx *ctx = NULL; int ret; pr_debug("pid: %d, state: 0x%lx", task_pid_nr(current), gsc->state); if (mutex_lock_interruptible(&gsc->lock)) return -ERESTARTSYS; ctx = kzalloc(sizeof(*ctx), GFP_KERNEL); if (!ctx) { ret = -ENOMEM; goto unlock; } v4l2_fh_init(&ctx->fh, gsc->m2m.vfd); ret = gsc_ctrls_create(ctx); if (ret) goto error_fh; /* Use separate control handler per file handle */ ctx->fh.ctrl_handler = &ctx->ctrl_handler; file->private_data = &ctx->fh; v4l2_fh_add(&ctx->fh); ctx->gsc_dev = gsc; /* Default color format */ ctx->s_frame.fmt = get_format(0); ctx->d_frame.fmt = get_format(0); /* Setup the device context for mem2mem mode. */ ctx->state = GSC_CTX_M2M; ctx->flags = 0; ctx->in_path = GSC_DMA; ctx->out_path = GSC_DMA; ctx->m2m_ctx = v4l2_m2m_ctx_init(gsc->m2m.m2m_dev, ctx, queue_init); if (IS_ERR(ctx->m2m_ctx)) { pr_err("Failed to initialize m2m context"); ret = PTR_ERR(ctx->m2m_ctx); goto error_ctrls; } if (gsc->m2m.refcnt++ == 0) set_bit(ST_M2M_OPEN, &gsc->state); pr_debug("gsc m2m driver is opened, ctx(0x%p)", ctx); mutex_unlock(&gsc->lock); return 0; error_ctrls: gsc_ctrls_delete(ctx); v4l2_fh_del(&ctx->fh); error_fh: v4l2_fh_exit(&ctx->fh); kfree(ctx); unlock: mutex_unlock(&gsc->lock); return ret; }