linux/drivers/media/platform/samsung/exynos-gsc/gsc-m2m.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Copyright (c) 2011 - 2012 Samsung Electronics Co., Ltd.
 *		http://www.samsung.com
 *
 * Samsung EXYNOS5 SoC series G-Scaler driver
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/errno.h>
#include <linux/bug.h>
#include <linux/interrupt.h>
#include <linux/workqueue.h>
#include <linux/device.h>
#include <linux/platform_device.h>
#include <linux/list.h>
#include <linux/io.h>
#include <linux/slab.h>
#include <linux/clk.h>

#include <media/v4l2-ioctl.h>

#include "gsc-core.h"

static int gsc_m2m_ctx_stop_req(struct gsc_ctx *ctx)
{ … }

static void __gsc_m2m_job_abort(struct gsc_ctx *ctx)
{ … }

static int gsc_m2m_start_streaming(struct vb2_queue *q, unsigned int count)
{ … }

static void __gsc_m2m_cleanup_queue(struct gsc_ctx *ctx)
{ … }

static void gsc_m2m_stop_streaming(struct vb2_queue *q)
{ … }

void gsc_m2m_job_finish(struct gsc_ctx *ctx, int vb_state)
{ … }

static void gsc_m2m_job_abort(void *priv)
{ … }

static int gsc_get_bufs(struct gsc_ctx *ctx)
{ … }

static void gsc_m2m_device_run(void *priv)
{ … }

static int gsc_m2m_queue_setup(struct vb2_queue *vq,
			unsigned int *num_buffers, unsigned int *num_planes,
			unsigned int sizes[], struct device *alloc_devs[])
{ … }

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

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

static const struct vb2_ops gsc_m2m_qops = …;

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

static int gsc_m2m_enum_fmt(struct file *file, void *priv,
			    struct v4l2_fmtdesc *f)
{ … }

static int gsc_m2m_g_fmt_mplane(struct file *file, void *fh,
			     struct v4l2_format *f)
{ … }

static int gsc_m2m_try_fmt_mplane(struct file *file, void *fh,
				  struct v4l2_format *f)
{ … }

static int gsc_m2m_s_fmt_mplane(struct file *file, void *fh,
				 struct v4l2_format *f)
{ … }

static int gsc_m2m_reqbufs(struct file *file, void *fh,
			  struct v4l2_requestbuffers *reqbufs)
{ … }

static int gsc_m2m_expbuf(struct file *file, void *fh,
				struct v4l2_exportbuffer *eb)
{ … }

static int gsc_m2m_querybuf(struct file *file, void *fh,
					struct v4l2_buffer *buf)
{ … }

static int gsc_m2m_qbuf(struct file *file, void *fh,
			  struct v4l2_buffer *buf)
{ … }

static int gsc_m2m_dqbuf(struct file *file, void *fh,
			   struct v4l2_buffer *buf)
{ … }

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

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

/* Return 1 if rectangle a is enclosed in rectangle b, or 0 otherwise. */
static int is_rectangle_enclosed(struct v4l2_rect *a, struct v4l2_rect *b)
{ … }

static int gsc_m2m_g_selection(struct file *file, void *fh,
			struct v4l2_selection *s)
{ … }

static int gsc_m2m_s_selection(struct file *file, void *fh,
				struct v4l2_selection *s)
{ … }

static const struct v4l2_ioctl_ops gsc_m2m_ioctl_ops = …;

static int queue_init(void *priv, struct vb2_queue *src_vq,
			struct vb2_queue *dst_vq)
{ … }

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

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

static __poll_t gsc_m2m_poll(struct file *file,
					struct poll_table_struct *wait)
{ … }

static int gsc_m2m_mmap(struct file *file, struct vm_area_struct *vma)
{ … }

static const struct v4l2_file_operations gsc_m2m_fops = …;

static const struct v4l2_m2m_ops gsc_m2m_ops = …;

int gsc_register_m2m_device(struct gsc_dev *gsc)
{ … }

void gsc_unregister_m2m_device(struct gsc_dev *gsc)
{ … }