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