[deliverable/linux.git] / drivers / media / pci / ivtv / ivtv-vbi.c

/*
    Vertical Blank Interval support functions
    Copyright (C) 2004-2007  Hans Verkuil <hverkuil@xs4all.nl>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include "ivtv-driver.h"
#include "ivtv-i2c.h"
#include "ivtv-ioctl.h"
#include "ivtv-queue.h"
#include "ivtv-cards.h"
#include "ivtv-vbi.h"

static void ivtv_set_vps(struct ivtv *itv, int enabled)
{
	struct v4l2_sliced_vbi_data data;

	if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
		return;
	data.id = V4L2_SLICED_VPS;
	data.field = 0;
	data.line = enabled ? 16 : 0;
	data.data[2] = itv->vbi.vps_payload.data[0];
	data.data[8] = itv->vbi.vps_payload.data[1];
	data.data[9] = itv->vbi.vps_payload.data[2];
	data.data[10] = itv->vbi.vps_payload.data[3];
	data.data[11] = itv->vbi.vps_payload.data[4];
	ivtv_call_hw(itv, IVTV_HW_SAA7127, vbi, s_vbi_data, &data);
}

static void ivtv_set_cc(struct ivtv *itv, int mode, const struct vbi_cc *cc)
{
	struct v4l2_sliced_vbi_data data;

	if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
		return;
	data.id = V4L2_SLICED_CAPTION_525;
	data.field = 0;
	data.line = (mode & 1) ? 21 : 0;
	data.data[0] = cc->odd[0];
	data.data[1] = cc->odd[1];
	ivtv_call_hw(itv, IVTV_HW_SAA7127, vbi, s_vbi_data, &data);
	data.field = 1;
	data.line = (mode & 2) ? 21 : 0;
	data.data[0] = cc->even[0];
	data.data[1] = cc->even[1];
	ivtv_call_hw(itv, IVTV_HW_SAA7127, vbi, s_vbi_data, &data);
}

static void ivtv_set_wss(struct ivtv *itv, int enabled, int mode)
{
	struct v4l2_sliced_vbi_data data;

	if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
		return;
	/* When using a 50 Hz system, always turn on the
	   wide screen signal with 4x3 ratio as the default.
	   Turning this signal on and off can confuse certain
	   TVs. As far as I can tell there is no reason not to
	   transmit this signal. */
	if ((itv->std_out & V4L2_STD_625_50) && !enabled) {
		enabled = 1;
		mode = 0x08;  /* 4x3 full format */
	}
	data.id = V4L2_SLICED_WSS_625;
	data.field = 0;
	data.line = enabled ? 23 : 0;
	data.data[0] = mode & 0xff;
	data.data[1] = (mode >> 8) & 0xff;
	ivtv_call_hw(itv, IVTV_HW_SAA7127, vbi, s_vbi_data, &data);
}

static int odd_parity(u8 c)
{
	c ^= (c >> 4);
	c ^= (c >> 2);
	c ^= (c >> 1);

	return c & 1;
}

static void ivtv_write_vbi_line(struct ivtv *itv,
				const struct v4l2_sliced_vbi_data *d,
				struct vbi_cc *cc, int *found_cc)
{
	struct vbi_info *vi = &itv->vbi;

	if (d->id == V4L2_SLICED_CAPTION_525 && d->line == 21) {
		if (d->field) {
			cc->even[0] = d->data[0];
			cc->even[1] = d->data[1];
		} else {
			cc->odd[0] = d->data[0];
			cc->odd[1] = d->data[1];
		}
		*found_cc = 1;
	} else if (d->id == V4L2_SLICED_VPS && d->line == 16 && d->field == 0) {
		struct vbi_vps vps;

		vps.data[0] = d->data[2];
		vps.data[1] = d->data[8];
		vps.data[2] = d->data[9];
		vps.data[3] = d->data[10];
		vps.data[4] = d->data[11];
		if (memcmp(&vps, &vi->vps_payload, sizeof(vps))) {
			vi->vps_payload = vps;
			set_bit(IVTV_F_I_UPDATE_VPS, &itv->i_flags);
		}
	} else if (d->id == V4L2_SLICED_WSS_625 &&
		   d->line == 23 && d->field == 0) {
		int wss = d->data[0] | d->data[1] << 8;

		if (vi->wss_payload != wss) {
			vi->wss_payload = wss;
			set_bit(IVTV_F_I_UPDATE_WSS, &itv->i_flags);
		}
	}
}

