static int solo_v4l2_open(struct file *file) { struct solo6010_dev *solo_dev = video_drvdata(file); struct solo_filehandle *fh; int ret; if ((fh = kzalloc(sizeof(*fh), GFP_KERNEL)) == NULL) return -ENOMEM; spin_lock_init(&fh->slock); INIT_LIST_HEAD(&fh->vidq_active); fh->solo_dev = solo_dev; file->private_data = fh; if ((ret = solo_start_thread(fh))) { kfree(fh); return ret; } videobuf_queue_dma_contig_init(&fh->vidq, &solo_video_qops, &solo_dev->pdev->dev, &fh->slock, V4L2_BUF_TYPE_VIDEO_CAPTURE, SOLO_DISP_PIX_FIELD, sizeof(struct videobuf_buffer), fh); return 0; }
static int vpif_reqbufs(struct file *file, void *priv, struct v4l2_requestbuffers *reqbuf) { struct vpif_fh *fh = priv; struct channel_obj *ch = fh->channel; struct common_obj *common; enum v4l2_field field; u8 index = 0; /* This file handle has not initialized the channel, It is not allowed to do settings */ if ((VPIF_CHANNEL2_VIDEO == ch->channel_id) || (VPIF_CHANNEL3_VIDEO == ch->channel_id)) { if (!fh->initialized) { vpif_err("Channel Busy\n"); return -EBUSY; } } if (V4L2_BUF_TYPE_VIDEO_OUTPUT != reqbuf->type) return -EINVAL; index = VPIF_VIDEO_INDEX; common = &ch->common[index]; if (common->fmt.type != reqbuf->type) return -EINVAL; if (0 != common->io_usrs) return -EBUSY; if (reqbuf->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) { if (common->fmt.fmt.pix.field == V4L2_FIELD_ANY) field = V4L2_FIELD_INTERLACED; else field = common->fmt.fmt.pix.field; } else { field = V4L2_VBI_INTERLACED; } /* Initialize videobuf queue as per the buffer type */ videobuf_queue_dma_contig_init(&common->buffer_queue, &video_qops, NULL, &common->irqlock, reqbuf->type, field, sizeof(struct videobuf_buffer), fh, &common->lock); /* Set io allowed member of file handle to TRUE */ fh->io_allowed[index] = 1; /* Increment io usrs member of channel object to 1 */ common->io_usrs = 1; /* Store type of memory requested in channel object */ common->memory = reqbuf->memory; INIT_LIST_HEAD(&common->dma_queue); /* Allocate buffers */ return videobuf_reqbufs(&common->buffer_queue, reqbuf); }
static void omap1_cam_init_videobuf(struct videobuf_queue *q, struct soc_camera_device *icd) { struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent); struct omap1_cam_dev *pcdev = ici->priv; if (!sg_mode) videobuf_queue_dma_contig_init(q, &omap1_videobuf_ops, icd->dev.parent, &pcdev->lock, V4L2_BUF_TYPE_VIDEO_CAPTURE, V4L2_FIELD_NONE, sizeof(struct omap1_cam_buf), icd, &icd->video_lock); else videobuf_queue_sg_init(q, &omap1_videobuf_ops, icd->dev.parent, &pcdev->lock, V4L2_BUF_TYPE_VIDEO_CAPTURE, V4L2_FIELD_NONE, sizeof(struct omap1_cam_buf), icd, &icd->video_lock); /* use videobuf mode (auto)selected with the module parameter */ pcdev->vb_mode = sg_mode ? OMAP1_CAM_DMA_SG : OMAP1_CAM_DMA_CONTIG; /* * Ensure we substitute the videobuf-dma-contig version of the * mmap_mapper() callback with our own wrapper, used for switching * automatically to videobuf-dma-sg on buffer allocation failure. */ if (!sg_mode && q->int_ops->mmap_mapper != omap1_cam_mmap_mapper) { pcdev->mmap_mapper = q->int_ops->mmap_mapper; q->int_ops->mmap_mapper = omap1_cam_mmap_mapper; } }
static void mx2_camera_init_videobuf(struct videobuf_queue *q, struct soc_camera_device *icd) { struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent); struct mx2_camera_dev *pcdev = ici->priv; videobuf_queue_dma_contig_init(q, &mx2_videobuf_ops, pcdev->dev, &pcdev->lock, V4L2_BUF_TYPE_VIDEO_CAPTURE, V4L2_FIELD_NONE, sizeof(struct mx2_buffer), icd, NULL); }
static int solo_v4l2_open(struct inode *ino, struct file *file) #endif { struct solo_dev *solo_dev = video_drvdata(file); struct solo_filehandle *fh; int ret; fh = kzalloc(sizeof(*fh), GFP_KERNEL); if (fh == NULL) return -ENOMEM; spin_lock_init(&fh->slock); INIT_LIST_HEAD(&fh->vidq_active); fh->solo_dev = solo_dev; file->private_data = fh; ret = solo_start_thread(fh); if (ret) { kfree(fh); return ret; } #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 37) videobuf_queue_dma_contig_init(&fh->vidq, &solo_video_qops, &solo_dev->pdev->dev, &fh->slock, V4L2_BUF_TYPE_VIDEO_CAPTURE, SOLO_DISP_PIX_FIELD, sizeof(struct videobuf_buffer), fh, NULL); #else videobuf_queue_dma_contig_init(&fh->vidq, &solo_video_qops, &solo_dev->pdev->dev, &fh->slock, V4L2_BUF_TYPE_VIDEO_CAPTURE, SOLO_DISP_PIX_FIELD, sizeof(struct videobuf_buffer), fh); #endif return 0; }
/** * @brief: register video buffer by video sub-system * * @author: caolianming * @date: 2014-01-06 * @param [in] *icd: soc_camera_device information structure, * akcamera depends on the soc driver. * @param [in] *q: V4L2 buffer queue information structure */ static void ak_camera_init_videobuf(struct videobuf_queue *q, struct soc_camera_device *icd) { struct soc_camera_host *ici = to_soc_camera_host(icd->parent); struct ak_camera_dev *pcdev = ici->priv; CAMDBG("entry %s\n", __func__); videobuf_queue_dma_contig_init(q, &ak_videobuf_ops, icd->parent, &pcdev->lock, V4L2_BUF_TYPE_VIDEO_CAPTURE, V4L2_FIELD_NONE, sizeof(struct ak_buffer), icd, &icd->video_lock); CAMDBG("leave %s\n", __func__); }
static void sh_mobile_ceu_init_videobuf(struct videobuf_queue *q, struct soc_camera_device *icd) { struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent); struct sh_mobile_ceu_dev *pcdev = ici->priv; videobuf_queue_dma_contig_init(q, &sh_mobile_ceu_videobuf_ops, icd->dev.parent, &pcdev->lock, V4L2_BUF_TYPE_VIDEO_CAPTURE, pcdev->is_interlaced ? V4L2_FIELD_INTERLACED : V4L2_FIELD_NONE, sizeof(struct sh_mobile_ceu_buffer), icd); }
static int vpif_reqbufs(struct file *file, void *priv, struct v4l2_requestbuffers *reqbuf) { struct vpif_fh *fh = priv; struct channel_obj *ch = fh->channel; struct common_obj *common; u8 index = 0; vpif_dbg(2, debug, "vpif_reqbufs\n"); if ((VPIF_CHANNEL0_VIDEO == ch->channel_id) || (VPIF_CHANNEL1_VIDEO == ch->channel_id)) { if (!fh->initialized) { vpif_dbg(1, debug, "Channel Busy\n"); return -EBUSY; } } if (V4L2_BUF_TYPE_VIDEO_CAPTURE != reqbuf->type) return -EINVAL; index = VPIF_VIDEO_INDEX; common = &ch->common[index]; if (0 != common->io_usrs) return -EBUSY; videobuf_queue_dma_contig_init(&common->buffer_queue, &video_qops, NULL, &common->irqlock, reqbuf->type, common->fmt.fmt.pix.field, sizeof(struct videobuf_buffer), fh, &common->lock); fh->io_allowed[index] = 1; common->io_usrs = 1; common->memory = reqbuf->memory; INIT_LIST_HEAD(&common->dma_queue); return videobuf_reqbufs(&common->buffer_queue, reqbuf); }
/** * vpif_reqbufs() - request buffer handler * @file: file ptr * @priv: file handle * @reqbuf: request buffer structure ptr */ static int vpif_reqbufs(struct file *file, void *priv, struct v4l2_requestbuffers *reqbuf) { struct vpif_fh *fh = priv; struct channel_obj *ch = fh->channel; struct common_obj *common; u8 index = 0; int ret = 0; vpif_dbg(2, debug, "vpif_reqbufs\n"); /** * This file handle has not initialized the channel, * It is not allowed to do settings */ if ((VPIF_CHANNEL0_VIDEO == ch->channel_id) || (VPIF_CHANNEL1_VIDEO == ch->channel_id)) { if (!fh->initialized) { vpif_dbg(1, debug, "Channel Busy\n"); return -EBUSY; } } if (V4L2_BUF_TYPE_VIDEO_CAPTURE != reqbuf->type) return -EINVAL; index = VPIF_VIDEO_INDEX; common = &ch->common[index]; if (mutex_lock_interruptible(&common->lock)) return -ERESTARTSYS; if (0 != common->io_usrs) { ret = -EBUSY; goto reqbuf_exit; } /* Initialize videobuf queue as per the buffer type */ videobuf_queue_dma_contig_init(&common->buffer_queue, &video_qops, NULL, &common->irqlock, reqbuf->type, common->fmt.fmt.pix.field, sizeof(struct videobuf_buffer), fh); /* Set io allowed member of file handle to TRUE */ fh->io_allowed[index] = 1; /* Increment io usrs member of channel object to 1 */ common->io_usrs = 1; /* Store type of memory requested in channel object */ common->memory = reqbuf->memory; INIT_LIST_HEAD(&common->dma_queue); /* Allocate buffers */ ret = videobuf_reqbufs(&common->buffer_queue, reqbuf); reqbuf_exit: mutex_unlock(&common->lock); return ret; }
int fimc_register_capture_device(struct fimc_dev *fimc) { struct v4l2_device *v4l2_dev = &fimc->vid_cap.v4l2_dev; struct video_device *vfd; struct fimc_vid_cap *vid_cap; struct fimc_ctx *ctx; struct v4l2_format f; int ret; ctx = kzalloc(sizeof *ctx, GFP_KERNEL); if (!ctx) return -ENOMEM; ctx->fimc_dev = fimc; ctx->in_path = FIMC_CAMERA; ctx->out_path = FIMC_DMA; ctx->state = FIMC_CTX_CAP; f.fmt.pix.pixelformat = V4L2_PIX_FMT_RGB24; ctx->d_frame.fmt = find_format(&f, FMT_FLAGS_M2M); if (!v4l2_dev->name[0]) snprintf(v4l2_dev->name, sizeof(v4l2_dev->name), "%s.capture", dev_name(&fimc->pdev->dev)); ret = v4l2_device_register(NULL, v4l2_dev); if (ret) goto err_info; vfd = video_device_alloc(); if (!vfd) { v4l2_err(v4l2_dev, "Failed to allocate video device\n"); goto err_v4l2_reg; } snprintf(vfd->name, sizeof(vfd->name), "%s:cap", dev_name(&fimc->pdev->dev)); vfd->fops = &fimc_capture_fops; vfd->ioctl_ops = &fimc_capture_ioctl_ops; vfd->minor = -1; vfd->release = video_device_release; video_set_drvdata(vfd, fimc); vid_cap = &fimc->vid_cap; vid_cap->vfd = vfd; vid_cap->active_buf_cnt = 0; vid_cap->reqbufs_count = 0; vid_cap->refcnt = 0; /* The default color format for image sensor. */ vid_cap->fmt.code = V4L2_MBUS_FMT_YUYV8_2X8; INIT_LIST_HEAD(&vid_cap->pending_buf_q); INIT_LIST_HEAD(&vid_cap->active_buf_q); spin_lock_init(&ctx->slock); vid_cap->ctx = ctx; videobuf_queue_dma_contig_init(&vid_cap->vbq, &fimc_qops, vid_cap->v4l2_dev.dev, &fimc->irqlock, V4L2_BUF_TYPE_VIDEO_CAPTURE, V4L2_FIELD_NONE, sizeof(struct fimc_vid_buffer), (void *)ctx); ret = video_register_device(vfd, VFL_TYPE_GRABBER, -1); if (ret) { v4l2_err(v4l2_dev, "Failed to register video device\n"); goto err_vd_reg; } v4l2_info(v4l2_dev, "FIMC capture driver registered as /dev/video%d\n", vfd->num); return 0; err_vd_reg: video_device_release(vfd); err_v4l2_reg: v4l2_device_unregister(v4l2_dev); err_info: dev_err(&fimc->pdev->dev, "failed to install\n"); return ret; }