drivers/media/test-drivers/vidtv/vidtv_psi.c

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