1 // SPDX-License-Identifier: LGPL-2.1-or-later 2 /* 3 * dvb_demux.c - DVB kernel demux API 4 * 5 * Copyright (C) 2000-2001 Ralph Metzler <ralph@convergence.de> 6 * & Marcus Metzler <marcus@convergence.de> 7 * for convergence integrated media GmbH 8 */ 9 10 #define pr_fmt(fmt) "dvb_demux: " fmt 11 12 #include <linux/sched/signal.h> 13 #include <linux/spinlock.h> 14 #include <linux/slab.h> 15 #include <linux/vmalloc.h> 16 #include <linux/module.h> 17 #include <linux/poll.h> 18 #include <linux/string.h> 19 #include <linux/crc32.h> 20 #include <linux/uaccess.h> 21 #include <asm/div64.h> 22 23 #include <media/dvb_demux.h> 24 25 static int dvb_demux_tscheck; 26 module_param(dvb_demux_tscheck, int, 0644); 27 MODULE_PARM_DESC(dvb_demux_tscheck, 28 "enable transport stream continuity and TEI check"); 29 30 static int dvb_demux_speedcheck; 31 module_param(dvb_demux_speedcheck, int, 0644); 32 MODULE_PARM_DESC(dvb_demux_speedcheck, 33 "enable transport stream speed check"); 34 35 static int dvb_demux_feed_err_pkts = 1; 36 module_param(dvb_demux_feed_err_pkts, int, 0644); 37 MODULE_PARM_DESC(dvb_demux_feed_err_pkts, 38 "when set to 0, drop packets with the TEI bit set (1 by default)"); 39 40 #define dprintk(fmt, arg...) \ 41 printk(KERN_DEBUG pr_fmt("%s: " fmt), __func__, ##arg) 42 43 #define dprintk_tscheck(x...) do { \ 44 if (dvb_demux_tscheck && printk_ratelimit()) \ 45 dprintk(x); \ 46 } while (0) 47 48 #ifdef CONFIG_DVB_DEMUX_SECTION_LOSS_LOG 49 # define dprintk_sect_loss(x...) dprintk(x) 50 #else 51 # define dprintk_sect_loss(x...) 52 #endif 53 54 #define set_buf_flags(__feed, __flag) \ 55 do { \ 56 (__feed)->buffer_flags |= (__flag); \ 57 } while (0) 58 59 /****************************************************************************** 60 * static inlined helper functions 61 ******************************************************************************/ 62 63 static inline u16 section_length(const u8 *buf) 64 { 65 return 3 + ((buf[1] & 0x0f) << 8) + buf[2]; 66 } 67 68 static inline u16 ts_pid(const u8 *buf) 69 { 70 return ((buf[1] & 0x1f) << 8) + buf[2]; 71 } 72 73 static inline u8 payload(const u8 *tsp) 74 { 75 if (!(tsp[3] & 0x10)) // no payload? 76 return 0; 77 78 if (tsp[3] & 0x20) { // adaptation field? 79 if (tsp[4] > 183) // corrupted data? 80 return 0; 81 else 82 return 184 - 1 - tsp[4]; 83 } 84 85 return 184; 86 } 87 88 static u32 dvb_dmx_crc32(struct dvb_demux_feed *f, const u8 *src, size_t len) 89 { 90 return (f->feed.sec.crc_val = crc32_be(f->feed.sec.crc_val, src, len)); 91 } 92 93 static void dvb_dmx_memcopy(struct dvb_demux_feed *f, u8 *d, const u8 *s, 94 size_t len) 95 { 96 memcpy(d, s, len); 97 } 98 99 /****************************************************************************** 100 * Software filter functions 101 ******************************************************************************/ 102 103 static inline int dvb_dmx_swfilter_payload(struct dvb_demux_feed *feed, 104 const u8 *buf) 105 { 106 int count = payload(buf); 107 int p; 108 int ccok; 109 u8 cc; 110 111 if (count == 0) 112 return -1; 113 114 p = 188 - count; 115 116 cc = buf[3] & 0x0f; 117 ccok = ((feed->cc + 1) & 0x0f) == cc; 118 if (!ccok) { 119 set_buf_flags(feed, DMX_BUFFER_FLAG_DISCONTINUITY_DETECTED); 120 dprintk_sect_loss("missed packet: %d instead of %d!\n", 121 cc, (feed->cc + 1) & 0x0f); 122 } 123 feed->cc = cc; 124 125 if (buf[1] & 0x40) // PUSI ? 126 feed->peslen = 0xfffa; 127 128 feed->peslen += count; 129 130 return feed->cb.ts(&buf[p], count, NULL, 0, &feed->feed.ts, 131 &feed->buffer_flags); 132 } 133 134 static int dvb_dmx_swfilter_sectionfilter(struct dvb_demux_feed *feed, 135 struct dvb_demux_filter *f) 136 { 137 u8 neq = 0; 138 int i; 139 140 for (i = 0; i < DVB_DEMUX_MASK_MAX; i++) { 141 u8 xor = f->filter.filter_value[i] ^ feed->feed.sec.secbuf[i]; 142 143 if (f->maskandmode[i] & xor) 144 return 0; 145 146 neq |= f->maskandnotmode[i] & xor; 147 } 148 149 if (f->doneq && !neq) 150 return 0; 151 152 return feed->cb.sec(feed->feed.sec.secbuf, feed->feed.sec.seclen, 153 NULL, 0, &f->filter, &feed->buffer_flags); 154 } 155 156 static inline int dvb_dmx_swfilter_section_feed(struct dvb_demux_feed *feed) 157 { 158 struct dvb_demux *demux = feed->demux; 159 struct dvb_demux_filter *f = feed->filter; 160 struct dmx_section_feed *sec = &feed->feed.sec; 161 int section_syntax_indicator; 162 163 if (!sec->is_filtering) 164 return 0; 165 166 if (!f) 167 return 0; 168 169 if (sec->check_crc) { 170 section_syntax_indicator = ((sec->secbuf[1] & 0x80) != 0); 171 if (section_syntax_indicator && 172 demux->check_crc32(feed, sec->secbuf, sec->seclen)) { 173 set_buf_flags(feed, DMX_BUFFER_FLAG_HAD_CRC32_DISCARD); 174 return -1; 175 } 176 } 177 178 do { 179 if (dvb_dmx_swfilter_sectionfilter(feed, f) < 0) 180 return -1; 181 } while ((f = f->next) && sec->is_filtering); 182 183 sec->seclen = 0; 184 185 return 0; 186 } 187 188 static void dvb_dmx_swfilter_section_new(struct dvb_demux_feed *feed) 189 { 190 struct dmx_section_feed *sec = &feed->feed.sec; 191 192 if (sec->secbufp < sec->tsfeedp) { 193 int n = sec->tsfeedp - sec->secbufp; 194 195 /* 196 * Section padding is done with 0xff bytes entirely. 197 * Due to speed reasons, we won't check all of them 198 * but just first and last. 199 */ 200 if (sec->secbuf[0] != 0xff || sec->secbuf[n - 1] != 0xff) { 201 set_buf_flags(feed, 202 DMX_BUFFER_FLAG_DISCONTINUITY_DETECTED); 203 dprintk_sect_loss("section ts padding loss: %d/%d\n", 204 n, sec->tsfeedp); 205 dprintk_sect_loss("pad data: %*ph\n", n, sec->secbuf); 206 } 207 } 208 209 sec->tsfeedp = sec->secbufp = sec->seclen = 0; 210 sec->secbuf = sec->secbuf_base; 211 } 212 213 /* 214 * Losless Section Demux 1.4.1 by Emard 215 * Valsecchi Patrick: 216 * - middle of section A (no PUSI) 217 * - end of section A and start of section B 218 * (with PUSI pointing to the start of the second section) 219 * 220 * In this case, without feed->pusi_seen you'll receive a garbage section 221 * consisting of the end of section A. Basically because tsfeedp 222 * is incemented and the use=0 condition is not raised 223 * when the second packet arrives. 224 * 225 * Fix: 226 * when demux is started, let feed->pusi_seen = false to 227 * prevent initial feeding of garbage from the end of 228 * previous section. When you for the first time see PUSI=1 229 * then set feed->pusi_seen = true 230 */ 231 static int dvb_dmx_swfilter_section_copy_dump(struct dvb_demux_feed *feed, 232 const u8 *buf, u8 len) 233 { 234 struct dvb_demux *demux = feed->demux; 235 struct dmx_section_feed *sec = &feed->feed.sec; 236 u16 limit, seclen; 237 238 if (sec->tsfeedp >= DMX_MAX_SECFEED_SIZE) 239 return 0; 240 241 if (sec->tsfeedp + len > DMX_MAX_SECFEED_SIZE) { 242 set_buf_flags(feed, DMX_BUFFER_FLAG_DISCONTINUITY_DETECTED); 243 dprintk_sect_loss("section buffer full loss: %d/%d\n", 244 sec->tsfeedp + len - DMX_MAX_SECFEED_SIZE, 245 DMX_MAX_SECFEED_SIZE); 246 len = DMX_MAX_SECFEED_SIZE - sec->tsfeedp; 247 } 248 249 if (len <= 0) 250 return 0; 251 252 demux->memcopy(feed, sec->secbuf_base + sec->tsfeedp, buf, len); 253 sec->tsfeedp += len; 254 255 /* 256 * Dump all the sections we can find in the data (Emard) 257 */ 258 limit = sec->tsfeedp; 259 if (limit > DMX_MAX_SECFEED_SIZE) 260 return -1; /* internal error should never happen */ 261 262 /* to be sure always set secbuf */ 263 sec->secbuf = sec->secbuf_base + sec->secbufp; 264 265 while (sec->secbufp + 2 < limit) { 266 seclen = section_length(sec->secbuf); 267 if (seclen <= 0 || seclen > DMX_MAX_SECTION_SIZE 268 || seclen + sec->secbufp > limit) 269 return 0; 270 sec->seclen = seclen; 271 sec->crc_val = ~0; 272 /* dump [secbuf .. secbuf+seclen) */ 273 if (feed->pusi_seen) { 274 dvb_dmx_swfilter_section_feed(feed); 275 } else { 276 set_buf_flags(feed, 277 DMX_BUFFER_FLAG_DISCONTINUITY_DETECTED); 278 dprintk_sect_loss("pusi not seen, discarding section data\n"); 279 } 280 sec->secbufp += seclen; /* secbufp and secbuf moving together is */ 281 sec->secbuf += seclen; /* redundant but saves pointer arithmetic */ 282 } 283 284 return 0; 285 } 286 287 static int dvb_dmx_swfilter_section_packet(struct dvb_demux_feed *feed, 288 const u8 *buf) 289 { 290 u8 p, count; 291 int ccok, dc_i = 0; 292 u8 cc; 293 294 count = payload(buf); 295 296 if (count == 0) /* count == 0 if no payload or out of range */ 297 return -1; 298 299 p = 188 - count; /* payload start */ 300 301 cc = buf[3] & 0x0f; 302 ccok = ((feed->cc + 1) & 0x0f) == cc; 303 304 if (buf[3] & 0x20) { 305 /* adaption field present, check for discontinuity_indicator */ 306 if ((buf[4] > 0) && (buf[5] & 0x80)) 307 dc_i = 1; 308 } 309 310 if (!ccok || dc_i) { 311 if (dc_i) { 312 set_buf_flags(feed, 313 DMX_BUFFER_FLAG_DISCONTINUITY_INDICATOR); 314 dprintk_sect_loss("%d frame with disconnect indicator\n", 315 cc); 316 } else { 317 set_buf_flags(feed, 318 DMX_BUFFER_FLAG_DISCONTINUITY_DETECTED); 319 dprintk_sect_loss("discontinuity: %d instead of %d. %d bytes lost\n", 320 cc, (feed->cc + 1) & 0x0f, count + 4); 321 } 322 /* 323 * those bytes under some circumstances will again be reported 324 * in the following dvb_dmx_swfilter_section_new 325 */ 326 327 /* 328 * Discontinuity detected. Reset pusi_seen to 329 * stop feeding of suspicious data until next PUSI=1 arrives 330 * 331 * FIXME: does it make sense if the MPEG-TS is the one 332 * reporting discontinuity? 333 */ 334 335 feed->pusi_seen = false; 336 dvb_dmx_swfilter_section_new(feed); 337 } 338 feed->cc = cc; 339 340 if (buf[1] & 0x40) { 341 /* PUSI=1 (is set), section boundary is here */ 342 if (count > 1 && buf[p] < count) { 343 const u8 *before = &buf[p + 1]; 344 u8 before_len = buf[p]; 345 const u8 *after = &before[before_len]; 346 u8 after_len = count - 1 - before_len; 347 348 dvb_dmx_swfilter_section_copy_dump(feed, before, 349 before_len); 350 /* before start of new section, set pusi_seen */ 351 feed->pusi_seen = true; 352 dvb_dmx_swfilter_section_new(feed); 353 dvb_dmx_swfilter_section_copy_dump(feed, after, 354 after_len); 355 } else if (count > 0) { 356 set_buf_flags(feed, 357 DMX_BUFFER_FLAG_DISCONTINUITY_DETECTED); 358 dprintk_sect_loss("PUSI=1 but %d bytes lost\n", count); 359 } 360 } else { 361 /* PUSI=0 (is not set), no section boundary */ 362 dvb_dmx_swfilter_section_copy_dump(feed, &buf[p], count); 363 } 364 365 return 0; 366 } 367 368 static inline void dvb_dmx_swfilter_packet_type(struct dvb_demux_feed *feed, 369 const u8 *buf) 370 { 371 switch (feed->type) { 372 case DMX_TYPE_TS: 373 if (!feed->feed.ts.is_filtering) 374 break; 375 if (feed->ts_type & TS_PACKET) { 376 if (feed->ts_type & TS_PAYLOAD_ONLY) 377 dvb_dmx_swfilter_payload(feed, buf); 378 else 379 feed->cb.ts(buf, 188, NULL, 0, &feed->feed.ts, 380 &feed->buffer_flags); 381 } 382 /* Used only on full-featured devices */ 383 if (feed->ts_type & TS_DECODER) 384 if (feed->demux->write_to_decoder) 385 feed->demux->write_to_decoder(feed, buf, 188); 386 break; 387 388 case DMX_TYPE_SEC: 389 if (!feed->feed.sec.is_filtering) 390 break; 391 if (dvb_dmx_swfilter_section_packet(feed, buf) < 0) 392 feed->feed.sec.seclen = feed->feed.sec.secbufp = 0; 393 break; 394 395 default: 396 break; 397 } 398 } 399 400 #define DVR_FEED(f) \ 401 (((f)->type == DMX_TYPE_TS) && \ 402 ((f)->feed.ts.is_filtering) && \ 403 (((f)->ts_type & (TS_PACKET | TS_DEMUX)) == TS_PACKET)) 404 405 static void dvb_dmx_swfilter_packet(struct dvb_demux *demux, const u8 *buf) 406 { 407 struct dvb_demux_feed *feed; 408 u16 pid = ts_pid(buf); 409 int dvr_done = 0; 410 411 if (dvb_demux_speedcheck) { 412 ktime_t cur_time; 413 u64 speed_bytes, speed_timedelta; 414 415 demux->speed_pkts_cnt++; 416 417 /* show speed every SPEED_PKTS_INTERVAL packets */ 418 if (!(demux->speed_pkts_cnt % SPEED_PKTS_INTERVAL)) { 419 cur_time = ktime_get(); 420 421 if (ktime_to_ns(demux->speed_last_time) != 0) { 422 speed_bytes = (u64)demux->speed_pkts_cnt 423 * 188 * 8; 424 /* convert to 1024 basis */ 425 speed_bytes = 1000 * div64_u64(speed_bytes, 426 1024); 427 speed_timedelta = ktime_ms_delta(cur_time, 428 demux->speed_last_time); 429 if (speed_timedelta) 430 dprintk("TS speed %llu Kbits/sec \n", 431 div64_u64(speed_bytes, 432 speed_timedelta)); 433 } 434 435 demux->speed_last_time = cur_time; 436 demux->speed_pkts_cnt = 0; 437 } 438 } 439 440 if (buf[1] & 0x80) { 441 list_for_each_entry(feed, &demux->feed_list, list_head) { 442 if ((feed->pid != pid) && (feed->pid != 0x2000)) 443 continue; 444 set_buf_flags(feed, DMX_BUFFER_FLAG_TEI); 445 } 446 dprintk_tscheck("TEI detected. PID=0x%x data1=0x%x\n", 447 pid, buf[1]); 448 /* data in this packet can't be trusted - drop it unless 449 * module option dvb_demux_feed_err_pkts is set */ 450 if (!dvb_demux_feed_err_pkts) 451 return; 452 } else /* if TEI bit is set, pid may be wrong- skip pkt counter */ 453 if (demux->cnt_storage && dvb_demux_tscheck) { 454 /* check pkt counter */ 455 if (pid < MAX_PID) { 456 if (buf[3] & 0x10) 457 demux->cnt_storage[pid] = 458 (demux->cnt_storage[pid] + 1) & 0xf; 459 460 if ((buf[3] & 0xf) != demux->cnt_storage[pid]) { 461 list_for_each_entry(feed, &demux->feed_list, list_head) { 462 if ((feed->pid != pid) && (feed->pid != 0x2000)) 463 continue; 464 set_buf_flags(feed, 465 DMX_BUFFER_PKT_COUNTER_MISMATCH); 466 } 467 468 dprintk_tscheck("TS packet counter mismatch. PID=0x%x expected 0x%x got 0x%x\n", 469 pid, demux->cnt_storage[pid], 470 buf[3] & 0xf); 471 demux->cnt_storage[pid] = buf[3] & 0xf; 472 } 473 } 474 /* end check */ 475 } 476 477 list_for_each_entry(feed, &demux->feed_list, list_head) { 478 if ((feed->pid != pid) && (feed->pid != 0x2000)) 479 continue; 480 481 /* copy each packet only once to the dvr device, even 482 * if a PID is in multiple filters (e.g. video + PCR) */ 483 if ((DVR_FEED(feed)) && (dvr_done++)) 484 continue; 485 486 if (feed->pid == pid) 487 dvb_dmx_swfilter_packet_type(feed, buf); 488 else if (feed->pid == 0x2000) 489 feed->cb.ts(buf, 188, NULL, 0, &feed->feed.ts, 490 &feed->buffer_flags); 491 } 492 } 493 494 void dvb_dmx_swfilter_packets(struct dvb_demux *demux, const u8 *buf, 495 size_t count) 496 { 497 unsigned long flags; 498 499 spin_lock_irqsave(&demux->lock, flags); 500 501 while (count--) { 502 if (buf[0] == 0x47) 503 dvb_dmx_swfilter_packet(demux, buf); 504 buf += 188; 505 } 506 507 spin_unlock_irqrestore(&demux->lock, flags); 508 } 509 510 EXPORT_SYMBOL(dvb_dmx_swfilter_packets); 511 512 static inline int find_next_packet(const u8 *buf, int pos, size_t count, 513 const int pktsize) 514 { 515 int start = pos, lost; 516 517 while (pos < count) { 518 if (buf[pos] == 0x47 || 519 (pktsize == 204 && buf[pos] == 0xB8)) 520 break; 521 pos++; 522 } 523 524 lost = pos - start; 525 if (lost) { 526 /* This garbage is part of a valid packet? */ 527 int backtrack = pos - pktsize; 528 if (backtrack >= 0 && (buf[backtrack] == 0x47 || 529 (pktsize == 204 && buf[backtrack] == 0xB8))) 530 return backtrack; 531 } 532 533 return pos; 534 } 535 536 /* Filter all pktsize= 188 or 204 sized packets and skip garbage. */ 537 static inline void _dvb_dmx_swfilter(struct dvb_demux *demux, const u8 *buf, 538 size_t count, const int pktsize) 539 { 540 int p = 0, i, j; 541 const u8 *q; 542 unsigned long flags; 543 544 spin_lock_irqsave(&demux->lock, flags); 545 546 if (demux->tsbufp) { /* tsbuf[0] is now 0x47. */ 547 i = demux->tsbufp; 548 j = pktsize - i; 549 if (count < j) { 550 memcpy(&demux->tsbuf[i], buf, count); 551 demux->tsbufp += count; 552 goto bailout; 553 } 554 memcpy(&demux->tsbuf[i], buf, j); 555 if (demux->tsbuf[0] == 0x47) /* double check */ 556 dvb_dmx_swfilter_packet(demux, demux->tsbuf); 557 demux->tsbufp = 0; 558 p += j; 559 } 560 561 while (1) { 562 p = find_next_packet(buf, p, count, pktsize); 563 if (p >= count) 564 break; 565 if (count - p < pktsize) 566 break; 567 568 q = &buf[p]; 569 570 if (pktsize == 204 && (*q == 0xB8)) { 571 memcpy(demux->tsbuf, q, 188); 572 demux->tsbuf[0] = 0x47; 573 q = demux->tsbuf; 574 } 575 dvb_dmx_swfilter_packet(demux, q); 576 p += pktsize; 577 } 578 579 i = count - p; 580 if (i) { 581 memcpy(demux->tsbuf, &buf[p], i); 582 demux->tsbufp = i; 583 if (pktsize == 204 && demux->tsbuf[0] == 0xB8) 584 demux->tsbuf[0] = 0x47; 585 } 586 587 bailout: 588 spin_unlock_irqrestore(&demux->lock, flags); 589 } 590 591 void dvb_dmx_swfilter(struct dvb_demux *demux, const u8 *buf, size_t count) 592 { 593 _dvb_dmx_swfilter(demux, buf, count, 188); 594 } 595 EXPORT_SYMBOL(dvb_dmx_swfilter); 596 597 void dvb_dmx_swfilter_204(struct dvb_demux *demux, const u8 *buf, size_t count) 598 { 599 _dvb_dmx_swfilter(demux, buf, count, 204); 600 } 601 EXPORT_SYMBOL(dvb_dmx_swfilter_204); 602 603 void dvb_dmx_swfilter_raw(struct dvb_demux *demux, const u8 *buf, size_t count) 604 { 605 unsigned long flags; 606 607 spin_lock_irqsave(&demux->lock, flags); 608 609 demux->feed->cb.ts(buf, count, NULL, 0, &demux->feed->feed.ts, 610 &demux->feed->buffer_flags); 611 612 spin_unlock_irqrestore(&demux->lock, flags); 613 } 614 EXPORT_SYMBOL(dvb_dmx_swfilter_raw); 615 616 static struct dvb_demux_filter *dvb_dmx_filter_alloc(struct dvb_demux *demux) 617 { 618 int i; 619 620 for (i = 0; i < demux->filternum; i++) 621 if (demux->filter[i].state == DMX_STATE_FREE) 622 break; 623 624 if (i == demux->filternum) 625 return NULL; 626 627 demux->filter[i].state = DMX_STATE_ALLOCATED; 628 629 return &demux->filter[i]; 630 } 631 632 static struct dvb_demux_feed *dvb_dmx_feed_alloc(struct dvb_demux *demux) 633 { 634 int i; 635 636 for (i = 0; i < demux->feednum; i++) 637 if (demux->feed[i].state == DMX_STATE_FREE) 638 break; 639 640 if (i == demux->feednum) 641 return NULL; 642 643 demux->feed[i].state = DMX_STATE_ALLOCATED; 644 645 return &demux->feed[i]; 646 } 647 648 static int dvb_demux_feed_find(struct dvb_demux_feed *feed) 649 { 650 struct dvb_demux_feed *entry; 651 652 list_for_each_entry(entry, &feed->demux->feed_list, list_head) 653 if (entry == feed) 654 return 1; 655 656 return 0; 657 } 658 659 static void dvb_demux_feed_add(struct dvb_demux_feed *feed) 660 { 661 spin_lock_irq(&feed->demux->lock); 662 if (dvb_demux_feed_find(feed)) { 663 pr_err("%s: feed already in list (type=%x state=%x pid=%x)\n", 664 __func__, feed->type, feed->state, feed->pid); 665 goto out; 666 } 667 668 list_add(&feed->list_head, &feed->demux->feed_list); 669 out: 670 spin_unlock_irq(&feed->demux->lock); 671 } 672 673 static void dvb_demux_feed_del(struct dvb_demux_feed *feed) 674 { 675 spin_lock_irq(&feed->demux->lock); 676 if (!(dvb_demux_feed_find(feed))) { 677 pr_err("%s: feed not in list (type=%x state=%x pid=%x)\n", 678 __func__, feed->type, feed->state, feed->pid); 679 goto out; 680 } 681 682 list_del(&feed->list_head); 683 out: 684 spin_unlock_irq(&feed->demux->lock); 685 } 686 687 static int dmx_ts_feed_set(struct dmx_ts_feed *ts_feed, u16 pid, int ts_type, 688 enum dmx_ts_pes pes_type, ktime_t timeout) 689 { 690 struct dvb_demux_feed *feed = (struct dvb_demux_feed *)ts_feed; 691 struct dvb_demux *demux = feed->demux; 692 693 if (pid > DMX_MAX_PID) 694 return -EINVAL; 695 696 if (mutex_lock_interruptible(&demux->mutex)) 697 return -ERESTARTSYS; 698 699 if (ts_type & TS_DECODER) { 700 if (pes_type >= DMX_PES_OTHER) { 701 mutex_unlock(&demux->mutex); 702 return -EINVAL; 703 } 704 705 if (demux->pesfilter[pes_type] && 706 demux->pesfilter[pes_type] != feed) { 707 mutex_unlock(&demux->mutex); 708 return -EINVAL; 709 } 710 711 demux->pesfilter[pes_type] = feed; 712 demux->pids[pes_type] = pid; 713 } 714 715 dvb_demux_feed_add(feed); 716 717 feed->pid = pid; 718 feed->timeout = timeout; 719 feed->ts_type = ts_type; 720 feed->pes_type = pes_type; 721 722 feed->state = DMX_STATE_READY; 723 mutex_unlock(&demux->mutex); 724 725 return 0; 726 } 727 728 static int dmx_ts_feed_start_filtering(struct dmx_ts_feed *ts_feed) 729 { 730 struct dvb_demux_feed *feed = (struct dvb_demux_feed *)ts_feed; 731 struct dvb_demux *demux = feed->demux; 732 int ret; 733 734 if (mutex_lock_interruptible(&demux->mutex)) 735 return -ERESTARTSYS; 736 737 if (feed->state != DMX_STATE_READY || feed->type != DMX_TYPE_TS) { 738 mutex_unlock(&demux->mutex); 739 return -EINVAL; 740 } 741 742 if (!demux->start_feed) { 743 mutex_unlock(&demux->mutex); 744 return -ENODEV; 745 } 746 747 ret = demux->start_feed(feed); 748 if (ret < 0) { 749 mutex_unlock(&demux->mutex); 750 return ret; 751 } 752 753 spin_lock_irq(&demux->lock); 754 ts_feed->is_filtering = 1; 755 feed->state = DMX_STATE_GO; 756 spin_unlock_irq(&demux->lock); 757 mutex_unlock(&demux->mutex); 758 759 return 0; 760 } 761 762 static int dmx_ts_feed_stop_filtering(struct dmx_ts_feed *ts_feed) 763 { 764 struct dvb_demux_feed *feed = (struct dvb_demux_feed *)ts_feed; 765 struct dvb_demux *demux = feed->demux; 766 int ret; 767 768 mutex_lock(&demux->mutex); 769 770 if (feed->state < DMX_STATE_GO) { 771 mutex_unlock(&demux->mutex); 772 return -EINVAL; 773 } 774 775 if (!demux->stop_feed) { 776 mutex_unlock(&demux->mutex); 777 return -ENODEV; 778 } 779 780 ret = demux->stop_feed(feed); 781 782 spin_lock_irq(&demux->lock); 783 ts_feed->is_filtering = 0; 784 feed->state = DMX_STATE_ALLOCATED; 785 spin_unlock_irq(&demux->lock); 786 mutex_unlock(&demux->mutex); 787 788 return ret; 789 } 790 791 static int dvbdmx_allocate_ts_feed(struct dmx_demux *dmx, 792 struct dmx_ts_feed **ts_feed, 793 dmx_ts_cb callback) 794 { 795 struct dvb_demux *demux = (struct dvb_demux *)dmx; 796 struct dvb_demux_feed *feed; 797 798 if (mutex_lock_interruptible(&demux->mutex)) 799 return -ERESTARTSYS; 800 801 feed = dvb_dmx_feed_alloc(demux); 802 if (!feed) { 803 mutex_unlock(&demux->mutex); 804 return -EBUSY; 805 } 806 807 feed->type = DMX_TYPE_TS; 808 feed->cb.ts = callback; 809 feed->demux = demux; 810 feed->pid = 0xffff; 811 feed->peslen = 0xfffa; 812 feed->buffer_flags = 0; 813 814 (*ts_feed) = &feed->feed.ts; 815 (*ts_feed)->parent = dmx; 816 (*ts_feed)->priv = NULL; 817 (*ts_feed)->is_filtering = 0; 818 (*ts_feed)->start_filtering = dmx_ts_feed_start_filtering; 819 (*ts_feed)->stop_filtering = dmx_ts_feed_stop_filtering; 820 (*ts_feed)->set = dmx_ts_feed_set; 821 822 feed->filter = dvb_dmx_filter_alloc(demux); 823 if (!feed->filter) { 824 feed->state = DMX_STATE_FREE; 825 mutex_unlock(&demux->mutex); 826 return -EBUSY; 827 } 828 829 feed->filter->type = DMX_TYPE_TS; 830 feed->filter->feed = feed; 831 feed->filter->state = DMX_STATE_READY; 832 833 mutex_unlock(&demux->mutex); 834 835 return 0; 836 } 837 838 static int dvbdmx_release_ts_feed(struct dmx_demux *dmx, 839 struct dmx_ts_feed *ts_feed) 840 { 841 struct dvb_demux *demux = (struct dvb_demux *)dmx; 842 struct dvb_demux_feed *feed = (struct dvb_demux_feed *)ts_feed; 843 844 mutex_lock(&demux->mutex); 845 846 if (feed->state == DMX_STATE_FREE) { 847 mutex_unlock(&demux->mutex); 848 return -EINVAL; 849 } 850 851 feed->state = DMX_STATE_FREE; 852 feed->filter->state = DMX_STATE_FREE; 853 854 dvb_demux_feed_del(feed); 855 856 feed->pid = 0xffff; 857 858 if (feed->ts_type & TS_DECODER && feed->pes_type < DMX_PES_OTHER) 859 demux->pesfilter[feed->pes_type] = NULL; 860 861 mutex_unlock(&demux->mutex); 862 return 0; 863 } 864 865 /****************************************************************************** 866 * dmx_section_feed API calls 867 ******************************************************************************/ 868 869 static int dmx_section_feed_allocate_filter(struct dmx_section_feed *feed, 870 struct dmx_section_filter **filter) 871 { 872 struct dvb_demux_feed *dvbdmxfeed = (struct dvb_demux_feed *)feed; 873 struct dvb_demux *dvbdemux = dvbdmxfeed->demux; 874 struct dvb_demux_filter *dvbdmxfilter; 875 876 if (mutex_lock_interruptible(&dvbdemux->mutex)) 877 return -ERESTARTSYS; 878 879 dvbdmxfilter = dvb_dmx_filter_alloc(dvbdemux); 880 if (!dvbdmxfilter) { 881 mutex_unlock(&dvbdemux->mutex); 882 return -EBUSY; 883 } 884 885 spin_lock_irq(&dvbdemux->lock); 886 *filter = &dvbdmxfilter->filter; 887 (*filter)->parent = feed; 888 (*filter)->priv = NULL; 889 dvbdmxfilter->feed = dvbdmxfeed; 890 dvbdmxfilter->type = DMX_TYPE_SEC; 891 dvbdmxfilter->state = DMX_STATE_READY; 892 dvbdmxfilter->next = dvbdmxfeed->filter; 893 dvbdmxfeed->filter = dvbdmxfilter; 894 spin_unlock_irq(&dvbdemux->lock); 895 896 mutex_unlock(&dvbdemux->mutex); 897 return 0; 898 } 899 900 static int dmx_section_feed_set(struct dmx_section_feed *feed, 901 u16 pid, int check_crc) 902 { 903 struct dvb_demux_feed *dvbdmxfeed = (struct dvb_demux_feed *)feed; 904 struct dvb_demux *dvbdmx = dvbdmxfeed->demux; 905 906 if (pid > 0x1fff) 907 return -EINVAL; 908 909 if (mutex_lock_interruptible(&dvbdmx->mutex)) 910 return -ERESTARTSYS; 911 912 dvb_demux_feed_add(dvbdmxfeed); 913 914 dvbdmxfeed->pid = pid; 915 dvbdmxfeed->feed.sec.check_crc = check_crc; 916 917 dvbdmxfeed->state = DMX_STATE_READY; 918 mutex_unlock(&dvbdmx->mutex); 919 return 0; 920 } 921 922 static void prepare_secfilters(struct dvb_demux_feed *dvbdmxfeed) 923 { 924 int i; 925 struct dvb_demux_filter *f; 926 struct dmx_section_filter *sf; 927 u8 mask, mode, doneq; 928 929 f = dvbdmxfeed->filter; 930 if (!f) 931 return; 932 do { 933 sf = &f->filter; 934 doneq = false; 935 for (i = 0; i < DVB_DEMUX_MASK_MAX; i++) { 936 mode = sf->filter_mode[i]; 937 mask = sf->filter_mask[i]; 938 f->maskandmode[i] = mask & mode; 939 doneq |= f->maskandnotmode[i] = mask & ~mode; 940 } 941 f->doneq = doneq ? true : false; 942 } while ((f = f->next)); 943 } 944 945 static int dmx_section_feed_start_filtering(struct dmx_section_feed *feed) 946 { 947 struct dvb_demux_feed *dvbdmxfeed = (struct dvb_demux_feed *)feed; 948 struct dvb_demux *dvbdmx = dvbdmxfeed->demux; 949 int ret; 950 951 if (mutex_lock_interruptible(&dvbdmx->mutex)) 952 return -ERESTARTSYS; 953 954 if (feed->is_filtering) { 955 mutex_unlock(&dvbdmx->mutex); 956 return -EBUSY; 957 } 958 959 if (!dvbdmxfeed->filter) { 960 mutex_unlock(&dvbdmx->mutex); 961 return -EINVAL; 962 } 963 964 dvbdmxfeed->feed.sec.tsfeedp = 0; 965 dvbdmxfeed->feed.sec.secbuf = dvbdmxfeed->feed.sec.secbuf_base; 966 dvbdmxfeed->feed.sec.secbufp = 0; 967 dvbdmxfeed->feed.sec.seclen = 0; 968 dvbdmxfeed->pusi_seen = false; 969 970 if (!dvbdmx->start_feed) { 971 mutex_unlock(&dvbdmx->mutex); 972 return -ENODEV; 973 } 974 975 prepare_secfilters(dvbdmxfeed); 976 977 ret = dvbdmx->start_feed(dvbdmxfeed); 978 if (ret < 0) { 979 mutex_unlock(&dvbdmx->mutex); 980 return ret; 981 } 982 983 spin_lock_irq(&dvbdmx->lock); 984 feed->is_filtering = 1; 985 dvbdmxfeed->state = DMX_STATE_GO; 986 spin_unlock_irq(&dvbdmx->lock); 987 988 mutex_unlock(&dvbdmx->mutex); 989 return 0; 990 } 991 992 static int dmx_section_feed_stop_filtering(struct dmx_section_feed *feed) 993 { 994 struct dvb_demux_feed *dvbdmxfeed = (struct dvb_demux_feed *)feed; 995 struct dvb_demux *dvbdmx = dvbdmxfeed->demux; 996 int ret; 997 998 mutex_lock(&dvbdmx->mutex); 999 1000 if (!dvbdmx->stop_feed) { 1001 mutex_unlock(&dvbdmx->mutex); 1002 return -ENODEV; 1003 } 1004 1005 ret = dvbdmx->stop_feed(dvbdmxfeed); 1006 1007 spin_lock_irq(&dvbdmx->lock); 1008 dvbdmxfeed->state = DMX_STATE_READY; 1009 feed->is_filtering = 0; 1010 spin_unlock_irq(&dvbdmx->lock); 1011 1012 mutex_unlock(&dvbdmx->mutex); 1013 return ret; 1014 } 1015 1016 static int dmx_section_feed_release_filter(struct dmx_section_feed *feed, 1017 struct dmx_section_filter *filter) 1018 { 1019 struct dvb_demux_filter *dvbdmxfilter = (struct dvb_demux_filter *)filter, *f; 1020 struct dvb_demux_feed *dvbdmxfeed = (struct dvb_demux_feed *)feed; 1021 struct dvb_demux *dvbdmx = dvbdmxfeed->demux; 1022 1023 mutex_lock(&dvbdmx->mutex); 1024 1025 if (dvbdmxfilter->feed != dvbdmxfeed) { 1026 mutex_unlock(&dvbdmx->mutex); 1027 return -EINVAL; 1028 } 1029 1030 if (feed->is_filtering) { 1031 /* release dvbdmx->mutex as far as it is 1032 acquired by stop_filtering() itself */ 1033 mutex_unlock(&dvbdmx->mutex); 1034 feed->stop_filtering(feed); 1035 mutex_lock(&dvbdmx->mutex); 1036 } 1037 1038 spin_lock_irq(&dvbdmx->lock); 1039 f = dvbdmxfeed->filter; 1040 1041 if (f == dvbdmxfilter) { 1042 dvbdmxfeed->filter = dvbdmxfilter->next; 1043 } else { 1044 while (f->next != dvbdmxfilter) 1045 f = f->next; 1046 f->next = f->next->next; 1047 } 1048 1049 dvbdmxfilter->state = DMX_STATE_FREE; 1050 spin_unlock_irq(&dvbdmx->lock); 1051 mutex_unlock(&dvbdmx->mutex); 1052 return 0; 1053 } 1054 1055 static int dvbdmx_allocate_section_feed(struct dmx_demux *demux, 1056 struct dmx_section_feed **feed, 1057 dmx_section_cb callback) 1058 { 1059 struct dvb_demux *dvbdmx = (struct dvb_demux *)demux; 1060 struct dvb_demux_feed *dvbdmxfeed; 1061 1062 if (mutex_lock_interruptible(&dvbdmx->mutex)) 1063 return -ERESTARTSYS; 1064 1065 dvbdmxfeed = dvb_dmx_feed_alloc(dvbdmx); 1066 if (!dvbdmxfeed) { 1067 mutex_unlock(&dvbdmx->mutex); 1068 return -EBUSY; 1069 } 1070 1071 dvbdmxfeed->type = DMX_TYPE_SEC; 1072 dvbdmxfeed->cb.sec = callback; 1073 dvbdmxfeed->demux = dvbdmx; 1074 dvbdmxfeed->pid = 0xffff; 1075 dvbdmxfeed->buffer_flags = 0; 1076 dvbdmxfeed->feed.sec.secbuf = dvbdmxfeed->feed.sec.secbuf_base; 1077 dvbdmxfeed->feed.sec.secbufp = dvbdmxfeed->feed.sec.seclen = 0; 1078 dvbdmxfeed->feed.sec.tsfeedp = 0; 1079 dvbdmxfeed->filter = NULL; 1080 1081 (*feed) = &dvbdmxfeed->feed.sec; 1082 (*feed)->is_filtering = 0; 1083 (*feed)->parent = demux; 1084 (*feed)->priv = NULL; 1085 1086 (*feed)->set = dmx_section_feed_set; 1087 (*feed)->allocate_filter = dmx_section_feed_allocate_filter; 1088 (*feed)->start_filtering = dmx_section_feed_start_filtering; 1089 (*feed)->stop_filtering = dmx_section_feed_stop_filtering; 1090 (*feed)->release_filter = dmx_section_feed_release_filter; 1091 1092 mutex_unlock(&dvbdmx->mutex); 1093 return 0; 1094 } 1095 1096 static int dvbdmx_release_section_feed(struct dmx_demux *demux, 1097 struct dmx_section_feed *feed) 1098 { 1099 struct dvb_demux_feed *dvbdmxfeed = (struct dvb_demux_feed *)feed; 1100 struct dvb_demux *dvbdmx = (struct dvb_demux *)demux; 1101 1102 mutex_lock(&dvbdmx->mutex); 1103 1104 if (dvbdmxfeed->state == DMX_STATE_FREE) { 1105 mutex_unlock(&dvbdmx->mutex); 1106 return -EINVAL; 1107 } 1108 dvbdmxfeed->state = DMX_STATE_FREE; 1109 1110 dvb_demux_feed_del(dvbdmxfeed); 1111 1112 dvbdmxfeed->pid = 0xffff; 1113 1114 mutex_unlock(&dvbdmx->mutex); 1115 return 0; 1116 } 1117 1118 /****************************************************************************** 1119 * dvb_demux kernel data API calls 1120 ******************************************************************************/ 1121 1122 static int dvbdmx_open(struct dmx_demux *demux) 1123 { 1124 struct dvb_demux *dvbdemux = (struct dvb_demux *)demux; 1125 1126 if (dvbdemux->users >= MAX_DVB_DEMUX_USERS) 1127 return -EUSERS; 1128 1129 dvbdemux->users++; 1130 return 0; 1131 } 1132 1133 static int dvbdmx_close(struct dmx_demux *demux) 1134 { 1135 struct dvb_demux *dvbdemux = (struct dvb_demux *)demux; 1136 1137 if (dvbdemux->users == 0) 1138 return -ENODEV; 1139 1140 dvbdemux->users--; 1141 //FIXME: release any unneeded resources if users==0 1142 return 0; 1143 } 1144 1145 static int dvbdmx_write(struct dmx_demux *demux, const char __user *buf, size_t count) 1146 { 1147 struct dvb_demux *dvbdemux = (struct dvb_demux *)demux; 1148 void *p; 1149 1150 if ((!demux->frontend) || (demux->frontend->source != DMX_MEMORY_FE)) 1151 return -EINVAL; 1152 1153 p = memdup_user(buf, count); 1154 if (IS_ERR(p)) 1155 return PTR_ERR(p); 1156 if (mutex_lock_interruptible(&dvbdemux->mutex)) { 1157 kfree(p); 1158 return -ERESTARTSYS; 1159 } 1160 dvb_dmx_swfilter(dvbdemux, p, count); 1161 kfree(p); 1162 mutex_unlock(&dvbdemux->mutex); 1163 1164 if (signal_pending(current)) 1165 return -EINTR; 1166 return count; 1167 } 1168 1169 static int dvbdmx_add_frontend(struct dmx_demux *demux, 1170 struct dmx_frontend *frontend) 1171 { 1172 struct dvb_demux *dvbdemux = (struct dvb_demux *)demux; 1173 struct list_head *head = &dvbdemux->frontend_list; 1174 1175 list_add(&(frontend->connectivity_list), head); 1176 1177 return 0; 1178 } 1179 1180 static int dvbdmx_remove_frontend(struct dmx_demux *demux, 1181 struct dmx_frontend *frontend) 1182 { 1183 struct dvb_demux *dvbdemux = (struct dvb_demux *)demux; 1184 struct list_head *pos, *n, *head = &dvbdemux->frontend_list; 1185 1186 list_for_each_safe(pos, n, head) { 1187 if (DMX_FE_ENTRY(pos) == frontend) { 1188 list_del(pos); 1189 return 0; 1190 } 1191 } 1192 1193 return -ENODEV; 1194 } 1195 1196 static struct list_head *dvbdmx_get_frontends(struct dmx_demux *demux) 1197 { 1198 struct dvb_demux *dvbdemux = (struct dvb_demux *)demux; 1199 1200 if (list_empty(&dvbdemux->frontend_list)) 1201 return NULL; 1202 1203 return &dvbdemux->frontend_list; 1204 } 1205 1206 static int dvbdmx_connect_frontend(struct dmx_demux *demux, 1207 struct dmx_frontend *frontend) 1208 { 1209 struct dvb_demux *dvbdemux = (struct dvb_demux *)demux; 1210 1211 if (demux->frontend) 1212 return -EINVAL; 1213 1214 mutex_lock(&dvbdemux->mutex); 1215 1216 demux->frontend = frontend; 1217 mutex_unlock(&dvbdemux->mutex); 1218 return 0; 1219 } 1220 1221 static int dvbdmx_disconnect_frontend(struct dmx_demux *demux) 1222 { 1223 struct dvb_demux *dvbdemux = (struct dvb_demux *)demux; 1224 1225 mutex_lock(&dvbdemux->mutex); 1226 1227 demux->frontend = NULL; 1228 mutex_unlock(&dvbdemux->mutex); 1229 return 0; 1230 } 1231 1232 static int dvbdmx_get_pes_pids(struct dmx_demux *demux, u16 *pids) 1233 { 1234 struct dvb_demux *dvbdemux = (struct dvb_demux *)demux; 1235 1236 memcpy(pids, dvbdemux->pids, 5 * sizeof(u16)); 1237 return 0; 1238 } 1239 1240 int dvb_dmx_init(struct dvb_demux *dvbdemux) 1241 { 1242 int i; 1243 struct dmx_demux *dmx = &dvbdemux->dmx; 1244 1245 dvbdemux->cnt_storage = NULL; 1246 dvbdemux->users = 0; 1247 dvbdemux->filter = vmalloc_array(dvbdemux->filternum, 1248 sizeof(struct dvb_demux_filter)); 1249 1250 if (!dvbdemux->filter) 1251 return -ENOMEM; 1252 1253 dvbdemux->feed = vmalloc_array(dvbdemux->feednum, 1254 sizeof(struct dvb_demux_feed)); 1255 if (!dvbdemux->feed) { 1256 vfree(dvbdemux->filter); 1257 dvbdemux->filter = NULL; 1258 return -ENOMEM; 1259 } 1260 for (i = 0; i < dvbdemux->filternum; i++) { 1261 dvbdemux->filter[i].state = DMX_STATE_FREE; 1262 dvbdemux->filter[i].index = i; 1263 } 1264 for (i = 0; i < dvbdemux->feednum; i++) { 1265 dvbdemux->feed[i].state = DMX_STATE_FREE; 1266 dvbdemux->feed[i].index = i; 1267 } 1268 1269 dvbdemux->cnt_storage = vmalloc(MAX_PID + 1); 1270 if (!dvbdemux->cnt_storage) 1271 pr_warn("Couldn't allocate memory for TS/TEI check. Disabling it\n"); 1272 1273 INIT_LIST_HEAD(&dvbdemux->frontend_list); 1274 1275 for (i = 0; i < DMX_PES_OTHER; i++) { 1276 dvbdemux->pesfilter[i] = NULL; 1277 dvbdemux->pids[i] = 0xffff; 1278 } 1279 1280 INIT_LIST_HEAD(&dvbdemux->feed_list); 1281 1282 dvbdemux->playing = 0; 1283 dvbdemux->recording = 0; 1284 dvbdemux->tsbufp = 0; 1285 1286 if (!dvbdemux->check_crc32) 1287 dvbdemux->check_crc32 = dvb_dmx_crc32; 1288 1289 if (!dvbdemux->memcopy) 1290 dvbdemux->memcopy = dvb_dmx_memcopy; 1291 1292 dmx->frontend = NULL; 1293 dmx->priv = dvbdemux; 1294 dmx->open = dvbdmx_open; 1295 dmx->close = dvbdmx_close; 1296 dmx->write = dvbdmx_write; 1297 dmx->allocate_ts_feed = dvbdmx_allocate_ts_feed; 1298 dmx->release_ts_feed = dvbdmx_release_ts_feed; 1299 dmx->allocate_section_feed = dvbdmx_allocate_section_feed; 1300 dmx->release_section_feed = dvbdmx_release_section_feed; 1301 1302 dmx->add_frontend = dvbdmx_add_frontend; 1303 dmx->remove_frontend = dvbdmx_remove_frontend; 1304 dmx->get_frontends = dvbdmx_get_frontends; 1305 dmx->connect_frontend = dvbdmx_connect_frontend; 1306 dmx->disconnect_frontend = dvbdmx_disconnect_frontend; 1307 dmx->get_pes_pids = dvbdmx_get_pes_pids; 1308 1309 mutex_init(&dvbdemux->mutex); 1310 spin_lock_init(&dvbdemux->lock); 1311 1312 return 0; 1313 } 1314 1315 EXPORT_SYMBOL(dvb_dmx_init); 1316 1317 void dvb_dmx_release(struct dvb_demux *dvbdemux) 1318 { 1319 vfree(dvbdemux->cnt_storage); 1320 vfree(dvbdemux->filter); 1321 vfree(dvbdemux->feed); 1322 } 1323 1324 EXPORT_SYMBOL(dvb_dmx_release); 1325