static void ivtv_write_vbi_cc_lines(struct ivtv *itv, const struct vbi_cc *cc)
{
	struct vbi_info *vi = &itv->vbi;

	if (vi->cc_payload_idx < ARRAY_SIZE(vi->cc_payload)) {
		memcpy(&vi->cc_payload[vi->cc_payload_idx], cc,
		       sizeof(struct vbi_cc));
		vi->cc_payload_idx++;
		set_bit(IVTV_F_I_UPDATE_CC, &itv->i_flags);
	}
}

static void ivtv_write_vbi(struct ivtv *itv,
			   const struct v4l2_sliced_vbi_data *sliced,
			   size_t cnt)
{
	struct vbi_cc cc = { .odd = { 0x80, 0x80 }, .even = { 0x80, 0x80 } };
	int found_cc = 0;
	size_t i;

	for (i = 0; i < cnt; i++)
		ivtv_write_vbi_line(itv, sliced + i, &cc, &found_cc);

	if (found_cc)
		ivtv_write_vbi_cc_lines(itv, &cc);
}

ssize_t
ivtv_write_vbi_from_user(struct ivtv *itv,
			 const struct v4l2_sliced_vbi_data __user *sliced,
			 size_t cnt)
{
	struct vbi_cc cc = { .odd = { 0x80, 0x80 }, .even = { 0x80, 0x80 } };
	int found_cc = 0;
	size_t i;
	struct v4l2_sliced_vbi_data d;
	ssize_t ret = cnt * sizeof(struct v4l2_sliced_vbi_data);

	for (i = 0; i < cnt; i++) {
		if (copy_from_user(&d, sliced + i,
				   sizeof(struct v4l2_sliced_vbi_data))) {
			ret = -EFAULT;
			break;
		}
		ivtv_write_vbi_line(itv, &d, &cc, &found_cc);
	}

	if (found_cc)
		ivtv_write_vbi_cc_lines(itv, &cc);

	return ret;
}

static void copy_vbi_data(struct ivtv *itv, int lines, u32 pts_stamp)
{
	int line = 0;
	int i;
	u32 linemask[2] = { 0, 0 };
	unsigned short size;
	static const u8 mpeg_hdr_data[] = {
		0x00, 0x00, 0x01, 0xba, 0x44, 0x00, 0x0c, 0x66,
		0x24, 0x01, 0x01, 0xd1, 0xd3, 0xfa, 0xff, 0xff,
		0x00, 0x00, 0x01, 0xbd, 0x00, 0x1a, 0x84, 0x80,
		0x07, 0x21, 0x00, 0x5d, 0x63, 0xa7, 0xff, 0xff
	};
	const int sd = sizeof(mpeg_hdr_data);	/* start of vbi data */
	int idx = itv->vbi.frame % IVTV_VBI_FRAMES;
	u8 *dst = &itv->vbi.sliced_mpeg_data[idx][0];

	for (i = 0; i < lines; i++) {
		int f, l;

		if (itv->vbi.sliced_data[i].id == 0)
			continue;

		l = itv->vbi.sliced_data[i].line - 6;
		f = itv->vbi.sliced_data[i].field;
		if (f)
			l += 18;
		if (l < 32)
			linemask[0] |= (1 << l);
		else
			linemask[1] |= (1 << (l - 32));
		dst[sd + 12 + line * 43] =
			ivtv_service2vbi(itv->vbi.sliced_data[i].id);
		memcpy(dst + sd + 12 + line * 43 + 1, itv->vbi.sliced_data[i].data, 42);
		line++;
	}
	memcpy(dst, mpeg_hdr_data, sizeof(mpeg_hdr_data));
	if (line == 36) {
		/* All lines are used, so there is no space for the linemask
		   (the max size of the VBI data is 36 * 43 + 4 bytes).
		   So in this case we use the magic number 'ITV0'. */
		memcpy(dst + sd, "ITV0", 4);
		memcpy(dst + sd + 4, dst + sd + 12, line * 43);
		size = 4 + ((43 * line + 3) & ~3);
	} else {
		memcpy(dst + sd, "itv0", 4);
		cpu_to_le32s(&linemask[0]);
		cpu_to_le32s(&linemask[1]);
		memcpy(dst + sd + 4, &linemask[0], 8);
		size = 12 + ((43 * line + 3) & ~3);
	}
	dst[4+16] = (size + 10) >> 8;
	dst[5+16] = (size + 10) & 0xff;
	dst[9+16] = 0x21 | ((pts_stamp >> 29) & 0x6);
	dst[10+16] = (pts_stamp >> 22) & 0xff;
	dst[11+16] = 1 | ((pts_stamp >> 14) & 0xff);
	dst[12+16] = (pts_stamp >> 7) & 0xff;
	dst[13+16] = 1 | ((pts_stamp & 0x7f) << 1);
	itv->vbi.sliced_mpeg_size[idx] = sd + size;
}

