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