drivers/media/dvb-core/dmxdev.c

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