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