2 * dmxdev.c - DVB demultiplexer device
4 * Copyright (C) 2000 Ralph Metzler & Marcus Metzler
5 * for convergence integrated media GmbH
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public License
9 * as published by the Free Software Foundation; either version 2.1
10 * of the License, or (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
23 #include <linux/sched.h>
24 #include <linux/spinlock.h>
25 #include <linux/slab.h>
26 #include <linux/vmalloc.h>
27 #include <linux/module.h>
28 #include <linux/poll.h>
29 #include <linux/ioctl.h>
30 #include <linux/wait.h>
31 #include <asm/uaccess.h>
36 module_param(debug
, int, 0644);
37 MODULE_PARM_DESC(debug
, "Turn on/off debugging (default:off).");
39 #define dprintk if (debug) printk
41 static int dvb_dmxdev_buffer_write(struct dvb_ringbuffer
*buf
,
42 const u8
*src
, size_t len
)
51 free
= dvb_ringbuffer_free(buf
);
53 dprintk("dmxdev: buffer overflow\n");
57 return dvb_ringbuffer_write(buf
, src
, len
);
60 static ssize_t
dvb_dmxdev_buffer_read(struct dvb_ringbuffer
*src
,
61 int non_blocking
, char __user
*buf
,
62 size_t count
, loff_t
*ppos
)
73 dvb_ringbuffer_flush(src
);
77 for (todo
= count
; todo
> 0; todo
-= ret
) {
78 if (non_blocking
&& dvb_ringbuffer_empty(src
)) {
83 ret
= wait_event_interruptible(src
->queue
,
84 !dvb_ringbuffer_empty(src
) ||
91 dvb_ringbuffer_flush(src
);
95 avail
= dvb_ringbuffer_avail(src
);
99 ret
= dvb_ringbuffer_read_user(src
, buf
, avail
);
106 return (count
- todo
) ? (count
- todo
) : ret
;
109 static struct dmx_frontend
*get_fe(struct dmx_demux
*demux
, int type
)
111 struct list_head
*head
, *pos
;
113 head
= demux
->get_frontends(demux
);
116 list_for_each(pos
, head
)
117 if (DMX_FE_ENTRY(pos
)->source
== type
)
118 return DMX_FE_ENTRY(pos
);
123 static int dvb_dvr_open(struct inode
*inode
, struct file
*file
)
125 struct dvb_device
*dvbdev
= file
->private_data
;
126 struct dmxdev
*dmxdev
= dvbdev
->priv
;
127 struct dmx_frontend
*front
;
129 dprintk("function : %s\n", __func__
);
131 if (mutex_lock_interruptible(&dmxdev
->mutex
))
135 mutex_unlock(&dmxdev
->mutex
);
139 if ((file
->f_flags
& O_ACCMODE
) == O_RDWR
) {
140 if (!(dmxdev
->capabilities
& DMXDEV_CAP_DUPLEX
)) {
141 mutex_unlock(&dmxdev
->mutex
);
146 if ((file
->f_flags
& O_ACCMODE
) == O_RDONLY
) {
148 if (!dvbdev
->readers
) {
149 mutex_unlock(&dmxdev
->mutex
);
152 mem
= vmalloc(DVR_BUFFER_SIZE
);
154 mutex_unlock(&dmxdev
->mutex
);
157 dvb_ringbuffer_init(&dmxdev
->dvr_buffer
, mem
, DVR_BUFFER_SIZE
);
161 if ((file
->f_flags
& O_ACCMODE
) == O_WRONLY
) {
162 dmxdev
->dvr_orig_fe
= dmxdev
->demux
->frontend
;
164 if (!dmxdev
->demux
->write
) {
165 mutex_unlock(&dmxdev
->mutex
);
169 front
= get_fe(dmxdev
->demux
, DMX_MEMORY_FE
);
172 mutex_unlock(&dmxdev
->mutex
);
175 dmxdev
->demux
->disconnect_frontend(dmxdev
->demux
);
176 dmxdev
->demux
->connect_frontend(dmxdev
->demux
, front
);
179 mutex_unlock(&dmxdev
->mutex
);
183 static int dvb_dvr_release(struct inode
*inode
, struct file
*file
)
185 struct dvb_device
*dvbdev
= file
->private_data
;
186 struct dmxdev
*dmxdev
= dvbdev
->priv
;
188 mutex_lock(&dmxdev
->mutex
);
190 if ((file
->f_flags
& O_ACCMODE
) == O_WRONLY
) {
191 dmxdev
->demux
->disconnect_frontend(dmxdev
->demux
);
192 dmxdev
->demux
->connect_frontend(dmxdev
->demux
,
193 dmxdev
->dvr_orig_fe
);
195 if ((file
->f_flags
& O_ACCMODE
) == O_RDONLY
) {
197 if (dmxdev
->dvr_buffer
.data
) {
198 void *mem
= dmxdev
->dvr_buffer
.data
;
200 spin_lock_irq(&dmxdev
->lock
);
201 dmxdev
->dvr_buffer
.data
= NULL
;
202 spin_unlock_irq(&dmxdev
->lock
);
208 if (dvbdev
->users
== 1 && dmxdev
->exit
== 1) {
209 fops_put(file
->f_op
);
211 mutex_unlock(&dmxdev
->mutex
);
212 wake_up(&dvbdev
->wait_queue
);
214 mutex_unlock(&dmxdev
->mutex
);
219 static ssize_t
dvb_dvr_write(struct file
*file
, const char __user
*buf
,
220 size_t count
, loff_t
*ppos
)
222 struct dvb_device
*dvbdev
= file
->private_data
;
223 struct dmxdev
*dmxdev
= dvbdev
->priv
;
226 if (!dmxdev
->demux
->write
)
228 if ((file
->f_flags
& O_ACCMODE
) != O_WRONLY
)
230 if (mutex_lock_interruptible(&dmxdev
->mutex
))
234 mutex_unlock(&dmxdev
->mutex
);
237 ret
= dmxdev
->demux
->write(dmxdev
->demux
, buf
, count
);
238 mutex_unlock(&dmxdev
->mutex
);
242 static ssize_t
dvb_dvr_read(struct file
*file
, char __user
*buf
, size_t count
,
245 struct dvb_device
*dvbdev
= file
->private_data
;
246 struct dmxdev
*dmxdev
= dvbdev
->priv
;
251 return dvb_dmxdev_buffer_read(&dmxdev
->dvr_buffer
,
252 file
->f_flags
& O_NONBLOCK
,
256 static int dvb_dvr_set_buffer_size(struct dmxdev
*dmxdev
,
259 struct dvb_ringbuffer
*buf
= &dmxdev
->dvr_buffer
;
263 dprintk("function : %s\n", __func__
);
265 if (buf
->size
== size
)
270 newmem
= vmalloc(size
);
276 spin_lock_irq(&dmxdev
->lock
);
280 /* reset and not flush in case the buffer shrinks */
281 dvb_ringbuffer_reset(buf
);
282 spin_unlock_irq(&dmxdev
->lock
);
289 static inline void dvb_dmxdev_filter_state_set(struct dmxdev_filter
290 *dmxdevfilter
, int state
)
292 spin_lock_irq(&dmxdevfilter
->dev
->lock
);
293 dmxdevfilter
->state
= state
;
294 spin_unlock_irq(&dmxdevfilter
->dev
->lock
);
297 static int dvb_dmxdev_set_buffer_size(struct dmxdev_filter
*dmxdevfilter
,
300 struct dvb_ringbuffer
*buf
= &dmxdevfilter
->buffer
;
304 if (buf
->size
== size
)
308 if (dmxdevfilter
->state
>= DMXDEV_STATE_GO
)
311 newmem
= vmalloc(size
);
317 spin_lock_irq(&dmxdevfilter
->dev
->lock
);
321 /* reset and not flush in case the buffer shrinks */
322 dvb_ringbuffer_reset(buf
);
323 spin_unlock_irq(&dmxdevfilter
->dev
->lock
);
330 static void dvb_dmxdev_filter_timeout(unsigned long data
)
332 struct dmxdev_filter
*dmxdevfilter
= (struct dmxdev_filter
*)data
;
334 dmxdevfilter
->buffer
.error
= -ETIMEDOUT
;
335 spin_lock_irq(&dmxdevfilter
->dev
->lock
);
336 dmxdevfilter
->state
= DMXDEV_STATE_TIMEDOUT
;
337 spin_unlock_irq(&dmxdevfilter
->dev
->lock
);
338 wake_up(&dmxdevfilter
->buffer
.queue
);
341 static void dvb_dmxdev_filter_timer(struct dmxdev_filter
*dmxdevfilter
)
343 struct dmx_sct_filter_params
*para
= &dmxdevfilter
->params
.sec
;
345 del_timer(&dmxdevfilter
->timer
);
347 dmxdevfilter
->timer
.function
= dvb_dmxdev_filter_timeout
;
348 dmxdevfilter
->timer
.data
= (unsigned long)dmxdevfilter
;
349 dmxdevfilter
->timer
.expires
=
350 jiffies
+ 1 + (HZ
/ 2 + HZ
* para
->timeout
) / 1000;
351 add_timer(&dmxdevfilter
->timer
);
355 static int dvb_dmxdev_section_callback(const u8
*buffer1
, size_t buffer1_len
,
356 const u8
*buffer2
, size_t buffer2_len
,
357 struct dmx_section_filter
*filter
,
358 enum dmx_success success
)
360 struct dmxdev_filter
*dmxdevfilter
= filter
->priv
;
363 if (dmxdevfilter
->buffer
.error
) {
364 wake_up(&dmxdevfilter
->buffer
.queue
);
367 spin_lock(&dmxdevfilter
->dev
->lock
);
368 if (dmxdevfilter
->state
!= DMXDEV_STATE_GO
) {
369 spin_unlock(&dmxdevfilter
->dev
->lock
);
372 del_timer(&dmxdevfilter
->timer
);
373 dprintk("dmxdev: section callback %*ph\n", 6, buffer1
);
374 ret
= dvb_dmxdev_buffer_write(&dmxdevfilter
->buffer
, buffer1
,
376 if (ret
== buffer1_len
) {
377 ret
= dvb_dmxdev_buffer_write(&dmxdevfilter
->buffer
, buffer2
,
381 dmxdevfilter
->buffer
.error
= ret
;
382 if (dmxdevfilter
->params
.sec
.flags
& DMX_ONESHOT
)
383 dmxdevfilter
->state
= DMXDEV_STATE_DONE
;
384 spin_unlock(&dmxdevfilter
->dev
->lock
);
385 wake_up(&dmxdevfilter
->buffer
.queue
);
389 static int dvb_dmxdev_ts_callback(const u8
*buffer1
, size_t buffer1_len
,
390 const u8
*buffer2
, size_t buffer2_len
,
391 struct dmx_ts_feed
*feed
,
392 enum dmx_success success
)
394 struct dmxdev_filter
*dmxdevfilter
= feed
->priv
;
395 struct dvb_ringbuffer
*buffer
;
398 spin_lock(&dmxdevfilter
->dev
->lock
);
399 if (dmxdevfilter
->params
.pes
.output
== DMX_OUT_DECODER
) {
400 spin_unlock(&dmxdevfilter
->dev
->lock
);
404 if (dmxdevfilter
->params
.pes
.output
== DMX_OUT_TAP
405 || dmxdevfilter
->params
.pes
.output
== DMX_OUT_TSDEMUX_TAP
)
406 buffer
= &dmxdevfilter
->buffer
;
408 buffer
= &dmxdevfilter
->dev
->dvr_buffer
;
410 spin_unlock(&dmxdevfilter
->dev
->lock
);
411 wake_up(&buffer
->queue
);
414 ret
= dvb_dmxdev_buffer_write(buffer
, buffer1
, buffer1_len
);
415 if (ret
== buffer1_len
)
416 ret
= dvb_dmxdev_buffer_write(buffer
, buffer2
, buffer2_len
);
419 spin_unlock(&dmxdevfilter
->dev
->lock
);
420 wake_up(&buffer
->queue
);
424 /* stop feed but only mark the specified filter as stopped (state set) */
425 static int dvb_dmxdev_feed_stop(struct dmxdev_filter
*dmxdevfilter
)
427 struct dmxdev_feed
*feed
;
429 dvb_dmxdev_filter_state_set(dmxdevfilter
, DMXDEV_STATE_SET
);
431 switch (dmxdevfilter
->type
) {
432 case DMXDEV_TYPE_SEC
:
433 del_timer(&dmxdevfilter
->timer
);
434 dmxdevfilter
->feed
.sec
->stop_filtering(dmxdevfilter
->feed
.sec
);
436 case DMXDEV_TYPE_PES
:
437 list_for_each_entry(feed
, &dmxdevfilter
->feed
.ts
, next
)
438 feed
->ts
->stop_filtering(feed
->ts
);
446 /* start feed associated with the specified filter */
447 static int dvb_dmxdev_feed_start(struct dmxdev_filter
*filter
)
449 struct dmxdev_feed
*feed
;
452 dvb_dmxdev_filter_state_set(filter
, DMXDEV_STATE_GO
);
454 switch (filter
->type
) {
455 case DMXDEV_TYPE_SEC
:
456 return filter
->feed
.sec
->start_filtering(filter
->feed
.sec
);
457 case DMXDEV_TYPE_PES
:
458 list_for_each_entry(feed
, &filter
->feed
.ts
, next
) {
459 ret
= feed
->ts
->start_filtering(feed
->ts
);
461 dvb_dmxdev_feed_stop(filter
);
473 /* restart section feed if it has filters left associated with it,
474 otherwise release the feed */
475 static int dvb_dmxdev_feed_restart(struct dmxdev_filter
*filter
)
478 struct dmxdev
*dmxdev
= filter
->dev
;
479 u16 pid
= filter
->params
.sec
.pid
;
481 for (i
= 0; i
< dmxdev
->filternum
; i
++)
482 if (dmxdev
->filter
[i
].state
>= DMXDEV_STATE_GO
&&
483 dmxdev
->filter
[i
].type
== DMXDEV_TYPE_SEC
&&
484 dmxdev
->filter
[i
].params
.sec
.pid
== pid
) {
485 dvb_dmxdev_feed_start(&dmxdev
->filter
[i
]);
489 filter
->dev
->demux
->release_section_feed(dmxdev
->demux
,
495 static int dvb_dmxdev_filter_stop(struct dmxdev_filter
*dmxdevfilter
)
497 struct dmxdev_feed
*feed
;
498 struct dmx_demux
*demux
;
500 if (dmxdevfilter
->state
< DMXDEV_STATE_GO
)
503 switch (dmxdevfilter
->type
) {
504 case DMXDEV_TYPE_SEC
:
505 if (!dmxdevfilter
->feed
.sec
)
507 dvb_dmxdev_feed_stop(dmxdevfilter
);
508 if (dmxdevfilter
->filter
.sec
)
509 dmxdevfilter
->feed
.sec
->
510 release_filter(dmxdevfilter
->feed
.sec
,
511 dmxdevfilter
->filter
.sec
);
512 dvb_dmxdev_feed_restart(dmxdevfilter
);
513 dmxdevfilter
->feed
.sec
= NULL
;
515 case DMXDEV_TYPE_PES
:
516 dvb_dmxdev_feed_stop(dmxdevfilter
);
517 demux
= dmxdevfilter
->dev
->demux
;
518 list_for_each_entry(feed
, &dmxdevfilter
->feed
.ts
, next
) {
519 demux
->release_ts_feed(demux
, feed
->ts
);
524 if (dmxdevfilter
->state
== DMXDEV_STATE_ALLOCATED
)
529 dvb_ringbuffer_flush(&dmxdevfilter
->buffer
);
533 static void dvb_dmxdev_delete_pids(struct dmxdev_filter
*dmxdevfilter
)
535 struct dmxdev_feed
*feed
, *tmp
;
537 /* delete all PIDs */
538 list_for_each_entry_safe(feed
, tmp
, &dmxdevfilter
->feed
.ts
, next
) {
539 list_del(&feed
->next
);
543 BUG_ON(!list_empty(&dmxdevfilter
->feed
.ts
));
546 static inline int dvb_dmxdev_filter_reset(struct dmxdev_filter
*dmxdevfilter
)
548 if (dmxdevfilter
->state
< DMXDEV_STATE_SET
)
551 if (dmxdevfilter
->type
== DMXDEV_TYPE_PES
)
552 dvb_dmxdev_delete_pids(dmxdevfilter
);
554 dmxdevfilter
->type
= DMXDEV_TYPE_NONE
;
555 dvb_dmxdev_filter_state_set(dmxdevfilter
, DMXDEV_STATE_ALLOCATED
);
559 static int dvb_dmxdev_start_feed(struct dmxdev
*dmxdev
,
560 struct dmxdev_filter
*filter
,
561 struct dmxdev_feed
*feed
)
563 struct timespec timeout
= { 0 };
564 struct dmx_pes_filter_params
*para
= &filter
->params
.pes
;
568 enum dmx_ts_pes ts_pes
;
569 struct dmx_ts_feed
*tsfeed
;
572 otype
= para
->output
;
574 ts_pes
= para
->pes_type
;
576 if (ts_pes
< DMX_PES_OTHER
)
577 ts_type
= TS_DECODER
;
581 if (otype
== DMX_OUT_TS_TAP
)
582 ts_type
|= TS_PACKET
;
583 else if (otype
== DMX_OUT_TSDEMUX_TAP
)
584 ts_type
|= TS_PACKET
| TS_DEMUX
;
585 else if (otype
== DMX_OUT_TAP
)
586 ts_type
|= TS_PACKET
| TS_DEMUX
| TS_PAYLOAD_ONLY
;
588 ret
= dmxdev
->demux
->allocate_ts_feed(dmxdev
->demux
, &feed
->ts
,
589 dvb_dmxdev_ts_callback
);
594 tsfeed
->priv
= filter
;
596 ret
= tsfeed
->set(tsfeed
, feed
->pid
, ts_type
, ts_pes
, 32768, timeout
);
598 dmxdev
->demux
->release_ts_feed(dmxdev
->demux
, tsfeed
);
602 ret
= tsfeed
->start_filtering(tsfeed
);
604 dmxdev
->demux
->release_ts_feed(dmxdev
->demux
, tsfeed
);
611 static int dvb_dmxdev_filter_start(struct dmxdev_filter
*filter
)
613 struct dmxdev
*dmxdev
= filter
->dev
;
614 struct dmxdev_feed
*feed
;
618 if (filter
->state
< DMXDEV_STATE_SET
)
621 if (filter
->state
>= DMXDEV_STATE_GO
)
622 dvb_dmxdev_filter_stop(filter
);
624 if (!filter
->buffer
.data
) {
625 mem
= vmalloc(filter
->buffer
.size
);
628 spin_lock_irq(&filter
->dev
->lock
);
629 filter
->buffer
.data
= mem
;
630 spin_unlock_irq(&filter
->dev
->lock
);
633 dvb_ringbuffer_flush(&filter
->buffer
);
635 switch (filter
->type
) {
636 case DMXDEV_TYPE_SEC
:
638 struct dmx_sct_filter_params
*para
= &filter
->params
.sec
;
639 struct dmx_section_filter
**secfilter
= &filter
->filter
.sec
;
640 struct dmx_section_feed
**secfeed
= &filter
->feed
.sec
;
646 /* find active filter/feed with same PID */
647 for (i
= 0; i
< dmxdev
->filternum
; i
++) {
648 if (dmxdev
->filter
[i
].state
>= DMXDEV_STATE_GO
&&
649 dmxdev
->filter
[i
].type
== DMXDEV_TYPE_SEC
&&
650 dmxdev
->filter
[i
].params
.sec
.pid
== para
->pid
) {
651 *secfeed
= dmxdev
->filter
[i
].feed
.sec
;
656 /* if no feed found, try to allocate new one */
658 ret
= dmxdev
->demux
->allocate_section_feed(dmxdev
->demux
,
660 dvb_dmxdev_section_callback
);
662 printk("DVB (%s): could not alloc feed\n",
667 ret
= (*secfeed
)->set(*secfeed
, para
->pid
, 32768,
668 (para
->flags
& DMX_CHECK_CRC
) ? 1 : 0);
670 printk("DVB (%s): could not set feed\n",
672 dvb_dmxdev_feed_restart(filter
);
676 dvb_dmxdev_feed_stop(filter
);
679 ret
= (*secfeed
)->allocate_filter(*secfeed
, secfilter
);
681 dvb_dmxdev_feed_restart(filter
);
682 filter
->feed
.sec
->start_filtering(*secfeed
);
683 dprintk("could not get filter\n");
687 (*secfilter
)->priv
= filter
;
689 memcpy(&((*secfilter
)->filter_value
[3]),
690 &(para
->filter
.filter
[1]), DMX_FILTER_SIZE
- 1);
691 memcpy(&(*secfilter
)->filter_mask
[3],
692 ¶
->filter
.mask
[1], DMX_FILTER_SIZE
- 1);
693 memcpy(&(*secfilter
)->filter_mode
[3],
694 ¶
->filter
.mode
[1], DMX_FILTER_SIZE
- 1);
696 (*secfilter
)->filter_value
[0] = para
->filter
.filter
[0];
697 (*secfilter
)->filter_mask
[0] = para
->filter
.mask
[0];
698 (*secfilter
)->filter_mode
[0] = para
->filter
.mode
[0];
699 (*secfilter
)->filter_mask
[1] = 0;
700 (*secfilter
)->filter_mask
[2] = 0;
704 ret
= filter
->feed
.sec
->start_filtering(filter
->feed
.sec
);
708 dvb_dmxdev_filter_timer(filter
);
711 case DMXDEV_TYPE_PES
:
712 list_for_each_entry(feed
, &filter
->feed
.ts
, next
) {
713 ret
= dvb_dmxdev_start_feed(dmxdev
, filter
, feed
);
715 dvb_dmxdev_filter_stop(filter
);
724 dvb_dmxdev_filter_state_set(filter
, DMXDEV_STATE_GO
);
728 static int dvb_demux_open(struct inode
*inode
, struct file
*file
)
730 struct dvb_device
*dvbdev
= file
->private_data
;
731 struct dmxdev
*dmxdev
= dvbdev
->priv
;
733 struct dmxdev_filter
*dmxdevfilter
;
738 if (mutex_lock_interruptible(&dmxdev
->mutex
))
741 for (i
= 0; i
< dmxdev
->filternum
; i
++)
742 if (dmxdev
->filter
[i
].state
== DMXDEV_STATE_FREE
)
745 if (i
== dmxdev
->filternum
) {
746 mutex_unlock(&dmxdev
->mutex
);
750 dmxdevfilter
= &dmxdev
->filter
[i
];
751 mutex_init(&dmxdevfilter
->mutex
);
752 file
->private_data
= dmxdevfilter
;
754 dvb_ringbuffer_init(&dmxdevfilter
->buffer
, NULL
, 8192);
755 dmxdevfilter
->type
= DMXDEV_TYPE_NONE
;
756 dvb_dmxdev_filter_state_set(dmxdevfilter
, DMXDEV_STATE_ALLOCATED
);
757 init_timer(&dmxdevfilter
->timer
);
761 mutex_unlock(&dmxdev
->mutex
);
765 static int dvb_dmxdev_filter_free(struct dmxdev
*dmxdev
,
766 struct dmxdev_filter
*dmxdevfilter
)
768 mutex_lock(&dmxdev
->mutex
);
769 mutex_lock(&dmxdevfilter
->mutex
);
771 dvb_dmxdev_filter_stop(dmxdevfilter
);
772 dvb_dmxdev_filter_reset(dmxdevfilter
);
774 if (dmxdevfilter
->buffer
.data
) {
775 void *mem
= dmxdevfilter
->buffer
.data
;
777 spin_lock_irq(&dmxdev
->lock
);
778 dmxdevfilter
->buffer
.data
= NULL
;
779 spin_unlock_irq(&dmxdev
->lock
);
783 dvb_dmxdev_filter_state_set(dmxdevfilter
, DMXDEV_STATE_FREE
);
784 wake_up(&dmxdevfilter
->buffer
.queue
);
785 mutex_unlock(&dmxdevfilter
->mutex
);
786 mutex_unlock(&dmxdev
->mutex
);
790 static inline void invert_mode(dmx_filter_t
*filter
)
794 for (i
= 0; i
< DMX_FILTER_SIZE
; i
++)
795 filter
->mode
[i
] ^= 0xff;
798 static int dvb_dmxdev_add_pid(struct dmxdev
*dmxdev
,
799 struct dmxdev_filter
*filter
, u16 pid
)
801 struct dmxdev_feed
*feed
;
803 if ((filter
->type
!= DMXDEV_TYPE_PES
) ||
804 (filter
->state
< DMXDEV_STATE_SET
))
807 /* only TS packet filters may have multiple PIDs */
808 if ((filter
->params
.pes
.output
!= DMX_OUT_TSDEMUX_TAP
) &&
809 (!list_empty(&filter
->feed
.ts
)))
812 feed
= kzalloc(sizeof(struct dmxdev_feed
), GFP_KERNEL
);
817 list_add(&feed
->next
, &filter
->feed
.ts
);
819 if (filter
->state
>= DMXDEV_STATE_GO
)
820 return dvb_dmxdev_start_feed(dmxdev
, filter
, feed
);
825 static int dvb_dmxdev_remove_pid(struct dmxdev
*dmxdev
,
826 struct dmxdev_filter
*filter
, u16 pid
)
828 struct dmxdev_feed
*feed
, *tmp
;
830 if ((filter
->type
!= DMXDEV_TYPE_PES
) ||
831 (filter
->state
< DMXDEV_STATE_SET
))
834 list_for_each_entry_safe(feed
, tmp
, &filter
->feed
.ts
, next
) {
835 if ((feed
->pid
== pid
) && (feed
->ts
!= NULL
)) {
836 feed
->ts
->stop_filtering(feed
->ts
);
837 filter
->dev
->demux
->release_ts_feed(filter
->dev
->demux
,
839 list_del(&feed
->next
);
847 static int dvb_dmxdev_filter_set(struct dmxdev
*dmxdev
,
848 struct dmxdev_filter
*dmxdevfilter
,
849 struct dmx_sct_filter_params
*params
)
851 dprintk("function : %s, PID=0x%04x, flags=%02x, timeout=%d\n",
852 __func__
, params
->pid
, params
->flags
, params
->timeout
);
854 dvb_dmxdev_filter_stop(dmxdevfilter
);
856 dmxdevfilter
->type
= DMXDEV_TYPE_SEC
;
857 memcpy(&dmxdevfilter
->params
.sec
,
858 params
, sizeof(struct dmx_sct_filter_params
));
859 invert_mode(&dmxdevfilter
->params
.sec
.filter
);
860 dvb_dmxdev_filter_state_set(dmxdevfilter
, DMXDEV_STATE_SET
);
862 if (params
->flags
& DMX_IMMEDIATE_START
)
863 return dvb_dmxdev_filter_start(dmxdevfilter
);
868 static int dvb_dmxdev_pes_filter_set(struct dmxdev
*dmxdev
,
869 struct dmxdev_filter
*dmxdevfilter
,
870 struct dmx_pes_filter_params
*params
)
874 dvb_dmxdev_filter_stop(dmxdevfilter
);
875 dvb_dmxdev_filter_reset(dmxdevfilter
);
877 if ((unsigned)params
->pes_type
> DMX_PES_OTHER
)
880 dmxdevfilter
->type
= DMXDEV_TYPE_PES
;
881 memcpy(&dmxdevfilter
->params
, params
,
882 sizeof(struct dmx_pes_filter_params
));
883 INIT_LIST_HEAD(&dmxdevfilter
->feed
.ts
);
885 dvb_dmxdev_filter_state_set(dmxdevfilter
, DMXDEV_STATE_SET
);
887 ret
= dvb_dmxdev_add_pid(dmxdev
, dmxdevfilter
,
888 dmxdevfilter
->params
.pes
.pid
);
892 if (params
->flags
& DMX_IMMEDIATE_START
)
893 return dvb_dmxdev_filter_start(dmxdevfilter
);
898 static ssize_t
dvb_dmxdev_read_sec(struct dmxdev_filter
*dfil
,
899 struct file
*file
, char __user
*buf
,
900 size_t count
, loff_t
*ppos
)
905 if (dfil
->todo
<= 0) {
906 hcount
= 3 + dfil
->todo
;
909 result
= dvb_dmxdev_buffer_read(&dfil
->buffer
,
910 file
->f_flags
& O_NONBLOCK
,
916 if (copy_from_user(dfil
->secheader
- dfil
->todo
, buf
, result
))
921 dfil
->todo
-= result
;
924 dfil
->todo
= ((dfil
->secheader
[1] << 8) | dfil
->secheader
[2]) & 0xfff;
928 if (count
> dfil
->todo
)
930 result
= dvb_dmxdev_buffer_read(&dfil
->buffer
,
931 file
->f_flags
& O_NONBLOCK
,
935 dfil
->todo
-= result
;
936 return (result
+ done
);
940 dvb_demux_read(struct file
*file
, char __user
*buf
, size_t count
,
943 struct dmxdev_filter
*dmxdevfilter
= file
->private_data
;
946 if (mutex_lock_interruptible(&dmxdevfilter
->mutex
))
949 if (dmxdevfilter
->type
== DMXDEV_TYPE_SEC
)
950 ret
= dvb_dmxdev_read_sec(dmxdevfilter
, file
, buf
, count
, ppos
);
952 ret
= dvb_dmxdev_buffer_read(&dmxdevfilter
->buffer
,
953 file
->f_flags
& O_NONBLOCK
,
956 mutex_unlock(&dmxdevfilter
->mutex
);
960 static int dvb_demux_do_ioctl(struct file
*file
,
961 unsigned int cmd
, void *parg
)
963 struct dmxdev_filter
*dmxdevfilter
= file
->private_data
;
964 struct dmxdev
*dmxdev
= dmxdevfilter
->dev
;
965 unsigned long arg
= (unsigned long)parg
;
968 if (mutex_lock_interruptible(&dmxdev
->mutex
))
973 if (mutex_lock_interruptible(&dmxdevfilter
->mutex
)) {
974 mutex_unlock(&dmxdev
->mutex
);
977 if (dmxdevfilter
->state
< DMXDEV_STATE_SET
)
980 ret
= dvb_dmxdev_filter_start(dmxdevfilter
);
981 mutex_unlock(&dmxdevfilter
->mutex
);
985 if (mutex_lock_interruptible(&dmxdevfilter
->mutex
)) {
986 mutex_unlock(&dmxdev
->mutex
);
989 ret
= dvb_dmxdev_filter_stop(dmxdevfilter
);
990 mutex_unlock(&dmxdevfilter
->mutex
);
994 if (mutex_lock_interruptible(&dmxdevfilter
->mutex
)) {
995 mutex_unlock(&dmxdev
->mutex
);
998 ret
= dvb_dmxdev_filter_set(dmxdev
, dmxdevfilter
, parg
);
999 mutex_unlock(&dmxdevfilter
->mutex
);
1002 case DMX_SET_PES_FILTER
:
1003 if (mutex_lock_interruptible(&dmxdevfilter
->mutex
)) {
1004 mutex_unlock(&dmxdev
->mutex
);
1005 return -ERESTARTSYS
;
1007 ret
= dvb_dmxdev_pes_filter_set(dmxdev
, dmxdevfilter
, parg
);
1008 mutex_unlock(&dmxdevfilter
->mutex
);
1011 case DMX_SET_BUFFER_SIZE
:
1012 if (mutex_lock_interruptible(&dmxdevfilter
->mutex
)) {
1013 mutex_unlock(&dmxdev
->mutex
);
1014 return -ERESTARTSYS
;
1016 ret
= dvb_dmxdev_set_buffer_size(dmxdevfilter
, arg
);
1017 mutex_unlock(&dmxdevfilter
->mutex
);
1020 case DMX_GET_PES_PIDS
:
1021 if (!dmxdev
->demux
->get_pes_pids
) {
1025 dmxdev
->demux
->get_pes_pids(dmxdev
->demux
, parg
);
1029 if (!dmxdev
->demux
->get_caps
) {
1033 ret
= dmxdev
->demux
->get_caps(dmxdev
->demux
, parg
);
1036 case DMX_SET_SOURCE
:
1037 if (!dmxdev
->demux
->set_source
) {
1041 ret
= dmxdev
->demux
->set_source(dmxdev
->demux
, parg
);
1045 if (!dmxdev
->demux
->get_stc
) {
1049 ret
= dmxdev
->demux
->get_stc(dmxdev
->demux
,
1050 ((struct dmx_stc
*)parg
)->num
,
1051 &((struct dmx_stc
*)parg
)->stc
,
1052 &((struct dmx_stc
*)parg
)->base
);
1056 if (mutex_lock_interruptible(&dmxdevfilter
->mutex
)) {
1060 ret
= dvb_dmxdev_add_pid(dmxdev
, dmxdevfilter
, *(u16
*)parg
);
1061 mutex_unlock(&dmxdevfilter
->mutex
);
1064 case DMX_REMOVE_PID
:
1065 if (mutex_lock_interruptible(&dmxdevfilter
->mutex
)) {
1069 ret
= dvb_dmxdev_remove_pid(dmxdev
, dmxdevfilter
, *(u16
*)parg
);
1070 mutex_unlock(&dmxdevfilter
->mutex
);
1077 mutex_unlock(&dmxdev
->mutex
);
1081 static long dvb_demux_ioctl(struct file
*file
, unsigned int cmd
,
1084 return dvb_usercopy(file
, cmd
, arg
, dvb_demux_do_ioctl
);
1087 static unsigned int dvb_demux_poll(struct file
*file
, poll_table
*wait
)
1089 struct dmxdev_filter
*dmxdevfilter
= file
->private_data
;
1090 unsigned int mask
= 0;
1095 poll_wait(file
, &dmxdevfilter
->buffer
.queue
, wait
);
1097 if (dmxdevfilter
->state
!= DMXDEV_STATE_GO
&&
1098 dmxdevfilter
->state
!= DMXDEV_STATE_DONE
&&
1099 dmxdevfilter
->state
!= DMXDEV_STATE_TIMEDOUT
)
1102 if (dmxdevfilter
->buffer
.error
)
1103 mask
|= (POLLIN
| POLLRDNORM
| POLLPRI
| POLLERR
);
1105 if (!dvb_ringbuffer_empty(&dmxdevfilter
->buffer
))
1106 mask
|= (POLLIN
| POLLRDNORM
| POLLPRI
);
1111 static int dvb_demux_release(struct inode
*inode
, struct file
*file
)
1113 struct dmxdev_filter
*dmxdevfilter
= file
->private_data
;
1114 struct dmxdev
*dmxdev
= dmxdevfilter
->dev
;
1118 ret
= dvb_dmxdev_filter_free(dmxdev
, dmxdevfilter
);
1120 mutex_lock(&dmxdev
->mutex
);
1121 dmxdev
->dvbdev
->users
--;
1122 if(dmxdev
->dvbdev
->users
==1 && dmxdev
->exit
==1) {
1123 fops_put(file
->f_op
);
1125 mutex_unlock(&dmxdev
->mutex
);
1126 wake_up(&dmxdev
->dvbdev
->wait_queue
);
1128 mutex_unlock(&dmxdev
->mutex
);
1133 static const struct file_operations dvb_demux_fops
= {
1134 .owner
= THIS_MODULE
,
1135 .read
= dvb_demux_read
,
1136 .unlocked_ioctl
= dvb_demux_ioctl
,
1137 .open
= dvb_demux_open
,
1138 .release
= dvb_demux_release
,
1139 .poll
= dvb_demux_poll
,
1140 .llseek
= default_llseek
,
1143 static struct dvb_device dvbdev_demux
= {
1147 .fops
= &dvb_demux_fops
1150 static int dvb_dvr_do_ioctl(struct file
*file
,
1151 unsigned int cmd
, void *parg
)
1153 struct dvb_device
*dvbdev
= file
->private_data
;
1154 struct dmxdev
*dmxdev
= dvbdev
->priv
;
1155 unsigned long arg
= (unsigned long)parg
;
1158 if (mutex_lock_interruptible(&dmxdev
->mutex
))
1159 return -ERESTARTSYS
;
1162 case DMX_SET_BUFFER_SIZE
:
1163 ret
= dvb_dvr_set_buffer_size(dmxdev
, arg
);
1170 mutex_unlock(&dmxdev
->mutex
);
1174 static long dvb_dvr_ioctl(struct file
*file
,
1175 unsigned int cmd
, unsigned long arg
)
1177 return dvb_usercopy(file
, cmd
, arg
, dvb_dvr_do_ioctl
);
1180 static unsigned int dvb_dvr_poll(struct file
*file
, poll_table
*wait
)
1182 struct dvb_device
*dvbdev
= file
->private_data
;
1183 struct dmxdev
*dmxdev
= dvbdev
->priv
;
1184 unsigned int mask
= 0;
1186 dprintk("function : %s\n", __func__
);
1188 poll_wait(file
, &dmxdev
->dvr_buffer
.queue
, wait
);
1190 if ((file
->f_flags
& O_ACCMODE
) == O_RDONLY
) {
1191 if (dmxdev
->dvr_buffer
.error
)
1192 mask
|= (POLLIN
| POLLRDNORM
| POLLPRI
| POLLERR
);
1194 if (!dvb_ringbuffer_empty(&dmxdev
->dvr_buffer
))
1195 mask
|= (POLLIN
| POLLRDNORM
| POLLPRI
);
1197 mask
|= (POLLOUT
| POLLWRNORM
| POLLPRI
);
1202 static const struct file_operations dvb_dvr_fops
= {
1203 .owner
= THIS_MODULE
,
1204 .read
= dvb_dvr_read
,
1205 .write
= dvb_dvr_write
,
1206 .unlocked_ioctl
= dvb_dvr_ioctl
,
1207 .open
= dvb_dvr_open
,
1208 .release
= dvb_dvr_release
,
1209 .poll
= dvb_dvr_poll
,
1210 .llseek
= default_llseek
,
1213 static struct dvb_device dvbdev_dvr
= {
1217 .fops
= &dvb_dvr_fops
1220 int dvb_dmxdev_init(struct dmxdev
*dmxdev
, struct dvb_adapter
*dvb_adapter
)
1224 if (dmxdev
->demux
->open(dmxdev
->demux
) < 0)
1227 dmxdev
->filter
= vmalloc(dmxdev
->filternum
* sizeof(struct dmxdev_filter
));
1228 if (!dmxdev
->filter
)
1231 mutex_init(&dmxdev
->mutex
);
1232 spin_lock_init(&dmxdev
->lock
);
1233 for (i
= 0; i
< dmxdev
->filternum
; i
++) {
1234 dmxdev
->filter
[i
].dev
= dmxdev
;
1235 dmxdev
->filter
[i
].buffer
.data
= NULL
;
1236 dvb_dmxdev_filter_state_set(&dmxdev
->filter
[i
],
1240 dvb_register_device(dvb_adapter
, &dmxdev
->dvbdev
, &dvbdev_demux
, dmxdev
,
1242 dvb_register_device(dvb_adapter
, &dmxdev
->dvr_dvbdev
, &dvbdev_dvr
,
1243 dmxdev
, DVB_DEVICE_DVR
);
1245 dvb_ringbuffer_init(&dmxdev
->dvr_buffer
, NULL
, 8192);
1250 EXPORT_SYMBOL(dvb_dmxdev_init
);
1252 void dvb_dmxdev_release(struct dmxdev
*dmxdev
)
1255 if (dmxdev
->dvbdev
->users
> 1) {
1256 wait_event(dmxdev
->dvbdev
->wait_queue
,
1257 dmxdev
->dvbdev
->users
==1);
1259 if (dmxdev
->dvr_dvbdev
->users
> 1) {
1260 wait_event(dmxdev
->dvr_dvbdev
->wait_queue
,
1261 dmxdev
->dvr_dvbdev
->users
==1);
1264 dvb_unregister_device(dmxdev
->dvbdev
);
1265 dvb_unregister_device(dmxdev
->dvr_dvbdev
);
1267 vfree(dmxdev
->filter
);
1268 dmxdev
->filter
= NULL
;
1269 dmxdev
->demux
->close(dmxdev
->demux
);
1272 EXPORT_SYMBOL(dvb_dmxdev_release
);