[mirror_ubuntu-jammy-kernel.git] / drivers / media / pci / bt8xx / bttv-vbi.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*

    bttv - Bt848 frame grabber driver
    vbi interface

    (c) 2002 Gerd Knorr <kraxel@bytesex.org>

    Copyright (C) 2005, 2006 Michael H. Schimek <mschimek@gmx.at>
    Sponsored by OPQ Systems AB

*/

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/module.h>
#include <linux/errno.h>
#include <linux/fs.h>
#include <linux/kernel.h>
#include <linux/interrupt.h>
#include <linux/kdev_t.h>
#include <media/v4l2-ioctl.h>
#include <asm/io.h>
#include "bttvp.h"

/* Offset from line sync pulse leading edge (0H) to start of VBI capture,
   in fCLKx2 pixels.  According to the datasheet, VBI capture starts
   VBI_HDELAY fCLKx1 pixels from the tailing edgeof /HRESET, and /HRESET
   is 64 fCLKx1 pixels wide.  VBI_HDELAY is set to 0, so this should be
   (64 + 0) * 2 = 128 fCLKx2 pixels.  But it's not!  The datasheet is
   Just Plain Wrong.  The real value appears to be different for
   different revisions of the bt8x8 chips, and to be affected by the
   horizontal scaling factor.  Experimentally, the value is measured
   to be about 244.  */
#define VBI_OFFSET 244

/* 2048 for compatibility with earlier driver versions. The driver
   really stores 1024 + tvnorm->vbipack * 4 samples per line in the
   buffer. Note tvnorm->vbipack is <= 0xFF (limit of VBIPACK_LO + HI
   is 0x1FF DWORDs) and VBI read()s store a frame counter in the last
   four bytes of the VBI image. */
#define VBI_BPL 2048

/* Compatibility. */
#define VBI_DEFLINES 16

static unsigned int vbibufs = 4;
static unsigned int vbi_debug;

module_param(vbibufs,   int, 0444);
module_param(vbi_debug, int, 0644);
MODULE_PARM_DESC(vbibufs,"number of vbi buffers, range 2-32, default 4");
MODULE_PARM_DESC(vbi_debug,"vbi code debug messages, default is 0 (no)");

