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 /* 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. */
45 #define VBI_DEFLINES 16
46 
47 static unsigned int vbibufs = 4;
48 static unsigned int vbi_debug;
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
58 #define dprintk(fmt, ...)						\
59 do {									\
60 	if (vbi_debug)							\
61 		pr_debug("%d: " fmt, btv->c.nr, ##__VA_ARGS__);		\
62 } while (0)
63 
64 #define IMAGE_SIZE(fmt) \
65 	(((fmt)->count[0] + (fmt)->count[1]) * (fmt)->samples_per_line)
66 
67 /* ----------------------------------------------------------------------- */
68 /* vbi risc code + mm                                                      */
69 
vbi_buffer_setup(struct videobuf_queue * q,unsigned int * count,unsigned int * size)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;
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 
88 	return 0;
89 }
90 
vbi_buffer_prepare(struct videobuf_queue * q,struct videobuf_buffer * vb,enum v4l2_field field)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);
98 	const struct bttv_tvnorm *tvnorm;
99 	unsigned int skip_lines0, skip_lines1, min_vdelay;
100 	int redo_dma_risc;
101 	int rc;
102 
103 	buf->vb.size = IMAGE_SIZE(&fh->vbi_fmt.fmt);
104 	if (0 != buf->vb.baddr  &&  buf->vb.bsize < buf->vb.size)
105 		return -EINVAL;
106 
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 
139 	if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
140 		redo_dma_risc = 1;
141 		if (0 != (rc = videobuf_iolock(q, &buf->vb, NULL)))
142 			goto fail;
143 	}
144 
145 	if (redo_dma_risc) {
146 		unsigned int bpl, padding, offset;
147 		struct videobuf_dmabuf *dma=videobuf_to_dma(&buf->vb);
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,
154 					      dma->sglist,
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,
166 					      dma->sglist,
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 
186 	buf->vb.state = VIDEOBUF_PREPARED;
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:
194 	bttv_dma_free(q,btv,buf);
195 	return rc;
196 }
197 
198 static void
vbi_buffer_queue(struct videobuf_queue * q,struct videobuf_buffer * vb)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);
206 	buf->vb.state = VIDEOBUF_QUEUED;
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 
vbi_buffer_release(struct videobuf_queue * q,struct videobuf_buffer * vb)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);
221 	bttv_dma_free(q,fh->btv,buf);
222 }
223 
224 const struct videobuf_queue_ops bttv_vbi_qops = {
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 
try_fmt(struct v4l2_vbi_format * f,const struct bttv_tvnorm * tvnorm,__s32 crop_start)233 static int try_fmt(struct v4l2_vbi_format *f, const struct bttv_tvnorm *tvnorm,
234 			__s32 crop_start)
235 {
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;
282 	}
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;
298 }
299 
bttv_try_fmt_vbi_cap(struct file * file,void * f,struct v4l2_format * frt)300 int bttv_try_fmt_vbi_cap(struct file *file, void *f, struct v4l2_format *frt)
301 {
302 	struct bttv_fh *fh = f;
303 	struct bttv *btv = fh->btv;
304 	const struct bttv_tvnorm *tvnorm;
305 	__s32 crop_start;
306 
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 
314 	return try_fmt(&frt->fmt.vbi, tvnorm, crop_start);
315 }
316 
317 
bttv_s_fmt_vbi_cap(struct file * file,void * f,struct v4l2_format * frt)318 int bttv_s_fmt_vbi_cap(struct file *file, void *f, struct v4l2_format *frt)
319 {
320 	struct bttv_fh *fh = f;
321 	struct bttv *btv = fh->btv;
322 	const struct bttv_tvnorm *tvnorm;
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 
334 	rc = try_fmt(&frt->fmt.vbi, tvnorm, btv->crop_start);
335 	if (0 != rc)
336 		goto fail;
337 
338 	start1 = frt->fmt.vbi.start[1] - tvnorm->vbistart[1] +
339 		tvnorm->vbistart[0];
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. */
347 	end = max(frt->fmt.vbi.start[0], start1) * 2 + 2;
348 
349 	mutex_lock(&fh->vbi.vb_lock);
350 
351 	fh->vbi_fmt.fmt    = frt->fmt.vbi;
352 	fh->vbi_fmt.tvnorm = tvnorm;
353 	fh->vbi_fmt.end    = end;
354 
355 	mutex_unlock(&fh->vbi.vb_lock);
356 
357 	rc = 0;
358 
359  fail:
360 	mutex_unlock(&btv->lock);
361 
362 	return rc;
363 }
364 
365 
bttv_g_fmt_vbi_cap(struct file * file,void * f,struct v4l2_format * frt)366 int bttv_g_fmt_vbi_cap(struct file *file, void *f, struct v4l2_format *frt)
367 {
368 	struct bttv_fh *fh = f;
369 	const struct bttv_tvnorm *tvnorm;
370 
371 	frt->fmt.vbi = fh->vbi_fmt.fmt;
372 
373 	tvnorm = &bttv_tvnorms[fh->btv->tvnorm];
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 
386 		frt->fmt.vbi.sampling_rate = tvnorm->Fsc;
387 
388 		for (i = 0; i < 2; ++i) {
389 			__s32 new_start;
390 
391 			new_start = frt->fmt.vbi.start[i]
392 				+ tvnorm->vbistart[i]
393 				- fh->vbi_fmt.tvnorm->vbistart[i];
394 
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]);
399 
400 			max_end += tvnorm->vbistart[1]
401 				- tvnorm->vbistart[0];
402 		}
403 	}
404 	return 0;
405 }
406 
bttv_vbi_fmt_reset(struct bttv_vbi_fmt * f,unsigned int norm)407 void bttv_vbi_fmt_reset(struct bttv_vbi_fmt *f, unsigned int norm)
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;
440 }
441