cx88-video.c | Explore in Territory

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 *
 * device driver for Conexant 2388x based TV cards
 * video4linux video interface
 *
 * (c) 2003-04 Gerd Knorr <[email protected]> [SuSE Labs]
 *
 * (c) 2005-2006 Mauro Carvalho Chehab <[email protected]>
 *	- Multituner support
 *	- video_ioctl2 conversion
 *	- PAL/M fixes
 */

#include "cx88.h"

#include <linux/init.h>
#include <linux/list.h>
#include <linux/module.h>
#include <linux/kmod.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/interrupt.h>
#include <linux/dma-mapping.h>
#include <linux/delay.h>
#include <linux/kthread.h>
#include <asm/div64.h>

#include <media/v4l2-common.h>
#include <media/v4l2-ioctl.h>
#include <media/v4l2-event.h>
#include <media/i2c/wm8775.h>

MODULE_DESCRIPTION(…) …;
MODULE_AUTHOR(…) …;
MODULE_LICENSE(…) …;
MODULE_VERSION(…);

/* ------------------------------------------------------------------ */

static unsigned int video_nr[] = …;
static unsigned int vbi_nr[]   = …;
static unsigned int radio_nr[] = …;

module_param_array(…);
module_param_array(…);
module_param_array(…);

MODULE_PARM_DESC(…) …;
MODULE_PARM_DESC(…) …;
MODULE_PARM_DESC(…) …;

static unsigned int video_debug;
module_param(video_debug, int, 0644);
MODULE_PARM_DESC(…) …;

static unsigned int irq_debug;
module_param(irq_debug, int, 0644);
MODULE_PARM_DESC(…) …;

#define dprintk(level, fmt, arg...) …

/* ------------------------------------------------------------------- */
/* static data                                                         */

static const struct cx8800_fmt formats[] = …;

static const struct cx8800_fmt *format_by_fourcc(unsigned int fourcc)
{ … }

/* ------------------------------------------------------------------- */

struct cx88_ctrl { … };

static const struct cx88_ctrl cx8800_vid_ctls[] = …;

static const struct cx88_ctrl cx8800_aud_ctls[] = …;

enum { … };

/* ------------------------------------------------------------------ */

int cx88_video_mux(struct cx88_core *core, unsigned int input)
{ … }
EXPORT_SYMBOL(…);

/* ------------------------------------------------------------------ */

static int start_video_dma(struct cx8800_dev    *dev,
			   struct cx88_dmaqueue *q,
			   struct cx88_buffer   *buf)
{ … }

static int __maybe_unused stop_video_dma(struct cx8800_dev    *dev)
{ … }

static int __maybe_unused restart_video_queue(struct cx8800_dev *dev,
					      struct cx88_dmaqueue *q)
{ … }

/* ------------------------------------------------------------------ */

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

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

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

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

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

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

static const struct vb2_ops cx8800_video_qops = …;

/* ------------------------------------------------------------------ */

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

/* ------------------------------------------------------------------ */
/* VIDEO CTRL IOCTLS                                                  */

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

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

/* ------------------------------------------------------------------ */
/* VIDEO IOCTLS                                                       */

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

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

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

int cx88_querycap(struct file *file, struct cx88_core *core,
		  struct v4l2_capability *cap)
{ … }
EXPORT_SYMBOL(…);

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

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

static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *tvnorm)
{ … }

static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id tvnorms)
{ … }

/* only one input in this sample driver */
int cx88_enum_input(struct cx88_core  *core, struct v4l2_input *i)
{ … }
EXPORT_SYMBOL(…);

static int vidioc_enum_input(struct file *file, void *priv,
			     struct v4l2_input *i)
{ … }

static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
{ … }

static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
{ … }

static int vidioc_g_tuner(struct file *file, void *priv,
			  struct v4l2_tuner *t)
{ … }

static int vidioc_s_tuner(struct file *file, void *priv,
			  const struct v4l2_tuner *t)
{ … }

static int vidioc_g_frequency(struct file *file, void *priv,
			      struct v4l2_frequency *f)
{ … }

int cx88_set_freq(struct cx88_core  *core,
		  const struct v4l2_frequency *f)
{ … }
EXPORT_SYMBOL(…);

static int vidioc_s_frequency(struct file *file, void *priv,
			      const struct v4l2_frequency *f)
{ … }

#ifdef CONFIG_VIDEO_ADV_DEBUG
static int vidioc_g_register(struct file *file, void *fh,
			     struct v4l2_dbg_register *reg)
{ … }

static int vidioc_s_register(struct file *file, void *fh,
			     const struct v4l2_dbg_register *reg)
{ … }
#endif

/* ----------------------------------------------------------- */
/* RADIO ESPECIFIC IOCTLS                                      */
/* ----------------------------------------------------------- */

static int radio_g_tuner(struct file *file, void *priv,
			 struct v4l2_tuner *t)
{ … }

static int radio_s_tuner(struct file *file, void *priv,
			 const struct v4l2_tuner *t)
{ … }

/* ----------------------------------------------------------- */

static const char *cx88_vid_irqs[32] = …;

static void cx8800_vid_irq(struct cx8800_dev *dev)
{ … }

static irqreturn_t cx8800_irq(int irq, void *dev_id)
{ … }

/* ----------------------------------------------------------- */
/* exported stuff                                              */

static const struct v4l2_file_operations video_fops = …;

static const struct v4l2_ioctl_ops video_ioctl_ops = …;

static const struct video_device cx8800_video_template = …;

static const struct v4l2_ioctl_ops vbi_ioctl_ops = …;

static const struct video_device cx8800_vbi_template = …;

static const struct v4l2_file_operations radio_fops = …;

static const struct v4l2_ioctl_ops radio_ioctl_ops = …;

static const struct video_device cx8800_radio_template = …;

static const struct v4l2_ctrl_ops cx8800_ctrl_vid_ops = …;

static const struct v4l2_ctrl_ops cx8800_ctrl_aud_ops = …;

/* ----------------------------------------------------------- */

static void cx8800_unregister_video(struct cx8800_dev *dev)
{ … }

static int cx8800_initdev(struct pci_dev *pci_dev,
			  const struct pci_device_id *pci_id)
{ … }

static void cx8800_finidev(struct pci_dev *pci_dev)
{ … }

static int __maybe_unused cx8800_suspend(struct device *dev_d)
{ … }

static int __maybe_unused cx8800_resume(struct device *dev_d)
{ … }

/* ----------------------------------------------------------- */

static const struct pci_device_id cx8800_pci_tbl[] = …;
MODULE_DEVICE_TABLE(pci, cx8800_pci_tbl);

static SIMPLE_DEV_PM_OPS(cx8800_pm_ops, cx8800_suspend, cx8800_resume);

static struct pci_driver cx8800_pci_driver = …;

module_pci_driver(…) …;
linux/drivers/media/pci/cx88/cx88-video.c