#ifdef dprintk
# undef dprintk
#endif
#define dprintk(fmt, ...)						\
do {									\
	if (vbi_debug)							\
		pr_debug("%d: " fmt, btv->c.nr, ##__VA_ARGS__);		\
} while (0)

#define IMAGE_SIZE(fmt) \
	(((fmt)->count[0] + (fmt)->count[1]) * (fmt)->samples_per_line)

/* ----------------------------------------------------------------------- */
/* vbi risc code + mm                                                      */

static int vbi_buffer_setup(struct videobuf_queue *q,
			    unsigned int *count, unsigned int *size)
{
	struct bttv_fh *fh = q->priv_data;
	struct bttv *btv = fh->btv;

	if (0 == *count)
		*count = vbibufs;

	*size = IMAGE_SIZE(&fh->vbi_fmt.fmt);

	dprintk("setup: samples=%u start=%d,%d count=%u,%u\n",
		fh->vbi_fmt.fmt.samples_per_line,
		fh->vbi_fmt.fmt.start[0],
		fh->vbi_fmt.fmt.start[1],
		fh->vbi_fmt.fmt.count[0],
		fh->vbi_fmt.fmt.count[1]);

	return 0;
}

static int vbi_buffer_prepare(struct videobuf_queue *q,
			      struct videobuf_buffer *vb,
			      enum v4l2_field field)
{
	struct bttv_fh *fh = q->priv_data;
	struct bttv *btv = fh->btv;
	struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
	const struct bttv_tvnorm *tvnorm;
	unsigned int skip_lines0, skip_lines1, min_vdelay;
	int redo_dma_risc;
	int rc;

	buf->vb.size = IMAGE_SIZE(&fh->vbi_fmt.fmt);
	if (0 != buf->vb.baddr  &&  buf->vb.bsize < buf->vb.size)
		return -EINVAL;

	tvnorm = fh->vbi_fmt.tvnorm;

	/* There's no VBI_VDELAY register, RISC must skip the lines
	   we don't want. With default parameters we skip zero lines
	   as earlier driver versions did. The driver permits video
	   standard changes while capturing, so we use vbi_fmt.tvnorm
	   instead of btv->tvnorm to skip zero lines after video
	   standard changes as well. */

	skip_lines0 = 0;
	skip_lines1 = 0;

	if (fh->vbi_fmt.fmt.count[0] > 0)
		skip_lines0 = max(0, (fh->vbi_fmt.fmt.start[0]
				      - tvnorm->vbistart[0]));
	if (fh->vbi_fmt.fmt.count[1] > 0)
		skip_lines1 = max(0, (fh->vbi_fmt.fmt.start[1]
				      - tvnorm->vbistart[1]));

	redo_dma_risc = 0;

	if (buf->vbi_skip[0] != skip_lines0 ||
	    buf->vbi_skip[1] != skip_lines1 ||
	    buf->vbi_count[0] != fh->vbi_fmt.fmt.count[0] ||
	    buf->vbi_count[1] != fh->vbi_fmt.fmt.count[1]) {
		buf->vbi_skip[0] = skip_lines0;
		buf->vbi_skip[1] = skip_lines1;
		buf->vbi_count[0] = fh->vbi_fmt.fmt.count[0];
		buf->vbi_count[1] = fh->vbi_fmt.fmt.count[1];
		redo_dma_risc = 1;
	}

	if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
		redo_dma_risc = 1;
		if (0 != (rc = videobuf_iolock(q, &buf->vb, NULL)))
			goto fail;
	}

	if (redo_dma_risc) {
		unsigned int bpl, padding, offset;
		struct videobuf_dmabuf *dma=videobuf_to_dma(&buf->vb);

		bpl = 2044; /* max. vbipack */
		padding = VBI_BPL - bpl;

		if (fh->vbi_fmt.fmt.count[0] > 0) {
			rc = bttv_risc_packed(btv, &buf->top,
					      dma->sglist,
					      /* offset */ 0, bpl,
					      padding, skip_lines0,
					      fh->vbi_fmt.fmt.count[0]);
			if (0 != rc)
				goto fail;
		}

		if (fh->vbi_fmt.fmt.count[1] > 0) {
			offset = fh->vbi_fmt.fmt.count[0] * VBI_BPL;

			rc = bttv_risc_packed(btv, &buf->bottom,
					      dma->sglist,
					      offset, bpl,
					      padding, skip_lines1,
					      fh->vbi_fmt.fmt.count[1]);
			if (0 != rc)
				goto fail;
		}
	}

	/* VBI capturing ends at VDELAY, start of video capturing,
	   no matter where the RISC program ends. VDELAY minimum is 2,
	   bounds.top is the corresponding first field line number
	   times two. VDELAY counts half field lines. */
	min_vdelay = MIN_VDELAY;
	if (fh->vbi_fmt.end >= tvnorm->cropcap.bounds.top)
		min_vdelay += fh->vbi_fmt.end - tvnorm->cropcap.bounds.top;

	/* For bttv_buffer_activate_vbi(). */
	buf->geo.vdelay = min_vdelay;

	buf->vb.state = VIDEOBUF_PREPARED;
	buf->vb.field = field;
	dprintk("buf prepare %p: top=%p bottom=%p field=%s\n",
		vb, &buf->top, &buf->bottom,
		v4l2_field_names[buf->vb.field]);
	return 0;

 fail:
	bttv_dma_free(q,btv,buf);
	return rc;
}

static void
vbi_buffer_queue(struct videobuf_queue *q, struct videobuf_buffer *vb)
{
	struct bttv_fh *fh = q->priv_data;
	struct bttv *btv = fh->btv;
	struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);

	dprintk("queue %p\n",vb);
	buf->vb.state = VIDEOBUF_QUEUED;
	list_add_tail(&buf->vb.queue,&btv->vcapture);
	if (NULL == btv->cvbi) {
		fh->btv->loop_irq |= 4;
		bttv_set_dma(btv,0x0c);
	}
}

static void vbi_buffer_release(struct videobuf_queue *q, struct videobuf_buffer *vb)
{
	struct bttv_fh *fh = q->priv_data;
	struct bttv *btv = fh->btv;
	struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);

	dprintk("free %p\n",vb);
	bttv_dma_free(q,fh->btv,buf);
}

const struct videobuf_queue_ops bttv_vbi_qops = {
	.buf_setup    = vbi_buffer_setup,
	.buf_prepare  = vbi_buffer_prepare,
	.buf_queue    = vbi_buffer_queue,
	.buf_release  = vbi_buffer_release,
};

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

