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