2 * dmxdev.c - DVB demultiplexer device
4 * Copyright (C) 2000 Ralph Metzler <ralph@convergence.de>
5 * & Marcus Metzler <marcus@convergence.de>
6 for convergence integrated media GmbH
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public License
10 * as published by the Free Software Foundation; either version 2.1
11 * of the License, or (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
24 #include <linux/spinlock.h>
25 #include <linux/slab.h>
26 #include <linux/vmalloc.h>
27 #include <linux/module.h>
28 #include <linux/moduleparam.h>
29 #include <linux/sched.h>
30 #include <linux/poll.h>
31 #include <linux/ioctl.h>
32 #include <linux/wait.h>
33 #include <asm/uaccess.h>
34 #include <asm/system.h>
40 module_param(debug
, int, 0644);
41 MODULE_PARM_DESC(debug
, "Turn on/off debugging (default:off).");
43 #define dprintk if (debug) printk
45 static inline void dvb_dmxdev_buffer_init(struct dmxdev_buffer
*buffer
)
52 init_waitqueue_head(&buffer
->queue
);
55 static inline int dvb_dmxdev_buffer_write(struct dmxdev_buffer
*buf
, const u8
*src
, int len
)
66 free
=buf
->pread
-buf
->pwrite
;
70 split
=buf
->size
-buf
->pwrite
;
73 dprintk("dmxdev: buffer overflow\n");
80 memcpy(buf
->data
+ buf
->pwrite
, src
, split
);
84 memcpy(buf
->data
+ buf
->pwrite
, src
+split
, todo
);
85 buf
->pwrite
=(buf
->pwrite
+todo
)%buf
->size
;
89 static ssize_t
dvb_dmxdev_buffer_read(struct dmxdev_buffer
*src
,
90 int non_blocking
, char __user
*buf
, size_t count
, loff_t
*ppos
)
92 unsigned long todo
=count
;
93 int split
, avail
, error
;
98 if ((error
=src
->error
)) {
99 src
->pwrite
=src
->pread
;
104 if (non_blocking
&& (src
->pwrite
==src
->pread
))
108 if (non_blocking
&& (src
->pwrite
==src
->pread
))
109 return (count
-todo
) ? (count
-todo
) : -EWOULDBLOCK
;
111 if (wait_event_interruptible(src
->queue
,
112 (src
->pread
!=src
->pwrite
) ||
116 if ((error
=src
->error
)) {
117 src
->pwrite
=src
->pread
;
123 avail
=src
->pwrite
- src
->pread
;
126 split
=src
->size
- src
->pread
;
131 if (copy_to_user(buf
, src
->data
+src
->pread
, split
))
139 if (copy_to_user(buf
, src
->data
+src
->pread
, avail
))
141 src
->pread
= (src
->pread
+ avail
) % src
->size
;
149 static struct dmx_frontend
* get_fe(struct dmx_demux
*demux
, int type
)
151 struct list_head
*head
, *pos
;
153 head
=demux
->get_frontends(demux
);
156 list_for_each(pos
, head
)
157 if (DMX_FE_ENTRY(pos
)->source
==type
)
158 return DMX_FE_ENTRY(pos
);
163 static int dvb_dvr_open(struct inode
*inode
, struct file
*file
)
165 struct dvb_device
*dvbdev
= file
->private_data
;
166 struct dmxdev
*dmxdev
= dvbdev
->priv
;
167 struct dmx_frontend
*front
;
169 dprintk ("function : %s\n", __FUNCTION__
);
171 if (mutex_lock_interruptible(&dmxdev
->mutex
))
174 if ((file
->f_flags
&O_ACCMODE
)==O_RDWR
) {
175 if (!(dmxdev
->capabilities
&DMXDEV_CAP_DUPLEX
)) {
176 mutex_unlock(&dmxdev
->mutex
);
181 if ((file
->f_flags
&O_ACCMODE
)==O_RDONLY
) {
182 dvb_dmxdev_buffer_init(&dmxdev
->dvr_buffer
);
183 dmxdev
->dvr_buffer
.size
=DVR_BUFFER_SIZE
;
184 dmxdev
->dvr_buffer
.data
=vmalloc(DVR_BUFFER_SIZE
);
185 if (!dmxdev
->dvr_buffer
.data
) {
186 mutex_unlock(&dmxdev
->mutex
);
191 if ((file
->f_flags
&O_ACCMODE
)==O_WRONLY
) {
192 dmxdev
->dvr_orig_fe
=dmxdev
->demux
->frontend
;
194 if (!dmxdev
->demux
->write
) {
195 mutex_unlock(&dmxdev
->mutex
);
199 front
=get_fe(dmxdev
->demux
, DMX_MEMORY_FE
);
202 mutex_unlock(&dmxdev
->mutex
);
205 dmxdev
->demux
->disconnect_frontend(dmxdev
->demux
);
206 dmxdev
->demux
->connect_frontend(dmxdev
->demux
, front
);
208 mutex_unlock(&dmxdev
->mutex
);
212 static int dvb_dvr_release(struct inode
*inode
, struct file
*file
)
214 struct dvb_device
*dvbdev
= file
->private_data
;
215 struct dmxdev
*dmxdev
= dvbdev
->priv
;
217 if (mutex_lock_interruptible(&dmxdev
->mutex
))
220 if ((file
->f_flags
&O_ACCMODE
)==O_WRONLY
) {
221 dmxdev
->demux
->disconnect_frontend(dmxdev
->demux
);
222 dmxdev
->demux
->connect_frontend(dmxdev
->demux
,
223 dmxdev
->dvr_orig_fe
);
225 if ((file
->f_flags
&O_ACCMODE
)==O_RDONLY
) {
226 if (dmxdev
->dvr_buffer
.data
) {
227 void *mem
=dmxdev
->dvr_buffer
.data
;
229 spin_lock_irq(&dmxdev
->lock
);
230 dmxdev
->dvr_buffer
.data
=NULL
;
231 spin_unlock_irq(&dmxdev
->lock
);
235 mutex_unlock(&dmxdev
->mutex
);
239 static ssize_t
dvb_dvr_write(struct file
*file
, const char __user
*buf
,
240 size_t count
, loff_t
*ppos
)
242 struct dvb_device
*dvbdev
= file
->private_data
;
243 struct dmxdev
*dmxdev
= dvbdev
->priv
;
246 if (!dmxdev
->demux
->write
)
248 if ((file
->f_flags
&O_ACCMODE
)!=O_WRONLY
)
250 if (mutex_lock_interruptible(&dmxdev
->mutex
))
252 ret
=dmxdev
->demux
->write(dmxdev
->demux
, buf
, count
);
253 mutex_unlock(&dmxdev
->mutex
);
257 static ssize_t
dvb_dvr_read(struct file
*file
, char __user
*buf
, size_t count
,
260 struct dvb_device
*dvbdev
= file
->private_data
;
261 struct dmxdev
*dmxdev
= dvbdev
->priv
;
264 //mutex_lock(&dmxdev->mutex);
265 ret
= dvb_dmxdev_buffer_read(&dmxdev
->dvr_buffer
,
266 file
->f_flags
&O_NONBLOCK
,
268 //mutex_unlock(&dmxdev->mutex);
272 static inline void dvb_dmxdev_filter_state_set(struct dmxdev_filter
*dmxdevfilter
, int state
)
274 spin_lock_irq(&dmxdevfilter
->dev
->lock
);
275 dmxdevfilter
->state
=state
;
276 spin_unlock_irq(&dmxdevfilter
->dev
->lock
);
279 static int dvb_dmxdev_set_buffer_size(struct dmxdev_filter
*dmxdevfilter
, unsigned long size
)
281 struct dmxdev_buffer
*buf
=&dmxdevfilter
->buffer
;
286 if (dmxdevfilter
->state
>=DMXDEV_STATE_GO
)
288 spin_lock_irq(&dmxdevfilter
->dev
->lock
);
292 buf
->pwrite
=buf
->pread
=0;
293 spin_unlock_irq(&dmxdevfilter
->dev
->lock
);
297 mem
=vmalloc(dmxdevfilter
->buffer
.size
);
300 spin_lock_irq(&dmxdevfilter
->dev
->lock
);
302 spin_unlock_irq(&dmxdevfilter
->dev
->lock
);
307 static void dvb_dmxdev_filter_timeout(unsigned long data
)
309 struct dmxdev_filter
*dmxdevfilter
=(struct dmxdev_filter
*)data
;
311 dmxdevfilter
->buffer
.error
=-ETIMEDOUT
;
312 spin_lock_irq(&dmxdevfilter
->dev
->lock
);
313 dmxdevfilter
->state
=DMXDEV_STATE_TIMEDOUT
;
314 spin_unlock_irq(&dmxdevfilter
->dev
->lock
);
315 wake_up(&dmxdevfilter
->buffer
.queue
);
318 static void dvb_dmxdev_filter_timer(struct dmxdev_filter
*dmxdevfilter
)
320 struct dmx_sct_filter_params
*para
=&dmxdevfilter
->params
.sec
;
322 del_timer(&dmxdevfilter
->timer
);
324 dmxdevfilter
->timer
.function
=dvb_dmxdev_filter_timeout
;
325 dmxdevfilter
->timer
.data
=(unsigned long) dmxdevfilter
;
326 dmxdevfilter
->timer
.expires
=jiffies
+1+(HZ
/2+HZ
*para
->timeout
)/1000;
327 add_timer(&dmxdevfilter
->timer
);
331 static int dvb_dmxdev_section_callback(const u8
*buffer1
, size_t buffer1_len
,
332 const u8
*buffer2
, size_t buffer2_len
,
333 struct dmx_section_filter
*filter
, enum dmx_success success
)
335 struct dmxdev_filter
*dmxdevfilter
= filter
->priv
;
338 if (dmxdevfilter
->buffer
.error
) {
339 wake_up(&dmxdevfilter
->buffer
.queue
);
342 spin_lock(&dmxdevfilter
->dev
->lock
);
343 if (dmxdevfilter
->state
!=DMXDEV_STATE_GO
) {
344 spin_unlock(&dmxdevfilter
->dev
->lock
);
347 del_timer(&dmxdevfilter
->timer
);
348 dprintk("dmxdev: section callback %02x %02x %02x %02x %02x %02x\n",
349 buffer1
[0], buffer1
[1],
350 buffer1
[2], buffer1
[3],
351 buffer1
[4], buffer1
[5]);
352 ret
=dvb_dmxdev_buffer_write(&dmxdevfilter
->buffer
, buffer1
, buffer1_len
);
353 if (ret
==buffer1_len
) {
354 ret
=dvb_dmxdev_buffer_write(&dmxdevfilter
->buffer
, buffer2
, buffer2_len
);
357 dmxdevfilter
->buffer
.pwrite
=dmxdevfilter
->buffer
.pread
;
358 dmxdevfilter
->buffer
.error
=-EOVERFLOW
;
360 if (dmxdevfilter
->params
.sec
.flags
&DMX_ONESHOT
)
361 dmxdevfilter
->state
=DMXDEV_STATE_DONE
;
362 spin_unlock(&dmxdevfilter
->dev
->lock
);
363 wake_up(&dmxdevfilter
->buffer
.queue
);
367 static int dvb_dmxdev_ts_callback(const u8
*buffer1
, size_t buffer1_len
,
368 const u8
*buffer2
, size_t buffer2_len
,
369 struct dmx_ts_feed
*feed
, enum dmx_success success
)
371 struct dmxdev_filter
*dmxdevfilter
= feed
->priv
;
372 struct dmxdev_buffer
*buffer
;
375 spin_lock(&dmxdevfilter
->dev
->lock
);
376 if (dmxdevfilter
->params
.pes
.output
==DMX_OUT_DECODER
) {
377 spin_unlock(&dmxdevfilter
->dev
->lock
);
381 if (dmxdevfilter
->params
.pes
.output
==DMX_OUT_TAP
)
382 buffer
=&dmxdevfilter
->buffer
;
384 buffer
=&dmxdevfilter
->dev
->dvr_buffer
;
386 spin_unlock(&dmxdevfilter
->dev
->lock
);
387 wake_up(&buffer
->queue
);
390 ret
=dvb_dmxdev_buffer_write(buffer
, buffer1
, buffer1_len
);
391 if (ret
==buffer1_len
)
392 ret
=dvb_dmxdev_buffer_write(buffer
, buffer2
, buffer2_len
);
394 buffer
->pwrite
=buffer
->pread
;
395 buffer
->error
=-EOVERFLOW
;
397 spin_unlock(&dmxdevfilter
->dev
->lock
);
398 wake_up(&buffer
->queue
);
403 /* stop feed but only mark the specified filter as stopped (state set) */
405 static int dvb_dmxdev_feed_stop(struct dmxdev_filter
*dmxdevfilter
)
407 dvb_dmxdev_filter_state_set(dmxdevfilter
, DMXDEV_STATE_SET
);
409 switch (dmxdevfilter
->type
) {
410 case DMXDEV_TYPE_SEC
:
411 del_timer(&dmxdevfilter
->timer
);
412 dmxdevfilter
->feed
.sec
->stop_filtering(dmxdevfilter
->feed
.sec
);
414 case DMXDEV_TYPE_PES
:
415 dmxdevfilter
->feed
.ts
->stop_filtering(dmxdevfilter
->feed
.ts
);
424 /* start feed associated with the specified filter */
426 static int dvb_dmxdev_feed_start(struct dmxdev_filter
*filter
)
428 dvb_dmxdev_filter_state_set (filter
, DMXDEV_STATE_GO
);
430 switch (filter
->type
) {
431 case DMXDEV_TYPE_SEC
:
432 return filter
->feed
.sec
->start_filtering(filter
->feed
.sec
);
434 case DMXDEV_TYPE_PES
:
435 return filter
->feed
.ts
->start_filtering(filter
->feed
.ts
);
445 /* restart section feed if it has filters left associated with it,
446 otherwise release the feed */
448 static int dvb_dmxdev_feed_restart(struct dmxdev_filter
*filter
)
451 struct dmxdev
*dmxdev
= filter
->dev
;
452 u16 pid
= filter
->params
.sec
.pid
;
454 for (i
=0; i
<dmxdev
->filternum
; i
++)
455 if (dmxdev
->filter
[i
].state
>=DMXDEV_STATE_GO
&&
456 dmxdev
->filter
[i
].type
==DMXDEV_TYPE_SEC
&&
457 dmxdev
->filter
[i
].pid
==pid
) {
458 dvb_dmxdev_feed_start(&dmxdev
->filter
[i
]);
462 filter
->dev
->demux
->release_section_feed(dmxdev
->demux
, filter
->feed
.sec
);
467 static int dvb_dmxdev_filter_stop(struct dmxdev_filter
*dmxdevfilter
)
469 if (dmxdevfilter
->state
<DMXDEV_STATE_GO
)
472 switch (dmxdevfilter
->type
) {
473 case DMXDEV_TYPE_SEC
:
474 if (!dmxdevfilter
->feed
.sec
)
476 dvb_dmxdev_feed_stop(dmxdevfilter
);
477 if (dmxdevfilter
->filter
.sec
)
478 dmxdevfilter
->feed
.sec
->
479 release_filter(dmxdevfilter
->feed
.sec
,
480 dmxdevfilter
->filter
.sec
);
481 dvb_dmxdev_feed_restart(dmxdevfilter
);
482 dmxdevfilter
->feed
.sec
=NULL
;
484 case DMXDEV_TYPE_PES
:
485 if (!dmxdevfilter
->feed
.ts
)
487 dvb_dmxdev_feed_stop(dmxdevfilter
);
488 dmxdevfilter
->dev
->demux
->
489 release_ts_feed(dmxdevfilter
->dev
->demux
,
490 dmxdevfilter
->feed
.ts
);
491 dmxdevfilter
->feed
.ts
=NULL
;
494 if (dmxdevfilter
->state
==DMXDEV_STATE_ALLOCATED
)
498 dmxdevfilter
->buffer
.pwrite
=dmxdevfilter
->buffer
.pread
=0;
502 static inline int dvb_dmxdev_filter_reset(struct dmxdev_filter
*dmxdevfilter
)
504 if (dmxdevfilter
->state
<DMXDEV_STATE_SET
)
507 dmxdevfilter
->type
=DMXDEV_TYPE_NONE
;
508 dmxdevfilter
->pid
=0xffff;
509 dvb_dmxdev_filter_state_set(dmxdevfilter
, DMXDEV_STATE_ALLOCATED
);
513 static int dvb_dmxdev_filter_start(struct dmxdev_filter
*filter
)
515 struct dmxdev
*dmxdev
= filter
->dev
;
519 if (filter
->state
< DMXDEV_STATE_SET
)
522 if (filter
->state
>= DMXDEV_STATE_GO
)
523 dvb_dmxdev_filter_stop(filter
);
525 if (!(mem
= filter
->buffer
.data
)) {
526 mem
= vmalloc(filter
->buffer
.size
);
527 spin_lock_irq(&filter
->dev
->lock
);
528 filter
->buffer
.data
=mem
;
529 spin_unlock_irq(&filter
->dev
->lock
);
530 if (!filter
->buffer
.data
)
534 filter
->buffer
.pwrite
= filter
->buffer
.pread
= 0;
536 switch (filter
->type
) {
537 case DMXDEV_TYPE_SEC
:
539 struct dmx_sct_filter_params
*para
=&filter
->params
.sec
;
540 struct dmx_section_filter
**secfilter
=&filter
->filter
.sec
;
541 struct dmx_section_feed
**secfeed
=&filter
->feed
.sec
;
546 /* find active filter/feed with same PID */
547 for (i
=0; i
<dmxdev
->filternum
; i
++) {
548 if (dmxdev
->filter
[i
].state
>= DMXDEV_STATE_GO
&&
549 dmxdev
->filter
[i
].pid
== para
->pid
&&
550 dmxdev
->filter
[i
].type
== DMXDEV_TYPE_SEC
) {
551 *secfeed
= dmxdev
->filter
[i
].feed
.sec
;
556 /* if no feed found, try to allocate new one */
558 ret
=dmxdev
->demux
->allocate_section_feed(dmxdev
->demux
,
560 dvb_dmxdev_section_callback
);
562 printk ("DVB (%s): could not alloc feed\n",
567 ret
=(*secfeed
)->set(*secfeed
, para
->pid
, 32768,
568 (para
->flags
& DMX_CHECK_CRC
) ? 1 : 0);
571 printk ("DVB (%s): could not set feed\n",
573 dvb_dmxdev_feed_restart(filter
);
577 dvb_dmxdev_feed_stop(filter
);
580 ret
=(*secfeed
)->allocate_filter(*secfeed
, secfilter
);
583 dvb_dmxdev_feed_restart(filter
);
584 filter
->feed
.sec
->start_filtering(*secfeed
);
585 dprintk ("could not get filter\n");
589 (*secfilter
)->priv
= filter
;
591 memcpy(&((*secfilter
)->filter_value
[3]),
592 &(para
->filter
.filter
[1]), DMX_FILTER_SIZE
-1);
593 memcpy(&(*secfilter
)->filter_mask
[3],
594 ¶
->filter
.mask
[1], DMX_FILTER_SIZE
-1);
595 memcpy(&(*secfilter
)->filter_mode
[3],
596 ¶
->filter
.mode
[1], DMX_FILTER_SIZE
-1);
598 (*secfilter
)->filter_value
[0]=para
->filter
.filter
[0];
599 (*secfilter
)->filter_mask
[0]=para
->filter
.mask
[0];
600 (*secfilter
)->filter_mode
[0]=para
->filter
.mode
[0];
601 (*secfilter
)->filter_mask
[1]=0;
602 (*secfilter
)->filter_mask
[2]=0;
606 ret
= filter
->feed
.sec
->start_filtering (filter
->feed
.sec
);
611 dvb_dmxdev_filter_timer(filter
);
615 case DMXDEV_TYPE_PES
:
617 struct timespec timeout
= { 0 };
618 struct dmx_pes_filter_params
*para
= &filter
->params
.pes
;
622 enum dmx_ts_pes ts_pes
;
623 struct dmx_ts_feed
**tsfeed
= &filter
->feed
.ts
;
625 filter
->feed
.ts
= NULL
;
628 ts_pes
=(enum dmx_ts_pes
) para
->pes_type
;
630 if (ts_pes
<DMX_PES_OTHER
)
635 if (otype
== DMX_OUT_TS_TAP
)
636 ts_type
|= TS_PACKET
;
638 if (otype
== DMX_OUT_TAP
)
639 ts_type
|= TS_PAYLOAD_ONLY
|TS_PACKET
;
641 ret
=dmxdev
->demux
->allocate_ts_feed(dmxdev
->demux
,
643 dvb_dmxdev_ts_callback
);
647 (*tsfeed
)->priv
= (void *) filter
;
649 ret
= (*tsfeed
)->set(*tsfeed
, para
->pid
, ts_type
, ts_pes
,
653 dmxdev
->demux
->release_ts_feed(dmxdev
->demux
, *tsfeed
);
657 ret
= filter
->feed
.ts
->start_filtering(filter
->feed
.ts
);
660 dmxdev
->demux
->release_ts_feed(dmxdev
->demux
, *tsfeed
);
670 dvb_dmxdev_filter_state_set(filter
, DMXDEV_STATE_GO
);
674 static int dvb_demux_open(struct inode
*inode
, struct file
*file
)
676 struct dvb_device
*dvbdev
= file
->private_data
;
677 struct dmxdev
*dmxdev
= dvbdev
->priv
;
679 struct dmxdev_filter
*dmxdevfilter
;
684 if (mutex_lock_interruptible(&dmxdev
->mutex
))
687 for (i
=0; i
<dmxdev
->filternum
; i
++)
688 if (dmxdev
->filter
[i
].state
==DMXDEV_STATE_FREE
)
691 if (i
==dmxdev
->filternum
) {
692 mutex_unlock(&dmxdev
->mutex
);
696 dmxdevfilter
=&dmxdev
->filter
[i
];
697 mutex_init(&dmxdevfilter
->mutex
);
698 dmxdevfilter
->dvbdev
=dmxdev
->dvbdev
;
699 file
->private_data
=dmxdevfilter
;
701 dvb_dmxdev_buffer_init(&dmxdevfilter
->buffer
);
702 dmxdevfilter
->type
=DMXDEV_TYPE_NONE
;
703 dvb_dmxdev_filter_state_set(dmxdevfilter
, DMXDEV_STATE_ALLOCATED
);
704 dmxdevfilter
->feed
.ts
=NULL
;
705 init_timer(&dmxdevfilter
->timer
);
707 mutex_unlock(&dmxdev
->mutex
);
712 static int dvb_dmxdev_filter_free(struct dmxdev
*dmxdev
, struct dmxdev_filter
*dmxdevfilter
)
714 if (mutex_lock_interruptible(&dmxdev
->mutex
))
717 if (mutex_lock_interruptible(&dmxdevfilter
->mutex
)) {
718 mutex_unlock(&dmxdev
->mutex
);
722 dvb_dmxdev_filter_stop(dmxdevfilter
);
723 dvb_dmxdev_filter_reset(dmxdevfilter
);
725 if (dmxdevfilter
->buffer
.data
) {
726 void *mem
=dmxdevfilter
->buffer
.data
;
728 spin_lock_irq(&dmxdev
->lock
);
729 dmxdevfilter
->buffer
.data
=NULL
;
730 spin_unlock_irq(&dmxdev
->lock
);
734 dvb_dmxdev_filter_state_set(dmxdevfilter
, DMXDEV_STATE_FREE
);
735 wake_up(&dmxdevfilter
->buffer
.queue
);
736 mutex_unlock(&dmxdevfilter
->mutex
);
737 mutex_unlock(&dmxdev
->mutex
);
741 static inline void invert_mode(dmx_filter_t
*filter
)
745 for (i
=0; i
<DMX_FILTER_SIZE
; i
++)
746 filter
->mode
[i
]^=0xff;
750 static int dvb_dmxdev_filter_set(struct dmxdev
*dmxdev
,
751 struct dmxdev_filter
*dmxdevfilter
,
752 struct dmx_sct_filter_params
*params
)
754 dprintk ("function : %s\n", __FUNCTION__
);
756 dvb_dmxdev_filter_stop(dmxdevfilter
);
758 dmxdevfilter
->type
=DMXDEV_TYPE_SEC
;
759 dmxdevfilter
->pid
=params
->pid
;
760 memcpy(&dmxdevfilter
->params
.sec
,
761 params
, sizeof(struct dmx_sct_filter_params
));
762 invert_mode(&dmxdevfilter
->params
.sec
.filter
);
763 dvb_dmxdev_filter_state_set(dmxdevfilter
, DMXDEV_STATE_SET
);
765 if (params
->flags
&DMX_IMMEDIATE_START
)
766 return dvb_dmxdev_filter_start(dmxdevfilter
);
771 static int dvb_dmxdev_pes_filter_set(struct dmxdev
*dmxdev
,
772 struct dmxdev_filter
*dmxdevfilter
,
773 struct dmx_pes_filter_params
*params
)
775 dvb_dmxdev_filter_stop(dmxdevfilter
);
777 if (params
->pes_type
>DMX_PES_OTHER
|| params
->pes_type
<0)
780 dmxdevfilter
->type
=DMXDEV_TYPE_PES
;
781 dmxdevfilter
->pid
=params
->pid
;
782 memcpy(&dmxdevfilter
->params
, params
, sizeof(struct dmx_pes_filter_params
));
784 dvb_dmxdev_filter_state_set(dmxdevfilter
, DMXDEV_STATE_SET
);
786 if (params
->flags
&DMX_IMMEDIATE_START
)
787 return dvb_dmxdev_filter_start(dmxdevfilter
);
792 static ssize_t
dvb_dmxdev_read_sec(struct dmxdev_filter
*dfil
,
793 struct file
*file
, char __user
*buf
, size_t count
, loff_t
*ppos
)
802 result
=dvb_dmxdev_buffer_read(&dfil
->buffer
, file
->f_flags
&O_NONBLOCK
,
808 if (copy_from_user(dfil
->secheader
-dfil
->todo
, buf
, result
))
816 dfil
->todo
=((dfil
->secheader
[1]<<8)|dfil
->secheader
[2])&0xfff;
820 if (count
>dfil
->todo
)
822 result
=dvb_dmxdev_buffer_read(&dfil
->buffer
, file
->f_flags
&O_NONBLOCK
,
827 return (result
+done
);
832 dvb_demux_read(struct file
*file
, char __user
*buf
, size_t count
, loff_t
*ppos
)
834 struct dmxdev_filter
*dmxdevfilter
= file
->private_data
;
837 if (mutex_lock_interruptible(&dmxdevfilter
->mutex
))
840 if (dmxdevfilter
->type
==DMXDEV_TYPE_SEC
)
841 ret
=dvb_dmxdev_read_sec(dmxdevfilter
, file
, buf
, count
, ppos
);
843 ret
=dvb_dmxdev_buffer_read(&dmxdevfilter
->buffer
,
844 file
->f_flags
&O_NONBLOCK
,
847 mutex_unlock(&dmxdevfilter
->mutex
);
852 static int dvb_demux_do_ioctl(struct inode
*inode
, struct file
*file
,
853 unsigned int cmd
, void *parg
)
855 struct dmxdev_filter
*dmxdevfilter
= file
->private_data
;
856 struct dmxdev
*dmxdev
=dmxdevfilter
->dev
;
857 unsigned long arg
=(unsigned long) parg
;
860 if (mutex_lock_interruptible(&dmxdev
->mutex
))
865 if (mutex_lock_interruptible(&dmxdevfilter
->mutex
)) {
866 mutex_unlock(&dmxdev
->mutex
);
869 if (dmxdevfilter
->state
<DMXDEV_STATE_SET
)
872 ret
= dvb_dmxdev_filter_start(dmxdevfilter
);
873 mutex_unlock(&dmxdevfilter
->mutex
);
877 if (mutex_lock_interruptible(&dmxdevfilter
->mutex
)) {
878 mutex_unlock(&dmxdev
->mutex
);
881 ret
=dvb_dmxdev_filter_stop(dmxdevfilter
);
882 mutex_unlock(&dmxdevfilter
->mutex
);
886 if (mutex_lock_interruptible(&dmxdevfilter
->mutex
)) {
887 mutex_unlock(&dmxdev
->mutex
);
890 ret
= dvb_dmxdev_filter_set(dmxdev
, dmxdevfilter
,
891 (struct dmx_sct_filter_params
*)parg
);
892 mutex_unlock(&dmxdevfilter
->mutex
);
895 case DMX_SET_PES_FILTER
:
896 if (mutex_lock_interruptible(&dmxdevfilter
->mutex
)) {
897 mutex_unlock(&dmxdev
->mutex
);
900 ret
=dvb_dmxdev_pes_filter_set(dmxdev
, dmxdevfilter
,
901 (struct dmx_pes_filter_params
*)parg
);
902 mutex_unlock(&dmxdevfilter
->mutex
);
905 case DMX_SET_BUFFER_SIZE
:
906 if (mutex_lock_interruptible(&dmxdevfilter
->mutex
)) {
907 mutex_unlock(&dmxdev
->mutex
);
910 ret
=dvb_dmxdev_set_buffer_size(dmxdevfilter
, arg
);
911 mutex_unlock(&dmxdevfilter
->mutex
);
917 case DMX_GET_PES_PIDS
:
918 if (!dmxdev
->demux
->get_pes_pids
) {
922 dmxdev
->demux
->get_pes_pids(dmxdev
->demux
, (u16
*)parg
);
926 if (!dmxdev
->demux
->get_caps
) {
930 ret
= dmxdev
->demux
->get_caps(dmxdev
->demux
, parg
);
934 if (!dmxdev
->demux
->set_source
) {
938 ret
= dmxdev
->demux
->set_source(dmxdev
->demux
, parg
);
942 if (!dmxdev
->demux
->get_stc
) {
946 ret
= dmxdev
->demux
->get_stc(dmxdev
->demux
,
947 ((struct dmx_stc
*)parg
)->num
,
948 &((struct dmx_stc
*)parg
)->stc
,
949 &((struct dmx_stc
*)parg
)->base
);
955 mutex_unlock(&dmxdev
->mutex
);
959 static int dvb_demux_ioctl(struct inode
*inode
, struct file
*file
,
960 unsigned int cmd
, unsigned long arg
)
962 return dvb_usercopy(inode
, file
, cmd
, arg
, dvb_demux_do_ioctl
);
966 static unsigned int dvb_demux_poll (struct file
*file
, poll_table
*wait
)
968 struct dmxdev_filter
*dmxdevfilter
= file
->private_data
;
969 unsigned int mask
= 0;
974 poll_wait(file
, &dmxdevfilter
->buffer
.queue
, wait
);
976 if (dmxdevfilter
->state
!= DMXDEV_STATE_GO
&&
977 dmxdevfilter
->state
!= DMXDEV_STATE_DONE
&&
978 dmxdevfilter
->state
!= DMXDEV_STATE_TIMEDOUT
)
981 if (dmxdevfilter
->buffer
.error
)
982 mask
|= (POLLIN
| POLLRDNORM
| POLLPRI
| POLLERR
);
984 if (dmxdevfilter
->buffer
.pread
!= dmxdevfilter
->buffer
.pwrite
)
985 mask
|= (POLLIN
| POLLRDNORM
| POLLPRI
);
991 static int dvb_demux_release(struct inode
*inode
, struct file
*file
)
993 struct dmxdev_filter
*dmxdevfilter
= file
->private_data
;
994 struct dmxdev
*dmxdev
= dmxdevfilter
->dev
;
996 return dvb_dmxdev_filter_free(dmxdev
, dmxdevfilter
);
1000 static struct file_operations dvb_demux_fops
= {
1001 .owner
= THIS_MODULE
,
1002 .read
= dvb_demux_read
,
1003 .ioctl
= dvb_demux_ioctl
,
1004 .open
= dvb_demux_open
,
1005 .release
= dvb_demux_release
,
1006 .poll
= dvb_demux_poll
,
1010 static struct dvb_device dvbdev_demux
= {
1014 .fops
= &dvb_demux_fops
1018 static int dvb_dvr_do_ioctl(struct inode
*inode
, struct file
*file
,
1019 unsigned int cmd
, void *parg
)
1021 struct dvb_device
*dvbdev
= file
->private_data
;
1022 struct dmxdev
*dmxdev
= dvbdev
->priv
;
1026 if (mutex_lock_interruptible(&dmxdev
->mutex
))
1027 return -ERESTARTSYS
;
1030 case DMX_SET_BUFFER_SIZE
:
1038 mutex_unlock(&dmxdev
->mutex
);
1043 static int dvb_dvr_ioctl(struct inode
*inode
, struct file
*file
,
1044 unsigned int cmd
, unsigned long arg
)
1046 return dvb_usercopy(inode
, file
, cmd
, arg
, dvb_dvr_do_ioctl
);
1050 static unsigned int dvb_dvr_poll (struct file
*file
, poll_table
*wait
)
1052 struct dvb_device
*dvbdev
= file
->private_data
;
1053 struct dmxdev
*dmxdev
= dvbdev
->priv
;
1054 unsigned int mask
= 0;
1056 dprintk ("function : %s\n", __FUNCTION__
);
1058 poll_wait(file
, &dmxdev
->dvr_buffer
.queue
, wait
);
1060 if ((file
->f_flags
&O_ACCMODE
) == O_RDONLY
) {
1061 if (dmxdev
->dvr_buffer
.error
)
1062 mask
|= (POLLIN
| POLLRDNORM
| POLLPRI
| POLLERR
);
1064 if (dmxdev
->dvr_buffer
.pread
!=dmxdev
->dvr_buffer
.pwrite
)
1065 mask
|= (POLLIN
| POLLRDNORM
| POLLPRI
);
1067 mask
|= (POLLOUT
| POLLWRNORM
| POLLPRI
);
1073 static struct file_operations dvb_dvr_fops
= {
1074 .owner
= THIS_MODULE
,
1075 .read
= dvb_dvr_read
,
1076 .write
= dvb_dvr_write
,
1077 .ioctl
= dvb_dvr_ioctl
,
1078 .open
= dvb_dvr_open
,
1079 .release
= dvb_dvr_release
,
1080 .poll
= dvb_dvr_poll
,
1083 static struct dvb_device dvbdev_dvr
= {
1087 .fops
= &dvb_dvr_fops
1091 dvb_dmxdev_init(struct dmxdev
*dmxdev
, struct dvb_adapter
*dvb_adapter
)
1095 if (dmxdev
->demux
->open(dmxdev
->demux
) < 0)
1098 dmxdev
->filter
= vmalloc(dmxdev
->filternum
*sizeof(struct dmxdev_filter
));
1099 if (!dmxdev
->filter
)
1102 mutex_init(&dmxdev
->mutex
);
1103 spin_lock_init(&dmxdev
->lock
);
1104 for (i
=0; i
<dmxdev
->filternum
; i
++) {
1105 dmxdev
->filter
[i
].dev
=dmxdev
;
1106 dmxdev
->filter
[i
].buffer
.data
=NULL
;
1107 dvb_dmxdev_filter_state_set(&dmxdev
->filter
[i
], DMXDEV_STATE_FREE
);
1110 dvb_register_device(dvb_adapter
, &dmxdev
->dvbdev
, &dvbdev_demux
, dmxdev
, DVB_DEVICE_DEMUX
);
1111 dvb_register_device(dvb_adapter
, &dmxdev
->dvr_dvbdev
, &dvbdev_dvr
, dmxdev
, DVB_DEVICE_DVR
);
1113 dvb_dmxdev_buffer_init(&dmxdev
->dvr_buffer
);
1117 EXPORT_SYMBOL(dvb_dmxdev_init
);
1120 dvb_dmxdev_release(struct dmxdev
*dmxdev
)
1122 dvb_unregister_device(dmxdev
->dvbdev
);
1123 dvb_unregister_device(dmxdev
->dvr_dvbdev
);
1125 vfree(dmxdev
->filter
);
1126 dmxdev
->filter
=NULL
;
1127 dmxdev
->demux
->close(dmxdev
->demux
);
1129 EXPORT_SYMBOL(dvb_dmxdev_release
);