dmxdev.c

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