xref: /openbmc/linux/drivers/media/pci/bt8xx/bttv-vbi.c (revision e8fa30fa)
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