static int try_fmt(struct v4l2_vbi_format *f, const struct bttv_tvnorm *tvnorm,
			__s32 crop_start)
{
	__s32 min_start, max_start, max_end, f2_offset;
	unsigned int i;

	/* For compatibility with earlier driver versions we must pretend
	   the VBI and video capture window may overlap. In reality RISC
	   magic aborts VBI capturing at the first line of video capturing,
	   leaving the rest of the buffer unchanged, usually all zero.
	   VBI capturing must always start before video capturing. >> 1
	   because cropping counts field lines times two. */
	min_start = tvnorm->vbistart[0];
	max_start = (crop_start >> 1) - 1;
	max_end = (tvnorm->cropcap.bounds.top
		   + tvnorm->cropcap.bounds.height) >> 1;

	if (min_start > max_start)
		return -EBUSY;

	BUG_ON(max_start >= max_end);

	f->sampling_rate    = tvnorm->Fsc;
	f->samples_per_line = VBI_BPL;
	f->sample_format    = V4L2_PIX_FMT_GREY;
	f->offset           = VBI_OFFSET;

	f2_offset = tvnorm->vbistart[1] - tvnorm->vbistart[0];

	for (i = 0; i < 2; ++i) {
		if (0 == f->count[i]) {
			/* No data from this field. We leave f->start[i]
			   alone because VIDIOCSVBIFMT is w/o and EINVALs
			   when a driver does not support exactly the
			   requested parameters. */
		} else {
			s64 start, count;

			start = clamp(f->start[i], min_start, max_start);
			/* s64 to prevent overflow. */
			count = (s64) f->start[i] + f->count[i] - start;
			f->start[i] = start;
			f->count[i] = clamp(count, (s64) 1,
					    max_end - start);
		}

		min_start += f2_offset;
		max_start += f2_offset;
		max_end += f2_offset;
	}

	if (0 == (f->count[0] | f->count[1])) {
		/* As in earlier driver versions. */
		f->start[0] = tvnorm->vbistart[0];
		f->start[1] = tvnorm->vbistart[1];
		f->count[0] = 1;
		f->count[1] = 1;
	}

	f->flags = 0;

	f->reserved[0] = 0;
	f->reserved[1] = 0;

	return 0;
}

int bttv_try_fmt_vbi_cap(struct file *file, void *f, struct v4l2_format *frt)
{
	struct bttv_fh *fh = f;
	struct bttv *btv = fh->btv;
	const struct bttv_tvnorm *tvnorm;
	__s32 crop_start;

	mutex_lock(&btv->lock);

	tvnorm = &bttv_tvnorms[btv->tvnorm];
	crop_start = btv->crop_start;

	mutex_unlock(&btv->lock);

	return try_fmt(&frt->fmt.vbi, tvnorm, crop_start);
}


int bttv_s_fmt_vbi_cap(struct file *file, void *f, struct v4l2_format *frt)
{
	struct bttv_fh *fh = f;
	struct bttv *btv = fh->btv;
	const struct bttv_tvnorm *tvnorm;
	__s32 start1, end;
	int rc;

	mutex_lock(&btv->lock);

	rc = -EBUSY;
	if (fh->resources & RESOURCE_VBI)
		goto fail;

	tvnorm = &bttv_tvnorms[btv->tvnorm];

	rc = try_fmt(&frt->fmt.vbi, tvnorm, btv->crop_start);
	if (0 != rc)
		goto fail;

	start1 = frt->fmt.vbi.start[1] - tvnorm->vbistart[1] +
		tvnorm->vbistart[0];

	/* First possible line of video capturing. Should be
	   max(f->start[0] + f->count[0], start1 + f->count[1]) * 2
	   when capturing both fields. But for compatibility we must
	   pretend the VBI and video capture window may overlap,
	   so end = start + 1, the lowest possible value, times two
	   because vbi_fmt.end counts field lines times two. */
	end = max(frt->fmt.vbi.start[0], start1) * 2 + 2;

	mutex_lock(&fh->vbi.vb_lock);

	fh->vbi_fmt.fmt    = frt->fmt.vbi;
	fh->vbi_fmt.tvnorm = tvnorm;
	fh->vbi_fmt.end    = end;

	mutex_unlock(&fh->vbi.vb_lock);

	rc = 0;

 fail:
	mutex_unlock(&btv->lock);

	return rc;
}