static int ivtv_convert_ivtv_vbi(struct ivtv *itv, u8 *p)
{
	u32 linemask[2];
	int i, l, id2;
	int line = 0;

	if (!memcmp(p, "itv0", 4)) {
		memcpy(linemask, p + 4, 8);
		p += 12;
	} else if (!memcmp(p, "ITV0", 4)) {
		linemask[0] = 0xffffffff;
		linemask[1] = 0xf;
		p += 4;
	} else {
		/* unknown VBI data, convert to empty VBI frame */
		linemask[0] = linemask[1] = 0;
	}
	for (i = 0; i < 36; i++) {
		int err = 0;

		if (i < 32 && !(linemask[0] & (1 << i)))
			continue;
		if (i >= 32 && !(linemask[1] & (1 << (i - 32))))
			continue;
		id2 = *p & 0xf;
		switch (id2) {
		case IVTV_SLICED_TYPE_TELETEXT_B:
			id2 = V4L2_SLICED_TELETEXT_B;
			break;
		case IVTV_SLICED_TYPE_CAPTION_525:
			id2 = V4L2_SLICED_CAPTION_525;
			err = !odd_parity(p[1]) || !odd_parity(p[2]);
			break;
		case IVTV_SLICED_TYPE_VPS:
			id2 = V4L2_SLICED_VPS;
			break;
		case IVTV_SLICED_TYPE_WSS_625:
			id2 = V4L2_SLICED_WSS_625;
			break;
		default:
			id2 = 0;
			break;
		}
		if (err == 0) {
			l = (i < 18) ? i + 6 : i - 18 + 6;
			itv->vbi.sliced_dec_data[line].line = l;
			itv->vbi.sliced_dec_data[line].field = i >= 18;
			itv->vbi.sliced_dec_data[line].id = id2;
			memcpy(itv->vbi.sliced_dec_data[line].data, p + 1, 42);
			line++;
		}
		p += 43;
	}
	while (line < 36) {
		itv->vbi.sliced_dec_data[line].id = 0;
		itv->vbi.sliced_dec_data[line].line = 0;
		itv->vbi.sliced_dec_data[line].field = 0;
		line++;
	}
	return line * sizeof(itv->vbi.sliced_dec_data[0]);
}

/* Compress raw VBI format, removes leading SAV codes and surplus space after the
   field.
   Returns new compressed size. */
static u32 compress_raw_buf(struct ivtv *itv, u8 *buf, u32 size)
{
	u32 line_size = itv->vbi.raw_decoder_line_size;
	u32 lines = itv->vbi.count;
	u8 sav1 = itv->vbi.raw_decoder_sav_odd_field;
	u8 sav2 = itv->vbi.raw_decoder_sav_even_field;
	u8 *q = buf;
	u8 *p;
	int i;

	for (i = 0; i < lines; i++) {
		p = buf + i * line_size;

		/* Look for SAV code */
		if (p[0] != 0xff || p[1] || p[2] || (p[3] != sav1 && p[3] != sav2)) {
			break;
		}
		memcpy(q, p + 4, line_size - 4);
		q += line_size - 4;
	}
	return lines * (line_size - 4);
}


