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 dvb_ringbuffer_flush(&dmxdevfilter
->buffer
);
382 dmxdevfilter
->buffer
.error
= ret
;
384 if (dmxdevfilter
->params
.sec
.flags
& DMX_ONESHOT
)
385 dmxdevfilter
->state
= DMXDEV_STATE_DONE
;
386 spin_unlock(&dmxdevfilter
->dev
->lock
);
387 wake_up(&dmxdevfilter
->buffer
.queue
);
391 static int dvb_dmxdev_ts_callback(const u8
*buffer1
, size_t buffer1_len
,
392 const u8
*buffer2
, size_t buffer2_len
,
393 struct dmx_ts_feed
*feed
,
394 enum dmx_success success
)
396 struct dmxdev_filter
*dmxdevfilter
= feed
->priv
;
397 struct dvb_ringbuffer
*buffer
;
400 spin_lock(&dmxdevfilter
->dev
->lock
);
401 if (dmxdevfilter
->params
.pes
.output
== DMX_OUT_DECODER
) {
402 spin_unlock(&dmxdevfilter
->dev
->lock
);
406 if (dmxdevfilter
->params
.pes
.output
== DMX_OUT_TAP
407 || dmxdevfilter
->params
.pes
.output
== DMX_OUT_TSDEMUX_TAP
)
408 buffer
= &dmxdevfilter
->buffer
;
410 buffer
= &dmxdevfilter
->dev
->dvr_buffer
;
412 spin_unlock(&dmxdevfilter
->dev
->lock
);
413 wake_up(&buffer
->queue
);
416 ret
= dvb_dmxdev_buffer_write(buffer
, buffer1
, buffer1_len
);
417 if (ret
== buffer1_len
)
418 ret
= dvb_dmxdev_buffer_write(buffer
, buffer2
, buffer2_len
);
420 dvb_ringbuffer_flush(buffer
);
423 spin_unlock(&dmxdevfilter
->dev
->lock
);
424 wake_up(&buffer
->queue
);
428 /* stop feed but only mark the specified filter as stopped (state set) */
429 static int dvb_dmxdev_feed_stop(struct dmxdev_filter
*dmxdevfilter
)
431 struct dmxdev_feed
*feed
;
433 dvb_dmxdev_filter_state_set(dmxdevfilter
, DMXDEV_STATE_SET
);
435 switch (dmxdevfilter
->type
) {
436 case DMXDEV_TYPE_SEC
:
437 del_timer(&dmxdevfilter
->timer
);
438 dmxdevfilter
->feed
.sec
->stop_filtering(dmxdevfilter
->feed
.sec
);
440 case DMXDEV_TYPE_PES
:
441 list_for_each_entry(feed
, &dmxdevfilter
->feed
.ts
, next
)
442 feed
->ts
->stop_filtering(feed
->ts
);
450 /* start feed associated with the specified filter */
451 static int dvb_dmxdev_feed_start(struct dmxdev_filter
*filter
)
453 struct dmxdev_feed
*feed
;
456 dvb_dmxdev_filter_state_set(filter
, DMXDEV_STATE_GO
);
458 switch (filter
->type
) {
459 case DMXDEV_TYPE_SEC
:
460 return filter
->feed
.sec
->start_filtering(filter
->feed
.sec
);
461 case DMXDEV_TYPE_PES
:
462 list_for_each_entry(feed
, &filter
->feed
.ts
, next
) {
463 ret
= feed
->ts
->start_filtering(feed
->ts
);
465 dvb_dmxdev_feed_stop(filter
);
477 /* restart section feed if it has filters left associated with it,
478 otherwise release the feed */
479 static int dvb_dmxdev_feed_restart(struct dmxdev_filter
*filter
)
482 struct dmxdev
*dmxdev
= filter
->dev
;
483 u16 pid
= filter
->params
.sec
.pid
;
485 for (i
= 0; i
< dmxdev
->filternum
; i
++)
486 if (dmxdev
->filter
[i
].state
>= DMXDEV_STATE_GO
&&
487 dmxdev
->filter
[i
].type
== DMXDEV_TYPE_SEC
&&
488 dmxdev
->filter
[i
].params
.sec
.pid
== pid
) {
489 dvb_dmxdev_feed_start(&dmxdev
->filter
[i
]);
493 filter
->dev
->demux
->release_section_feed(dmxdev
->demux
,
499 static int dvb_dmxdev_filter_stop(struct dmxdev_filter
*dmxdevfilter
)
501 struct dmxdev_feed
*feed
;
502 struct dmx_demux
*demux
;
504 if (dmxdevfilter
->state
< DMXDEV_STATE_GO
)
507 switch (dmxdevfilter
->type
) {
508 case DMXDEV_TYPE_SEC
:
509 if (!dmxdevfilter
->feed
.sec
)
511 dvb_dmxdev_feed_stop(dmxdevfilter
);
512 if (dmxdevfilter
->filter
.sec
)
513 dmxdevfilter
->feed
.sec
->
514 release_filter(dmxdevfilter
->feed
.sec
,
515 dmxdevfilter
->filter
.sec
);
516 dvb_dmxdev_feed_restart(dmxdevfilter
);
517 dmxdevfilter
->feed
.sec
= NULL
;
519 case DMXDEV_TYPE_PES
:
520 dvb_dmxdev_feed_stop(dmxdevfilter
);
521 demux
= dmxdevfilter
->dev
->demux
;
522 list_for_each_entry(feed
, &dmxdevfilter
->feed
.ts
, next
) {
523 demux
->release_ts_feed(demux
, feed
->ts
);
528 if (dmxdevfilter
->state
== DMXDEV_STATE_ALLOCATED
)
533 dvb_ringbuffer_flush(&dmxdevfilter
->buffer
);
537 static void dvb_dmxdev_delete_pids(struct dmxdev_filter
*dmxdevfilter
)
539 struct dmxdev_feed
*feed
, *tmp
;
541 /* delete all PIDs */
542 list_for_each_entry_safe(feed
, tmp
, &dmxdevfilter
->feed
.ts
, next
) {
543 list_del(&feed
->next
);
547 BUG_ON(!list_empty(&dmxdevfilter
->feed
.ts
));
550 static inline int dvb_dmxdev_filter_reset(struct dmxdev_filter
*dmxdevfilter
)
552 if (dmxdevfilter
->state
< DMXDEV_STATE_SET
)
555 if (dmxdevfilter
->type
== DMXDEV_TYPE_PES
)
556 dvb_dmxdev_delete_pids(dmxdevfilter
);
558 dmxdevfilter
->type
= DMXDEV_TYPE_NONE
;
559 dvb_dmxdev_filter_state_set(dmxdevfilter
, DMXDEV_STATE_ALLOCATED
);
563 static int dvb_dmxdev_start_feed(struct dmxdev
*dmxdev
,
564 struct dmxdev_filter
*filter
,
565 struct dmxdev_feed
*feed
)
567 struct timespec timeout
= { 0 };
568 struct dmx_pes_filter_params
*para
= &filter
->params
.pes
;
572 enum dmx_ts_pes ts_pes
;
573 struct dmx_ts_feed
*tsfeed
;
576 otype
= para
->output
;
578 ts_pes
= para
->pes_type
;
580 if (ts_pes
< DMX_PES_OTHER
)
581 ts_type
= TS_DECODER
;
585 if (otype
== DMX_OUT_TS_TAP
)
586 ts_type
|= TS_PACKET
;
587 else if (otype
== DMX_OUT_TSDEMUX_TAP
)
588 ts_type
|= TS_PACKET
| TS_DEMUX
;
589 else if (otype
== DMX_OUT_TAP
)
590 ts_type
|= TS_PACKET
| TS_DEMUX
| TS_PAYLOAD_ONLY
;
592 ret
= dmxdev
->demux
->allocate_ts_feed(dmxdev
->demux
, &feed
->ts
,
593 dvb_dmxdev_ts_callback
);
598 tsfeed
->priv
= filter
;
600 ret
= tsfeed
->set(tsfeed
, feed
->pid
, ts_type
, ts_pes
, 32768, timeout
);
602 dmxdev
->demux
->release_ts_feed(dmxdev
->demux
, tsfeed
);
606 ret
= tsfeed
->start_filtering(tsfeed
);
608 dmxdev
->demux
->release_ts_feed(dmxdev
->demux
, tsfeed
);
615 static int dvb_dmxdev_filter_start(struct dmxdev_filter
*filter
)
617 struct dmxdev
*dmxdev
= filter
->dev
;
618 struct dmxdev_feed
*feed
;
622 if (filter
->state
< DMXDEV_STATE_SET
)
625 if (filter
->state
>= DMXDEV_STATE_GO
)
626 dvb_dmxdev_filter_stop(filter
);
628 if (!filter
->buffer
.data
) {
629 mem
= vmalloc(filter
->buffer
.size
);
632 spin_lock_irq(&filter
->dev
->lock
);
633 filter
->buffer
.data
= mem
;
634 spin_unlock_irq(&filter
->dev
->lock
);
637 dvb_ringbuffer_flush(&filter
->buffer
);
639 switch (filter
->type
) {
640 case DMXDEV_TYPE_SEC
:
642 struct dmx_sct_filter_params
*para
= &filter
->params
.sec
;
643 struct dmx_section_filter
**secfilter
= &filter
->filter
.sec
;
644 struct dmx_section_feed
**secfeed
= &filter
->feed
.sec
;
650 /* find active filter/feed with same PID */
651 for (i
= 0; i
< dmxdev
->filternum
; i
++) {
652 if (dmxdev
->filter
[i
].state
>= DMXDEV_STATE_GO
&&
653 dmxdev
->filter
[i
].type
== DMXDEV_TYPE_SEC
&&
654 dmxdev
->filter
[i
].params
.sec
.pid
== para
->pid
) {
655 *secfeed
= dmxdev
->filter
[i
].feed
.sec
;
660 /* if no feed found, try to allocate new one */
662 ret
= dmxdev
->demux
->allocate_section_feed(dmxdev
->demux
,
664 dvb_dmxdev_section_callback
);
666 printk("DVB (%s): could not alloc feed\n",
671 ret
= (*secfeed
)->set(*secfeed
, para
->pid
, 32768,
672 (para
->flags
& DMX_CHECK_CRC
) ? 1 : 0);
674 printk("DVB (%s): could not set feed\n",
676 dvb_dmxdev_feed_restart(filter
);
680 dvb_dmxdev_feed_stop(filter
);
683 ret
= (*secfeed
)->allocate_filter(*secfeed
, secfilter
);
685 dvb_dmxdev_feed_restart(filter
);
686 filter
->feed
.sec
->start_filtering(*secfeed
);
687 dprintk("could not get filter\n");
691 (*secfilter
)->priv
= filter
;
693 memcpy(&((*secfilter
)->filter_value
[3]),
694 &(para
->filter
.filter
[1]), DMX_FILTER_SIZE
- 1);
695 memcpy(&(*secfilter
)->filter_mask
[3],
696 ¶
->filter
.mask
[1], DMX_FILTER_SIZE
- 1);
697 memcpy(&(*secfilter
)->filter_mode
[3],
698 ¶
->filter
.mode
[1], DMX_FILTER_SIZE
- 1);
700 (*secfilter
)->filter_value
[0] = para
->filter
.filter
[0];
701 (*secfilter
)->filter_mask
[0] = para
->filter
.mask
[0];
702 (*secfilter
)->filter_mode
[0] = para
->filter
.mode
[0];
703 (*secfilter
)->filter_mask
[1] = 0;
704 (*secfilter
)->filter_mask
[2] = 0;
708 ret
= filter
->feed
.sec
->start_filtering(filter
->feed
.sec
);
712 dvb_dmxdev_filter_timer(filter
);
715 case DMXDEV_TYPE_PES
:
716 list_for_each_entry(feed
, &filter
->feed
.ts
, next
) {
717 ret
= dvb_dmxdev_start_feed(dmxdev
, filter
, feed
);
719 dvb_dmxdev_filter_stop(filter
);
728 dvb_dmxdev_filter_state_set(filter
, DMXDEV_STATE_GO
);
732 static int dvb_demux_open(struct inode
*inode
, struct file
*file
)
734 struct dvb_device
*dvbdev
= file
->private_data
;
735 struct dmxdev
*dmxdev
= dvbdev
->priv
;
737 struct dmxdev_filter
*dmxdevfilter
;
742 if (mutex_lock_interruptible(&dmxdev
->mutex
))
745 for (i
= 0; i
< dmxdev
->filternum
; i
++)
746 if (dmxdev
->filter
[i
].state
== DMXDEV_STATE_FREE
)
749 if (i
== dmxdev
->filternum
) {
750 mutex_unlock(&dmxdev
->mutex
);
754 dmxdevfilter
= &dmxdev
->filter
[i
];
755 mutex_init(&dmxdevfilter
->mutex
);
756 file
->private_data
= dmxdevfilter
;
758 dvb_ringbuffer_init(&dmxdevfilter
->buffer
, NULL
, 8192);
759 dmxdevfilter
->type
= DMXDEV_TYPE_NONE
;
760 dvb_dmxdev_filter_state_set(dmxdevfilter
, DMXDEV_STATE_ALLOCATED
);
761 init_timer(&dmxdevfilter
->timer
);
765 mutex_unlock(&dmxdev
->mutex
);
769 static int dvb_dmxdev_filter_free(struct dmxdev
*dmxdev
,
770 struct dmxdev_filter
*dmxdevfilter
)
772 mutex_lock(&dmxdev
->mutex
);
773 mutex_lock(&dmxdevfilter
->mutex
);
775 dvb_dmxdev_filter_stop(dmxdevfilter
);
776 dvb_dmxdev_filter_reset(dmxdevfilter
);
778 if (dmxdevfilter
->buffer
.data
) {
779 void *mem
= dmxdevfilter
->buffer
.data
;
781 spin_lock_irq(&dmxdev
->lock
);
782 dmxdevfilter
->buffer
.data
= NULL
;
783 spin_unlock_irq(&dmxdev
->lock
);
787 dvb_dmxdev_filter_state_set(dmxdevfilter
, DMXDEV_STATE_FREE
);
788 wake_up(&dmxdevfilter
->buffer
.queue
);
789 mutex_unlock(&dmxdevfilter
->mutex
);
790 mutex_unlock(&dmxdev
->mutex
);
794 static inline void invert_mode(dmx_filter_t
*filter
)
798 for (i
= 0; i
< DMX_FILTER_SIZE
; i
++)
799 filter
->mode
[i
] ^= 0xff;
802 static int dvb_dmxdev_add_pid(struct dmxdev
*dmxdev
,
803 struct dmxdev_filter
*filter
, u16 pid
)
805 struct dmxdev_feed
*feed
;
807 if ((filter
->type
!= DMXDEV_TYPE_PES
) ||
808 (filter
->state
< DMXDEV_STATE_SET
))
811 /* only TS packet filters may have multiple PIDs */
812 if ((filter
->params
.pes
.output
!= DMX_OUT_TSDEMUX_TAP
) &&
813 (!list_empty(&filter
->feed
.ts
)))
816 feed
= kzalloc(sizeof(struct dmxdev_feed
), GFP_KERNEL
);
821 list_add(&feed
->next
, &filter
->feed
.ts
);
823 if (filter
->state
>= DMXDEV_STATE_GO
)
824 return dvb_dmxdev_start_feed(dmxdev
, filter
, feed
);
829 static int dvb_dmxdev_remove_pid(struct dmxdev
*dmxdev
,
830 struct dmxdev_filter
*filter
, u16 pid
)
832 struct dmxdev_feed
*feed
, *tmp
;
834 if ((filter
->type
!= DMXDEV_TYPE_PES
) ||
835 (filter
->state
< DMXDEV_STATE_SET
))
838 list_for_each_entry_safe(feed
, tmp
, &filter
->feed
.ts
, next
) {
839 if ((feed
->pid
== pid
) && (feed
->ts
!= NULL
)) {
840 feed
->ts
->stop_filtering(feed
->ts
);
841 filter
->dev
->demux
->release_ts_feed(filter
->dev
->demux
,
843 list_del(&feed
->next
);
851 static int dvb_dmxdev_filter_set(struct dmxdev
*dmxdev
,
852 struct dmxdev_filter
*dmxdevfilter
,
853 struct dmx_sct_filter_params
*params
)
855 dprintk("function : %s, PID=0x%04x, flags=%02x, timeout=%d\n",
856 __func__
, params
->pid
, params
->flags
, params
->timeout
);
858 dvb_dmxdev_filter_stop(dmxdevfilter
);
860 dmxdevfilter
->type
= DMXDEV_TYPE_SEC
;
861 memcpy(&dmxdevfilter
->params
.sec
,
862 params
, sizeof(struct dmx_sct_filter_params
));
863 invert_mode(&dmxdevfilter
->params
.sec
.filter
);
864 dvb_dmxdev_filter_state_set(dmxdevfilter
, DMXDEV_STATE_SET
);
866 if (params
->flags
& DMX_IMMEDIATE_START
)
867 return dvb_dmxdev_filter_start(dmxdevfilter
);
872 static int dvb_dmxdev_pes_filter_set(struct dmxdev
*dmxdev
,
873 struct dmxdev_filter
*dmxdevfilter
,
874 struct dmx_pes_filter_params
*params
)
878 dvb_dmxdev_filter_stop(dmxdevfilter
);
879 dvb_dmxdev_filter_reset(dmxdevfilter
);
881 if ((unsigned)params
->pes_type
> DMX_PES_OTHER
)
884 dmxdevfilter
->type
= DMXDEV_TYPE_PES
;
885 memcpy(&dmxdevfilter
->params
, params
,
886 sizeof(struct dmx_pes_filter_params
));
887 INIT_LIST_HEAD(&dmxdevfilter
->feed
.ts
);
889 dvb_dmxdev_filter_state_set(dmxdevfilter
, DMXDEV_STATE_SET
);
891 ret
= dvb_dmxdev_add_pid(dmxdev
, dmxdevfilter
,
892 dmxdevfilter
->params
.pes
.pid
);
896 if (params
->flags
& DMX_IMMEDIATE_START
)
897 return dvb_dmxdev_filter_start(dmxdevfilter
);
902 static ssize_t
dvb_dmxdev_read_sec(struct dmxdev_filter
*dfil
,
903 struct file
*file
, char __user
*buf
,
904 size_t count
, loff_t
*ppos
)
909 if (dfil
->todo
<= 0) {
910 hcount
= 3 + dfil
->todo
;
913 result
= dvb_dmxdev_buffer_read(&dfil
->buffer
,
914 file
->f_flags
& O_NONBLOCK
,
920 if (copy_from_user(dfil
->secheader
- dfil
->todo
, buf
, result
))
925 dfil
->todo
-= result
;
928 dfil
->todo
= ((dfil
->secheader
[1] << 8) | dfil
->secheader
[2]) & 0xfff;
932 if (count
> dfil
->todo
)
934 result
= dvb_dmxdev_buffer_read(&dfil
->buffer
,
935 file
->f_flags
& O_NONBLOCK
,
939 dfil
->todo
-= result
;
940 return (result
+ done
);
944 dvb_demux_read(struct file
*file
, char __user
*buf
, size_t count
,
947 struct dmxdev_filter
*dmxdevfilter
= file
->private_data
;
950 if (mutex_lock_interruptible(&dmxdevfilter
->mutex
))
953 if (dmxdevfilter
->type
== DMXDEV_TYPE_SEC
)
954 ret
= dvb_dmxdev_read_sec(dmxdevfilter
, file
, buf
, count
, ppos
);
956 ret
= dvb_dmxdev_buffer_read(&dmxdevfilter
->buffer
,
957 file
->f_flags
& O_NONBLOCK
,
960 mutex_unlock(&dmxdevfilter
->mutex
);
964 static int dvb_demux_do_ioctl(struct file
*file
,
965 unsigned int cmd
, void *parg
)
967 struct dmxdev_filter
*dmxdevfilter
= file
->private_data
;
968 struct dmxdev
*dmxdev
= dmxdevfilter
->dev
;
969 unsigned long arg
= (unsigned long)parg
;
972 if (mutex_lock_interruptible(&dmxdev
->mutex
))
977 if (mutex_lock_interruptible(&dmxdevfilter
->mutex
)) {
978 mutex_unlock(&dmxdev
->mutex
);
981 if (dmxdevfilter
->state
< DMXDEV_STATE_SET
)
984 ret
= dvb_dmxdev_filter_start(dmxdevfilter
);
985 mutex_unlock(&dmxdevfilter
->mutex
);
989 if (mutex_lock_interruptible(&dmxdevfilter
->mutex
)) {
990 mutex_unlock(&dmxdev
->mutex
);
993 ret
= dvb_dmxdev_filter_stop(dmxdevfilter
);
994 mutex_unlock(&dmxdevfilter
->mutex
);
998 if (mutex_lock_interruptible(&dmxdevfilter
->mutex
)) {
999 mutex_unlock(&dmxdev
->mutex
);
1000 return -ERESTARTSYS
;
1002 ret
= dvb_dmxdev_filter_set(dmxdev
, dmxdevfilter
, parg
);
1003 mutex_unlock(&dmxdevfilter
->mutex
);
1006 case DMX_SET_PES_FILTER
:
1007 if (mutex_lock_interruptible(&dmxdevfilter
->mutex
)) {
1008 mutex_unlock(&dmxdev
->mutex
);
1009 return -ERESTARTSYS
;
1011 ret
= dvb_dmxdev_pes_filter_set(dmxdev
, dmxdevfilter
, parg
);
1012 mutex_unlock(&dmxdevfilter
->mutex
);
1015 case DMX_SET_BUFFER_SIZE
:
1016 if (mutex_lock_interruptible(&dmxdevfilter
->mutex
)) {
1017 mutex_unlock(&dmxdev
->mutex
);
1018 return -ERESTARTSYS
;
1020 ret
= dvb_dmxdev_set_buffer_size(dmxdevfilter
, arg
);
1021 mutex_unlock(&dmxdevfilter
->mutex
);
1024 case DMX_GET_PES_PIDS
:
1025 if (!dmxdev
->demux
->get_pes_pids
) {
1029 dmxdev
->demux
->get_pes_pids(dmxdev
->demux
, parg
);
1033 if (!dmxdev
->demux
->get_caps
) {
1037 ret
= dmxdev
->demux
->get_caps(dmxdev
->demux
, parg
);
1040 case DMX_SET_SOURCE
:
1041 if (!dmxdev
->demux
->set_source
) {
1045 ret
= dmxdev
->demux
->set_source(dmxdev
->demux
, parg
);
1049 if (!dmxdev
->demux
->get_stc
) {
1053 ret
= dmxdev
->demux
->get_stc(dmxdev
->demux
,
1054 ((struct dmx_stc
*)parg
)->num
,
1055 &((struct dmx_stc
*)parg
)->stc
,
1056 &((struct dmx_stc
*)parg
)->base
);
1060 if (mutex_lock_interruptible(&dmxdevfilter
->mutex
)) {
1064 ret
= dvb_dmxdev_add_pid(dmxdev
, dmxdevfilter
, *(u16
*)parg
);
1065 mutex_unlock(&dmxdevfilter
->mutex
);
1068 case DMX_REMOVE_PID
:
1069 if (mutex_lock_interruptible(&dmxdevfilter
->mutex
)) {
1073 ret
= dvb_dmxdev_remove_pid(dmxdev
, dmxdevfilter
, *(u16
*)parg
);
1074 mutex_unlock(&dmxdevfilter
->mutex
);
1081 mutex_unlock(&dmxdev
->mutex
);
1085 static long dvb_demux_ioctl(struct file
*file
, unsigned int cmd
,
1088 return dvb_usercopy(file
, cmd
, arg
, dvb_demux_do_ioctl
);
1091 static unsigned int dvb_demux_poll(struct file
*file
, poll_table
*wait
)
1093 struct dmxdev_filter
*dmxdevfilter
= file
->private_data
;
1094 unsigned int mask
= 0;
1099 poll_wait(file
, &dmxdevfilter
->buffer
.queue
, wait
);
1101 if (dmxdevfilter
->state
!= DMXDEV_STATE_GO
&&
1102 dmxdevfilter
->state
!= DMXDEV_STATE_DONE
&&
1103 dmxdevfilter
->state
!= DMXDEV_STATE_TIMEDOUT
)
1106 if (dmxdevfilter
->buffer
.error
)
1107 mask
|= (POLLIN
| POLLRDNORM
| POLLPRI
| POLLERR
);
1109 if (!dvb_ringbuffer_empty(&dmxdevfilter
->buffer
))
1110 mask
|= (POLLIN
| POLLRDNORM
| POLLPRI
);
1115 static int dvb_demux_release(struct inode
*inode
, struct file
*file
)
1117 struct dmxdev_filter
*dmxdevfilter
= file
->private_data
;
1118 struct dmxdev
*dmxdev
= dmxdevfilter
->dev
;
1122 ret
= dvb_dmxdev_filter_free(dmxdev
, dmxdevfilter
);
1124 mutex_lock(&dmxdev
->mutex
);
1125 dmxdev
->dvbdev
->users
--;
1126 if(dmxdev
->dvbdev
->users
==1 && dmxdev
->exit
==1) {
1127 fops_put(file
->f_op
);
1129 mutex_unlock(&dmxdev
->mutex
);
1130 wake_up(&dmxdev
->dvbdev
->wait_queue
);
1132 mutex_unlock(&dmxdev
->mutex
);
1137 static const struct file_operations dvb_demux_fops
= {
1138 .owner
= THIS_MODULE
,
1139 .read
= dvb_demux_read
,
1140 .unlocked_ioctl
= dvb_demux_ioctl
,
1141 .open
= dvb_demux_open
,
1142 .release
= dvb_demux_release
,
1143 .poll
= dvb_demux_poll
,
1144 .llseek
= default_llseek
,
1147 static struct dvb_device dvbdev_demux
= {
1151 .fops
= &dvb_demux_fops
1154 static int dvb_dvr_do_ioctl(struct file
*file
,
1155 unsigned int cmd
, void *parg
)
1157 struct dvb_device
*dvbdev
= file
->private_data
;
1158 struct dmxdev
*dmxdev
= dvbdev
->priv
;
1159 unsigned long arg
= (unsigned long)parg
;
1162 if (mutex_lock_interruptible(&dmxdev
->mutex
))
1163 return -ERESTARTSYS
;
1166 case DMX_SET_BUFFER_SIZE
:
1167 ret
= dvb_dvr_set_buffer_size(dmxdev
, arg
);
1174 mutex_unlock(&dmxdev
->mutex
);
1178 static long dvb_dvr_ioctl(struct file
*file
,
1179 unsigned int cmd
, unsigned long arg
)
1181 return dvb_usercopy(file
, cmd
, arg
, dvb_dvr_do_ioctl
);
1184 static unsigned int dvb_dvr_poll(struct file
*file
, poll_table
*wait
)
1186 struct dvb_device
*dvbdev
= file
->private_data
;
1187 struct dmxdev
*dmxdev
= dvbdev
->priv
;
1188 unsigned int mask
= 0;
1190 dprintk("function : %s\n", __func__
);
1192 poll_wait(file
, &dmxdev
->dvr_buffer
.queue
, wait
);
1194 if ((file
->f_flags
& O_ACCMODE
) == O_RDONLY
) {
1195 if (dmxdev
->dvr_buffer
.error
)
1196 mask
|= (POLLIN
| POLLRDNORM
| POLLPRI
| POLLERR
);
1198 if (!dvb_ringbuffer_empty(&dmxdev
->dvr_buffer
))
1199 mask
|= (POLLIN
| POLLRDNORM
| POLLPRI
);
1201 mask
|= (POLLOUT
| POLLWRNORM
| POLLPRI
);
1206 static const struct file_operations dvb_dvr_fops
= {
1207 .owner
= THIS_MODULE
,
1208 .read
= dvb_dvr_read
,
1209 .write
= dvb_dvr_write
,
1210 .unlocked_ioctl
= dvb_dvr_ioctl
,
1211 .open
= dvb_dvr_open
,
1212 .release
= dvb_dvr_release
,
1213 .poll
= dvb_dvr_poll
,
1214 .llseek
= default_llseek
,
1217 static struct dvb_device dvbdev_dvr
= {
1221 .fops
= &dvb_dvr_fops
1224 int dvb_dmxdev_init(struct dmxdev
*dmxdev
, struct dvb_adapter
*dvb_adapter
)
1228 if (dmxdev
->demux
->open(dmxdev
->demux
) < 0)
1231 dmxdev
->filter
= vmalloc(dmxdev
->filternum
* sizeof(struct dmxdev_filter
));
1232 if (!dmxdev
->filter
)
1235 mutex_init(&dmxdev
->mutex
);
1236 spin_lock_init(&dmxdev
->lock
);
1237 for (i
= 0; i
< dmxdev
->filternum
; i
++) {
1238 dmxdev
->filter
[i
].dev
= dmxdev
;
1239 dmxdev
->filter
[i
].buffer
.data
= NULL
;
1240 dvb_dmxdev_filter_state_set(&dmxdev
->filter
[i
],
1244 dvb_register_device(dvb_adapter
, &dmxdev
->dvbdev
, &dvbdev_demux
, dmxdev
,
1246 dvb_register_device(dvb_adapter
, &dmxdev
->dvr_dvbdev
, &dvbdev_dvr
,
1247 dmxdev
, DVB_DEVICE_DVR
);
1249 dvb_ringbuffer_init(&dmxdev
->dvr_buffer
, NULL
, 8192);
1254 EXPORT_SYMBOL(dvb_dmxdev_init
);
1256 void dvb_dmxdev_release(struct dmxdev
*dmxdev
)
1259 if (dmxdev
->dvbdev
->users
> 1) {
1260 wait_event(dmxdev
->dvbdev
->wait_queue
,
1261 dmxdev
->dvbdev
->users
==1);
1263 if (dmxdev
->dvr_dvbdev
->users
> 1) {
1264 wait_event(dmxdev
->dvr_dvbdev
->wait_queue
,
1265 dmxdev
->dvr_dvbdev
->users
==1);
1268 dvb_unregister_device(dmxdev
->dvbdev
);
1269 dvb_unregister_device(dmxdev
->dvr_dvbdev
);
1271 vfree(dmxdev
->filter
);
1272 dmxdev
->filter
= NULL
;
1273 dmxdev
->demux
->close(dmxdev
->demux
);
1276 EXPORT_SYMBOL(dvb_dmxdev_release
);