int bttv_g_fmt_vbi_cap(struct file *file, void *f, struct v4l2_format *frt)
{
	struct bttv_fh *fh = f;
	const struct bttv_tvnorm *tvnorm;

	frt->fmt.vbi = fh->vbi_fmt.fmt;

	tvnorm = &bttv_tvnorms[fh->btv->tvnorm];

	if (tvnorm != fh->vbi_fmt.tvnorm) {
		__s32 max_end;
		unsigned int i;

		/* As in vbi_buffer_prepare() this imitates the
		   behaviour of earlier driver versions after video
		   standard changes, with default parameters anyway. */

		max_end = (tvnorm->cropcap.bounds.top
			   + tvnorm->cropcap.bounds.height) >> 1;

		frt->fmt.vbi.sampling_rate = tvnorm->Fsc;

		for (i = 0; i < 2; ++i) {
			__s32 new_start;

			new_start = frt->fmt.vbi.start[i]
				+ tvnorm->vbistart[i]
				- fh->vbi_fmt.tvnorm->vbistart[i];

			frt->fmt.vbi.start[i] = min(new_start, max_end - 1);
			frt->fmt.vbi.count[i] =
				min((__s32) frt->fmt.vbi.count[i],
					  max_end - frt->fmt.vbi.start[i]);

			max_end += tvnorm->vbistart[1]
				- tvnorm->vbistart[0];
		}
	}
	return 0;
}

void bttv_vbi_fmt_reset(struct bttv_vbi_fmt *f, unsigned int norm)
{
	const struct bttv_tvnorm *tvnorm;
	unsigned int real_samples_per_line;
	unsigned int real_count;

	tvnorm = &bttv_tvnorms[norm];

	f->fmt.sampling_rate    = tvnorm->Fsc;
	f->fmt.samples_per_line = VBI_BPL;
	f->fmt.sample_format    = V4L2_PIX_FMT_GREY;
	f->fmt.offset           = VBI_OFFSET;
	f->fmt.start[0]		= tvnorm->vbistart[0];
	f->fmt.start[1]		= tvnorm->vbistart[1];
	f->fmt.count[0]		= VBI_DEFLINES;
	f->fmt.count[1]		= VBI_DEFLINES;
	f->fmt.flags            = 0;
	f->fmt.reserved[0]      = 0;
	f->fmt.reserved[1]      = 0;

	/* For compatibility the buffer size must be 2 * VBI_DEFLINES *
	   VBI_BPL regardless of the current video standard. */
	real_samples_per_line   = 1024 + tvnorm->vbipack * 4;
	real_count              = ((tvnorm->cropcap.defrect.top >> 1)
				   - tvnorm->vbistart[0]);

	BUG_ON(real_samples_per_line > VBI_BPL);
	BUG_ON(real_count > VBI_DEFLINES);

	f->tvnorm               = tvnorm;

	/* See bttv_vbi_fmt_set(). */
	f->end                  = tvnorm->vbistart[0] * 2 + 2;
}
Commit	Line	Data
74ba9207	1	// SPDX-License-Identifier: GPL-2.0-or-later
1da177e4	2	/*
1da177e4 LT	3
	4	bttv - Bt848 frame grabber driver
	5	vbi interface
	6
	7	(c) 2002 Gerd Knorr <kraxel@bytesex.org>
	8
e5bd0260 MS	9	Copyright (C) 2005, 2006 Michael H. Schimek <mschimek@gmx.at>
	10	Sponsored by OPQ Systems AB
	11
1da177e4 LT	12	*/
1da177e4 LT	13
8af443e5 JP	14	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
8af443e5 JP	15
1da177e4	16	#include <linux/module.h>
1da177e4 LT	17	#include <linux/errno.h>
	18	#include <linux/fs.h>
	19	#include <linux/kernel.h>
1da177e4 LT	20	#include <linux/interrupt.h>
1da177e4 LT	21	#include <linux/kdev_t.h>
35ea11ff	22	#include <media/v4l2-ioctl.h>
1da177e4 LT	23	#include <asm/io.h>
	24	#include "bttvp.h"
	25
ddecbe11 TP	26	/* Offset from line sync pulse leading edge (0H) to start of VBI capture,
	27	in fCLKx2 pixels. According to the datasheet, VBI capture starts
	28	VBI_HDELAY fCLKx1 pixels from the tailing edgeof /HRESET, and /HRESET
	29	is 64 fCLKx1 pixels wide. VBI_HDELAY is set to 0, so this should be
	30	(64 + 0) * 2 = 128 fCLKx2 pixels. But it's not! The datasheet is
	31	Just Plain Wrong. The real value appears to be different for
	32	different revisions of the bt8x8 chips, and to be affected by the
	33	horizontal scaling factor. Experimentally, the value is measured
	34	to be about 244. */
	35	#define VBI_OFFSET 244
67f1570a	36
e5bd0260 MS	37	/* 2048 for compatibility with earlier driver versions. The driver
	38	really stores 1024 + tvnorm->vbipack * 4 samples per line in the
	39	buffer. Note tvnorm->vbipack is <= 0xFF (limit of VBIPACK_LO + HI
	40	is 0x1FF DWORDs) and VBI read()s store a frame counter in the last
	41	four bytes of the VBI image. */
	42	#define VBI_BPL 2048
	43
	44	/* Compatibility. */
