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 if ((ret = demux->start_feed(feed)) < 0) { 748 mutex_unlock(&demux->mutex); 749 return ret; 750 } 751 752 spin_lock_irq(&demux->lock); 753 ts_feed->is_filtering = 1; 754 feed->state = DMX_STATE_GO; 755 spin_unlock_irq(&demux->lock); 756 mutex_unlock(&demux->mutex); 757 758 return 0; 759 } 760 761 static int dmx_ts_feed_stop_filtering(struct dmx_ts_feed *ts_feed) 762 { 763 struct dvb_demux_feed *feed = (struct dvb_demux_feed *)ts_feed; 764 struct dvb_demux *demux = feed->demux; 765 int ret; 766 767 mutex_lock(&demux->mutex); 768 769 if (feed->state < DMX_STATE_GO) { 770 mutex_unlock(&demux->mutex); 771 return -EINVAL; 772 } 773 774 if (!demux->stop_feed) { 775 mutex_unlock(&demux->mutex); 776 return -ENODEV; 777 } 778 779 ret = demux->stop_feed(feed); 780 781 spin_lock_irq(&demux->lock); 782 ts_feed->is_filtering = 0; 783 feed->state = DMX_STATE_ALLOCATED; 784 spin_unlock_irq(&demux->lock); 785 mutex_unlock(&demux->mutex); 786 787 return ret; 788 } 789 790 static int dvbdmx_allocate_ts_feed(struct dmx_demux *dmx, 791 struct dmx_ts_feed **ts_feed, 792 dmx_ts_cb callback) 793 { 794 struct dvb_demux *demux = (struct dvb_demux *)dmx; 795 struct dvb_demux_feed *feed; 796 797 if (mutex_lock_interruptible(&demux->mutex)) 798 return -ERESTARTSYS; 799 800 if (!(feed = dvb_dmx_feed_alloc(demux))) { 801 mutex_unlock(&demux->mutex); 802 return -EBUSY; 803 } 804 805 feed->type = DMX_TYPE_TS; 806 feed->cb.ts = callback; 807 feed->demux = demux; 808 feed->pid = 0xffff; 809 feed->peslen = 0xfffa; 810 feed->buffer_flags = 0; 811 812 (*ts_feed) = &feed->feed.ts; 813 (*ts_feed)->parent = dmx; 814 (*ts_feed)->priv = NULL; 815 (*ts_feed)->is_filtering = 0; 816 (*ts_feed)->start_filtering = dmx_ts_feed_start_filtering; 817 (*ts_feed)->stop_filtering = dmx_ts_feed_stop_filtering; 818 (*ts_feed)->set = dmx_ts_feed_set; 819 820 if (!(feed->filter = dvb_dmx_filter_alloc(demux))) { 821 feed->state = DMX_STATE_FREE; 822 mutex_unlock(&demux->mutex); 823 return -EBUSY; 824 } 825 826 feed->filter->type = DMX_TYPE_TS; 827 feed->filter->feed = feed; 828 feed->filter->state = DMX_STATE_READY; 829 830 mutex_unlock(&demux->mutex); 831 832 return 0; 833 } 834 835 static int dvbdmx_release_ts_feed(struct dmx_demux *dmx, 836 struct dmx_ts_feed *ts_feed) 837 { 838 struct dvb_demux *demux = (struct dvb_demux *)dmx; 839 struct dvb_demux_feed *feed = (struct dvb_demux_feed *)ts_feed; 840 841 mutex_lock(&demux->mutex); 842 843 if (feed->state == DMX_STATE_FREE) { 844 mutex_unlock(&demux->mutex); 845 return -EINVAL; 846 } 847 848 feed->state = DMX_STATE_FREE; 849 feed->filter->state = DMX_STATE_FREE; 850 851 dvb_demux_feed_del(feed); 852 853 feed->pid = 0xffff; 854 855 if (feed->ts_type & TS_DECODER && feed->pes_type < DMX_PES_OTHER) 856 demux->pesfilter[feed->pes_type] = NULL; 857 858 mutex_unlock(&demux->mutex); 859 return 0; 860 } 861 862 /****************************************************************************** 863 * dmx_section_feed API calls 864 ******************************************************************************/ 865 866 static int dmx_section_feed_allocate_filter(struct dmx_section_feed *feed, 867 struct dmx_section_filter **filter) 868 { 869 struct dvb_demux_feed *dvbdmxfeed = (struct dvb_demux_feed *)feed; 870 struct dvb_demux *dvbdemux = dvbdmxfeed->demux; 871 struct dvb_demux_filter *dvbdmxfilter; 872 873 if (mutex_lock_interruptible(&dvbdemux->mutex)) 874 return -ERESTARTSYS; 875 876 dvbdmxfilter = dvb_dmx_filter_alloc(dvbdemux); 877 if (!dvbdmxfilter) { 878 mutex_unlock(&dvbdemux->mutex); 879 return -EBUSY; 880 } 881 882 spin_lock_irq(&dvbdemux->lock); 883 *filter = &dvbdmxfilter->filter; 884 (*filter)->parent = feed; 885 (*filter)->priv = NULL; 886 dvbdmxfilter->feed = dvbdmxfeed; 887 dvbdmxfilter->type = DMX_TYPE_SEC; 888 dvbdmxfilter->state = DMX_STATE_READY; 889 dvbdmxfilter->next = dvbdmxfeed->filter; 890 dvbdmxfeed->filter = dvbdmxfilter; 891 spin_unlock_irq(&dvbdemux->lock); 892 893 mutex_unlock(&dvbdemux->mutex); 894 return 0; 895 } 896 897 static int dmx_section_feed_set(struct dmx_section_feed *feed, 898 u16 pid, int check_crc) 899 { 900 struct dvb_demux_feed *dvbdmxfeed = (struct dvb_demux_feed *)feed; 901 struct dvb_demux *dvbdmx = dvbdmxfeed->demux; 902 903 if (pid > 0x1fff) 904 return -EINVAL; 905 906 if (mutex_lock_interruptible(&dvbdmx->mutex)) 907 return -ERESTARTSYS; 908 909 dvb_demux_feed_add(dvbdmxfeed); 910 911 dvbdmxfeed->pid = pid; 912 dvbdmxfeed->feed.sec.check_crc = check_crc; 913 914 dvbdmxfeed->state = DMX_STATE_READY; 915 mutex_unlock(&dvbdmx->mutex); 916 return 0; 917 } 918 919 static void prepare_secfilters(struct dvb_demux_feed *dvbdmxfeed) 920 { 921 int i; 922 struct dvb_demux_filter *f; 923 struct dmx_section_filter *sf; 924 u8 mask, mode, doneq; 925 926 if (!(f = dvbdmxfeed->filter)) 927 return; 928 do { 929 sf = &f->filter; 930 doneq = false; 931 for (i = 0; i < DVB_DEMUX_MASK_MAX; i++) { 932 mode = sf->filter_mode[i]; 933 mask = sf->filter_mask[i]; 934 f->maskandmode[i] = mask & mode; 935 doneq |= f->maskandnotmode[i] = mask & ~mode; 936 } 937 f->doneq = doneq ? true : false; 938 } while ((f = f->next)); 939 } 940 941 static int dmx_section_feed_start_filtering(struct dmx_section_feed *feed) 942 { 943 struct dvb_demux_feed *dvbdmxfeed = (struct dvb_demux_feed *)feed; 944 struct dvb_demux *dvbdmx = dvbdmxfeed->demux; 945 int ret; 946 947 if (mutex_lock_interruptible(&dvbdmx->mutex)) 948 return -ERESTARTSYS; 949 950 if (feed->is_filtering) { 951 mutex_unlock(&dvbdmx->mutex); 952 return -EBUSY; 953 } 954 955 if (!dvbdmxfeed->filter) { 956 mutex_unlock(&dvbdmx->mutex); 957 return -EINVAL; 958 } 959 960 dvbdmxfeed->feed.sec.tsfeedp = 0; 961 dvbdmxfeed->feed.sec.secbuf = dvbdmxfeed->feed.sec.secbuf_base; 962 dvbdmxfeed->feed.sec.secbufp = 0; 963 dvbdmxfeed->feed.sec.seclen = 0; 964 dvbdmxfeed->pusi_seen = false; 965 966 if (!dvbdmx->start_feed) { 967 mutex_unlock(&dvbdmx->mutex); 968 return -ENODEV; 969 } 970 971 prepare_secfilters(dvbdmxfeed); 972 973 if ((ret = dvbdmx->start_feed(dvbdmxfeed)) < 0) { 974 mutex_unlock(&dvbdmx->mutex); 975 return ret; 976 } 977 978 spin_lock_irq(&dvbdmx->lock); 979 feed->is_filtering = 1; 980 dvbdmxfeed->state = DMX_STATE_GO; 981 spin_unlock_irq(&dvbdmx->lock); 982 983 mutex_unlock(&dvbdmx->mutex); 984 return 0; 985 } 986 987 static int dmx_section_feed_stop_filtering(struct dmx_section_feed *feed) 988 { 989 struct dvb_demux_feed *dvbdmxfeed = (struct dvb_demux_feed *)feed; 990 struct dvb_demux *dvbdmx = dvbdmxfeed->demux; 991 int ret; 992 993 mutex_lock(&dvbdmx->mutex); 994 995 if (!dvbdmx->stop_feed) { 996 mutex_unlock(&dvbdmx->mutex); 997 return -ENODEV; 998 } 999 1000 ret = dvbdmx->stop_feed(dvbdmxfeed); 1001 1002 spin_lock_irq(&dvbdmx->lock); 1003 dvbdmxfeed->state = DMX_STATE_READY; 1004 feed->is_filtering = 0; 1005 spin_unlock_irq(&dvbdmx->lock); 1006 1007 mutex_unlock(&dvbdmx->mutex); 1008 return ret; 1009 } 1010 1011 static int dmx_section_feed_release_filter(struct dmx_section_feed *feed, 1012 struct dmx_section_filter *filter) 1013 { 1014 struct dvb_demux_filter *dvbdmxfilter = (struct dvb_demux_filter *)filter, *f; 1015 struct dvb_demux_feed *dvbdmxfeed = (struct dvb_demux_feed *)feed; 1016 struct dvb_demux *dvbdmx = dvbdmxfeed->demux; 1017 1018 mutex_lock(&dvbdmx->mutex); 1019 1020 if (dvbdmxfilter->feed != dvbdmxfeed) { 1021 mutex_unlock(&dvbdmx->mutex); 1022 return -EINVAL; 1023 } 1024 1025 if (feed->is_filtering) { 1026 /* release dvbdmx->mutex as far as it is 1027 acquired by stop_filtering() itself */ 1028 mutex_unlock(&dvbdmx->mutex); 1029 feed->stop_filtering(feed); 1030 mutex_lock(&dvbdmx->mutex); 1031 } 1032 1033 spin_lock_irq(&dvbdmx->lock); 1034 f = dvbdmxfeed->filter; 1035 1036 if (f == dvbdmxfilter) { 1037 dvbdmxfeed->filter = dvbdmxfilter->next; 1038 } else { 1039 while (f->next != dvbdmxfilter) 1040 f = f->next; 1041 f->next = f->next->next; 1042 } 1043 1044 dvbdmxfilter->state = DMX_STATE_FREE; 1045 spin_unlock_irq(&dvbdmx->lock); 1046 mutex_unlock(&dvbdmx->mutex); 1047 return 0; 1048 } 1049 1050 static int dvbdmx_allocate_section_feed(struct dmx_demux *demux, 1051 struct dmx_section_feed **feed, 1052 dmx_section_cb callback) 1053 { 1054 struct dvb_demux *dvbdmx = (struct dvb_demux *)demux; 1055 struct dvb_demux_feed *dvbdmxfeed; 1056 1057 if (mutex_lock_interruptible(&dvbdmx->mutex)) 1058 return -ERESTARTSYS; 1059 1060 if (!(dvbdmxfeed = dvb_dmx_feed_alloc(dvbdmx))) { 1061 mutex_unlock(&dvbdmx->mutex); 1062 return -EBUSY; 1063 } 1064 1065 dvbdmxfeed->type = DMX_TYPE_SEC; 1066 dvbdmxfeed->cb.sec = callback; 1067 dvbdmxfeed->demux = dvbdmx; 1068 dvbdmxfeed->pid = 0xffff; 1069 dvbdmxfeed->buffer_flags = 0; 1070 dvbdmxfeed->feed.sec.secbuf = dvbdmxfeed->feed.sec.secbuf_base; 1071 dvbdmxfeed->feed.sec.secbufp = dvbdmxfeed->feed.sec.seclen = 0; 1072 dvbdmxfeed->feed.sec.tsfeedp = 0; 1073 dvbdmxfeed->filter = NULL; 1074 1075 (*feed) = &dvbdmxfeed->feed.sec; 1076 (*feed)->is_filtering = 0; 1077 (*feed)->parent = demux; 1078 (*feed)->priv = NULL; 1079 1080 (*feed)->set = dmx_section_feed_set; 1081 (*feed)->allocate_filter = dmx_section_feed_allocate_filter; 1082 (*feed)->start_filtering = dmx_section_feed_start_filtering; 1083 (*feed)->stop_filtering = dmx_section_feed_stop_filtering; 1084 (*feed)->release_filter = dmx_section_feed_release_filter; 1085 1086 mutex_unlock(&dvbdmx->mutex); 1087 return 0; 1088 } 1089 1090 static int dvbdmx_release_section_feed(struct dmx_demux *demux, 1091 struct dmx_section_feed *feed) 1092 { 1093 struct dvb_demux_feed *dvbdmxfeed = (struct dvb_demux_feed *)feed; 1094 struct dvb_demux *dvbdmx = (struct dvb_demux *)demux; 1095 1096 mutex_lock(&dvbdmx->mutex); 1097 1098 if (dvbdmxfeed->state == DMX_STATE_FREE) { 1099 mutex_unlock(&dvbdmx->mutex); 1100 return -EINVAL; 1101 } 1102 dvbdmxfeed->state = DMX_STATE_FREE; 1103 1104 dvb_demux_feed_del(dvbdmxfeed); 1105 1106 dvbdmxfeed->pid = 0xffff; 1107 1108 mutex_unlock(&dvbdmx->mutex); 1109 return 0; 1110 } 1111 1112 /****************************************************************************** 1113 * dvb_demux kernel data API calls 1114 ******************************************************************************/ 1115 1116 static int dvbdmx_open(struct dmx_demux *demux) 1117 { 1118 struct dvb_demux *dvbdemux = (struct dvb_demux *)demux; 1119 1120 if (dvbdemux->users >= MAX_DVB_DEMUX_USERS) 1121 return -EUSERS; 1122 1123 dvbdemux->users++; 1124 return 0; 1125 } 1126 1127 static int dvbdmx_close(struct dmx_demux *demux) 1128 { 1129 struct dvb_demux *dvbdemux = (struct dvb_demux *)demux; 1130 1131 if (dvbdemux->users == 0) 1132 return -ENODEV; 1133 1134 dvbdemux->users--; 1135 //FIXME: release any unneeded resources if users==0 1136 return 0; 1137 } 1138 1139 static int dvbdmx_write(struct dmx_demux *demux, const char __user *buf, size_t count) 1140 { 1141 struct dvb_demux *dvbdemux = (struct dvb_demux *)demux; 1142 void *p; 1143 1144 if ((!demux->frontend) || (demux->frontend->source != DMX_MEMORY_FE)) 1145 return -EINVAL; 1146 1147 p = memdup_user(buf, count); 1148 if (IS_ERR(p)) 1149 return PTR_ERR(p); 1150 if (mutex_lock_interruptible(&dvbdemux->mutex)) { 1151 kfree(p); 1152 return -ERESTARTSYS; 1153 } 1154 dvb_dmx_swfilter(dvbdemux, p, count); 1155 kfree(p); 1156 mutex_unlock(&dvbdemux->mutex); 1157 1158 if (signal_pending(current)) 1159 return -EINTR; 1160 return count; 1161 } 1162 1163 static int dvbdmx_add_frontend(struct dmx_demux *demux, 1164 struct dmx_frontend *frontend) 1165 { 1166 struct dvb_demux *dvbdemux = (struct dvb_demux *)demux; 1167 struct list_head *head = &dvbdemux->frontend_list; 1168 1169 list_add(&(frontend->connectivity_list), head); 1170 1171 return 0; 1172 } 1173 1174 static int dvbdmx_remove_frontend(struct dmx_demux *demux, 1175 struct dmx_frontend *frontend) 1176 { 1177 struct dvb_demux *dvbdemux = (struct dvb_demux *)demux; 1178 struct list_head *pos, *n, *head = &dvbdemux->frontend_list; 1179 1180 list_for_each_safe(pos, n, head) { 1181 if (DMX_FE_ENTRY(pos) == frontend) { 1182 list_del(pos); 1183 return 0; 1184 } 1185 } 1186 1187 return -ENODEV; 1188 } 1189 1190 static struct list_head *dvbdmx_get_frontends(struct dmx_demux *demux) 1191 { 1192 struct dvb_demux *dvbdemux = (struct dvb_demux *)demux; 1193 1194 if (list_empty(&dvbdemux->frontend_list)) 1195 return NULL; 1196 1197 return &dvbdemux->frontend_list; 1198 } 1199 1200 static int dvbdmx_connect_frontend(struct dmx_demux *demux, 1201 struct dmx_frontend *frontend) 1202 { 1203 struct dvb_demux *dvbdemux = (struct dvb_demux *)demux; 1204 1205 if (demux->frontend) 1206 return -EINVAL; 1207 1208 mutex_lock(&dvbdemux->mutex); 1209 1210 demux->frontend = frontend; 1211 mutex_unlock(&dvbdemux->mutex); 1212 return 0; 1213 } 1214 1215 static int dvbdmx_disconnect_frontend(struct dmx_demux *demux) 1216 { 1217 struct dvb_demux *dvbdemux = (struct dvb_demux *)demux; 1218 1219 mutex_lock(&dvbdemux->mutex); 1220 1221 demux->frontend = NULL; 1222 mutex_unlock(&dvbdemux->mutex); 1223 return 0; 1224 } 1225 1226 static int dvbdmx_get_pes_pids(struct dmx_demux *demux, u16 * pids) 1227 { 1228 struct dvb_demux *dvbdemux = (struct dvb_demux *)demux; 1229 1230 memcpy(pids, dvbdemux->pids, 5 * sizeof(u16)); 1231 return 0; 1232 } 1233 1234 int dvb_dmx_init(struct dvb_demux *dvbdemux) 1235 { 1236 int i; 1237 struct dmx_demux *dmx = &dvbdemux->dmx; 1238 1239 dvbdemux->cnt_storage = NULL; 1240 dvbdemux->users = 0; 1241 dvbdemux->filter = vmalloc(array_size(sizeof(struct dvb_demux_filter), 1242 dvbdemux->filternum)); 1243 1244 if (!dvbdemux->filter) 1245 return -ENOMEM; 1246 1247 dvbdemux->feed = vmalloc(array_size(sizeof(struct dvb_demux_feed), 1248 dvbdemux->feednum)); 1249 if (!dvbdemux->feed) { 1250 vfree(dvbdemux->filter); 1251 dvbdemux->filter = NULL; 1252 return -ENOMEM; 1253 } 1254 for (i = 0; i < dvbdemux->filternum; i++) { 1255 dvbdemux->filter[i].state = DMX_STATE_FREE; 1256 dvbdemux->filter[i].index = i; 1257 } 1258 for (i = 0; i < dvbdemux->feednum; i++) { 1259 dvbdemux->feed[i].state = DMX_STATE_FREE; 1260 dvbdemux->feed[i].index = i; 1261 } 1262 1263 dvbdemux->cnt_storage = vmalloc(MAX_PID + 1); 1264 if (!dvbdemux->cnt_storage) 1265 pr_warn("Couldn't allocate memory for TS/TEI check. Disabling it\n"); 1266 1267 INIT_LIST_HEAD(&dvbdemux->frontend_list); 1268 1269 for (i = 0; i < DMX_PES_OTHER; i++) { 1270 dvbdemux->pesfilter[i] = NULL; 1271 dvbdemux->pids[i] = 0xffff; 1272 } 1273 1274 INIT_LIST_HEAD(&dvbdemux->feed_list); 1275 1276 dvbdemux->playing = 0; 1277 dvbdemux->recording = 0; 1278 dvbdemux->tsbufp = 0; 1279 1280 if (!dvbdemux->check_crc32) 1281 dvbdemux->check_crc32 = dvb_dmx_crc32; 1282 1283 if (!dvbdemux->memcopy) 1284 dvbdemux->memcopy = dvb_dmx_memcopy; 1285 1286 dmx->frontend = NULL; 1287 dmx->priv = dvbdemux; 1288 dmx->open = dvbdmx_open; 1289 dmx->close = dvbdmx_close; 1290 dmx->write = dvbdmx_write; 1291 dmx->allocate_ts_feed = dvbdmx_allocate_ts_feed; 1292 dmx->release_ts_feed = dvbdmx_release_ts_feed; 1293 dmx->allocate_section_feed = dvbdmx_allocate_section_feed; 1294 dmx->release_section_feed = dvbdmx_release_section_feed; 1295 1296 dmx->add_frontend = dvbdmx_add_frontend; 1297 dmx->remove_frontend = dvbdmx_remove_frontend; 1298 dmx->get_frontends = dvbdmx_get_frontends; 1299 dmx->connect_frontend = dvbdmx_connect_frontend; 1300 dmx->disconnect_frontend = dvbdmx_disconnect_frontend; 1301 dmx->get_pes_pids = dvbdmx_get_pes_pids; 1302 1303 mutex_init(&dvbdemux->mutex); 1304 spin_lock_init(&dvbdemux->lock); 1305 1306 return 0; 1307 } 1308 1309 EXPORT_SYMBOL(dvb_dmx_init); 1310 1311 void dvb_dmx_release(struct dvb_demux *dvbdemux) 1312 { 1313 vfree(dvbdemux->cnt_storage); 1314 vfree(dvbdemux->filter); 1315 vfree(dvbdemux->feed); 1316 } 1317 1318 EXPORT_SYMBOL(dvb_dmx_release); 1319