1	// SPDX-License-Identifier: GPL-2.0
2	/*
3	* This file contains the logic to work with MPEG Program-Specific Information.
4	* These are defined both in ISO/IEC 13818-1 (systems) and ETSI EN 300 468.
5	* PSI is carried in the form of table structures, and although each table might
6	* technically be broken into one or more sections, we do not do this here,
7	* hence 'table' and 'section' are interchangeable for vidtv.
8	*
9	* Copyright (C) 2020 Daniel W. S. Almeida
10	*/
11
12	#define pr_fmt(fmt) KBUILD_MODNAME ":%s, %d: " fmt, __func__, __LINE__
13
14	#include <linux/bcd.h>
15	#include <linux/crc32.h>
16	#include <linux/kernel.h>
17	#include <linux/ktime.h>
18	#include <linux/printk.h>
19	#include <linux/ratelimit.h>
20	#include <linux/slab.h>
21	#include <linux/string.h>
22	#include <linux/time.h>
23	#include <linux/types.h>
24
25	#include "vidtv_common.h"
26	#include "vidtv_psi.h"
27	#include "vidtv_ts.h"
28
29	#define CRC_SIZE_IN_BYTES 4
30	#define MAX_VERSION_NUM 32
31	#define INITIAL_CRC 0xffffffff
32	#define ISO_LANGUAGE_CODE_LEN 3
33
34	static const u32 CRC_LUT[256] = {
35	/* from libdvbv5 */
36	0x00000000, 0x04c11db7, 0x09823b6e, 0x0d4326d9, 0x130476dc, 0x17c56b6b,
37	0x1a864db2, 0x1e475005, 0x2608edb8, 0x22c9f00f, 0x2f8ad6d6, 0x2b4bcb61,
38	0x350c9b64, 0x31cd86d3, 0x3c8ea00a, 0x384fbdbd, 0x4c11db70, 0x48d0c6c7,
39	0x4593e01e, 0x4152fda9, 0x5f15adac, 0x5bd4b01b, 0x569796c2, 0x52568b75,
40	0x6a1936c8, 0x6ed82b7f, 0x639b0da6, 0x675a1011, 0x791d4014, 0x7ddc5da3,
41	0x709f7b7a, 0x745e66cd, 0x9823b6e0, 0x9ce2ab57, 0x91a18d8e, 0x95609039,
42	0x8b27c03c, 0x8fe6dd8b, 0x82a5fb52, 0x8664e6e5, 0xbe2b5b58, 0xbaea46ef,
43	0xb7a96036, 0xb3687d81, 0xad2f2d84, 0xa9ee3033, 0xa4ad16ea, 0xa06c0b5d,
44	0xd4326d90, 0xd0f37027, 0xddb056fe, 0xd9714b49, 0xc7361b4c, 0xc3f706fb,
45	0xceb42022, 0xca753d95, 0xf23a8028, 0xf6fb9d9f, 0xfbb8bb46, 0xff79a6f1,
46	0xe13ef6f4, 0xe5ffeb43, 0xe8bccd9a, 0xec7dd02d, 0x34867077, 0x30476dc0,
47	0x3d044b19, 0x39c556ae, 0x278206ab, 0x23431b1c, 0x2e003dc5, 0x2ac12072,
48	0x128e9dcf, 0x164f8078, 0x1b0ca6a1, 0x1fcdbb16, 0x018aeb13, 0x054bf6a4,
49	0x0808d07d, 0x0cc9cdca, 0x7897ab07, 0x7c56b6b0, 0x71159069, 0x75d48dde,
50	0x6b93dddb, 0x6f52c06c, 0x6211e6b5, 0x66d0fb02, 0x5e9f46bf, 0x5a5e5b08,
51	0x571d7dd1, 0x53dc6066, 0x4d9b3063, 0x495a2dd4, 0x44190b0d, 0x40d816ba,
52	0xaca5c697, 0xa864db20, 0xa527fdf9, 0xa1e6e04e, 0xbfa1b04b, 0xbb60adfc,
53	0xb6238b25, 0xb2e29692, 0x8aad2b2f, 0x8e6c3698, 0x832f1041, 0x87ee0df6,
54	0x99a95df3, 0x9d684044, 0x902b669d, 0x94ea7b2a, 0xe0b41de7, 0xe4750050,
55	0xe9362689, 0xedf73b3e, 0xf3b06b3b, 0xf771768c, 0xfa325055, 0xfef34de2,
56	0xc6bcf05f, 0xc27dede8, 0xcf3ecb31, 0xcbffd686, 0xd5b88683, 0xd1799b34,
57	0xdc3abded, 0xd8fba05a, 0x690ce0ee, 0x6dcdfd59, 0x608edb80, 0x644fc637,
58	0x7a089632, 0x7ec98b85, 0x738aad5c, 0x774bb0eb, 0x4f040d56, 0x4bc510e1,
59	0x46863638, 0x42472b8f, 0x5c007b8a, 0x58c1663d, 0x558240e4, 0x51435d53,
60	0x251d3b9e, 0x21dc2629, 0x2c9f00f0, 0x285e1d47, 0x36194d42, 0x32d850f5,
61	0x3f9b762c, 0x3b5a6b9b, 0x0315d626, 0x07d4cb91, 0x0a97ed48, 0x0e56f0ff,
62	0x1011a0fa, 0x14d0bd4d, 0x19939b94, 0x1d528623, 0xf12f560e, 0xf5ee4bb9,
63	0xf8ad6d60, 0xfc6c70d7, 0xe22b20d2, 0xe6ea3d65, 0xeba91bbc, 0xef68060b,
64	0xd727bbb6, 0xd3e6a601, 0xdea580d8, 0xda649d6f, 0xc423cd6a, 0xc0e2d0dd,
65	0xcda1f604, 0xc960ebb3, 0xbd3e8d7e, 0xb9ff90c9, 0xb4bcb610, 0xb07daba7,
66	0xae3afba2, 0xaafbe615, 0xa7b8c0cc, 0xa379dd7b, 0x9b3660c6, 0x9ff77d71,
67	0x92b45ba8, 0x9675461f, 0x8832161a, 0x8cf30bad, 0x81b02d74, 0x857130c3,
68	0x5d8a9099, 0x594b8d2e, 0x5408abf7, 0x50c9b640, 0x4e8ee645, 0x4a4ffbf2,
69	0x470cdd2b, 0x43cdc09c, 0x7b827d21, 0x7f436096, 0x7200464f, 0x76c15bf8,
70	0x68860bfd, 0x6c47164a, 0x61043093, 0x65c52d24, 0x119b4be9, 0x155a565e,
71	0x18197087, 0x1cd86d30, 0x029f3d35, 0x065e2082, 0x0b1d065b, 0x0fdc1bec,
72	0x3793a651, 0x3352bbe6, 0x3e119d3f, 0x3ad08088, 0x2497d08d, 0x2056cd3a,
73	0x2d15ebe3, 0x29d4f654, 0xc5a92679, 0xc1683bce, 0xcc2b1d17, 0xc8ea00a0,
74	0xd6ad50a5, 0xd26c4d12, 0xdf2f6bcb, 0xdbee767c, 0xe3a1cbc1, 0xe760d676,
75	0xea23f0af, 0xeee2ed18, 0xf0a5bd1d, 0xf464a0aa, 0xf9278673, 0xfde69bc4,
76	0x89b8fd09, 0x8d79e0be, 0x803ac667, 0x84fbdbd0, 0x9abc8bd5, 0x9e7d9662,
77	0x933eb0bb, 0x97ffad0c, 0xafb010b1, 0xab710d06, 0xa6322bdf, 0xa2f33668,
78	0xbcb4666d, 0xb8757bda, 0xb5365d03, 0xb1f740b4
79	};
80
81	static u32 dvb_crc32(u32 crc, u8 *data, u32 len)
82	{
83	/* from libdvbv5 */
84	while (len--)
85	crc = (crc << 8) ^ CRC_LUT[((crc >> 24) ^ *data++) & 0xff];
86	return crc;
87	}
88
89	static void vidtv_psi_update_version_num(struct vidtv_psi_table_header *h)
90	{
91	h->version++;
92	}
93
94	static u16 vidtv_psi_get_sec_len(struct vidtv_psi_table_header *h)
95	{
96	u16 mask;
97
98	mask = GENMASK(11, 0);
99
100	return be16_to_cpu(h->bitfield) & mask;
101	}
102
103	u16 vidtv_psi_get_pat_program_pid(struct vidtv_psi_table_pat_program *p)
104	{
105	u16 mask;
106
107	mask = GENMASK(12, 0);
108
109	return be16_to_cpu(p->bitfield) & mask;
110	}
111
112	u16 vidtv_psi_pmt_stream_get_elem_pid(struct vidtv_psi_table_pmt_stream *s)
113	{
114	u16 mask;
115
116	mask = GENMASK(12, 0);
117
118	return be16_to_cpu(s->bitfield) & mask;
119	}
120
121	static void vidtv_psi_set_desc_loop_len(__be16 *bitfield, u16 new_len,
122	u8 desc_len_nbits)
123	{
124	__be16 new;
125	u16 mask;
126
127	mask = GENMASK(15, desc_len_nbits);
128
129	new = cpu_to_be16((be16_to_cpu(*bitfield) & mask) | new_len);
130	*bitfield = new;
131	}
132
133	static void vidtv_psi_set_sec_len(struct vidtv_psi_table_header *h, u16 new_len)
134	{
135	u16 old_len = vidtv_psi_get_sec_len(h);
136	__be16 new;
137	u16 mask;
138
139	mask = GENMASK(15, 13);
140
141	new = cpu_to_be16((be16_to_cpu(h->bitfield) & mask) | new_len);
142
143	if (old_len > MAX_SECTION_LEN)
144	pr_warn_ratelimited("section length: %d > %d, old len was %d\n",
145	new_len,
146	MAX_SECTION_LEN,
147	old_len);
148
149	h->bitfield = new;
150	}
151
152	/*
153	* Packetize PSI sections into TS packets:
154	* push a TS header (4bytes) every 184 bytes
155	* manage the continuity_counter
156	* add stuffing (i.e. padding bytes) after the CRC
157	*/
158	static u32 vidtv_psi_ts_psi_write_into(struct psi_write_args *args)
159	{
160	struct vidtv_mpeg_ts ts_header = {
161	.sync_byte = TS_SYNC_BYTE,
162	.bitfield = cpu_to_be16((args->new_psi_section << 14) | args->pid),
163	.scrambling = 0,
164	.payload = 1,
165	.adaptation_field = 0, /* no adaptation field */
166	};
167	u32 nbytes_past_boundary = (args->dest_offset % TS_PACKET_LEN);
168	bool aligned = (nbytes_past_boundary == 0);
169	u32 remaining_len = args->len;
170	u32 payload_write_len = 0;
171	u32 payload_offset = 0;
172	u32 nbytes = 0;
173
174	if (!args->crc && !args->is_crc)
175	pr_warn_ratelimited("Missing CRC for chunk\n");
176
177	if (args->crc)
178	*args->crc = dvb_crc32(crc: *args->crc, data: args->from, len: args->len);
179
180	if (args->new_psi_section && !aligned) {
181	pr_warn_ratelimited("Cannot write a new PSI section in a misaligned buffer\n");
182
183	/* forcibly align and hope for the best */
184	nbytes += vidtv_memset(to: args->dest_buf,
185	to_offset: args->dest_offset + nbytes,
186	to_size: args->dest_buf_sz,
187	TS_FILL_BYTE,
188	TS_PACKET_LEN - nbytes_past_boundary);
189	}
190
191	while (remaining_len) {
192	nbytes_past_boundary = (args->dest_offset + nbytes) % TS_PACKET_LEN;
193	aligned = (nbytes_past_boundary == 0);
194
195	if (aligned) {
196	/* if at a packet boundary, write a new TS header */
197	ts_header.continuity_counter = *args->continuity_counter;
198
199	nbytes += vidtv_memcpy(to: args->dest_buf,
200	to_offset: args->dest_offset + nbytes,
201	to_size: args->dest_buf_sz,
202	from: &ts_header,
203	len: sizeof(ts_header));
204	/*
205	* This will trigger a discontinuity if the buffer is full,
206	* effectively dropping the packet.
207	*/
208	vidtv_ts_inc_cc(continuity_counter: args->continuity_counter);
209	}
210
211	/* write the pointer_field in the first byte of the payload */
212	if (args->new_psi_section)
213	nbytes += vidtv_memset(to: args->dest_buf,
214	to_offset: args->dest_offset + nbytes,
215	to_size: args->dest_buf_sz,
216	c: 0x0,
217	len: 1);
218
219	/* write as much of the payload as possible */
220	nbytes_past_boundary = (args->dest_offset + nbytes) % TS_PACKET_LEN;
221	payload_write_len = min(TS_PACKET_LEN - nbytes_past_boundary, remaining_len);
222
223	nbytes += vidtv_memcpy(to: args->dest_buf,
224	to_offset: args->dest_offset + nbytes,
225	to_size: args->dest_buf_sz,
226	from: args->from + payload_offset,
227	len: payload_write_len);
228
229	/* 'payload_write_len' written from a total of 'len' requested*/
230	remaining_len -= payload_write_len;
231	payload_offset += payload_write_len;
232	}
233
234	/*
235	* fill the rest of the packet if there is any remaining space unused
236	*/
237
238	nbytes_past_boundary = (args->dest_offset + nbytes) % TS_PACKET_LEN;
239
240	if (args->is_crc)
241	nbytes += vidtv_memset(to: args->dest_buf,
242	to_offset: args->dest_offset + nbytes,
243	to_size: args->dest_buf_sz,
244	TS_FILL_BYTE,
245	TS_PACKET_LEN - nbytes_past_boundary);
246
247	return nbytes;
248	}
249
250	static u32 table_section_crc32_write_into(struct crc32_write_args *args)
251	{
252	struct psi_write_args psi_args = {
253	.dest_buf = args->dest_buf,
254	.from = &args->crc,
255	.len = CRC_SIZE_IN_BYTES,
256	.dest_offset = args->dest_offset,
257	.pid = args->pid,
258	.new_psi_section = false,
259	.continuity_counter = args->continuity_counter,
260	.is_crc = true,
261	.dest_buf_sz = args->dest_buf_sz,
262	};
263
264	/* the CRC is the last entry in the section */
265
266	return vidtv_psi_ts_psi_write_into(args: &psi_args);
267	}
268
269	static void vidtv_psi_desc_chain(struct vidtv_psi_desc *head, struct vidtv_psi_desc *desc)
270	{
271	if (head) {
272	while (head->next)
273	head = head->next;
274
275	head->next = desc;
276	}
277	}
278
279	struct vidtv_psi_desc_service *vidtv_psi_service_desc_init(struct vidtv_psi_desc *head,
280	enum service_type service_type,
281	char *service_name,
282	char *provider_name)
283	{
284	struct vidtv_psi_desc_service *desc;
285	u32 service_name_len = service_name ? strlen(service_name) : 0;
286	u32 provider_name_len = provider_name ? strlen(provider_name) : 0;
287
288	desc = kzalloc(size: sizeof(*desc), GFP_KERNEL);
289	if (!desc)
290	return NULL;
291
292	desc->type = SERVICE_DESCRIPTOR;
293
294	desc->length = sizeof_field(struct vidtv_psi_desc_service, service_type)
295	+ sizeof_field(struct vidtv_psi_desc_service, provider_name_len)
296	+ provider_name_len
297	+ sizeof_field(struct vidtv_psi_desc_service, service_name_len)
298	+ service_name_len;
299
300	desc->service_type = service_type;
301
302	desc->service_name_len = service_name_len;
303
304	if (service_name && service_name_len) {
305	desc->service_name = kstrdup(s: service_name, GFP_KERNEL);
306	if (!desc->service_name)
307	goto free_desc;
308	}
309
310	desc->provider_name_len = provider_name_len;
311
312	if (provider_name && provider_name_len) {
313	desc->provider_name = kstrdup(s: provider_name, GFP_KERNEL);
314	if (!desc->provider_name)
315	goto free_desc_service_name;
316	}
317
318	vidtv_psi_desc_chain(head, desc: (struct vidtv_psi_desc *)desc);
319	return desc;
320
321	free_desc_service_name:
322	if (service_name && service_name_len)
323	kfree(objp: desc->service_name);
324	free_desc:
325	kfree(objp: desc);
326	return NULL;
327	}
328
329	struct vidtv_psi_desc_registration
330	*vidtv_psi_registration_desc_init(struct vidtv_psi_desc *head,
331	__be32 format_id,
332	u8 *additional_ident_info,
333	u32 additional_info_len)
334	{
335	struct vidtv_psi_desc_registration *desc;
336
337	desc = kzalloc(size: sizeof(*desc) + sizeof(format_id) + additional_info_len, GFP_KERNEL);
338	if (!desc)
339	return NULL;
340
341	desc->type = REGISTRATION_DESCRIPTOR;
342
343	desc->length = sizeof_field(struct vidtv_psi_desc_registration, format_id)
344	+ additional_info_len;
345
346	desc->format_id = format_id;
347
348	if (additional_ident_info && additional_info_len)
349	memcpy(desc->additional_identification_info,
350	additional_ident_info,
351	additional_info_len);
352
353	vidtv_psi_desc_chain(head, desc: (struct vidtv_psi_desc *)desc);
354	return desc;
355	}
356
357	struct vidtv_psi_desc_network_name
358	*vidtv_psi_network_name_desc_init(struct vidtv_psi_desc *head, char *network_name)
359	{
360	u32 network_name_len = network_name ? strlen(network_name) : 0;
361	struct vidtv_psi_desc_network_name *desc;
362
363	desc = kzalloc(size: sizeof(*desc), GFP_KERNEL);
364	if (!desc)
365	return NULL;
366
367	desc->type = NETWORK_NAME_DESCRIPTOR;
368
369	desc->length = network_name_len;
370
371	if (network_name && network_name_len) {
372	desc->network_name = kstrdup(s: network_name, GFP_KERNEL);
373	if (!desc->network_name) {
374	kfree(objp: desc);
375	return NULL;
376	}
377	}
378
379	vidtv_psi_desc_chain(head, desc: (struct vidtv_psi_desc *)desc);
380	return desc;
381	}
382
383	struct vidtv_psi_desc_service_list
384	*vidtv_psi_service_list_desc_init(struct vidtv_psi_desc *head,
385	struct vidtv_psi_desc_service_list_entry *entry)
386	{
387	struct vidtv_psi_desc_service_list_entry *curr_e = NULL;
388	struct vidtv_psi_desc_service_list_entry *head_e = NULL;
389	struct vidtv_psi_desc_service_list_entry *prev_e = NULL;
390	struct vidtv_psi_desc_service_list *desc;
391	u16 length = 0;
392
393	desc = kzalloc(size: sizeof(*desc), GFP_KERNEL);
394	if (!desc)
395	return NULL;
396
397	desc->type = SERVICE_LIST_DESCRIPTOR;
398
399	while (entry) {
400	curr_e = kzalloc(size: sizeof(*curr_e), GFP_KERNEL);
401	if (!curr_e) {
402	while (head_e) {
403	curr_e = head_e;
404	head_e = head_e->next;
405	kfree(objp: curr_e);
406	}
407	kfree(objp: desc);
408	return NULL;
409	}
410
411	curr_e->service_id = entry->service_id;
412	curr_e->service_type = entry->service_type;
413
414	length += sizeof(struct vidtv_psi_desc_service_list_entry) -
415	sizeof(struct vidtv_psi_desc_service_list_entry *);
416
417	if (!head_e)
418	head_e = curr_e;
419	if (prev_e)
420	prev_e->next = curr_e;
421
422	prev_e = curr_e;
423	entry = entry->next;
424	}
425
426	desc->length = length;
427	desc->service_list = head_e;
428
429	vidtv_psi_desc_chain(head, desc: (struct vidtv_psi_desc *)desc);
430	return desc;
431	}
432
433	struct vidtv_psi_desc_short_event
434	*vidtv_psi_short_event_desc_init(struct vidtv_psi_desc *head,
435	char *iso_language_code,
436	char *event_name,
437	char *text)
438	{
439	u32 iso_len = iso_language_code ? strlen(iso_language_code) : 0;
440	u32 event_name_len = event_name ? strlen(event_name) : 0;
441	struct vidtv_psi_desc_short_event *desc;
442	u32 text_len = text ? strlen(text) : 0;
443
444	desc = kzalloc(size: sizeof(*desc), GFP_KERNEL);
445	if (!desc)
446	return NULL;
447
448	desc->type = SHORT_EVENT_DESCRIPTOR;
449
450	desc->length = ISO_LANGUAGE_CODE_LEN +
451	sizeof_field(struct vidtv_psi_desc_short_event, event_name_len) +
452	event_name_len +
453	sizeof_field(struct vidtv_psi_desc_short_event, text_len) +
454	text_len;
455
456	desc->event_name_len = event_name_len;
457	desc->text_len = text_len;
458
459	if (iso_len != ISO_LANGUAGE_CODE_LEN)
460	iso_language_code = "eng";
461
462	desc->iso_language_code = kstrdup(s: iso_language_code, GFP_KERNEL);
463	if (!desc->iso_language_code)
464	goto free_desc;
465
466	if (event_name && event_name_len) {
467	desc->event_name = kstrdup(s: event_name, GFP_KERNEL);
468	if (!desc->event_name)
469	goto free_desc_language_code;
470	}
471
472	if (text && text_len) {
473	desc->text = kstrdup(s: text, GFP_KERNEL);
474	if (!desc->text)
475	goto free_desc_event_name;
476	}
477
478	vidtv_psi_desc_chain(head, desc: (struct vidtv_psi_desc *)desc);
479	return desc;
480
481	free_desc_event_name:
482	if (event_name && event_name_len)
483	kfree(objp: desc->event_name);
484	free_desc_language_code:
485	kfree(objp: desc->iso_language_code);
486	free_desc:
487	kfree(objp: desc);
488	return NULL;
489	}
490
491	struct vidtv_psi_desc *vidtv_psi_desc_clone(struct vidtv_psi_desc *desc)
492	{
493	struct vidtv_psi_desc_network_name *desc_network_name;
494	struct vidtv_psi_desc_service_list *desc_service_list;
495	struct vidtv_psi_desc_short_event *desc_short_event;
496	struct vidtv_psi_desc_service *service;
497	struct vidtv_psi_desc *head = NULL;
498	struct vidtv_psi_desc *prev = NULL;
499	struct vidtv_psi_desc *curr = NULL;
500
501	while (desc) {
502	switch (desc->type) {
503	case SERVICE_DESCRIPTOR:
504	service = (struct vidtv_psi_desc_service *)desc;
505	curr = (struct vidtv_psi_desc *)
506	vidtv_psi_service_desc_init(head,
507	service_type: service->service_type,
508	service_name: service->service_name,
509	provider_name: service->provider_name);
510	break;
511
512	case NETWORK_NAME_DESCRIPTOR:
513	desc_network_name = (struct vidtv_psi_desc_network_name *)desc;
514	curr = (struct vidtv_psi_desc *)
515	vidtv_psi_network_name_desc_init(head,
516	network_name: desc_network_name->network_name);
517	break;
518
519	case SERVICE_LIST_DESCRIPTOR:
520	desc_service_list = (struct vidtv_psi_desc_service_list *)desc;
521	curr = (struct vidtv_psi_desc *)
522	vidtv_psi_service_list_desc_init(head,
523	entry: desc_service_list->service_list);
524	break;
525
526	case SHORT_EVENT_DESCRIPTOR:
527	desc_short_event = (struct vidtv_psi_desc_short_event *)desc;
528	curr = (struct vidtv_psi_desc *)
529	vidtv_psi_short_event_desc_init(head,
530	iso_language_code: desc_short_event->iso_language_code,
531	event_name: desc_short_event->event_name,
532	text: desc_short_event->text);
533	break;
534
535	case REGISTRATION_DESCRIPTOR:
536	default:
537	curr = kmemdup(p: desc, size: sizeof(*desc) + desc->length, GFP_KERNEL);
538	if (!curr)
539	return NULL;
540	}
541
542	if (!curr)
543	return NULL;
544
545	curr->next = NULL;
546	if (!head)
547	head = curr;
548	if (prev)
549	prev->next = curr;
550
551	prev = curr;
552	desc = desc->next;
553	}
554
555	return head;
556	}
557
558	void vidtv_psi_desc_destroy(struct vidtv_psi_desc *desc)
559	{
560	struct vidtv_psi_desc_service_list_entry *sl_entry_tmp = NULL;
561	struct vidtv_psi_desc_service_list_entry *sl_entry = NULL;
562	struct vidtv_psi_desc *curr = desc;
563	struct vidtv_psi_desc *tmp = NULL;
564
565	while (curr) {
566	tmp = curr;
567	curr = curr->next;
568
569	switch (tmp->type) {
570	case SERVICE_DESCRIPTOR:
571	kfree(objp: ((struct vidtv_psi_desc_service *)tmp)->provider_name);
572	kfree(objp: ((struct vidtv_psi_desc_service *)tmp)->service_name);
573
574	break;
575	case REGISTRATION_DESCRIPTOR:
576	/* nothing to do */
577	break;
578
579	case NETWORK_NAME_DESCRIPTOR:
580	kfree(objp: ((struct vidtv_psi_desc_network_name *)tmp)->network_name);
581	break;
582
583	case SERVICE_LIST_DESCRIPTOR:
584	sl_entry = ((struct vidtv_psi_desc_service_list *)tmp)->service_list;
585	while (sl_entry) {
586	sl_entry_tmp = sl_entry;
587	sl_entry = sl_entry->next;
588	kfree(objp: sl_entry_tmp);
589	}
590	break;
591
592	case SHORT_EVENT_DESCRIPTOR:
593	kfree(objp: ((struct vidtv_psi_desc_short_event *)tmp)->iso_language_code);
594	kfree(objp: ((struct vidtv_psi_desc_short_event *)tmp)->event_name);
595	kfree(objp: ((struct vidtv_psi_desc_short_event *)tmp)->text);
596	break;
597
598	default:
599	pr_warn_ratelimited("Possible leak: not handling descriptor type %d\n",
600	tmp->type);
601	break;
602	}
603
604	kfree(objp: tmp);
605	}
606	}
607
608	static u16
609	vidtv_psi_desc_comp_loop_len(struct vidtv_psi_desc *desc)
610	{
611	u32 length = 0;
612
613	if (!desc)
614	return 0;
615
616	while (desc) {
617	length += sizeof_field(struct vidtv_psi_desc, type);
618	length += sizeof_field(struct vidtv_psi_desc, length);
619	length += desc->length; /* from 'length' field until the end of the descriptor */
620	desc = desc->next;
621	}
622
623	return length;
624	}
625
626	void vidtv_psi_desc_assign(struct vidtv_psi_desc **to,
627	struct vidtv_psi_desc *desc)
628	{
629	if (desc == *to)
630	return;
631
632	if (*to)
633	vidtv_psi_desc_destroy(desc: *to);
634
635	*to = desc;
636	}
637
638	void vidtv_pmt_desc_assign(struct vidtv_psi_table_pmt *pmt,
639	struct vidtv_psi_desc **to,
640	struct vidtv_psi_desc *desc)
641	{
642	vidtv_psi_desc_assign(to, desc);
643	vidtv_psi_pmt_table_update_sec_len(pmt);
644
645	if (vidtv_psi_get_sec_len(h: &pmt->header) > MAX_SECTION_LEN)
646	vidtv_psi_desc_assign(to, NULL);
647
648	vidtv_psi_update_version_num(h: &pmt->header);
649	}
650
651	void vidtv_sdt_desc_assign(struct vidtv_psi_table_sdt *sdt,
652	struct vidtv_psi_desc **to,
653	struct vidtv_psi_desc *desc)
654	{
655	vidtv_psi_desc_assign(to, desc);
656	vidtv_psi_sdt_table_update_sec_len(sdt);
657
658	if (vidtv_psi_get_sec_len(h: &sdt->header) > MAX_SECTION_LEN)
659	vidtv_psi_desc_assign(to, NULL);
660
661	vidtv_psi_update_version_num(h: &sdt->header);
662	}
663
664	static u32 vidtv_psi_desc_write_into(struct desc_write_args *args)
665	{
666	struct psi_write_args psi_args = {
667	.dest_buf = args->dest_buf,
668	.from = &args->desc->type,
669	.pid = args->pid,
670	.new_psi_section = false,
671	.continuity_counter = args->continuity_counter,
672	.is_crc = false,
673	.dest_buf_sz = args->dest_buf_sz,
674	.crc = args->crc,
675	.len = sizeof_field(struct vidtv_psi_desc, type) +
676	sizeof_field(struct vidtv_psi_desc, length),
677	};
678	struct vidtv_psi_desc_service_list_entry *serv_list_entry = NULL;
679	u32 nbytes = 0;
680
681	psi_args.dest_offset = args->dest_offset + nbytes;
682
683	nbytes += vidtv_psi_ts_psi_write_into(args: &psi_args);
684
685	switch (args->desc->type) {
686	case SERVICE_DESCRIPTOR:
687	psi_args.dest_offset = args->dest_offset + nbytes;
688	psi_args.len = sizeof_field(struct vidtv_psi_desc_service, service_type) +
689	sizeof_field(struct vidtv_psi_desc_service, provider_name_len);
690	psi_args.from = &((struct vidtv_psi_desc_service *)args->desc)->service_type;
691
692	nbytes += vidtv_psi_ts_psi_write_into(args: &psi_args);
693
694	psi_args.dest_offset = args->dest_offset + nbytes;
695	psi_args.len = ((struct vidtv_psi_desc_service *)args->desc)->provider_name_len;
696	psi_args.from = ((struct vidtv_psi_desc_service *)args->desc)->provider_name;
697
698	nbytes += vidtv_psi_ts_psi_write_into(args: &psi_args);
699
700	psi_args.dest_offset = args->dest_offset + nbytes;
701	psi_args.len = sizeof_field(struct vidtv_psi_desc_service, service_name_len);
702	psi_args.from = &((struct vidtv_psi_desc_service *)args->desc)->service_name_len;
703
704	nbytes += vidtv_psi_ts_psi_write_into(args: &psi_args);
705
706	psi_args.dest_offset = args->dest_offset + nbytes;
707	psi_args.len = ((struct vidtv_psi_desc_service *)args->desc)->service_name_len;
708	psi_args.from = ((struct vidtv_psi_desc_service *)args->desc)->service_name;
709
710	nbytes += vidtv_psi_ts_psi_write_into(args: &psi_args);
711	break;
712
713	case NETWORK_NAME_DESCRIPTOR:
714	psi_args.dest_offset = args->dest_offset + nbytes;
715	psi_args.len = args->desc->length;
716	psi_args.from = ((struct vidtv_psi_desc_network_name *)args->desc)->network_name;
717
718	nbytes += vidtv_psi_ts_psi_write_into(args: &psi_args);
719	break;
720
721	case SERVICE_LIST_DESCRIPTOR:
722	serv_list_entry = ((struct vidtv_psi_desc_service_list *)args->desc)->service_list;
723	while (serv_list_entry) {
724	psi_args.dest_offset = args->dest_offset + nbytes;
725	psi_args.len = sizeof(struct vidtv_psi_desc_service_list_entry) -
726	sizeof(struct vidtv_psi_desc_service_list_entry *);
727	psi_args.from = serv_list_entry;
728
729	nbytes += vidtv_psi_ts_psi_write_into(args: &psi_args);
730
731	serv_list_entry = serv_list_entry->next;
732	}
733	break;
734
735	case SHORT_EVENT_DESCRIPTOR:
736	psi_args.dest_offset = args->dest_offset + nbytes;
737	psi_args.len = ISO_LANGUAGE_CODE_LEN;
738	psi_args.from = ((struct vidtv_psi_desc_short_event *)
739	args->desc)->iso_language_code;
740
741	nbytes += vidtv_psi_ts_psi_write_into(args: &psi_args);
742
743	psi_args.dest_offset = args->dest_offset + nbytes;
744	psi_args.len = sizeof_field(struct vidtv_psi_desc_short_event, event_name_len);
745	psi_args.from = &((struct vidtv_psi_desc_short_event *)
746	args->desc)->event_name_len;
747
748	nbytes += vidtv_psi_ts_psi_write_into(args: &psi_args);
749
750	psi_args.dest_offset = args->dest_offset + nbytes;
751	psi_args.len = ((struct vidtv_psi_desc_short_event *)args->desc)->event_name_len;
752	psi_args.from = ((struct vidtv_psi_desc_short_event *)args->desc)->event_name;
753
754	nbytes += vidtv_psi_ts_psi_write_into(args: &psi_args);
755
756	psi_args.dest_offset = args->dest_offset + nbytes;
757	psi_args.len = sizeof_field(struct vidtv_psi_desc_short_event, text_len);
758	psi_args.from = &((struct vidtv_psi_desc_short_event *)args->desc)->text_len;
759
760	nbytes += vidtv_psi_ts_psi_write_into(args: &psi_args);
761
762	psi_args.dest_offset = args->dest_offset + nbytes;
763	psi_args.len = ((struct vidtv_psi_desc_short_event *)args->desc)->text_len;
764	psi_args.from = ((struct vidtv_psi_desc_short_event *)args->desc)->text;
765
766	nbytes += vidtv_psi_ts_psi_write_into(args: &psi_args);
767
768	break;
769
770	case REGISTRATION_DESCRIPTOR:
771	default:
772	psi_args.dest_offset = args->dest_offset + nbytes;
773	psi_args.len = args->desc->length;
774	psi_args.from = &args->desc->data;
775
776	nbytes += vidtv_psi_ts_psi_write_into(args: &psi_args);
777	break;
778	}
779
780	return nbytes;
781	}
782
783	static u32
784	vidtv_psi_table_header_write_into(struct header_write_args *args)
785	{
786	struct psi_write_args psi_args = {
787	.dest_buf = args->dest_buf,
788	.from = args->h,
789	.len = sizeof(struct vidtv_psi_table_header),
790	.dest_offset = args->dest_offset,
791	.pid = args->pid,
792	.new_psi_section = true,
793	.continuity_counter = args->continuity_counter,
794	.is_crc = false,
795	.dest_buf_sz = args->dest_buf_sz,
796	.crc = args->crc,
797	};
798
799	return vidtv_psi_ts_psi_write_into(args: &psi_args);
800	}
801
802	void
803	vidtv_psi_pat_table_update_sec_len(struct vidtv_psi_table_pat *pat)
804	{
805	u16 length = 0;
806	u32 i;
807
808	/* see ISO/IEC 13818-1 : 2000 p.43 */
809
810	/* from immediately after 'section_length' until 'last_section_number'*/
811	length += PAT_LEN_UNTIL_LAST_SECTION_NUMBER;
812
813	/* do not count the pointer */
814	for (i = 0; i < pat->num_pat; ++i)
815	length += sizeof(struct vidtv_psi_table_pat_program) -
816	sizeof(struct vidtv_psi_table_pat_program *);
817
818	length += CRC_SIZE_IN_BYTES;
819
820	vidtv_psi_set_sec_len(h: &pat->header, new_len: length);
821	}
822
823	void vidtv_psi_pmt_table_update_sec_len(struct vidtv_psi_table_pmt *pmt)
824	{
825	struct vidtv_psi_table_pmt_stream *s = pmt->stream;
826	u16 desc_loop_len;
827	u16 length = 0;
828
829	/* see ISO/IEC 13818-1 : 2000 p.46 */
830
831	/* from immediately after 'section_length' until 'program_info_length'*/
832	length += PMT_LEN_UNTIL_PROGRAM_INFO_LENGTH;
833
834	desc_loop_len = vidtv_psi_desc_comp_loop_len(desc: pmt->descriptor);
835	vidtv_psi_set_desc_loop_len(bitfield: &pmt->bitfield2, new_len: desc_loop_len, desc_len_nbits: 10);
836
837	length += desc_loop_len;
838
839	while (s) {
840	/* skip both pointers at the end */
841	length += sizeof(struct vidtv_psi_table_pmt_stream) -
842	sizeof(struct vidtv_psi_desc *) -
843	sizeof(struct vidtv_psi_table_pmt_stream *);
844
845	desc_loop_len = vidtv_psi_desc_comp_loop_len(desc: s->descriptor);
846	vidtv_psi_set_desc_loop_len(bitfield: &s->bitfield2, new_len: desc_loop_len, desc_len_nbits: 10);
847
848	length += desc_loop_len;
849
850	s = s->next;
851	}
852
853	length += CRC_SIZE_IN_BYTES;
854
855	vidtv_psi_set_sec_len(h: &pmt->header, new_len: length);
856	}
857
858	void vidtv_psi_sdt_table_update_sec_len(struct vidtv_psi_table_sdt *sdt)
859	{
860	struct vidtv_psi_table_sdt_service *s = sdt->service;
861	u16 desc_loop_len;
862	u16 length = 0;
863
864	/* see ETSI EN 300 468 V 1.10.1 p.24 */
865
866	/*
867	* from immediately after 'section_length' until
868	* 'reserved_for_future_use'
869	*/
870	length += SDT_LEN_UNTIL_RESERVED_FOR_FUTURE_USE;
871
872	while (s) {
873	/* skip both pointers at the end */
874	length += sizeof(struct vidtv_psi_table_sdt_service) -
875	sizeof(struct vidtv_psi_desc *) -
876	sizeof(struct vidtv_psi_table_sdt_service *);
877
878	desc_loop_len = vidtv_psi_desc_comp_loop_len(desc: s->descriptor);
879	vidtv_psi_set_desc_loop_len(bitfield: &s->bitfield, new_len: desc_loop_len, desc_len_nbits: 12);
880
881	length += desc_loop_len;
882
883	s = s->next;
884	}
885
886	length += CRC_SIZE_IN_BYTES;
887	vidtv_psi_set_sec_len(h: &sdt->header, new_len: length);
888	}
889
890	struct vidtv_psi_table_pat_program*
891	vidtv_psi_pat_program_init(struct vidtv_psi_table_pat_program *head,
892	u16 service_id,
893	u16 program_map_pid)
894	{
895	struct vidtv_psi_table_pat_program *program;
896	const u16 RESERVED = 0x07;
897
898	program = kzalloc(size: sizeof(*program), GFP_KERNEL);
899	if (!program)
900	return NULL;
901
902	program->service_id = cpu_to_be16(service_id);
903
904	/* pid for the PMT section in the TS */
905	program->bitfield = cpu_to_be16((RESERVED << 13) | program_map_pid);
906	program->next = NULL;
907
908	if (head) {
909	while (head->next)
910	head = head->next;
911
912	head->next = program;
913	}
914
915	return program;
916	}
917
918	void
919	vidtv_psi_pat_program_destroy(struct vidtv_psi_table_pat_program *p)
920	{
921	struct vidtv_psi_table_pat_program *tmp = NULL;
922	struct vidtv_psi_table_pat_program *curr = p;
923
924	while (curr) {
925	tmp = curr;
926	curr = curr->next;
927	kfree(objp: tmp);
928	}
929	}
930
931	/* This function transfers ownership of p to the table */
932	void
933	vidtv_psi_pat_program_assign(struct vidtv_psi_table_pat *pat,
934	struct vidtv_psi_table_pat_program *p)
935	{
936	struct vidtv_psi_table_pat_program *program;
937	u16 program_count;
938
939	do {
940	program_count = 0;
941	program = p;
942
943	if (p == pat->program)
944	return;
945
946	while (program) {
947	++program_count;
948	program = program->next;
949	}
950
951	pat->num_pat = program_count;
952	pat->program = p;
953
954	/* Recompute section length */
955	vidtv_psi_pat_table_update_sec_len(pat);
956
957	p = NULL;
958	} while (vidtv_psi_get_sec_len(h: &pat->header) > MAX_SECTION_LEN);
959
960	vidtv_psi_update_version_num(h: &pat->header);
961	}
962
963	struct vidtv_psi_table_pat *vidtv_psi_pat_table_init(u16 transport_stream_id)
964	{
965	struct vidtv_psi_table_pat *pat;
966	const u16 SYNTAX = 0x1;
967	const u16 ZERO = 0x0;
968	const u16 ONES = 0x03;
969
970	pat = kzalloc(size: sizeof(*pat), GFP_KERNEL);
971	if (!pat)
972	return NULL;
973
974	pat->header.table_id = 0x0;
975
976	pat->header.bitfield = cpu_to_be16((SYNTAX << 15) | (ZERO << 14) | (ONES << 12));
977	pat->header.id = cpu_to_be16(transport_stream_id);
978	pat->header.current_next = 0x1;
979
980	pat->header.version = 0x1f;
981
982	pat->header.one2 = 0x03;
983	pat->header.section_id = 0x0;
984	pat->header.last_section = 0x0;
985
986	vidtv_psi_pat_table_update_sec_len(pat);
987
988	return pat;
989	}
990
991	u32 vidtv_psi_pat_write_into(struct vidtv_psi_pat_write_args *args)
992	{
993	struct vidtv_psi_table_pat_program *p = args->pat->program;
994	struct header_write_args h_args = {
995	.dest_buf = args->buf,
996	.dest_offset = args->offset,
997	.pid = VIDTV_PAT_PID,
998	.h = &args->pat->header,
999	.continuity_counter = args->continuity_counter,
1000	.dest_buf_sz = args->buf_sz,
1001	};
1002	struct psi_write_args psi_args = {
1003	.dest_buf = args->buf,
1004	.pid = VIDTV_PAT_PID,
1005	.new_psi_section = false,
1006	.continuity_counter = args->continuity_counter,
1007	.is_crc = false,
1008	.dest_buf_sz = args->buf_sz,
1009	};
1010	struct crc32_write_args c_args = {
1011	.dest_buf = args->buf,
1012	.pid = VIDTV_PAT_PID,
1013	.dest_buf_sz = args->buf_sz,
1014	};
1015	u32 crc = INITIAL_CRC;
1016	u32 nbytes = 0;
1017
1018	vidtv_psi_pat_table_update_sec_len(pat: args->pat);
1019
1020	h_args.crc = &crc;
1021
1022	nbytes += vidtv_psi_table_header_write_into(args: &h_args);
1023
1024	/* note that the field 'u16 programs' is not really part of the PAT */
1025
1026	psi_args.crc = &crc;
1027
1028	while (p) {
1029	/* copy the PAT programs */
1030	psi_args.from = p;
1031	/* skip the pointer */
1032	psi_args.len = sizeof(*p) -
1033	sizeof(struct vidtv_psi_table_pat_program *);
1034	psi_args.dest_offset = args->offset + nbytes;
1035	psi_args.continuity_counter = args->continuity_counter;
1036
1037	nbytes += vidtv_psi_ts_psi_write_into(args: &psi_args);
1038
1039	p = p->next;
1040	}
1041
1042	c_args.dest_offset = args->offset + nbytes;
1043	c_args.continuity_counter = args->continuity_counter;
1044	c_args.crc = cpu_to_be32(crc);
1045
1046	/* Write the CRC32 at the end */
1047	nbytes += table_section_crc32_write_into(args: &c_args);
1048
1049	return nbytes;
1050	}
1051
1052	void
1053	vidtv_psi_pat_table_destroy(struct vidtv_psi_table_pat *p)
1054	{
1055	vidtv_psi_pat_program_destroy(p: p->program);
1056	kfree(objp: p);
1057	}
1058
1059	struct vidtv_psi_table_pmt_stream*
1060	vidtv_psi_pmt_stream_init(struct vidtv_psi_table_pmt_stream *head,
1061	enum vidtv_psi_stream_types stream_type,
1062	u16 es_pid)
1063	{
1064	struct vidtv_psi_table_pmt_stream *stream;
1065	const u16 RESERVED1 = 0x07;
1066	const u16 RESERVED2 = 0x0f;
1067	const u16 ZERO = 0x0;
1068	u16 desc_loop_len;
1069
1070	stream = kzalloc(size: sizeof(*stream), GFP_KERNEL);
1071	if (!stream)
1072	return NULL;
1073
1074	stream->type = stream_type;
1075
1076	stream->bitfield = cpu_to_be16((RESERVED1 << 13) | es_pid);
1077
1078	desc_loop_len = vidtv_psi_desc_comp_loop_len(desc: stream->descriptor);
1079
1080	stream->bitfield2 = cpu_to_be16((RESERVED2 << 12) |
1081	(ZERO << 10) |
1082	desc_loop_len);
1083	stream->next = NULL;
1084
1085	if (head) {
1086	while (head->next)
1087	head = head->next;
1088
1089	head->next = stream;
1090	}
1091
1092	return stream;
1093	}
1094
1095	void vidtv_psi_pmt_stream_destroy(struct vidtv_psi_table_pmt_stream *s)
1096	{
1097	struct vidtv_psi_table_pmt_stream *tmp_stream = NULL;
1098	struct vidtv_psi_table_pmt_stream *curr_stream = s;
1099
1100	while (curr_stream) {
1101	tmp_stream = curr_stream;
1102	curr_stream = curr_stream->next;
1103	vidtv_psi_desc_destroy(desc: tmp_stream->descriptor);
1104	kfree(objp: tmp_stream);
1105	}
1106	}
1107
1108	void vidtv_psi_pmt_stream_assign(struct vidtv_psi_table_pmt *pmt,
1109	struct vidtv_psi_table_pmt_stream *s)
1110	{
1111	do {
1112	/* This function transfers ownership of s to the table */
1113	if (s == pmt->stream)
1114	return;
1115
1116	pmt->stream = s;
1117	vidtv_psi_pmt_table_update_sec_len(pmt);
1118
1119	s = NULL;
1120	} while (vidtv_psi_get_sec_len(h: &pmt->header) > MAX_SECTION_LEN);
1121
1122	vidtv_psi_update_version_num(h: &pmt->header);
1123	}
1124
1125	u16 vidtv_psi_pmt_get_pid(struct vidtv_psi_table_pmt *section,
1126	struct vidtv_psi_table_pat *pat)
1127	{
1128	struct vidtv_psi_table_pat_program *program = pat->program;
1129
1130	/*
1131	* service_id is the same as program_number in the
1132	* corresponding program_map_section
1133	* see ETSI EN 300 468 v1.15.1 p. 24
1134	*/
1135	while (program) {
1136	if (program->service_id == section->header.id)
1137	return vidtv_psi_get_pat_program_pid(p: program);
1138
1139	program = program->next;
1140	}
1141
1142	return TS_LAST_VALID_PID + 1; /* not found */
1143	}
1144
1145	struct vidtv_psi_table_pmt *vidtv_psi_pmt_table_init(u16 program_number,
1146	u16 pcr_pid)
1147	{
1148	struct vidtv_psi_table_pmt *pmt;
1149	const u16 RESERVED1 = 0x07;
1150	const u16 RESERVED2 = 0x0f;
1151	const u16 SYNTAX = 0x1;
1152	const u16 ONES = 0x03;
1153	const u16 ZERO = 0x0;
1154	u16 desc_loop_len;
1155
1156	pmt = kzalloc(size: sizeof(*pmt), GFP_KERNEL);
1157	if (!pmt)
1158	return NULL;
1159
1160	if (!pcr_pid)
1161	pcr_pid = 0x1fff;
1162
1163	pmt->header.table_id = 0x2;
1164
1165	pmt->header.bitfield = cpu_to_be16((SYNTAX << 15) | (ZERO << 14) | (ONES << 12));
1166
1167	pmt->header.id = cpu_to_be16(program_number);
1168	pmt->header.current_next = 0x1;
1169
1170	pmt->header.version = 0x1f;
1171
1172	pmt->header.one2 = ONES;
1173	pmt->header.section_id = 0;
1174	pmt->header.last_section = 0;
1175
1176	pmt->bitfield = cpu_to_be16((RESERVED1 << 13) | pcr_pid);
1177
1178	desc_loop_len = vidtv_psi_desc_comp_loop_len(desc: pmt->descriptor);
1179
1180	pmt->bitfield2 = cpu_to_be16((RESERVED2 << 12) |
1181	(ZERO << 10) |
1182	desc_loop_len);
1183
1184	vidtv_psi_pmt_table_update_sec_len(pmt);
1185
1186	return pmt;
1187	}
1188
1189	u32 vidtv_psi_pmt_write_into(struct vidtv_psi_pmt_write_args *args)
1190	{
1191	struct vidtv_psi_desc *table_descriptor = args->pmt->descriptor;
1192	struct vidtv_psi_table_pmt_stream *stream = args->pmt->stream;
1193	struct vidtv_psi_desc *stream_descriptor;
1194	u32 crc = INITIAL_CRC;
1195	u32 nbytes = 0;
1196	struct header_write_args h_args = {
1197	.dest_buf = args->buf,
1198	.dest_offset = args->offset,
1199	.h = &args->pmt->header,
1200	.pid = args->pid,
1201	.continuity_counter = args->continuity_counter,
1202	.dest_buf_sz = args->buf_sz,
1203	};
1204	struct psi_write_args psi_args = {
1205	.dest_buf = args->buf,
1206	.from = &args->pmt->bitfield,
1207	.len = sizeof_field(struct vidtv_psi_table_pmt, bitfield) +
1208	sizeof_field(struct vidtv_psi_table_pmt, bitfield2),
1209	.pid = args->pid,
1210	.new_psi_section = false,
1211	.is_crc = false,
1212	.dest_buf_sz = args->buf_sz,
1213	.crc = &crc,
1214	};
1215	struct desc_write_args d_args = {
1216	.dest_buf = args->buf,
1217	.desc = table_descriptor,
1218	.pid = args->pid,
1219	.dest_buf_sz = args->buf_sz,
1220	};
1221	struct crc32_write_args c_args = {
1222	.dest_buf = args->buf,
1223	.pid = args->pid,
1224	.dest_buf_sz = args->buf_sz,
1225	};
1226
1227	vidtv_psi_pmt_table_update_sec_len(pmt: args->pmt);
1228
1229	h_args.crc = &crc;
1230
1231	nbytes += vidtv_psi_table_header_write_into(args: &h_args);
1232
1233	/* write the two bitfields */
1234	psi_args.dest_offset = args->offset + nbytes;
1235	psi_args.continuity_counter = args->continuity_counter;
1236	nbytes += vidtv_psi_ts_psi_write_into(args: &psi_args);
1237
1238	while (table_descriptor) {
1239	/* write the descriptors, if any */
1240	d_args.dest_offset = args->offset + nbytes;
1241	d_args.continuity_counter = args->continuity_counter;
1242	d_args.crc = &crc;
1243
1244	nbytes += vidtv_psi_desc_write_into(args: &d_args);
1245
1246	table_descriptor = table_descriptor->next;
1247	}
1248
1249	psi_args.len += sizeof_field(struct vidtv_psi_table_pmt_stream, type);
1250	while (stream) {
1251	/* write the streams, if any */
1252	psi_args.from = stream;
1253	psi_args.dest_offset = args->offset + nbytes;
1254	psi_args.continuity_counter = args->continuity_counter;
1255
1256	nbytes += vidtv_psi_ts_psi_write_into(args: &psi_args);
1257
1258	stream_descriptor = stream->descriptor;
1259
1260	while (stream_descriptor) {
1261	/* write the stream descriptors, if any */
1262	d_args.dest_offset = args->offset + nbytes;
1263	d_args.desc = stream_descriptor;
1264	d_args.continuity_counter = args->continuity_counter;
1265	d_args.crc = &crc;
1266
1267	nbytes += vidtv_psi_desc_write_into(args: &d_args);
1268
1269	stream_descriptor = stream_descriptor->next;
1270	}
1271
1272	stream = stream->next;
1273	}
1274
1275	c_args.dest_offset = args->offset + nbytes;
1276	c_args.crc = cpu_to_be32(crc);
1277	c_args.continuity_counter = args->continuity_counter;
1278
1279	/* Write the CRC32 at the end */
1280	nbytes += table_section_crc32_write_into(args: &c_args);
1281
1282	return nbytes;
1283	}
1284
1285	void vidtv_psi_pmt_table_destroy(struct vidtv_psi_table_pmt *pmt)
1286	{
1287	vidtv_psi_desc_destroy(desc: pmt->descriptor);
1288	vidtv_psi_pmt_stream_destroy(s: pmt->stream);
1289	kfree(objp: pmt);
1290	}
1291
1292	struct vidtv_psi_table_sdt *vidtv_psi_sdt_table_init(u16 network_id,
1293	u16 transport_stream_id)
1294	{
1295	struct vidtv_psi_table_sdt *sdt;
1296	const u16 RESERVED = 0xff;
1297	const u16 SYNTAX = 0x1;
1298	const u16 ONES = 0x03;
1299	const u16 ONE = 0x1;
1300
1301	sdt = kzalloc(size: sizeof(*sdt), GFP_KERNEL);
1302	if (!sdt)
1303	return NULL;
1304
1305	sdt->header.table_id = 0x42;
1306	sdt->header.bitfield = cpu_to_be16((SYNTAX << 15) | (ONE << 14) | (ONES << 12));
1307
1308	/*
1309	* This is a 16-bit field which serves as a label for identification
1310	* of the TS, about which the SDT informs, from any other multiplex
1311	* within the delivery system.
1312	*/
1313	sdt->header.id = cpu_to_be16(transport_stream_id);
1314	sdt->header.current_next = ONE;
1315
1316	sdt->header.version = 0x1f;
1317
1318	sdt->header.one2 = ONES;
1319	sdt->header.section_id = 0;
1320	sdt->header.last_section = 0;
1321
1322	/*
1323	* FIXME: The network_id range from 0xFF01 to 0xFFFF is used to
1324	* indicate temporary private use. For now, let's use the first
1325	* value.
1326	* This can be changed to something more useful, when support for
1327	* NIT gets added
1328	*/
1329	sdt->network_id = cpu_to_be16(network_id);
1330	sdt->reserved = RESERVED;
1331
1332	vidtv_psi_sdt_table_update_sec_len(sdt);
1333
1334	return sdt;
1335	}
1336
1337	u32 vidtv_psi_sdt_write_into(struct vidtv_psi_sdt_write_args *args)
1338	{
1339	struct header_write_args h_args = {
1340	.dest_buf = args->buf,
1341	.dest_offset = args->offset,
1342	.h = &args->sdt->header,
1343	.pid = VIDTV_SDT_PID,
1344	.dest_buf_sz = args->buf_sz,
1345	};
1346	struct psi_write_args psi_args = {
1347	.dest_buf = args->buf,
1348	.len = sizeof_field(struct vidtv_psi_table_sdt, network_id) +
1349	sizeof_field(struct vidtv_psi_table_sdt, reserved),
1350	.pid = VIDTV_SDT_PID,
1351	.new_psi_section = false,
1352	.is_crc = false,
1353	.dest_buf_sz = args->buf_sz,
1354	};
1355	struct desc_write_args d_args = {
1356	.dest_buf = args->buf,
1357	.pid = VIDTV_SDT_PID,
1358	.dest_buf_sz = args->buf_sz,
1359	};
1360	struct crc32_write_args c_args = {
1361	.dest_buf = args->buf,
1362	.pid = VIDTV_SDT_PID,
1363	.dest_buf_sz = args->buf_sz,
1364	};
1365	struct vidtv_psi_table_sdt_service *service = args->sdt->service;
1366	struct vidtv_psi_desc *service_desc;
1367	u32 nbytes = 0;
1368	u32 crc = INITIAL_CRC;
1369
1370	/* see ETSI EN 300 468 v1.15.1 p. 11 */
1371
1372	vidtv_psi_sdt_table_update_sec_len(sdt: args->sdt);
1373
1374	h_args.continuity_counter = args->continuity_counter;
1375	h_args.crc = &crc;
1376
1377	nbytes += vidtv_psi_table_header_write_into(args: &h_args);
1378
1379	psi_args.from = &args->sdt->network_id;
1380	psi_args.dest_offset = args->offset + nbytes;
1381	psi_args.continuity_counter = args->continuity_counter;
1382	psi_args.crc = &crc;
1383
1384	/* copy u16 network_id + u8 reserved)*/
1385	nbytes += vidtv_psi_ts_psi_write_into(args: &psi_args);
1386
1387	/* skip both pointers at the end */
1388	psi_args.len = sizeof(struct vidtv_psi_table_sdt_service) -
1389	sizeof(struct vidtv_psi_desc *) -
1390	sizeof(struct vidtv_psi_table_sdt_service *);
1391
1392	while (service) {
1393	/* copy the services, if any */
1394	psi_args.from = service;
1395	psi_args.dest_offset = args->offset + nbytes;
1396	psi_args.continuity_counter = args->continuity_counter;
1397
1398	nbytes += vidtv_psi_ts_psi_write_into(args: &psi_args);
1399
1400	service_desc = service->descriptor;
1401
1402	while (service_desc) {
1403	/* copy the service descriptors, if any */
1404	d_args.dest_offset = args->offset + nbytes;
1405	d_args.desc = service_desc;
1406	d_args.continuity_counter = args->continuity_counter;
1407	d_args.crc = &crc;
1408
1409	nbytes += vidtv_psi_desc_write_into(args: &d_args);
1410
1411	service_desc = service_desc->next;
1412	}
1413
1414	service = service->next;
1415	}
1416
1417	c_args.dest_offset = args->offset + nbytes;
1418	c_args.crc = cpu_to_be32(crc);
1419	c_args.continuity_counter = args->continuity_counter;
1420
1421	/* Write the CRC at the end */
1422	nbytes += table_section_crc32_write_into(args: &c_args);
1423
1424	return nbytes;
1425	}
1426
1427	void vidtv_psi_sdt_table_destroy(struct vidtv_psi_table_sdt *sdt)
1428	{
1429	vidtv_psi_sdt_service_destroy(service: sdt->service);
1430	kfree(objp: sdt);
1431	}
1432
1433	struct vidtv_psi_table_sdt_service
1434	*vidtv_psi_sdt_service_init(struct vidtv_psi_table_sdt_service *head,
1435	u16 service_id,
1436	bool eit_schedule,
1437	bool eit_present_following)
1438	{
1439	struct vidtv_psi_table_sdt_service *service;
1440
1441	service = kzalloc(size: sizeof(*service), GFP_KERNEL);
1442	if (!service)
1443	return NULL;
1444
1445	/*
1446	* ETSI 300 468: this is a 16bit field which serves as a label to
1447	* identify this service from any other service within the TS.
1448	* The service id is the same as the program number in the
1449	* corresponding program_map_section
1450	*/
1451	service->service_id = cpu_to_be16(service_id);
1452	service->EIT_schedule = eit_schedule;
1453	service->EIT_present_following = eit_present_following;
1454	service->reserved = 0x3f;
1455
1456	service->bitfield = cpu_to_be16(RUNNING << 13);
1457
1458	if (head) {
1459	while (head->next)
1460	head = head->next;
1461
1462	head->next = service;
1463	}
1464
1465	return service;
1466	}
1467
1468	void
1469	vidtv_psi_sdt_service_destroy(struct vidtv_psi_table_sdt_service *service)
1470	{
1471	struct vidtv_psi_table_sdt_service *curr = service;
1472	struct vidtv_psi_table_sdt_service *tmp = NULL;
1473
1474	while (curr) {
1475	tmp = curr;
1476	curr = curr->next;
1477	vidtv_psi_desc_destroy(desc: tmp->descriptor);
1478	kfree(objp: tmp);
1479	}
1480	}
1481
1482	void
1483	vidtv_psi_sdt_service_assign(struct vidtv_psi_table_sdt *sdt,
1484	struct vidtv_psi_table_sdt_service *service)
1485	{
1486	do {
1487	if (service == sdt->service)
1488	return;
1489
1490	sdt->service = service;
1491
1492	/* recompute section length */
1493	vidtv_psi_sdt_table_update_sec_len(sdt);
1494
1495	service = NULL;
1496	} while (vidtv_psi_get_sec_len(h: &sdt->header) > MAX_SECTION_LEN);
1497
1498	vidtv_psi_update_version_num(h: &sdt->header);
1499	}
1500
1501	/*
1502	* PMTs contain information about programs. For each program,
1503	* there is one PMT section. This function will create a section
1504	* for each program found in the PAT
1505	*/
1506	struct vidtv_psi_table_pmt**
1507	vidtv_psi_pmt_create_sec_for_each_pat_entry(struct vidtv_psi_table_pat *pat,
1508	u16 pcr_pid)
1509
1510	{
1511	struct vidtv_psi_table_pat_program *program;
1512	struct vidtv_psi_table_pmt **pmt_secs;
1513	u32 i = 0, num_pmt = 0;
1514
1515	/*
1516	* The number of PMT entries is the number of PAT entries
1517	* that contain service_id. That exclude special tables, like NIT
1518	*/
1519	program = pat->program;
1520	while (program) {
1521	if (program->service_id)
1522	num_pmt++;
1523	program = program->next;
1524	}
1525
1526	pmt_secs = kcalloc(n: num_pmt,
1527	size: sizeof(struct vidtv_psi_table_pmt *),
1528	GFP_KERNEL);
1529	if (!pmt_secs)
1530	return NULL;
1531
1532	for (program = pat->program; program; program = program->next) {
1533	if (!program->service_id)
1534	continue;
1535	pmt_secs[i] = vidtv_psi_pmt_table_init(be16_to_cpu(program->service_id),
1536	pcr_pid);
1537
1538	if (!pmt_secs[i]) {
1539	while (i > 0) {
1540	i--;
1541	vidtv_psi_pmt_table_destroy(pmt: pmt_secs[i]);
1542	}
1543	return NULL;
1544	}
1545	i++;
1546	}
1547	pat->num_pmt = num_pmt;
1548
1549	return pmt_secs;
1550	}
1551
1552	/* find the PMT section associated with 'program_num' */
1553	struct vidtv_psi_table_pmt
1554	*vidtv_psi_find_pmt_sec(struct vidtv_psi_table_pmt **pmt_sections,
1555	u16 nsections,
1556	u16 program_num)
1557	{
1558	struct vidtv_psi_table_pmt *sec = NULL;
1559	u32 i;
1560
1561	for (i = 0; i < nsections; ++i) {
1562	sec = pmt_sections[i];
1563	if (be16_to_cpu(sec->header.id) == program_num)
1564	return sec;
1565	}
1566
1567	return NULL; /* not found */
1568	}
1569
1570	static void vidtv_psi_nit_table_update_sec_len(struct vidtv_psi_table_nit *nit)
1571	{
1572	u16 length = 0;
1573	struct vidtv_psi_table_transport *t = nit->transport;
1574	u16 desc_loop_len;
1575	u16 transport_loop_len = 0;
1576
1577	/*
1578	* from immediately after 'section_length' until
1579	* 'network_descriptor_length'
1580	*/
1581	length += NIT_LEN_UNTIL_NETWORK_DESCRIPTOR_LEN;
1582
1583	desc_loop_len = vidtv_psi_desc_comp_loop_len(desc: nit->descriptor);
1584	vidtv_psi_set_desc_loop_len(bitfield: &nit->bitfield, new_len: desc_loop_len, desc_len_nbits: 12);
1585
1586	length += desc_loop_len;
1587
1588	length += sizeof_field(struct vidtv_psi_table_nit, bitfield2);
1589
1590	while (t) {
1591	/* skip both pointers at the end */
1592	transport_loop_len += sizeof(struct vidtv_psi_table_transport) -
1593	sizeof(struct vidtv_psi_desc *) -
1594	sizeof(struct vidtv_psi_table_transport *);
1595
1596	length += transport_loop_len;
1597
1598	desc_loop_len = vidtv_psi_desc_comp_loop_len(desc: t->descriptor);
1599	vidtv_psi_set_desc_loop_len(bitfield: &t->bitfield, new_len: desc_loop_len, desc_len_nbits: 12);
1600
1601	length += desc_loop_len;
1602
1603	t = t->next;
1604	}
1605
1606	// Actually sets the transport stream loop len, maybe rename this function later
1607	vidtv_psi_set_desc_loop_len(bitfield: &nit->bitfield2, new_len: transport_loop_len, desc_len_nbits: 12);
1608	length += CRC_SIZE_IN_BYTES;
1609
1610	vidtv_psi_set_sec_len(h: &nit->header, new_len: length);
1611	}
1612
1613	struct vidtv_psi_table_nit
1614	*vidtv_psi_nit_table_init(u16 network_id,
1615	u16 transport_stream_id,
1616	char *network_name,
1617	struct vidtv_psi_desc_service_list_entry *service_list)
1618	{
1619	struct vidtv_psi_table_transport *transport;
1620	struct vidtv_psi_table_nit *nit;
1621	const u16 SYNTAX = 0x1;
1622	const u16 ONES = 0x03;
1623	const u16 ONE = 0x1;
1624
1625	nit = kzalloc(size: sizeof(*nit), GFP_KERNEL);
1626	if (!nit)
1627	return NULL;
1628
1629	transport = kzalloc(size: sizeof(*transport), GFP_KERNEL);
1630	if (!transport)
1631	goto free_nit;
1632
1633	nit->header.table_id = 0x40; // ACTUAL_NETWORK
1634
1635	nit->header.bitfield = cpu_to_be16((SYNTAX << 15) | (ONE << 14) | (ONES << 12));
1636
1637	nit->header.id = cpu_to_be16(network_id);
1638	nit->header.current_next = ONE;
1639
1640	nit->header.version = 0x1f;
1641
1642	nit->header.one2 = ONES;
1643	nit->header.section_id = 0;
1644	nit->header.last_section = 0;
1645
1646	nit->bitfield = cpu_to_be16(0xf);
1647	nit->bitfield2 = cpu_to_be16(0xf);
1648
1649	nit->descriptor = (struct vidtv_psi_desc *)
1650	vidtv_psi_network_name_desc_init(NULL, network_name);
1651	if (!nit->descriptor)
1652	goto free_transport;
1653
1654	transport->transport_id = cpu_to_be16(transport_stream_id);
1655	transport->network_id = cpu_to_be16(network_id);
1656	transport->bitfield = cpu_to_be16(0xf);
1657	transport->descriptor = (struct vidtv_psi_desc *)
1658	vidtv_psi_service_list_desc_init(NULL, entry: service_list);
1659	if (!transport->descriptor)
1660	goto free_nit_desc;
1661
1662	nit->transport = transport;
1663
1664	vidtv_psi_nit_table_update_sec_len(nit);
1665
1666	return nit;
1667
1668	free_nit_desc:
1669	vidtv_psi_desc_destroy(desc: (struct vidtv_psi_desc *)nit->descriptor);
1670
1671	free_transport:
1672	kfree(objp: transport);
1673	free_nit:
1674	kfree(objp: nit);
1675	return NULL;
1676	}
1677
1678	u32 vidtv_psi_nit_write_into(struct vidtv_psi_nit_write_args *args)
1679	{
1680	struct header_write_args h_args = {
1681	.dest_buf = args->buf,
1682	.dest_offset = args->offset,
1683	.h = &args->nit->header,
1684	.pid = VIDTV_NIT_PID,
1685	.dest_buf_sz = args->buf_sz,
1686	};
1687	struct psi_write_args psi_args = {
1688	.dest_buf = args->buf,
1689	.from = &args->nit->bitfield,
1690	.len = sizeof_field(struct vidtv_psi_table_nit, bitfield),
1691	.pid = VIDTV_NIT_PID,
1692	.new_psi_section = false,
1693	.is_crc = false,
1694	.dest_buf_sz = args->buf_sz,
1695	};
1696	struct desc_write_args d_args = {
1697	.dest_buf = args->buf,
1698	.pid = VIDTV_NIT_PID,
1699	.dest_buf_sz = args->buf_sz,
1700	};
1701	struct crc32_write_args c_args = {
1702	.dest_buf = args->buf,
1703	.pid = VIDTV_NIT_PID,
1704	.dest_buf_sz = args->buf_sz,
1705	};
1706	struct vidtv_psi_desc *table_descriptor = args->nit->descriptor;
1707	struct vidtv_psi_table_transport *transport = args->nit->transport;
1708	struct vidtv_psi_desc *transport_descriptor;
1709	u32 crc = INITIAL_CRC;
1710	u32 nbytes = 0;
1711
1712	vidtv_psi_nit_table_update_sec_len(nit: args->nit);
1713
1714	h_args.continuity_counter = args->continuity_counter;
1715	h_args.crc = &crc;
1716
1717	nbytes += vidtv_psi_table_header_write_into(args: &h_args);
1718
1719	/* write the bitfield */
1720
1721	psi_args.dest_offset = args->offset + nbytes;
1722	psi_args.continuity_counter = args->continuity_counter;
1723	psi_args.crc = &crc;
1724
1725	nbytes += vidtv_psi_ts_psi_write_into(args: &psi_args);
1726
1727	while (table_descriptor) {
1728	/* write the descriptors, if any */
1729	d_args.dest_offset = args->offset + nbytes;
1730	d_args.desc = table_descriptor;
1731	d_args.continuity_counter = args->continuity_counter;
1732	d_args.crc = &crc;
1733
1734	nbytes += vidtv_psi_desc_write_into(args: &d_args);
1735
1736	table_descriptor = table_descriptor->next;
1737	}
1738
1739	/* write the second bitfield */
1740	psi_args.from = &args->nit->bitfield2;
1741	psi_args.len = sizeof_field(struct vidtv_psi_table_nit, bitfield2);
1742	psi_args.dest_offset = args->offset + nbytes;
1743
1744	nbytes += vidtv_psi_ts_psi_write_into(args: &psi_args);
1745
1746	psi_args.len = sizeof_field(struct vidtv_psi_table_transport, transport_id) +
1747	sizeof_field(struct vidtv_psi_table_transport, network_id) +
1748	sizeof_field(struct vidtv_psi_table_transport, bitfield);
1749	while (transport) {
1750	/* write the transport sections, if any */
1751	psi_args.from = transport;
1752	psi_args.dest_offset = args->offset + nbytes;
1753
1754	nbytes += vidtv_psi_ts_psi_write_into(args: &psi_args);
1755
1756	transport_descriptor = transport->descriptor;
1757
1758	while (transport_descriptor) {
1759	/* write the transport descriptors, if any */
1760	d_args.dest_offset = args->offset + nbytes;
1761	d_args.desc = transport_descriptor;
1762	d_args.continuity_counter = args->continuity_counter;
1763	d_args.crc = &crc;
1764
1765	nbytes += vidtv_psi_desc_write_into(args: &d_args);
1766
1767	transport_descriptor = transport_descriptor->next;
1768	}
1769
1770	transport = transport->next;
1771	}
1772
1773	c_args.dest_offset = args->offset + nbytes;
1774	c_args.crc = cpu_to_be32(crc);
1775	c_args.continuity_counter = args->continuity_counter;
1776
1777	/* Write the CRC32 at the end */
1778	nbytes += table_section_crc32_write_into(args: &c_args);
1779
1780	return nbytes;
1781	}
1782
1783	static void vidtv_psi_transport_destroy(struct vidtv_psi_table_transport *t)
1784	{
1785	struct vidtv_psi_table_transport *tmp_t = NULL;
1786	struct vidtv_psi_table_transport *curr_t = t;
1787
1788	while (curr_t) {
1789	tmp_t = curr_t;
1790	curr_t = curr_t->next;
1791	vidtv_psi_desc_destroy(desc: tmp_t->descriptor);
1792	kfree(objp: tmp_t);
1793	}
1794	}
1795
1796	void vidtv_psi_nit_table_destroy(struct vidtv_psi_table_nit *nit)
1797	{
1798	vidtv_psi_desc_destroy(desc: nit->descriptor);
1799	vidtv_psi_transport_destroy(t: nit->transport);
1800	kfree(objp: nit);
1801	}
1802
1803	void vidtv_psi_eit_table_update_sec_len(struct vidtv_psi_table_eit *eit)
1804	{
1805	struct vidtv_psi_table_eit_event *e = eit->event;
1806	u16 desc_loop_len;
1807	u16 length = 0;
1808
1809	/*
1810	* from immediately after 'section_length' until
1811	* 'last_table_id'
1812	*/
1813	length += EIT_LEN_UNTIL_LAST_TABLE_ID;
1814
1815	while (e) {
1816	/* skip both pointers at the end */
1817	length += sizeof(struct vidtv_psi_table_eit_event) -
1818	sizeof(struct vidtv_psi_desc *) -
1819	sizeof(struct vidtv_psi_table_eit_event *);
1820
1821	desc_loop_len = vidtv_psi_desc_comp_loop_len(desc: e->descriptor);
1822	vidtv_psi_set_desc_loop_len(bitfield: &e->bitfield, new_len: desc_loop_len, desc_len_nbits: 12);
1823
1824	length += desc_loop_len;
1825
1826	e = e->next;
1827	}
1828
1829	length += CRC_SIZE_IN_BYTES;
1830
1831	vidtv_psi_set_sec_len(h: &eit->header, new_len: length);
1832	}
1833
1834	void vidtv_psi_eit_event_assign(struct vidtv_psi_table_eit *eit,
1835	struct vidtv_psi_table_eit_event *e)
1836	{
1837	do {
1838	if (e == eit->event)
1839	return;
1840
1841	eit->event = e;
1842	vidtv_psi_eit_table_update_sec_len(eit);
1843
1844	e = NULL;
1845	} while (vidtv_psi_get_sec_len(h: &eit->header) > EIT_MAX_SECTION_LEN);
1846
1847	vidtv_psi_update_version_num(h: &eit->header);
1848	}
1849
1850	struct vidtv_psi_table_eit
1851	*vidtv_psi_eit_table_init(u16 network_id,
1852	u16 transport_stream_id,
1853	__be16 service_id)
1854	{
1855	struct vidtv_psi_table_eit *eit;
1856	const u16 SYNTAX = 0x1;
1857	const u16 ONE = 0x1;
1858	const u16 ONES = 0x03;
1859
1860	eit = kzalloc(size: sizeof(*eit), GFP_KERNEL);
1861	if (!eit)
1862	return NULL;
1863
1864	eit->header.table_id = 0x4e; //actual_transport_stream: present/following
1865
1866	eit->header.bitfield = cpu_to_be16((SYNTAX << 15) | (ONE << 14) | (ONES << 12));
1867
1868	eit->header.id = service_id;
1869	eit->header.current_next = ONE;
1870
1871	eit->header.version = 0x1f;
1872
1873	eit->header.one2 = ONES;
1874	eit->header.section_id = 0;
1875	eit->header.last_section = 0;
1876
1877	eit->transport_id = cpu_to_be16(transport_stream_id);
1878	eit->network_id = cpu_to_be16(network_id);
1879
1880	eit->last_segment = eit->header.last_section; /* not implemented */
1881	eit->last_table_id = eit->header.table_id; /* not implemented */
1882
1883	vidtv_psi_eit_table_update_sec_len(eit);
1884
1885	return eit;
1886	}
1887
1888	u32 vidtv_psi_eit_write_into(struct vidtv_psi_eit_write_args *args)
1889	{
1890	struct header_write_args h_args = {
1891	.dest_buf = args->buf,
1892	.dest_offset = args->offset,
1893	.h = &args->eit->header,
1894	.pid = VIDTV_EIT_PID,
1895	.dest_buf_sz = args->buf_sz,
1896	};
1897	struct psi_write_args psi_args = {
1898	.dest_buf = args->buf,
1899	.len = sizeof_field(struct vidtv_psi_table_eit, transport_id) +
1900	sizeof_field(struct vidtv_psi_table_eit, network_id) +
1901	sizeof_field(struct vidtv_psi_table_eit, last_segment) +
1902	sizeof_field(struct vidtv_psi_table_eit, last_table_id),
1903	.pid = VIDTV_EIT_PID,
1904	.new_psi_section = false,
1905	.is_crc = false,
1906	.dest_buf_sz = args->buf_sz,
1907	};
1908	struct desc_write_args d_args = {
1909	.dest_buf = args->buf,
1910	.pid = VIDTV_EIT_PID,
1911	.dest_buf_sz = args->buf_sz,
1912	};
1913	struct crc32_write_args c_args = {
1914	.dest_buf = args->buf,
1915	.pid = VIDTV_EIT_PID,
1916	.dest_buf_sz = args->buf_sz,
1917	};
1918	struct vidtv_psi_table_eit_event *event = args->eit->event;
1919	struct vidtv_psi_desc *event_descriptor;
1920	u32 crc = INITIAL_CRC;
1921	u32 nbytes = 0;
1922
1923	vidtv_psi_eit_table_update_sec_len(eit: args->eit);
1924
1925	h_args.continuity_counter = args->continuity_counter;
1926	h_args.crc = &crc;
1927
1928	nbytes += vidtv_psi_table_header_write_into(args: &h_args);
1929
1930	psi_args.from = &args->eit->transport_id;
1931	psi_args.dest_offset = args->offset + nbytes;
1932	psi_args.continuity_counter = args->continuity_counter;
1933	psi_args.crc = &crc;
1934
1935	nbytes += vidtv_psi_ts_psi_write_into(args: &psi_args);
1936
1937	/* skip both pointers at the end */
1938	psi_args.len = sizeof(struct vidtv_psi_table_eit_event) -
1939	sizeof(struct vidtv_psi_desc *) -
1940	sizeof(struct vidtv_psi_table_eit_event *);
1941	while (event) {
1942	/* copy the events, if any */
1943	psi_args.from = event;
1944	psi_args.dest_offset = args->offset + nbytes;
1945
1946	nbytes += vidtv_psi_ts_psi_write_into(args: &psi_args);
1947
1948	event_descriptor = event->descriptor;
1949
1950	while (event_descriptor) {
1951	/* copy the event descriptors, if any */
1952	d_args.dest_offset = args->offset + nbytes;
1953	d_args.desc = event_descriptor;
1954	d_args.continuity_counter = args->continuity_counter;
1955	d_args.crc = &crc;
1956
1957	nbytes += vidtv_psi_desc_write_into(args: &d_args);
1958
1959	event_descriptor = event_descriptor->next;
1960	}
1961
1962	event = event->next;
1963	}
1964
1965	c_args.dest_offset = args->offset + nbytes;
1966	c_args.crc = cpu_to_be32(crc);
1967	c_args.continuity_counter = args->continuity_counter;
1968
1969	/* Write the CRC at the end */
1970	nbytes += table_section_crc32_write_into(args: &c_args);
1971
1972	return nbytes;
1973	}
1974
1975	struct vidtv_psi_table_eit_event
1976	*vidtv_psi_eit_event_init(struct vidtv_psi_table_eit_event *head, u16 event_id)
1977	{
1978	static const u8 DURATION[] = {0x23, 0x59, 0x59}; /* BCD encoded */
1979	struct vidtv_psi_table_eit_event *e;
1980	struct timespec64 ts;
1981	struct tm time;
1982	int mjd, l;
1983	__be16 mjd_be;
1984
1985	e = kzalloc(size: sizeof(*e), GFP_KERNEL);
1986	if (!e)
1987	return NULL;
1988
1989	e->event_id = cpu_to_be16(event_id);
1990
1991	ts = ktime_to_timespec64(ktime_get_real());
1992	time64_to_tm(totalsecs: ts.tv_sec, offset: 0, result: &time);
1993
1994	/* Convert date to Modified Julian Date - per EN 300 468 Annex C */
1995	if (time.tm_mon < 2)
1996	l = 1;
1997	else
1998	l = 0;
1999
2000	mjd = 14956 + time.tm_mday;
2001	mjd += (time.tm_year - l) * 36525 / 100;
2002	mjd += (time.tm_mon + 2 + l * 12) * 306001 / 10000;
2003	mjd_be = cpu_to_be16(mjd);
2004
2005	/*
2006	* Store MJD and hour/min/sec to the event.
2007	*
2008	* Let's make the event to start on a full hour
2009	*/
2010	memcpy(e->start_time, &mjd_be, sizeof(mjd_be));
2011	e->start_time[2] = bin2bcd(time.tm_hour);
2012	e->start_time[3] = 0;
2013	e->start_time[4] = 0;
2014
2015	/*
2016	* TODO: for now, the event will last for a day. Should be
2017	* enough for testing purposes, but if one runs the driver
2018	* for more than that, the current event will become invalid.
2019	* So, we need a better code here in order to change the start
2020	* time once the event expires.
2021	*/
2022	memcpy(e->duration, DURATION, sizeof(e->duration));
2023
2024	e->bitfield = cpu_to_be16(RUNNING << 13);
2025
2026	if (head) {
2027	while (head->next)
2028	head = head->next;
2029
2030	head->next = e;
2031	}
2032
2033	return e;
2034	}
2035
2036	void vidtv_psi_eit_event_destroy(struct vidtv_psi_table_eit_event *e)
2037	{
2038	struct vidtv_psi_table_eit_event *tmp_e = NULL;
2039	struct vidtv_psi_table_eit_event *curr_e = e;
2040
2041	while (curr_e) {
2042	tmp_e = curr_e;
2043	curr_e = curr_e->next;
2044	vidtv_psi_desc_destroy(desc: tmp_e->descriptor);
2045	kfree(objp: tmp_e);
2046	}
2047	}
2048
2049	void vidtv_psi_eit_table_destroy(struct vidtv_psi_table_eit *eit)
2050	{
2051	vidtv_psi_eit_event_destroy(e: eit->event);
2052	kfree(objp: eit);
2053	}
2054