/drivers/media/video/bt8xx/bttv-vbi.c
C | 454 lines | 281 code | 90 blank | 83 comment | 40 complexity | 4e9e22b8b7a3a0a252e6df71d49e8c32 MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.0, AGPL-1.0
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/errno.h>
28#include <linux/fs.h>
29#include <linux/kernel.h>
30#include <linux/interrupt.h>
31#include <linux/kdev_t.h>
32#include <media/v4l2-ioctl.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;
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 (VIDEOBUF_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 struct videobuf_dmabuf *dma=videobuf_to_dma(&buf->vb);
155
156 bpl = 2044; /* max. vbipack */
157 padding = VBI_BPL - bpl;
158
159 if (fh->vbi_fmt.fmt.count[0] > 0) {
160 rc = bttv_risc_packed(btv, &buf->top,
161 dma->sglist,
162 /* offset */ 0, bpl,
163 padding, skip_lines0,
164 fh->vbi_fmt.fmt.count[0]);
165 if (0 != rc)
166 goto fail;
167 }
168
169 if (fh->vbi_fmt.fmt.count[1] > 0) {
170 offset = fh->vbi_fmt.fmt.count[0] * VBI_BPL;
171
172 rc = bttv_risc_packed(btv, &buf->bottom,
173 dma->sglist,
174 offset, bpl,
175 padding, skip_lines1,
176 fh->vbi_fmt.fmt.count[1]);
177 if (0 != rc)
178 goto fail;
179 }
180 }
181
182 /* VBI capturing ends at VDELAY, start of video capturing,
183 no matter where the RISC program ends. VDELAY minimum is 2,
184 bounds.top is the corresponding first field line number
185 times two. VDELAY counts half field lines. */
186 min_vdelay = MIN_VDELAY;
187 if (fh->vbi_fmt.end >= tvnorm->cropcap.bounds.top)
188 min_vdelay += fh->vbi_fmt.end - tvnorm->cropcap.bounds.top;
189
190 /* For bttv_buffer_activate_vbi(). */
191 buf->geo.vdelay = min_vdelay;
192
193 buf->vb.state = VIDEOBUF_PREPARED;
194 buf->vb.field = field;
195 dprintk("buf prepare %p: top=%p bottom=%p field=%s\n",
196 vb, &buf->top, &buf->bottom,
197 v4l2_field_names[buf->vb.field]);
198 return 0;
199
200 fail:
201 bttv_dma_free(q,btv,buf);
202 return rc;
203}
204
205static void
206vbi_buffer_queue(struct videobuf_queue *q, struct videobuf_buffer *vb)
207{
208 struct bttv_fh *fh = q->priv_data;
209 struct bttv *btv = fh->btv;
210 struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
211
212 dprintk("queue %p\n",vb);
213 buf->vb.state = VIDEOBUF_QUEUED;
214 list_add_tail(&buf->vb.queue,&btv->vcapture);
215 if (NULL == btv->cvbi) {
216 fh->btv->loop_irq |= 4;
217 bttv_set_dma(btv,0x0c);
218 }
219}
220
221static void vbi_buffer_release(struct videobuf_queue *q, struct videobuf_buffer *vb)
222{
223 struct bttv_fh *fh = q->priv_data;
224 struct bttv *btv = fh->btv;
225 struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
226
227 dprintk("free %p\n",vb);
228 bttv_dma_free(q,fh->btv,buf);
229}
230
231struct videobuf_queue_ops bttv_vbi_qops = {
232 .buf_setup = vbi_buffer_setup,
233 .buf_prepare = vbi_buffer_prepare,
234 .buf_queue = vbi_buffer_queue,
235 .buf_release = vbi_buffer_release,
236};
237
238/* ----------------------------------------------------------------------- */
239
240static int try_fmt(struct v4l2_vbi_format *f, const struct bttv_tvnorm *tvnorm,
241 __s32 crop_start)
242{
243 __s32 min_start, max_start, max_end, f2_offset;
244 unsigned int i;
245
246 /* For compatibility with earlier driver versions we must pretend
247 the VBI and video capture window may overlap. In reality RISC
248 magic aborts VBI capturing at the first line of video capturing,
249 leaving the rest of the buffer unchanged, usually all zero.
250 VBI capturing must always start before video capturing. >> 1
251 because cropping counts field lines times two. */
252 min_start = tvnorm->vbistart[0];
253 max_start = (crop_start >> 1) - 1;
254 max_end = (tvnorm->cropcap.bounds.top
255 + tvnorm->cropcap.bounds.height) >> 1;
256
257 if (min_start > max_start)
258 return -EBUSY;
259
260 BUG_ON(max_start >= max_end);
261
262 f->sampling_rate = tvnorm->Fsc;
263 f->samples_per_line = VBI_BPL;
264 f->sample_format = V4L2_PIX_FMT_GREY;
265 f->offset = VBI_OFFSET;
266
267 f2_offset = tvnorm->vbistart[1] - tvnorm->vbistart[0];
268
269 for (i = 0; i < 2; ++i) {
270 if (0 == f->count[i]) {
271 /* No data from this field. We leave f->start[i]
272 alone because VIDIOCSVBIFMT is w/o and EINVALs
273 when a driver does not support exactly the
274 requested parameters. */
275 } else {
276 s64 start, count;
277
278 start = clamp(f->start[i], min_start, max_start);
279 /* s64 to prevent overflow. */
280 count = (s64) f->start[i] + f->count[i] - start;
281 f->start[i] = start;
282 f->count[i] = clamp(count, (s64) 1,
283 max_end - start);
284 }
285
286 min_start += f2_offset;
287 max_start += f2_offset;
288 max_end += f2_offset;
289 }
290
291 if (0 == (f->count[0] | f->count[1])) {
292 /* As in earlier driver versions. */
293 f->start[0] = tvnorm->vbistart[0];
294 f->start[1] = tvnorm->vbistart[1];
295 f->count[0] = 1;
296 f->count[1] = 1;
297 }
298
299 f->flags = 0;
300
301 f->reserved[0] = 0;
302 f->reserved[1] = 0;
303
304 return 0;
305}
306
307int bttv_try_fmt_vbi_cap(struct file *file, void *f, struct v4l2_format *frt)
308{
309 struct bttv_fh *fh = f;
310 struct bttv *btv = fh->btv;
311 const struct bttv_tvnorm *tvnorm;
312 __s32 crop_start;
313
314 mutex_lock(&btv->lock);
315
316 tvnorm = &bttv_tvnorms[btv->tvnorm];
317 crop_start = btv->crop_start;
318
319 mutex_unlock(&btv->lock);
320
321 return try_fmt(&frt->fmt.vbi, tvnorm, crop_start);
322}
323
324
325int bttv_s_fmt_vbi_cap(struct file *file, void *f, struct v4l2_format *frt)
326{
327 struct bttv_fh *fh = f;
328 struct bttv *btv = fh->btv;
329 const struct bttv_tvnorm *tvnorm;
330 __s32 start1, end;
331 int rc;
332
333 mutex_lock(&btv->lock);
334
335 rc = -EBUSY;
336 if (fh->resources & RESOURCE_VBI)
337 goto fail;
338
339 tvnorm = &bttv_tvnorms[btv->tvnorm];
340
341 rc = try_fmt(&frt->fmt.vbi, tvnorm, btv->crop_start);
342 if (0 != rc)
343 goto fail;
344
345 start1 = frt->fmt.vbi.start[1] - tvnorm->vbistart[1] +
346 tvnorm->vbistart[0];
347
348 /* First possible line of video capturing. Should be
349 max(f->start[0] + f->count[0], start1 + f->count[1]) * 2
350 when capturing both fields. But for compatibility we must
351 pretend the VBI and video capture window may overlap,
352 so end = start + 1, the lowest possible value, times two
353 because vbi_fmt.end counts field lines times two. */
354 end = max(frt->fmt.vbi.start[0], start1) * 2 + 2;
355
356 mutex_lock(&fh->vbi.vb_lock);
357
358 fh->vbi_fmt.fmt = frt->fmt.vbi;
359 fh->vbi_fmt.tvnorm = tvnorm;
360 fh->vbi_fmt.end = end;
361
362 mutex_unlock(&fh->vbi.vb_lock);
363
364 rc = 0;
365
366 fail:
367 mutex_unlock(&btv->lock);
368
369 return rc;
370}
371
372
373int bttv_g_fmt_vbi_cap(struct file *file, void *f, struct v4l2_format *frt)
374{
375 struct bttv_fh *fh = f;
376 const struct bttv_tvnorm *tvnorm;
377
378 frt->fmt.vbi = fh->vbi_fmt.fmt;
379
380 tvnorm = &bttv_tvnorms[fh->btv->tvnorm];
381
382 if (tvnorm != fh->vbi_fmt.tvnorm) {
383 __s32 max_end;
384 unsigned int i;
385
386 /* As in vbi_buffer_prepare() this imitates the
387 behaviour of earlier driver versions after video
388 standard changes, with default parameters anyway. */
389
390 max_end = (tvnorm->cropcap.bounds.top
391 + tvnorm->cropcap.bounds.height) >> 1;
392
393 frt->fmt.vbi.sampling_rate = tvnorm->Fsc;
394
395 for (i = 0; i < 2; ++i) {
396 __s32 new_start;
397
398 new_start = frt->fmt.vbi.start[i]
399 + tvnorm->vbistart[i]
400 - fh->vbi_fmt.tvnorm->vbistart[i];
401
402 frt->fmt.vbi.start[i] = min(new_start, max_end - 1);
403 frt->fmt.vbi.count[i] =
404 min((__s32) frt->fmt.vbi.count[i],
405 max_end - frt->fmt.vbi.start[i]);
406
407 max_end += tvnorm->vbistart[1]
408 - tvnorm->vbistart[0];
409 }
410 }
411 return 0;
412}
413
414void bttv_vbi_fmt_reset(struct bttv_vbi_fmt *f, unsigned int norm)
415{
416 const struct bttv_tvnorm *tvnorm;
417 unsigned int real_samples_per_line;
418 unsigned int real_count;
419
420 tvnorm = &bttv_tvnorms[norm];
421
422 f->fmt.sampling_rate = tvnorm->Fsc;
423 f->fmt.samples_per_line = VBI_BPL;
424 f->fmt.sample_format = V4L2_PIX_FMT_GREY;
425 f->fmt.offset = VBI_OFFSET;
426 f->fmt.start[0] = tvnorm->vbistart[0];
427 f->fmt.start[1] = tvnorm->vbistart[1];
428 f->fmt.count[0] = VBI_DEFLINES;
429 f->fmt.count[1] = VBI_DEFLINES;
430 f->fmt.flags = 0;
431 f->fmt.reserved[0] = 0;
432 f->fmt.reserved[1] = 0;
433
434 /* For compatibility the buffer size must be 2 * VBI_DEFLINES *
435 VBI_BPL regardless of the current video standard. */
436 real_samples_per_line = 1024 + tvnorm->vbipack * 4;
437 real_count = ((tvnorm->cropcap.defrect.top >> 1)
438 - tvnorm->vbistart[0]);
439
440 BUG_ON(real_samples_per_line > VBI_BPL);
441 BUG_ON(real_count > VBI_DEFLINES);
442
443 f->tvnorm = tvnorm;
444
445 /* See bttv_vbi_fmt_set(). */
446 f->end = tvnorm->vbistart[0] * 2 + 2;
447}
448
449/* ----------------------------------------------------------------------- */
450/*
451 * Local variables:
452 * c-basic-offset: 8
453 * End:
454 */