1da177e4	45	#define VBI_DEFLINES 16
1da177e4 LT	46
1da177e4 LT	47	static unsigned int vbibufs = 4;
ff699e6b	48	static unsigned int vbi_debug;
1da177e4 LT	49
	50	module_param(vbibufs, int, 0444);
	51	module_param(vbi_debug, int, 0644);
	52	MODULE_PARM_DESC(vbibufs,"number of vbi buffers, range 2-32, default 4");
	53	MODULE_PARM_DESC(vbi_debug,"vbi code debug messages, default is 0 (no)");
	54
	55	#ifdef dprintk
	56	# undef dprintk
	57	#endif
8af443e5 JP	58	#define dprintk(fmt, ...) \
	59	do { \
	60	if (vbi_debug) \
	61	pr_debug("%d: " fmt, btv->c.nr, ##__VA_ARGS__); \
	62	} while (0)
1da177e4	63
e5bd0260 MS	64	#define IMAGE_SIZE(fmt) \
	65	(((fmt)->count[0] + (fmt)->count[1]) * (fmt)->samples_per_line)
	66
1da177e4 LT	67	/* ----------------------------------------------------------------------- */
	68	/* vbi risc code + mm */
	69
1da177e4 LT	70	static int vbi_buffer_setup(struct videobuf_queue *q,
	71	unsigned int count, unsigned int size)
	72	{
	73	struct bttv_fh *fh = q->priv_data;
	74	struct bttv *btv = fh->btv;
	75
	76	if (0 == *count)
	77	*count = vbibufs;
e5bd0260 MS	78
	79	*size = IMAGE_SIZE(&fh->vbi_fmt.fmt);
	80
	81	dprintk("setup: samples=%u start=%d,%d count=%u,%u\n",
	82	fh->vbi_fmt.fmt.samples_per_line,
	83	fh->vbi_fmt.fmt.start[0],
	84	fh->vbi_fmt.fmt.start[1],
	85	fh->vbi_fmt.fmt.count[0],
	86	fh->vbi_fmt.fmt.count[1]);
	87
1da177e4 LT	88	return 0;
	89	}
	90
	91	static int vbi_buffer_prepare(struct videobuf_queue *q,
	92	struct videobuf_buffer *vb,
	93	enum v4l2_field field)
	94	{
	95	struct bttv_fh *fh = q->priv_data;
	96	struct bttv *btv = fh->btv;
	97	struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
e5bd0260 MS	98	const struct bttv_tvnorm *tvnorm;
	99	unsigned int skip_lines0, skip_lines1, min_vdelay;
	100	int redo_dma_risc;
1da177e4 LT	101	int rc;
1da177e4 LT	102
e5bd0260	103	buf->vb.size = IMAGE_SIZE(&fh->vbi_fmt.fmt);
1da177e4 LT	104	if (0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size)
	105	return -EINVAL;
	106
e5bd0260 MS	107	tvnorm = fh->vbi_fmt.tvnorm;
	108
	109	/* There's no VBI_VDELAY register, RISC must skip the lines
	110	we don't want. With default parameters we skip zero lines
	111	as earlier driver versions did. The driver permits video
	112	standard changes while capturing, so we use vbi_fmt.tvnorm
	113	instead of btv->tvnorm to skip zero lines after video
	114	standard changes as well. */
	115
	116	skip_lines0 = 0;
	117	skip_lines1 = 0;
	118
	119	if (fh->vbi_fmt.fmt.count[0] > 0)
	120	skip_lines0 = max(0, (fh->vbi_fmt.fmt.start[0]
	121	- tvnorm->vbistart[0]));
	122	if (fh->vbi_fmt.fmt.count[1] > 0)
	123	skip_lines1 = max(0, (fh->vbi_fmt.fmt.start[1]
	124	- tvnorm->vbistart[1]));
	125
	126	redo_dma_risc = 0;
	127
	128	if (buf->vbi_skip[0] != skip_lines0 \|\|
	129	buf->vbi_skip[1] != skip_lines1 \|\|
	130	buf->vbi_count[0] != fh->vbi_fmt.fmt.count[0] \|\|
	131	buf->vbi_count[1] != fh->vbi_fmt.fmt.count[1]) {
	132	buf->vbi_skip[0] = skip_lines0;
	133	buf->vbi_skip[1] = skip_lines1;
	134	buf->vbi_count[0] = fh->vbi_fmt.fmt.count[0];
	135	buf->vbi_count[1] = fh->vbi_fmt.fmt.count[1];
	136	redo_dma_risc = 1;
	137	}
	138
0fc0686e	139	if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
e5bd0260	140	redo_dma_risc = 1;
c7b0ac05	141	if (0 != (rc = videobuf_iolock(q, &buf->vb, NULL)))
1da177e4	142	goto fail;
1da177e4	143	}
e5bd0260 MS	144
	145	if (redo_dma_risc) {
	146	unsigned int bpl, padding, offset;
c1accaa2	147	struct videobuf_dmabuf *dma=videobuf_to_dma(&buf->vb);
e5bd0260 MS	148
	149	bpl = 2044; /* max. vbipack */
	150	padding = VBI_BPL - bpl;
	151
	152	if (fh->vbi_fmt.fmt.count[0] > 0) {
	153	rc = bttv_risc_packed(btv, &buf->top,
c1accaa2	154	dma->sglist,
e5bd0260 MS	155	/* offset */ 0, bpl,
	156	padding, skip_lines0,
	157	fh->vbi_fmt.fmt.count[0]);
	158	if (0 != rc)
	159	goto fail;
	160	}
	161
	162	if (fh->vbi_fmt.fmt.count[1] > 0) {
	163	offset = fh->vbi_fmt.fmt.count[0] * VBI_BPL;
	164
	165	rc = bttv_risc_packed(btv, &buf->bottom,
c1accaa2	166	dma->sglist,
e5bd0260 MS	167	offset, bpl,
	168	padding, skip_lines1,
	169	fh->vbi_fmt.fmt.count[1]);
	170	if (0 != rc)
	171	goto fail;
	172	}
	173	}
	174
	175	/* VBI capturing ends at VDELAY, start of video capturing,
	176	no matter where the RISC program ends. VDELAY minimum is 2,
	177	bounds.top is the corresponding first field line number
	178	times two. VDELAY counts half field lines. */
	179	min_vdelay = MIN_VDELAY;
	180	if (fh->vbi_fmt.end >= tvnorm->cropcap.bounds.top)
	181	min_vdelay += fh->vbi_fmt.end - tvnorm->cropcap.bounds.top;
	182
	183	/* For bttv_buffer_activate_vbi(). */
	184	buf->geo.vdelay = min_vdelay;
	185
0fc0686e	186	buf->vb.state = VIDEOBUF_PREPARED;
1da177e4 LT	187	buf->vb.field = field;
	188	dprintk("buf prepare %p: top=%p bottom=%p field=%s\n",
	189	vb, &buf->top, &buf->bottom,
	190	v4l2_field_names[buf->vb.field]);
	191	return 0;
	192
	193	fail:
c7b0ac05	194	bttv_dma_free(q,btv,buf);
1da177e4 LT	195	return rc;
	196	}
	197
	198	static void
	199	vbi_buffer_queue(struct videobuf_queue q, struct videobuf_buffer vb)
	200	{
	201	struct bttv_fh *fh = q->priv_data;
	202	struct bttv *btv = fh->btv;
	203	struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
	204
	205	dprintk("queue %p\n",vb);
0fc0686e	206	buf->vb.state = VIDEOBUF_QUEUED;
1da177e4 LT	207	list_add_tail(&buf->vb.queue,&btv->vcapture);
	208	if (NULL == btv->cvbi) {
	209	fh->btv->loop_irq \|= 4;
	210	bttv_set_dma(btv,0x0c);
	211	}
	212	}
	213
	214	static void vbi_buffer_release(struct videobuf_queue q, struct videobuf_buffer vb)
	215	{
	216	struct bttv_fh *fh = q->priv_data;
	217	struct bttv *btv = fh->btv;
	218	struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
	219
	220	dprintk("free %p\n",vb);
feaba7a9	221	bttv_dma_free(q,fh->btv,buf);
1da177e4 LT	222	}
1da177e4 LT	223
b145ef4f	224	const struct videobuf_queue_ops bttv_vbi_qops = {
1da177e4 LT	225	.buf_setup = vbi_buffer_setup,
	226	.buf_prepare = vbi_buffer_prepare,
	227	.buf_queue = vbi_buffer_queue,
	228	.buf_release = vbi_buffer_release,
	229	};
	230
	231	/* ----------------------------------------------------------------------- */
	232
