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