static int jpeg_m2m_open(struct file *file) { struct jpeg_dev *dev = video_drvdata(file); struct jpeg_ctx *ctx = NULL; int ret = 0; enum jpeg_node_type node; node = jpeg_get_node_type(file); if (node == JPEG_NODE_INVALID) { jpeg_err("cannot specify node type\n"); ret = -ENOENT; goto err_node_type; } ctx = kzalloc(sizeof *ctx, GFP_KERNEL); if (!ctx) return -ENOMEM; file->private_data = ctx; ctx->dev = dev; spin_lock_init(&ctx->slock); if (node == JPEG_NODE_DECODER) ctx->m2m_ctx = v4l2_m2m_ctx_init(dev->m2m_dev_dec, ctx, queue_init_dec); else ctx->m2m_ctx = v4l2_m2m_ctx_init(dev->m2m_dev_enc, ctx, queue_init_enc); if (IS_ERR(ctx->m2m_ctx)) { int err = PTR_ERR(ctx->m2m_ctx); kfree(ctx); return err; } clk_enable(dev->clk); #ifdef CONFIG_PM_RUNTIME #if defined (CONFIG_CPU_EXYNOS5250) dev->vb2->resume(dev->alloc_ctx); #ifdef CONFIG_BUSFREQ_OPP /* lock bus frequency */ dev_lock(dev->bus_dev, &dev->plat_dev->dev, BUSFREQ_400MHZ); #endif #else pm_runtime_get_sync(&dev->plat_dev->dev); #endif #endif return 0; err_node_type: kfree(ctx); return ret; }
static int jpeg_m2m_open(struct file *file) { struct jpeg_dev *dev = video_drvdata(file); struct jpeg_ctx *ctx = NULL; int ret = 0; enum jpeg_node_type node; node = jpeg_get_node_type(file); if (node == JPEG_NODE_INVALID) { jpeg_err("cannot specify node type\n"); ret = -ENOENT; goto err_node_type; } ctx = kzalloc(sizeof *ctx, GFP_KERNEL); if (!ctx) return -ENOMEM; file->private_data = ctx; ctx->dev = dev; if (node == JPEG_NODE_DECODER) ctx->m2m_ctx = v4l2_m2m_ctx_init(dev->m2m_dev_dec, ctx, queue_init_dec); else ctx->m2m_ctx = v4l2_m2m_ctx_init(dev->m2m_dev_enc, ctx, queue_init_enc); if (IS_ERR(ctx->m2m_ctx)) { int err = PTR_ERR(ctx->m2m_ctx); kfree(ctx); return err; } clk_enable(dev->clk); #ifdef CONFIG_PM_RUNTIME pm_runtime_get_sync(&dev->plat_dev->dev); #endif return 0; err_node_type: kfree(ctx); return ret; }
static int g2d_open(struct file *file) { struct g2d_dev *dev = video_drvdata(file); struct g2d_ctx *ctx = NULL; int ret = 0; ctx = kzalloc(sizeof(*ctx), GFP_KERNEL); if (!ctx) return -ENOMEM; ctx->dev = dev; /* Set default formats */ ctx->in = def_frame; ctx->out = def_frame; ctx->m2m_ctx = v4l2_m2m_ctx_init(dev->m2m_dev, ctx, &queue_init); if (IS_ERR(ctx->m2m_ctx)) { ret = PTR_ERR(ctx->m2m_ctx); kfree(ctx); return ret; } v4l2_fh_init(&ctx->fh, video_devdata(file)); file->private_data = &ctx->fh; v4l2_fh_add(&ctx->fh); g2d_setup_ctrls(ctx); /* Write the default values to the ctx struct */ v4l2_ctrl_handler_setup(&ctx->ctrl_handler); ctx->fh.ctrl_handler = &ctx->ctrl_handler; v4l2_info(&dev->v4l2_dev, "instance opened\n"); return 0; }
static int rot_open(struct file *file) { struct rot_dev *rot = video_drvdata(file); struct rot_ctx *ctx = NULL; ctx = kzalloc(sizeof *ctx, GFP_KERNEL); if (!ctx) { rot_err("no memory for open context\n"); return -ENOMEM; } atomic_inc(&rot->m2m.in_use); file->private_data = ctx; ctx->rot_dev = rot; /* Default color format */ ctx->s_frame.rot_fmt = &rot_formats[0]; ctx->d_frame.rot_fmt = &rot_formats[0]; spin_lock_init(&ctx->slock); /* Setup the device context for mem2mem mode. */ ctx->m2m_ctx = v4l2_m2m_ctx_init(rot->m2m.m2m_dev, ctx, queue_init); if (IS_ERR(ctx->m2m_ctx)) { kfree(ctx); atomic_dec(&rot->m2m.in_use); return PTR_ERR(ctx->m2m_ctx); } return 0; }
int register_nxp_video(struct nxp_video *me) { int ret; me->vdev.v4l2_dev = me->v4l2_dev; pr_debug("%s: entered\n", __func__); ret = video_register_device(&me->vdev, VFL_TYPE_GRABBER, -1); if (ret < 0) { pr_err("%s: failed to video_register_device()\n", __func__); return ret; } #if 0 if (me->m2m_dev) { me->m2m_ctx = v4l2_m2m_ctx_init(me->m2m_dev, me, m2m_queue_init); if (IS_ERR(me->m2m_ctx)) { pr_err("%s: failed to v4l2_m2m_ctx_init()\n", __func__); video_unregister_device(&me->vdev); return -EINVAL; } } #endif pr_debug("%s: success!!!\n", __func__); return 0; }
/* * v4l2_file_operations */ static int nxp_video_open(struct file *file) { struct nxp_video *me = video_drvdata(file); u32 pad; struct v4l2_subdev *sd; int ret = 0; pr_debug("%s entered : %s\n", __func__, me->name); if (me->open_count == 0) { memset(me->frame, 0, sizeof(struct nxp_video_frame)*2); 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, 1); if (me->m2m_dev) { me->m2m_ctx = v4l2_m2m_ctx_init(me->m2m_dev, me, m2m_queue_init); if (IS_ERR(me->m2m_ctx)) { pr_err("%s: failed to v4l2_m2m_ctx_init()\n", __func__); return -EINVAL; } } } me->open_count++; file->private_data = me; pr_debug("%s exit\n", __func__); return ret; }
static int gsc_m2m_open(struct file *file) { struct gsc_dev *gsc = video_drvdata(file); struct gsc_ctx *ctx = NULL; int ret; gsc_dbg("pid: %d, state: 0x%lx", task_pid_nr(current), gsc->state); if (gsc_out_opened(gsc) || gsc_cap_opened(gsc)) return -EBUSY; ctx = kzalloc(sizeof *ctx, GFP_KERNEL); if (!ctx) return -ENOMEM; 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; spin_lock_init(&ctx->slock); INIT_LIST_HEAD(&ctx->fence_wait_list); INIT_WORK(&ctx->fence_work, gsc_m2m_fence_work); ctx->m2m_ctx = v4l2_m2m_ctx_init(gsc->m2m.m2m_dev, ctx, queue_init); if (IS_ERR(ctx->m2m_ctx)) { gsc_err("Failed to initialize m2m context"); ret = PTR_ERR(ctx->m2m_ctx); goto error_fh; } if (gsc->m2m.refcnt++ == 0) set_bit(ST_M2M_OPEN, &gsc->state); gsc_dbg("gsc m2m driver is opened, ctx(0x%p)", ctx); return 0; error_fh: v4l2_fh_del(&ctx->fh); v4l2_fh_exit(&ctx->fh); kfree(ctx); return ret; }
static int rockchip_vpu_open(struct file *filp) { struct rockchip_vpu_dev *vpu = video_drvdata(filp); struct video_device *vdev = video_devdata(filp); struct rockchip_vpu_ctx *ctx; int ret; /* * We do not need any extra locking here, because we operate only * on local data here, except reading few fields from dev, which * do not change through device's lifetime (which is guaranteed by * reference on module from open()) and V4L2 internal objects (such * as vdev and ctx->fh), which have proper locking done in respective * helper functions used here. */ ctx = kzalloc(sizeof(*ctx), GFP_KERNEL); if (!ctx) return -ENOMEM; ctx->dev = vpu; if (vdev == vpu->vfd_enc) ctx->fh.m2m_ctx = v4l2_m2m_ctx_init(vpu->m2m_dev, ctx, &enc_queue_init); else ctx->fh.m2m_ctx = ERR_PTR(-ENODEV); if (IS_ERR(ctx->fh.m2m_ctx)) { ret = PTR_ERR(ctx->fh.m2m_ctx); kfree(ctx); return ret; } v4l2_fh_init(&ctx->fh, vdev); filp->private_data = &ctx->fh; v4l2_fh_add(&ctx->fh); if (vdev == vpu->vfd_enc) { rockchip_vpu_enc_reset_dst_fmt(vpu, ctx); rockchip_vpu_enc_reset_src_fmt(vpu, ctx); } ret = rockchip_vpu_ctrls_setup(vpu, ctx); if (ret) { vpu_err("Failed to set up controls\n"); goto err_fh_free; } ctx->fh.ctrl_handler = &ctx->ctrl_handler; return 0; err_fh_free: v4l2_fh_del(&ctx->fh); v4l2_fh_exit(&ctx->fh); kfree(ctx); return ret; }
static int s5p_jpeg_open(struct file *file) { struct s5p_jpeg *jpeg = video_drvdata(file); struct video_device *vfd = video_devdata(file); struct s5p_jpeg_ctx *ctx; struct s5p_jpeg_fmt *out_fmt; int ret = 0; ctx = kzalloc(sizeof(*ctx), GFP_KERNEL); if (!ctx) return -ENOMEM; if (mutex_lock_interruptible(&jpeg->lock)) { ret = -ERESTARTSYS; goto free; } v4l2_fh_init(&ctx->fh, vfd); /* 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->jpeg = jpeg; if (vfd == jpeg->vfd_encoder) { ctx->mode = S5P_JPEG_ENCODE; out_fmt = s5p_jpeg_find_format(ctx->mode, V4L2_PIX_FMT_RGB565); } else { ctx->mode = S5P_JPEG_DECODE; out_fmt = s5p_jpeg_find_format(ctx->mode, V4L2_PIX_FMT_JPEG); } ret = s5p_jpeg_controls_create(ctx); if (ret < 0) goto error; ctx->m2m_ctx = v4l2_m2m_ctx_init(jpeg->m2m_dev, ctx, queue_init); if (IS_ERR(ctx->m2m_ctx)) { ret = PTR_ERR(ctx->m2m_ctx); goto error; } ctx->out_q.fmt = out_fmt; ctx->cap_q.fmt = s5p_jpeg_find_format(ctx->mode, V4L2_PIX_FMT_YUYV); mutex_unlock(&jpeg->lock); return 0; error: v4l2_fh_del(&ctx->fh); v4l2_fh_exit(&ctx->fh); mutex_unlock(&jpeg->lock); free: kfree(ctx); return ret; }
/* * msm_jpegdma_open - Fd device open method. * @file: Pointer to file struct. */ static int msm_jpegdma_open(struct file *file) { struct msm_jpegdma_device *device = video_drvdata(file); struct video_device *video = video_devdata(file); struct jpegdma_ctx *ctx; int ret; ctx = kzalloc(sizeof(*ctx), GFP_KERNEL); if (!ctx) return -ENOMEM; mutex_init(&ctx->lock); ctx->jdma_device = device; dev_dbg(ctx->jdma_device->dev, "Jpeg v4l2 dma open\n"); /* Set ctx defaults */ ctx->timeperframe.numerator = 1; ctx->timeperframe.denominator = MSM_JPEGDMA_DEFAULT_FPS; atomic_set(&ctx->active, 0); v4l2_fh_init(&ctx->fh, video); file->private_data = &ctx->fh; v4l2_fh_add(&ctx->fh); ctx->m2m_ctx = v4l2_m2m_ctx_init(device->m2m_dev, ctx, msm_jpegdma_queue_init); if (IS_ERR_OR_NULL(ctx->m2m_ctx)) { ret = PTR_ERR(ctx->m2m_ctx); goto error_m2m_init; } init_completion(&ctx->completion); complete_all(&ctx->completion); dev_dbg(ctx->jdma_device->dev, "Jpeg v4l2 dma open success\n"); ret = cam_config_ahb_clk(CAM_AHB_CLIENT_JPEG, CAMERA_AHB_SVS_VOTE); if (ret < 0) { pr_err("%s: failed to vote for AHB\n", __func__); goto error_m2m_init; } return 0; error_m2m_init: v4l2_fh_del(&ctx->fh); v4l2_fh_exit(&ctx->fh); kfree(ctx); return ret; }
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; }
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; }
static int bdisp_open(struct file *file) { struct bdisp_dev *bdisp = video_drvdata(file); struct bdisp_ctx *ctx = NULL; int ret; if (mutex_lock_interruptible(&bdisp->lock)) return -ERESTARTSYS; /* Allocate memory for both context and node */ ctx = kzalloc(sizeof(*ctx), GFP_KERNEL); if (!ctx) { ret = -ENOMEM; goto unlock; } ctx->bdisp_dev = bdisp; if (bdisp_hw_alloc_nodes(ctx)) { dev_err(bdisp->dev, "no memory for nodes\n"); ret = -ENOMEM; goto mem_ctx; } v4l2_fh_init(&ctx->fh, bdisp->m2m.vdev); ret = bdisp_ctrls_create(ctx); if (ret) { dev_err(bdisp->dev, "Failed to create control\n"); 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); /* Default format */ ctx->src = bdisp_dflt_fmt; ctx->dst = bdisp_dflt_fmt; /* Setup the device context for mem2mem mode. */ ctx->fh.m2m_ctx = v4l2_m2m_ctx_init(bdisp->m2m.m2m_dev, ctx, queue_init); if (IS_ERR(ctx->fh.m2m_ctx)) { dev_err(bdisp->dev, "Failed to initialize m2m context\n"); ret = PTR_ERR(ctx->fh.m2m_ctx); goto error_ctrls; } bdisp->m2m.refcnt++; set_bit(ST_M2M_OPEN, &bdisp->state); dev_dbg(bdisp->dev, "driver opened, ctx = 0x%p\n", ctx); mutex_unlock(&bdisp->lock); return 0; error_ctrls: bdisp_ctrls_delete(ctx); error_fh: v4l2_fh_del(&ctx->fh); v4l2_fh_exit(&ctx->fh); bdisp_hw_free_nodes(ctx); mem_ctx: kfree(ctx); unlock: mutex_unlock(&bdisp->lock); return ret; }
static int fimc_m2m_open(struct file *file) { struct fimc_dev *fimc = video_drvdata(file); struct fimc_ctx *ctx; int ret = -EBUSY; dbg("pid: %d, state: 0x%lx, refcnt: %d", task_pid_nr(current), fimc->state, fimc->vid_cap.refcnt); if (mutex_lock_interruptible(&fimc->lock)) return -ERESTARTSYS; /* * Return if the corresponding video capture node * is already opened. */ if (fimc->vid_cap.refcnt > 0) 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->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); mutex_unlock(&fimc->lock); return 0; 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; }
static int hva_open(struct file *file) { struct hva_dev *hva = video_drvdata(file); struct device *dev = hva_to_dev(hva); struct hva_ctx *ctx; int ret; ctx = kzalloc(sizeof(*ctx), GFP_KERNEL); if (!ctx) { ret = -ENOMEM; goto out; } ctx->hva_dev = hva; INIT_WORK(&ctx->run_work, hva_run_work); v4l2_fh_init(&ctx->fh, video_devdata(file)); file->private_data = &ctx->fh; v4l2_fh_add(&ctx->fh); ret = hva_ctrls_setup(ctx); if (ret) { dev_err(dev, "%s [x:x] failed to setup controls\n", HVA_PREFIX); goto err_fh; } ctx->fh.ctrl_handler = &ctx->ctrl_handler; mutex_init(&ctx->lock); ctx->fh.m2m_ctx = v4l2_m2m_ctx_init(hva->m2m_dev, ctx, &hva_queue_init); if (IS_ERR(ctx->fh.m2m_ctx)) { ret = PTR_ERR(ctx->fh.m2m_ctx); dev_err(dev, "%s failed to initialize m2m context (%d)\n", HVA_PREFIX, ret); goto err_ctrls; } /* set the instance name */ mutex_lock(&hva->lock); hva->instance_id++; snprintf(ctx->name, sizeof(ctx->name), "[%3d:----]", hva->instance_id); mutex_unlock(&hva->lock); /* default parameters for frame and stream */ set_default_params(ctx); dev_info(dev, "%s encoder instance created\n", ctx->name); return 0; err_ctrls: v4l2_ctrl_handler_free(&ctx->ctrl_handler); err_fh: v4l2_fh_del(&ctx->fh); v4l2_fh_exit(&ctx->fh); kfree(ctx); out: return ret; }