xref: /linux/drivers/media/dvb-core/dmxdev.c (revision 3821a065f5672c430a088ae68b4da2a2d2b34106) 
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 		mutex_unlock(&dmxdev->mutex);
210 		wake_up(&dvbdev->wait_queue);
211 	} else
212 		mutex_unlock(&dmxdev->mutex);
213 
214 	return 0;
215 }
216 
217 static ssize_t dvb_dvr_write(struct file *file, const char __user *buf,
218 			     size_t count, loff_t *ppos)
219 {
220 	struct dvb_device *dvbdev = file->private_data;
221 	struct dmxdev *dmxdev = dvbdev->priv;
222 	int ret;
223 
224 	if (!dmxdev->demux->write)
225 		return -EOPNOTSUPP;
226 	if ((file->f_flags & O_ACCMODE) != O_WRONLY)
227 		return -EINVAL;
228 	if (mutex_lock_interruptible(&dmxdev->mutex))
229 		return -ERESTARTSYS;
230 
231 	if (dmxdev->exit) {
232 		mutex_unlock(&dmxdev->mutex);
233 		return -ENODEV;
234 	}
235 	ret = dmxdev->demux->write(dmxdev->demux, buf, count);
236 	mutex_unlock(&dmxdev->mutex);
237 	return ret;
238 }
239 
240 static ssize_t dvb_dvr_read(struct file *file, char __user *buf, size_t count,
241 			    loff_t *ppos)
242 {
243 	struct dvb_device *dvbdev = file->private_data;
244 	struct dmxdev *dmxdev = dvbdev->priv;
245 
246 	if (dmxdev->exit)
247 		return -ENODEV;
248 
249 	return dvb_dmxdev_buffer_read(&dmxdev->dvr_buffer,
250 				      file->f_flags & O_NONBLOCK,
251 				      buf, count, ppos);
252 }
253 
254 static int dvb_dvr_set_buffer_size(struct dmxdev *dmxdev,
255 				      unsigned long size)
256 {
257 	struct dvb_ringbuffer *buf = &dmxdev->dvr_buffer;
258 	void *newmem;
259 	void *oldmem;
260 
261 	dprintk("function : %s\n", __func__);
262 
263 	if (buf->size == size)
264 		return 0;
265 	if (!size)
266 		return -EINVAL;
267 
268 	newmem = vmalloc(size);
269 	if (!newmem)
270 		return -ENOMEM;
271 
272 	oldmem = buf->data;
273 
274 	spin_lock_irq(&dmxdev->lock);
275 	buf->data = newmem;
276 	buf->size = size;
277 
278 	/* reset and not flush in case the buffer shrinks */
279 	dvb_ringbuffer_reset(buf);
280 	spin_unlock_irq(&dmxdev->lock);
281 
282 	vfree(oldmem);
283 
284 	return 0;
285 }
286 
287 static inline void dvb_dmxdev_filter_state_set(struct dmxdev_filter
288 					       *dmxdevfilter, int state)
289 {
290 	spin_lock_irq(&dmxdevfilter->dev->lock);
291 	dmxdevfilter->state = state;
292 	spin_unlock_irq(&dmxdevfilter->dev->lock);
293 }
294 
295 static int dvb_dmxdev_set_buffer_size(struct dmxdev_filter *dmxdevfilter,
296 				      unsigned long size)
297 {
298 	struct dvb_ringbuffer *buf = &dmxdevfilter->buffer;
299 	void *newmem;
300 	void *oldmem;
301 
302 	if (buf->size == size)
303 		return 0;
304 	if (!size)
305 		return -EINVAL;
306 	if (dmxdevfilter->state >= DMXDEV_STATE_GO)
307 		return -EBUSY;
308 
309 	newmem = vmalloc(size);
310 	if (!newmem)
311 		return -ENOMEM;
312 
313 	oldmem = buf->data;
314 
315 	spin_lock_irq(&dmxdevfilter->dev->lock);
316 	buf->data = newmem;
317 	buf->size = size;
318 
319 	/* reset and not flush in case the buffer shrinks */
320 	dvb_ringbuffer_reset(buf);
321 	spin_unlock_irq(&dmxdevfilter->dev->lock);
322 
323 	vfree(oldmem);
324 
325 	return 0;
326 }
327 
328 static void dvb_dmxdev_filter_timeout(unsigned long data)
329 {
330 	struct dmxdev_filter *dmxdevfilter = (struct dmxdev_filter *)data;
331 
332 	dmxdevfilter->buffer.error = -ETIMEDOUT;
333 	spin_lock_irq(&dmxdevfilter->dev->lock);
334 	dmxdevfilter->state = DMXDEV_STATE_TIMEDOUT;
335 	spin_unlock_irq(&dmxdevfilter->dev->lock);
336 	wake_up(&dmxdevfilter->buffer.queue);
337 }
338 
339 static void dvb_dmxdev_filter_timer(struct dmxdev_filter *dmxdevfilter)
340 {
341 	struct dmx_sct_filter_params *para = &dmxdevfilter->params.sec;
342 
343 	del_timer(&dmxdevfilter->timer);
344 	if (para->timeout) {
345 		dmxdevfilter->timer.function = dvb_dmxdev_filter_timeout;
346 		dmxdevfilter->timer.data = (unsigned long)dmxdevfilter;
347 		dmxdevfilter->timer.expires =
348 		    jiffies + 1 + (HZ / 2 + HZ * para->timeout) / 1000;
349 		add_timer(&dmxdevfilter->timer);
350 	}
351 }
352 
353 static int dvb_dmxdev_section_callback(const u8 *buffer1, size_t buffer1_len,
354 				       const u8 *buffer2, size_t buffer2_len,
355 				       struct dmx_section_filter *filter,
356 				       enum dmx_success success)
357 {
358 	struct dmxdev_filter *dmxdevfilter = filter->priv;
359 	int ret;
360 
361 	if (dmxdevfilter->buffer.error) {
362 		wake_up(&dmxdevfilter->buffer.queue);
363 		return 0;
364 	}
365 	spin_lock(&dmxdevfilter->dev->lock);
366 	if (dmxdevfilter->state != DMXDEV_STATE_GO) {
367 		spin_unlock(&dmxdevfilter->dev->lock);
368 		return 0;
369 	}
370 	del_timer(&dmxdevfilter->timer);
371 	dprintk("dmxdev: section callback %*ph\n", 6, buffer1);
372 	ret = dvb_dmxdev_buffer_write(&dmxdevfilter->buffer, buffer1,
373 				      buffer1_len);
374 	if (ret == buffer1_len) {
375 		ret = dvb_dmxdev_buffer_write(&dmxdevfilter->buffer, buffer2,
376 					      buffer2_len);
377 	}
378 	if (ret < 0)
379 		dmxdevfilter->buffer.error = ret;
380 	if (dmxdevfilter->params.sec.flags & DMX_ONESHOT)
381 		dmxdevfilter->state = DMXDEV_STATE_DONE;
382 	spin_unlock(&dmxdevfilter->dev->lock);
383 	wake_up(&dmxdevfilter->buffer.queue);
384 	return 0;
385 }
386 
387 static int dvb_dmxdev_ts_callback(const u8 *buffer1, size_t buffer1_len,
388 				  const u8 *buffer2, size_t buffer2_len,
389 				  struct dmx_ts_feed *feed,
390 				  enum dmx_success success)
391 {
392 	struct dmxdev_filter *dmxdevfilter = feed->priv;
393 	struct dvb_ringbuffer *buffer;
394 	int ret;
395 
396 	spin_lock(&dmxdevfilter->dev->lock);
397 	if (dmxdevfilter->params.pes.output == DMX_OUT_DECODER) {
398 		spin_unlock(&dmxdevfilter->dev->lock);
399 		return 0;
400 	}
401 
402 	if (dmxdevfilter->params.pes.output == DMX_OUT_TAP
403 	    || dmxdevfilter->params.pes.output == DMX_OUT_TSDEMUX_TAP)
404 		buffer = &dmxdevfilter->buffer;
405 	else
406 		buffer = &dmxdevfilter->dev->dvr_buffer;
407 	if (buffer->error) {
408 		spin_unlock(&dmxdevfilter->dev->lock);
409 		wake_up(&buffer->queue);
410 		return 0;
411 	}
412 	ret = dvb_dmxdev_buffer_write(buffer, buffer1, buffer1_len);
413 	if (ret == buffer1_len)
414 		ret = dvb_dmxdev_buffer_write(buffer, buffer2, buffer2_len);
415 	if (ret < 0)
416 		buffer->error = ret;
417 	spin_unlock(&dmxdevfilter->dev->lock);
418 	wake_up(&buffer->queue);
419 	return 0;
420 }
421 
422 /* stop feed but only mark the specified filter as stopped (state set) */
423 static int dvb_dmxdev_feed_stop(struct dmxdev_filter *dmxdevfilter)
424 {
425 	struct dmxdev_feed *feed;
426 
427 	dvb_dmxdev_filter_state_set(dmxdevfilter, DMXDEV_STATE_SET);
428 
429 	switch (dmxdevfilter->type) {
430 	case DMXDEV_TYPE_SEC:
431 		del_timer(&dmxdevfilter->timer);
432 		dmxdevfilter->feed.sec->stop_filtering(dmxdevfilter->feed.sec);
433 		break;
434 	case DMXDEV_TYPE_PES:
435 		list_for_each_entry(feed, &dmxdevfilter->feed.ts, next)
436 			feed->ts->stop_filtering(feed->ts);
437 		break;
438 	default:
439 		return -EINVAL;
440 	}
441 	return 0;
442 }
443 
444 /* start feed associated with the specified filter */
445 static int dvb_dmxdev_feed_start(struct dmxdev_filter *filter)
446 {
447 	struct dmxdev_feed *feed;
448 	int ret;
449 
450 	dvb_dmxdev_filter_state_set(filter, DMXDEV_STATE_GO);
451 
452 	switch (filter->type) {
453 	case DMXDEV_TYPE_SEC:
454 		return filter->feed.sec->start_filtering(filter->feed.sec);
455 	case DMXDEV_TYPE_PES:
456 		list_for_each_entry(feed, &filter->feed.ts, next) {
457 			ret = feed->ts->start_filtering(feed->ts);
458 			if (ret < 0) {
459 				dvb_dmxdev_feed_stop(filter);
460 				return ret;
461 			}
462 		}
463 		break;
464 	default:
465 		return -EINVAL;
466 	}
467 
468 	return 0;
469 }
470 
471 /* restart section feed if it has filters left associated with it,
472    otherwise release the feed */
473 static int dvb_dmxdev_feed_restart(struct dmxdev_filter *filter)
474 {
475 	int i;
476 	struct dmxdev *dmxdev = filter->dev;
477 	u16 pid = filter->params.sec.pid;
478 
479 	for (i = 0; i < dmxdev->filternum; i++)
480 		if (dmxdev->filter[i].state >= DMXDEV_STATE_GO &&
481 		    dmxdev->filter[i].type == DMXDEV_TYPE_SEC &&
482 		    dmxdev->filter[i].params.sec.pid == pid) {
483 			dvb_dmxdev_feed_start(&dmxdev->filter[i]);
484 			return 0;
485 		}
486 
487 	filter->dev->demux->release_section_feed(dmxdev->demux,
488 						 filter->feed.sec);
489 
490 	return 0;
491 }
492 
493 static int dvb_dmxdev_filter_stop(struct dmxdev_filter *dmxdevfilter)
494 {
495 	struct dmxdev_feed *feed;
496 	struct dmx_demux *demux;
497 
498 	if (dmxdevfilter->state < DMXDEV_STATE_GO)
499 		return 0;
500 
501 	switch (dmxdevfilter->type) {
502 	case DMXDEV_TYPE_SEC:
503 		if (!dmxdevfilter->feed.sec)
504 			break;
505 		dvb_dmxdev_feed_stop(dmxdevfilter);
506 		if (dmxdevfilter->filter.sec)
507 			dmxdevfilter->feed.sec->
508 			    release_filter(dmxdevfilter->feed.sec,
509 					   dmxdevfilter->filter.sec);
510 		dvb_dmxdev_feed_restart(dmxdevfilter);
511 		dmxdevfilter->feed.sec = NULL;
512 		break;
513 	case DMXDEV_TYPE_PES:
514 		dvb_dmxdev_feed_stop(dmxdevfilter);
515 		demux = dmxdevfilter->dev->demux;
516 		list_for_each_entry(feed, &dmxdevfilter->feed.ts, next) {
517 			demux->release_ts_feed(demux, feed->ts);
518 			feed->ts = NULL;
519 		}
520 		break;
521 	default:
522 		if (dmxdevfilter->state == DMXDEV_STATE_ALLOCATED)
523 			return 0;
524 		return -EINVAL;
525 	}
526 
527 	dvb_ringbuffer_flush(&dmxdevfilter->buffer);
528 	return 0;
529 }
530 
531 static void dvb_dmxdev_delete_pids(struct dmxdev_filter *dmxdevfilter)
532 {
533 	struct dmxdev_feed *feed, *tmp;
534 
535 	/* delete all PIDs */
536 	list_for_each_entry_safe(feed, tmp, &dmxdevfilter->feed.ts, next) {
537 		list_del(&feed->next);
538 		kfree(feed);
539 	}
540 
541 	BUG_ON(!list_empty(&dmxdevfilter->feed.ts));
542 }
543 
544 static inline int dvb_dmxdev_filter_reset(struct dmxdev_filter *dmxdevfilter)
545 {
546 	if (dmxdevfilter->state < DMXDEV_STATE_SET)
547 		return 0;
548 
549 	if (dmxdevfilter->type == DMXDEV_TYPE_PES)
550 		dvb_dmxdev_delete_pids(dmxdevfilter);
551 
552 	dmxdevfilter->type = DMXDEV_TYPE_NONE;
553 	dvb_dmxdev_filter_state_set(dmxdevfilter, DMXDEV_STATE_ALLOCATED);
554 	return 0;
555 }
556 
557 static int dvb_dmxdev_start_feed(struct dmxdev *dmxdev,
558 				 struct dmxdev_filter *filter,
559 				 struct dmxdev_feed *feed)
560 {
561 	struct timespec timeout = { 0 };
562 	struct dmx_pes_filter_params *para = &filter->params.pes;
563 	dmx_output_t otype;
564 	int ret;
565 	int ts_type;
566 	enum dmx_ts_pes ts_pes;
567 	struct dmx_ts_feed *tsfeed;
568 
569 	feed->ts = NULL;
570 	otype = para->output;
571 
572 	ts_pes = para->pes_type;
573 
574 	if (ts_pes < DMX_PES_OTHER)
575 		ts_type = TS_DECODER;
576 	else
577 		ts_type = 0;
578 
579 	if (otype == DMX_OUT_TS_TAP)
580 		ts_type |= TS_PACKET;
581 	else if (otype == DMX_OUT_TSDEMUX_TAP)
582 		ts_type |= TS_PACKET | TS_DEMUX;
583 	else if (otype == DMX_OUT_TAP)
584 		ts_type |= TS_PACKET | TS_DEMUX | TS_PAYLOAD_ONLY;
585 
586 	ret = dmxdev->demux->allocate_ts_feed(dmxdev->demux, &feed->ts,
587 					      dvb_dmxdev_ts_callback);
588 	if (ret < 0)
589 		return ret;
590 
591 	tsfeed = feed->ts;
592 	tsfeed->priv = filter;
593 
594 	ret = tsfeed->set(tsfeed, feed->pid, ts_type, ts_pes, 32768, timeout);
595 	if (ret < 0) {
596 		dmxdev->demux->release_ts_feed(dmxdev->demux, tsfeed);
597 		return ret;
598 	}
599 
600 	ret = tsfeed->start_filtering(tsfeed);
601 	if (ret < 0) {
602 		dmxdev->demux->release_ts_feed(dmxdev->demux, tsfeed);
603 		return ret;
604 	}
605 
606 	return 0;
607 }
608 
609 static int dvb_dmxdev_filter_start(struct dmxdev_filter *filter)
610 {
611 	struct dmxdev *dmxdev = filter->dev;
612 	struct dmxdev_feed *feed;
613 	void *mem;
614 	int ret, i;
615 
616 	if (filter->state < DMXDEV_STATE_SET)
617 		return -EINVAL;
618 
619 	if (filter->state >= DMXDEV_STATE_GO)
620 		dvb_dmxdev_filter_stop(filter);
621 
622 	if (!filter->buffer.data) {
623 		mem = vmalloc(filter->buffer.size);
624 		if (!mem)
625 			return -ENOMEM;
626 		spin_lock_irq(&filter->dev->lock);
627 		filter->buffer.data = mem;
628 		spin_unlock_irq(&filter->dev->lock);
629 	}
630 
631 	dvb_ringbuffer_flush(&filter->buffer);
632 
633 	switch (filter->type) {
634 	case DMXDEV_TYPE_SEC:
635 	{
636 		struct dmx_sct_filter_params *para = &filter->params.sec;
637 		struct dmx_section_filter **secfilter = &filter->filter.sec;
638 		struct dmx_section_feed **secfeed = &filter->feed.sec;
639 
640 		*secfilter = NULL;
641 		*secfeed = NULL;
642 
643 
644 		/* find active filter/feed with same PID */
645 		for (i = 0; i < dmxdev->filternum; i++) {
646 			if (dmxdev->filter[i].state >= DMXDEV_STATE_GO &&
647 			    dmxdev->filter[i].type == DMXDEV_TYPE_SEC &&
648 			    dmxdev->filter[i].params.sec.pid == para->pid) {
649 				*secfeed = dmxdev->filter[i].feed.sec;
650 				break;
651 			}
652 		}
653 
654 		/* if no feed found, try to allocate new one */
655 		if (!*secfeed) {
656 			ret = dmxdev->demux->allocate_section_feed(dmxdev->demux,
657 								   secfeed,
658 								   dvb_dmxdev_section_callback);
659 			if (ret < 0) {
660 				printk("DVB (%s): could not alloc feed\n",
661 				       __func__);
662 				return ret;
663 			}
664 
665 			ret = (*secfeed)->set(*secfeed, para->pid, 32768,
666 					      (para->flags & DMX_CHECK_CRC) ? 1 : 0);
667 			if (ret < 0) {
668 				printk("DVB (%s): could not set feed\n",
669 				       __func__);
670 				dvb_dmxdev_feed_restart(filter);
671 				return ret;
672 			}
673 		} else {
674 			dvb_dmxdev_feed_stop(filter);
675 		}
676 
677 		ret = (*secfeed)->allocate_filter(*secfeed, secfilter);
678 		if (ret < 0) {
679 			dvb_dmxdev_feed_restart(filter);
680 			filter->feed.sec->start_filtering(*secfeed);
681 			dprintk("could not get filter\n");
682 			return ret;
683 		}
684 
685 		(*secfilter)->priv = filter;
686 
687 		memcpy(&((*secfilter)->filter_value[3]),
688 		       &(para->filter.filter[1]), DMX_FILTER_SIZE - 1);
689 		memcpy(&(*secfilter)->filter_mask[3],
690 		       &para->filter.mask[1], DMX_FILTER_SIZE - 1);
691 		memcpy(&(*secfilter)->filter_mode[3],
692 		       &para->filter.mode[1], DMX_FILTER_SIZE - 1);
693 
694 		(*secfilter)->filter_value[0] = para->filter.filter[0];
695 		(*secfilter)->filter_mask[0] = para->filter.mask[0];
696 		(*secfilter)->filter_mode[0] = para->filter.mode[0];
697 		(*secfilter)->filter_mask[1] = 0;
698 		(*secfilter)->filter_mask[2] = 0;
699 
700 		filter->todo = 0;
701 
702 		ret = filter->feed.sec->start_filtering(filter->feed.sec);
703 		if (ret < 0)
704 			return ret;
705 
706 		dvb_dmxdev_filter_timer(filter);
707 		break;
708 	}
709 	case DMXDEV_TYPE_PES:
710 		list_for_each_entry(feed, &filter->feed.ts, next) {
711 			ret = dvb_dmxdev_start_feed(dmxdev, filter, feed);
712 			if (ret < 0) {
713 				dvb_dmxdev_filter_stop(filter);
714 				return ret;
715 			}
716 		}
717 		break;
718 	default:
719 		return -EINVAL;
720 	}
721 
722 	dvb_dmxdev_filter_state_set(filter, DMXDEV_STATE_GO);
723 	return 0;
724 }
725 
726 static int dvb_demux_open(struct inode *inode, struct file *file)
727 {
728 	struct dvb_device *dvbdev = file->private_data;
729 	struct dmxdev *dmxdev = dvbdev->priv;
730 	int i;
731 	struct dmxdev_filter *dmxdevfilter;
732 
733 	if (!dmxdev->filter)
734 		return -EINVAL;
735 
736 	if (mutex_lock_interruptible(&dmxdev->mutex))
737 		return -ERESTARTSYS;
738 
739 	for (i = 0; i < dmxdev->filternum; i++)
740 		if (dmxdev->filter[i].state == DMXDEV_STATE_FREE)
741 			break;
742 
743 	if (i == dmxdev->filternum) {
744 		mutex_unlock(&dmxdev->mutex);
745 		return -EMFILE;
746 	}
747 
748 	dmxdevfilter = &dmxdev->filter[i];
749 	mutex_init(&dmxdevfilter->mutex);
750 	file->private_data = dmxdevfilter;
751 
752 	dvb_ringbuffer_init(&dmxdevfilter->buffer, NULL, 8192);
753 	dmxdevfilter->type = DMXDEV_TYPE_NONE;
754 	dvb_dmxdev_filter_state_set(dmxdevfilter, DMXDEV_STATE_ALLOCATED);
755 	init_timer(&dmxdevfilter->timer);
756 
757 	dvbdev->users++;
758 
759 	mutex_unlock(&dmxdev->mutex);
760 	return 0;
761 }
762 
763 static int dvb_dmxdev_filter_free(struct dmxdev *dmxdev,
764 				  struct dmxdev_filter *dmxdevfilter)
765 {
766 	mutex_lock(&dmxdev->mutex);
767 	mutex_lock(&dmxdevfilter->mutex);
768 
769 	dvb_dmxdev_filter_stop(dmxdevfilter);
770 	dvb_dmxdev_filter_reset(dmxdevfilter);
771 
772 	if (dmxdevfilter->buffer.data) {
773 		void *mem = dmxdevfilter->buffer.data;
774 
775 		spin_lock_irq(&dmxdev->lock);
776 		dmxdevfilter->buffer.data = NULL;
777 		spin_unlock_irq(&dmxdev->lock);
778 		vfree(mem);
779 	}
780 
781 	dvb_dmxdev_filter_state_set(dmxdevfilter, DMXDEV_STATE_FREE);
782 	wake_up(&dmxdevfilter->buffer.queue);
783 	mutex_unlock(&dmxdevfilter->mutex);
784 	mutex_unlock(&dmxdev->mutex);
785 	return 0;
786 }
787 
788 static inline void invert_mode(dmx_filter_t *filter)
789 {
790 	int i;
791 
792 	for (i = 0; i < DMX_FILTER_SIZE; i++)
793 		filter->mode[i] ^= 0xff;
794 }
795 
796 static int dvb_dmxdev_add_pid(struct dmxdev *dmxdev,
797 			      struct dmxdev_filter *filter, u16 pid)
798 {
799 	struct dmxdev_feed *feed;
800 
801 	if ((filter->type != DMXDEV_TYPE_PES) ||
802 	    (filter->state < DMXDEV_STATE_SET))
803 		return -EINVAL;
804 
805 	/* only TS packet filters may have multiple PIDs */
806 	if ((filter->params.pes.output != DMX_OUT_TSDEMUX_TAP) &&
807 	    (!list_empty(&filter->feed.ts)))
808 		return -EINVAL;
809 
810 	feed = kzalloc(sizeof(struct dmxdev_feed), GFP_KERNEL);
811 	if (feed == NULL)
812 		return -ENOMEM;
813 
814 	feed->pid = pid;
815 	list_add(&feed->next, &filter->feed.ts);
816 
817 	if (filter->state >= DMXDEV_STATE_GO)
818 		return dvb_dmxdev_start_feed(dmxdev, filter, feed);
819 
820 	return 0;
821 }
822 
823 static int dvb_dmxdev_remove_pid(struct dmxdev *dmxdev,
824 				  struct dmxdev_filter *filter, u16 pid)
825 {
826 	struct dmxdev_feed *feed, *tmp;
827 
828 	if ((filter->type != DMXDEV_TYPE_PES) ||
829 	    (filter->state < DMXDEV_STATE_SET))
830 		return -EINVAL;
831 
832 	list_for_each_entry_safe(feed, tmp, &filter->feed.ts, next) {
833 		if ((feed->pid == pid) && (feed->ts != NULL)) {
834 			feed->ts->stop_filtering(feed->ts);
835 			filter->dev->demux->release_ts_feed(filter->dev->demux,
836 							    feed->ts);
837 			list_del(&feed->next);
838 			kfree(feed);
839 		}
840 	}
841 
842 	return 0;
843 }
844 
845 static int dvb_dmxdev_filter_set(struct dmxdev *dmxdev,
846 				 struct dmxdev_filter *dmxdevfilter,
847 				 struct dmx_sct_filter_params *params)
848 {
849 	dprintk("function : %s, PID=0x%04x, flags=%02x, timeout=%d\n",
850 		__func__, params->pid, params->flags, params->timeout);
851 
852 	dvb_dmxdev_filter_stop(dmxdevfilter);
853 
854 	dmxdevfilter->type = DMXDEV_TYPE_SEC;
855 	memcpy(&dmxdevfilter->params.sec,
856 	       params, sizeof(struct dmx_sct_filter_params));
857 	invert_mode(&dmxdevfilter->params.sec.filter);
858 	dvb_dmxdev_filter_state_set(dmxdevfilter, DMXDEV_STATE_SET);
859 
860 	if (params->flags & DMX_IMMEDIATE_START)
861 		return dvb_dmxdev_filter_start(dmxdevfilter);
862 
863 	return 0;
864 }
865 
866 static int dvb_dmxdev_pes_filter_set(struct dmxdev *dmxdev,
867 				     struct dmxdev_filter *dmxdevfilter,
868 				     struct dmx_pes_filter_params *params)
869 {
870 	int ret;
871 
872 	dvb_dmxdev_filter_stop(dmxdevfilter);
873 	dvb_dmxdev_filter_reset(dmxdevfilter);
874 
875 	if ((unsigned)params->pes_type > DMX_PES_OTHER)
876 		return -EINVAL;
877 
878 	dmxdevfilter->type = DMXDEV_TYPE_PES;
879 	memcpy(&dmxdevfilter->params, params,
880 	       sizeof(struct dmx_pes_filter_params));
881 	INIT_LIST_HEAD(&dmxdevfilter->feed.ts);
882 
883 	dvb_dmxdev_filter_state_set(dmxdevfilter, DMXDEV_STATE_SET);
884 
885 	ret = dvb_dmxdev_add_pid(dmxdev, dmxdevfilter,
886 				 dmxdevfilter->params.pes.pid);
887 	if (ret < 0)
888 		return ret;
889 
890 	if (params->flags & DMX_IMMEDIATE_START)
891 		return dvb_dmxdev_filter_start(dmxdevfilter);
892 
893 	return 0;
894 }
895 
896 static ssize_t dvb_dmxdev_read_sec(struct dmxdev_filter *dfil,
897 				   struct file *file, char __user *buf,
898 				   size_t count, loff_t *ppos)
899 {
900 	int result, hcount;
901 	int done = 0;
902 
903 	if (dfil->todo <= 0) {
904 		hcount = 3 + dfil->todo;
905 		if (hcount > count)
906 			hcount = count;
907 		result = dvb_dmxdev_buffer_read(&dfil->buffer,
908 						file->f_flags & O_NONBLOCK,
909 						buf, hcount, ppos);
910 		if (result < 0) {
911 			dfil->todo = 0;
912 			return result;
913 		}
914 		if (copy_from_user(dfil->secheader - dfil->todo, buf, result))
915 			return -EFAULT;
916 		buf += result;
917 		done = result;
918 		count -= result;
919 		dfil->todo -= result;
920 		if (dfil->todo > -3)
921 			return done;
922 		dfil->todo = ((dfil->secheader[1] << 8) | dfil->secheader[2]) & 0xfff;
923 		if (!count)
924 			return done;
925 	}
926 	if (count > dfil->todo)
927 		count = dfil->todo;
928 	result = dvb_dmxdev_buffer_read(&dfil->buffer,
929 					file->f_flags & O_NONBLOCK,
930 					buf, count, ppos);
931 	if (result < 0)
932 		return result;
933 	dfil->todo -= result;
934 	return (result + done);
935 }
936 
937 static ssize_t
938 dvb_demux_read(struct file *file, char __user *buf, size_t count,
939 	       loff_t *ppos)
940 {
941 	struct dmxdev_filter *dmxdevfilter = file->private_data;
942 	int ret;
943 
944 	if (mutex_lock_interruptible(&dmxdevfilter->mutex))
945 		return -ERESTARTSYS;
946 
947 	if (dmxdevfilter->type == DMXDEV_TYPE_SEC)
948 		ret = dvb_dmxdev_read_sec(dmxdevfilter, file, buf, count, ppos);
949 	else
950 		ret = dvb_dmxdev_buffer_read(&dmxdevfilter->buffer,
951 					     file->f_flags & O_NONBLOCK,
952 					     buf, count, ppos);
953 
954 	mutex_unlock(&dmxdevfilter->mutex);
955 	return ret;
956 }
957 
958 static int dvb_demux_do_ioctl(struct file *file,
959 			      unsigned int cmd, void *parg)
960 {
961 	struct dmxdev_filter *dmxdevfilter = file->private_data;
962 	struct dmxdev *dmxdev = dmxdevfilter->dev;
963 	unsigned long arg = (unsigned long)parg;
964 	int ret = 0;
965 
966 	if (mutex_lock_interruptible(&dmxdev->mutex))
967 		return -ERESTARTSYS;
968 
969 	switch (cmd) {
970 	case DMX_START:
971 		if (mutex_lock_interruptible(&dmxdevfilter->mutex)) {
972 			mutex_unlock(&dmxdev->mutex);
973 			return -ERESTARTSYS;
974 		}
975 		if (dmxdevfilter->state < DMXDEV_STATE_SET)
976 			ret = -EINVAL;
977 		else
978 			ret = dvb_dmxdev_filter_start(dmxdevfilter);
979 		mutex_unlock(&dmxdevfilter->mutex);
980 		break;
981 
982 	case DMX_STOP:
983 		if (mutex_lock_interruptible(&dmxdevfilter->mutex)) {
984 			mutex_unlock(&dmxdev->mutex);
985 			return -ERESTARTSYS;
986 		}
987 		ret = dvb_dmxdev_filter_stop(dmxdevfilter);
988 		mutex_unlock(&dmxdevfilter->mutex);
989 		break;
990 
991 	case DMX_SET_FILTER:
992 		if (mutex_lock_interruptible(&dmxdevfilter->mutex)) {
993 			mutex_unlock(&dmxdev->mutex);
994 			return -ERESTARTSYS;
995 		}
996 		ret = dvb_dmxdev_filter_set(dmxdev, dmxdevfilter, parg);
997 		mutex_unlock(&dmxdevfilter->mutex);
998 		break;
999 
1000 	case DMX_SET_PES_FILTER:
1001 		if (mutex_lock_interruptible(&dmxdevfilter->mutex)) {
1002 			mutex_unlock(&dmxdev->mutex);
1003 			return -ERESTARTSYS;
1004 		}
1005 		ret = dvb_dmxdev_pes_filter_set(dmxdev, dmxdevfilter, parg);
1006 		mutex_unlock(&dmxdevfilter->mutex);
1007 		break;
1008 
1009 	case DMX_SET_BUFFER_SIZE:
1010 		if (mutex_lock_interruptible(&dmxdevfilter->mutex)) {
1011 			mutex_unlock(&dmxdev->mutex);
1012 			return -ERESTARTSYS;
1013 		}
1014 		ret = dvb_dmxdev_set_buffer_size(dmxdevfilter, arg);
1015 		mutex_unlock(&dmxdevfilter->mutex);
1016 		break;
1017 
1018 	case DMX_GET_PES_PIDS:
1019 		if (!dmxdev->demux->get_pes_pids) {
1020 			ret = -EINVAL;
1021 			break;
1022 		}
1023 		dmxdev->demux->get_pes_pids(dmxdev->demux, parg);
1024 		break;
1025 
1026 	case DMX_GET_CAPS:
1027 		if (!dmxdev->demux->get_caps) {
1028 			ret = -EINVAL;
1029 			break;
1030 		}
1031 		ret = dmxdev->demux->get_caps(dmxdev->demux, parg);
1032 		break;
1033 
1034 	case DMX_SET_SOURCE:
1035 		if (!dmxdev->demux->set_source) {
1036 			ret = -EINVAL;
1037 			break;
1038 		}
1039 		ret = dmxdev->demux->set_source(dmxdev->demux, parg);
1040 		break;
1041 
1042 	case DMX_GET_STC:
1043 		if (!dmxdev->demux->get_stc) {
1044 			ret = -EINVAL;
1045 			break;
1046 		}
1047 		ret = dmxdev->demux->get_stc(dmxdev->demux,
1048 					     ((struct dmx_stc *)parg)->num,
1049 					     &((struct dmx_stc *)parg)->stc,
1050 					     &((struct dmx_stc *)parg)->base);
1051 		break;
1052 
1053 	case DMX_ADD_PID:
1054 		if (mutex_lock_interruptible(&dmxdevfilter->mutex)) {
1055 			ret = -ERESTARTSYS;
1056 			break;
1057 		}
1058 		ret = dvb_dmxdev_add_pid(dmxdev, dmxdevfilter, *(u16 *)parg);
1059 		mutex_unlock(&dmxdevfilter->mutex);
1060 		break;
1061 
1062 	case DMX_REMOVE_PID:
1063 		if (mutex_lock_interruptible(&dmxdevfilter->mutex)) {
1064 			ret = -ERESTARTSYS;
1065 			break;
1066 		}
1067 		ret = dvb_dmxdev_remove_pid(dmxdev, dmxdevfilter, *(u16 *)parg);
1068 		mutex_unlock(&dmxdevfilter->mutex);
1069 		break;
1070 
1071 	default:
1072 		ret = -EINVAL;
1073 		break;
1074 	}
1075 	mutex_unlock(&dmxdev->mutex);
1076 	return ret;
1077 }
1078 
1079 static long dvb_demux_ioctl(struct file *file, unsigned int cmd,
1080 			    unsigned long arg)
1081 {
1082 	return dvb_usercopy(file, cmd, arg, dvb_demux_do_ioctl);
1083 }
1084 
1085 static unsigned int dvb_demux_poll(struct file *file, poll_table *wait)
1086 {
1087 	struct dmxdev_filter *dmxdevfilter = file->private_data;
1088 	unsigned int mask = 0;
1089 
1090 	if ((!dmxdevfilter) || dmxdevfilter->dev->exit)
1091 		return POLLERR;
1092 
1093 	poll_wait(file, &dmxdevfilter->buffer.queue, wait);
1094 
1095 	if (dmxdevfilter->state != DMXDEV_STATE_GO &&
1096 	    dmxdevfilter->state != DMXDEV_STATE_DONE &&
1097 	    dmxdevfilter->state != DMXDEV_STATE_TIMEDOUT)
1098 		return 0;
1099 
1100 	if (dmxdevfilter->buffer.error)
1101 		mask |= (POLLIN | POLLRDNORM | POLLPRI | POLLERR);
1102 
1103 	if (!dvb_ringbuffer_empty(&dmxdevfilter->buffer))
1104 		mask |= (POLLIN | POLLRDNORM | POLLPRI);
1105 
1106 	return mask;
1107 }
1108 
1109 static int dvb_demux_release(struct inode *inode, struct file *file)
1110 {
1111 	struct dmxdev_filter *dmxdevfilter = file->private_data;
1112 	struct dmxdev *dmxdev = dmxdevfilter->dev;
1113 
1114 	int ret;
1115 
1116 	ret = dvb_dmxdev_filter_free(dmxdev, dmxdevfilter);
1117 
1118 	mutex_lock(&dmxdev->mutex);
1119 	dmxdev->dvbdev->users--;
1120 	if(dmxdev->dvbdev->users==1 && dmxdev->exit==1) {
1121 		mutex_unlock(&dmxdev->mutex);
1122 		wake_up(&dmxdev->dvbdev->wait_queue);
1123 	} else
1124 		mutex_unlock(&dmxdev->mutex);
1125 
1126 	return ret;
1127 }
1128 
1129 static const struct file_operations dvb_demux_fops = {
1130 	.owner = THIS_MODULE,
1131 	.read = dvb_demux_read,
1132 	.unlocked_ioctl = dvb_demux_ioctl,
1133 	.open = dvb_demux_open,
1134 	.release = dvb_demux_release,
1135 	.poll = dvb_demux_poll,
1136 	.llseek = default_llseek,
1137 };
1138 
1139 static const struct dvb_device dvbdev_demux = {
1140 	.priv = NULL,
1141 	.users = 1,
1142 	.writers = 1,
1143 #if defined(CONFIG_MEDIA_CONTROLLER_DVB)
1144 	.name = "dvb-demux",
1145 #endif
1146 	.fops = &dvb_demux_fops
1147 };
1148 
1149 static int dvb_dvr_do_ioctl(struct file *file,
1150 			    unsigned int cmd, void *parg)
1151 {
1152 	struct dvb_device *dvbdev = file->private_data;
1153 	struct dmxdev *dmxdev = dvbdev->priv;
1154 	unsigned long arg = (unsigned long)parg;
1155 	int ret;
1156 
1157 	if (mutex_lock_interruptible(&dmxdev->mutex))
1158 		return -ERESTARTSYS;
1159 
1160 	switch (cmd) {
1161 	case DMX_SET_BUFFER_SIZE:
1162 		ret = dvb_dvr_set_buffer_size(dmxdev, arg);
1163 		break;
1164 
1165 	default:
1166 		ret = -EINVAL;
1167 		break;
1168 	}
1169 	mutex_unlock(&dmxdev->mutex);
1170 	return ret;
1171 }
1172 
1173 static long dvb_dvr_ioctl(struct file *file,
1174 			 unsigned int cmd, unsigned long arg)
1175 {
1176 	return dvb_usercopy(file, cmd, arg, dvb_dvr_do_ioctl);
1177 }
1178 
1179 static unsigned int dvb_dvr_poll(struct file *file, poll_table *wait)
1180 {
1181 	struct dvb_device *dvbdev = file->private_data;
1182 	struct dmxdev *dmxdev = dvbdev->priv;
1183 	unsigned int mask = 0;
1184 
1185 	dprintk("function : %s\n", __func__);
1186 
1187 	if (dmxdev->exit)
1188 		return POLLERR;
1189 
1190 	poll_wait(file, &dmxdev->dvr_buffer.queue, wait);
1191 
1192 	if ((file->f_flags & O_ACCMODE) == O_RDONLY) {
1193 		if (dmxdev->dvr_buffer.error)
1194 			mask |= (POLLIN | POLLRDNORM | POLLPRI | POLLERR);
1195 
1196 		if (!dvb_ringbuffer_empty(&dmxdev->dvr_buffer))
1197 			mask |= (POLLIN | POLLRDNORM | POLLPRI);
1198 	} else
1199 		mask |= (POLLOUT | POLLWRNORM | POLLPRI);
1200 
1201 	return mask;
1202 }
1203 
1204 static const struct file_operations dvb_dvr_fops = {
1205 	.owner = THIS_MODULE,
1206 	.read = dvb_dvr_read,
1207 	.write = dvb_dvr_write,
1208 	.unlocked_ioctl = dvb_dvr_ioctl,
1209 	.open = dvb_dvr_open,
1210 	.release = dvb_dvr_release,
1211 	.poll = dvb_dvr_poll,
1212 	.llseek = default_llseek,
1213 };
1214 
1215 static const struct dvb_device dvbdev_dvr = {
1216 	.priv = NULL,
1217 	.readers = 1,
1218 	.users = 1,
1219 #if defined(CONFIG_MEDIA_CONTROLLER_DVB)
1220 	.name = "dvb-dvr",
1221 #endif
1222 	.fops = &dvb_dvr_fops
1223 };
1224 int dvb_dmxdev_init(struct dmxdev *dmxdev, struct dvb_adapter *dvb_adapter)
1225 {
1226 	int i;
1227 
1228 	if (dmxdev->demux->open(dmxdev->demux) < 0)
1229 		return -EUSERS;
1230 
1231 	dmxdev->filter = vmalloc(dmxdev->filternum * sizeof(struct dmxdev_filter));
1232 	if (!dmxdev->filter)
1233 		return -ENOMEM;
1234 
1235 	mutex_init(&dmxdev->mutex);
1236 	spin_lock_init(&dmxdev->lock);
1237 	for (i = 0; i < dmxdev->filternum; i++) {
1238 		dmxdev->filter[i].dev = dmxdev;
1239 		dmxdev->filter[i].buffer.data = NULL;
1240 		dvb_dmxdev_filter_state_set(&dmxdev->filter[i],
1241 					    DMXDEV_STATE_FREE);
1242 	}
1243 
1244 	dvb_register_device(dvb_adapter, &dmxdev->dvbdev, &dvbdev_demux, dmxdev,
1245 			    DVB_DEVICE_DEMUX);
1246 	dvb_register_device(dvb_adapter, &dmxdev->dvr_dvbdev, &dvbdev_dvr,
1247 			    dmxdev, DVB_DEVICE_DVR);
1248 
1249 	dvb_ringbuffer_init(&dmxdev->dvr_buffer, NULL, 8192);
1250 
1251 	return 0;
1252 }
1253 
1254 EXPORT_SYMBOL(dvb_dmxdev_init);
1255 
1256 void dvb_dmxdev_release(struct dmxdev *dmxdev)
1257 {
1258 	dmxdev->exit=1;
1259 	if (dmxdev->dvbdev->users > 1) {
1260 		wait_event(dmxdev->dvbdev->wait_queue,
1261 				dmxdev->dvbdev->users==1);
1262 	}
1263 	if (dmxdev->dvr_dvbdev->users > 1) {
1264 		wait_event(dmxdev->dvr_dvbdev->wait_queue,
1265 				dmxdev->dvr_dvbdev->users==1);
1266 	}
1267 
1268 	dvb_unregister_device(dmxdev->dvbdev);
1269 	dvb_unregister_device(dmxdev->dvr_dvbdev);
1270 
1271 	vfree(dmxdev->filter);
1272 	dmxdev->filter = NULL;
1273 	dmxdev->demux->close(dmxdev->demux);
1274 }
1275 
1276 EXPORT_SYMBOL(dvb_dmxdev_release);
1277