1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3
4 bttv - Bt848 frame grabber driver
5 vbi interface
6
7 (c) 2002 Gerd Knorr <kraxel@bytesex.org>
8
9 Copyright (C) 2005, 2006 Michael H. Schimek <mschimek@gmx.at>
10 Sponsored by OPQ Systems AB
11
12 */
13
14 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
15
16 #include <linux/module.h>
17 #include <linux/errno.h>
18 #include <linux/fs.h>
19 #include <linux/kernel.h>
20 #include <linux/interrupt.h>
21 #include <linux/kdev_t.h>
22 #include <media/v4l2-ioctl.h>
23 #include <asm/io.h>
24 #include "bttvp.h"
25
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
36
37 static unsigned int vbibufs = 4;
38 static unsigned int vbi_debug;
39
40 module_param(vbibufs, int, 0444);
41 module_param(vbi_debug, int, 0644);
42 MODULE_PARM_DESC(vbibufs,"number of vbi buffers, range 2-32, default 4");
43 MODULE_PARM_DESC(vbi_debug,"vbi code debug messages, default is 0 (no)");
44
45 #ifdef dprintk
46 # undef dprintk
47 #endif
48 #define dprintk(fmt, ...) \
49 do { \
50 if (vbi_debug) \
51 pr_debug("%d: " fmt, btv->c.nr, ##__VA_ARGS__); \
52 } while (0)
53
54 #define IMAGE_SIZE(fmt) \
55 (((fmt)->count[0] + (fmt)->count[1]) * (fmt)->samples_per_line)
56
57 /* ----------------------------------------------------------------------- */
58 /* vbi risc code + mm */
59
queue_setup_vbi(struct vb2_queue * q,unsigned int * num_buffers,unsigned int * num_planes,unsigned int sizes[],struct device * alloc_devs[])60 static int queue_setup_vbi(struct vb2_queue *q, unsigned int *num_buffers,
61 unsigned int *num_planes, unsigned int sizes[],
62 struct device *alloc_devs[])
63 {
64 struct bttv *btv = vb2_get_drv_priv(q);
65 unsigned int size = IMAGE_SIZE(&btv->vbi_fmt.fmt);
66
67 if (*num_planes)
68 return sizes[0] < size ? -EINVAL : 0;
69 *num_planes = 1;
70 sizes[0] = size;
71
72 return 0;
73 }
74
buf_queue_vbi(struct vb2_buffer * vb)75 static void buf_queue_vbi(struct vb2_buffer *vb)
76 {
77 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
78 struct vb2_queue *vq = vb->vb2_queue;
79 struct bttv *btv = vb2_get_drv_priv(vq);
80 struct bttv_buffer *buf = container_of(vbuf, struct bttv_buffer, vbuf);
81 unsigned long flags;
82
83 spin_lock_irqsave(&btv->s_lock, flags);
84 if (list_empty(&btv->vcapture)) {
85 btv->loop_irq = BT848_RISC_VBI;
86 if (vb2_is_streaming(&btv->capq))
87 btv->loop_irq |= BT848_RISC_VIDEO;
88 bttv_set_dma(btv, BT848_CAP_CTL_CAPTURE_VBI_ODD |
89 BT848_CAP_CTL_CAPTURE_VBI_EVEN);
90 }
91 list_add_tail(&buf->list, &btv->vcapture);
92 spin_unlock_irqrestore(&btv->s_lock, flags);
93 }
94
buf_prepare_vbi(struct vb2_buffer * vb)95 static int buf_prepare_vbi(struct vb2_buffer *vb)
96 {
97 int ret = 0;
98 struct vb2_queue *vq = vb->vb2_queue;
99 struct bttv *btv = vb2_get_drv_priv(vq);
100 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
101 struct bttv_buffer *buf = container_of(vbuf, struct bttv_buffer, vbuf);
102 unsigned int size = IMAGE_SIZE(&btv->vbi_fmt.fmt);
103
104 if (vb2_plane_size(vb, 0) < size)
105 return -EINVAL;
106 vb2_set_plane_payload(vb, 0, size);
107 buf->vbuf.field = V4L2_FIELD_NONE;
108 ret = bttv_buffer_risc_vbi(btv, buf);
109
110 return ret;
111 }
112
buf_cleanup_vbi(struct vb2_buffer * vb)113 static void buf_cleanup_vbi(struct vb2_buffer *vb)
114 {
115 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
116 struct bttv_buffer *buf = container_of(vbuf, struct bttv_buffer, vbuf);
117 struct vb2_queue *vq = vb->vb2_queue;
118 struct bttv *btv = vb2_get_drv_priv(vq);
119
120 btcx_riscmem_free(btv->c.pci, &buf->top);
121 btcx_riscmem_free(btv->c.pci, &buf->bottom);
122 }
123
start_streaming_vbi(struct vb2_queue * q,unsigned int count)124 static int start_streaming_vbi(struct vb2_queue *q, unsigned int count)
125 {
126 int seqnr = 0;
127 struct bttv_buffer *buf;
128 struct bttv *btv = vb2_get_drv_priv(q);
129
130 btv->framedrop = 0;
131 if (!check_alloc_btres_lock(btv, RESOURCE_VBI)) {
132 if (btv->field_count)
133 seqnr++;
134 while (!list_empty(&btv->vcapture)) {
135 buf = list_entry(btv->vcapture.next,
136 struct bttv_buffer, list);
137 list_del(&buf->list);
138 buf->vbuf.sequence = (btv->field_count >> 1) + seqnr++;
139 vb2_buffer_done(&buf->vbuf.vb2_buf,
140 VB2_BUF_STATE_QUEUED);
141 }
142 return -EBUSY;
143 }
144 if (!vb2_is_streaming(&btv->capq)) {
145 init_irqreg(btv);
146 btv->field_count = 0;
147 }
148 return 0;
149 }
150
stop_streaming_vbi(struct vb2_queue * q)151 static void stop_streaming_vbi(struct vb2_queue *q)
152 {
153 struct bttv *btv = vb2_get_drv_priv(q);
154 unsigned long flags;
155
156 vb2_wait_for_all_buffers(q);
157 spin_lock_irqsave(&btv->s_lock, flags);
158 free_btres_lock(btv, RESOURCE_VBI);
159 if (!vb2_is_streaming(&btv->capq)) {
160 /* stop field counter */
161 btand(~BT848_INT_VSYNC, BT848_INT_MASK);
162 }
163 spin_unlock_irqrestore(&btv->s_lock, flags);
164 }
165
166 const struct vb2_ops bttv_vbi_qops = {
167 .queue_setup = queue_setup_vbi,
168 .buf_queue = buf_queue_vbi,
169 .buf_prepare = buf_prepare_vbi,
170 .buf_cleanup = buf_cleanup_vbi,
171 .start_streaming = start_streaming_vbi,
172 .stop_streaming = stop_streaming_vbi,
173 .wait_prepare = vb2_ops_wait_prepare,
174 .wait_finish = vb2_ops_wait_finish,
175 };
176
177 /* ----------------------------------------------------------------------- */
178
try_fmt(struct v4l2_vbi_format * f,const struct bttv_tvnorm * tvnorm,__s32 crop_start)179 static int try_fmt(struct v4l2_vbi_format *f, const struct bttv_tvnorm *tvnorm,
180 __s32 crop_start)
181 {
182 __s32 min_start, max_start, max_end, f2_offset;
183 unsigned int i;
184
185 /* For compatibility with earlier driver versions we must pretend
186 the VBI and video capture window may overlap. In reality RISC
187 magic aborts VBI capturing at the first line of video capturing,
188 leaving the rest of the buffer unchanged, usually all zero.
189 VBI capturing must always start before video capturing. >> 1
190 because cropping counts field lines times two. */
191 min_start = tvnorm->vbistart[0];
192 max_start = (crop_start >> 1) - 1;
193 max_end = (tvnorm->cropcap.bounds.top
194 + tvnorm->cropcap.bounds.height) >> 1;
195
196 if (min_start > max_start)
197 return -EBUSY;
198
199 WARN_ON(max_start >= max_end);
200
201 f->sampling_rate = tvnorm->Fsc;
202 f->samples_per_line = VBI_BPL;
203 f->sample_format = V4L2_PIX_FMT_GREY;
204 f->offset = VBI_OFFSET;
205
206 f2_offset = tvnorm->vbistart[1] - tvnorm->vbistart[0];
207
208 for (i = 0; i < 2; ++i) {
209 if (0 == f->count[i]) {
210 /* No data from this field. We leave f->start[i]
211 alone because VIDIOCSVBIFMT is w/o and EINVALs
212 when a driver does not support exactly the
213 requested parameters. */
214 } else {
215 s64 start, count;
216
217 start = clamp(f->start[i], min_start, max_start);
218 /* s64 to prevent overflow. */
219 count = (s64) f->start[i] + f->count[i] - start;
220 f->start[i] = start;
221 f->count[i] = clamp(count, (s64) 1,
222 max_end - start);
223 }
224
225 min_start += f2_offset;
226 max_start += f2_offset;
227 max_end += f2_offset;
228 }
229
230 if (0 == (f->count[0] | f->count[1])) {
231 /* As in earlier driver versions. */
232 f->start[0] = tvnorm->vbistart[0];
233 f->start[1] = tvnorm->vbistart[1];
234 f->count[0] = 1;
235 f->count[1] = 1;
236 }
237
238 f->flags = 0;
239
240 f->reserved[0] = 0;
241 f->reserved[1] = 0;
242
243 return 0;
244 }
245
bttv_try_fmt_vbi_cap(struct file * file,void * f,struct v4l2_format * frt)246 int bttv_try_fmt_vbi_cap(struct file *file, void *f, struct v4l2_format *frt)
247 {
248 struct bttv *btv = video_drvdata(file);
249 const struct bttv_tvnorm *tvnorm;
250 __s32 crop_start;
251
252 mutex_lock(&btv->lock);
253
254 tvnorm = &bttv_tvnorms[btv->tvnorm];
255 crop_start = btv->crop_start;
256
257 mutex_unlock(&btv->lock);
258
259 return try_fmt(&frt->fmt.vbi, tvnorm, crop_start);
260 }
261
262
bttv_s_fmt_vbi_cap(struct file * file,void * f,struct v4l2_format * frt)263 int bttv_s_fmt_vbi_cap(struct file *file, void *f, struct v4l2_format *frt)
264 {
265 struct bttv *btv = video_drvdata(file);
266 const struct bttv_tvnorm *tvnorm;
267 __s32 start1, end;
268 int rc;
269
270 mutex_lock(&btv->lock);
271
272 rc = -EBUSY;
273 if (btv->resources & RESOURCE_VBI)
274 goto fail;
275
276 tvnorm = &bttv_tvnorms[btv->tvnorm];
277
278 rc = try_fmt(&frt->fmt.vbi, tvnorm, btv->crop_start);
279 if (0 != rc)
280 goto fail;
281
282 start1 = frt->fmt.vbi.start[1] - tvnorm->vbistart[1] +
283 tvnorm->vbistart[0];
284
285 /* First possible line of video capturing. Should be
286 max(f->start[0] + f->count[0], start1 + f->count[1]) * 2
287 when capturing both fields. But for compatibility we must
288 pretend the VBI and video capture window may overlap,
289 so end = start + 1, the lowest possible value, times two
290 because vbi_fmt.end counts field lines times two. */
291 end = max(frt->fmt.vbi.start[0], start1) * 2 + 2;
292
293 btv->vbi_fmt.fmt = frt->fmt.vbi;
294 btv->vbi_fmt.tvnorm = tvnorm;
295 btv->vbi_fmt.end = end;
296
297 rc = 0;
298
299 fail:
300 mutex_unlock(&btv->lock);
301
302 return rc;
303 }
304
305
bttv_g_fmt_vbi_cap(struct file * file,void * f,struct v4l2_format * frt)306 int bttv_g_fmt_vbi_cap(struct file *file, void *f, struct v4l2_format *frt)
307 {
308 const struct bttv_tvnorm *tvnorm;
309 struct bttv *btv = video_drvdata(file);
310
311 frt->fmt.vbi = btv->vbi_fmt.fmt;
312
313 tvnorm = &bttv_tvnorms[btv->tvnorm];
314
315 if (tvnorm != btv->vbi_fmt.tvnorm) {
316 __s32 max_end;
317 unsigned int i;
318
319 /* As in vbi_buffer_prepare() this imitates the
320 behaviour of earlier driver versions after video
321 standard changes, with default parameters anyway. */
322
323 max_end = (tvnorm->cropcap.bounds.top
324 + tvnorm->cropcap.bounds.height) >> 1;
325
326 frt->fmt.vbi.sampling_rate = tvnorm->Fsc;
327
328 for (i = 0; i < 2; ++i) {
329 __s32 new_start;
330
331 new_start = frt->fmt.vbi.start[i] + tvnorm->vbistart[i]
332 - btv->vbi_fmt.tvnorm->vbistart[i];
333
334 frt->fmt.vbi.start[i] = min(new_start, max_end - 1);
335 frt->fmt.vbi.count[i] =
336 min((__s32) frt->fmt.vbi.count[i],
337 max_end - frt->fmt.vbi.start[i]);
338
339 max_end += tvnorm->vbistart[1]
340 - tvnorm->vbistart[0];
341 }
342 }
343 return 0;
344 }
345
bttv_vbi_fmt_reset(struct bttv_vbi_fmt * f,unsigned int norm)346 void bttv_vbi_fmt_reset(struct bttv_vbi_fmt *f, unsigned int norm)
347 {
348 const struct bttv_tvnorm *tvnorm;
349 unsigned int real_samples_per_line;
350 unsigned int real_count;
351
352 tvnorm = &bttv_tvnorms[norm];
353
354 f->fmt.sampling_rate = tvnorm->Fsc;
355 f->fmt.samples_per_line = VBI_BPL;
356 f->fmt.sample_format = V4L2_PIX_FMT_GREY;
357 f->fmt.offset = VBI_OFFSET;
358 f->fmt.start[0] = tvnorm->vbistart[0];
359 f->fmt.start[1] = tvnorm->vbistart[1];
360 f->fmt.count[0] = VBI_DEFLINES;
361 f->fmt.count[1] = VBI_DEFLINES;
362 f->fmt.flags = 0;
363 f->fmt.reserved[0] = 0;
364 f->fmt.reserved[1] = 0;
365
366 /* For compatibility the buffer size must be 2 * VBI_DEFLINES *
367 VBI_BPL regardless of the current video standard. */
368 real_samples_per_line = 1024 + tvnorm->vbipack * 4;
369 real_count = ((tvnorm->cropcap.defrect.top >> 1)
370 - tvnorm->vbistart[0]);
371
372 WARN_ON(real_samples_per_line > VBI_BPL);
373 WARN_ON(real_count > VBI_DEFLINES);
374
375 f->tvnorm = tvnorm;
376
377 /* See bttv_vbi_fmt_set(). */
378 f->end = tvnorm->vbistart[0] * 2 + 2;
379 }
380