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