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         file->private_data=dmxdevfilter;
 698
 699         dvb_dmxdev_buffer_init(&dmxdevfilter->buffer);
 700         dmxdevfilter->type=DMXDEV_TYPE_NONE;
 701         dvb_dmxdev_filter_state_set(dmxdevfilter, DMXDEV_STATE_ALLOCATED);
 702         dmxdevfilter->feed.ts=NULL;
 703         init_timer(&dmxdevfilter->timer);
 704
 705         mutex_unlock(&dmxdev->mutex);
 706         return 0;
 707 }
 708
 709
 710 static int dvb_dmxdev_filter_free(struct dmxdev *dmxdev, struct dmxdev_filter *dmxdevfilter)
 711 {
 712         if (mutex_lock_interruptible(&dmxdev->mutex))
 713                 return -ERESTARTSYS;
 714
 715         if (mutex_lock_interruptible(&dmxdevfilter->mutex)) {
 716                 mutex_unlock(&dmxdev->mutex);
 717                 return -ERESTARTSYS;
 718         }
 719
 720         dvb_dmxdev_filter_stop(dmxdevfilter);
 721         dvb_dmxdev_filter_reset(dmxdevfilter);
 722
 723         if (dmxdevfilter->buffer.data) {
 724                 void *mem=dmxdevfilter->buffer.data;
 725
 726                 spin_lock_irq(&dmxdev->lock);
 727                 dmxdevfilter->buffer.data=NULL;
 728                 spin_unlock_irq(&dmxdev->lock);
 729                 vfree(mem);
 730         }
 731
 732         dvb_dmxdev_filter_state_set(dmxdevfilter, DMXDEV_STATE_FREE);
 733         wake_up(&dmxdevfilter->buffer.queue);
 734         mutex_unlock(&dmxdevfilter->mutex);
 735         mutex_unlock(&dmxdev->mutex);
 736         return 0;
 737 }
 738
 739 static inline void invert_mode(dmx_filter_t *filter)
 740 {
 741         int i;
 742
 743         for (i=0; i<DMX_FILTER_SIZE; i++)
 744                 filter->mode[i]^=0xff;
 745 }
 746
 747
 748 static int dvb_dmxdev_filter_set(struct dmxdev *dmxdev,
 749                 struct dmxdev_filter *dmxdevfilter,
 750                 struct dmx_sct_filter_params *params)
 751 {
 752         dprintk ("function : %s\n", __FUNCTION__);
 753
 754         dvb_dmxdev_filter_stop(dmxdevfilter);
 755
 756         dmxdevfilter->type=DMXDEV_TYPE_SEC;
 757         memcpy(&dmxdevfilter->params.sec,
 758                params, sizeof(struct dmx_sct_filter_params));
 759         invert_mode(&dmxdevfilter->params.sec.filter);
 760         dvb_dmxdev_filter_state_set(dmxdevfilter, DMXDEV_STATE_SET);
 761
 762         if (params->flags&DMX_IMMEDIATE_START)
 763                 return dvb_dmxdev_filter_start(dmxdevfilter);
 764
 765         return 0;
 766 }
 767
 768 static int dvb_dmxdev_pes_filter_set(struct dmxdev *dmxdev,
 769                    struct dmxdev_filter *dmxdevfilter,
 770                    struct dmx_pes_filter_params *params)
 771 {
 772         dvb_dmxdev_filter_stop(dmxdevfilter);
 773
 774         if (params->pes_type>DMX_PES_OTHER || params->pes_type<0)
 775                 return -EINVAL;
 776
 777         dmxdevfilter->type=DMXDEV_TYPE_PES;
 778         memcpy(&dmxdevfilter->params, params, sizeof(struct dmx_pes_filter_params));
 779
 780         dvb_dmxdev_filter_state_set(dmxdevfilter, DMXDEV_STATE_SET);
 781
 782         if (params->flags&DMX_IMMEDIATE_START)
 783                 return dvb_dmxdev_filter_start(dmxdevfilter);
 784
 785         return 0;
 786 }
 787
 788 static ssize_t dvb_dmxdev_read_sec(struct dmxdev_filter *dfil,
 789                 struct file *file, char __user *buf, size_t count, loff_t *ppos)
 790 {
 791         int result, hcount;
 792         int done=0;
 793
 794         if (dfil->todo<=0) {
 795                 hcount=3+dfil->todo;
 796                 if (hcount>count)
 797                         hcount=count;
 798                 result=dvb_dmxdev_buffer_read(&dfil->buffer, file->f_flags&O_NONBLOCK,
 799                                         buf, hcount, ppos);
 800                 if (result<0) {
 801                         dfil->todo=0;
 802                         return result;
 803                 }
 804                 if (copy_from_user(dfil->secheader-dfil->todo, buf, result))
 805                         return -EFAULT;
 806                 buf+=result;
 807                 done=result;
 808                 count-=result;
 809                 dfil->todo-=result;
 810                 if (dfil->todo>-3)
 811                         return done;
 812                 dfil->todo=((dfil->secheader[1]<<8)|dfil->secheader[2])&0xfff;
 813                 if (!count)
 814                         return done;
 815         }
 816         if (count>dfil->todo)
 817                 count=dfil->todo;
 818         result=dvb_dmxdev_buffer_read(&dfil->buffer, file->f_flags&O_NONBLOCK,
 819                                 buf, count, ppos);
 820         if (result<0)
 821                 return result;
 822         dfil->todo-=result;
 823         return (result+done);
 824 }
 825
 826
 827 static ssize_t
 828 dvb_demux_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
 829 {
 830         struct dmxdev_filter *dmxdevfilter= file->private_data;
 831         int ret=0;
 832
 833         if (mutex_lock_interruptible(&dmxdevfilter->mutex))
 834                 return -ERESTARTSYS;
 835
 836         if (dmxdevfilter->type==DMXDEV_TYPE_SEC)
 837                 ret=dvb_dmxdev_read_sec(dmxdevfilter, file, buf, count, ppos);
 838         else
 839                 ret=dvb_dmxdev_buffer_read(&dmxdevfilter->buffer,
 840                                      file->f_flags&O_NONBLOCK,
 841                                      buf, count, ppos);
 842
 843         mutex_unlock(&dmxdevfilter->mutex);
 844         return ret;
 845 }
 846
 847
 848 static int dvb_demux_do_ioctl(struct inode *inode, struct file *file,
 849                               unsigned int cmd, void *parg)
 850 {
 851         struct dmxdev_filter *dmxdevfilter = file->private_data;
 852         struct dmxdev *dmxdev=dmxdevfilter->dev;
 853         unsigned long arg=(unsigned long) parg;
 854         int ret=0;
 855
 856         if (mutex_lock_interruptible(&dmxdev->mutex))
 857                 return -ERESTARTSYS;
 858
 859         switch (cmd) {
 860         case DMX_START:
 861                 if (mutex_lock_interruptible(&dmxdevfilter->mutex)) {
 862                         mutex_unlock(&dmxdev->mutex);
 863                         return -ERESTARTSYS;
 864                 }
 865                 if (dmxdevfilter->state<DMXDEV_STATE_SET)
 866                         ret = -EINVAL;
 867                 else
 868                         ret = dvb_dmxdev_filter_start(dmxdevfilter);
 869                 mutex_unlock(&dmxdevfilter->mutex);
 870                 break;
 871
 872         case DMX_STOP:
 873                 if (mutex_lock_interruptible(&dmxdevfilter->mutex)) {
 874                         mutex_unlock(&dmxdev->mutex);
 875                         return -ERESTARTSYS;
 876                 }
 877                 ret=dvb_dmxdev_filter_stop(dmxdevfilter);
 878                 mutex_unlock(&dmxdevfilter->mutex);
 879                 break;
 880
 881         case DMX_SET_FILTER:
 882                 if (mutex_lock_interruptible(&dmxdevfilter->mutex)) {
 883                         mutex_unlock(&dmxdev->mutex);
 884                         return -ERESTARTSYS;
 885                 }
 886                 ret = dvb_dmxdev_filter_set(dmxdev, dmxdevfilter,
 887                                     (struct dmx_sct_filter_params *)parg);
 888                 mutex_unlock(&dmxdevfilter->mutex);
 889                 break;
 890
 891         case DMX_SET_PES_FILTER:
 892                 if (mutex_lock_interruptible(&dmxdevfilter->mutex)) {
 893                         mutex_unlock(&dmxdev->mutex);
 894                         return -ERESTARTSYS;
 895                 }
 896                 ret=dvb_dmxdev_pes_filter_set(dmxdev, dmxdevfilter,
 897                                                (struct dmx_pes_filter_params *)parg);
 898                 mutex_unlock(&dmxdevfilter->mutex);
 899                 break;
 900
 901         case DMX_SET_BUFFER_SIZE:
 902                 if (mutex_lock_interruptible(&dmxdevfilter->mutex)) {
 903                         mutex_unlock(&dmxdev->mutex);
 904                         return -ERESTARTSYS;
 905                 }
 906                 ret=dvb_dmxdev_set_buffer_size(dmxdevfilter, arg);
 907                 mutex_unlock(&dmxdevfilter->mutex);
 908                 break;
 909
 910         case DMX_GET_EVENT:
 911                 break;
 912
 913         case DMX_GET_PES_PIDS:
 914                 if (!dmxdev->demux->get_pes_pids) {
 915                         ret=-EINVAL;
 916                         break;
 917                 }
 918                 dmxdev->demux->get_pes_pids(dmxdev->demux, (u16 *)parg);
 919                 break;
 920
 921         case DMX_GET_CAPS:
 922                 if (!dmxdev->demux->get_caps) {
 923                         ret = -EINVAL;
 924                         break;
 925                 }
 926                 ret = dmxdev->demux->get_caps(dmxdev->demux, parg);
 927                 break;
 928
 929         case DMX_SET_SOURCE:
 930                 if (!dmxdev->demux->set_source) {
 931                         ret = -EINVAL;
 932                         break;
 933                 }
 934                 ret = dmxdev->demux->set_source(dmxdev->demux, parg);
 935                 break;
 936
 937         case DMX_GET_STC:
 938                 if (!dmxdev->demux->get_stc) {
 939                         ret=-EINVAL;
 940                         break;
 941                 }
 942                 ret = dmxdev->demux->get_stc(dmxdev->demux,
 943                                 ((struct dmx_stc *)parg)->num,
 944                                 &((struct dmx_stc *)parg)->stc,
 945                                 &((struct dmx_stc *)parg)->base);
 946                 break;
 947
 948         default:
 949                 ret=-EINVAL;
 950         }
 951         mutex_unlock(&dmxdev->mutex);
 952         return ret;
 953 }
 954
 955 static int dvb_demux_ioctl(struct inode *inode, struct file *file,
 956                            unsigned int cmd, unsigned long arg)
 957 {
 958         return dvb_usercopy(inode, file, cmd, arg, dvb_demux_do_ioctl);
 959 }
 960
 961
 962 static unsigned int dvb_demux_poll (struct file *file, poll_table *wait)
 963 {
 964         struct dmxdev_filter *dmxdevfilter = file->private_data;
 965         unsigned int mask = 0;
 966
 967         if (!dmxdevfilter)
 968                 return -EINVAL;
 969
 970         poll_wait(file, &dmxdevfilter->buffer.queue, wait);
 971
 972         if (dmxdevfilter->state != DMXDEV_STATE_GO &&
 973             dmxdevfilter->state != DMXDEV_STATE_DONE &&
 974             dmxdevfilter->state != DMXDEV_STATE_TIMEDOUT)
 975                 return 0;
 976
 977         if (dmxdevfilter->buffer.error)
 978                 mask |= (POLLIN | POLLRDNORM | POLLPRI | POLLERR);
 979
 980         if (dmxdevfilter->buffer.pread != dmxdevfilter->buffer.pwrite)
 981                 mask |= (POLLIN | POLLRDNORM | POLLPRI);
 982
 983         return mask;
 984 }
 985
 986
 987 static int dvb_demux_release(struct inode *inode, struct file *file)
 988 {
 989         struct dmxdev_filter *dmxdevfilter = file->private_data;
 990         struct dmxdev *dmxdev = dmxdevfilter->dev;
 991
 992         return dvb_dmxdev_filter_free(dmxdev, dmxdevfilter);
 993 }
 994
 995
 996 static struct file_operations dvb_demux_fops = {
 997         .owner          = THIS_MODULE,
 998         .read           = dvb_demux_read,
 999         .ioctl          = dvb_demux_ioctl,
1000         .open           = dvb_demux_open,
1001         .release        = dvb_demux_release,
1002         .poll           = dvb_demux_poll,
1003 };
1004
1005
1006 static struct dvb_device dvbdev_demux = {
1007         .priv           = NULL,
1008         .users          = 1,
1009         .writers        = 1,
1010         .fops           = &dvb_demux_fops
1011 };
1012
1013
1014 static int dvb_dvr_do_ioctl(struct inode *inode, struct file *file,
1015                      unsigned int cmd, void *parg)
1016 {
1017         struct dvb_device *dvbdev = file->private_data;
1018         struct dmxdev *dmxdev = dvbdev->priv;
1019
1020         int ret=0;
1021
1022         if (mutex_lock_interruptible(&dmxdev->mutex))
1023                 return -ERESTARTSYS;
1024
1025         switch (cmd) {
1026         case DMX_SET_BUFFER_SIZE:
1027                 // FIXME: implement
1028                 ret=0;
1029                 break;
1030
1031         default:
1032                 ret=-EINVAL;
1033         }
1034         mutex_unlock(&dmxdev->mutex);
1035         return ret;
1036 }
1037
1038
1039 static int dvb_dvr_ioctl(struct inode *inode, struct file *file,
1040                   unsigned int cmd, unsigned long arg)
1041 {
1042         return dvb_usercopy(inode, file, cmd, arg, dvb_dvr_do_ioctl);
1043 }
1044
1045
1046 static unsigned int dvb_dvr_poll (struct file *file, poll_table *wait)
1047 {
1048         struct dvb_device *dvbdev = file->private_data;
1049         struct dmxdev *dmxdev = dvbdev->priv;
1050         unsigned int mask = 0;
1051
1052         dprintk ("function : %s\n", __FUNCTION__);
1053
1054         poll_wait(file, &dmxdev->dvr_buffer.queue, wait);
1055
1056         if ((file->f_flags&O_ACCMODE) == O_RDONLY) {
1057                 if (dmxdev->dvr_buffer.error)
1058                         mask |= (POLLIN | POLLRDNORM | POLLPRI | POLLERR);
1059
1060                 if (dmxdev->dvr_buffer.pread!=dmxdev->dvr_buffer.pwrite)
1061                         mask |= (POLLIN | POLLRDNORM | POLLPRI);
1062         } else
1063                 mask |= (POLLOUT | POLLWRNORM | POLLPRI);
1064
1065         return mask;
1066 }
1067
1068
1069 static struct file_operations dvb_dvr_fops = {
1070         .owner          = THIS_MODULE,
1071         .read           = dvb_dvr_read,
1072         .write          = dvb_dvr_write,
1073         .ioctl          = dvb_dvr_ioctl,
1074         .open           = dvb_dvr_open,
1075         .release        = dvb_dvr_release,
1076         .poll           = dvb_dvr_poll,
1077 };
1078
1079 static struct dvb_device dvbdev_dvr = {
1080         .priv           = NULL,
1081         .users          = 1,
1082         .writers        = 1,
1083         .fops           = &dvb_dvr_fops
1084 };
1085
1086 int
1087 dvb_dmxdev_init(struct dmxdev *dmxdev, struct dvb_adapter *dvb_adapter)
1088 {
1089         int i;
1090
1091         if (dmxdev->demux->open(dmxdev->demux) < 0)
1092                 return -EUSERS;
1093
1094         dmxdev->filter = vmalloc(dmxdev->filternum*sizeof(struct dmxdev_filter));
1095         if (!dmxdev->filter)
1096                 return -ENOMEM;
1097
1098         mutex_init(&dmxdev->mutex);
1099         spin_lock_init(&dmxdev->lock);
1100         for (i=0; i<dmxdev->filternum; i++) {
1101                 dmxdev->filter[i].dev=dmxdev;
1102                 dmxdev->filter[i].buffer.data=NULL;
1103                 dvb_dmxdev_filter_state_set(&dmxdev->filter[i], DMXDEV_STATE_FREE);
1104         }
1105
1106         dvb_register_device(dvb_adapter, &dmxdev->dvbdev, &dvbdev_demux, dmxdev, DVB_DEVICE_DEMUX);
1107         dvb_register_device(dvb_adapter, &dmxdev->dvr_dvbdev, &dvbdev_dvr, dmxdev, DVB_DEVICE_DVR);
1108
1109         dvb_dmxdev_buffer_init(&dmxdev->dvr_buffer);
1110
1111         return 0;
1112 }
1113 EXPORT_SYMBOL(dvb_dmxdev_init);
1114
1115 void
1116 dvb_dmxdev_release(struct dmxdev *dmxdev)
1117 {
1118         dvb_unregister_device(dmxdev->dvbdev);
1119         dvb_unregister_device(dmxdev->dvr_dvbdev);
1120
1121         vfree(dmxdev->filter);
1122         dmxdev->filter=NULL;
1123         dmxdev->demux->close(dmxdev->demux);
1124 }
1125 EXPORT_SYMBOL(dvb_dmxdev_release);