linux/drivers/media/platform/nxp/imx8-isi/imx8-isi-video.c

// SPDX-License-Identifier: GPL-2.0
/*
 * V4L2 Capture ISI subdev driver for i.MX8QXP/QM platform
 *
 * ISI is a Image Sensor Interface of i.MX8QXP/QM platform, which
 * used to process image from camera sensor to memory or DC
 *
 * Copyright (c) 2019 NXP Semiconductor
 */

#include <linux/device.h>
#include <linux/dma-mapping.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/media-bus-format.h>
#include <linux/minmax.h>
#include <linux/pm_runtime.h>
#include <linux/string.h>
#include <linux/types.h>
#include <linux/videodev2.h>

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

#include "imx8-isi-core.h"
#include "imx8-isi-regs.h"

/* Keep the first entry matching MXC_ISI_DEF_PIXEL_FORMAT */
static const struct mxc_isi_format_info mxc_isi_formats[] = …;

const struct mxc_isi_format_info *
mxc_isi_format_by_fourcc(u32 fourcc, enum mxc_isi_video_type type)
{ … }

const struct mxc_isi_format_info *
mxc_isi_format_enum(unsigned int index, enum mxc_isi_video_type type)
{ … }

const struct mxc_isi_format_info *
mxc_isi_format_try(struct mxc_isi_pipe *pipe, struct v4l2_pix_format_mplane *pix,
		   enum mxc_isi_video_type type)
{ … }

/* -----------------------------------------------------------------------------
 * videobuf2 queue operations
 */

static void mxc_isi_video_frame_write_done(struct mxc_isi_pipe *pipe,
					   u32 status)
{ … }

static void mxc_isi_video_free_discard_buffers(struct mxc_isi_video *video)
{ … }

static int mxc_isi_video_alloc_discard_buffers(struct mxc_isi_video *video)
{ … }

static int mxc_isi_video_validate_format(struct mxc_isi_video *video)
{ … }

static void mxc_isi_video_return_buffers(struct mxc_isi_video *video,
					 enum vb2_buffer_state state)
{ … }

static void mxc_isi_video_queue_first_buffers(struct mxc_isi_video *video)
{ … }

static inline struct mxc_isi_buffer *to_isi_buffer(struct vb2_v4l2_buffer *v4l2_buf)
{ … }

int mxc_isi_video_queue_setup(const struct v4l2_pix_format_mplane *format,
			      const struct mxc_isi_format_info *info,
			      unsigned int *num_buffers,
			      unsigned int *num_planes, unsigned int sizes[])
{ … }

void mxc_isi_video_buffer_init(struct vb2_buffer *vb2, dma_addr_t dma_addrs[3],
			       const struct mxc_isi_format_info *info,
			       const struct v4l2_pix_format_mplane *pix)
{ … }

int mxc_isi_video_buffer_prepare(struct mxc_isi_dev *isi, struct vb2_buffer *vb2,
				 const struct mxc_isi_format_info *info,
				 const struct v4l2_pix_format_mplane *pix)
{ … }

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

static int mxc_isi_vb2_buffer_init(struct vb2_buffer *vb2)
{ … }

static int mxc_isi_vb2_buffer_prepare(struct vb2_buffer *vb2)
{ … }

static void mxc_isi_vb2_buffer_queue(struct vb2_buffer *vb2)
{ … }

static void mxc_isi_video_init_channel(struct mxc_isi_video *video)
{ … }

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

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

static const struct vb2_ops mxc_isi_vb2_qops = …;

/* -----------------------------------------------------------------------------
 * V4L2 controls
 */

static inline struct mxc_isi_video *ctrl_to_isi_video(struct v4l2_ctrl *ctrl)
{ … }

static int mxc_isi_video_s_ctrl(struct v4l2_ctrl *ctrl)
{ … }

static const struct v4l2_ctrl_ops mxc_isi_video_ctrl_ops = …;

static int mxc_isi_video_ctrls_create(struct mxc_isi_video *video)
{ … }

static void mxc_isi_video_ctrls_delete(struct mxc_isi_video *video)
{ … }

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

static int mxc_isi_video_querycap(struct file *file, void *priv,
				  struct v4l2_capability *cap)
{ … }

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

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

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

static int mxc_isi_video_s_fmt(struct file *file, void *priv,
			       struct v4l2_format *f)
{ … }

static int mxc_isi_video_streamon(struct file *file, void *priv,
				  enum v4l2_buf_type type)
{ … }

static void mxc_isi_video_cleanup_streaming(struct mxc_isi_video *video)
{ … }

static int mxc_isi_video_streamoff(struct file *file, void *priv,
				   enum v4l2_buf_type type)
{ … }

static int mxc_isi_video_enum_framesizes(struct file *file, void *priv,
					 struct v4l2_frmsizeenum *fsize)
{ … }

static const struct v4l2_ioctl_ops mxc_isi_video_ioctl_ops = …;

/* -----------------------------------------------------------------------------
 * Video device file operations
 */

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

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

static const struct v4l2_file_operations mxc_isi_video_fops = …;

/* -----------------------------------------------------------------------------
 * Suspend & resume
 */

void mxc_isi_video_suspend(struct mxc_isi_pipe *pipe)
{ … }

int mxc_isi_video_resume(struct mxc_isi_pipe *pipe)
{ … }

/* -----------------------------------------------------------------------------
 * Registration
 */

int mxc_isi_video_register(struct mxc_isi_pipe *pipe,
			   struct v4l2_device *v4l2_dev)
{ … }

void mxc_isi_video_unregister(struct mxc_isi_pipe *pipe)
{ … }