1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3     Vertical Blank Interval support functions
4     Copyright (C) 2004-2007  Hans Verkuil <hverkuil@xs4all.nl>
5 
6  */
7 
8 #include "ivtv-driver.h"
9 #include "ivtv-i2c.h"
10 #include "ivtv-ioctl.h"
11 #include "ivtv-queue.h"
12 #include "ivtv-cards.h"
13 #include "ivtv-vbi.h"
14 
ivtv_set_vps(struct ivtv * itv,int enabled)15 static void ivtv_set_vps(struct ivtv *itv, int enabled)
16 {
17 	struct v4l2_sliced_vbi_data data;
18 
19 	if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
20 		return;
21 	data.id = V4L2_SLICED_VPS;
22 	data.field = 0;
23 	data.line = enabled ? 16 : 0;
24 	data.data[2] = itv->vbi.vps_payload.data[0];
25 	data.data[8] = itv->vbi.vps_payload.data[1];
26 	data.data[9] = itv->vbi.vps_payload.data[2];
27 	data.data[10] = itv->vbi.vps_payload.data[3];
28 	data.data[11] = itv->vbi.vps_payload.data[4];
29 	ivtv_call_hw(itv, IVTV_HW_SAA7127, vbi, s_vbi_data, &data);
30 }
31 
ivtv_set_cc(struct ivtv * itv,int mode,const struct vbi_cc * cc)32 static void ivtv_set_cc(struct ivtv *itv, int mode, const struct vbi_cc *cc)
33 {
34 	struct v4l2_sliced_vbi_data data;
35 
36 	if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
37 		return;
38 	data.id = V4L2_SLICED_CAPTION_525;
39 	data.field = 0;
40 	data.line = (mode & 1) ? 21 : 0;
41 	data.data[0] = cc->odd[0];
42 	data.data[1] = cc->odd[1];
43 	ivtv_call_hw(itv, IVTV_HW_SAA7127, vbi, s_vbi_data, &data);
44 	data.field = 1;
45 	data.line = (mode & 2) ? 21 : 0;
46 	data.data[0] = cc->even[0];
47 	data.data[1] = cc->even[1];
48 	ivtv_call_hw(itv, IVTV_HW_SAA7127, vbi, s_vbi_data, &data);
49 }
50 
ivtv_set_wss(struct ivtv * itv,int enabled,int mode)51 static void ivtv_set_wss(struct ivtv *itv, int enabled, int mode)
52 {
53 	struct v4l2_sliced_vbi_data data;
54 
55 	if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
56 		return;
57 	/* When using a 50 Hz system, always turn on the
58 	   wide screen signal with 4x3 ratio as the default.
59 	   Turning this signal on and off can confuse certain
60 	   TVs. As far as I can tell there is no reason not to
61 	   transmit this signal. */
62 	if ((itv->std_out & V4L2_STD_625_50) && !enabled) {
63 		enabled = 1;
64 		mode = 0x08;  /* 4x3 full format */
65 	}
66 	data.id = V4L2_SLICED_WSS_625;
67 	data.field = 0;
68 	data.line = enabled ? 23 : 0;
69 	data.data[0] = mode & 0xff;
70 	data.data[1] = (mode >> 8) & 0xff;
71 	ivtv_call_hw(itv, IVTV_HW_SAA7127, vbi, s_vbi_data, &data);
72 }
73 
odd_parity(u8 c)74 static int odd_parity(u8 c)
75 {
76 	c ^= (c >> 4);
77 	c ^= (c >> 2);
78 	c ^= (c >> 1);
79 
80 	return c & 1;
81 }
82 
ivtv_write_vbi_line(struct ivtv * itv,const struct v4l2_sliced_vbi_data * d,struct vbi_cc * cc,int * found_cc)83 static void ivtv_write_vbi_line(struct ivtv *itv,
84 				const struct v4l2_sliced_vbi_data *d,
85 				struct vbi_cc *cc, int *found_cc)
86 {
87 	struct vbi_info *vi = &itv->vbi;
88 
89 	if (d->id == V4L2_SLICED_CAPTION_525 && d->line == 21) {
90 		if (d->field) {
91 			cc->even[0] = d->data[0];
92 			cc->even[1] = d->data[1];
93 		} else {
94 			cc->odd[0] = d->data[0];
95 			cc->odd[1] = d->data[1];
96 		}
97 		*found_cc = 1;
98 	} else if (d->id == V4L2_SLICED_VPS && d->line == 16 && d->field == 0) {
99 		struct vbi_vps vps;
100 
101 		vps.data[0] = d->data[2];
102 		vps.data[1] = d->data[8];
103 		vps.data[2] = d->data[9];
104 		vps.data[3] = d->data[10];
105 		vps.data[4] = d->data[11];
106 		if (memcmp(&vps, &vi->vps_payload, sizeof(vps))) {
107 			vi->vps_payload = vps;
108 			set_bit(IVTV_F_I_UPDATE_VPS, &itv->i_flags);
109 		}
110 	} else if (d->id == V4L2_SLICED_WSS_625 &&
111 		   d->line == 23 && d->field == 0) {
112 		int wss = d->data[0] | d->data[1] << 8;
113 
114 		if (vi->wss_payload != wss) {
115 			vi->wss_payload = wss;
116 			set_bit(IVTV_F_I_UPDATE_WSS, &itv->i_flags);
117 		}
118 	}
119 }
120 
ivtv_write_vbi_cc_lines(struct ivtv * itv,const struct vbi_cc * cc)121 static void ivtv_write_vbi_cc_lines(struct ivtv *itv, const struct vbi_cc *cc)
122 {
123 	struct vbi_info *vi = &itv->vbi;
124 
125 	if (vi->cc_payload_idx < ARRAY_SIZE(vi->cc_payload)) {
126 		memcpy(&vi->cc_payload[vi->cc_payload_idx], cc,
127 		       sizeof(struct vbi_cc));
128 		vi->cc_payload_idx++;
129 		set_bit(IVTV_F_I_UPDATE_CC, &itv->i_flags);
130 	}
131 }
132 
ivtv_write_vbi(struct ivtv * itv,const struct v4l2_sliced_vbi_data * sliced,size_t cnt)133 static void ivtv_write_vbi(struct ivtv *itv,
134 			   const struct v4l2_sliced_vbi_data *sliced,
135 			   size_t cnt)
136 {
137 	struct vbi_cc cc = { .odd = { 0x80, 0x80 }, .even = { 0x80, 0x80 } };
138 	int found_cc = 0;
139 	size_t i;
140 
141 	for (i = 0; i < cnt; i++)
142 		ivtv_write_vbi_line(itv, sliced + i, &cc, &found_cc);
143 
144 	if (found_cc)
145 		ivtv_write_vbi_cc_lines(itv, &cc);
146 }
147 
148 ssize_t
ivtv_write_vbi_from_user(struct ivtv * itv,const struct v4l2_sliced_vbi_data __user * sliced,size_t cnt)149 ivtv_write_vbi_from_user(struct ivtv *itv,
150 			 const struct v4l2_sliced_vbi_data __user *sliced,
151 			 size_t cnt)
152 {
153 	struct vbi_cc cc = { .odd = { 0x80, 0x80 }, .even = { 0x80, 0x80 } };
154 	int found_cc = 0;
155 	size_t i;
156 	struct v4l2_sliced_vbi_data d;
157 	ssize_t ret = cnt * sizeof(struct v4l2_sliced_vbi_data);
158 
159 	for (i = 0; i < cnt; i++) {
160 		if (copy_from_user(&d, sliced + i,
161 				   sizeof(struct v4l2_sliced_vbi_data))) {
162 			ret = -EFAULT;
163 			break;
164 		}
165 		ivtv_write_vbi_line(itv, &d, &cc, &found_cc);
166 	}
167 
168 	if (found_cc)
169 		ivtv_write_vbi_cc_lines(itv, &cc);
170 
171 	return ret;
172 }
173 
copy_vbi_data(struct ivtv * itv,int lines,u32 pts_stamp)174 static void copy_vbi_data(struct ivtv *itv, int lines, u32 pts_stamp)
175 {
176 	int line = 0;
177 	int i;
178 	u32 linemask[2] = { 0, 0 };
179 	unsigned short size;
180 	static const u8 mpeg_hdr_data[] = {
181 		0x00, 0x00, 0x01, 0xba, 0x44, 0x00, 0x0c, 0x66,
182 		0x24, 0x01, 0x01, 0xd1, 0xd3, 0xfa, 0xff, 0xff,
183 		0x00, 0x00, 0x01, 0xbd, 0x00, 0x1a, 0x84, 0x80,
184 		0x07, 0x21, 0x00, 0x5d, 0x63, 0xa7, 0xff, 0xff
185 	};
186 	const int sd = sizeof(mpeg_hdr_data);	/* start of vbi data */
187 	int idx = itv->vbi.frame % IVTV_VBI_FRAMES;
188 	u8 *dst = &itv->vbi.sliced_mpeg_data[idx][0];
189 
190 	for (i = 0; i < lines; i++) {
191 		int f, l;
192 
193 		if (itv->vbi.sliced_data[i].id == 0)
194 			continue;
195 
196 		l = itv->vbi.sliced_data[i].line - 6;
197 		f = itv->vbi.sliced_data[i].field;
198 		if (f)
199 			l += 18;
200 		if (l < 32)
201 			linemask[0] |= (1 << l);
202 		else
203 			linemask[1] |= (1 << (l - 32));
204 		dst[sd + 12 + line * 43] =
205 			ivtv_service2vbi(itv->vbi.sliced_data[i].id);
206 		memcpy(dst + sd + 12 + line * 43 + 1, itv->vbi.sliced_data[i].data, 42);
207 		line++;
208 	}
209 	memcpy(dst, mpeg_hdr_data, sizeof(mpeg_hdr_data));
210 	if (line == 36) {
211 		/* All lines are used, so there is no space for the linemask
212 		   (the max size of the VBI data is 36 * 43 + 4 bytes).
213 		   So in this case we use the magic number 'ITV0'. */
214 		memcpy(dst + sd, "ITV0", 4);
215 		memmove(dst + sd + 4, dst + sd + 12, line * 43);
216 		size = 4 + ((43 * line + 3) & ~3);
217 	} else {
218 		memcpy(dst + sd, "itv0", 4);
219 		cpu_to_le32s(&linemask[0]);
220 		cpu_to_le32s(&linemask[1]);
221 		memcpy(dst + sd + 4, &linemask[0], 8);
222 		size = 12 + ((43 * line + 3) & ~3);
223 	}
224 	dst[4+16] = (size + 10) >> 8;
225 	dst[5+16] = (size + 10) & 0xff;
226 	dst[9+16] = 0x21 | ((pts_stamp >> 29) & 0x6);
227 	dst[10+16] = (pts_stamp >> 22) & 0xff;
228 	dst[11+16] = 1 | ((pts_stamp >> 14) & 0xff);
229 	dst[12+16] = (pts_stamp >> 7) & 0xff;
230 	dst[13+16] = 1 | ((pts_stamp & 0x7f) << 1);
231 	itv->vbi.sliced_mpeg_size[idx] = sd + size;
232 }
233 
ivtv_convert_ivtv_vbi(struct ivtv * itv,u8 * p)234 static int ivtv_convert_ivtv_vbi(struct ivtv *itv, u8 *p)
235 {
236 	u32 linemask[2];
237 	int i, l, id2;
238 	int line = 0;
239 
240 	if (!memcmp(p, "itv0", 4)) {
241 		memcpy(linemask, p + 4, 8);
242 		p += 12;
243 	} else if (!memcmp(p, "ITV0", 4)) {
244 		linemask[0] = 0xffffffff;
245 		linemask[1] = 0xf;
246 		p += 4;
247 	} else {
248 		/* unknown VBI data, convert to empty VBI frame */
249 		linemask[0] = linemask[1] = 0;
250 	}
251 	for (i = 0; i < 36; i++) {
252 		int err = 0;
253 
254 		if (i < 32 && !(linemask[0] & (1 << i)))
255 			continue;
256 		if (i >= 32 && !(linemask[1] & (1 << (i - 32))))
257 			continue;
258 		id2 = *p & 0xf;
259 		switch (id2) {
260 		case IVTV_SLICED_TYPE_TELETEXT_B:
261 			id2 = V4L2_SLICED_TELETEXT_B;
262 			break;
263 		case IVTV_SLICED_TYPE_CAPTION_525:
264 			id2 = V4L2_SLICED_CAPTION_525;
265 			err = !odd_parity(p[1]) || !odd_parity(p[2]);
266 			break;
267 		case IVTV_SLICED_TYPE_VPS:
268 			id2 = V4L2_SLICED_VPS;
269 			break;
270 		case IVTV_SLICED_TYPE_WSS_625:
271 			id2 = V4L2_SLICED_WSS_625;
272 			break;
273 		default:
274 			id2 = 0;
275 			break;
276 		}
277 		if (err == 0) {
278 			l = (i < 18) ? i + 6 : i - 18 + 6;
279 			itv->vbi.sliced_dec_data[line].line = l;
280 			itv->vbi.sliced_dec_data[line].field = i >= 18;
281 			itv->vbi.sliced_dec_data[line].id = id2;
282 			memcpy(itv->vbi.sliced_dec_data[line].data, p + 1, 42);
283 			line++;
284 		}
285 		p += 43;
286 	}
287 	while (line < 36) {
288 		itv->vbi.sliced_dec_data[line].id = 0;
289 		itv->vbi.sliced_dec_data[line].line = 0;
290 		itv->vbi.sliced_dec_data[line].field = 0;
291 		line++;
292 	}
293 	return line * sizeof(itv->vbi.sliced_dec_data[0]);
294 }
295 
296 /* Compress raw VBI format, removes leading SAV codes and surplus space after the
297    field.
298    Returns new compressed size. */
compress_raw_buf(struct ivtv * itv,u8 * buf,u32 size)299 static u32 compress_raw_buf(struct ivtv *itv, u8 *buf, u32 size)
300 {
301 	u32 line_size = itv->vbi.raw_decoder_line_size;
302 	u32 lines = itv->vbi.count;
303 	u8 sav1 = itv->vbi.raw_decoder_sav_odd_field;
304 	u8 sav2 = itv->vbi.raw_decoder_sav_even_field;
305 	u8 *q = buf;
306 	u8 *p;
307 	int i;
308 
309 	for (i = 0; i < lines; i++) {
310 		p = buf + i * line_size;
311 
312 		/* Look for SAV code */
313 		if (p[0] != 0xff || p[1] || p[2] || (p[3] != sav1 && p[3] != sav2)) {
314 			break;
315 		}
316 		memcpy(q, p + 4, line_size - 4);
317 		q += line_size - 4;
318 	}
319 	return lines * (line_size - 4);
320 }
321 
322 
323 /* Compressed VBI format, all found sliced blocks put next to one another
324    Returns new compressed size */
compress_sliced_buf(struct ivtv * itv,u32 line,u8 * buf,u32 size,u8 sav)325 static u32 compress_sliced_buf(struct ivtv *itv, u32 line, u8 *buf, u32 size, u8 sav)
326 {
327 	u32 line_size = itv->vbi.sliced_decoder_line_size;
328 	struct v4l2_decode_vbi_line vbi = {};
329 	int i;
330 	unsigned lines = 0;
331 
332 	/* find the first valid line */
333 	for (i = 0; i < size; i++, buf++) {
334 		if (buf[0] == 0xff && !buf[1] && !buf[2] && buf[3] == sav)
335 			break;
336 	}
337 
338 	size -= i;
339 	if (size < line_size) {
340 		return line;
341 	}
342 	for (i = 0; i < size / line_size; i++) {
343 		u8 *p = buf + i * line_size;
344 
345 		/* Look for SAV code  */
346 		if (p[0] != 0xff || p[1] || p[2] || p[3] != sav) {
347 			continue;
348 		}
349 		vbi.p = p + 4;
350 		v4l2_subdev_call(itv->sd_video, vbi, decode_vbi_line, &vbi);
351 		if (vbi.type && !(lines & (1 << vbi.line))) {
352 			lines |= 1 << vbi.line;
353 			itv->vbi.sliced_data[line].id = vbi.type;
354 			itv->vbi.sliced_data[line].field = vbi.is_second_field;
355 			itv->vbi.sliced_data[line].line = vbi.line;
356 			memcpy(itv->vbi.sliced_data[line].data, vbi.p, 42);
357 			line++;
358 		}
359 	}
360 	return line;
361 }
362 
ivtv_process_vbi_data(struct ivtv * itv,struct ivtv_buffer * buf,u64 pts_stamp,int streamtype)363 void ivtv_process_vbi_data(struct ivtv *itv, struct ivtv_buffer *buf,
364 			   u64 pts_stamp, int streamtype)
365 {
366 	u8 *p = (u8 *) buf->buf;
367 	u32 size = buf->bytesused;
368 	int y;
369 
370 	/* Raw VBI data */
371 	if (streamtype == IVTV_ENC_STREAM_TYPE_VBI && ivtv_raw_vbi(itv)) {
372 		u8 type;
373 
374 		ivtv_buf_swap(buf);
375 
376 		type = p[3];
377 
378 		size = buf->bytesused = compress_raw_buf(itv, p, size);
379 
380 		/* second field of the frame? */
381 		if (type == itv->vbi.raw_decoder_sav_even_field) {
382 			/* Dirty hack needed for backwards
383 			   compatibility of old VBI software. */
384 			p += size - 4;
385 			memcpy(p, &itv->vbi.frame, 4);
386 			itv->vbi.frame++;
387 		}
388 		return;
389 	}
390 
391 	/* Sliced VBI data with data insertion */
392 	if (streamtype == IVTV_ENC_STREAM_TYPE_VBI) {
393 		int lines;
394 
395 		ivtv_buf_swap(buf);
396 
397 		/* first field */
398 		lines = compress_sliced_buf(itv, 0, p, size / 2,
399 			itv->vbi.sliced_decoder_sav_odd_field);
400 		/* second field */
401 		/* experimentation shows that the second half does not always begin
402 		   at the exact address. So start a bit earlier (hence 32). */
403 		lines = compress_sliced_buf(itv, lines, p + size / 2 - 32, size / 2 + 32,
404 			itv->vbi.sliced_decoder_sav_even_field);
405 		/* always return at least one empty line */
406 		if (lines == 0) {
407 			itv->vbi.sliced_data[0].id = 0;
408 			itv->vbi.sliced_data[0].line = 0;
409 			itv->vbi.sliced_data[0].field = 0;
410 			lines = 1;
411 		}
412 		buf->bytesused = size = lines * sizeof(itv->vbi.sliced_data[0]);
413 		memcpy(p, &itv->vbi.sliced_data[0], size);
414 
415 		if (itv->vbi.insert_mpeg) {
416 			copy_vbi_data(itv, lines, pts_stamp);
417 		}
418 		itv->vbi.frame++;
419 		return;
420 	}
421 
422 	/* Sliced VBI re-inserted from an MPEG stream */
423 	if (streamtype == IVTV_DEC_STREAM_TYPE_VBI) {
424 		/* If the size is not 4-byte aligned, then the starting address
425 		   for the swapping is also shifted. After swapping the data the
426 		   real start address of the VBI data is exactly 4 bytes after the
427 		   original start. It's a bit fiddly but it works like a charm.
428 		   Non-4-byte alignment happens when an lseek is done on the input
429 		   mpeg file to a non-4-byte aligned position. So on arrival here
430 		   the VBI data is also non-4-byte aligned. */
431 		int offset = size & 3;
432 		int cnt;
433 
434 		if (offset) {
435 			p += 4 - offset;
436 		}
437 		/* Swap Buffer */
438 		for (y = 0; y < size; y += 4) {
439 		       swab32s((u32 *)(p + y));
440 		}
441 
442 		cnt = ivtv_convert_ivtv_vbi(itv, p + offset);
443 		memcpy(buf->buf, itv->vbi.sliced_dec_data, cnt);
444 		buf->bytesused = cnt;
445 
446 		ivtv_write_vbi(itv, itv->vbi.sliced_dec_data,
447 			       cnt / sizeof(itv->vbi.sliced_dec_data[0]));
448 		return;
449 	}
450 }
451 
ivtv_disable_cc(struct ivtv * itv)452 void ivtv_disable_cc(struct ivtv *itv)
453 {
454 	struct vbi_cc cc = { .odd = { 0x80, 0x80 }, .even = { 0x80, 0x80 } };
455 
456 	clear_bit(IVTV_F_I_UPDATE_CC, &itv->i_flags);
457 	ivtv_set_cc(itv, 0, &cc);
458 	itv->vbi.cc_payload_idx = 0;
459 }
460 
461 
ivtv_vbi_work_handler(struct ivtv * itv)462 void ivtv_vbi_work_handler(struct ivtv *itv)
463 {
464 	struct vbi_info *vi = &itv->vbi;
465 	struct v4l2_sliced_vbi_data data;
466 	struct vbi_cc cc = { .odd = { 0x80, 0x80 }, .even = { 0x80, 0x80 } };
467 
468 	/* Lock */
469 	if (itv->output_mode == OUT_PASSTHROUGH) {
470 		if (itv->is_50hz) {
471 			data.id = V4L2_SLICED_WSS_625;
472 			data.field = 0;
473 
474 			if (v4l2_subdev_call(itv->sd_video, vbi, g_vbi_data, &data) == 0) {
475 				ivtv_set_wss(itv, 1, data.data[0] & 0xf);
476 				vi->wss_missing_cnt = 0;
477 			} else if (vi->wss_missing_cnt == 4) {
478 				ivtv_set_wss(itv, 1, 0x8);  /* 4x3 full format */
479 			} else {
480 				vi->wss_missing_cnt++;
481 			}
482 		}
483 		else {
484 			int mode = 0;
485 
486 			data.id = V4L2_SLICED_CAPTION_525;
487 			data.field = 0;
488 			if (v4l2_subdev_call(itv->sd_video, vbi, g_vbi_data, &data) == 0) {
489 				mode |= 1;
490 				cc.odd[0] = data.data[0];
491 				cc.odd[1] = data.data[1];
492 			}
493 			data.field = 1;
494 			if (v4l2_subdev_call(itv->sd_video, vbi, g_vbi_data, &data) == 0) {
495 				mode |= 2;
496 				cc.even[0] = data.data[0];
497 				cc.even[1] = data.data[1];
498 			}
499 			if (mode) {
500 				vi->cc_missing_cnt = 0;
501 				ivtv_set_cc(itv, mode, &cc);
502 			} else if (vi->cc_missing_cnt == 4) {
503 				ivtv_set_cc(itv, 0, &cc);
504 			} else {
505 				vi->cc_missing_cnt++;
506 			}
507 		}
508 		return;
509 	}
510 
511 	if (test_and_clear_bit(IVTV_F_I_UPDATE_WSS, &itv->i_flags)) {
512 		ivtv_set_wss(itv, 1, vi->wss_payload & 0xf);
513 	}
514 
515 	if (test_bit(IVTV_F_I_UPDATE_CC, &itv->i_flags)) {
516 		if (vi->cc_payload_idx == 0) {
517 			clear_bit(IVTV_F_I_UPDATE_CC, &itv->i_flags);
518 			ivtv_set_cc(itv, 3, &cc);
519 		}
520 		while (vi->cc_payload_idx) {
521 			cc = vi->cc_payload[0];
522 
523 			memmove(vi->cc_payload, vi->cc_payload + 1,
524 					sizeof(vi->cc_payload) - sizeof(vi->cc_payload[0]));
525 			vi->cc_payload_idx--;
526 			if (vi->cc_payload_idx && cc.odd[0] == 0x80 && cc.odd[1] == 0x80)
527 				continue;
528 
529 			ivtv_set_cc(itv, 3, &cc);
530 			break;
531 		}
532 	}
533 
534 	if (test_and_clear_bit(IVTV_F_I_UPDATE_VPS, &itv->i_flags)) {
535 		ivtv_set_vps(itv, 1);
536 	}
537 }
538