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