linux/drivers/media/platform/renesas/vsp1/vsp1_video.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * vsp1_video.c  --  R-Car VSP1 Video Node
 *
 * Copyright (C) 2013-2015 Renesas Electronics Corporation
 *
 * Contact: Laurent Pinchart ([email protected])
 */

#include <linux/list.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/slab.h>
#include <linux/v4l2-mediabus.h>
#include <linux/videodev2.h>
#include <linux/wait.h>

#include <media/media-entity.h>
#include <media/v4l2-dev.h>
#include <media/v4l2-fh.h>
#include <media/v4l2-ioctl.h>
#include <media/v4l2-subdev.h>
#include <media/videobuf2-v4l2.h>
#include <media/videobuf2-dma-contig.h>

#include "vsp1.h"
#include "vsp1_brx.h"
#include "vsp1_dl.h"
#include "vsp1_entity.h"
#include "vsp1_hgo.h"
#include "vsp1_hgt.h"
#include "vsp1_pipe.h"
#include "vsp1_rwpf.h"
#include "vsp1_uds.h"
#include "vsp1_video.h"

#define VSP1_VIDEO_DEF_FORMAT …
#define VSP1_VIDEO_DEF_WIDTH …
#define VSP1_VIDEO_DEF_HEIGHT …

#define VSP1_VIDEO_MAX_WIDTH …
#define VSP1_VIDEO_MAX_HEIGHT …

/* -----------------------------------------------------------------------------
 * Helper functions
 */

static struct v4l2_subdev *
vsp1_video_remote_subdev(struct media_pad *local, u32 *pad)
{ … }

static int vsp1_video_verify_format(struct vsp1_video *video)
{ … }

static int __vsp1_video_try_format(struct vsp1_video *video,
				   struct v4l2_pix_format_mplane *pix,
				   const struct vsp1_format_info **fmtinfo)
{ … }

/* -----------------------------------------------------------------------------
 * Pipeline Management
 */

/*
 * vsp1_video_complete_buffer - Complete the current buffer
 * @video: the video node
 *
 * This function completes the current buffer by filling its sequence number,
 * time stamp and payload size, and hands it back to the vb2 core.
 *
 * Return the next queued buffer or NULL if the queue is empty.
 */
static struct vsp1_vb2_buffer *
vsp1_video_complete_buffer(struct vsp1_video *video)
{ … }

static void vsp1_video_frame_end(struct vsp1_pipeline *pipe,
				 struct vsp1_rwpf *rwpf)
{ … }

static void vsp1_video_pipeline_run_partition(struct vsp1_pipeline *pipe,
					      struct vsp1_dl_list *dl,
					      unsigned int partition)
{ … }

static void vsp1_video_pipeline_run(struct vsp1_pipeline *pipe)
{ … }

static void vsp1_video_pipeline_frame_end(struct vsp1_pipeline *pipe,
					  unsigned int completion)
{ … }

static int vsp1_video_pipeline_build_branch(struct vsp1_pipeline *pipe,
					    struct vsp1_rwpf *input,
					    struct vsp1_rwpf *output)
{ … }

static int vsp1_video_pipeline_build(struct vsp1_pipeline *pipe,
				     struct vsp1_video *video)
{ … }

static int vsp1_video_pipeline_init(struct vsp1_pipeline *pipe,
				    struct vsp1_video *video)
{ … }

static struct vsp1_pipeline *vsp1_video_pipeline_get(struct vsp1_video *video)
{ … }

static void vsp1_video_pipeline_release(struct kref *kref)
{ … }

static void vsp1_video_pipeline_put(struct vsp1_pipeline *pipe)
{ … }

/* -----------------------------------------------------------------------------
 * videobuf2 Queue Operations
 */

static int
vsp1_video_queue_setup(struct vb2_queue *vq,
		       unsigned int *nbuffers, unsigned int *nplanes,
		       unsigned int sizes[], struct device *alloc_devs[])
{ … }

static int vsp1_video_buffer_prepare(struct vb2_buffer *vb)
{ … }

static void vsp1_video_buffer_queue(struct vb2_buffer *vb)
{ … }

static int vsp1_video_pipeline_setup_partitions(struct vsp1_pipeline *pipe)
{ … }

static int vsp1_video_setup_pipeline(struct vsp1_pipeline *pipe)
{ … }

static void vsp1_video_release_buffers(struct vsp1_video *video)
{ … }

static void vsp1_video_cleanup_pipeline(struct vsp1_pipeline *pipe)
{ … }

static int vsp1_video_start_streaming(struct vb2_queue *vq, unsigned int count)
{ … }

static void vsp1_video_stop_streaming(struct vb2_queue *vq)
{ … }

static const struct vb2_ops vsp1_video_queue_qops = …;

/* -----------------------------------------------------------------------------
 * V4L2 ioctls
 */

static int
vsp1_video_querycap(struct file *file, void *fh, struct v4l2_capability *cap)
{ … }

static int
vsp1_video_get_format(struct file *file, void *fh, struct v4l2_format *format)
{ … }

static int
vsp1_video_try_format(struct file *file, void *fh, struct v4l2_format *format)
{ … }

static int
vsp1_video_set_format(struct file *file, void *fh, struct v4l2_format *format)
{ … }

static int
vsp1_video_streamon(struct file *file, void *fh, enum v4l2_buf_type type)
{ … }

static const struct v4l2_ioctl_ops vsp1_video_ioctl_ops = …;

/* -----------------------------------------------------------------------------
 * V4L2 File Operations
 */

static int vsp1_video_open(struct file *file)
{ … }

static int vsp1_video_release(struct file *file)
{ … }

static const struct v4l2_file_operations vsp1_video_fops = …;

/* -----------------------------------------------------------------------------
 * Media entity operations
 */

static int vsp1_video_link_validate(struct media_link *link)
{ … }

static const struct media_entity_operations vsp1_video_media_ops = …;

/* -----------------------------------------------------------------------------
 * Suspend and Resume
 */

void vsp1_video_suspend(struct vsp1_device *vsp1)
{ … }

void vsp1_video_resume(struct vsp1_device *vsp1)
{ … }

/* -----------------------------------------------------------------------------
 * Initialization and Cleanup
 */

struct vsp1_video *vsp1_video_create(struct vsp1_device *vsp1,
				     struct vsp1_rwpf *rwpf)
{ … }

void vsp1_video_cleanup(struct vsp1_video *video)
{ … }