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