/* Compressed VBI format, all found sliced blocks put next to one another
   Returns new compressed size */
static u32 compress_sliced_buf(struct ivtv *itv, u32 line, u8 *buf, u32 size, u8 sav)
{
	u32 line_size = itv->vbi.sliced_decoder_line_size;
	struct v4l2_decode_vbi_line vbi;
	int i;
	unsigned lines = 0;

	/* find the first valid line */
	for (i = 0; i < size; i++, buf++) {
		if (buf[0] == 0xff && !buf[1] && !buf[2] && buf[3] == sav)
			break;
	}

	size -= i;
	if (size < line_size) {
		return line;
	}
	for (i = 0; i < size / line_size; i++) {
		u8 *p = buf + i * line_size;

		/* Look for SAV code  */
		if (p[0] != 0xff || p[1] || p[2] || p[3] != sav) {
			continue;
		}
		vbi.p = p + 4;
		v4l2_subdev_call(itv->sd_video, vbi, decode_vbi_line, &vbi);
		if (vbi.type && !(lines & (1 << vbi.line))) {
			lines |= 1 << vbi.line;
			itv->vbi.sliced_data[line].id = vbi.type;
			itv->vbi.sliced_data[line].field = vbi.is_second_field;
			itv->vbi.sliced_data[line].line = vbi.line;
			memcpy(itv->vbi.sliced_data[line].data, vbi.p, 42);
			line++;
		}
	}
	return line;
}

void ivtv_process_vbi_data(struct ivtv *itv, struct ivtv_buffer *buf,
			   u64 pts_stamp, int streamtype)
{
	u8 *p = (u8 *) buf->buf;
	u32 size = buf->bytesused;
	int y;

	/* Raw VBI data */
	if (streamtype == IVTV_ENC_STREAM_TYPE_VBI && ivtv_raw_vbi(itv)) {
		u8 type;

		ivtv_buf_swap(buf);

		type = p[3];

		size = buf->bytesused = compress_raw_buf(itv, p, size);

		/* second field of the frame? */
		if (type == itv->vbi.raw_decoder_sav_even_field) {
			/* Dirty hack needed for backwards
			   compatibility of old VBI software. */
			p += size - 4;
			memcpy(p, &itv->vbi.frame, 4);
			itv->vbi.frame++;
		}
		return;
	}

	/* Sliced VBI data with data insertion */
	if (streamtype == IVTV_ENC_STREAM_TYPE_VBI) {
		int lines;

		ivtv_buf_swap(buf);

		/* first field */
		lines = compress_sliced_buf(itv, 0, p, size / 2,
			itv->vbi.sliced_decoder_sav_odd_field);
		/* second field */
		/* experimentation shows that the second half does not always begin
		   at the exact address. So start a bit earlier (hence 32). */
		lines = compress_sliced_buf(itv, lines, p + size / 2 - 32, size / 2 + 32,
			itv->vbi.sliced_decoder_sav_even_field);
		/* always return at least one empty line */
		if (lines == 0) {
			itv->vbi.sliced_data[0].id = 0;
			itv->vbi.sliced_data[0].line = 0;
			itv->vbi.sliced_data[0].field = 0;
			lines = 1;
		}
		buf->bytesused = size = lines * sizeof(itv->vbi.sliced_data[0]);
		memcpy(p, &itv->vbi.sliced_data[0], size);

		if (itv->vbi.insert_mpeg) {
			copy_vbi_data(itv, lines, pts_stamp);
		}
		itv->vbi.frame++;
		return;
	}

	/* Sliced VBI re-inserted from an MPEG stream */
	if (streamtype == IVTV_DEC_STREAM_TYPE_VBI) {
		/* If the size is not 4-byte aligned, then the starting address
		   for the swapping is also shifted. After swapping the data the
		   real start address of the VBI data is exactly 4 bytes after the
		   original start. It's a bit fiddly but it works like a charm.
		   Non-4-byte alignment happens when an lseek is done on the input
		   mpeg file to a non-4-byte aligned position. So on arrival here
		   the VBI data is also non-4-byte aligned. */
		int offset = size & 3;
		int cnt;

		if (offset) {
			p += 4 - offset;
		}
		/* Swap Buffer */
		for (y = 0; y < size; y += 4) {
		       swab32s((u32 *)(p + y));
		}

		cnt = ivtv_convert_ivtv_vbi(itv, p + offset);
		memcpy(buf->buf, itv->vbi.sliced_dec_data, cnt);
		buf->bytesused = cnt;

		ivtv_write_vbi(itv, itv->vbi.sliced_dec_data,
			       cnt / sizeof(itv->vbi.sliced_dec_data[0]));
		return;
	}
}

