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