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