402aa76a DSL	233	static int try_fmt(struct v4l2_vbi_format f, const struct bttv_tvnorm tvnorm,
402aa76a DSL	234	__s32 crop_start)
1da177e4	235	{
e5bd0260 MS	236	__s32 min_start, max_start, max_end, f2_offset;
	237	unsigned int i;
	238
	239	/* For compatibility with earlier driver versions we must pretend
	240	the VBI and video capture window may overlap. In reality RISC
	241	magic aborts VBI capturing at the first line of video capturing,
	242	leaving the rest of the buffer unchanged, usually all zero.
	243	VBI capturing must always start before video capturing. >> 1
	244	because cropping counts field lines times two. */
	245	min_start = tvnorm->vbistart[0];
	246	max_start = (crop_start >> 1) - 1;
	247	max_end = (tvnorm->cropcap.bounds.top
	248	+ tvnorm->cropcap.bounds.height) >> 1;
	249
	250	if (min_start > max_start)
	251	return -EBUSY;
	252
	253	BUG_ON(max_start >= max_end);
	254
	255	f->sampling_rate = tvnorm->Fsc;
	256	f->samples_per_line = VBI_BPL;
	257	f->sample_format = V4L2_PIX_FMT_GREY;
	258	f->offset = VBI_OFFSET;
	259
	260	f2_offset = tvnorm->vbistart[1] - tvnorm->vbistart[0];
	261
	262	for (i = 0; i < 2; ++i) {
	263	if (0 == f->count[i]) {
	264	/* No data from this field. We leave f->start[i]
	265	alone because VIDIOCSVBIFMT is w/o and EINVALs
	266	when a driver does not support exactly the
	267	requested parameters. */
	268	} else {
	269	s64 start, count;
	270
	271	start = clamp(f->start[i], min_start, max_start);
	272	/* s64 to prevent overflow. */
	273	count = (s64) f->start[i] + f->count[i] - start;
	274	f->start[i] = start;
	275	f->count[i] = clamp(count, (s64) 1,
	276	max_end - start);
	277	}
	278
	279	min_start += f2_offset;
	280	max_start += f2_offset;
	281	max_end += f2_offset;
1da177e4	282	}
e5bd0260 MS	283
	284	if (0 == (f->count[0] \| f->count[1])) {
	285	/* As in earlier driver versions. */
	286	f->start[0] = tvnorm->vbistart[0];
	287	f->start[1] = tvnorm->vbistart[1];
	288	f->count[0] = 1;
	289	f->count[1] = 1;
	290	}
	291
	292	f->flags = 0;
	293
	294	f->reserved[0] = 0;
	295	f->reserved[1] = 0;
	296
	297	return 0;
1da177e4 LT	298	}
1da177e4 LT	299
78b526a4	300	int bttv_try_fmt_vbi_cap(struct file file, void f, struct v4l2_format *frt)
1da177e4	301	{
402aa76a	302	struct bttv_fh *fh = f;
e5bd0260	303	struct bttv *btv = fh->btv;
1da177e4	304	const struct bttv_tvnorm *tvnorm;
e5bd0260	305	__s32 crop_start;
1da177e4	306
e5bd0260 MS	307	mutex_lock(&btv->lock);
	308
	309	tvnorm = &bttv_tvnorms[btv->tvnorm];
	310	crop_start = btv->crop_start;
	311
	312	mutex_unlock(&btv->lock);
	313
402aa76a	314	return try_fmt(&frt->fmt.vbi, tvnorm, crop_start);
1da177e4 LT	315	}
1da177e4 LT	316
402aa76a	317
78b526a4	318	int bttv_s_fmt_vbi_cap(struct file file, void f, struct v4l2_format *frt)
1da177e4	319	{
402aa76a	320	struct bttv_fh *fh = f;
e5bd0260	321	struct bttv *btv = fh->btv;
1da177e4	322	const struct bttv_tvnorm *tvnorm;
e5bd0260 MS	323	__s32 start1, end;
	324	int rc;
	325
	326	mutex_lock(&btv->lock);
	327
	328	rc = -EBUSY;
	329	if (fh->resources & RESOURCE_VBI)
	330	goto fail;
	331
	332	tvnorm = &bttv_tvnorms[btv->tvnorm];
	333
402aa76a	334	rc = try_fmt(&frt->fmt.vbi, tvnorm, btv->crop_start);
e5bd0260 MS	335	if (0 != rc)
	336	goto fail;
	337
402aa76a DSL	338	start1 = frt->fmt.vbi.start[1] - tvnorm->vbistart[1] +
402aa76a DSL	339	tvnorm->vbistart[0];
e5bd0260 MS	340
	341	/* First possible line of video capturing. Should be
	342	max(f->start[0] + f->count[0], start1 + f->count[1]) * 2
	343	when capturing both fields. But for compatibility we must
	344	pretend the VBI and video capture window may overlap,
	345	so end = start + 1, the lowest possible value, times two
	346	because vbi_fmt.end counts field lines times two. */
402aa76a	347	end = max(frt->fmt.vbi.start[0], start1) * 2 + 2;
e5bd0260	348
64f9477f	349	mutex_lock(&fh->vbi.vb_lock);
e5bd0260	350
402aa76a	351	fh->vbi_fmt.fmt = frt->fmt.vbi;
e5bd0260 MS	352	fh->vbi_fmt.tvnorm = tvnorm;
	353	fh->vbi_fmt.end = end;
	354
64f9477f	355	mutex_unlock(&fh->vbi.vb_lock);
e5bd0260 MS	356
	357	rc = 0;
	358
	359	fail:
	360	mutex_unlock(&btv->lock);
	361
	362	return rc;
	363	}
	364
