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 * You should have received a copy of the GNU Lesser General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 20 * 21 */ 22 23 #include <linux/sched.h> 24 #include <linux/spinlock.h> 25 #include <linux/slab.h> 26 #include <linux/vmalloc.h> 27 #include <linux/module.h> 28 #include <linux/poll.h> 29 #include <linux/ioctl.h> 30 #include <linux/wait.h> 31 #include <asm/uaccess.h> 32 #include "dmxdev.h" 33 34 static int debug; 35 36 module_param(debug, int, 0644); 37 MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off)."); 38 39 #define dprintk if (debug) printk 40 41 static int dvb_dmxdev_buffer_write(struct dvb_ringbuffer *buf, 42 const u8 *src, size_t len) 43 { 44 ssize_t free; 45 46 if (!len) 47 return 0; 48 if (!buf->data) 49 return 0; 50 51 free = dvb_ringbuffer_free(buf); 52 if (len > free) { 53 dprintk("dmxdev: buffer overflow\n"); 54 return -EOVERFLOW; 55 } 56 57 return dvb_ringbuffer_write(buf, src, len); 58 } 59 60 static ssize_t dvb_dmxdev_buffer_read(struct dvb_ringbuffer *src, 61 int non_blocking, char __user *buf, 62 size_t count, loff_t *ppos) 63 { 64 size_t todo; 65 ssize_t avail; 66 ssize_t ret = 0; 67 68 if (!src->data) 69 return 0; 70 71 if (src->error) { 72 ret = src->error; 73 dvb_ringbuffer_flush(src); 74 return ret; 75 } 76 77 for (todo = count; todo > 0; todo -= ret) { 78 if (non_blocking && dvb_ringbuffer_empty(src)) { 79 ret = -EWOULDBLOCK; 80 break; 81 } 82 83 ret = wait_event_interruptible(src->queue, 84 !dvb_ringbuffer_empty(src) || 85 (src->error != 0)); 86 if (ret < 0) 87 break; 88 89 if (src->error) { 90 ret = src->error; 91 dvb_ringbuffer_flush(src); 92 break; 93 } 94 95 avail = dvb_ringbuffer_avail(src); 96 if (avail > todo) 97 avail = todo; 98 99 ret = dvb_ringbuffer_read_user(src, buf, avail); 100 if (ret < 0) 101 break; 102 103 buf += ret; 104 } 105 106 return (count - todo) ? (count - todo) : ret; 107 } 108 109 static struct dmx_frontend *get_fe(struct dmx_demux *demux, int type) 110 { 111 struct list_head *head, *pos; 112 113 head = demux->get_frontends(demux); 114 if (!head) 115 return NULL; 116 list_for_each(pos, head) 117 if (DMX_FE_ENTRY(pos)->source == type) 118 return DMX_FE_ENTRY(pos); 119 120 return NULL; 121 } 122 123 static int dvb_dvr_open(struct inode *inode, struct file *file) 124 { 125 struct dvb_device *dvbdev = file->private_data; 126 struct dmxdev *dmxdev = dvbdev->priv; 127 struct dmx_frontend *front; 128 129 dprintk("function : %s\n", __func__); 130 131 if (mutex_lock_interruptible(&dmxdev->mutex)) 132 return -ERESTARTSYS; 133 134 if (dmxdev->exit) { 135 mutex_unlock(&dmxdev->mutex); 136 return -ENODEV; 137 } 138 139 if ((file->f_flags & O_ACCMODE) == O_RDWR) { 140 if (!(dmxdev->capabilities & DMXDEV_CAP_DUPLEX)) { 141 mutex_unlock(&dmxdev->mutex); 142 return -EOPNOTSUPP; 143 } 144 } 145 146 if ((file->f_flags & O_ACCMODE) == O_RDONLY) { 147 void *mem; 148 if (!dvbdev->readers) { 149 mutex_unlock(&dmxdev->mutex); 150 return -EBUSY; 151 } 152 mem = vmalloc(DVR_BUFFER_SIZE); 153 if (!mem) { 154 mutex_unlock(&dmxdev->mutex); 155 return -ENOMEM; 156 } 157 dvb_ringbuffer_init(&dmxdev->dvr_buffer, mem, DVR_BUFFER_SIZE); 158 dvbdev->readers--; 159 } 160 161 if ((file->f_flags & O_ACCMODE) == O_WRONLY) { 162 dmxdev->dvr_orig_fe = dmxdev->demux->frontend; 163 164 if (!dmxdev->demux->write) { 165 mutex_unlock(&dmxdev->mutex); 166 return -EOPNOTSUPP; 167 } 168 169 front = get_fe(dmxdev->demux, DMX_MEMORY_FE); 170 171 if (!front) { 172 mutex_unlock(&dmxdev->mutex); 173 return -EINVAL; 174 } 175 dmxdev->demux->disconnect_frontend(dmxdev->demux); 176 dmxdev->demux->connect_frontend(dmxdev->demux, front); 177 } 178 dvbdev->users++; 179 mutex_unlock(&dmxdev->mutex); 180 return 0; 181 } 182 183 static int dvb_dvr_release(struct inode *inode, struct file *file) 184 { 185 struct dvb_device *dvbdev = file->private_data; 186 struct dmxdev *dmxdev = dvbdev->priv; 187 188 mutex_lock(&dmxdev->mutex); 189 190 if ((file->f_flags & O_ACCMODE) == O_WRONLY) { 191 dmxdev->demux->disconnect_frontend(dmxdev->demux); 192 dmxdev->demux->connect_frontend(dmxdev->demux, 193 dmxdev->dvr_orig_fe); 194 } 195 if ((file->f_flags & O_ACCMODE) == O_RDONLY) { 196 dvbdev->readers++; 197 if (dmxdev->dvr_buffer.data) { 198 void *mem = dmxdev->dvr_buffer.data; 199 mb(); 200 spin_lock_irq(&dmxdev->lock); 201 dmxdev->dvr_buffer.data = NULL; 202 spin_unlock_irq(&dmxdev->lock); 203 vfree(mem); 204 } 205 } 206 /* TODO */ 207 dvbdev->users--; 208 if (dvbdev->users == 1 && dmxdev->exit == 1) { 209 mutex_unlock(&dmxdev->mutex); 210 wake_up(&dvbdev->wait_queue); 211 } else 212 mutex_unlock(&dmxdev->mutex); 213 214 return 0; 215 } 216 217 static ssize_t dvb_dvr_write(struct file *file, const char __user *buf, 218 size_t count, loff_t *ppos) 219 { 220 struct dvb_device *dvbdev = file->private_data; 221 struct dmxdev *dmxdev = dvbdev->priv; 222 int ret; 223 224 if (!dmxdev->demux->write) 225 return -EOPNOTSUPP; 226 if ((file->f_flags & O_ACCMODE) != O_WRONLY) 227 return -EINVAL; 228 if (mutex_lock_interruptible(&dmxdev->mutex)) 229 return -ERESTARTSYS; 230 231 if (dmxdev->exit) { 232 mutex_unlock(&dmxdev->mutex); 233 return -ENODEV; 234 } 235 ret = dmxdev->demux->write(dmxdev->demux, buf, count); 236 mutex_unlock(&dmxdev->mutex); 237 return ret; 238 } 239 240 static ssize_t dvb_dvr_read(struct file *file, char __user *buf, size_t count, 241 loff_t *ppos) 242 { 243 struct dvb_device *dvbdev = file->private_data; 244 struct dmxdev *dmxdev = dvbdev->priv; 245 246 if (dmxdev->exit) 247 return -ENODEV; 248 249 return dvb_dmxdev_buffer_read(&dmxdev->dvr_buffer, 250 file->f_flags & O_NONBLOCK, 251 buf, count, ppos); 252 } 253 254 static int dvb_dvr_set_buffer_size(struct dmxdev *dmxdev, 255 unsigned long size) 256 { 257 struct dvb_ringbuffer *buf = &dmxdev->dvr_buffer; 258 void *newmem; 259 void *oldmem; 260 261 dprintk("function : %s\n", __func__); 262 263 if (buf->size == size) 264 return 0; 265 if (!size) 266 return -EINVAL; 267 268 newmem = vmalloc(size); 269 if (!newmem) 270 return -ENOMEM; 271 272 oldmem = buf->data; 273 274 spin_lock_irq(&dmxdev->lock); 275 buf->data = newmem; 276 buf->size = size; 277 278 /* reset and not flush in case the buffer shrinks */ 279 dvb_ringbuffer_reset(buf); 280 spin_unlock_irq(&dmxdev->lock); 281 282 vfree(oldmem); 283 284 return 0; 285 } 286 287 static inline void dvb_dmxdev_filter_state_set(struct dmxdev_filter 288 *dmxdevfilter, int state) 289 { 290 spin_lock_irq(&dmxdevfilter->dev->lock); 291 dmxdevfilter->state = state; 292 spin_unlock_irq(&dmxdevfilter->dev->lock); 293 } 294 295 static int dvb_dmxdev_set_buffer_size(struct dmxdev_filter *dmxdevfilter, 296 unsigned long size) 297 { 298 struct dvb_ringbuffer *buf = &dmxdevfilter->buffer; 299 void *newmem; 300 void *oldmem; 301 302 if (buf->size == size) 303 return 0; 304 if (!size) 305 return -EINVAL; 306 if (dmxdevfilter->state >= DMXDEV_STATE_GO) 307 return -EBUSY; 308 309 newmem = vmalloc(size); 310 if (!newmem) 311 return -ENOMEM; 312 313 oldmem = buf->data; 314 315 spin_lock_irq(&dmxdevfilter->dev->lock); 316 buf->data = newmem; 317 buf->size = size; 318 319 /* reset and not flush in case the buffer shrinks */ 320 dvb_ringbuffer_reset(buf); 321 spin_unlock_irq(&dmxdevfilter->dev->lock); 322 323 vfree(oldmem); 324 325 return 0; 326 } 327 328 static void dvb_dmxdev_filter_timeout(unsigned long data) 329 { 330 struct dmxdev_filter *dmxdevfilter = (struct dmxdev_filter *)data; 331 332 dmxdevfilter->buffer.error = -ETIMEDOUT; 333 spin_lock_irq(&dmxdevfilter->dev->lock); 334 dmxdevfilter->state = DMXDEV_STATE_TIMEDOUT; 335 spin_unlock_irq(&dmxdevfilter->dev->lock); 336 wake_up(&dmxdevfilter->buffer.queue); 337 } 338 339 static void dvb_dmxdev_filter_timer(struct dmxdev_filter *dmxdevfilter) 340 { 341 struct dmx_sct_filter_params *para = &dmxdevfilter->params.sec; 342 343 del_timer(&dmxdevfilter->timer); 344 if (para->timeout) { 345 dmxdevfilter->timer.function = dvb_dmxdev_filter_timeout; 346 dmxdevfilter->timer.data = (unsigned long)dmxdevfilter; 347 dmxdevfilter->timer.expires = 348 jiffies + 1 + (HZ / 2 + HZ * para->timeout) / 1000; 349 add_timer(&dmxdevfilter->timer); 350 } 351 } 352 353 static int dvb_dmxdev_section_callback(const u8 *buffer1, size_t buffer1_len, 354 const u8 *buffer2, size_t buffer2_len, 355 struct dmx_section_filter *filter, 356 enum dmx_success success) 357 { 358 struct dmxdev_filter *dmxdevfilter = filter->priv; 359 int ret; 360 361 if (dmxdevfilter->buffer.error) { 362 wake_up(&dmxdevfilter->buffer.queue); 363 return 0; 364 } 365 spin_lock(&dmxdevfilter->dev->lock); 366 if (dmxdevfilter->state != DMXDEV_STATE_GO) { 367 spin_unlock(&dmxdevfilter->dev->lock); 368 return 0; 369 } 370 del_timer(&dmxdevfilter->timer); 371 dprintk("dmxdev: section callback %*ph\n", 6, buffer1); 372 ret = dvb_dmxdev_buffer_write(&dmxdevfilter->buffer, buffer1, 373 buffer1_len); 374 if (ret == buffer1_len) { 375 ret = dvb_dmxdev_buffer_write(&dmxdevfilter->buffer, buffer2, 376 buffer2_len); 377 } 378 if (ret < 0) 379 dmxdevfilter->buffer.error = ret; 380 if (dmxdevfilter->params.sec.flags & DMX_ONESHOT) 381 dmxdevfilter->state = DMXDEV_STATE_DONE; 382 spin_unlock(&dmxdevfilter->dev->lock); 383 wake_up(&dmxdevfilter->buffer.queue); 384 return 0; 385 } 386 387 static int dvb_dmxdev_ts_callback(const u8 *buffer1, size_t buffer1_len, 388 const u8 *buffer2, size_t buffer2_len, 389 struct dmx_ts_feed *feed, 390 enum dmx_success success) 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 struct timespec timeout = { 0 }; 562 struct dmx_pes_filter_params *para = &filter->params.pes; 563 dmx_output_t 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, 32768, 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 printk("DVB (%s): could not alloc feed\n", 661 __func__); 662 return ret; 663 } 664 665 ret = (*secfeed)->set(*secfeed, para->pid, 32768, 666 (para->flags & DMX_CHECK_CRC) ? 1 : 0); 667 if (ret < 0) { 668 printk("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 init_timer(&dmxdevfilter->timer); 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(dmx_filter_t *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("function : %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)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_CAPS: 1027 if (!dmxdev->demux->get_caps) { 1028 ret = -EINVAL; 1029 break; 1030 } 1031 ret = dmxdev->demux->get_caps(dmxdev->demux, parg); 1032 break; 1033 1034 case DMX_SET_SOURCE: 1035 if (!dmxdev->demux->set_source) { 1036 ret = -EINVAL; 1037 break; 1038 } 1039 ret = dmxdev->demux->set_source(dmxdev->demux, parg); 1040 break; 1041 1042 case DMX_GET_STC: 1043 if (!dmxdev->demux->get_stc) { 1044 ret = -EINVAL; 1045 break; 1046 } 1047 ret = dmxdev->demux->get_stc(dmxdev->demux, 1048 ((struct dmx_stc *)parg)->num, 1049 &((struct dmx_stc *)parg)->stc, 1050 &((struct dmx_stc *)parg)->base); 1051 break; 1052 1053 case DMX_ADD_PID: 1054 if (mutex_lock_interruptible(&dmxdevfilter->mutex)) { 1055 ret = -ERESTARTSYS; 1056 break; 1057 } 1058 ret = dvb_dmxdev_add_pid(dmxdev, dmxdevfilter, *(u16 *)parg); 1059 mutex_unlock(&dmxdevfilter->mutex); 1060 break; 1061 1062 case DMX_REMOVE_PID: 1063 if (mutex_lock_interruptible(&dmxdevfilter->mutex)) { 1064 ret = -ERESTARTSYS; 1065 break; 1066 } 1067 ret = dvb_dmxdev_remove_pid(dmxdev, dmxdevfilter, *(u16 *)parg); 1068 mutex_unlock(&dmxdevfilter->mutex); 1069 break; 1070 1071 default: 1072 ret = -EINVAL; 1073 break; 1074 } 1075 mutex_unlock(&dmxdev->mutex); 1076 return ret; 1077 } 1078 1079 static long dvb_demux_ioctl(struct file *file, unsigned int cmd, 1080 unsigned long arg) 1081 { 1082 return dvb_usercopy(file, cmd, arg, dvb_demux_do_ioctl); 1083 } 1084 1085 static unsigned int dvb_demux_poll(struct file *file, poll_table *wait) 1086 { 1087 struct dmxdev_filter *dmxdevfilter = file->private_data; 1088 unsigned int mask = 0; 1089 1090 if ((!dmxdevfilter) || dmxdevfilter->dev->exit) 1091 return POLLERR; 1092 1093 poll_wait(file, &dmxdevfilter->buffer.queue, wait); 1094 1095 if (dmxdevfilter->state != DMXDEV_STATE_GO && 1096 dmxdevfilter->state != DMXDEV_STATE_DONE && 1097 dmxdevfilter->state != DMXDEV_STATE_TIMEDOUT) 1098 return 0; 1099 1100 if (dmxdevfilter->buffer.error) 1101 mask |= (POLLIN | POLLRDNORM | POLLPRI | POLLERR); 1102 1103 if (!dvb_ringbuffer_empty(&dmxdevfilter->buffer)) 1104 mask |= (POLLIN | POLLRDNORM | POLLPRI); 1105 1106 return mask; 1107 } 1108 1109 static int dvb_demux_release(struct inode *inode, struct file *file) 1110 { 1111 struct dmxdev_filter *dmxdevfilter = file->private_data; 1112 struct dmxdev *dmxdev = dmxdevfilter->dev; 1113 1114 int ret; 1115 1116 ret = dvb_dmxdev_filter_free(dmxdev, dmxdevfilter); 1117 1118 mutex_lock(&dmxdev->mutex); 1119 dmxdev->dvbdev->users--; 1120 if(dmxdev->dvbdev->users==1 && dmxdev->exit==1) { 1121 mutex_unlock(&dmxdev->mutex); 1122 wake_up(&dmxdev->dvbdev->wait_queue); 1123 } else 1124 mutex_unlock(&dmxdev->mutex); 1125 1126 return ret; 1127 } 1128 1129 static const struct file_operations dvb_demux_fops = { 1130 .owner = THIS_MODULE, 1131 .read = dvb_demux_read, 1132 .unlocked_ioctl = dvb_demux_ioctl, 1133 .open = dvb_demux_open, 1134 .release = dvb_demux_release, 1135 .poll = dvb_demux_poll, 1136 .llseek = default_llseek, 1137 }; 1138 1139 static const struct dvb_device dvbdev_demux = { 1140 .priv = NULL, 1141 .users = 1, 1142 .writers = 1, 1143 #if defined(CONFIG_MEDIA_CONTROLLER_DVB) 1144 .name = "dvb-demux", 1145 #endif 1146 .fops = &dvb_demux_fops 1147 }; 1148 1149 static int dvb_dvr_do_ioctl(struct file *file, 1150 unsigned int cmd, void *parg) 1151 { 1152 struct dvb_device *dvbdev = file->private_data; 1153 struct dmxdev *dmxdev = dvbdev->priv; 1154 unsigned long arg = (unsigned long)parg; 1155 int ret; 1156 1157 if (mutex_lock_interruptible(&dmxdev->mutex)) 1158 return -ERESTARTSYS; 1159 1160 switch (cmd) { 1161 case DMX_SET_BUFFER_SIZE: 1162 ret = dvb_dvr_set_buffer_size(dmxdev, arg); 1163 break; 1164 1165 default: 1166 ret = -EINVAL; 1167 break; 1168 } 1169 mutex_unlock(&dmxdev->mutex); 1170 return ret; 1171 } 1172 1173 static long dvb_dvr_ioctl(struct file *file, 1174 unsigned int cmd, unsigned long arg) 1175 { 1176 return dvb_usercopy(file, cmd, arg, dvb_dvr_do_ioctl); 1177 } 1178 1179 static unsigned int dvb_dvr_poll(struct file *file, poll_table *wait) 1180 { 1181 struct dvb_device *dvbdev = file->private_data; 1182 struct dmxdev *dmxdev = dvbdev->priv; 1183 unsigned int mask = 0; 1184 1185 dprintk("function : %s\n", __func__); 1186 1187 if (dmxdev->exit) 1188 return POLLERR; 1189 1190 poll_wait(file, &dmxdev->dvr_buffer.queue, wait); 1191 1192 if ((file->f_flags & O_ACCMODE) == O_RDONLY) { 1193 if (dmxdev->dvr_buffer.error) 1194 mask |= (POLLIN | POLLRDNORM | POLLPRI | POLLERR); 1195 1196 if (!dvb_ringbuffer_empty(&dmxdev->dvr_buffer)) 1197 mask |= (POLLIN | POLLRDNORM | POLLPRI); 1198 } else 1199 mask |= (POLLOUT | POLLWRNORM | POLLPRI); 1200 1201 return mask; 1202 } 1203 1204 static const struct file_operations dvb_dvr_fops = { 1205 .owner = THIS_MODULE, 1206 .read = dvb_dvr_read, 1207 .write = dvb_dvr_write, 1208 .unlocked_ioctl = dvb_dvr_ioctl, 1209 .open = dvb_dvr_open, 1210 .release = dvb_dvr_release, 1211 .poll = dvb_dvr_poll, 1212 .llseek = default_llseek, 1213 }; 1214 1215 static const struct dvb_device dvbdev_dvr = { 1216 .priv = NULL, 1217 .readers = 1, 1218 .users = 1, 1219 #if defined(CONFIG_MEDIA_CONTROLLER_DVB) 1220 .name = "dvb-dvr", 1221 #endif 1222 .fops = &dvb_dvr_fops 1223 }; 1224 int dvb_dmxdev_init(struct dmxdev *dmxdev, struct dvb_adapter *dvb_adapter) 1225 { 1226 int i; 1227 1228 if (dmxdev->demux->open(dmxdev->demux) < 0) 1229 return -EUSERS; 1230 1231 dmxdev->filter = vmalloc(dmxdev->filternum * sizeof(struct dmxdev_filter)); 1232 if (!dmxdev->filter) 1233 return -ENOMEM; 1234 1235 mutex_init(&dmxdev->mutex); 1236 spin_lock_init(&dmxdev->lock); 1237 for (i = 0; i < dmxdev->filternum; i++) { 1238 dmxdev->filter[i].dev = dmxdev; 1239 dmxdev->filter[i].buffer.data = NULL; 1240 dvb_dmxdev_filter_state_set(&dmxdev->filter[i], 1241 DMXDEV_STATE_FREE); 1242 } 1243 1244 dvb_register_device(dvb_adapter, &dmxdev->dvbdev, &dvbdev_demux, dmxdev, 1245 DVB_DEVICE_DEMUX); 1246 dvb_register_device(dvb_adapter, &dmxdev->dvr_dvbdev, &dvbdev_dvr, 1247 dmxdev, DVB_DEVICE_DVR); 1248 1249 dvb_ringbuffer_init(&dmxdev->dvr_buffer, NULL, 8192); 1250 1251 return 0; 1252 } 1253 1254 EXPORT_SYMBOL(dvb_dmxdev_init); 1255 1256 void dvb_dmxdev_release(struct dmxdev *dmxdev) 1257 { 1258 dmxdev->exit=1; 1259 if (dmxdev->dvbdev->users > 1) { 1260 wait_event(dmxdev->dvbdev->wait_queue, 1261 dmxdev->dvbdev->users==1); 1262 } 1263 if (dmxdev->dvr_dvbdev->users > 1) { 1264 wait_event(dmxdev->dvr_dvbdev->wait_queue, 1265 dmxdev->dvr_dvbdev->users==1); 1266 } 1267 1268 dvb_unregister_device(dmxdev->dvbdev); 1269 dvb_unregister_device(dmxdev->dvr_dvbdev); 1270 1271 vfree(dmxdev->filter); 1272 dmxdev->filter = NULL; 1273 dmxdev->demux->close(dmxdev->demux); 1274 } 1275 1276 EXPORT_SYMBOL(dvb_dmxdev_release); 1277