vivid-vbi-gen.c

  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * vivid-vbi-gen.c - vbi generator support functions.
  4 *
  5 * Copyright 2014 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
  6 */
  7
  8#include <linux/bitops.h>
  9#include <linux/errno.h>
 10#include <linux/kernel.h>
 11#include <linux/ktime.h>
 12#include <linux/string.h>
 13#include <linux/videodev2.h>
 14
 15#include "vivid-vbi-gen.h"
 16
 17static void wss_insert(u8 *wss, u32 val, unsigned size)
 18{
 19	while (size--)
 20		*wss++ = (val & (1 << size)) ? 0xc0 : 0x10;
 21}
 22
 23static void vivid_vbi_gen_wss_raw(const struct v4l2_sliced_vbi_data *data,
 24		u8 *buf, unsigned sampling_rate)
 25{
 26	const unsigned rate = 5000000;	/* WSS has a 5 MHz transmission rate */
 27	u8 wss[29 + 24 + 24 + 24 + 18 + 18] = { 0 };
 28	const unsigned zero = 0x07;
 29	const unsigned one = 0x38;
 30	unsigned bit = 0;
 31	u16 wss_data;
 32	int i;
 33
 34	wss_insert(wss + bit, 0x1f1c71c7, 29); bit += 29;
 35	wss_insert(wss + bit, 0x1e3c1f, 24); bit += 24;
 36
 37	wss_data = (data->data[1] << 8) | data->data[0];
 38	for (i = 0; i <= 13; i++, bit += 6)
 39		wss_insert(wss + bit, (wss_data & (1 << i)) ? one : zero, 6);
 40
 41	for (i = 0, bit = 0; bit < sizeof(wss); bit++) {
 42		unsigned n = ((bit + 1) * sampling_rate) / rate;
 43
 44		while (i < n)
 45			buf[i++] = wss[bit];
 46	}
 47}
 48
 49static void vivid_vbi_gen_teletext_raw(const struct v4l2_sliced_vbi_data *data,
 50		u8 *buf, unsigned sampling_rate)
 51{
 52	const unsigned rate = 6937500 / 10;	/* Teletext has a 6.9375 MHz transmission rate */
 53	u8 teletext[45] = { 0x55, 0x55, 0x27 };
 54	unsigned bit = 0;
 55	int i;
 56
 57	memcpy(teletext + 3, data->data, sizeof(teletext) - 3);
 58	/* prevents 32 bit overflow */
 59	sampling_rate /= 10;
 60
 61	for (i = 0, bit = 0; bit < sizeof(teletext) * 8; bit++) {
 62		unsigned n = ((bit + 1) * sampling_rate) / rate;
 63		u8 val = (teletext[bit / 8] & (1 << (bit & 7))) ? 0xc0 : 0x10;
 64
 65		while (i < n)
 66			buf[i++] = val;
 67	}
 68}
 69
 70static void cc_insert(u8 *cc, u8 ch)
 71{
 72	unsigned tot = 0;
 73	unsigned i;
 74
 75	for (i = 0; i < 7; i++) {
 76		cc[2 * i] = cc[2 * i + 1] = (ch & (1 << i)) ? 1 : 0;
 77		tot += cc[2 * i];
 78	}
 79	cc[14] = cc[15] = !(tot & 1);
 80}
 81
 82#define CC_PREAMBLE_BITS (14 + 4 + 2)
 83
 84static void vivid_vbi_gen_cc_raw(const struct v4l2_sliced_vbi_data *data,
 85		u8 *buf, unsigned sampling_rate)
 86{
 87	const unsigned rate = 1000000;	/* CC has a 1 MHz transmission rate */
 88
 89	u8 cc[CC_PREAMBLE_BITS + 2 * 16] = {
 90		/* Clock run-in: 7 cycles */
 91		0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1,
 92		/* 2 cycles of 0 */
 93		0, 0, 0, 0,
 94		/* Start bit of 1 (each bit is two cycles) */
 95		1, 1
 96	};
 97	unsigned bit, i;
 98
 99	cc_insert(cc + CC_PREAMBLE_BITS, data->data[0]);
100	cc_insert(cc + CC_PREAMBLE_BITS + 16, data->data[1]);
101
102	for (i = 0, bit = 0; bit < sizeof(cc); bit++) {
103		unsigned n = ((bit + 1) * sampling_rate) / rate;
104
105		while (i < n)
106			buf[i++] = cc[bit] ? 0xc0 : 0x10;
107	}
108}
109
110void vivid_vbi_gen_raw(const struct vivid_vbi_gen_data *vbi,
111		const struct v4l2_vbi_format *vbi_fmt, u8 *buf)
112{
113	unsigned idx;
114
115	for (idx = 0; idx < 25; idx++) {
116		const struct v4l2_sliced_vbi_data *data = vbi->data + idx;
117		unsigned start_2nd_field;
118		unsigned line = data->line;
119		u8 *linebuf = buf;
120
121		start_2nd_field = (data->id & V4L2_SLICED_VBI_525) ? 263 : 313;
122		if (data->field)
123			line += start_2nd_field;
124		line -= vbi_fmt->start[data->field];
125
126		if (vbi_fmt->flags & V4L2_VBI_INTERLACED)
127			linebuf += (line * 2 + data->field) *
128				vbi_fmt->samples_per_line;
129		else
130			linebuf += (line + data->field * vbi_fmt->count[0]) *
131				vbi_fmt->samples_per_line;
132		if (data->id == V4L2_SLICED_CAPTION_525)
133			vivid_vbi_gen_cc_raw(data, linebuf, vbi_fmt->sampling_rate);
134		else if (data->id == V4L2_SLICED_WSS_625)
135			vivid_vbi_gen_wss_raw(data, linebuf, vbi_fmt->sampling_rate);
136		else if (data->id == V4L2_SLICED_TELETEXT_B)
137			vivid_vbi_gen_teletext_raw(data, linebuf, vbi_fmt->sampling_rate);
138	}
139}
140
141static const u8 vivid_cc_sequence1[30] = {
142	0x14, 0x20,	/* Resume Caption Loading */
143	'H',  'e',
144	'l',  'l',
145	'o',  ' ',
146	'w',  'o',
147	'r',  'l',
148	'd',  '!',
149	0x14, 0x2f,	/* End of Caption */
150};
151
152static const u8 vivid_cc_sequence2[30] = {
153	0x14, 0x20,	/* Resume Caption Loading */
154	'C',  'l',
155	'o',  's',
156	'e',  'd',
157	' ',  'c',
158	'a',  'p',
159	't',  'i',
160	'o',  'n',
161	's',  ' ',
162	't',  'e',
163	's',  't',
164	0x14, 0x2f,	/* End of Caption */
165};
166
167static u8 calc_parity(u8 val)
168{
169	return val | (parity8(val) ? 0 : 0x80);
170}
171
172static void vivid_vbi_gen_set_time_of_day(u8 *packet)
173{
174	struct tm tm;
175	u8 checksum, i;
176
177	time64_to_tm(ktime_get_real_seconds(), 0, &tm);
178	packet[0] = calc_parity(0x07);
179	packet[1] = calc_parity(0x01);
180	packet[2] = calc_parity(0x40 | tm.tm_min);
181	packet[3] = calc_parity(0x40 | tm.tm_hour);
182	packet[4] = calc_parity(0x40 | tm.tm_mday);
183	if (tm.tm_mday == 1 && tm.tm_mon == 2 &&
184	    sys_tz.tz_minuteswest > tm.tm_min + tm.tm_hour * 60)
185		packet[4] = calc_parity(0x60 | tm.tm_mday);
186	packet[5] = calc_parity(0x40 | (1 + tm.tm_mon));
187	packet[6] = calc_parity(0x40 | (1 + tm.tm_wday));
188	packet[7] = calc_parity(0x40 | ((tm.tm_year - 90) & 0x3f));
189	packet[8] = calc_parity(0x0f);
190	for (checksum = i = 0; i <= 8; i++)
191		checksum += packet[i] & 0x7f;
192	packet[9] = calc_parity(0x100 - checksum);
193	packet[10] = calc_parity(0x07);
194	packet[11] = calc_parity(0x04);
195	if (sys_tz.tz_minuteswest >= 0)
196		packet[12] = calc_parity(0x40 | ((sys_tz.tz_minuteswest / 60) & 0x1f));
197	else
198		packet[12] = calc_parity(0x40 | ((24 + sys_tz.tz_minuteswest / 60) & 0x1f));
199	packet[13] = calc_parity(0);
200	packet[14] = calc_parity(0x0f);
201	for (checksum = 0, i = 10; i <= 14; i++)
202		checksum += packet[i] & 0x7f;
203	packet[15] = calc_parity(0x100 - checksum);
204}
205
206static const u8 hamming[16] = {
207	0x15, 0x02, 0x49, 0x5e, 0x64, 0x73, 0x38, 0x2f,
208	0xd0, 0xc7, 0x8c, 0x9b, 0xa1, 0xb6, 0xfd, 0xea
209};
210
211static void vivid_vbi_gen_teletext(u8 *packet, unsigned line, unsigned frame)
212{
213	unsigned offset = 2;
214	unsigned i;
215
216	packet[0] = hamming[1 + ((line & 1) << 3)];
217	packet[1] = hamming[line >> 1];
218	memset(packet + 2, 0x20, 40);
219	if (line == 0) {
220		/* subcode */
221		packet[2] = hamming[frame % 10];
222		packet[3] = hamming[frame / 10];
223		packet[4] = hamming[0];
224		packet[5] = hamming[0];
225		packet[6] = hamming[0];
226		packet[7] = hamming[0];
227		packet[8] = hamming[0];
228		packet[9] = hamming[1];
229		offset = 10;
230	}
231	packet += offset;
232	memcpy(packet, "Page: 100 Row: 10", 17);
233	packet[7] = '0' + frame / 10;
234	packet[8] = '0' + frame % 10;
235	packet[15] = '0' + line / 10;
236	packet[16] = '0' + line % 10;
237	for (i = 0; i < 42 - offset; i++)
238		packet[i] = calc_parity(packet[i]);
239}
240
241void vivid_vbi_gen_sliced(struct vivid_vbi_gen_data *vbi,
242		bool is_60hz, unsigned seqnr)
243{
244	struct v4l2_sliced_vbi_data *data0 = vbi->data;
245	struct v4l2_sliced_vbi_data *data1 = vbi->data + 1;
246	unsigned frame = seqnr % 60;
247
248	memset(vbi->data, 0, sizeof(vbi->data));
249
250	if (!is_60hz) {
251		unsigned i;
252
253		for (i = 0; i <= 11; i++) {
254			data0->id = V4L2_SLICED_TELETEXT_B;
255			data0->line = 7 + i;
256			vivid_vbi_gen_teletext(data0->data, i, frame);
257			data0++;
258		}
259		data0->id = V4L2_SLICED_WSS_625;
260		data0->line = 23;
261		/* 4x3 video aspect ratio */
262		data0->data[0] = 0x08;
263		data0++;
264		for (i = 0; i <= 11; i++) {
265			data0->id = V4L2_SLICED_TELETEXT_B;
266			data0->field = 1;
267			data0->line = 7 + i;
268			vivid_vbi_gen_teletext(data0->data, 12 + i, frame);
269			data0++;
270		}
271		return;
272	}
273
274	data0->id = V4L2_SLICED_CAPTION_525;
275	data0->line = 21;
276	data1->id = V4L2_SLICED_CAPTION_525;
277	data1->field = 1;
278	data1->line = 21;
279
280	if (frame < 15) {
281		data0->data[0] = calc_parity(vivid_cc_sequence1[2 * frame]);
282		data0->data[1] = calc_parity(vivid_cc_sequence1[2 * frame + 1]);
283	} else if (frame >= 30 && frame < 45) {
284		frame -= 30;
285		data0->data[0] = calc_parity(vivid_cc_sequence2[2 * frame]);
286		data0->data[1] = calc_parity(vivid_cc_sequence2[2 * frame + 1]);
287	} else {
288		data0->data[0] = calc_parity(0);
289		data0->data[1] = calc_parity(0);
290	}
291
292	frame = seqnr % (30 * 60);
293	switch (frame) {
294	case 0:
295		vivid_vbi_gen_set_time_of_day(vbi->time_of_day_packet);
296		fallthrough;
297	case 1 ... 7:
298		data1->data[0] = vbi->time_of_day_packet[frame * 2];
299		data1->data[1] = vbi->time_of_day_packet[frame * 2 + 1];
300		break;
301	default:
302		data1->data[0] = calc_parity(0);
303		data1->data[1] = calc_parity(0);
304		break;
305	}
306}