Hi Hans,
Thanks for the review.
On Fri, Sep 14, 2012 at 7:00 PM, Hans Verkuil <hverkuil@xxxxxxxxx> wrote:
> On Fri 14 September 2012 14:46:36 Prabhakar Lad wrote:
>> From: Manjunath Hadli <manjunath.hadli@xxxxxx>
>>
>> add a generic video driver functionality to be used by all the vpfe
>> drivers for davinci SoCs. The functionality includes all the
>> standard v4l2 interfaces including streaming. The video node
>> interface can be used both as an input and output node for both
>> continuous and single shot modes.Also supports dv_presets to include
>> HD modes, wth support for both user pointer IO and mmap.
>>
>> Signed-off-by: Manjunath Hadli <manjunath.hadli@xxxxxx>
>> Signed-off-by: Lad, Prabhakar <prabhakar.lad@xxxxxx>
>> ---
>> drivers/media/platform/davinci/vpfe_video.c | 1725 +++++++++++++++++++++++++++
>> drivers/media/platform/davinci/vpfe_video.h | 150 +++
>> 2 files changed, 1875 insertions(+), 0 deletions(-)
>> create mode 100644 drivers/media/platform/davinci/vpfe_video.c
>> create mode 100644 drivers/media/platform/davinci/vpfe_video.h
>>
>> diff --git a/drivers/media/platform/davinci/vpfe_video.c b/drivers/media/platform/davinci/vpfe_video.c
>> new file mode 100644
>> index 0000000..2e696a0
>> --- /dev/null
>> +++ b/drivers/media/platform/davinci/vpfe_video.c
>> @@ -0,0 +1,1725 @@
>> +/*
>> + * Copyright (C) 2012 Texas Instruments Inc
>> + *
>> + * This program is free software; you can redistribute it and/or
>> + * modify it under the terms of the GNU General Public License as
>> + * published by the Free Software Foundation version 2.
>> + *
>> + * This program is distributed in the hope that it will be useful,
>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
>> + * GNU General Public License for more details.
>> + *
>> + * You should have received a copy of the GNU General Public License
>> + * along with this program; if not, write to the Free Software
>> + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
>> + *
>> + * Contributors:
>> + * Manjunath Hadli <manjunath.hadli@xxxxxx>
>> + * Prabhakar Lad <prabhakar.lad@xxxxxx>
>> + */
>> +
>> +#include <linux/slab.h>
>> +#include <linux/module.h>
>> +#include <linux/platform_device.h>
>> +
>> +#include <media/v4l2-common.h>
>> +#include <media/v4l2-mediabus.h>
>> +#include <media/media-entity.h>
>> +#include <media/media-device.h>
>> +#include <media/davinci/vpfe_types.h>
>> +
>> +#include <mach/cputype.h>
>> +
>> +#include "vpfe_mc_capture.h"
>> +#include "ccdc_hw_device.h"
>> +
>> +/* minimum number of buffers needed in cont-mode */
>> +#define CONT_MIN_NUM_BUFFERS 3
>> +
>> +static int debug;
>> +
>> +/* get v4l2 subdev pointer to external subdev which is active */
>> +static struct media_entity *vpfe_get_input_entity
>> + (struct vpfe_video_device *video)
>> +{
>> + struct vpfe_device *vpfe_dev = video->vpfe_dev;
>> + struct media_pad *remote;
>> +
>> + remote = media_entity_remote_source(&vpfe_dev->vpfe_ccdc.pads[0]);
>> + if (remote == NULL) {
>> + pr_err("Invalid media connection to ccdc\n");
>> + return NULL;
>> + }
>> +
>> + return remote->entity;
>> +}
>> +
>> +/* updates external subdev(sensor/decoder) which is active */
>> +static int vpfe_update_current_ext_subdev(struct vpfe_video_device *video)
>> +{
>> + struct vpfe_device *vpfe_dev = video->vpfe_dev;
>> + struct vpfe_config *vpfe_cfg;
>> + struct v4l2_subdev *subdev;
>> + struct media_pad *remote;
>> + int i;
>> +
>> + remote = media_entity_remote_source(&vpfe_dev->vpfe_ccdc.pads[0]);
>> + if (remote == NULL) {
>> + pr_err("Invalid media connection to ccdc\n");
>> + return -EINVAL;
>> + }
>> +
>> + subdev = media_entity_to_v4l2_subdev(remote->entity);
>> +
>> + vpfe_cfg = vpfe_dev->pdev->platform_data;
>> +
>> + for (i = 0; i < vpfe_cfg->num_subdevs; i++) {
>> + if (!strcmp(vpfe_cfg->sub_devs[i].module_name, subdev->name)) {
>> + video->current_ext_subdev = &vpfe_cfg->sub_devs[i];
>> + break;
>> + }
>> + }
>> +
>> + /* if user not linked decoder/sensor to ccdc */
>> + if (i == vpfe_cfg->num_subdevs) {
>> + pr_err("Invalid media chain connection to ccdc\n");
>> + return -EINVAL;
>> + }
>> +
>> + /* find the v4l2 subdev pointer */
>> + for (i = 0; i < vpfe_dev->num_ext_subdevs; i++) {
>> + if (!strcmp(video->current_ext_subdev->module_name,
>> + vpfe_dev->sd[i]->name))
>> + video->current_ext_subdev->subdev = vpfe_dev->sd[i];
>> + }
>> +
>> + return 0;
>> +}
>> +
>> +/* get the subdev which is connected to the output video node */
>> +static struct v4l2_subdev *
>> +vpfe_video_remote_subdev(struct vpfe_video_device *video, u32 *pad)
>> +{
>> + struct media_pad *remote;
>> +
>> + remote = media_entity_remote_source(&video->pad);
>> +
>> + if (remote == NULL || remote->entity->type != MEDIA_ENT_T_V4L2_SUBDEV)
>> + return NULL;
>> +
>> + if (pad)
>> + *pad = remote->index;
>> +
>> + return media_entity_to_v4l2_subdev(remote->entity);
>> +}
>> +
>> +/* get the format set at ouput pad of the adjacent subdev */
>> +static int
>> +__vpfe_video_get_format(struct vpfe_video_device *video,
>> + struct v4l2_format *format)
>> +{
>> + struct v4l2_subdev_format fmt;
>> + struct v4l2_subdev *subdev;
>> + struct media_pad *remote;
>> + u32 pad;
>> + int ret;
>> +
>> + subdev = vpfe_video_remote_subdev(video, &pad);
>> + if (subdev == NULL)
>> + return -EINVAL;
>> +
>> + fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE;
>> + remote = media_entity_remote_source(&video->pad);
>> + fmt.pad = remote->index;
>> +
>> + ret = v4l2_subdev_call(subdev, pad, get_fmt, NULL, &fmt);
>> + if (ret == -ENOIOCTLCMD)
>> + return -EINVAL;
>> +
>> + format->type = video->type;
>> + /* convert mbus_format to v4l2_format */
>> + v4l2_fill_pix_format(&format->fmt.pix, &fmt.format);
>> + mbus_to_pix(&fmt.format, &format->fmt.pix);
>> +
>> + return 0;
>> +}
>> +
>> +/* make a note of pipeline details */
>> +static void vpfe_prepare_pipeline(struct vpfe_video_device *video)
>> +{
>> + struct media_entity *entity = &video->video_dev.entity;
>> + struct media_device *mdev = entity->parent;
>> + struct vpfe_pipeline *pipe = &video->pipe;
>> + struct vpfe_video_device *far_end = NULL;
>> + struct media_entity_graph graph;
>> +
>> + pipe->input_num = 0;
>> + pipe->output_num = 0;
>> +
>> + if (video->type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
>> + pipe->inputs[pipe->input_num++] = video;
>> + else
>> + pipe->outputs[pipe->output_num++] = video;
>> +
>> + mutex_lock(&mdev->graph_mutex);
>> + media_entity_graph_walk_start(&graph, entity);
>> +
>> + while ((entity = media_entity_graph_walk_next(&graph))) {
>> + if (entity == &video->video_dev.entity)
>> + continue;
>> +
>> + if (media_entity_type(entity) != MEDIA_ENT_T_DEVNODE)
>> + continue;
>> +
>> + far_end = to_vpfe_video(media_entity_to_video_device(entity));
>> +
>> + if (far_end->type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
>> + pipe->inputs[pipe->input_num++] = far_end;
>> + else
>> + pipe->outputs[pipe->output_num++] = far_end;
>> + }
>> +
>> + mutex_unlock(&mdev->graph_mutex);
>> +}
>> +
>> +/* update pipe state selected by user */
>> +static int vpfe_update_pipe_state(struct vpfe_video_device *video)
>> +{
>> + struct vpfe_pipeline *pipe = &video->pipe;
>> + int ret;
>> +
>> + vpfe_prepare_pipeline(video);
>> +
>> + /* Find out if there is any input video
>> + if yes, it is single shot.
>> + */
>> + if (pipe->input_num == 0) {
>> + pipe->state = VPFE_PIPELINE_STREAM_CONTINUOUS;
>> + ret = vpfe_update_current_ext_subdev(video);
>> + if (ret) {
>> + pr_err("Invalid external subdev\n");
>> + return ret;
>> + }
>> + } else {
>> + pipe->state = VPFE_PIPELINE_STREAM_SINGLESHOT;
>> + }
>> +
>> + video->initialized = 1;
>> + video->skip_frame_count = 1;
>> + video->skip_frame_count_init = 1;
>> +
>> + return 0;
>> +}
>> +
>> +/* checks wether pipeline is ready for enabling */
>> +int is_pipe_ready(struct vpfe_pipeline *pipe)
>> +{
>> + int i;
>> +
>> + for (i = 0; i < pipe->input_num; i++)
>> + if (!pipe->inputs[i]->started ||
>> + pipe->inputs[i]->state != VPFE_VIDEO_BUFFER_QUEUED)
>> + return 0;
>> +
>> + for (i = 0; i < pipe->output_num; i++)
>> + if (!pipe->outputs[i]->started ||
>> + pipe->outputs[i]->state != VPFE_VIDEO_BUFFER_QUEUED)
>> + return 0;
>> +
>> + return 1;
>> +}
>> +
>> +/**
>> + * Validate a pipeline by checking both ends of all links for format
>> + * discrepancies.
>> + *
>> + * Return 0 if all formats match, or -EPIPE if at least one link is found with
>> + * different formats on its two ends.
>> + */
>> +static int vpfe_video_validate_pipeline(struct vpfe_pipeline *pipe)
>> +{
>> + struct v4l2_subdev_format fmt_source;
>> + struct v4l2_subdev_format fmt_sink;
>> + struct v4l2_subdev *subdev;
>> + struct media_pad *pad;
>> + int ret;
>> +
>> + /* Should not matter if it is output[0] or 1 as
>> + the general ideas is to traverse backwards and
>> + the fact that the out video node always has the
>> + format of the connected pad.
>> + */
>> + subdev = vpfe_video_remote_subdev(pipe->outputs[0], NULL);
>> + if (subdev == NULL)
>> + return -EPIPE;
>> +
>> + while (1) {
>> + /* Retrieve the sink format */
>> + pad = &subdev->entity.pads[0];
>> + if (!(pad->flags & MEDIA_PAD_FL_SINK))
>> + break;
>> +
>> + fmt_sink.which = V4L2_SUBDEV_FORMAT_ACTIVE;
>> + fmt_sink.pad = pad->index;
>> + ret = v4l2_subdev_call(subdev, pad, get_fmt, NULL,
>> + &fmt_sink);
>> +
>> + if (ret < 0 && ret != -ENOIOCTLCMD)
>> + return -EPIPE;
>> +
>> + /* Retrieve the source format */
>> + pad = media_entity_remote_source(pad);
>> + if (pad == NULL ||
>> + pad->entity->type != MEDIA_ENT_T_V4L2_SUBDEV)
>> + break;
>> +
>> + subdev = media_entity_to_v4l2_subdev(pad->entity);
>> +
>> + fmt_source.which = V4L2_SUBDEV_FORMAT_ACTIVE;
>> + fmt_source.pad = pad->index;
>> + ret = v4l2_subdev_call(subdev, pad, get_fmt, NULL, &fmt_source);
>> + if (ret < 0 && ret != -ENOIOCTLCMD)
>> + return -EPIPE;
>> +
>> + /* Check if the two ends match */
>> + if (fmt_source.format.code != fmt_sink.format.code ||
>> + fmt_source.format.width != fmt_sink.format.width ||
>> + fmt_source.format.height != fmt_sink.format.height)
>> + return -EPIPE;
>> + }
>> +
>> + return 0;
>> +}
>> +
>> +/**
>> + * vpfe_pipeline_enable() - Enable streaming on a pipeline
>> + * @vpfe_dev: vpfe device
>> + * @pipe: vpfe pipeline
>> + *
>> + * Walk the entities chain starting at the pipeline output video node and start
>> + * all modules in the chain in the given mode.
>> + *
>> + * Return 0 if successfull, or the return value of the failed video::s_stream
>> + * operation otherwise.
>> + */
>> +static int vpfe_pipeline_enable(struct vpfe_pipeline *pipe)
>> +{
>> + struct media_entity_graph graph;
>> + struct media_entity *entity;
>> + struct v4l2_subdev *subdev;
>> + struct media_device *mdev;
>> + int ret = 0;
>> +
>> + if (pipe->state == VPFE_PIPELINE_STREAM_CONTINUOUS)
>> + entity = vpfe_get_input_entity(pipe->outputs[0]);
>> + else
>> + entity = &pipe->inputs[0]->video_dev.entity;
>> +
>> + mdev = entity->parent;
>> +
>> + mutex_lock(&mdev->graph_mutex);
>> + media_entity_graph_walk_start(&graph, entity);
>> +
>> + while ((entity = media_entity_graph_walk_next(&graph))) {
>> +
>> + if (media_entity_type(entity) == MEDIA_ENT_T_DEVNODE)
>> + continue;
>> +
>> + subdev = media_entity_to_v4l2_subdev(entity);
>> +
>> + ret = v4l2_subdev_call(subdev, video, s_stream, 1);
>> + if (ret < 0 && ret != -ENOIOCTLCMD)
>> + break;
>> + }
>> + mutex_unlock(&mdev->graph_mutex);
>> +
>> + return ret;
>> +}
>> +
>> +/**
>> + * vpfe_pipeline_disable() - Disable streaming on a pipeline
>> + * @vpfe_dev: vpfe device
>> + * @pipe: VPFE pipeline
>> + *
>> + * Walk the entities chain starting at the pipeline output video node and stop
>> + * all modules in the chain.
>> + *
>> + * Return 0 if all modules have been properly stopped, or -ETIMEDOUT if a module
>> + * can't be stopped.
>> + */
>> +static int vpfe_pipeline_disable(struct vpfe_pipeline *pipe)
>> +{
>> + struct media_entity_graph graph;
>> + struct media_entity *entity;
>> + struct v4l2_subdev *subdev;
>> + struct media_device *mdev;
>> + int ret = 0;
>> +
>> + if (pipe->state == VPFE_PIPELINE_STREAM_CONTINUOUS)
>> + entity = vpfe_get_input_entity(pipe->outputs[0]);
>> + else
>> + entity = &pipe->inputs[0]->video_dev.entity;
>> +
>> + mdev = entity->parent;
>> +
>> + mutex_lock(&mdev->graph_mutex);
>> + media_entity_graph_walk_start(&graph, entity);
>> +
>> + while ((entity = media_entity_graph_walk_next(&graph))) {
>> +
>> + if (media_entity_type(entity) == MEDIA_ENT_T_DEVNODE)
>> + continue;
>> +
>> + subdev = media_entity_to_v4l2_subdev(entity);
>> +
>> + ret = v4l2_subdev_call(subdev, video, s_stream, 0);
>> + if (ret < 0 && ret != -ENOIOCTLCMD)
>> + break;
>> + }
>> +
>> + mutex_unlock(&mdev->graph_mutex);
>> +
>> + return (ret == 0) ? ret : -ETIMEDOUT ;
>> +}
>> +
>> +/**
>> + * vpfe_pipeline_set_stream() - Enable/disable streaming on a pipeline
>> + * @vpfe_dev: VPFE device
>> + * @pipe: VPFE pipeline
>> + * @state: Stream state (stopped or active)
>> + *
>> + * Set the pipeline to the given stream state.
>> + *
>> + * Return 0 if successfull, or the return value of the failed video::s_stream
>> + * operation otherwise.
>> + */
>> +static int vpfe_pipeline_set_stream(struct vpfe_pipeline *pipe,
>> + enum vpfe_pipeline_stream_state state)
>> +{
>> + if (state == VPFE_PIPELINE_STREAM_STOPPED)
>> + return vpfe_pipeline_disable(pipe);
>> +
>> + return vpfe_pipeline_enable(pipe);
>> +}
>> +
>> +static int all_videos_stopped(struct vpfe_video_device *video)
>> +{
>> + struct vpfe_pipeline *pipe = &video->pipe;
>> + int i;
>> +
>> + for (i = 0; i < pipe->input_num; i++)
>> + if (pipe->inputs[i]->started)
>> + return 0;
>> +
>> + for (i = 0; i < pipe->output_num; i++)
>> + if (pipe->outputs[i]->started)
>> + return 0;
>> +
>> + return 1;
>> +}
>> +
>> +/*
>> + * vpfe_open() - open video device
>> + * @file: file pointer
>> + *
>> + * initialize media pipeline state, allocate memory for file hadle
>> + *
>> + * Return 0 if successfull, or the return -ENODEV otherwise.
>> + */
>> +static int vpfe_open(struct file *file)
>> +{
>> + struct vpfe_video_device *video = video_drvdata(file);
>> + struct vpfe_fh *fh;
>> +
>> + /* Allocate memory for the file handle object */
>> + fh = kzalloc(sizeof(struct vpfe_fh), GFP_KERNEL);
>
> Please use struct v4l2_fh: it gives you the event API and priority handling
> for free.
>
Ok.
>> +
>> + if (fh == NULL)
>> + return -ENOMEM;
>> + /* store pointer to fh in private_data member of file */
>> + file->private_data = fh;
>> + fh->video = video;
>> + mutex_lock(&video->lock);
>> + /* If decoder is not initialized. initialize it */
>> + if (!video->initialized && vpfe_update_pipe_state(video)) {
>> + mutex_unlock(&video->lock);
>> + return -ENODEV;
>> + }
>> + /* Increment device usrs counter */
>> + video->usrs++;
>> + /* Set io_allowed member to false */
>> + fh->io_allowed = 0;
>> + /* Initialize priority of this instance to default priority */
>> + fh->prio = V4L2_PRIORITY_UNSET;
>> + v4l2_prio_open(&video->prio, &fh->prio);
>> + mutex_unlock(&video->lock);
>> +
>> + return 0;
>> +}
>> +
>> +/* get the next buffer available from dma queue */
>> +unsigned long vpfe_get_next_buffer(struct vpfe_video_device *video)
>> +{
>> + /* mark next buffer as active */
>> + video->next_frm = list_entry(video->dma_queue.next,
>> + struct videobuf_buffer, queue);
>> +
>> + /* in single shot mode both curr_frm
>> + and next_frm point to same buffer */
>> + video->cur_frm = video->next_frm;
>> + list_del(&video->next_frm->queue);
>> + video->next_frm->state = VIDEOBUF_ACTIVE;
>> +
>> + return videobuf_to_dma_contig(video->next_frm);
>> +}
>> +
>> +/* schedule the next buffer which is available on dma queue */
>> +void vpfe_schedule_next_buffer(struct vpfe_video_device *video)
>> +{
>> + struct vpfe_device *vpfe_dev = video->vpfe_dev;
>> + unsigned long addr;
>> +
>> + if (list_empty(&video->dma_queue))
>> + return;
>> +
>> + video->next_frm = list_entry(video->dma_queue.next,
>> + struct videobuf_buffer, queue);
>> +
>> + if (VPFE_PIPELINE_STREAM_SINGLESHOT == video->pipe.state)
>> + video->cur_frm = video->next_frm;
>> +
>> + list_del(&video->next_frm->queue);
>> + video->next_frm->state = VIDEOBUF_ACTIVE;
>> + addr = videobuf_to_dma_contig(video->next_frm);
>> +
>> + video->ops->queue(vpfe_dev, addr);
>> +
>> + video->state = VPFE_VIDEO_BUFFER_QUEUED;
>> +}
>> +
>> +/* schedule the buffer for capturing bottom field */
>> +void vpfe_schedule_bottom_field(struct vpfe_video_device *video)
>> +{
>> + struct vpfe_device *vpfe_dev = video->vpfe_dev;
>> + unsigned long addr;
>> +
>> + addr = videobuf_to_dma_contig(video->cur_frm);
>
> Perhaps it is a good idea to upgrade to vb2?
>
> I'm inclined to make it a requirement for new drivers.
>
Done ported vb2.
>> + addr += video->field_off;
>> +
>> + video->ops->queue(vpfe_dev, addr);
>> +}
>> +
>> +/* make buffer available for dequeue */
>> +void vpfe_process_buffer_complete(struct vpfe_video_device *video)
>> +{
>> + struct vpfe_pipeline *pipe = &video->pipe;
>> + struct timespec timespec;
>> + s64 nsec;
>> +
>> + ktime_get_ts(×pec);
>> + nsec = timespec_to_ns(×pec);
>> +
>> + video->cur_frm->ts = ns_to_timeval(nsec);
>> + video->cur_frm->state = VIDEOBUF_DONE;
>> + video->cur_frm->size = video->fmt.fmt.pix.sizeimage;
>> + wake_up_interruptible(&video->cur_frm->done);
>> + if (pipe->state == VPFE_PIPELINE_STREAM_CONTINUOUS)
>> + video->cur_frm = video->next_frm;
>> +}
>> +
>> +/* vpfe_stop_capture() - stop streaming */
>> +static void vpfe_stop_capture(struct vpfe_video_device *video)
>> +{
>> + struct vpfe_pipeline *pipe = &video->pipe;
>> +
>> + video->started = 0;
>> +
>> + if (video->type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
>> + return;
>> +
>> + if (all_videos_stopped(video))
>> + vpfe_pipeline_set_stream(pipe,
>> + VPFE_PIPELINE_STREAM_STOPPED);
>> +}
>> +
>> +/*
>> + * vpfe_release() - release video device
>> + * @file: file pointer
>> + *
>> + * deletes buffer queue, frees the buffers and the vpfe file handle
>> + *
>> + * Return 0
>> + */
>> +static int vpfe_release(struct file *file)
>> +{
>> + struct vpfe_video_device *video = video_drvdata(file);
>> + struct vpfe_device *vpfe_dev = video->vpfe_dev;
>> + struct vpfe_fh *fh = file->private_data;
>> +
>> + v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_release\n");
>> +
>> + /* Get the device lock */
>> + mutex_lock(&video->lock);
>> + /* if this instance is doing IO */
>> + if (fh->io_allowed) {
>> + if (video->started) {
>> + vpfe_stop_capture(video);
>> + /* mark pipe state as stopped in vpfe_release(),
>> + as app might call streamon() after streamoff()
>> + in which case driver has to start streaming.
>> + */
>> + video->pipe.state = VPFE_PIPELINE_STREAM_STOPPED;
>> + videobuf_streamoff(&video->buffer_queue);
>> + }
>> + video->io_usrs = 0;
>> + }
>> +
>> + /* Decrement device usrs counter */
>> + video->usrs--;
>> + /* Close the priority */
>> + v4l2_prio_close(&video->prio, fh->prio);
>> +
>> + /* If this is the last file handle */
>> + if (!video->usrs)
>> + video->initialized = 0;
>> +
>> + mutex_unlock(&video->lock);
>> + file->private_data = NULL;
>> + /* Free memory allocated to file handle object */
>> + kzfree(fh);
>> +
>> + return 0;
>> +}
>> +
>> +/*
>> + * vpfe_mmap() - It is used to map kernel space buffers
>> + * into user spaces
>> + */
>> +static int vpfe_mmap(struct file *file, struct vm_area_struct *vma)
>> +{
>> + struct vpfe_video_device *video = video_drvdata(file);
>> + struct vpfe_device *vpfe_dev = video->vpfe_dev;
>> +
>> + v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_mmap\n");
>> +
>> + return videobuf_mmap_mapper(&video->buffer_queue, vma);
>> +}
>> +
>> +/*
>> + * vpfe_poll() - It is used for select/poll system call
>> + */
>> +static unsigned int vpfe_poll(struct file *file, poll_table *wait)
>> +{
>> + struct vpfe_video_device *video = video_drvdata(file);
>> + struct vpfe_device *vpfe_dev = video->vpfe_dev;
>> +
>> + v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_poll\n");
>> +
>> + if (video->started)
>> + return videobuf_poll_stream(file,
>> + &video->buffer_queue, wait);
>> +
>> + return 0;
>> +}
>> +
>> +/* vpfe capture driver file operations */
>> +static const struct v4l2_file_operations vpfe_fops = {
>> + .owner = THIS_MODULE,
>> + .open = vpfe_open,
>> + .release = vpfe_release,
>> + .unlocked_ioctl = video_ioctl2,
>> + .mmap = vpfe_mmap,
>> + .poll = vpfe_poll
>> +};
>> +
>> +/*
>> + * vpfe_querycap() - query capabilities of video device
>> + * @file: file pointer
>> + * @priv: void pointer
>> + * @cap: pointer to v4l2_capability structure
>> + *
>> + * fills v4l2 capabilities structure
>> + *
>> + * Return 0
>> + */
>> +static int vpfe_querycap(struct file *file, void *priv,
>> + struct v4l2_capability *cap)
>> +{
>> + struct vpfe_video_device *video = video_drvdata(file);
>> + struct vpfe_device *vpfe_dev = video->vpfe_dev;
>> +
>> + v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_querycap\n");
>> +
>> + if (video->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
>> + cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
>> + else
>> + cap->capabilities = V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_STREAMING;
>
> Please set cap->device_caps as well (see the spec for this new functionality).
>
Ok.
>> +
>> + cap->version = VPFE_CAPTURE_VERSION_CODE;
>> + strlcpy(cap->driver, CAPTURE_DRV_NAME, sizeof(cap->driver));
>> + strlcpy(cap->bus_info, "VPFE", sizeof(cap->bus_info));
>> + strlcpy(cap->card, vpfe_dev->cfg->card_name, sizeof(cap->card));
>> +
>> + return 0;
>> +}
>> +
>> +/*
>> + * vpfe_g_fmt() - get the format which is active on video device
>> + * @file: file pointer
>> + * @priv: void pointer
>> + * @fmt: pointer to v4l2_format structure
>> + *
>> + * fills v4l2 format structure with active format
>> + *
>> + * Return 0
>> + */
>> +static int vpfe_g_fmt(struct file *file, void *priv,
>> + struct v4l2_format *fmt)
>> +{
>> + struct vpfe_video_device *video = video_drvdata(file);
>> + struct vpfe_device *vpfe_dev = video->vpfe_dev;
>> +
>> + v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_g_fmt\n");
>> + /* Fill in the information about format */
>> + *fmt = video->fmt;
>> +
>> + return 0;
>> +}
>> +
>> +/*
>> + * vpfe_enum_fmt() - enum formats supported on media chain
>> + * @file: file pointer
>> + * @priv: void pointer
>> + * @fmt: pointer to v4l2_fmtdesc structure
>> + *
>> + * fills v4l2_fmtdesc structure with output format set on adjacent subdev,
>> + * only one format is enumearted as subdevs are already configured
>> + *
>> + * Return 0 if successfull, error code otherwise
>> + */
>> +static int vpfe_enum_fmt(struct file *file, void *priv,
>> + struct v4l2_fmtdesc *fmt)
>> +{
>> + struct vpfe_video_device *video = video_drvdata(file);
>> + struct vpfe_device *vpfe_dev = video->vpfe_dev;
>> + struct v4l2_subdev_format sd_fmt;
>> + struct v4l2_mbus_framefmt mbus;
>> + struct v4l2_subdev *subdev;
>> + struct v4l2_format format;
>> + struct media_pad *remote;
>> + int ret;
>> +
>> + v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_enum_fmt\n");
>> +
>> + /* since already subdev pad format is set,
>> + only one pixel format is available */
>> + if (fmt->index > 0) {
>> + v4l2_err(&vpfe_dev->v4l2_dev, "Invalid index\n");
>> + return -EINVAL;
>> + }
>> +
>> + /* get the remote pad */
>> + remote = media_entity_remote_source(&video->pad);
>> + if (remote == NULL) {
>> + v4l2_err(&vpfe_dev->v4l2_dev,
>> + "invalid remote pad for video node\n");
>> + return -EINVAL;
>> + }
>> +
>> + /* get the remote subdev */
>> + subdev = vpfe_video_remote_subdev(video, NULL);
>> + if (subdev == NULL) {
>> + v4l2_err(&vpfe_dev->v4l2_dev,
>> + "invalid remote subdev for video node\n");
>> + return -EINVAL;
>> + }
>> +
>> + sd_fmt.pad = remote->index;
>> + sd_fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE;
>> + /* get output format of remote subdev */
>> + ret = v4l2_subdev_call(subdev, pad, get_fmt, NULL, &sd_fmt);
>> + if (ret) {
>> + v4l2_err(&vpfe_dev->v4l2_dev,
>> + "invalid remote subdev for video node\n");
>> + return ret;
>> + }
>> + /* convert to pix format */
>> + mbus.code = sd_fmt.format.code;
>> + mbus_to_pix(&mbus, &format.fmt.pix);
>> +
>> + /* copy the result */
>> + fmt->pixelformat = format.fmt.pix.pixelformat;
>> +
>> + return 0;
>> +}
>> +
>> +/*
>> + * vpfe_s_fmt() - set the format on video device
>> + * @file: file pointer
>> + * @priv: void pointer
>> + * @fmt: pointer to v4l2_format structure
>> + *
>> + * validate and set the format on video device
>> + *
>> + * Return 0 on success, error code otherwise
>> + */
>> +static int vpfe_s_fmt(struct file *file, void *priv,
>> + struct v4l2_format *fmt)
>> +{
>> + struct vpfe_video_device *video = video_drvdata(file);
>> + struct vpfe_device *vpfe_dev = video->vpfe_dev;
>> + struct v4l2_format format;
>> + int ret;
>> +
>> + v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_s_fmt\n");
>> +
>> + /* If streaming is started, return error */
>> + if (video->started) {
>> + v4l2_err(&vpfe_dev->v4l2_dev, "Streaming is started\n");
>> + return -EBUSY;
>> + }
>> +
>> + /* get adjacent subdev's output pad format */
>> + ret = __vpfe_video_get_format(video, &format);
>> + if (ret)
>> + return ret;
>> +
>> + *fmt = format;
>> +
>> + video->fmt = *fmt;
>> +
>> + return 0;
>> +}
>> +
>> +/*
>> + * vpfe_try_fmt() - try the format on video device
>> + * @file: file pointer
>> + * @priv: void pointer
>> + * @fmt: pointer to v4l2_format structure
>> + *
>> + * validate the format, update with correct format
>> + * based on output format set on adjacent subdev
>> + *
>> + * Return 0 on success, error code otherwise
>> + */
>> +static int vpfe_try_fmt(struct file *file, void *priv,
>> + struct v4l2_format *fmt)
>> +{
>> + struct vpfe_video_device *video = video_drvdata(file);
>> + struct vpfe_device *vpfe_dev = video->vpfe_dev;
>> + struct v4l2_format format;
>> + int ret;
>> +
>> + v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_try_fmt\n");
>> +
>> + /* get adjacent subdev's output pad format */
>> + ret = __vpfe_video_get_format(video, &format);
>> + if (ret)
>> + return ret;
>> +
>> + *fmt = format;
>> +
>> + return 0;
>> +}
>> +
>> +/*
>> + * vpfe_enum_input() - enum inputs supported on media chain
>> + * @file: file pointer
>> + * @priv: void pointer
>> + * @fmt: pointer to v4l2_fmtdesc structure
>> + *
>> + * fills v4l2_input structure with input available on media chain,
>> + * only one input is enumearted as media chain is setup by this time
>> + *
>> + * Return 0 if successfull, -EINVAL is media chain is invalid
>> + */
>> +static int vpfe_enum_input(struct file *file, void *priv,
>> + struct v4l2_input *inp)
>> +{
>> + struct vpfe_video_device *video = video_drvdata(file);
>> + struct vpfe_ext_subdev_info *sdinfo = video->current_ext_subdev;
>> + struct vpfe_device *vpfe_dev = video->vpfe_dev;
>> +
>> + v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_enum_input\n");
>> +
>> + /* enumerate from the subdev user has choosen through mc */
>> + if (inp->index < sdinfo->num_inputs) {
>> + memcpy(inp, &sdinfo->inputs[inp->index],
>> + sizeof(struct v4l2_input));
>
> This makes the same mistake that the vpif driver have: the assumption that
> for each input there is a corresponding subdev. I'm working on a patch for
> the vpif_capture/display drivers to fix that. I hope to post that today or
> next week.
>
Ok.
>> + return 0;
>> + }
>> +
>> + return -EINVAL;
>> +}
>> +
>> +/*
>> + * vpfe_g_input() - get index of the input which is active
>> + * @file: file pointer
>> + * @priv: void pointer
>> + * @index: pointer to unsigned int
>> + *
>> + * set index with input index which is active
>> + *
>> + * Return 0
>> + */
>> +static int vpfe_g_input(struct file *file, void *priv, unsigned int *index)
>> +{
>> + struct vpfe_video_device *video = video_drvdata(file);
>> + struct vpfe_device *vpfe_dev = video->vpfe_dev;
>> +
>> + v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_g_input\n");
>> +
>> + *index = video->current_input;
>> +
>> + return 0;
>> +}
>> +
>> +/*
>> + * vpfe_s_input() - set input which is pointed by input index
>> + * @file: file pointer
>> + * @priv: void pointer
>> + * @index: pointer to unsigned int
>> + *
>> + * set input on external subdev
>> + *
>> + * Return 0 on success, error code otherwise
>> + */
>> +static int vpfe_s_input(struct file *file, void *priv, unsigned int index)
>> +{
>> + struct vpfe_video_device *video = video_drvdata(file);
>> + struct vpfe_device *vpfe_dev = video->vpfe_dev;
>> + struct ccdc_hw_device *ccdc_dev = vpfe_dev->vpfe_ccdc.ccdc_dev;
>> + struct imp_hw_interface *imp_hw_if = vpfe_dev->vpfe_previewer.imp_hw_if;
>> + struct vpfe_ext_subdev_info *sdinfo;
>> + struct vpfe_route *route;
>> + struct v4l2_input *inps;
>> + u32 output;
>> + u32 input;
>> + int ret;
>> + int i;
>> +
>> + v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_s_input\n");
>> +
>> + ret = mutex_lock_interruptible(&video->lock);
>> + if (ret)
>> + return ret;
>> +
>> + /*
>> + * If streaming is started return device busy
>> + * error
>> + */
>> + if (video->started) {
>> + v4l2_err(&vpfe_dev->v4l2_dev, "Streaming is on\n");
>> + ret = -EBUSY;
>> + goto unlock_out;
>> + }
>> +
>> + sdinfo = video->current_ext_subdev;
>> +
>> + if (!sdinfo->registered) {
>> + ret = -EINVAL;
>> + goto unlock_out;
>> + }
>> +
>> + if (vpfe_dev->cfg->setup_input &&
>> + vpfe_dev->cfg->setup_input(sdinfo->grp_id) < 0) {
>> + ret = -EFAULT;
>> + v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev,
>> + "couldn't setup input for %s\n",
>> + sdinfo->module_name);
>> + goto unlock_out;
>> + }
>> +
>> + route = &sdinfo->routes[index];
>> + if (route && sdinfo->can_route) {
>> + input = route->input;
>> + output = route->output;
>> + ret = v4l2_device_call_until_err(&vpfe_dev->v4l2_dev,
>> + sdinfo->grp_id, video,
>> + s_routing, input, output, 0);
>> +
>> + if (ret) {
>> + v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev,
>> + "s_input:error in setting input in decoder\n");
>> + ret = -EINVAL;
>> + goto unlock_out;
>> + }
>> + }
>> +
>> + /* set standards set by subdev in video device */
>> + for (i = 0; i < sdinfo->num_inputs; i++) {
>> + inps = &sdinfo->inputs[i];
>> + video->video_dev.tvnorms |= inps->std;
>> + }
>> +
>> + /* set the bus/interface parameter for the sub device in ccdc */
>> + ret = ccdc_dev->hw_ops.set_hw_if_params(&sdinfo->ccdc_if_params);
>> + if (ret)
>> + goto unlock_out;
>> +
>> + /* update the if parameters to imp hw interface */
>> + if (imp_hw_if && imp_hw_if->set_hw_if_param)
>> + ret = imp_hw_if->set_hw_if_param(vpfe_dev->ipipe,
>> + &sdinfo->ccdc_if_params);
>> + if (ret)
>> + goto unlock_out;
>> +
>> + video->current_input = index;
>> +
>> +unlock_out:
>> + mutex_unlock(&video->lock);
>> + return ret;
>> +}
>> +
>> +/*
>> + * vpfe_querystd() - query std which is being input on external subdev
>> + * @file: file pointer
>> + * @priv: void pointer
>> + * @std_id: pointer to v4l2_std_id structure
>> + *
>> + * call external subdev through v4l2_device_call_until_err to
>> + * get the std that is being active.
>> + *
>> + * Return 0 on success, error code otherwise
>> + */
>> +static int vpfe_querystd(struct file *file, void *priv, v4l2_std_id *std_id)
>> +{
>> + struct vpfe_video_device *video = video_drvdata(file);
>> + struct vpfe_device *vpfe_dev = video->vpfe_dev;
>> + struct vpfe_ext_subdev_info *sdinfo;
>> + int ret;
>> +
>> + v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_querystd\n");
>> +
>> + ret = mutex_lock_interruptible(&video->lock);
>> + sdinfo = video->current_ext_subdev;
>> + if (ret)
>> + return ret;
>> +
>> + /* Call querystd function of decoder device */
>> + ret = v4l2_device_call_until_err(&vpfe_dev->v4l2_dev, sdinfo->grp_id,
>> + video, querystd, std_id);
>> + mutex_unlock(&video->lock);
>> +
>> + return ret;
>> +}
>> +
>> +/*
>> + * vpfe_s_std() - set std on external subdev
>> + * @file: file pointer
>> + * @priv: void pointer
>> + * @std_id: pointer to v4l2_std_id structure
>> + *
>> + * set std pointed by std_id on external subdev by calling it using
>> + * v4l2_device_call_until_err
>> + *
>> + * Return 0 on success, error code otherwise
>> + */
>> +static int vpfe_s_std(struct file *file, void *priv, v4l2_std_id *std_id)
>> +{
>> + struct vpfe_video_device *video = video_drvdata(file);
>> + struct vpfe_device *vpfe_dev = video->vpfe_dev;
>> + struct vpfe_ext_subdev_info *sdinfo;
>> + int ret;
>> +
>> + v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_s_std\n");
>> +
>> + /* Call decoder driver function to set the standard */
>> + ret = mutex_lock_interruptible(&video->lock);
>> + if (ret)
>> + return ret;
>> +
>> + sdinfo = video->current_ext_subdev;
>> + /* If streaming is started, return device busy error */
>> + if (video->started) {
>> + v4l2_err(&vpfe_dev->v4l2_dev, "streaming is started\n");
>> + ret = -EBUSY;
>> + goto unlock_out;
>> + }
>> +
>> + ret = v4l2_device_call_until_err(&vpfe_dev->v4l2_dev, sdinfo->grp_id,
>> + core, s_std, *std_id);
>> + if (ret < 0) {
>> + v4l2_err(&vpfe_dev->v4l2_dev, "Failed to set standard\n");
>> + goto unlock_out;
>> + }
>> +
>> +unlock_out:
>> + mutex_unlock(&video->lock);
>> + return ret;
>> +}
>> +
>> +/*
>> + * vpfe_enum_preset() - enumerate dv_preset which are supported by
>> + * to external subdev
>> + *
>> + * @file: file pointer
>> + * @priv: void pointer
>> + * @preset: pointer to v4l2_dv_enum_preset structure
>> + *
>> + * enum dv_preset's which are supported by external subdev through
>> + * v4l2_subdev_call
>> + *
>> + * Return 0 on success, error code otherwise
>> + */
>> +static int vpfe_enum_preset(struct file *file, void *fh,
>> + struct v4l2_dv_enum_preset *preset)
>> +{
>> + struct vpfe_video_device *video = video_drvdata(file);
>> + struct vpfe_device *vpfe_dev = video->vpfe_dev;
>> + struct v4l2_subdev *subdev = video->current_ext_subdev->subdev;
>> +
>> + v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_enum_preset\n");
>> +
>> + return v4l2_subdev_call(subdev, video, enum_dv_presets, preset);
>> +}
>> +
>> +/*
>> + * vpfe_query_preset() - query the dv_preset which is being input
>> + * to external subdev
>> + *
>> + * @file: file pointer
>> + * @priv: void pointer
>> + * @preset: pointer to v4l2_preset structure
>> + *
>> + * get dv_preset which is being input on external subdev through
>> + * v4l2_subdev_call
>> + *
>> + * Return 0 on success, error code otherwise
>> + */
>> +static int vpfe_query_preset(struct file *file, void *fh,
>> + struct v4l2_dv_preset *preset)
>> +{
>> + struct vpfe_video_device *video = video_drvdata(file);
>> + struct vpfe_device *vpfe_dev = video->vpfe_dev;
>> + struct v4l2_subdev *subdev = video->current_ext_subdev->subdev;
>> +
>> + v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_query_preset\n");
>> +
>> + return v4l2_subdev_call(subdev, video, query_dv_preset, preset);
>> +}
>> +
>> +/*
>> + * vpfe_s_preset() - set dv_preset on external subdev
>> + * @file: file pointer
>> + * @priv: void pointer
>> + * @preset: pointer to v4l2_preset structure
>> + *
>> + * set dv_preset pointed by preset on external subdev through
>> + * v4l2_device_call_until_err, this configures amplifier also
>> + *
>> + * Return 0 on success, error code otherwise
>> + */
>> +static int vpfe_s_preset(struct file *file, void *fh,
>> + struct v4l2_dv_preset *preset)
>> +{
>> + struct vpfe_video_device *video = video_drvdata(file);
>> + struct vpfe_device *vpfe_dev = video->vpfe_dev;
>> +
>> + v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_s_preset\n");
>> +
>> + return v4l2_device_call_until_err(&vpfe_dev->v4l2_dev,
>> + video->current_ext_subdev->grp_id,
>> + video, s_dv_preset, preset);
>> +}
>> +
>> +/*
>> + * vpfe_g_preset() - get dv_preset which is set on external subdev
>> + * @file: file pointer
>> + * @priv: void pointer
>> + * @preset: pointer to v4l2_preset structure
>> + *
>> + * get dv_preset which is set on external subdev through
>> + * v4l2_subdev_call
>> + *
>> + * Return 0 on success, error code otherwise
>> + */
>> +static int vpfe_g_preset(struct file *file, void *fh,
>> + struct v4l2_dv_preset *preset)
>> +{
>> + struct vpfe_video_device *video = video_drvdata(file);
>> + struct vpfe_device *vpfe_dev = video->vpfe_dev;
>> + struct v4l2_subdev *subdev = video->current_ext_subdev->subdev;
>> +
>> + v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_g_preset\n");
>> +
>> + return v4l2_subdev_call(subdev, video, query_dv_preset, preset);
>> +}
>
> The preset API is deprecated and replaced by the DV Timings API. New drivers
> should implement that API instead.
>
>> +
>> +/*
>> + * Videobuf operations
>> + */
>> +static int vpfe_videobuf_setup(struct videobuf_queue *vq,
>> + unsigned int *count,
>> + unsigned int *size)
>> +{
>> + struct vpfe_fh *fh = vq->priv_data;
>> + struct vpfe_video_device *video = fh->video;
>> + struct vpfe_device *vpfe_dev = video->vpfe_dev;
>> + struct vpfe_pipeline *pipe = &video->pipe;
>> +
>> + v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_buffer_setup\n");
>> +
>> + *size = video->fmt.fmt.pix.sizeimage;
>> +
>> + if (vpfe_dev->video_limit) {
>> + while (*size * *count > vpfe_dev->video_limit)
>> + (*count)--;
>> + }
>> +
>> + if (pipe->state == VPFE_PIPELINE_STREAM_CONTINUOUS) {
>> + if (*count < CONT_MIN_NUM_BUFFERS)
>> + *count = CONT_MIN_NUM_BUFFERS;
>> + }
>> +
>> + v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev,
>> + "count=%d, size=%d\n", *count, *size);
>> +
>> + return 0;
>> +}
>> +
>> +static int vpfe_videobuf_prepare(struct videobuf_queue *vq,
>> + struct videobuf_buffer *vb,
>> + enum v4l2_field field)
>> +{
>> + struct vpfe_fh *fh = vq->priv_data;
>> + struct vpfe_video_device *video = fh->video;
>> + struct vpfe_device *vpfe_dev = video->vpfe_dev;
>> + unsigned long addr;
>> + int ret;
>> +
>> + v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_videobuf_prepare\n");
>> +
>> + if (VIDEOBUF_NEEDS_INIT != vb->state)
>> + return 0;
>> +
>> + /* Initialize buffer */
>> + vb->width = video->fmt.fmt.pix.width;
>> + vb->height = video->fmt.fmt.pix.height;
>> + vb->size = video->fmt.fmt.pix.sizeimage;
>> + vb->field = field;
>> +
>> + ret = videobuf_iolock(vq, vb, NULL);
>> + if (ret < 0)
>> + return ret;
>> +
>> + addr = videobuf_to_dma_contig(vb);
>> + /* Make sure user addresses are aligned to 32 bytes */
>> + if (!ALIGN(addr, 32))
>> + return -EINVAL;
>> +
>> + vb->state = VIDEOBUF_PREPARED;
>> +
>> + return 0;
>> +}
>> +
>> +static void vpfe_videobuf_queue(struct videobuf_queue *vq,
>> + struct videobuf_buffer *vb)
>> +{
>> + /* Get the file handle object and device object */
>> + struct vpfe_fh *fh = vq->priv_data;
>> + struct vpfe_video_device *video = fh->video;
>> + struct vpfe_device *vpfe_dev = video->vpfe_dev;
>> + struct vpfe_pipeline *pipe = &video->pipe;
>> + unsigned long flags;
>> + unsigned long empty;
>> + unsigned long addr;
>> +
>> + spin_lock_irqsave(&video->dma_queue_lock, flags);
>> + empty = list_empty(&video->dma_queue);
>> +
>> + /* add the buffer to the DMA queue */
>> + list_add_tail(&vb->queue, &video->dma_queue);
>> + spin_unlock_irqrestore(&video->dma_queue_lock, flags);
>> +
>> + /* Change state of the buffer */
>> + vb->state = VIDEOBUF_QUEUED;
>> +
>> + /* this case happens in case of single shot */
>> + if (empty && video->started && pipe->state ==
>> + VPFE_PIPELINE_STREAM_SINGLESHOT &&
>> + video->state == VPFE_VIDEO_BUFFER_NOT_QUEUED) {
>> + spin_lock(&video->dma_queue_lock);
>> + addr = vpfe_get_next_buffer(video);
>> + video->ops->queue(vpfe_dev, addr);
>> +
>> + video->state = VPFE_VIDEO_BUFFER_QUEUED;
>> + spin_unlock(&video->dma_queue_lock);
>> +
>> + /* enable h/w each time in single shot */
>> + if (is_pipe_ready(pipe))
>> + vpfe_pipeline_set_stream(pipe,
>> + VPFE_PIPELINE_STREAM_SINGLESHOT);
>> + }
>> +}
>> +
>> +static void vpfe_videobuf_release(struct videobuf_queue *vq,
>> + struct videobuf_buffer *vb)
>> +{
>> + struct vpfe_fh *fh = vq->priv_data;
>> + struct vpfe_video_device *video = fh->video;
>> + struct vpfe_device *vpfe_dev = video->vpfe_dev;
>> +
>> + v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_videobuf_release\n");
>> +
>> + if (video->memory == V4L2_MEMORY_MMAP)
>> + videobuf_dma_contig_free(vq, vb);
>> + vb->state = VIDEOBUF_NEEDS_INIT;
>> +}
>> +
>> +static struct videobuf_queue_ops vpfe_videobuf_qops = {
>> + .buf_setup = vpfe_videobuf_setup,
>> + .buf_prepare = vpfe_videobuf_prepare,
>> + .buf_queue = vpfe_videobuf_queue,
>> + .buf_release = vpfe_videobuf_release,
>> +};
>
> Again, I highly recommend moving to the videobuf2 framework. If nothing else,
> the vb2 framework will get support for DMABUF, allowing zero-copy pipelining.
>
>> +
>> +/*
>> + * vpfe_reqbufs() - supported REQBUF only once opening
>> + * the device.
>> + */
>> +static int vpfe_reqbufs(struct file *file, void *priv,
>> + struct v4l2_requestbuffers *req_buf)
>> +{
>> + struct vpfe_video_device *video = video_drvdata(file);
>> + struct vpfe_device *vpfe_dev = video->vpfe_dev;
>> + struct vpfe_fh *fh = file->private_data;
>> + int ret;
>> +
>> + v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_reqbufs\n");
>> +
>> + if (V4L2_BUF_TYPE_VIDEO_CAPTURE != req_buf->type &&
>> + V4L2_BUF_TYPE_VIDEO_OUTPUT != req_buf->type) {
>> + v4l2_err(&vpfe_dev->v4l2_dev, "Invalid buffer type\n");
>> + return -EINVAL;
>> + }
>> +
>> + ret = mutex_lock_interruptible(&video->lock);
>> + if (ret)
>> + return ret;
>> +
>> + if (video->io_usrs != 0) {
>> + v4l2_err(&vpfe_dev->v4l2_dev, "Only one IO user allowed\n");
>> + ret = -EBUSY;
>> + goto unlock_out;
>> + }
>> +
>> + video->memory = req_buf->memory;
>> + videobuf_queue_dma_contig_init(&video->buffer_queue,
>> + &vpfe_videobuf_qops, vpfe_dev->pdev,
>> + &video->irqlock, req_buf->type,
>> + video->fmt.fmt.pix.field,
>> + sizeof(struct videobuf_buffer),
>> + fh, NULL);
>> +
>> + fh->io_allowed = 1;
>> + video->io_usrs = 1;
>> + INIT_LIST_HEAD(&video->dma_queue);
>> + ret = videobuf_reqbufs(&video->buffer_queue, req_buf);
>> +
>> +unlock_out:
>> + mutex_unlock(&video->lock);
>> + return ret;
>> +}
>> +
>> +/*
>> + * vpfe_querybuf() - query buffers for exchange
>> + */
>> +static int vpfe_querybuf(struct file *file, void *priv,
>> + struct v4l2_buffer *buf)
>> +{
>> + struct vpfe_video_device *video = video_drvdata(file);
>> + struct vpfe_device *vpfe_dev = video->vpfe_dev;
>> +
>> + v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_querybuf\n");
>> +
>> + if (V4L2_BUF_TYPE_VIDEO_CAPTURE != buf->type &&
>> + V4L2_BUF_TYPE_VIDEO_OUTPUT != buf->type) {
>> + v4l2_err(&vpfe_dev->v4l2_dev, "Invalid buf type\n");
>> + return -EINVAL;
>> + }
>> +
>> + if (video->memory != V4L2_MEMORY_MMAP) {
>> + v4l2_err(&vpfe_dev->v4l2_dev, "Invalid memory\n");
>> + return -EINVAL;
>> + }
>> +
>> + /* Call videobuf_querybuf to get information */
>> + return videobuf_querybuf(&video->buffer_queue, buf);
>> +}
>> +
>> +/*
>> + * vpfe_qbuf() - queue buffers for capture or processing
>> + */
>> +static int vpfe_qbuf(struct file *file, void *priv,
>> + struct v4l2_buffer *p)
>> +{
>> + struct vpfe_video_device *video = video_drvdata(file);
>> + struct vpfe_device *vpfe_dev = video->vpfe_dev;
>> + struct vpfe_fh *fh = file->private_data;
>> +
>> + v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_qbuf\n");
>> +
>> + if (V4L2_BUF_TYPE_VIDEO_CAPTURE != p->type &&
>> + V4L2_BUF_TYPE_VIDEO_OUTPUT != p->type) {
>> + v4l2_err(&vpfe_dev->v4l2_dev, "Invalid buf type\n");
>> + return -EINVAL;
>> + }
>> +
>> + /*
>> + * If this file handle is not allowed to do IO,
>> + * return error
>> + */
>> + if (!fh->io_allowed) {
>> + v4l2_err(&vpfe_dev->v4l2_dev, "fh->io_allowed\n");
>> + return -EACCES;
>> + }
>> +
>> + return videobuf_qbuf(&video->buffer_queue, p);
>> +}
>> +
>> +/*
>> + * vpfe_dqbuf() - deque buffer which is done with processing
>> + */
>> +static int vpfe_dqbuf(struct file *file, void *priv,
>> + struct v4l2_buffer *buf)
>> +{
>> + struct vpfe_video_device *video = video_drvdata(file);
>> + struct vpfe_device *vpfe_dev = video->vpfe_dev;
>> +
>> + v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_dqbuf\n");
>> +
>> + if (V4L2_BUF_TYPE_VIDEO_CAPTURE != buf->type &&
>> + V4L2_BUF_TYPE_VIDEO_OUTPUT != buf->type) {
>> + v4l2_err(&vpfe_dev->v4l2_dev, "Invalid buf type\n");
>> + return -EINVAL;
>> + }
>> +
>> + return videobuf_dqbuf(&video->buffer_queue,
>> + buf, file->f_flags & O_NONBLOCK);
>> +}
>> +
>> +/* vpfe_start_capture() - start streaming on all the subdevs */
>> +static int vpfe_start_capture(struct vpfe_video_device *video)
>> +{
>> + struct vpfe_pipeline *pipe = &video->pipe;
>> + int ret = 0;
>> +
>> + video->started = 1;
>> +
>> + if (is_pipe_ready(pipe))
>> + ret = vpfe_pipeline_set_stream(pipe, pipe->state);
>> +
>> + return ret;
>> +}
>> +
>> +/*
>> + * vpfe_streamon() - get dv_preset which is set on external subdev
>> + * @file: file pointer
>> + * @priv: void pointer
>> + * @buf_type: enum v4l2_buf_type
>> + *
>> + * queue buffer onto hardware for capture/processing and
>> + * start all the subdevs which are in media chain
>> + *
>> + * Return 0 on success, error code otherwise
>> + */
>> +static int vpfe_streamon(struct file *file, void *priv,
>> + enum v4l2_buf_type buf_type)
>> +{
>> + struct vpfe_video_device *video = video_drvdata(file);
>> + struct vpfe_device *vpfe_dev = video->vpfe_dev;
>> + struct vpfe_pipeline *pipe = &video->pipe;
>> + struct vpfe_fh *fh = file->private_data;
>> + struct vpfe_ext_subdev_info *sdinfo;
>> + unsigned long addr;
>> + int ret = -EINVAL;
>> +
>> + v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_streamon\n");
>> +
>> + if (V4L2_BUF_TYPE_VIDEO_CAPTURE != buf_type &&
>> + V4L2_BUF_TYPE_VIDEO_OUTPUT != buf_type) {
>> + v4l2_err(&vpfe_dev->v4l2_dev, "Invalid buf type\n");
>> + return ret;
>> + }
>> +
>> + /* If file handle is not allowed IO, return error */
>> + if (!fh->io_allowed) {
>> + v4l2_err(&vpfe_dev->v4l2_dev, "fh->io_allowed\n");
>> + return -EACCES;
>> + }
>> + sdinfo = video->current_ext_subdev;
>> + /* If buffer queue is empty, return error */
>> + if (list_empty(&video->buffer_queue.stream)) {
>> + v4l2_err(&vpfe_dev->v4l2_dev, "buffer queue is empty\n");
>> + return -EIO;
>> + }
>> + /* Validate the pipeline */
>> + if (V4L2_BUF_TYPE_VIDEO_CAPTURE == buf_type) {
>> + ret = vpfe_video_validate_pipeline(pipe);
>> + if (ret < 0)
>> + return ret;
>> + }
>> + /* Call videobuf_streamon to start streaming * in videobuf */
>> + ret = videobuf_streamon(&video->buffer_queue);
>> + if (ret)
>> + return ret;
>> +
>> + ret = mutex_lock_interruptible(&video->lock);
>> + if (ret)
>> + goto streamoff;
>> +
>> + /* Get the next frame from the buffer queue */
>> + video->next_frm = list_entry(video->dma_queue.next,
>> + struct videobuf_buffer, queue);
>> + video->cur_frm = video->next_frm;
>> + /* Remove buffer from the buffer queue */
>> + list_del(&video->cur_frm->queue);
>> + /* Mark state of the current frame to active */
>> + video->cur_frm->state = VIDEOBUF_ACTIVE;
>> + /* Initialize field_id and started member */
>> + video->field_id = 0;
>> + addr = videobuf_to_dma_contig(video->cur_frm);
>> + video->ops->queue(vpfe_dev, addr);
>> + video->state = VPFE_VIDEO_BUFFER_QUEUED;
>> + ret = vpfe_start_capture(video);
>> + if (ret)
>> + goto unlock_out;
>> +
>> + mutex_unlock(&video->lock);
>> + return ret;
>> +unlock_out:
>> + mutex_unlock(&video->lock);
>> +streamoff:
>> + ret = videobuf_streamoff(&video->buffer_queue);
>> + return ret;
>> +}
>> +
>> +/*
>> + * vpfe_streamoff() - get dv_preset which is set on external subdev
>> + * @file: file pointer
>> + * @priv: void pointer
>> + * @buf_type: enum v4l2_buf_type
>> + *
>> + * stop all the subdevs which are in media chain
>> + *
>> + * Return 0 on success, error code otherwise
>> + */
>> +static int vpfe_streamoff(struct file *file, void *priv,
>> + enum v4l2_buf_type buf_type)
>> +{
>> + struct vpfe_video_device *video = video_drvdata(file);
>> + struct vpfe_device *vpfe_dev = video->vpfe_dev;
>> + struct vpfe_fh *fh = file->private_data;
>> + int ret = 0;
>> +
>> + v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_streamoff\n");
>> +
>> + if (buf_type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
>> + buf_type != V4L2_BUF_TYPE_VIDEO_OUTPUT) {
>> + v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "Invalid buf type\n");
>> + return -EINVAL;
>> + }
>> +
>> + /* If io is allowed for this file handle, return error */
>> + if (!fh->io_allowed) {
>> + v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "fh->io_allowed\n");
>> + return -EACCES;
>> + }
>> +
>> + /* If streaming is not started, return error */
>> + if (!video->started) {
>> + v4l2_err(&vpfe_dev->v4l2_dev, "device is not started\n");
>> + return -EINVAL;
>> + }
>> +
>> + ret = mutex_lock_interruptible(&video->lock);
>> + if (ret)
>> + return ret;
>> +
>> + vpfe_stop_capture(video);
>> +
>> + ret = videobuf_streamoff(&video->buffer_queue);
>> + mutex_unlock(&video->lock);
>> +
>> + return ret;
>> +}
>> +
>> +/*
>> + * vpfe_queryctrl() - query for v4l2 controls which is set on external subdev
>> + * @file: file pointer
>> + * @priv: void pointer
>> + * @ctrl: pointer to v4l2_control structure
>> + *
>> + * get the v4l2 controls active on external subdev through
>> + * v4l2_device_call_until_err
>> + *
>> + * Return return value returned by v4l2_device_call_until_err
>> + */
>> +static int vpfe_queryctrl(struct file *file, void *priv,
>> + struct v4l2_queryctrl *qc)
>> +{
>> + struct vpfe_video_device *video = video_drvdata(file);
>> + struct vpfe_device *vpfe_dev = video->vpfe_dev;
>> + struct vpfe_ext_subdev_info *sub_dev = video->current_ext_subdev;
>> +
>> + v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_queryctrl\n");
>> +
>> + /* pass it to sub device */
>> + return v4l2_device_call_until_err(&vpfe_dev->v4l2_dev, sub_dev->grp_id,
>> + core, queryctrl, qc);
>> +}
>
> It is compulsory to use the control framework.
>
> Which should be simple enough: make an empty control handler, let the ctrl_handler field
> of struct v4l2_device point to it and then when the subdevs are added the controls of
> each subdev will be added (inherited) as well.
>
Ok.
>> +
>> +/*
>> + * vpfe_g_ctrl() - get the v4l2 controls which is set on external subdev
>> + * @file: file pointer
>> + * @priv: void pointer
>> + * @ctrl: pointer to v4l2_control structure
>> + *
>> + * get the v4l2 controls set on external subdev through
>> + * v4l2_device_call_until_err
>> + *
>> + * Return return value returned by v4l2_device_call_until_err
>> + */
>> +static int vpfe_g_ctrl(struct file *file, void *priv,
>> + struct v4l2_control *ctrl)
>> +{
>> + struct vpfe_video_device *video = video_drvdata(file);
>> + struct vpfe_device *vpfe_dev = video->vpfe_dev;
>> + struct vpfe_ext_subdev_info *sub_dev = video->current_ext_subdev;
>> +
>> + v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_g_ctrl\n");
>> +
>> + return v4l2_device_call_until_err(&vpfe_dev->v4l2_dev, sub_dev->grp_id,
>> + core, g_ctrl, ctrl);
>> +}
>> +
>> +/*
>> + * vpfe_s_ctrl() - set the v4l2 controls on external subdev
>> + * @file: file pointer
>> + * @priv: void pointer
>> + * @ctrl: pointer to v4l2_control structure
>> + *
>> + * call external subdev through v4l2_device_call_until_err to
>> + * set v4l2 controls
>> + *
>> + * Return return value returned by v4l2_device_call_until_err
>> + */
>> +static int vpfe_s_ctrl(struct file *file, void *priv,
>> + struct v4l2_control *ctrl)
>> +{
>> + struct vpfe_video_device *video = video_drvdata(file);
>> + struct vpfe_device *vpfe_dev = video->vpfe_dev;
>> + struct vpfe_ext_subdev_info *sub_dev = video->current_ext_subdev;
>> +
>> + v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_s_ctrl\n");
>> +
>> + return v4l2_device_call_until_err(&vpfe_dev->v4l2_dev, sub_dev->grp_id,
>> + core, s_ctrl, ctrl);
>> +}
>> +
>> +/* vpfe capture ioctl operations */
>> +static const struct v4l2_ioctl_ops vpfe_ioctl_ops = {
>> + .vidioc_querycap = vpfe_querycap,
>> + .vidioc_g_fmt_vid_cap = vpfe_g_fmt,
>> + .vidioc_s_fmt_vid_cap = vpfe_s_fmt,
>> + .vidioc_try_fmt_vid_cap = vpfe_try_fmt,
>> + .vidioc_enum_fmt_vid_cap = vpfe_enum_fmt,
>> + .vidioc_g_fmt_vid_out = vpfe_g_fmt,
>> + .vidioc_s_fmt_vid_out = vpfe_s_fmt,
>> + .vidioc_try_fmt_vid_out = vpfe_try_fmt,
>> + .vidioc_enum_fmt_vid_out = vpfe_enum_fmt,
>> + .vidioc_enum_input = vpfe_enum_input,
>> + .vidioc_g_input = vpfe_g_input,
>> + .vidioc_s_input = vpfe_s_input,
>> + .vidioc_querystd = vpfe_querystd,
>> + .vidioc_s_std = vpfe_s_std,
>> + .vidioc_enum_dv_presets = vpfe_enum_preset,
>> + .vidioc_query_dv_preset = vpfe_query_preset,
>> + .vidioc_s_dv_preset = vpfe_s_preset,
>> + .vidioc_g_dv_preset = vpfe_g_preset,
>> + .vidioc_reqbufs = vpfe_reqbufs,
>> + .vidioc_querybuf = vpfe_querybuf,
>> + .vidioc_qbuf = vpfe_qbuf,
>> + .vidioc_dqbuf = vpfe_dqbuf,
>> + .vidioc_streamon = vpfe_streamon,
>> + .vidioc_streamoff = vpfe_streamoff,
>> + .vidioc_queryctrl = vpfe_queryctrl,
>> + .vidioc_g_ctrl = vpfe_g_ctrl,
>> + .vidioc_s_ctrl = vpfe_s_ctrl,
>> +};
>> +
>> +/* VPFE video init function */
>> +int vpfe_video_init(struct vpfe_video_device *video, const char *name)
>> +{
>> + const char *direction;
>> + int ret;
>> +
>> + switch (video->type) {
>> + case V4L2_BUF_TYPE_VIDEO_CAPTURE:
>> + direction = "output";
>> + video->pad.flags = MEDIA_PAD_FL_SINK;
>> + video->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
>> + break;
>> + case V4L2_BUF_TYPE_VIDEO_OUTPUT:
>> + direction = "input";
>> + video->pad.flags = MEDIA_PAD_FL_SOURCE;
>> + video->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
>> + break;
>> + default:
>> + return -EINVAL;
>> + }
>> +
>> + /* Initialize field of video device */
>> + video->video_dev.release = video_device_release;
>> + video->video_dev.fops = &vpfe_fops;
>> + video->video_dev.ioctl_ops = &vpfe_ioctl_ops;
>> + video->video_dev.minor = -1;
>> + video->video_dev.tvnorms = 0;
>> + video->video_dev.current_norm = V4L2_STD_NTSC;
>
> Don't use current_norm. Create a proper vpfe_g_std instead. current_norm is
> being phased out.
>
Ok.
Regards,
--Prabhakar Lad
>> +
>> + snprintf(video->video_dev.name, sizeof(video->video_dev.name),
>> + "DAVINCI VIDEO %s %s", name, direction);
>> +
>> + /* Initialize prio member of device object */
>> + v4l2_prio_init(&video->prio);
>> +
>> + spin_lock_init(&video->irqlock);
>> + spin_lock_init(&video->dma_queue_lock);
>> + mutex_init(&video->lock);
>> +
>> + ret = media_entity_init(&video->video_dev.entity,
>> + 1, &video->pad, 0);
>> + if (ret < 0)
>> + return ret;
>> +
>> + video_set_drvdata(&video->video_dev, video);
>> +
>> + return 0;
>> +}
>> +
>> +/* vpfe video device register function */
>> +int vpfe_video_register(struct vpfe_video_device *video,
>> + struct v4l2_device *vdev)
>> +{
>> + int ret;
>> +
>> + video->video_dev.v4l2_dev = vdev;
>> +
>> + ret = video_register_device(&video->video_dev, VFL_TYPE_GRABBER, -1);
>> + if (ret < 0)
>> + pr_err("%s: could not register video device (%d)\n",
>> + __func__, ret);
>> +
>> + return ret;
>> +}
>> +
>> +/* vpfe video device unregister function */
>> +void vpfe_video_unregister(struct vpfe_video_device *video)
>> +{
>> + if (video_is_registered(&video->video_dev)) {
>> + media_entity_cleanup(&video->video_dev.entity);
>> + video_unregister_device(&video->video_dev);
>> + }
>> +}
>> diff --git a/drivers/media/platform/davinci/vpfe_video.h b/drivers/media/platform/davinci/vpfe_video.h
>> new file mode 100644
>> index 0000000..af68caf
>> --- /dev/null
>> +++ b/drivers/media/platform/davinci/vpfe_video.h
>> @@ -0,0 +1,150 @@
>> +/*
>> + * Copyright (C) 2012 Texas Instruments Inc
>> + *
>> + * This program is free software; you can redistribute it and/or
>> + * modify it under the terms of the GNU General Public License as
>> + * published by the Free Software Foundation version 2.
>> + *
>> + * This program is distributed in the hope that it will be useful,
>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
>> + * GNU General Public License for more details.
>> + *
>> + * You should have received a copy of the GNU General Public License
>> + * along with this program; if not, write to the Free Software
>> + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
>> + *
>> + * Contributors:
>> + * Manjunath Hadli <manjunath.hadli@xxxxxx>
>> + * Prabhakar Lad <prabhakar.lad@xxxxxx>
>> + */
>> +
>> +/* All video device related structures will go here */
>> +#ifndef _VPFE_VIDEO_H
>> +#define _VPFE_VIDEO_H
>> +
>> +#include <media/media-entity.h>
>> +#include <media/videobuf-dma-contig.h>
>> +
>> +struct vpfe_device;
>> +
>> +/*
>> + * struct vpfe_video_operations - VPFE video operations
>> + * @queue: Resume streaming when a buffer is queued. Called on VIDIOC_QBUF
>> + * if there was no buffer previously queued.
>> + */
>> +struct vpfe_video_operations {
>> + void(*queue)(struct vpfe_device *vpfe_dev, unsigned long addr);
>> +};
>> +
>> +enum vpfe_pipeline_stream_state {
>> + VPFE_PIPELINE_STREAM_STOPPED,
>> + VPFE_PIPELINE_STREAM_CONTINUOUS,
>> + VPFE_PIPELINE_STREAM_SINGLESHOT
>> +};
>> +
>> +enum vpfe_video_state {
>> + /* indicates that buffer is not queued */
>> + VPFE_VIDEO_BUFFER_NOT_QUEUED = 0,
>> + /* indicates that buffer is queued */
>> + VPFE_VIDEO_BUFFER_QUEUED = 1,
>> +};
>> +
>> +struct vpfe_pipeline {
>> + /* media pipeline */
>> + struct media_pipeline *pipe;
>> + /* state of the pipeline, continous,
>> + single-shot or stopped */
>> + enum vpfe_pipeline_stream_state state;
>> + /* number of active input video entities */
>> + unsigned int input_num;
>> + /* number of active output video entities */
>> + unsigned int output_num;
>> + /* input video nodes in case of single-shot mode */
>> + struct vpfe_video_device *inputs[10];
>> + /* capturing video nodes */
>> + struct vpfe_video_device *outputs[10];
>> +};
>> +
>> +#define to_vpfe_pipeline(__e) \
>> + container_of((__e)->pipe, struct vpfe_pipeline, pipe)
>> +
>> +#define to_vpfe_video(vdev) \
>> + container_of(vdev, struct vpfe_video_device, video_dev)
>> +
>> +struct vpfe_video_device {
>> + /* vpfe device */
>> + struct vpfe_device *vpfe_dev;
>> + /* video dev */
>> + struct video_device video_dev;
>> + /* media pad of video entity */
>> + struct media_pad pad;
>> + /* video operations supported by video device */
>> + const struct vpfe_video_operations *ops;
>> + /* type of the video buffers used by user */
>> + enum v4l2_buf_type type;
>> + /* Indicates id of the field which is being captured */
>> + u32 field_id;
>> + /* pipiline for which video device is part of */
>> + struct vpfe_pipeline pipe;
>> + /* Indicates whether streaming started */
>> + u8 started;
>> + /* Indicates state of the stream */
>> + unsigned int state;
>> + /* current input at the sub device */
>> + int current_input;
>> + /*
>> + * This field keeps track of type of buffer exchange mechanism
>> + * user has selected
>> + */
>> + enum v4l2_memory memory;
>> + /* Used to keep track of state of the priority */
>> + struct v4l2_prio_state prio;
>> + /* number of open instances of the channel */
>> + u32 usrs;
>> + /* flag to indicate whether decoder is initialized */
>> + u8 initialized;
>> + /* skip frame count */
>> + u8 skip_frame_count;
>> + /* skip frame count init value */
>> + u8 skip_frame_count_init;
>> + /* time per frame for skipping */
>> + struct v4l2_fract timeperframe;
>> + /* ptr to currently selected sub device */
>> + struct vpfe_ext_subdev_info *current_ext_subdev;
>> + /* Pointer pointing to current v4l2_buffer */
>> + struct videobuf_buffer *cur_frm;
>> + /* Pointer pointing to next v4l2_buffer */
>> + struct videobuf_buffer *next_frm;
>> + /* Used to store pixel format */
>> + struct v4l2_format fmt;
>> + /* Buffer queue used in video-buf */
>> + struct videobuf_queue buffer_queue;
>> + /* Queue of filled frames */
>> + struct list_head dma_queue;
>> + /* Used in video-buf */
>> + spinlock_t irqlock;
>> + /* IRQ lock for DMA queue */
>> + spinlock_t dma_queue_lock;
>> + /* lock used to access this structure */
>> + struct mutex lock;
>> + /* number of users performing IO */
>> + u32 io_usrs;
>> + /*
>> + * offset where second field starts from the starting of the
>> + * buffer for field seperated YCbCr formats
>> + */
>> + u32 field_off;
>> +};
>> +
>> +int is_pipe_ready(struct vpfe_pipeline *pipe);
>> +void vpfe_video_unregister(struct vpfe_video_device *video);
>> +int vpfe_video_register(struct vpfe_video_device *video,
>> + struct v4l2_device *vdev);
>> +int vpfe_video_init(struct vpfe_video_device *video, const char *name);
>> +
>> +void vpfe_process_buffer_complete(struct vpfe_video_device *video);
>> +void vpfe_schedule_bottom_field(struct vpfe_video_device *video);
>> +void vpfe_schedule_next_buffer(struct vpfe_video_device *video);
>> +unsigned long vpfe_get_next_buffer(struct vpfe_video_device *video);
>> +#endif
>>
>
> Regards,
>
> Hans
--
To unsubscribe from this list: send the line "unsubscribe linux-media" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
