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