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 | */ |
13 | ||
8af443e5 JP |
14 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
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> |
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 | |
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; |
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 | } |
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, |
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 | } |
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 | } |
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] + |
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; |
370 | ||
402aa76a | 371 | frt->fmt.vbi = fh->vbi_fmt.fmt; |
1da177e4 LT |
372 | |
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 | } |
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 | } |