void ivtv_disable_cc(struct ivtv *itv)
{
	struct vbi_cc cc = { .odd = { 0x80, 0x80 }, .even = { 0x80, 0x80 } };

	clear_bit(IVTV_F_I_UPDATE_CC, &itv->i_flags);
	ivtv_set_cc(itv, 0, &cc);
	itv->vbi.cc_payload_idx = 0;
}


void ivtv_vbi_work_handler(struct ivtv *itv)
{
	struct vbi_info *vi = &itv->vbi;
	struct v4l2_sliced_vbi_data data;
	struct vbi_cc cc = { .odd = { 0x80, 0x80 }, .even = { 0x80, 0x80 } };

	/* Lock */
	if (itv->output_mode == OUT_PASSTHROUGH) {
		if (itv->is_50hz) {
			data.id = V4L2_SLICED_WSS_625;
			data.field = 0;

			if (v4l2_subdev_call(itv->sd_video, vbi, g_vbi_data, &data) == 0) {
				ivtv_set_wss(itv, 1, data.data[0] & 0xf);
				vi->wss_missing_cnt = 0;
			} else if (vi->wss_missing_cnt == 4) {
				ivtv_set_wss(itv, 1, 0x8);  /* 4x3 full format */
			} else {
				vi->wss_missing_cnt++;
			}
		}
		else {
			int mode = 0;

			data.id = V4L2_SLICED_CAPTION_525;
			data.field = 0;
			if (v4l2_subdev_call(itv->sd_video, vbi, g_vbi_data, &data) == 0) {
				mode |= 1;
				cc.odd[0] = data.data[0];
				cc.odd[1] = data.data[1];
			}
			data.field = 1;
			if (v4l2_subdev_call(itv->sd_video, vbi, g_vbi_data, &data) == 0) {
				mode |= 2;
				cc.even[0] = data.data[0];
				cc.even[1] = data.data[1];
			}
			if (mode) {
				vi->cc_missing_cnt = 0;
				ivtv_set_cc(itv, mode, &cc);
			} else if (vi->cc_missing_cnt == 4) {
				ivtv_set_cc(itv, 0, &cc);
			} else {
				vi->cc_missing_cnt++;
			}
		}
		return;
	}

	if (test_and_clear_bit(IVTV_F_I_UPDATE_WSS, &itv->i_flags)) {
		ivtv_set_wss(itv, 1, vi->wss_payload & 0xf);
	}

	if (test_bit(IVTV_F_I_UPDATE_CC, &itv->i_flags)) {
		if (vi->cc_payload_idx == 0) {
			clear_bit(IVTV_F_I_UPDATE_CC, &itv->i_flags);
			ivtv_set_cc(itv, 3, &cc);
		}
		while (vi->cc_payload_idx) {
			cc = vi->cc_payload[0];

			memcpy(vi->cc_payload, vi->cc_payload + 1,
					sizeof(vi->cc_payload) - sizeof(vi->cc_payload[0]));
			vi->cc_payload_idx--;
			if (vi->cc_payload_idx && cc.odd[0] == 0x80 && cc.odd[1] == 0x80)
				continue;

			ivtv_set_cc(itv, 3, &cc);
			break;
		}
	}

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