1 /* 2 * dmxdev.c - DVB demultiplexer device 3 * 4 * Copyright (C) 2000 Ralph Metzler & Marcus Metzler 5 * for convergence integrated media GmbH 6 * 7 * This program is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU Lesser General Public License 9 * as published by the Free Software Foundation; either version 2.1 10 * of the License, or (at your option) any later version. 11 * 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 * 17 */ 18 19 #define pr_fmt(fmt) "dmxdev: " fmt 20 21 #include <linux/sched.h> 22 #include <linux/spinlock.h> 23 #include <linux/slab.h> 24 #include <linux/vmalloc.h> 25 #include <linux/module.h> 26 #include <linux/poll.h> 27 #include <linux/ioctl.h> 28 #include <linux/wait.h> 29 #include <linux/uaccess.h> 30 #include "dmxdev.h" 31 32 static int debug; 33 34 module_param(debug, int, 0644); 35 MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off)."); 36 37 #define dprintk(fmt, arg...) do { \ 38 if (debug) \ 39 printk(KERN_DEBUG pr_fmt("%s: " fmt), \ 40 __func__, ##arg); \ 41 } while (0) 42 43 static int dvb_dmxdev_buffer_write(struct dvb_ringbuffer *buf, 44 const u8 *src, size_t len) 45 { 46 ssize_t free; 47 48 if (!len) 49 return 0; 50 if (!buf->data) 51 return 0; 52 53 free = dvb_ringbuffer_free(buf); 54 if (len > free) { 55 dprintk("buffer overflow\n"); 56 return -EOVERFLOW; 57 } 58 59 return dvb_ringbuffer_write(buf, src, len); 60 } 61 62 static ssize_t dvb_dmxdev_buffer_read(struct dvb_ringbuffer *src, 63 int non_blocking, char __user *buf, 64 size_t count, loff_t *ppos) 65 { 66 size_t todo; 67 ssize_t avail; 68 ssize_t ret = 0; 69 70 if (!src->data) 71 return 0; 72 73 if (src->error) { 74 ret = src->error; 75 dvb_ringbuffer_flush(src); 76 return ret; 77 } 78 79 for (todo = count; todo > 0; todo -= ret) { 80 if (non_blocking && dvb_ringbuffer_empty(src)) { 81 ret = -EWOULDBLOCK; 82 break; 83 } 84 85 ret = wait_event_interruptible(src->queue, 86 !dvb_ringbuffer_empty(src) || 87 (src->error != 0)); 88 if (ret < 0) 89 break; 90 91 if (src->error) { 92 ret = src->error; 93 dvb_ringbuffer_flush(src); 94 break; 95 } 96 97 avail = dvb_ringbuffer_avail(src); 98 if (avail > todo) 99 avail = todo; 100 101 ret = dvb_ringbuffer_read_user(src, buf, avail); 102 if (ret < 0) 103 break; 104 105 buf += ret; 106 } 107 108 return (count - todo) ? (count - todo) : ret; 109 } 110 111 static struct dmx_frontend *get_fe(struct dmx_demux *demux, int type) 112 { 113 struct list_head *head, *pos; 114 115 head = demux->get_frontends(demux); 116 if (!head) 117 return NULL; 118 list_for_each(pos, head) 119 if (DMX_FE_ENTRY(pos)->source == type) 120 return DMX_FE_ENTRY(pos); 121 122 return NULL; 123 } 124 125 static int dvb_dvr_open(struct inode *inode, struct file *file) 126 { 127 struct dvb_device *dvbdev = file->private_data; 128 struct dmxdev *dmxdev = dvbdev->priv; 129 struct dmx_frontend *front; 130 131 dprintk("%s\n", __func__); 132 133 if (mutex_lock_interruptible(&dmxdev->mutex)) 134 return -ERESTARTSYS; 135 136 if (dmxdev->exit) { 137 mutex_unlock(&dmxdev->mutex); 138 return -ENODEV; 139 } 140 141 if ((file->f_flags & O_ACCMODE) == O_RDWR) { 142 if (!(dmxdev->capabilities & DMXDEV_CAP_DUPLEX)) { 143 mutex_unlock(&dmxdev->mutex); 144 return -EOPNOTSUPP; 145 } 146 } 147 148 if ((file->f_flags & O_ACCMODE) == O_RDONLY) { 149 void *mem; 150 151 if (!dvbdev->readers) { 152 mutex_unlock(&dmxdev->mutex); 153 return -EBUSY; 154 } 155 mem = vmalloc(DVR_BUFFER_SIZE); 156 if (!mem) { 157 mutex_unlock(&dmxdev->mutex); 158 return -ENOMEM; 159 } 160 dvb_ringbuffer_init(&dmxdev->dvr_buffer, mem, DVR_BUFFER_SIZE); 161 dvbdev->readers--; 162 } 163 164 if ((file->f_flags & O_ACCMODE) == O_WRONLY) { 165 dmxdev->dvr_orig_fe = dmxdev->demux->frontend; 166 167 if (!dmxdev->demux->write) { 168 mutex_unlock(&dmxdev->mutex); 169 return -EOPNOTSUPP; 170 } 171 172 front = get_fe(dmxdev->demux, DMX_MEMORY_FE); 173 174 if (!front) { 175 mutex_unlock(&dmxdev->mutex); 176 return -EINVAL; 177 } 178 dmxdev->demux->disconnect_frontend(dmxdev->demux); 179 dmxdev->demux->connect_frontend(dmxdev->demux, front); 180 } 181 dvbdev->users++; 182 mutex_unlock(&dmxdev->mutex); 183 return 0; 184 } 185 186 static int dvb_dvr_release(struct inode *inode, struct file *file) 187 { 188 struct dvb_device *dvbdev = file->private_data; 189 struct dmxdev *dmxdev = dvbdev->priv; 190 191 mutex_lock(&dmxdev->mutex); 192 193 if ((file->f_flags & O_ACCMODE) == O_WRONLY) { 194 dmxdev->demux->disconnect_frontend(dmxdev->demux); 195 dmxdev->demux->connect_frontend(dmxdev->demux, 196 dmxdev->dvr_orig_fe); 197 } 198 if ((file->f_flags & O_ACCMODE) == O_RDONLY) { 199 dvbdev->readers++; 200 if (dmxdev->dvr_buffer.data) { 201 void *mem = dmxdev->dvr_buffer.data; 202 /*memory barrier*/ 203 mb(); 204 spin_lock_irq(&dmxdev->lock); 205 dmxdev->dvr_buffer.data = NULL; 206 spin_unlock_irq(&dmxdev->lock); 207 vfree(mem); 208 } 209 } 210 /* TODO */ 211 dvbdev->users--; 212 if (dvbdev->users == 1 && dmxdev->exit == 1) { 213 mutex_unlock(&dmxdev->mutex); 214 wake_up(&dvbdev->wait_queue); 215 } else 216 mutex_unlock(&dmxdev->mutex); 217 218 return 0; 219 } 220 221 static ssize_t dvb_dvr_write(struct file *file, const char __user *buf, 222 size_t count, loff_t *ppos) 223 { 224 struct dvb_device *dvbdev = file->private_data; 225 struct dmxdev *dmxdev = dvbdev->priv; 226 int ret; 227 228 if (!dmxdev->demux->write) 229 return -EOPNOTSUPP; 230 if ((file->f_flags & O_ACCMODE) != O_WRONLY) 231 return -EINVAL; 232 if (mutex_lock_interruptible(&dmxdev->mutex)) 233 return -ERESTARTSYS; 234 235 if (dmxdev->exit) { 236 mutex_unlock(&dmxdev->mutex); 237 return -ENODEV; 238 } 239 ret = dmxdev->demux->write(dmxdev->demux, buf, count); 240 mutex_unlock(&dmxdev->mutex); 241 return ret; 242 } 243 244 static ssize_t dvb_dvr_read(struct file *file, char __user *buf, size_t count, 245 loff_t *ppos) 246 { 247 struct dvb_device *dvbdev = file->private_data; 248 struct dmxdev *dmxdev = dvbdev->priv; 249 250 if (dmxdev->exit) 251 return -ENODEV; 252 253 return dvb_dmxdev_buffer_read(&dmxdev->dvr_buffer, 254 file->f_flags & O_NONBLOCK, 255 buf, count, ppos); 256 } 257 258 static int dvb_dvr_set_buffer_size(struct dmxdev *dmxdev, 259 unsigned long size) 260 { 261 struct dvb_ringbuffer *buf = &dmxdev->dvr_buffer; 262 void *newmem; 263 void *oldmem; 264 265 dprintk("%s\n", __func__); 266 267 if (buf->size == size) 268 return 0; 269 if (!size) 270 return -EINVAL; 271 272 newmem = vmalloc(size); 273 if (!newmem) 274 return -ENOMEM; 275 276 oldmem = buf->data; 277 278 spin_lock_irq(&dmxdev->lock); 279 buf->data = newmem; 280 buf->size = size; 281 282 /* reset and not flush in case the buffer shrinks */ 283 dvb_ringbuffer_reset(buf); 284 spin_unlock_irq(&dmxdev->lock); 285 286 vfree(oldmem); 287 288 return 0; 289 } 290 291 static inline void dvb_dmxdev_filter_state_set(struct dmxdev_filter 292 *dmxdevfilter, int state) 293 { 294 spin_lock_irq(&dmxdevfilter->dev->lock); 295 dmxdevfilter->state = state; 296 spin_unlock_irq(&dmxdevfilter->dev->lock); 297 } 298 299 static int dvb_dmxdev_set_buffer_size(struct dmxdev_filter *dmxdevfilter, 300 unsigned long size) 301 { 302 struct dvb_ringbuffer *buf = &dmxdevfilter->buffer; 303 void *newmem; 304 void *oldmem; 305 306 if (buf->size == size) 307 return 0; 308 if (!size) 309 return -EINVAL; 310 if (dmxdevfilter->state >= DMXDEV_STATE_GO) 311 return -EBUSY; 312 313 newmem = vmalloc(size); 314 if (!newmem) 315 return -ENOMEM; 316 317 oldmem = buf->data; 318 319 spin_lock_irq(&dmxdevfilter->dev->lock); 320 buf->data = newmem; 321 buf->size = size; 322 323 /* reset and not flush in case the buffer shrinks */ 324 dvb_ringbuffer_reset(buf); 325 spin_unlock_irq(&dmxdevfilter->dev->lock); 326 327 vfree(oldmem); 328 329 return 0; 330 } 331 332 static void dvb_dmxdev_filter_timeout(struct timer_list *t) 333 { 334 struct dmxdev_filter *dmxdevfilter = from_timer(dmxdevfilter, t, timer); 335 336 dmxdevfilter->buffer.error = -ETIMEDOUT; 337 spin_lock_irq(&dmxdevfilter->dev->lock); 338 dmxdevfilter->state = DMXDEV_STATE_TIMEDOUT; 339 spin_unlock_irq(&dmxdevfilter->dev->lock); 340 wake_up(&dmxdevfilter->buffer.queue); 341 } 342 343 static void dvb_dmxdev_filter_timer(struct dmxdev_filter *dmxdevfilter) 344 { 345 struct dmx_sct_filter_params *para = &dmxdevfilter->params.sec; 346 347 del_timer(&dmxdevfilter->timer); 348 if (para->timeout) { 349 dmxdevfilter->timer.expires = 350 jiffies + 1 + (HZ / 2 + HZ * para->timeout) / 1000; 351 add_timer(&dmxdevfilter->timer); 352 } 353 } 354 355 static int dvb_dmxdev_section_callback(const u8 *buffer1, size_t buffer1_len, 356 const u8 *buffer2, size_t buffer2_len, 357 struct dmx_section_filter *filter) 358 { 359 struct dmxdev_filter *dmxdevfilter = filter->priv; 360 int ret; 361 362 if (dmxdevfilter->buffer.error) { 363 wake_up(&dmxdevfilter->buffer.queue); 364 return 0; 365 } 366 spin_lock(&dmxdevfilter->dev->lock); 367 if (dmxdevfilter->state != DMXDEV_STATE_GO) { 368 spin_unlock(&dmxdevfilter->dev->lock); 369 return 0; 370 } 371 del_timer(&dmxdevfilter->timer); 372 dprintk("section callback %*ph\n", 6, buffer1); 373 ret = dvb_dmxdev_buffer_write(&dmxdevfilter->buffer, buffer1, 374 buffer1_len); 375 if (ret == buffer1_len) { 376 ret = dvb_dmxdev_buffer_write(&dmxdevfilter->buffer, buffer2, 377 buffer2_len); 378 } 379 if (ret < 0) 380 dmxdevfilter->buffer.error = ret; 381 if (dmxdevfilter->params.sec.flags & DMX_ONESHOT) 382 dmxdevfilter->state = DMXDEV_STATE_DONE; 383 spin_unlock(&dmxdevfilter->dev->lock); 384 wake_up(&dmxdevfilter->buffer.queue); 385 return 0; 386 } 387 388 static int dvb_dmxdev_ts_callback(const u8 *buffer1, size_t buffer1_len, 389 const u8 *buffer2, size_t buffer2_len, 390 struct dmx_ts_feed *feed) 391 { 392 struct dmxdev_filter *dmxdevfilter = feed->priv; 393 struct dvb_ringbuffer *buffer; 394 int ret; 395 396 spin_lock(&dmxdevfilter->dev->lock); 397 if (dmxdevfilter->params.pes.output == DMX_OUT_DECODER) { 398 spin_unlock(&dmxdevfilter->dev->lock); 399 return 0; 400 } 401 402 if (dmxdevfilter->params.pes.output == DMX_OUT_TAP 403 || dmxdevfilter->params.pes.output == DMX_OUT_TSDEMUX_TAP) 404 buffer = &dmxdevfilter->buffer; 405 else 406 buffer = &dmxdevfilter->dev->dvr_buffer; 407 if (buffer->error) { 408 spin_unlock(&dmxdevfilter->dev->lock); 409 wake_up(&buffer->queue); 410 return 0; 411 } 412 ret = dvb_dmxdev_buffer_write(buffer, buffer1, buffer1_len); 413 if (ret == buffer1_len) 414 ret = dvb_dmxdev_buffer_write(buffer, buffer2, buffer2_len); 415 if (ret < 0) 416 buffer->error = ret; 417 spin_unlock(&dmxdevfilter->dev->lock); 418 wake_up(&buffer->queue); 419 return 0; 420 } 421 422 /* stop feed but only mark the specified filter as stopped (state set) */ 423 static int dvb_dmxdev_feed_stop(struct dmxdev_filter *dmxdevfilter) 424 { 425 struct dmxdev_feed *feed; 426 427 dvb_dmxdev_filter_state_set(dmxdevfilter, DMXDEV_STATE_SET); 428 429 switch (dmxdevfilter->type) { 430 case DMXDEV_TYPE_SEC: 431 del_timer(&dmxdevfilter->timer); 432 dmxdevfilter->feed.sec->stop_filtering(dmxdevfilter->feed.sec); 433 break; 434 case DMXDEV_TYPE_PES: 435 list_for_each_entry(feed, &dmxdevfilter->feed.ts, next) 436 feed->ts->stop_filtering(feed->ts); 437 break; 438 default: 439 return -EINVAL; 440 } 441 return 0; 442 } 443 444 /* start feed associated with the specified filter */ 445 static int dvb_dmxdev_feed_start(struct dmxdev_filter *filter) 446 { 447 struct dmxdev_feed *feed; 448 int ret; 449 450 dvb_dmxdev_filter_state_set(filter, DMXDEV_STATE_GO); 451 452 switch (filter->type) { 453 case DMXDEV_TYPE_SEC: 454 return filter->feed.sec->start_filtering(filter->feed.sec); 455 case DMXDEV_TYPE_PES: 456 list_for_each_entry(feed, &filter->feed.ts, next) { 457 ret = feed->ts->start_filtering(feed->ts); 458 if (ret < 0) { 459 dvb_dmxdev_feed_stop(filter); 460 return ret; 461 } 462 } 463 break; 464 default: 465 return -EINVAL; 466 } 467 468 return 0; 469 } 470 471 /* restart section feed if it has filters left associated with it, 472 otherwise release the feed */ 473 static int dvb_dmxdev_feed_restart(struct dmxdev_filter *filter) 474 { 475 int i; 476 struct dmxdev *dmxdev = filter->dev; 477 u16 pid = filter->params.sec.pid; 478 479 for (i = 0; i < dmxdev->filternum; i++) 480 if (dmxdev->filter[i].state >= DMXDEV_STATE_GO && 481 dmxdev->filter[i].type == DMXDEV_TYPE_SEC && 482 dmxdev->filter[i].params.sec.pid == pid) { 483 dvb_dmxdev_feed_start(&dmxdev->filter[i]); 484 return 0; 485 } 486 487 filter->dev->demux->release_section_feed(dmxdev->demux, 488 filter->feed.sec); 489 490 return 0; 491 } 492 493 static int dvb_dmxdev_filter_stop(struct dmxdev_filter *dmxdevfilter) 494 { 495 struct dmxdev_feed *feed; 496 struct dmx_demux *demux; 497 498 if (dmxdevfilter->state < DMXDEV_STATE_GO) 499 return 0; 500 501 switch (dmxdevfilter->type) { 502 case DMXDEV_TYPE_SEC: 503 if (!dmxdevfilter->feed.sec) 504 break; 505 dvb_dmxdev_feed_stop(dmxdevfilter); 506 if (dmxdevfilter->filter.sec) 507 dmxdevfilter->feed.sec-> 508 release_filter(dmxdevfilter->feed.sec, 509 dmxdevfilter->filter.sec); 510 dvb_dmxdev_feed_restart(dmxdevfilter); 511 dmxdevfilter->feed.sec = NULL; 512 break; 513 case DMXDEV_TYPE_PES: 514 dvb_dmxdev_feed_stop(dmxdevfilter); 515 demux = dmxdevfilter->dev->demux; 516 list_for_each_entry(feed, &dmxdevfilter->feed.ts, next) { 517 demux->release_ts_feed(demux, feed->ts); 518 feed->ts = NULL; 519 } 520 break; 521 default: 522 if (dmxdevfilter->state == DMXDEV_STATE_ALLOCATED) 523 return 0; 524 return -EINVAL; 525 } 526 527 dvb_ringbuffer_flush(&dmxdevfilter->buffer); 528 return 0; 529 } 530 531 static void dvb_dmxdev_delete_pids(struct dmxdev_filter *dmxdevfilter) 532 { 533 struct dmxdev_feed *feed, *tmp; 534 535 /* delete all PIDs */ 536 list_for_each_entry_safe(feed, tmp, &dmxdevfilter->feed.ts, next) { 537 list_del(&feed->next); 538 kfree(feed); 539 } 540 541 BUG_ON(!list_empty(&dmxdevfilter->feed.ts)); 542 } 543 544 static inline int dvb_dmxdev_filter_reset(struct dmxdev_filter *dmxdevfilter) 545 { 546 if (dmxdevfilter->state < DMXDEV_STATE_SET) 547 return 0; 548 549 if (dmxdevfilter->type == DMXDEV_TYPE_PES) 550 dvb_dmxdev_delete_pids(dmxdevfilter); 551 552 dmxdevfilter->type = DMXDEV_TYPE_NONE; 553 dvb_dmxdev_filter_state_set(dmxdevfilter, DMXDEV_STATE_ALLOCATED); 554 return 0; 555 } 556 557 static int dvb_dmxdev_start_feed(struct dmxdev *dmxdev, 558 struct dmxdev_filter *filter, 559 struct dmxdev_feed *feed) 560 { 561 ktime_t timeout = 0; 562 struct dmx_pes_filter_params *para = &filter->params.pes; 563 enum dmx_output otype; 564 int ret; 565 int ts_type; 566 enum dmx_ts_pes ts_pes; 567 struct dmx_ts_feed *tsfeed; 568 569 feed->ts = NULL; 570 otype = para->output; 571 572 ts_pes = para->pes_type; 573 574 if (ts_pes < DMX_PES_OTHER) 575 ts_type = TS_DECODER; 576 else 577 ts_type = 0; 578 579 if (otype == DMX_OUT_TS_TAP) 580 ts_type |= TS_PACKET; 581 else if (otype == DMX_OUT_TSDEMUX_TAP) 582 ts_type |= TS_PACKET | TS_DEMUX; 583 else if (otype == DMX_OUT_TAP) 584 ts_type |= TS_PACKET | TS_DEMUX | TS_PAYLOAD_ONLY; 585 586 ret = dmxdev->demux->allocate_ts_feed(dmxdev->demux, &feed->ts, 587 dvb_dmxdev_ts_callback); 588 if (ret < 0) 589 return ret; 590 591 tsfeed = feed->ts; 592 tsfeed->priv = filter; 593 594 ret = tsfeed->set(tsfeed, feed->pid, ts_type, ts_pes, timeout); 595 if (ret < 0) { 596 dmxdev->demux->release_ts_feed(dmxdev->demux, tsfeed); 597 return ret; 598 } 599 600 ret = tsfeed->start_filtering(tsfeed); 601 if (ret < 0) { 602 dmxdev->demux->release_ts_feed(dmxdev->demux, tsfeed); 603 return ret; 604 } 605 606 return 0; 607 } 608 609 static int dvb_dmxdev_filter_start(struct dmxdev_filter *filter) 610 { 611 struct dmxdev *dmxdev = filter->dev; 612 struct dmxdev_feed *feed; 613 void *mem; 614 int ret, i; 615 616 if (filter->state < DMXDEV_STATE_SET) 617 return -EINVAL; 618 619 if (filter->state >= DMXDEV_STATE_GO) 620 dvb_dmxdev_filter_stop(filter); 621 622 if (!filter->buffer.data) { 623 mem = vmalloc(filter->buffer.size); 624 if (!mem) 625 return -ENOMEM; 626 spin_lock_irq(&filter->dev->lock); 627 filter->buffer.data = mem; 628 spin_unlock_irq(&filter->dev->lock); 629 } 630 631 dvb_ringbuffer_flush(&filter->buffer); 632 633 switch (filter->type) { 634 case DMXDEV_TYPE_SEC: 635 { 636 struct dmx_sct_filter_params *para = &filter->params.sec; 637 struct dmx_section_filter **secfilter = &filter->filter.sec; 638 struct dmx_section_feed **secfeed = &filter->feed.sec; 639 640 *secfilter = NULL; 641 *secfeed = NULL; 642 643 644 /* find active filter/feed with same PID */ 645 for (i = 0; i < dmxdev->filternum; i++) { 646 if (dmxdev->filter[i].state >= DMXDEV_STATE_GO && 647 dmxdev->filter[i].type == DMXDEV_TYPE_SEC && 648 dmxdev->filter[i].params.sec.pid == para->pid) { 649 *secfeed = dmxdev->filter[i].feed.sec; 650 break; 651 } 652 } 653 654 /* if no feed found, try to allocate new one */ 655 if (!*secfeed) { 656 ret = dmxdev->demux->allocate_section_feed(dmxdev->demux, 657 secfeed, 658 dvb_dmxdev_section_callback); 659 if (ret < 0) { 660 pr_err("DVB (%s): could not alloc feed\n", 661 __func__); 662 return ret; 663 } 664 665 ret = (*secfeed)->set(*secfeed, para->pid, 666 (para->flags & DMX_CHECK_CRC) ? 1 : 0); 667 if (ret < 0) { 668 pr_err("DVB (%s): could not set feed\n", 669 __func__); 670 dvb_dmxdev_feed_restart(filter); 671 return ret; 672 } 673 } else { 674 dvb_dmxdev_feed_stop(filter); 675 } 676 677 ret = (*secfeed)->allocate_filter(*secfeed, secfilter); 678 if (ret < 0) { 679 dvb_dmxdev_feed_restart(filter); 680 filter->feed.sec->start_filtering(*secfeed); 681 dprintk("could not get filter\n"); 682 return ret; 683 } 684 685 (*secfilter)->priv = filter; 686 687 memcpy(&((*secfilter)->filter_value[3]), 688 &(para->filter.filter[1]), DMX_FILTER_SIZE - 1); 689 memcpy(&(*secfilter)->filter_mask[3], 690 ¶->filter.mask[1], DMX_FILTER_SIZE - 1); 691 memcpy(&(*secfilter)->filter_mode[3], 692 ¶->filter.mode[1], DMX_FILTER_SIZE - 1); 693 694 (*secfilter)->filter_value[0] = para->filter.filter[0]; 695 (*secfilter)->filter_mask[0] = para->filter.mask[0]; 696 (*secfilter)->filter_mode[0] = para->filter.mode[0]; 697 (*secfilter)->filter_mask[1] = 0; 698 (*secfilter)->filter_mask[2] = 0; 699 700 filter->todo = 0; 701 702 ret = filter->feed.sec->start_filtering(filter->feed.sec); 703 if (ret < 0) 704 return ret; 705 706 dvb_dmxdev_filter_timer(filter); 707 break; 708 } 709 case DMXDEV_TYPE_PES: 710 list_for_each_entry(feed, &filter->feed.ts, next) { 711 ret = dvb_dmxdev_start_feed(dmxdev, filter, feed); 712 if (ret < 0) { 713 dvb_dmxdev_filter_stop(filter); 714 return ret; 715 } 716 } 717 break; 718 default: 719 return -EINVAL; 720 } 721 722 dvb_dmxdev_filter_state_set(filter, DMXDEV_STATE_GO); 723 return 0; 724 } 725 726 static int dvb_demux_open(struct inode *inode, struct file *file) 727 { 728 struct dvb_device *dvbdev = file->private_data; 729 struct dmxdev *dmxdev = dvbdev->priv; 730 int i; 731 struct dmxdev_filter *dmxdevfilter; 732 733 if (!dmxdev->filter) 734 return -EINVAL; 735 736 if (mutex_lock_interruptible(&dmxdev->mutex)) 737 return -ERESTARTSYS; 738 739 for (i = 0; i < dmxdev->filternum; i++) 740 if (dmxdev->filter[i].state == DMXDEV_STATE_FREE) 741 break; 742 743 if (i == dmxdev->filternum) { 744 mutex_unlock(&dmxdev->mutex); 745 return -EMFILE; 746 } 747 748 dmxdevfilter = &dmxdev->filter[i]; 749 mutex_init(&dmxdevfilter->mutex); 750 file->private_data = dmxdevfilter; 751 752 dvb_ringbuffer_init(&dmxdevfilter->buffer, NULL, 8192); 753 dmxdevfilter->type = DMXDEV_TYPE_NONE; 754 dvb_dmxdev_filter_state_set(dmxdevfilter, DMXDEV_STATE_ALLOCATED); 755 timer_setup(&dmxdevfilter->timer, dvb_dmxdev_filter_timeout, 0); 756 757 dvbdev->users++; 758 759 mutex_unlock(&dmxdev->mutex); 760 return 0; 761 } 762 763 static int dvb_dmxdev_filter_free(struct dmxdev *dmxdev, 764 struct dmxdev_filter *dmxdevfilter) 765 { 766 mutex_lock(&dmxdev->mutex); 767 mutex_lock(&dmxdevfilter->mutex); 768 769 dvb_dmxdev_filter_stop(dmxdevfilter); 770 dvb_dmxdev_filter_reset(dmxdevfilter); 771 772 if (dmxdevfilter->buffer.data) { 773 void *mem = dmxdevfilter->buffer.data; 774 775 spin_lock_irq(&dmxdev->lock); 776 dmxdevfilter->buffer.data = NULL; 777 spin_unlock_irq(&dmxdev->lock); 778 vfree(mem); 779 } 780 781 dvb_dmxdev_filter_state_set(dmxdevfilter, DMXDEV_STATE_FREE); 782 wake_up(&dmxdevfilter->buffer.queue); 783 mutex_unlock(&dmxdevfilter->mutex); 784 mutex_unlock(&dmxdev->mutex); 785 return 0; 786 } 787 788 static inline void invert_mode(struct dmx_filter *filter) 789 { 790 int i; 791 792 for (i = 0; i < DMX_FILTER_SIZE; i++) 793 filter->mode[i] ^= 0xff; 794 } 795 796 static int dvb_dmxdev_add_pid(struct dmxdev *dmxdev, 797 struct dmxdev_filter *filter, u16 pid) 798 { 799 struct dmxdev_feed *feed; 800 801 if ((filter->type != DMXDEV_TYPE_PES) || 802 (filter->state < DMXDEV_STATE_SET)) 803 return -EINVAL; 804 805 /* only TS packet filters may have multiple PIDs */ 806 if ((filter->params.pes.output != DMX_OUT_TSDEMUX_TAP) && 807 (!list_empty(&filter->feed.ts))) 808 return -EINVAL; 809 810 feed = kzalloc(sizeof(struct dmxdev_feed), GFP_KERNEL); 811 if (feed == NULL) 812 return -ENOMEM; 813 814 feed->pid = pid; 815 list_add(&feed->next, &filter->feed.ts); 816 817 if (filter->state >= DMXDEV_STATE_GO) 818 return dvb_dmxdev_start_feed(dmxdev, filter, feed); 819 820 return 0; 821 } 822 823 static int dvb_dmxdev_remove_pid(struct dmxdev *dmxdev, 824 struct dmxdev_filter *filter, u16 pid) 825 { 826 struct dmxdev_feed *feed, *tmp; 827 828 if ((filter->type != DMXDEV_TYPE_PES) || 829 (filter->state < DMXDEV_STATE_SET)) 830 return -EINVAL; 831 832 list_for_each_entry_safe(feed, tmp, &filter->feed.ts, next) { 833 if ((feed->pid == pid) && (feed->ts != NULL)) { 834 feed->ts->stop_filtering(feed->ts); 835 filter->dev->demux->release_ts_feed(filter->dev->demux, 836 feed->ts); 837 list_del(&feed->next); 838 kfree(feed); 839 } 840 } 841 842 return 0; 843 } 844 845 static int dvb_dmxdev_filter_set(struct dmxdev *dmxdev, 846 struct dmxdev_filter *dmxdevfilter, 847 struct dmx_sct_filter_params *params) 848 { 849 dprintk("%s: PID=0x%04x, flags=%02x, timeout=%d\n", 850 __func__, params->pid, params->flags, params->timeout); 851 852 dvb_dmxdev_filter_stop(dmxdevfilter); 853 854 dmxdevfilter->type = DMXDEV_TYPE_SEC; 855 memcpy(&dmxdevfilter->params.sec, 856 params, sizeof(struct dmx_sct_filter_params)); 857 invert_mode(&dmxdevfilter->params.sec.filter); 858 dvb_dmxdev_filter_state_set(dmxdevfilter, DMXDEV_STATE_SET); 859 860 if (params->flags & DMX_IMMEDIATE_START) 861 return dvb_dmxdev_filter_start(dmxdevfilter); 862 863 return 0; 864 } 865 866 static int dvb_dmxdev_pes_filter_set(struct dmxdev *dmxdev, 867 struct dmxdev_filter *dmxdevfilter, 868 struct dmx_pes_filter_params *params) 869 { 870 int ret; 871 872 dvb_dmxdev_filter_stop(dmxdevfilter); 873 dvb_dmxdev_filter_reset(dmxdevfilter); 874 875 if ((unsigned int)params->pes_type > DMX_PES_OTHER) 876 return -EINVAL; 877 878 dmxdevfilter->type = DMXDEV_TYPE_PES; 879 memcpy(&dmxdevfilter->params, params, 880 sizeof(struct dmx_pes_filter_params)); 881 INIT_LIST_HEAD(&dmxdevfilter->feed.ts); 882 883 dvb_dmxdev_filter_state_set(dmxdevfilter, DMXDEV_STATE_SET); 884 885 ret = dvb_dmxdev_add_pid(dmxdev, dmxdevfilter, 886 dmxdevfilter->params.pes.pid); 887 if (ret < 0) 888 return ret; 889 890 if (params->flags & DMX_IMMEDIATE_START) 891 return dvb_dmxdev_filter_start(dmxdevfilter); 892 893 return 0; 894 } 895 896 static ssize_t dvb_dmxdev_read_sec(struct dmxdev_filter *dfil, 897 struct file *file, char __user *buf, 898 size_t count, loff_t *ppos) 899 { 900 int result, hcount; 901 int done = 0; 902 903 if (dfil->todo <= 0) { 904 hcount = 3 + dfil->todo; 905 if (hcount > count) 906 hcount = count; 907 result = dvb_dmxdev_buffer_read(&dfil->buffer, 908 file->f_flags & O_NONBLOCK, 909 buf, hcount, ppos); 910 if (result < 0) { 911 dfil->todo = 0; 912 return result; 913 } 914 if (copy_from_user(dfil->secheader - dfil->todo, buf, result)) 915 return -EFAULT; 916 buf += result; 917 done = result; 918 count -= result; 919 dfil->todo -= result; 920 if (dfil->todo > -3) 921 return done; 922 dfil->todo = ((dfil->secheader[1] << 8) | dfil->secheader[2]) & 0xfff; 923 if (!count) 924 return done; 925 } 926 if (count > dfil->todo) 927 count = dfil->todo; 928 result = dvb_dmxdev_buffer_read(&dfil->buffer, 929 file->f_flags & O_NONBLOCK, 930 buf, count, ppos); 931 if (result < 0) 932 return result; 933 dfil->todo -= result; 934 return (result + done); 935 } 936 937 static ssize_t 938 dvb_demux_read(struct file *file, char __user *buf, size_t count, 939 loff_t *ppos) 940 { 941 struct dmxdev_filter *dmxdevfilter = file->private_data; 942 int ret; 943 944 if (mutex_lock_interruptible(&dmxdevfilter->mutex)) 945 return -ERESTARTSYS; 946 947 if (dmxdevfilter->type == DMXDEV_TYPE_SEC) 948 ret = dvb_dmxdev_read_sec(dmxdevfilter, file, buf, count, ppos); 949 else 950 ret = dvb_dmxdev_buffer_read(&dmxdevfilter->buffer, 951 file->f_flags & O_NONBLOCK, 952 buf, count, ppos); 953 954 mutex_unlock(&dmxdevfilter->mutex); 955 return ret; 956 } 957 958 static int dvb_demux_do_ioctl(struct file *file, 959 unsigned int cmd, void *parg) 960 { 961 struct dmxdev_filter *dmxdevfilter = file->private_data; 962 struct dmxdev *dmxdev = dmxdevfilter->dev; 963 unsigned long arg = (unsigned long)parg; 964 int ret = 0; 965 966 if (mutex_lock_interruptible(&dmxdev->mutex)) 967 return -ERESTARTSYS; 968 969 switch (cmd) { 970 case DMX_START: 971 if (mutex_lock_interruptible(&dmxdevfilter->mutex)) { 972 mutex_unlock(&dmxdev->mutex); 973 return -ERESTARTSYS; 974 } 975 if (dmxdevfilter->state < DMXDEV_STATE_SET) 976 ret = -EINVAL; 977 else 978 ret = dvb_dmxdev_filter_start(dmxdevfilter); 979 mutex_unlock(&dmxdevfilter->mutex); 980 break; 981 982 case DMX_STOP: 983 if (mutex_lock_interruptible(&dmxdevfilter->mutex)) { 984 mutex_unlock(&dmxdev->mutex); 985 return -ERESTARTSYS; 986 } 987 ret = dvb_dmxdev_filter_stop(dmxdevfilter); 988 mutex_unlock(&dmxdevfilter->mutex); 989 break; 990 991 case DMX_SET_FILTER: 992 if (mutex_lock_interruptible(&dmxdevfilter->mutex)) { 993 mutex_unlock(&dmxdev->mutex); 994 return -ERESTARTSYS; 995 } 996 ret = dvb_dmxdev_filter_set(dmxdev, dmxdevfilter, parg); 997 mutex_unlock(&dmxdevfilter->mutex); 998 break; 999 1000 case DMX_SET_PES_FILTER: 1001 if (mutex_lock_interruptible(&dmxdevfilter->mutex)) { 1002 mutex_unlock(&dmxdev->mutex); 1003 return -ERESTARTSYS; 1004 } 1005 ret = dvb_dmxdev_pes_filter_set(dmxdev, dmxdevfilter, parg); 1006 mutex_unlock(&dmxdevfilter->mutex); 1007 break; 1008 1009 case DMX_SET_BUFFER_SIZE: 1010 if (mutex_lock_interruptible(&dmxdevfilter->mutex)) { 1011 mutex_unlock(&dmxdev->mutex); 1012 return -ERESTARTSYS; 1013 } 1014 ret = dvb_dmxdev_set_buffer_size(dmxdevfilter, arg); 1015 mutex_unlock(&dmxdevfilter->mutex); 1016 break; 1017 1018 case DMX_GET_PES_PIDS: 1019 if (!dmxdev->demux->get_pes_pids) { 1020 ret = -EINVAL; 1021 break; 1022 } 1023 dmxdev->demux->get_pes_pids(dmxdev->demux, parg); 1024 break; 1025 1026 case DMX_GET_STC: 1027 if (!dmxdev->demux->get_stc) { 1028 ret = -EINVAL; 1029 break; 1030 } 1031 ret = dmxdev->demux->get_stc(dmxdev->demux, 1032 ((struct dmx_stc *)parg)->num, 1033 &((struct dmx_stc *)parg)->stc, 1034 &((struct dmx_stc *)parg)->base); 1035 break; 1036 1037 case DMX_ADD_PID: 1038 if (mutex_lock_interruptible(&dmxdevfilter->mutex)) { 1039 ret = -ERESTARTSYS; 1040 break; 1041 } 1042 ret = dvb_dmxdev_add_pid(dmxdev, dmxdevfilter, *(u16 *)parg); 1043 mutex_unlock(&dmxdevfilter->mutex); 1044 break; 1045 1046 case DMX_REMOVE_PID: 1047 if (mutex_lock_interruptible(&dmxdevfilter->mutex)) { 1048 ret = -ERESTARTSYS; 1049 break; 1050 } 1051 ret = dvb_dmxdev_remove_pid(dmxdev, dmxdevfilter, *(u16 *)parg); 1052 mutex_unlock(&dmxdevfilter->mutex); 1053 break; 1054 1055 default: 1056 ret = -EINVAL; 1057 break; 1058 } 1059 mutex_unlock(&dmxdev->mutex); 1060 return ret; 1061 } 1062 1063 static long dvb_demux_ioctl(struct file *file, unsigned int cmd, 1064 unsigned long arg) 1065 { 1066 return dvb_usercopy(file, cmd, arg, dvb_demux_do_ioctl); 1067 } 1068 1069 static unsigned int dvb_demux_poll(struct file *file, poll_table *wait) 1070 { 1071 struct dmxdev_filter *dmxdevfilter = file->private_data; 1072 unsigned int mask = 0; 1073 1074 if ((!dmxdevfilter) || dmxdevfilter->dev->exit) 1075 return POLLERR; 1076 1077 poll_wait(file, &dmxdevfilter->buffer.queue, wait); 1078 1079 if (dmxdevfilter->state != DMXDEV_STATE_GO && 1080 dmxdevfilter->state != DMXDEV_STATE_DONE && 1081 dmxdevfilter->state != DMXDEV_STATE_TIMEDOUT) 1082 return 0; 1083 1084 if (dmxdevfilter->buffer.error) 1085 mask |= (POLLIN | POLLRDNORM | POLLPRI | POLLERR); 1086 1087 if (!dvb_ringbuffer_empty(&dmxdevfilter->buffer)) 1088 mask |= (POLLIN | POLLRDNORM | POLLPRI); 1089 1090 return mask; 1091 } 1092 1093 static int dvb_demux_release(struct inode *inode, struct file *file) 1094 { 1095 struct dmxdev_filter *dmxdevfilter = file->private_data; 1096 struct dmxdev *dmxdev = dmxdevfilter->dev; 1097 1098 int ret; 1099 1100 ret = dvb_dmxdev_filter_free(dmxdev, dmxdevfilter); 1101 1102 mutex_lock(&dmxdev->mutex); 1103 dmxdev->dvbdev->users--; 1104 if (dmxdev->dvbdev->users == 1 && dmxdev->exit == 1) { 1105 mutex_unlock(&dmxdev->mutex); 1106 wake_up(&dmxdev->dvbdev->wait_queue); 1107 } else 1108 mutex_unlock(&dmxdev->mutex); 1109 1110 return ret; 1111 } 1112 1113 static const struct file_operations dvb_demux_fops = { 1114 .owner = THIS_MODULE, 1115 .read = dvb_demux_read, 1116 .unlocked_ioctl = dvb_demux_ioctl, 1117 .open = dvb_demux_open, 1118 .release = dvb_demux_release, 1119 .poll = dvb_demux_poll, 1120 .llseek = default_llseek, 1121 }; 1122 1123 static const struct dvb_device dvbdev_demux = { 1124 .priv = NULL, 1125 .users = 1, 1126 .writers = 1, 1127 #if defined(CONFIG_MEDIA_CONTROLLER_DVB) 1128 .name = "dvb-demux", 1129 #endif 1130 .fops = &dvb_demux_fops 1131 }; 1132 1133 static int dvb_dvr_do_ioctl(struct file *file, 1134 unsigned int cmd, void *parg) 1135 { 1136 struct dvb_device *dvbdev = file->private_data; 1137 struct dmxdev *dmxdev = dvbdev->priv; 1138 unsigned long arg = (unsigned long)parg; 1139 int ret; 1140 1141 if (mutex_lock_interruptible(&dmxdev->mutex)) 1142 return -ERESTARTSYS; 1143 1144 switch (cmd) { 1145 case DMX_SET_BUFFER_SIZE: 1146 ret = dvb_dvr_set_buffer_size(dmxdev, arg); 1147 break; 1148 1149 default: 1150 ret = -EINVAL; 1151 break; 1152 } 1153 mutex_unlock(&dmxdev->mutex); 1154 return ret; 1155 } 1156 1157 static long dvb_dvr_ioctl(struct file *file, 1158 unsigned int cmd, unsigned long arg) 1159 { 1160 return dvb_usercopy(file, cmd, arg, dvb_dvr_do_ioctl); 1161 } 1162 1163 static unsigned int dvb_dvr_poll(struct file *file, poll_table *wait) 1164 { 1165 struct dvb_device *dvbdev = file->private_data; 1166 struct dmxdev *dmxdev = dvbdev->priv; 1167 unsigned int mask = 0; 1168 1169 dprintk("%s\n", __func__); 1170 1171 if (dmxdev->exit) 1172 return POLLERR; 1173 1174 poll_wait(file, &dmxdev->dvr_buffer.queue, wait); 1175 1176 if ((file->f_flags & O_ACCMODE) == O_RDONLY) { 1177 if (dmxdev->dvr_buffer.error) 1178 mask |= (POLLIN | POLLRDNORM | POLLPRI | POLLERR); 1179 1180 if (!dvb_ringbuffer_empty(&dmxdev->dvr_buffer)) 1181 mask |= (POLLIN | POLLRDNORM | POLLPRI); 1182 } else 1183 mask |= (POLLOUT | POLLWRNORM | POLLPRI); 1184 1185 return mask; 1186 } 1187 1188 static const struct file_operations dvb_dvr_fops = { 1189 .owner = THIS_MODULE, 1190 .read = dvb_dvr_read, 1191 .write = dvb_dvr_write, 1192 .unlocked_ioctl = dvb_dvr_ioctl, 1193 .open = dvb_dvr_open, 1194 .release = dvb_dvr_release, 1195 .poll = dvb_dvr_poll, 1196 .llseek = default_llseek, 1197 }; 1198 1199 static const struct dvb_device dvbdev_dvr = { 1200 .priv = NULL, 1201 .readers = 1, 1202 .users = 1, 1203 #if defined(CONFIG_MEDIA_CONTROLLER_DVB) 1204 .name = "dvb-dvr", 1205 #endif 1206 .fops = &dvb_dvr_fops 1207 }; 1208 int dvb_dmxdev_init(struct dmxdev *dmxdev, struct dvb_adapter *dvb_adapter) 1209 { 1210 int i; 1211 1212 if (dmxdev->demux->open(dmxdev->demux) < 0) 1213 return -EUSERS; 1214 1215 dmxdev->filter = vmalloc(dmxdev->filternum * sizeof(struct dmxdev_filter)); 1216 if (!dmxdev->filter) 1217 return -ENOMEM; 1218 1219 mutex_init(&dmxdev->mutex); 1220 spin_lock_init(&dmxdev->lock); 1221 for (i = 0; i < dmxdev->filternum; i++) { 1222 dmxdev->filter[i].dev = dmxdev; 1223 dmxdev->filter[i].buffer.data = NULL; 1224 dvb_dmxdev_filter_state_set(&dmxdev->filter[i], 1225 DMXDEV_STATE_FREE); 1226 } 1227 1228 dvb_register_device(dvb_adapter, &dmxdev->dvbdev, &dvbdev_demux, dmxdev, 1229 DVB_DEVICE_DEMUX, dmxdev->filternum); 1230 dvb_register_device(dvb_adapter, &dmxdev->dvr_dvbdev, &dvbdev_dvr, 1231 dmxdev, DVB_DEVICE_DVR, dmxdev->filternum); 1232 1233 dvb_ringbuffer_init(&dmxdev->dvr_buffer, NULL, 8192); 1234 1235 return 0; 1236 } 1237 1238 EXPORT_SYMBOL(dvb_dmxdev_init); 1239 1240 void dvb_dmxdev_release(struct dmxdev *dmxdev) 1241 { 1242 dmxdev->exit = 1; 1243 if (dmxdev->dvbdev->users > 1) { 1244 wait_event(dmxdev->dvbdev->wait_queue, 1245 dmxdev->dvbdev->users == 1); 1246 } 1247 if (dmxdev->dvr_dvbdev->users > 1) { 1248 wait_event(dmxdev->dvr_dvbdev->wait_queue, 1249 dmxdev->dvr_dvbdev->users == 1); 1250 } 1251 1252 dvb_unregister_device(dmxdev->dvbdev); 1253 dvb_unregister_device(dmxdev->dvr_dvbdev); 1254 1255 vfree(dmxdev->filter); 1256 dmxdev->filter = NULL; 1257 dmxdev->demux->close(dmxdev->demux); 1258 } 1259 1260 EXPORT_SYMBOL(dvb_dmxdev_release); 1261