Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: LGPL-2.1-or-later
0002 /*
0003  * dmxdev.c - DVB demultiplexer device
0004  *
0005  * Copyright (C) 2000 Ralph Metzler & Marcus Metzler
0006  *            for convergence integrated media GmbH
0007  */
0008 
0009 #define pr_fmt(fmt) "dmxdev: " fmt
0010 
0011 #include <linux/sched.h>
0012 #include <linux/spinlock.h>
0013 #include <linux/slab.h>
0014 #include <linux/vmalloc.h>
0015 #include <linux/module.h>
0016 #include <linux/poll.h>
0017 #include <linux/ioctl.h>
0018 #include <linux/wait.h>
0019 #include <linux/uaccess.h>
0020 #include <media/dmxdev.h>
0021 #include <media/dvb_vb2.h>
0022 
0023 static int debug;
0024 
0025 module_param(debug, int, 0644);
0026 MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off).");
0027 
0028 #define dprintk(fmt, arg...) do {                   \
0029     if (debug)                          \
0030         printk(KERN_DEBUG pr_fmt("%s: " fmt),           \
0031             __func__, ##arg);               \
0032 } while (0)
0033 
0034 static int dvb_dmxdev_buffer_write(struct dvb_ringbuffer *buf,
0035                    const u8 *src, size_t len)
0036 {
0037     ssize_t free;
0038 
0039     if (!len)
0040         return 0;
0041     if (!buf->data)
0042         return 0;
0043 
0044     free = dvb_ringbuffer_free(buf);
0045     if (len > free) {
0046         dprintk("buffer overflow\n");
0047         return -EOVERFLOW;
0048     }
0049 
0050     return dvb_ringbuffer_write(buf, src, len);
0051 }
0052 
0053 static ssize_t dvb_dmxdev_buffer_read(struct dvb_ringbuffer *src,
0054                       int non_blocking, char __user *buf,
0055                       size_t count, loff_t *ppos)
0056 {
0057     size_t todo;
0058     ssize_t avail;
0059     ssize_t ret = 0;
0060 
0061     if (!src->data)
0062         return 0;
0063 
0064     if (src->error) {
0065         ret = src->error;
0066         dvb_ringbuffer_flush(src);
0067         return ret;
0068     }
0069 
0070     for (todo = count; todo > 0; todo -= ret) {
0071         if (non_blocking && dvb_ringbuffer_empty(src)) {
0072             ret = -EWOULDBLOCK;
0073             break;
0074         }
0075 
0076         ret = wait_event_interruptible(src->queue,
0077                            !dvb_ringbuffer_empty(src) ||
0078                            (src->error != 0));
0079         if (ret < 0)
0080             break;
0081 
0082         if (src->error) {
0083             ret = src->error;
0084             dvb_ringbuffer_flush(src);
0085             break;
0086         }
0087 
0088         avail = dvb_ringbuffer_avail(src);
0089         if (avail > todo)
0090             avail = todo;
0091 
0092         ret = dvb_ringbuffer_read_user(src, buf, avail);
0093         if (ret < 0)
0094             break;
0095 
0096         buf += ret;
0097     }
0098 
0099     return (count - todo) ? (count - todo) : ret;
0100 }
0101 
0102 static struct dmx_frontend *get_fe(struct dmx_demux *demux, int type)
0103 {
0104     struct list_head *head, *pos;
0105 
0106     head = demux->get_frontends(demux);
0107     if (!head)
0108         return NULL;
0109     list_for_each(pos, head)
0110         if (DMX_FE_ENTRY(pos)->source == type)
0111             return DMX_FE_ENTRY(pos);
0112 
0113     return NULL;
0114 }
0115 
0116 static int dvb_dvr_open(struct inode *inode, struct file *file)
0117 {
0118     struct dvb_device *dvbdev = file->private_data;
0119     struct dmxdev *dmxdev = dvbdev->priv;
0120     struct dmx_frontend *front;
0121     bool need_ringbuffer = false;
0122 
0123     dprintk("%s\n", __func__);
0124 
0125     if (mutex_lock_interruptible(&dmxdev->mutex))
0126         return -ERESTARTSYS;
0127 
0128     if (dmxdev->exit) {
0129         mutex_unlock(&dmxdev->mutex);
0130         return -ENODEV;
0131     }
0132 
0133     dmxdev->may_do_mmap = 0;
0134 
0135     /*
0136      * The logic here is a little tricky due to the ifdef.
0137      *
0138      * The ringbuffer is used for both read and mmap.
0139      *
0140      * It is not needed, however, on two situations:
0141      *  - Write devices (access with O_WRONLY);
0142      *  - For duplex device nodes, opened with O_RDWR.
0143      */
0144 
0145     if ((file->f_flags & O_ACCMODE) == O_RDONLY)
0146         need_ringbuffer = true;
0147     else if ((file->f_flags & O_ACCMODE) == O_RDWR) {
0148         if (!(dmxdev->capabilities & DMXDEV_CAP_DUPLEX)) {
0149 #ifdef CONFIG_DVB_MMAP
0150             dmxdev->may_do_mmap = 1;
0151             need_ringbuffer = true;
0152 #else
0153             mutex_unlock(&dmxdev->mutex);
0154             return -EOPNOTSUPP;
0155 #endif
0156         }
0157     }
0158 
0159     if (need_ringbuffer) {
0160         void *mem;
0161 
0162         if (!dvbdev->readers) {
0163             mutex_unlock(&dmxdev->mutex);
0164             return -EBUSY;
0165         }
0166         mem = vmalloc(DVR_BUFFER_SIZE);
0167         if (!mem) {
0168             mutex_unlock(&dmxdev->mutex);
0169             return -ENOMEM;
0170         }
0171         dvb_ringbuffer_init(&dmxdev->dvr_buffer, mem, DVR_BUFFER_SIZE);
0172         if (dmxdev->may_do_mmap)
0173             dvb_vb2_init(&dmxdev->dvr_vb2_ctx, "dvr",
0174                      file->f_flags & O_NONBLOCK);
0175         dvbdev->readers--;
0176     }
0177 
0178     if ((file->f_flags & O_ACCMODE) == O_WRONLY) {
0179         dmxdev->dvr_orig_fe = dmxdev->demux->frontend;
0180 
0181         if (!dmxdev->demux->write) {
0182             mutex_unlock(&dmxdev->mutex);
0183             return -EOPNOTSUPP;
0184         }
0185 
0186         front = get_fe(dmxdev->demux, DMX_MEMORY_FE);
0187 
0188         if (!front) {
0189             mutex_unlock(&dmxdev->mutex);
0190             return -EINVAL;
0191         }
0192         dmxdev->demux->disconnect_frontend(dmxdev->demux);
0193         dmxdev->demux->connect_frontend(dmxdev->demux, front);
0194     }
0195     dvbdev->users++;
0196     mutex_unlock(&dmxdev->mutex);
0197     return 0;
0198 }
0199 
0200 static int dvb_dvr_release(struct inode *inode, struct file *file)
0201 {
0202     struct dvb_device *dvbdev = file->private_data;
0203     struct dmxdev *dmxdev = dvbdev->priv;
0204 
0205     mutex_lock(&dmxdev->mutex);
0206 
0207     if ((file->f_flags & O_ACCMODE) == O_WRONLY) {
0208         dmxdev->demux->disconnect_frontend(dmxdev->demux);
0209         dmxdev->demux->connect_frontend(dmxdev->demux,
0210                         dmxdev->dvr_orig_fe);
0211     }
0212 
0213     if (((file->f_flags & O_ACCMODE) == O_RDONLY) ||
0214         dmxdev->may_do_mmap) {
0215         if (dmxdev->may_do_mmap) {
0216             if (dvb_vb2_is_streaming(&dmxdev->dvr_vb2_ctx))
0217                 dvb_vb2_stream_off(&dmxdev->dvr_vb2_ctx);
0218             dvb_vb2_release(&dmxdev->dvr_vb2_ctx);
0219         }
0220         dvbdev->readers++;
0221         if (dmxdev->dvr_buffer.data) {
0222             void *mem = dmxdev->dvr_buffer.data;
0223             /*memory barrier*/
0224             mb();
0225             spin_lock_irq(&dmxdev->lock);
0226             dmxdev->dvr_buffer.data = NULL;
0227             spin_unlock_irq(&dmxdev->lock);
0228             vfree(mem);
0229         }
0230     }
0231     /* TODO */
0232     dvbdev->users--;
0233     if (dvbdev->users == 1 && dmxdev->exit == 1) {
0234         mutex_unlock(&dmxdev->mutex);
0235         wake_up(&dvbdev->wait_queue);
0236     } else
0237         mutex_unlock(&dmxdev->mutex);
0238 
0239     return 0;
0240 }
0241 
0242 static ssize_t dvb_dvr_write(struct file *file, const char __user *buf,
0243                  size_t count, loff_t *ppos)
0244 {
0245     struct dvb_device *dvbdev = file->private_data;
0246     struct dmxdev *dmxdev = dvbdev->priv;
0247     int ret;
0248 
0249     if (!dmxdev->demux->write)
0250         return -EOPNOTSUPP;
0251     if ((file->f_flags & O_ACCMODE) != O_WRONLY)
0252         return -EINVAL;
0253     if (mutex_lock_interruptible(&dmxdev->mutex))
0254         return -ERESTARTSYS;
0255 
0256     if (dmxdev->exit) {
0257         mutex_unlock(&dmxdev->mutex);
0258         return -ENODEV;
0259     }
0260     ret = dmxdev->demux->write(dmxdev->demux, buf, count);
0261     mutex_unlock(&dmxdev->mutex);
0262     return ret;
0263 }
0264 
0265 static ssize_t dvb_dvr_read(struct file *file, char __user *buf, size_t count,
0266                 loff_t *ppos)
0267 {
0268     struct dvb_device *dvbdev = file->private_data;
0269     struct dmxdev *dmxdev = dvbdev->priv;
0270 
0271     if (dmxdev->exit)
0272         return -ENODEV;
0273 
0274     return dvb_dmxdev_buffer_read(&dmxdev->dvr_buffer,
0275                       file->f_flags & O_NONBLOCK,
0276                       buf, count, ppos);
0277 }
0278 
0279 static int dvb_dvr_set_buffer_size(struct dmxdev *dmxdev,
0280                       unsigned long size)
0281 {
0282     struct dvb_ringbuffer *buf = &dmxdev->dvr_buffer;
0283     void *newmem;
0284     void *oldmem;
0285 
0286     dprintk("%s\n", __func__);
0287 
0288     if (buf->size == size)
0289         return 0;
0290     if (!size)
0291         return -EINVAL;
0292 
0293     newmem = vmalloc(size);
0294     if (!newmem)
0295         return -ENOMEM;
0296 
0297     oldmem = buf->data;
0298 
0299     spin_lock_irq(&dmxdev->lock);
0300     buf->data = newmem;
0301     buf->size = size;
0302 
0303     /* reset and not flush in case the buffer shrinks */
0304     dvb_ringbuffer_reset(buf);
0305     spin_unlock_irq(&dmxdev->lock);
0306 
0307     vfree(oldmem);
0308 
0309     return 0;
0310 }
0311 
0312 static inline void dvb_dmxdev_filter_state_set(struct dmxdev_filter
0313                            *dmxdevfilter, int state)
0314 {
0315     spin_lock_irq(&dmxdevfilter->dev->lock);
0316     dmxdevfilter->state = state;
0317     spin_unlock_irq(&dmxdevfilter->dev->lock);
0318 }
0319 
0320 static int dvb_dmxdev_set_buffer_size(struct dmxdev_filter *dmxdevfilter,
0321                       unsigned long size)
0322 {
0323     struct dvb_ringbuffer *buf = &dmxdevfilter->buffer;
0324     void *newmem;
0325     void *oldmem;
0326 
0327     if (buf->size == size)
0328         return 0;
0329     if (!size)
0330         return -EINVAL;
0331     if (dmxdevfilter->state >= DMXDEV_STATE_GO)
0332         return -EBUSY;
0333 
0334     newmem = vmalloc(size);
0335     if (!newmem)
0336         return -ENOMEM;
0337 
0338     oldmem = buf->data;
0339 
0340     spin_lock_irq(&dmxdevfilter->dev->lock);
0341     buf->data = newmem;
0342     buf->size = size;
0343 
0344     /* reset and not flush in case the buffer shrinks */
0345     dvb_ringbuffer_reset(buf);
0346     spin_unlock_irq(&dmxdevfilter->dev->lock);
0347 
0348     vfree(oldmem);
0349 
0350     return 0;
0351 }
0352 
0353 static void dvb_dmxdev_filter_timeout(struct timer_list *t)
0354 {
0355     struct dmxdev_filter *dmxdevfilter = from_timer(dmxdevfilter, t, timer);
0356 
0357     dmxdevfilter->buffer.error = -ETIMEDOUT;
0358     spin_lock_irq(&dmxdevfilter->dev->lock);
0359     dmxdevfilter->state = DMXDEV_STATE_TIMEDOUT;
0360     spin_unlock_irq(&dmxdevfilter->dev->lock);
0361     wake_up(&dmxdevfilter->buffer.queue);
0362 }
0363 
0364 static void dvb_dmxdev_filter_timer(struct dmxdev_filter *dmxdevfilter)
0365 {
0366     struct dmx_sct_filter_params *para = &dmxdevfilter->params.sec;
0367 
0368     del_timer(&dmxdevfilter->timer);
0369     if (para->timeout) {
0370         dmxdevfilter->timer.expires =
0371             jiffies + 1 + (HZ / 2 + HZ * para->timeout) / 1000;
0372         add_timer(&dmxdevfilter->timer);
0373     }
0374 }
0375 
0376 static int dvb_dmxdev_section_callback(const u8 *buffer1, size_t buffer1_len,
0377                        const u8 *buffer2, size_t buffer2_len,
0378                        struct dmx_section_filter *filter,
0379                        u32 *buffer_flags)
0380 {
0381     struct dmxdev_filter *dmxdevfilter = filter->priv;
0382     int ret;
0383 
0384     if (!dvb_vb2_is_streaming(&dmxdevfilter->vb2_ctx) &&
0385         dmxdevfilter->buffer.error) {
0386         wake_up(&dmxdevfilter->buffer.queue);
0387         return 0;
0388     }
0389     spin_lock(&dmxdevfilter->dev->lock);
0390     if (dmxdevfilter->state != DMXDEV_STATE_GO) {
0391         spin_unlock(&dmxdevfilter->dev->lock);
0392         return 0;
0393     }
0394     del_timer(&dmxdevfilter->timer);
0395     dprintk("section callback %*ph\n", 6, buffer1);
0396     if (dvb_vb2_is_streaming(&dmxdevfilter->vb2_ctx)) {
0397         ret = dvb_vb2_fill_buffer(&dmxdevfilter->vb2_ctx,
0398                       buffer1, buffer1_len,
0399                       buffer_flags);
0400         if (ret == buffer1_len)
0401             ret = dvb_vb2_fill_buffer(&dmxdevfilter->vb2_ctx,
0402                           buffer2, buffer2_len,
0403                           buffer_flags);
0404     } else {
0405         ret = dvb_dmxdev_buffer_write(&dmxdevfilter->buffer,
0406                           buffer1, buffer1_len);
0407         if (ret == buffer1_len) {
0408             ret = dvb_dmxdev_buffer_write(&dmxdevfilter->buffer,
0409                               buffer2, buffer2_len);
0410         }
0411     }
0412     if (ret < 0)
0413         dmxdevfilter->buffer.error = ret;
0414     if (dmxdevfilter->params.sec.flags & DMX_ONESHOT)
0415         dmxdevfilter->state = DMXDEV_STATE_DONE;
0416     spin_unlock(&dmxdevfilter->dev->lock);
0417     wake_up(&dmxdevfilter->buffer.queue);
0418     return 0;
0419 }
0420 
0421 static int dvb_dmxdev_ts_callback(const u8 *buffer1, size_t buffer1_len,
0422                   const u8 *buffer2, size_t buffer2_len,
0423                   struct dmx_ts_feed *feed,
0424                   u32 *buffer_flags)
0425 {
0426     struct dmxdev_filter *dmxdevfilter = feed->priv;
0427     struct dvb_ringbuffer *buffer;
0428 #ifdef CONFIG_DVB_MMAP
0429     struct dvb_vb2_ctx *ctx;
0430 #endif
0431     int ret;
0432 
0433     spin_lock(&dmxdevfilter->dev->lock);
0434     if (dmxdevfilter->params.pes.output == DMX_OUT_DECODER) {
0435         spin_unlock(&dmxdevfilter->dev->lock);
0436         return 0;
0437     }
0438 
0439     if (dmxdevfilter->params.pes.output == DMX_OUT_TAP ||
0440         dmxdevfilter->params.pes.output == DMX_OUT_TSDEMUX_TAP) {
0441         buffer = &dmxdevfilter->buffer;
0442 #ifdef CONFIG_DVB_MMAP
0443         ctx = &dmxdevfilter->vb2_ctx;
0444 #endif
0445     } else {
0446         buffer = &dmxdevfilter->dev->dvr_buffer;
0447 #ifdef CONFIG_DVB_MMAP
0448         ctx = &dmxdevfilter->dev->dvr_vb2_ctx;
0449 #endif
0450     }
0451 
0452     if (dvb_vb2_is_streaming(ctx)) {
0453         ret = dvb_vb2_fill_buffer(ctx, buffer1, buffer1_len,
0454                       buffer_flags);
0455         if (ret == buffer1_len)
0456             ret = dvb_vb2_fill_buffer(ctx, buffer2, buffer2_len,
0457                           buffer_flags);
0458     } else {
0459         if (buffer->error) {
0460             spin_unlock(&dmxdevfilter->dev->lock);
0461             wake_up(&buffer->queue);
0462             return 0;
0463         }
0464         ret = dvb_dmxdev_buffer_write(buffer, buffer1, buffer1_len);
0465         if (ret == buffer1_len)
0466             ret = dvb_dmxdev_buffer_write(buffer,
0467                               buffer2, buffer2_len);
0468     }
0469     if (ret < 0)
0470         buffer->error = ret;
0471     spin_unlock(&dmxdevfilter->dev->lock);
0472     wake_up(&buffer->queue);
0473     return 0;
0474 }
0475 
0476 /* stop feed but only mark the specified filter as stopped (state set) */
0477 static int dvb_dmxdev_feed_stop(struct dmxdev_filter *dmxdevfilter)
0478 {
0479     struct dmxdev_feed *feed;
0480 
0481     dvb_dmxdev_filter_state_set(dmxdevfilter, DMXDEV_STATE_SET);
0482 
0483     switch (dmxdevfilter->type) {
0484     case DMXDEV_TYPE_SEC:
0485         del_timer(&dmxdevfilter->timer);
0486         dmxdevfilter->feed.sec->stop_filtering(dmxdevfilter->feed.sec);
0487         break;
0488     case DMXDEV_TYPE_PES:
0489         list_for_each_entry(feed, &dmxdevfilter->feed.ts, next)
0490             feed->ts->stop_filtering(feed->ts);
0491         break;
0492     default:
0493         return -EINVAL;
0494     }
0495     return 0;
0496 }
0497 
0498 /* start feed associated with the specified filter */
0499 static int dvb_dmxdev_feed_start(struct dmxdev_filter *filter)
0500 {
0501     struct dmxdev_feed *feed;
0502     int ret;
0503 
0504     dvb_dmxdev_filter_state_set(filter, DMXDEV_STATE_GO);
0505 
0506     switch (filter->type) {
0507     case DMXDEV_TYPE_SEC:
0508         return filter->feed.sec->start_filtering(filter->feed.sec);
0509     case DMXDEV_TYPE_PES:
0510         list_for_each_entry(feed, &filter->feed.ts, next) {
0511             ret = feed->ts->start_filtering(feed->ts);
0512             if (ret < 0) {
0513                 dvb_dmxdev_feed_stop(filter);
0514                 return ret;
0515             }
0516         }
0517         break;
0518     default:
0519         return -EINVAL;
0520     }
0521 
0522     return 0;
0523 }
0524 
0525 /* restart section feed if it has filters left associated with it,
0526    otherwise release the feed */
0527 static int dvb_dmxdev_feed_restart(struct dmxdev_filter *filter)
0528 {
0529     int i;
0530     struct dmxdev *dmxdev = filter->dev;
0531     u16 pid = filter->params.sec.pid;
0532 
0533     for (i = 0; i < dmxdev->filternum; i++)
0534         if (dmxdev->filter[i].state >= DMXDEV_STATE_GO &&
0535             dmxdev->filter[i].type == DMXDEV_TYPE_SEC &&
0536             dmxdev->filter[i].params.sec.pid == pid) {
0537             dvb_dmxdev_feed_start(&dmxdev->filter[i]);
0538             return 0;
0539         }
0540 
0541     filter->dev->demux->release_section_feed(dmxdev->demux,
0542                          filter->feed.sec);
0543 
0544     return 0;
0545 }
0546 
0547 static int dvb_dmxdev_filter_stop(struct dmxdev_filter *dmxdevfilter)
0548 {
0549     struct dmxdev_feed *feed;
0550     struct dmx_demux *demux;
0551 
0552     if (dmxdevfilter->state < DMXDEV_STATE_GO)
0553         return 0;
0554 
0555     switch (dmxdevfilter->type) {
0556     case DMXDEV_TYPE_SEC:
0557         if (!dmxdevfilter->feed.sec)
0558             break;
0559         dvb_dmxdev_feed_stop(dmxdevfilter);
0560         if (dmxdevfilter->filter.sec)
0561             dmxdevfilter->feed.sec->
0562                 release_filter(dmxdevfilter->feed.sec,
0563                        dmxdevfilter->filter.sec);
0564         dvb_dmxdev_feed_restart(dmxdevfilter);
0565         dmxdevfilter->feed.sec = NULL;
0566         break;
0567     case DMXDEV_TYPE_PES:
0568         dvb_dmxdev_feed_stop(dmxdevfilter);
0569         demux = dmxdevfilter->dev->demux;
0570         list_for_each_entry(feed, &dmxdevfilter->feed.ts, next) {
0571             demux->release_ts_feed(demux, feed->ts);
0572             feed->ts = NULL;
0573         }
0574         break;
0575     default:
0576         if (dmxdevfilter->state == DMXDEV_STATE_ALLOCATED)
0577             return 0;
0578         return -EINVAL;
0579     }
0580 
0581     dvb_ringbuffer_flush(&dmxdevfilter->buffer);
0582     return 0;
0583 }
0584 
0585 static void dvb_dmxdev_delete_pids(struct dmxdev_filter *dmxdevfilter)
0586 {
0587     struct dmxdev_feed *feed, *tmp;
0588 
0589     /* delete all PIDs */
0590     list_for_each_entry_safe(feed, tmp, &dmxdevfilter->feed.ts, next) {
0591         list_del(&feed->next);
0592         kfree(feed);
0593     }
0594 
0595     BUG_ON(!list_empty(&dmxdevfilter->feed.ts));
0596 }
0597 
0598 static inline int dvb_dmxdev_filter_reset(struct dmxdev_filter *dmxdevfilter)
0599 {
0600     if (dmxdevfilter->state < DMXDEV_STATE_SET)
0601         return 0;
0602 
0603     if (dmxdevfilter->type == DMXDEV_TYPE_PES)
0604         dvb_dmxdev_delete_pids(dmxdevfilter);
0605 
0606     dmxdevfilter->type = DMXDEV_TYPE_NONE;
0607     dvb_dmxdev_filter_state_set(dmxdevfilter, DMXDEV_STATE_ALLOCATED);
0608     return 0;
0609 }
0610 
0611 static int dvb_dmxdev_start_feed(struct dmxdev *dmxdev,
0612                  struct dmxdev_filter *filter,
0613                  struct dmxdev_feed *feed)
0614 {
0615     ktime_t timeout = ktime_set(0, 0);
0616     struct dmx_pes_filter_params *para = &filter->params.pes;
0617     enum dmx_output otype;
0618     int ret;
0619     int ts_type;
0620     enum dmx_ts_pes ts_pes;
0621     struct dmx_ts_feed *tsfeed;
0622 
0623     feed->ts = NULL;
0624     otype = para->output;
0625 
0626     ts_pes = para->pes_type;
0627 
0628     if (ts_pes < DMX_PES_OTHER)
0629         ts_type = TS_DECODER;
0630     else
0631         ts_type = 0;
0632 
0633     if (otype == DMX_OUT_TS_TAP)
0634         ts_type |= TS_PACKET;
0635     else if (otype == DMX_OUT_TSDEMUX_TAP)
0636         ts_type |= TS_PACKET | TS_DEMUX;
0637     else if (otype == DMX_OUT_TAP)
0638         ts_type |= TS_PACKET | TS_DEMUX | TS_PAYLOAD_ONLY;
0639 
0640     ret = dmxdev->demux->allocate_ts_feed(dmxdev->demux, &feed->ts,
0641                           dvb_dmxdev_ts_callback);
0642     if (ret < 0)
0643         return ret;
0644 
0645     tsfeed = feed->ts;
0646     tsfeed->priv = filter;
0647 
0648     ret = tsfeed->set(tsfeed, feed->pid, ts_type, ts_pes, timeout);
0649     if (ret < 0) {
0650         dmxdev->demux->release_ts_feed(dmxdev->demux, tsfeed);
0651         return ret;
0652     }
0653 
0654     ret = tsfeed->start_filtering(tsfeed);
0655     if (ret < 0) {
0656         dmxdev->demux->release_ts_feed(dmxdev->demux, tsfeed);
0657         return ret;
0658     }
0659 
0660     return 0;
0661 }
0662 
0663 static int dvb_dmxdev_filter_start(struct dmxdev_filter *filter)
0664 {
0665     struct dmxdev *dmxdev = filter->dev;
0666     struct dmxdev_feed *feed;
0667     void *mem;
0668     int ret, i;
0669 
0670     if (filter->state < DMXDEV_STATE_SET)
0671         return -EINVAL;
0672 
0673     if (filter->state >= DMXDEV_STATE_GO)
0674         dvb_dmxdev_filter_stop(filter);
0675 
0676     if (!filter->buffer.data) {
0677         mem = vmalloc(filter->buffer.size);
0678         if (!mem)
0679             return -ENOMEM;
0680         spin_lock_irq(&filter->dev->lock);
0681         filter->buffer.data = mem;
0682         spin_unlock_irq(&filter->dev->lock);
0683     }
0684 
0685     dvb_ringbuffer_flush(&filter->buffer);
0686 
0687     switch (filter->type) {
0688     case DMXDEV_TYPE_SEC:
0689     {
0690         struct dmx_sct_filter_params *para = &filter->params.sec;
0691         struct dmx_section_filter **secfilter = &filter->filter.sec;
0692         struct dmx_section_feed **secfeed = &filter->feed.sec;
0693 
0694         *secfilter = NULL;
0695         *secfeed = NULL;
0696 
0697 
0698         /* find active filter/feed with same PID */
0699         for (i = 0; i < dmxdev->filternum; i++) {
0700             if (dmxdev->filter[i].state >= DMXDEV_STATE_GO &&
0701                 dmxdev->filter[i].type == DMXDEV_TYPE_SEC &&
0702                 dmxdev->filter[i].params.sec.pid == para->pid) {
0703                 *secfeed = dmxdev->filter[i].feed.sec;
0704                 break;
0705             }
0706         }
0707 
0708         /* if no feed found, try to allocate new one */
0709         if (!*secfeed) {
0710             ret = dmxdev->demux->allocate_section_feed(dmxdev->demux,
0711                                    secfeed,
0712                                    dvb_dmxdev_section_callback);
0713             if (!*secfeed) {
0714                 pr_err("DVB (%s): could not alloc feed\n",
0715                        __func__);
0716                 return ret;
0717             }
0718 
0719             ret = (*secfeed)->set(*secfeed, para->pid,
0720                           (para->flags & DMX_CHECK_CRC) ? 1 : 0);
0721             if (ret < 0) {
0722                 pr_err("DVB (%s): could not set feed\n",
0723                        __func__);
0724                 dvb_dmxdev_feed_restart(filter);
0725                 return ret;
0726             }
0727         } else {
0728             dvb_dmxdev_feed_stop(filter);
0729         }
0730 
0731         ret = (*secfeed)->allocate_filter(*secfeed, secfilter);
0732         if (ret < 0) {
0733             dvb_dmxdev_feed_restart(filter);
0734             filter->feed.sec->start_filtering(*secfeed);
0735             dprintk("could not get filter\n");
0736             return ret;
0737         }
0738 
0739         (*secfilter)->priv = filter;
0740 
0741         memcpy(&((*secfilter)->filter_value[3]),
0742                &(para->filter.filter[1]), DMX_FILTER_SIZE - 1);
0743         memcpy(&(*secfilter)->filter_mask[3],
0744                &para->filter.mask[1], DMX_FILTER_SIZE - 1);
0745         memcpy(&(*secfilter)->filter_mode[3],
0746                &para->filter.mode[1], DMX_FILTER_SIZE - 1);
0747 
0748         (*secfilter)->filter_value[0] = para->filter.filter[0];
0749         (*secfilter)->filter_mask[0] = para->filter.mask[0];
0750         (*secfilter)->filter_mode[0] = para->filter.mode[0];
0751         (*secfilter)->filter_mask[1] = 0;
0752         (*secfilter)->filter_mask[2] = 0;
0753 
0754         filter->todo = 0;
0755 
0756         ret = filter->feed.sec->start_filtering(filter->feed.sec);
0757         if (ret < 0)
0758             return ret;
0759 
0760         dvb_dmxdev_filter_timer(filter);
0761         break;
0762     }
0763     case DMXDEV_TYPE_PES:
0764         list_for_each_entry(feed, &filter->feed.ts, next) {
0765             ret = dvb_dmxdev_start_feed(dmxdev, filter, feed);
0766             if (ret < 0) {
0767                 dvb_dmxdev_filter_stop(filter);
0768                 return ret;
0769             }
0770         }
0771         break;
0772     default:
0773         return -EINVAL;
0774     }
0775 
0776     dvb_dmxdev_filter_state_set(filter, DMXDEV_STATE_GO);
0777     return 0;
0778 }
0779 
0780 static int dvb_demux_open(struct inode *inode, struct file *file)
0781 {
0782     struct dvb_device *dvbdev = file->private_data;
0783     struct dmxdev *dmxdev = dvbdev->priv;
0784     int i;
0785     struct dmxdev_filter *dmxdevfilter;
0786 
0787     if (!dmxdev->filter)
0788         return -EINVAL;
0789 
0790     if (mutex_lock_interruptible(&dmxdev->mutex))
0791         return -ERESTARTSYS;
0792 
0793     for (i = 0; i < dmxdev->filternum; i++)
0794         if (dmxdev->filter[i].state == DMXDEV_STATE_FREE)
0795             break;
0796 
0797     if (i == dmxdev->filternum) {
0798         mutex_unlock(&dmxdev->mutex);
0799         return -EMFILE;
0800     }
0801 
0802     dmxdevfilter = &dmxdev->filter[i];
0803     mutex_init(&dmxdevfilter->mutex);
0804     file->private_data = dmxdevfilter;
0805 
0806 #ifdef CONFIG_DVB_MMAP
0807     dmxdev->may_do_mmap = 1;
0808 #else
0809     dmxdev->may_do_mmap = 0;
0810 #endif
0811 
0812     dvb_ringbuffer_init(&dmxdevfilter->buffer, NULL, 8192);
0813     dvb_vb2_init(&dmxdevfilter->vb2_ctx, "demux_filter",
0814              file->f_flags & O_NONBLOCK);
0815     dmxdevfilter->type = DMXDEV_TYPE_NONE;
0816     dvb_dmxdev_filter_state_set(dmxdevfilter, DMXDEV_STATE_ALLOCATED);
0817     timer_setup(&dmxdevfilter->timer, dvb_dmxdev_filter_timeout, 0);
0818 
0819     dvbdev->users++;
0820 
0821     mutex_unlock(&dmxdev->mutex);
0822     return 0;
0823 }
0824 
0825 static int dvb_dmxdev_filter_free(struct dmxdev *dmxdev,
0826                   struct dmxdev_filter *dmxdevfilter)
0827 {
0828     mutex_lock(&dmxdev->mutex);
0829     mutex_lock(&dmxdevfilter->mutex);
0830     if (dvb_vb2_is_streaming(&dmxdevfilter->vb2_ctx))
0831         dvb_vb2_stream_off(&dmxdevfilter->vb2_ctx);
0832     dvb_vb2_release(&dmxdevfilter->vb2_ctx);
0833 
0834 
0835     dvb_dmxdev_filter_stop(dmxdevfilter);
0836     dvb_dmxdev_filter_reset(dmxdevfilter);
0837 
0838     if (dmxdevfilter->buffer.data) {
0839         void *mem = dmxdevfilter->buffer.data;
0840 
0841         spin_lock_irq(&dmxdev->lock);
0842         dmxdevfilter->buffer.data = NULL;
0843         spin_unlock_irq(&dmxdev->lock);
0844         vfree(mem);
0845     }
0846 
0847     dvb_dmxdev_filter_state_set(dmxdevfilter, DMXDEV_STATE_FREE);
0848     wake_up(&dmxdevfilter->buffer.queue);
0849     mutex_unlock(&dmxdevfilter->mutex);
0850     mutex_unlock(&dmxdev->mutex);
0851     return 0;
0852 }
0853 
0854 static inline void invert_mode(struct dmx_filter *filter)
0855 {
0856     int i;
0857 
0858     for (i = 0; i < DMX_FILTER_SIZE; i++)
0859         filter->mode[i] ^= 0xff;
0860 }
0861 
0862 static int dvb_dmxdev_add_pid(struct dmxdev *dmxdev,
0863                   struct dmxdev_filter *filter, u16 pid)
0864 {
0865     struct dmxdev_feed *feed;
0866 
0867     if ((filter->type != DMXDEV_TYPE_PES) ||
0868         (filter->state < DMXDEV_STATE_SET))
0869         return -EINVAL;
0870 
0871     /* only TS packet filters may have multiple PIDs */
0872     if ((filter->params.pes.output != DMX_OUT_TSDEMUX_TAP) &&
0873         (!list_empty(&filter->feed.ts)))
0874         return -EINVAL;
0875 
0876     feed = kzalloc(sizeof(struct dmxdev_feed), GFP_KERNEL);
0877     if (feed == NULL)
0878         return -ENOMEM;
0879 
0880     feed->pid = pid;
0881     list_add(&feed->next, &filter->feed.ts);
0882 
0883     if (filter->state >= DMXDEV_STATE_GO)
0884         return dvb_dmxdev_start_feed(dmxdev, filter, feed);
0885 
0886     return 0;
0887 }
0888 
0889 static int dvb_dmxdev_remove_pid(struct dmxdev *dmxdev,
0890                   struct dmxdev_filter *filter, u16 pid)
0891 {
0892     struct dmxdev_feed *feed, *tmp;
0893 
0894     if ((filter->type != DMXDEV_TYPE_PES) ||
0895         (filter->state < DMXDEV_STATE_SET))
0896         return -EINVAL;
0897 
0898     list_for_each_entry_safe(feed, tmp, &filter->feed.ts, next) {
0899         if ((feed->pid == pid) && (feed->ts != NULL)) {
0900             feed->ts->stop_filtering(feed->ts);
0901             filter->dev->demux->release_ts_feed(filter->dev->demux,
0902                                 feed->ts);
0903             list_del(&feed->next);
0904             kfree(feed);
0905         }
0906     }
0907 
0908     return 0;
0909 }
0910 
0911 static int dvb_dmxdev_filter_set(struct dmxdev *dmxdev,
0912                  struct dmxdev_filter *dmxdevfilter,
0913                  struct dmx_sct_filter_params *params)
0914 {
0915     dprintk("%s: PID=0x%04x, flags=%02x, timeout=%d\n",
0916         __func__, params->pid, params->flags, params->timeout);
0917 
0918     dvb_dmxdev_filter_stop(dmxdevfilter);
0919 
0920     dmxdevfilter->type = DMXDEV_TYPE_SEC;
0921     memcpy(&dmxdevfilter->params.sec,
0922            params, sizeof(struct dmx_sct_filter_params));
0923     invert_mode(&dmxdevfilter->params.sec.filter);
0924     dvb_dmxdev_filter_state_set(dmxdevfilter, DMXDEV_STATE_SET);
0925 
0926     if (params->flags & DMX_IMMEDIATE_START)
0927         return dvb_dmxdev_filter_start(dmxdevfilter);
0928 
0929     return 0;
0930 }
0931 
0932 static int dvb_dmxdev_pes_filter_set(struct dmxdev *dmxdev,
0933                      struct dmxdev_filter *dmxdevfilter,
0934                      struct dmx_pes_filter_params *params)
0935 {
0936     int ret;
0937 
0938     dvb_dmxdev_filter_stop(dmxdevfilter);
0939     dvb_dmxdev_filter_reset(dmxdevfilter);
0940 
0941     if ((unsigned int)params->pes_type > DMX_PES_OTHER)
0942         return -EINVAL;
0943 
0944     dmxdevfilter->type = DMXDEV_TYPE_PES;
0945     memcpy(&dmxdevfilter->params, params,
0946            sizeof(struct dmx_pes_filter_params));
0947     INIT_LIST_HEAD(&dmxdevfilter->feed.ts);
0948 
0949     dvb_dmxdev_filter_state_set(dmxdevfilter, DMXDEV_STATE_SET);
0950 
0951     ret = dvb_dmxdev_add_pid(dmxdev, dmxdevfilter,
0952                  dmxdevfilter->params.pes.pid);
0953     if (ret < 0)
0954         return ret;
0955 
0956     if (params->flags & DMX_IMMEDIATE_START)
0957         return dvb_dmxdev_filter_start(dmxdevfilter);
0958 
0959     return 0;
0960 }
0961 
0962 static ssize_t dvb_dmxdev_read_sec(struct dmxdev_filter *dfil,
0963                    struct file *file, char __user *buf,
0964                    size_t count, loff_t *ppos)
0965 {
0966     int result, hcount;
0967     int done = 0;
0968 
0969     if (dfil->todo <= 0) {
0970         hcount = 3 + dfil->todo;
0971         if (hcount > count)
0972             hcount = count;
0973         result = dvb_dmxdev_buffer_read(&dfil->buffer,
0974                         file->f_flags & O_NONBLOCK,
0975                         buf, hcount, ppos);
0976         if (result < 0) {
0977             dfil->todo = 0;
0978             return result;
0979         }
0980         if (copy_from_user(dfil->secheader - dfil->todo, buf, result))
0981             return -EFAULT;
0982         buf += result;
0983         done = result;
0984         count -= result;
0985         dfil->todo -= result;
0986         if (dfil->todo > -3)
0987             return done;
0988         dfil->todo = ((dfil->secheader[1] << 8) | dfil->secheader[2]) & 0xfff;
0989         if (!count)
0990             return done;
0991     }
0992     if (count > dfil->todo)
0993         count = dfil->todo;
0994     result = dvb_dmxdev_buffer_read(&dfil->buffer,
0995                     file->f_flags & O_NONBLOCK,
0996                     buf, count, ppos);
0997     if (result < 0)
0998         return result;
0999     dfil->todo -= result;
1000     return (result + done);
1001 }
1002 
1003 static ssize_t
1004 dvb_demux_read(struct file *file, char __user *buf, size_t count,
1005            loff_t *ppos)
1006 {
1007     struct dmxdev_filter *dmxdevfilter = file->private_data;
1008     int ret;
1009 
1010     if (mutex_lock_interruptible(&dmxdevfilter->mutex))
1011         return -ERESTARTSYS;
1012 
1013     if (dmxdevfilter->type == DMXDEV_TYPE_SEC)
1014         ret = dvb_dmxdev_read_sec(dmxdevfilter, file, buf, count, ppos);
1015     else
1016         ret = dvb_dmxdev_buffer_read(&dmxdevfilter->buffer,
1017                          file->f_flags & O_NONBLOCK,
1018                          buf, count, ppos);
1019 
1020     mutex_unlock(&dmxdevfilter->mutex);
1021     return ret;
1022 }
1023 
1024 static int dvb_demux_do_ioctl(struct file *file,
1025                   unsigned int cmd, void *parg)
1026 {
1027     struct dmxdev_filter *dmxdevfilter = file->private_data;
1028     struct dmxdev *dmxdev = dmxdevfilter->dev;
1029     unsigned long arg = (unsigned long)parg;
1030     int ret = 0;
1031 
1032     if (mutex_lock_interruptible(&dmxdev->mutex))
1033         return -ERESTARTSYS;
1034 
1035     switch (cmd) {
1036     case DMX_START:
1037         if (mutex_lock_interruptible(&dmxdevfilter->mutex)) {
1038             mutex_unlock(&dmxdev->mutex);
1039             return -ERESTARTSYS;
1040         }
1041         if (dmxdevfilter->state < DMXDEV_STATE_SET)
1042             ret = -EINVAL;
1043         else
1044             ret = dvb_dmxdev_filter_start(dmxdevfilter);
1045         mutex_unlock(&dmxdevfilter->mutex);
1046         break;
1047 
1048     case DMX_STOP:
1049         if (mutex_lock_interruptible(&dmxdevfilter->mutex)) {
1050             mutex_unlock(&dmxdev->mutex);
1051             return -ERESTARTSYS;
1052         }
1053         ret = dvb_dmxdev_filter_stop(dmxdevfilter);
1054         mutex_unlock(&dmxdevfilter->mutex);
1055         break;
1056 
1057     case DMX_SET_FILTER:
1058         if (mutex_lock_interruptible(&dmxdevfilter->mutex)) {
1059             mutex_unlock(&dmxdev->mutex);
1060             return -ERESTARTSYS;
1061         }
1062         ret = dvb_dmxdev_filter_set(dmxdev, dmxdevfilter, parg);
1063         mutex_unlock(&dmxdevfilter->mutex);
1064         break;
1065 
1066     case DMX_SET_PES_FILTER:
1067         if (mutex_lock_interruptible(&dmxdevfilter->mutex)) {
1068             mutex_unlock(&dmxdev->mutex);
1069             return -ERESTARTSYS;
1070         }
1071         ret = dvb_dmxdev_pes_filter_set(dmxdev, dmxdevfilter, parg);
1072         mutex_unlock(&dmxdevfilter->mutex);
1073         break;
1074 
1075     case DMX_SET_BUFFER_SIZE:
1076         if (mutex_lock_interruptible(&dmxdevfilter->mutex)) {
1077             mutex_unlock(&dmxdev->mutex);
1078             return -ERESTARTSYS;
1079         }
1080         ret = dvb_dmxdev_set_buffer_size(dmxdevfilter, arg);
1081         mutex_unlock(&dmxdevfilter->mutex);
1082         break;
1083 
1084     case DMX_GET_PES_PIDS:
1085         if (!dmxdev->demux->get_pes_pids) {
1086             ret = -EINVAL;
1087             break;
1088         }
1089         dmxdev->demux->get_pes_pids(dmxdev->demux, parg);
1090         break;
1091 
1092     case DMX_GET_STC:
1093         if (!dmxdev->demux->get_stc) {
1094             ret = -EINVAL;
1095             break;
1096         }
1097         ret = dmxdev->demux->get_stc(dmxdev->demux,
1098                          ((struct dmx_stc *)parg)->num,
1099                          &((struct dmx_stc *)parg)->stc,
1100                          &((struct dmx_stc *)parg)->base);
1101         break;
1102 
1103     case DMX_ADD_PID:
1104         if (mutex_lock_interruptible(&dmxdevfilter->mutex)) {
1105             ret = -ERESTARTSYS;
1106             break;
1107         }
1108         ret = dvb_dmxdev_add_pid(dmxdev, dmxdevfilter, *(u16 *)parg);
1109         mutex_unlock(&dmxdevfilter->mutex);
1110         break;
1111 
1112     case DMX_REMOVE_PID:
1113         if (mutex_lock_interruptible(&dmxdevfilter->mutex)) {
1114             ret = -ERESTARTSYS;
1115             break;
1116         }
1117         ret = dvb_dmxdev_remove_pid(dmxdev, dmxdevfilter, *(u16 *)parg);
1118         mutex_unlock(&dmxdevfilter->mutex);
1119         break;
1120 
1121 #ifdef CONFIG_DVB_MMAP
1122     case DMX_REQBUFS:
1123         if (mutex_lock_interruptible(&dmxdevfilter->mutex)) {
1124             mutex_unlock(&dmxdev->mutex);
1125             return -ERESTARTSYS;
1126         }
1127         ret = dvb_vb2_reqbufs(&dmxdevfilter->vb2_ctx, parg);
1128         mutex_unlock(&dmxdevfilter->mutex);
1129         break;
1130 
1131     case DMX_QUERYBUF:
1132         if (mutex_lock_interruptible(&dmxdevfilter->mutex)) {
1133             mutex_unlock(&dmxdev->mutex);
1134             return -ERESTARTSYS;
1135         }
1136         ret = dvb_vb2_querybuf(&dmxdevfilter->vb2_ctx, parg);
1137         mutex_unlock(&dmxdevfilter->mutex);
1138         break;
1139 
1140     case DMX_EXPBUF:
1141         if (mutex_lock_interruptible(&dmxdevfilter->mutex)) {
1142             mutex_unlock(&dmxdev->mutex);
1143             return -ERESTARTSYS;
1144         }
1145         ret = dvb_vb2_expbuf(&dmxdevfilter->vb2_ctx, parg);
1146         mutex_unlock(&dmxdevfilter->mutex);
1147         break;
1148 
1149     case DMX_QBUF:
1150         if (mutex_lock_interruptible(&dmxdevfilter->mutex)) {
1151             mutex_unlock(&dmxdev->mutex);
1152             return -ERESTARTSYS;
1153         }
1154         ret = dvb_vb2_qbuf(&dmxdevfilter->vb2_ctx, parg);
1155         if (ret == 0 && !dvb_vb2_is_streaming(&dmxdevfilter->vb2_ctx))
1156             ret = dvb_vb2_stream_on(&dmxdevfilter->vb2_ctx);
1157         mutex_unlock(&dmxdevfilter->mutex);
1158         break;
1159 
1160     case DMX_DQBUF:
1161         if (mutex_lock_interruptible(&dmxdevfilter->mutex)) {
1162             mutex_unlock(&dmxdev->mutex);
1163             return -ERESTARTSYS;
1164         }
1165         ret = dvb_vb2_dqbuf(&dmxdevfilter->vb2_ctx, parg);
1166         mutex_unlock(&dmxdevfilter->mutex);
1167         break;
1168 #endif
1169     default:
1170         ret = -ENOTTY;
1171         break;
1172     }
1173     mutex_unlock(&dmxdev->mutex);
1174     return ret;
1175 }
1176 
1177 static long dvb_demux_ioctl(struct file *file, unsigned int cmd,
1178                 unsigned long arg)
1179 {
1180     return dvb_usercopy(file, cmd, arg, dvb_demux_do_ioctl);
1181 }
1182 
1183 static __poll_t dvb_demux_poll(struct file *file, poll_table *wait)
1184 {
1185     struct dmxdev_filter *dmxdevfilter = file->private_data;
1186     __poll_t mask = 0;
1187 
1188     poll_wait(file, &dmxdevfilter->buffer.queue, wait);
1189 
1190     if ((!dmxdevfilter) || dmxdevfilter->dev->exit)
1191         return EPOLLERR;
1192     if (dvb_vb2_is_streaming(&dmxdevfilter->vb2_ctx))
1193         return dvb_vb2_poll(&dmxdevfilter->vb2_ctx, file, wait);
1194 
1195     if (dmxdevfilter->state != DMXDEV_STATE_GO &&
1196         dmxdevfilter->state != DMXDEV_STATE_DONE &&
1197         dmxdevfilter->state != DMXDEV_STATE_TIMEDOUT)
1198         return 0;
1199 
1200     if (dmxdevfilter->buffer.error)
1201         mask |= (EPOLLIN | EPOLLRDNORM | EPOLLPRI | EPOLLERR);
1202 
1203     if (!dvb_ringbuffer_empty(&dmxdevfilter->buffer))
1204         mask |= (EPOLLIN | EPOLLRDNORM | EPOLLPRI);
1205 
1206     return mask;
1207 }
1208 
1209 #ifdef CONFIG_DVB_MMAP
1210 static int dvb_demux_mmap(struct file *file, struct vm_area_struct *vma)
1211 {
1212     struct dmxdev_filter *dmxdevfilter = file->private_data;
1213     struct dmxdev *dmxdev = dmxdevfilter->dev;
1214     int ret;
1215 
1216     if (!dmxdev->may_do_mmap)
1217         return -ENOTTY;
1218 
1219     if (mutex_lock_interruptible(&dmxdev->mutex))
1220         return -ERESTARTSYS;
1221 
1222     if (mutex_lock_interruptible(&dmxdevfilter->mutex)) {
1223         mutex_unlock(&dmxdev->mutex);
1224         return -ERESTARTSYS;
1225     }
1226     ret = dvb_vb2_mmap(&dmxdevfilter->vb2_ctx, vma);
1227 
1228     mutex_unlock(&dmxdevfilter->mutex);
1229     mutex_unlock(&dmxdev->mutex);
1230 
1231     return ret;
1232 }
1233 #endif
1234 
1235 static int dvb_demux_release(struct inode *inode, struct file *file)
1236 {
1237     struct dmxdev_filter *dmxdevfilter = file->private_data;
1238     struct dmxdev *dmxdev = dmxdevfilter->dev;
1239     int ret;
1240 
1241     ret = dvb_dmxdev_filter_free(dmxdev, dmxdevfilter);
1242 
1243     mutex_lock(&dmxdev->mutex);
1244     dmxdev->dvbdev->users--;
1245     if (dmxdev->dvbdev->users == 1 && dmxdev->exit == 1) {
1246         mutex_unlock(&dmxdev->mutex);
1247         wake_up(&dmxdev->dvbdev->wait_queue);
1248     } else
1249         mutex_unlock(&dmxdev->mutex);
1250 
1251     return ret;
1252 }
1253 
1254 static const struct file_operations dvb_demux_fops = {
1255     .owner = THIS_MODULE,
1256     .read = dvb_demux_read,
1257     .unlocked_ioctl = dvb_demux_ioctl,
1258     .compat_ioctl = dvb_demux_ioctl,
1259     .open = dvb_demux_open,
1260     .release = dvb_demux_release,
1261     .poll = dvb_demux_poll,
1262     .llseek = default_llseek,
1263 #ifdef CONFIG_DVB_MMAP
1264     .mmap = dvb_demux_mmap,
1265 #endif
1266 };
1267 
1268 static const struct dvb_device dvbdev_demux = {
1269     .priv = NULL,
1270     .users = 1,
1271     .writers = 1,
1272 #if defined(CONFIG_MEDIA_CONTROLLER_DVB)
1273     .name = "dvb-demux",
1274 #endif
1275     .fops = &dvb_demux_fops
1276 };
1277 
1278 static int dvb_dvr_do_ioctl(struct file *file,
1279                 unsigned int cmd, void *parg)
1280 {
1281     struct dvb_device *dvbdev = file->private_data;
1282     struct dmxdev *dmxdev = dvbdev->priv;
1283     unsigned long arg = (unsigned long)parg;
1284     int ret;
1285 
1286     if (mutex_lock_interruptible(&dmxdev->mutex))
1287         return -ERESTARTSYS;
1288 
1289     switch (cmd) {
1290     case DMX_SET_BUFFER_SIZE:
1291         ret = dvb_dvr_set_buffer_size(dmxdev, arg);
1292         break;
1293 
1294 #ifdef CONFIG_DVB_MMAP
1295     case DMX_REQBUFS:
1296         ret = dvb_vb2_reqbufs(&dmxdev->dvr_vb2_ctx, parg);
1297         break;
1298 
1299     case DMX_QUERYBUF:
1300         ret = dvb_vb2_querybuf(&dmxdev->dvr_vb2_ctx, parg);
1301         break;
1302 
1303     case DMX_EXPBUF:
1304         ret = dvb_vb2_expbuf(&dmxdev->dvr_vb2_ctx, parg);
1305         break;
1306 
1307     case DMX_QBUF:
1308         ret = dvb_vb2_qbuf(&dmxdev->dvr_vb2_ctx, parg);
1309         if (ret == 0 && !dvb_vb2_is_streaming(&dmxdev->dvr_vb2_ctx))
1310             ret = dvb_vb2_stream_on(&dmxdev->dvr_vb2_ctx);
1311         break;
1312 
1313     case DMX_DQBUF:
1314         ret = dvb_vb2_dqbuf(&dmxdev->dvr_vb2_ctx, parg);
1315         break;
1316 #endif
1317     default:
1318         ret = -ENOTTY;
1319         break;
1320     }
1321     mutex_unlock(&dmxdev->mutex);
1322     return ret;
1323 }
1324 
1325 static long dvb_dvr_ioctl(struct file *file,
1326              unsigned int cmd, unsigned long arg)
1327 {
1328     return dvb_usercopy(file, cmd, arg, dvb_dvr_do_ioctl);
1329 }
1330 
1331 static __poll_t dvb_dvr_poll(struct file *file, poll_table *wait)
1332 {
1333     struct dvb_device *dvbdev = file->private_data;
1334     struct dmxdev *dmxdev = dvbdev->priv;
1335     __poll_t mask = 0;
1336 
1337     dprintk("%s\n", __func__);
1338 
1339     poll_wait(file, &dmxdev->dvr_buffer.queue, wait);
1340 
1341     if (dmxdev->exit)
1342         return EPOLLERR;
1343     if (dvb_vb2_is_streaming(&dmxdev->dvr_vb2_ctx))
1344         return dvb_vb2_poll(&dmxdev->dvr_vb2_ctx, file, wait);
1345 
1346     if (((file->f_flags & O_ACCMODE) == O_RDONLY) ||
1347         dmxdev->may_do_mmap) {
1348         if (dmxdev->dvr_buffer.error)
1349             mask |= (EPOLLIN | EPOLLRDNORM | EPOLLPRI | EPOLLERR);
1350 
1351         if (!dvb_ringbuffer_empty(&dmxdev->dvr_buffer))
1352             mask |= (EPOLLIN | EPOLLRDNORM | EPOLLPRI);
1353     } else
1354         mask |= (EPOLLOUT | EPOLLWRNORM | EPOLLPRI);
1355 
1356     return mask;
1357 }
1358 
1359 #ifdef CONFIG_DVB_MMAP
1360 static int dvb_dvr_mmap(struct file *file, struct vm_area_struct *vma)
1361 {
1362     struct dvb_device *dvbdev = file->private_data;
1363     struct dmxdev *dmxdev = dvbdev->priv;
1364     int ret;
1365 
1366     if (!dmxdev->may_do_mmap)
1367         return -ENOTTY;
1368 
1369     if (dmxdev->exit)
1370         return -ENODEV;
1371 
1372     if (mutex_lock_interruptible(&dmxdev->mutex))
1373         return -ERESTARTSYS;
1374 
1375     ret = dvb_vb2_mmap(&dmxdev->dvr_vb2_ctx, vma);
1376     mutex_unlock(&dmxdev->mutex);
1377     return ret;
1378 }
1379 #endif
1380 
1381 static const struct file_operations dvb_dvr_fops = {
1382     .owner = THIS_MODULE,
1383     .read = dvb_dvr_read,
1384     .write = dvb_dvr_write,
1385     .unlocked_ioctl = dvb_dvr_ioctl,
1386     .open = dvb_dvr_open,
1387     .release = dvb_dvr_release,
1388     .poll = dvb_dvr_poll,
1389     .llseek = default_llseek,
1390 #ifdef CONFIG_DVB_MMAP
1391     .mmap = dvb_dvr_mmap,
1392 #endif
1393 };
1394 
1395 static const struct dvb_device dvbdev_dvr = {
1396     .priv = NULL,
1397     .readers = 1,
1398     .users = 1,
1399 #if defined(CONFIG_MEDIA_CONTROLLER_DVB)
1400     .name = "dvb-dvr",
1401 #endif
1402     .fops = &dvb_dvr_fops
1403 };
1404 int dvb_dmxdev_init(struct dmxdev *dmxdev, struct dvb_adapter *dvb_adapter)
1405 {
1406     int i, ret;
1407 
1408     if (dmxdev->demux->open(dmxdev->demux) < 0)
1409         return -EUSERS;
1410 
1411     dmxdev->filter = vmalloc(array_size(sizeof(struct dmxdev_filter),
1412                         dmxdev->filternum));
1413     if (!dmxdev->filter)
1414         return -ENOMEM;
1415 
1416     mutex_init(&dmxdev->mutex);
1417     spin_lock_init(&dmxdev->lock);
1418     for (i = 0; i < dmxdev->filternum; i++) {
1419         dmxdev->filter[i].dev = dmxdev;
1420         dmxdev->filter[i].buffer.data = NULL;
1421         dvb_dmxdev_filter_state_set(&dmxdev->filter[i],
1422                         DMXDEV_STATE_FREE);
1423     }
1424 
1425     ret = dvb_register_device(dvb_adapter, &dmxdev->dvbdev, &dvbdev_demux, dmxdev,
1426                 DVB_DEVICE_DEMUX, dmxdev->filternum);
1427     if (ret < 0)
1428         goto err_register_dvbdev;
1429 
1430     ret = dvb_register_device(dvb_adapter, &dmxdev->dvr_dvbdev, &dvbdev_dvr,
1431                 dmxdev, DVB_DEVICE_DVR, dmxdev->filternum);
1432     if (ret < 0)
1433         goto err_register_dvr_dvbdev;
1434 
1435     dvb_ringbuffer_init(&dmxdev->dvr_buffer, NULL, 8192);
1436 
1437     return 0;
1438 
1439 err_register_dvr_dvbdev:
1440     dvb_unregister_device(dmxdev->dvbdev);
1441 err_register_dvbdev:
1442     vfree(dmxdev->filter);
1443     dmxdev->filter = NULL;
1444     return ret;
1445 }
1446 
1447 EXPORT_SYMBOL(dvb_dmxdev_init);
1448 
1449 void dvb_dmxdev_release(struct dmxdev *dmxdev)
1450 {
1451     dmxdev->exit = 1;
1452     if (dmxdev->dvbdev->users > 1) {
1453         wait_event(dmxdev->dvbdev->wait_queue,
1454                 dmxdev->dvbdev->users == 1);
1455     }
1456     if (dmxdev->dvr_dvbdev->users > 1) {
1457         wait_event(dmxdev->dvr_dvbdev->wait_queue,
1458                 dmxdev->dvr_dvbdev->users == 1);
1459     }
1460 
1461     dvb_unregister_device(dmxdev->dvbdev);
1462     dvb_unregister_device(dmxdev->dvr_dvbdev);
1463 
1464     vfree(dmxdev->filter);
1465     dmxdev->filter = NULL;
1466     dmxdev->demux->close(dmxdev->demux);
1467 }
1468 
1469 EXPORT_SYMBOL(dvb_dmxdev_release);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!