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 | |
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 | |
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(q: 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(head: &btv->vcapture)) { |
85 | btv->loop_irq = BT848_RISC_VBI; |
86 | if (vb2_is_streaming(q: &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(new: &buf->list, head: &btv->vcapture); |
92 | spin_unlock_irqrestore(lock: &btv->s_lock, flags); |
93 | } |
94 | |
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(q: 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, plane_no: 0) < size) |
105 | return -EINVAL; |
106 | vb2_set_plane_payload(vb, plane_no: 0, size); |
107 | buf->vbuf.field = V4L2_FIELD_NONE; |
108 | ret = bttv_buffer_risc_vbi(btv, buf); |
109 | |
110 | return ret; |
111 | } |
112 | |
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(q: vq); |
119 | |
120 | btcx_riscmem_free(pci: btv->c.pci, risc: &buf->top); |
121 | btcx_riscmem_free(pci: btv->c.pci, risc: &buf->bottom); |
122 | } |
123 | |
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(head: &btv->vcapture)) { |
135 | buf = list_entry(btv->vcapture.next, |
136 | struct bttv_buffer, list); |
137 | list_del(entry: &buf->list); |
138 | buf->vbuf.sequence = (btv->field_count >> 1) + seqnr++; |
139 | vb2_buffer_done(vb: &buf->vbuf.vb2_buf, |
140 | state: VB2_BUF_STATE_QUEUED); |
141 | } |
142 | return -EBUSY; |
143 | } |
144 | if (!vb2_is_streaming(q: &btv->capq)) { |
145 | init_irqreg(btv); |
146 | btv->field_count = 0; |
147 | } |
148 | return 0; |
149 | } |
150 | |
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(q: &btv->capq)) { |
160 | /* stop field counter */ |
161 | btand(~BT848_INT_VSYNC, BT848_INT_MASK); |
162 | } |
163 | spin_unlock_irqrestore(lock: &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 | |
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 | |
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(lock: &btv->lock); |
258 | |
259 | return try_fmt(f: &frt->fmt.vbi, tvnorm, crop_start); |
260 | } |
261 | |
262 | |
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(f: &frt->fmt.vbi, tvnorm, crop_start: 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(lock: &btv->lock); |
301 | |
302 | return rc; |
303 | } |
304 | |
305 | |
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 | |
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 | |