SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/media/dvb/dvb-core/dmxdev.c

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