402aa76a	365
78b526a4	366	int bttv_g_fmt_vbi_cap(struct file file, void f, struct v4l2_format *frt)
e5bd0260	367	{
402aa76a	368	struct bttv_fh *fh = f;
e5bd0260 MS	369	const struct bttv_tvnorm *tvnorm;
e5bd0260 MS	370
402aa76a	371	frt->fmt.vbi = fh->vbi_fmt.fmt;
1da177e4 LT	372
1da177e4 LT	373	tvnorm = &bttv_tvnorms[fh->btv->tvnorm];
e5bd0260 MS	374
	375	if (tvnorm != fh->vbi_fmt.tvnorm) {
	376	__s32 max_end;
	377	unsigned int i;
	378
	379	/* As in vbi_buffer_prepare() this imitates the
	380	behaviour of earlier driver versions after video
	381	standard changes, with default parameters anyway. */
	382
	383	max_end = (tvnorm->cropcap.bounds.top
	384	+ tvnorm->cropcap.bounds.height) >> 1;
	385
402aa76a	386	frt->fmt.vbi.sampling_rate = tvnorm->Fsc;
e5bd0260 MS	387
	388	for (i = 0; i < 2; ++i) {
	389	__s32 new_start;
	390
402aa76a	391	new_start = frt->fmt.vbi.start[i]
e5bd0260 MS	392	+ tvnorm->vbistart[i]
	393	- fh->vbi_fmt.tvnorm->vbistart[i];
	394
402aa76a DSL	395	frt->fmt.vbi.start[i] = min(new_start, max_end - 1);
	396	frt->fmt.vbi.count[i] =
	397	min((__s32) frt->fmt.vbi.count[i],
	398	max_end - frt->fmt.vbi.start[i]);
e5bd0260 MS	399
	400	max_end += tvnorm->vbistart[1]
	401	- tvnorm->vbistart[0];
	402	}
	403	}
402aa76a	404	return 0;
e5bd0260 MS	405	}
e5bd0260 MS	406
4ef2ccc2	407	void bttv_vbi_fmt_reset(struct bttv_vbi_fmt *f, unsigned int norm)
e5bd0260 MS	408	{
	409	const struct bttv_tvnorm *tvnorm;
	410	unsigned int real_samples_per_line;
	411	unsigned int real_count;
	412
	413	tvnorm = &bttv_tvnorms[norm];
	414
	415	f->fmt.sampling_rate = tvnorm->Fsc;
	416	f->fmt.samples_per_line = VBI_BPL;
	417	f->fmt.sample_format = V4L2_PIX_FMT_GREY;
	418	f->fmt.offset = VBI_OFFSET;
	419	f->fmt.start[0] = tvnorm->vbistart[0];
	420	f->fmt.start[1] = tvnorm->vbistart[1];
	421	f->fmt.count[0] = VBI_DEFLINES;
	422	f->fmt.count[1] = VBI_DEFLINES;
	423	f->fmt.flags = 0;
	424	f->fmt.reserved[0] = 0;
	425	f->fmt.reserved[1] = 0;
	426
	427	/* For compatibility the buffer size must be 2 * VBI_DEFLINES *
	428	VBI_BPL regardless of the current video standard. */
	429	real_samples_per_line = 1024 + tvnorm->vbipack * 4;
	430	real_count = ((tvnorm->cropcap.defrect.top >> 1)
	431	- tvnorm->vbistart[0]);
	432
	433	BUG_ON(real_samples_per_line > VBI_BPL);
	434	BUG_ON(real_count > VBI_DEFLINES);
	435
	436	f->tvnorm = tvnorm;
	437
	438	/* See bttv_vbi_fmt_set(). */
	439	f->end = tvnorm->vbistart[0] * 2 + 2;
1da177e4	440	}