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/spinlock.h>
24 #include <linux/slab.h>
25 #include <linux/vmalloc.h>
26 #include <linux/module.h>
27 #include <linux/moduleparam.h>
28 #include <linux/sched.h>
29 #include <linux/poll.h>
30 #include <linux/ioctl.h>
31 #include <linux/wait.h>
32 #include <asm/uaccess.h>
33 #include <asm/system.h>
38 module_param(debug
, int, 0644);
39 MODULE_PARM_DESC(debug
, "Turn on/off debugging (default:off).");
41 #define dprintk if (debug) printk
43 static inline void dvb_dmxdev_buffer_init(struct dmxdev_buffer
*buffer
)
50 init_waitqueue_head(&buffer
->queue
);
53 static inline int dvb_dmxdev_buffer_write(struct dmxdev_buffer
*buf
,
54 const u8
*src
, int len
)
65 free
= buf
->pread
- buf
->pwrite
;
69 split
= buf
->size
- buf
->pwrite
;
72 dprintk("dmxdev: buffer overflow\n");
79 memcpy(buf
->data
+ buf
->pwrite
, src
, split
);
83 memcpy(buf
->data
+ buf
->pwrite
, src
+ split
, todo
);
84 buf
->pwrite
= (buf
->pwrite
+ todo
) % buf
->size
;
88 static ssize_t
dvb_dmxdev_buffer_read(struct dmxdev_buffer
*src
,
89 int non_blocking
, char __user
*buf
,
90 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
273 *dmxdevfilter
, int state
)
275 spin_lock_irq(&dmxdevfilter
->dev
->lock
);
276 dmxdevfilter
->state
= state
;
277 spin_unlock_irq(&dmxdevfilter
->dev
->lock
);
280 static int dvb_dmxdev_set_buffer_size(struct dmxdev_filter
*dmxdevfilter
,
283 struct dmxdev_buffer
*buf
= &dmxdevfilter
->buffer
;
286 if (buf
->size
== size
)
288 if (dmxdevfilter
->state
>= DMXDEV_STATE_GO
)
290 spin_lock_irq(&dmxdevfilter
->dev
->lock
);
294 buf
->pwrite
= buf
->pread
= 0;
295 spin_unlock_irq(&dmxdevfilter
->dev
->lock
);
299 mem
= vmalloc(dmxdevfilter
->buffer
.size
);
302 spin_lock_irq(&dmxdevfilter
->dev
->lock
);
304 spin_unlock_irq(&dmxdevfilter
->dev
->lock
);
309 static void dvb_dmxdev_filter_timeout(unsigned long data
)
311 struct dmxdev_filter
*dmxdevfilter
= (struct dmxdev_filter
*)data
;
313 dmxdevfilter
->buffer
.error
= -ETIMEDOUT
;
314 spin_lock_irq(&dmxdevfilter
->dev
->lock
);
315 dmxdevfilter
->state
= DMXDEV_STATE_TIMEDOUT
;
316 spin_unlock_irq(&dmxdevfilter
->dev
->lock
);
317 wake_up(&dmxdevfilter
->buffer
.queue
);
320 static void dvb_dmxdev_filter_timer(struct dmxdev_filter
*dmxdevfilter
)
322 struct dmx_sct_filter_params
*para
= &dmxdevfilter
->params
.sec
;
324 del_timer(&dmxdevfilter
->timer
);
326 dmxdevfilter
->timer
.function
= dvb_dmxdev_filter_timeout
;
327 dmxdevfilter
->timer
.data
= (unsigned long)dmxdevfilter
;
328 dmxdevfilter
->timer
.expires
=
329 jiffies
+ 1 + (HZ
/ 2 + HZ
* para
->timeout
) / 1000;
330 add_timer(&dmxdevfilter
->timer
);
334 static int dvb_dmxdev_section_callback(const u8
*buffer1
, size_t buffer1_len
,
335 const u8
*buffer2
, size_t buffer2_len
,
336 struct dmx_section_filter
*filter
,
337 enum dmx_success success
)
339 struct dmxdev_filter
*dmxdevfilter
= filter
->priv
;
342 if (dmxdevfilter
->buffer
.error
) {
343 wake_up(&dmxdevfilter
->buffer
.queue
);
346 spin_lock(&dmxdevfilter
->dev
->lock
);
347 if (dmxdevfilter
->state
!= DMXDEV_STATE_GO
) {
348 spin_unlock(&dmxdevfilter
->dev
->lock
);
351 del_timer(&dmxdevfilter
->timer
);
352 dprintk("dmxdev: section callback %02x %02x %02x %02x %02x %02x\n",
353 buffer1
[0], buffer1
[1],
354 buffer1
[2], buffer1
[3], buffer1
[4], buffer1
[5]);
355 ret
= dvb_dmxdev_buffer_write(&dmxdevfilter
->buffer
, buffer1
,
357 if (ret
== buffer1_len
) {
358 ret
= dvb_dmxdev_buffer_write(&dmxdevfilter
->buffer
, buffer2
,
362 dmxdevfilter
->buffer
.pwrite
= dmxdevfilter
->buffer
.pread
;
363 dmxdevfilter
->buffer
.error
= -EOVERFLOW
;
365 if (dmxdevfilter
->params
.sec
.flags
& DMX_ONESHOT
)
366 dmxdevfilter
->state
= DMXDEV_STATE_DONE
;
367 spin_unlock(&dmxdevfilter
->dev
->lock
);
368 wake_up(&dmxdevfilter
->buffer
.queue
);
372 static int dvb_dmxdev_ts_callback(const u8
*buffer1
, size_t buffer1_len
,
373 const u8
*buffer2
, size_t buffer2_len
,
374 struct dmx_ts_feed
*feed
,
375 enum dmx_success success
)
377 struct dmxdev_filter
*dmxdevfilter
= feed
->priv
;
378 struct dmxdev_buffer
*buffer
;
381 spin_lock(&dmxdevfilter
->dev
->lock
);
382 if (dmxdevfilter
->params
.pes
.output
== DMX_OUT_DECODER
) {
383 spin_unlock(&dmxdevfilter
->dev
->lock
);
387 if (dmxdevfilter
->params
.pes
.output
== DMX_OUT_TAP
)
388 buffer
= &dmxdevfilter
->buffer
;
390 buffer
= &dmxdevfilter
->dev
->dvr_buffer
;
392 spin_unlock(&dmxdevfilter
->dev
->lock
);
393 wake_up(&buffer
->queue
);
396 ret
= dvb_dmxdev_buffer_write(buffer
, buffer1
, buffer1_len
);
397 if (ret
== buffer1_len
)
398 ret
= dvb_dmxdev_buffer_write(buffer
, buffer2
, buffer2_len
);
400 buffer
->pwrite
= buffer
->pread
;
401 buffer
->error
= -EOVERFLOW
;
403 spin_unlock(&dmxdevfilter
->dev
->lock
);
404 wake_up(&buffer
->queue
);
408 /* stop feed but only mark the specified filter as stopped (state set) */
409 static int dvb_dmxdev_feed_stop(struct dmxdev_filter
*dmxdevfilter
)
411 dvb_dmxdev_filter_state_set(dmxdevfilter
, DMXDEV_STATE_SET
);
413 switch (dmxdevfilter
->type
) {
414 case DMXDEV_TYPE_SEC
:
415 del_timer(&dmxdevfilter
->timer
);
416 dmxdevfilter
->feed
.sec
->stop_filtering(dmxdevfilter
->feed
.sec
);
418 case DMXDEV_TYPE_PES
:
419 dmxdevfilter
->feed
.ts
->stop_filtering(dmxdevfilter
->feed
.ts
);
427 /* start feed associated with the specified filter */
428 static int dvb_dmxdev_feed_start(struct dmxdev_filter
*filter
)
430 dvb_dmxdev_filter_state_set(filter
, DMXDEV_STATE_GO
);
432 switch (filter
->type
) {
433 case DMXDEV_TYPE_SEC
:
434 return filter
->feed
.sec
->start_filtering(filter
->feed
.sec
);
435 case DMXDEV_TYPE_PES
:
436 return filter
->feed
.ts
->start_filtering(filter
->feed
.ts
);
444 /* restart section feed if it has filters left associated with it,
445 otherwise release the feed */
446 static int dvb_dmxdev_feed_restart(struct dmxdev_filter
*filter
)
449 struct dmxdev
*dmxdev
= filter
->dev
;
450 u16 pid
= filter
->params
.sec
.pid
;
452 for (i
= 0; i
< dmxdev
->filternum
; i
++)
453 if (dmxdev
->filter
[i
].state
>= DMXDEV_STATE_GO
&&
454 dmxdev
->filter
[i
].type
== DMXDEV_TYPE_SEC
&&
455 dmxdev
->filter
[i
].params
.sec
.pid
== pid
) {
456 dvb_dmxdev_feed_start(&dmxdev
->filter
[i
]);
460 filter
->dev
->demux
->release_section_feed(dmxdev
->demux
,
466 static int dvb_dmxdev_filter_stop(struct dmxdev_filter
*dmxdevfilter
)
468 if (dmxdevfilter
->state
< DMXDEV_STATE_GO
)
471 switch (dmxdevfilter
->type
) {
472 case DMXDEV_TYPE_SEC
:
473 if (!dmxdevfilter
->feed
.sec
)
475 dvb_dmxdev_feed_stop(dmxdevfilter
);
476 if (dmxdevfilter
->filter
.sec
)
477 dmxdevfilter
->feed
.sec
->
478 release_filter(dmxdevfilter
->feed
.sec
,
479 dmxdevfilter
->filter
.sec
);
480 dvb_dmxdev_feed_restart(dmxdevfilter
);
481 dmxdevfilter
->feed
.sec
= NULL
;
483 case DMXDEV_TYPE_PES
:
484 if (!dmxdevfilter
->feed
.ts
)
486 dvb_dmxdev_feed_stop(dmxdevfilter
);
487 dmxdevfilter
->dev
->demux
->
488 release_ts_feed(dmxdevfilter
->dev
->demux
,
489 dmxdevfilter
->feed
.ts
);
490 dmxdevfilter
->feed
.ts
= NULL
;
493 if (dmxdevfilter
->state
== DMXDEV_STATE_ALLOCATED
)
497 dmxdevfilter
->buffer
.pwrite
= dmxdevfilter
->buffer
.pread
= 0;
501 static inline int dvb_dmxdev_filter_reset(struct dmxdev_filter
*dmxdevfilter
)
503 if (dmxdevfilter
->state
< DMXDEV_STATE_SET
)
506 dmxdevfilter
->type
= DMXDEV_TYPE_NONE
;
507 dvb_dmxdev_filter_state_set(dmxdevfilter
, DMXDEV_STATE_ALLOCATED
);
511 static int dvb_dmxdev_filter_start(struct dmxdev_filter
*filter
)
513 struct dmxdev
*dmxdev
= filter
->dev
;
517 if (filter
->state
< DMXDEV_STATE_SET
)
520 if (filter
->state
>= DMXDEV_STATE_GO
)
521 dvb_dmxdev_filter_stop(filter
);
523 if (!(mem
= filter
->buffer
.data
)) {
524 mem
= vmalloc(filter
->buffer
.size
);
525 spin_lock_irq(&filter
->dev
->lock
);
526 filter
->buffer
.data
= mem
;
527 spin_unlock_irq(&filter
->dev
->lock
);
528 if (!filter
->buffer
.data
)
532 filter
->buffer
.pwrite
= filter
->buffer
.pread
= 0;
534 switch (filter
->type
) {
535 case DMXDEV_TYPE_SEC
:
537 struct dmx_sct_filter_params
*para
= &filter
->params
.sec
;
538 struct dmx_section_filter
**secfilter
= &filter
->filter
.sec
;
539 struct dmx_section_feed
**secfeed
= &filter
->feed
.sec
;
545 /* find active filter/feed with same PID */
546 for (i
= 0; i
< dmxdev
->filternum
; i
++) {
547 if (dmxdev
->filter
[i
].state
>= DMXDEV_STATE_GO
&&
548 dmxdev
->filter
[i
].type
== DMXDEV_TYPE_SEC
&&
549 dmxdev
->filter
[i
].params
.sec
.pid
== para
->pid
) {
550 *secfeed
= dmxdev
->filter
[i
].feed
.sec
;
555 /* if no feed found, try to allocate new one */
557 ret
= dmxdev
->demux
->allocate_section_feed(dmxdev
->demux
,
559 dvb_dmxdev_section_callback
);
561 printk("DVB (%s): could not alloc feed\n",
566 ret
= (*secfeed
)->set(*secfeed
, para
->pid
, 32768,
567 (para
->flags
& DMX_CHECK_CRC
) ? 1 : 0);
569 printk("DVB (%s): could not set feed\n",
571 dvb_dmxdev_feed_restart(filter
);
575 dvb_dmxdev_feed_stop(filter
);
578 ret
= (*secfeed
)->allocate_filter(*secfeed
, secfilter
);
580 dvb_dmxdev_feed_restart(filter
);
581 filter
->feed
.sec
->start_filtering(*secfeed
);
582 dprintk("could not get filter\n");
586 (*secfilter
)->priv
= filter
;
588 memcpy(&((*secfilter
)->filter_value
[3]),
589 &(para
->filter
.filter
[1]), DMX_FILTER_SIZE
- 1);
590 memcpy(&(*secfilter
)->filter_mask
[3],
591 ¶
->filter
.mask
[1], DMX_FILTER_SIZE
- 1);
592 memcpy(&(*secfilter
)->filter_mode
[3],
593 ¶
->filter
.mode
[1], DMX_FILTER_SIZE
- 1);
595 (*secfilter
)->filter_value
[0] = para
->filter
.filter
[0];
596 (*secfilter
)->filter_mask
[0] = para
->filter
.mask
[0];
597 (*secfilter
)->filter_mode
[0] = para
->filter
.mode
[0];
598 (*secfilter
)->filter_mask
[1] = 0;
599 (*secfilter
)->filter_mask
[2] = 0;
603 ret
= filter
->feed
.sec
->start_filtering(filter
->feed
.sec
);
607 dvb_dmxdev_filter_timer(filter
);
610 case DMXDEV_TYPE_PES
:
612 struct timespec timeout
= { 0 };
613 struct dmx_pes_filter_params
*para
= &filter
->params
.pes
;
617 enum dmx_ts_pes ts_pes
;
618 struct dmx_ts_feed
**tsfeed
= &filter
->feed
.ts
;
620 filter
->feed
.ts
= NULL
;
621 otype
= para
->output
;
623 ts_pes
= (enum dmx_ts_pes
)para
->pes_type
;
625 if (ts_pes
< DMX_PES_OTHER
)
626 ts_type
= TS_DECODER
;
630 if (otype
== DMX_OUT_TS_TAP
)
631 ts_type
|= TS_PACKET
;
633 if (otype
== DMX_OUT_TAP
)
634 ts_type
|= TS_PAYLOAD_ONLY
| TS_PACKET
;
636 ret
= dmxdev
->demux
->allocate_ts_feed(dmxdev
->demux
,
638 dvb_dmxdev_ts_callback
);
642 (*tsfeed
)->priv
= filter
;
644 ret
= (*tsfeed
)->set(*tsfeed
, para
->pid
, ts_type
, ts_pes
,
647 dmxdev
->demux
->release_ts_feed(dmxdev
->demux
,
652 ret
= filter
->feed
.ts
->start_filtering(filter
->feed
.ts
);
654 dmxdev
->demux
->release_ts_feed(dmxdev
->demux
,
665 dvb_dmxdev_filter_state_set(filter
, DMXDEV_STATE_GO
);
669 static int dvb_demux_open(struct inode
*inode
, struct file
*file
)
671 struct dvb_device
*dvbdev
= file
->private_data
;
672 struct dmxdev
*dmxdev
= dvbdev
->priv
;
674 struct dmxdev_filter
*dmxdevfilter
;
679 if (mutex_lock_interruptible(&dmxdev
->mutex
))
682 for (i
= 0; i
< dmxdev
->filternum
; i
++)
683 if (dmxdev
->filter
[i
].state
== DMXDEV_STATE_FREE
)
686 if (i
== dmxdev
->filternum
) {
687 mutex_unlock(&dmxdev
->mutex
);
691 dmxdevfilter
= &dmxdev
->filter
[i
];
692 mutex_init(&dmxdevfilter
->mutex
);
693 file
->private_data
= dmxdevfilter
;
695 dvb_dmxdev_buffer_init(&dmxdevfilter
->buffer
);
696 dmxdevfilter
->type
= DMXDEV_TYPE_NONE
;
697 dvb_dmxdev_filter_state_set(dmxdevfilter
, DMXDEV_STATE_ALLOCATED
);
698 dmxdevfilter
->feed
.ts
= NULL
;
699 init_timer(&dmxdevfilter
->timer
);
701 mutex_unlock(&dmxdev
->mutex
);
705 static int dvb_dmxdev_filter_free(struct dmxdev
*dmxdev
,
706 struct dmxdev_filter
*dmxdevfilter
)
708 if (mutex_lock_interruptible(&dmxdev
->mutex
))
711 if (mutex_lock_interruptible(&dmxdevfilter
->mutex
)) {
712 mutex_unlock(&dmxdev
->mutex
);
716 dvb_dmxdev_filter_stop(dmxdevfilter
);
717 dvb_dmxdev_filter_reset(dmxdevfilter
);
719 if (dmxdevfilter
->buffer
.data
) {
720 void *mem
= dmxdevfilter
->buffer
.data
;
722 spin_lock_irq(&dmxdev
->lock
);
723 dmxdevfilter
->buffer
.data
= NULL
;
724 spin_unlock_irq(&dmxdev
->lock
);
728 dvb_dmxdev_filter_state_set(dmxdevfilter
, DMXDEV_STATE_FREE
);
729 wake_up(&dmxdevfilter
->buffer
.queue
);
730 mutex_unlock(&dmxdevfilter
->mutex
);
731 mutex_unlock(&dmxdev
->mutex
);
735 static inline void invert_mode(dmx_filter_t
*filter
)
739 for (i
= 0; i
< DMX_FILTER_SIZE
; i
++)
740 filter
->mode
[i
] ^= 0xff;
743 static int dvb_dmxdev_filter_set(struct dmxdev
*dmxdev
,
744 struct dmxdev_filter
*dmxdevfilter
,
745 struct dmx_sct_filter_params
*params
)
747 dprintk("function : %s\n", __FUNCTION__
);
749 dvb_dmxdev_filter_stop(dmxdevfilter
);
751 dmxdevfilter
->type
= DMXDEV_TYPE_SEC
;
752 memcpy(&dmxdevfilter
->params
.sec
,
753 params
, sizeof(struct dmx_sct_filter_params
));
754 invert_mode(&dmxdevfilter
->params
.sec
.filter
);
755 dvb_dmxdev_filter_state_set(dmxdevfilter
, DMXDEV_STATE_SET
);
757 if (params
->flags
& DMX_IMMEDIATE_START
)
758 return dvb_dmxdev_filter_start(dmxdevfilter
);
763 static int dvb_dmxdev_pes_filter_set(struct dmxdev
*dmxdev
,
764 struct dmxdev_filter
*dmxdevfilter
,
765 struct dmx_pes_filter_params
*params
)
767 dvb_dmxdev_filter_stop(dmxdevfilter
);
769 if (params
->pes_type
> DMX_PES_OTHER
|| params
->pes_type
< 0)
772 dmxdevfilter
->type
= DMXDEV_TYPE_PES
;
773 memcpy(&dmxdevfilter
->params
, params
,
774 sizeof(struct dmx_pes_filter_params
));
776 dvb_dmxdev_filter_state_set(dmxdevfilter
, DMXDEV_STATE_SET
);
778 if (params
->flags
& DMX_IMMEDIATE_START
)
779 return dvb_dmxdev_filter_start(dmxdevfilter
);
784 static ssize_t
dvb_dmxdev_read_sec(struct dmxdev_filter
*dfil
,
785 struct file
*file
, char __user
*buf
,
786 size_t count
, loff_t
*ppos
)
791 if (dfil
->todo
<= 0) {
792 hcount
= 3 + dfil
->todo
;
795 result
= dvb_dmxdev_buffer_read(&dfil
->buffer
,
796 file
->f_flags
& O_NONBLOCK
,
802 if (copy_from_user(dfil
->secheader
- dfil
->todo
, buf
, result
))
807 dfil
->todo
-= result
;
810 dfil
->todo
= ((dfil
->secheader
[1] << 8) | dfil
->secheader
[2]) & 0xfff;
814 if (count
> dfil
->todo
)
816 result
= dvb_dmxdev_buffer_read(&dfil
->buffer
,
817 file
->f_flags
& O_NONBLOCK
,
821 dfil
->todo
-= result
;
822 return (result
+ done
);
826 dvb_demux_read(struct file
*file
, char __user
*buf
, size_t count
,
829 struct dmxdev_filter
*dmxdevfilter
= file
->private_data
;
832 if (mutex_lock_interruptible(&dmxdevfilter
->mutex
))
835 if (dmxdevfilter
->type
== DMXDEV_TYPE_SEC
)
836 ret
= dvb_dmxdev_read_sec(dmxdevfilter
, file
, buf
, count
, ppos
);
838 ret
= dvb_dmxdev_buffer_read(&dmxdevfilter
->buffer
,
839 file
->f_flags
& O_NONBLOCK
,
842 mutex_unlock(&dmxdevfilter
->mutex
);
846 static int dvb_demux_do_ioctl(struct inode
*inode
, struct file
*file
,
847 unsigned int cmd
, void *parg
)
849 struct dmxdev_filter
*dmxdevfilter
= file
->private_data
;
850 struct dmxdev
*dmxdev
= dmxdevfilter
->dev
;
851 unsigned long arg
= (unsigned long)parg
;
854 if (mutex_lock_interruptible(&dmxdev
->mutex
))
859 if (mutex_lock_interruptible(&dmxdevfilter
->mutex
)) {
860 mutex_unlock(&dmxdev
->mutex
);
863 if (dmxdevfilter
->state
< DMXDEV_STATE_SET
)
866 ret
= dvb_dmxdev_filter_start(dmxdevfilter
);
867 mutex_unlock(&dmxdevfilter
->mutex
);
871 if (mutex_lock_interruptible(&dmxdevfilter
->mutex
)) {
872 mutex_unlock(&dmxdev
->mutex
);
875 ret
= dvb_dmxdev_filter_stop(dmxdevfilter
);
876 mutex_unlock(&dmxdevfilter
->mutex
);
880 if (mutex_lock_interruptible(&dmxdevfilter
->mutex
)) {
881 mutex_unlock(&dmxdev
->mutex
);
884 ret
= dvb_dmxdev_filter_set(dmxdev
, dmxdevfilter
, parg
);
885 mutex_unlock(&dmxdevfilter
->mutex
);
888 case DMX_SET_PES_FILTER
:
889 if (mutex_lock_interruptible(&dmxdevfilter
->mutex
)) {
890 mutex_unlock(&dmxdev
->mutex
);
893 ret
= dvb_dmxdev_pes_filter_set(dmxdev
, dmxdevfilter
, parg
);
894 mutex_unlock(&dmxdevfilter
->mutex
);
897 case DMX_SET_BUFFER_SIZE
:
898 if (mutex_lock_interruptible(&dmxdevfilter
->mutex
)) {
899 mutex_unlock(&dmxdev
->mutex
);
902 ret
= dvb_dmxdev_set_buffer_size(dmxdevfilter
, arg
);
903 mutex_unlock(&dmxdevfilter
->mutex
);
909 case DMX_GET_PES_PIDS
:
910 if (!dmxdev
->demux
->get_pes_pids
) {
914 dmxdev
->demux
->get_pes_pids(dmxdev
->demux
, parg
);
918 if (!dmxdev
->demux
->get_caps
) {
922 ret
= dmxdev
->demux
->get_caps(dmxdev
->demux
, parg
);
926 if (!dmxdev
->demux
->set_source
) {
930 ret
= dmxdev
->demux
->set_source(dmxdev
->demux
, parg
);
934 if (!dmxdev
->demux
->get_stc
) {
938 ret
= dmxdev
->demux
->get_stc(dmxdev
->demux
,
939 ((struct dmx_stc
*)parg
)->num
,
940 &((struct dmx_stc
*)parg
)->stc
,
941 &((struct dmx_stc
*)parg
)->base
);
948 mutex_unlock(&dmxdev
->mutex
);
952 static int dvb_demux_ioctl(struct inode
*inode
, struct file
*file
,
953 unsigned int cmd
, unsigned long arg
)
955 return dvb_usercopy(inode
, file
, cmd
, arg
, dvb_demux_do_ioctl
);
958 static unsigned int dvb_demux_poll(struct file
*file
, poll_table
*wait
)
960 struct dmxdev_filter
*dmxdevfilter
= file
->private_data
;
961 unsigned int mask
= 0;
966 poll_wait(file
, &dmxdevfilter
->buffer
.queue
, wait
);
968 if (dmxdevfilter
->state
!= DMXDEV_STATE_GO
&&
969 dmxdevfilter
->state
!= DMXDEV_STATE_DONE
&&
970 dmxdevfilter
->state
!= DMXDEV_STATE_TIMEDOUT
)
973 if (dmxdevfilter
->buffer
.error
)
974 mask
|= (POLLIN
| POLLRDNORM
| POLLPRI
| POLLERR
);
976 if (dmxdevfilter
->buffer
.pread
!= dmxdevfilter
->buffer
.pwrite
)
977 mask
|= (POLLIN
| POLLRDNORM
| POLLPRI
);
982 static int dvb_demux_release(struct inode
*inode
, struct file
*file
)
984 struct dmxdev_filter
*dmxdevfilter
= file
->private_data
;
985 struct dmxdev
*dmxdev
= dmxdevfilter
->dev
;
987 return dvb_dmxdev_filter_free(dmxdev
, dmxdevfilter
);
990 static struct file_operations dvb_demux_fops
= {
991 .owner
= THIS_MODULE
,
992 .read
= dvb_demux_read
,
993 .ioctl
= dvb_demux_ioctl
,
994 .open
= dvb_demux_open
,
995 .release
= dvb_demux_release
,
996 .poll
= dvb_demux_poll
,
999 static struct dvb_device dvbdev_demux
= {
1003 .fops
= &dvb_demux_fops
1006 static int dvb_dvr_do_ioctl(struct inode
*inode
, struct file
*file
,
1007 unsigned int cmd
, void *parg
)
1009 struct dvb_device
*dvbdev
= file
->private_data
;
1010 struct dmxdev
*dmxdev
= dvbdev
->priv
;
1013 if (mutex_lock_interruptible(&dmxdev
->mutex
))
1014 return -ERESTARTSYS
;
1017 case DMX_SET_BUFFER_SIZE
:
1026 mutex_unlock(&dmxdev
->mutex
);
1030 static int dvb_dvr_ioctl(struct inode
*inode
, struct file
*file
,
1031 unsigned int cmd
, unsigned long arg
)
1033 return dvb_usercopy(inode
, file
, cmd
, arg
, dvb_dvr_do_ioctl
);
1036 static unsigned int dvb_dvr_poll(struct file
*file
, poll_table
*wait
)
1038 struct dvb_device
*dvbdev
= file
->private_data
;
1039 struct dmxdev
*dmxdev
= dvbdev
->priv
;
1040 unsigned int mask
= 0;
1042 dprintk("function : %s\n", __FUNCTION__
);
1044 poll_wait(file
, &dmxdev
->dvr_buffer
.queue
, wait
);
1046 if ((file
->f_flags
& O_ACCMODE
) == O_RDONLY
) {
1047 if (dmxdev
->dvr_buffer
.error
)
1048 mask
|= (POLLIN
| POLLRDNORM
| POLLPRI
| POLLERR
);
1050 if (dmxdev
->dvr_buffer
.pread
!= dmxdev
->dvr_buffer
.pwrite
)
1051 mask
|= (POLLIN
| POLLRDNORM
| POLLPRI
);
1053 mask
|= (POLLOUT
| POLLWRNORM
| POLLPRI
);
1058 static struct file_operations dvb_dvr_fops
= {
1059 .owner
= THIS_MODULE
,
1060 .read
= dvb_dvr_read
,
1061 .write
= dvb_dvr_write
,
1062 .ioctl
= dvb_dvr_ioctl
,
1063 .open
= dvb_dvr_open
,
1064 .release
= dvb_dvr_release
,
1065 .poll
= dvb_dvr_poll
,
1068 static struct dvb_device dvbdev_dvr
= {
1072 .fops
= &dvb_dvr_fops
1075 int dvb_dmxdev_init(struct dmxdev
*dmxdev
, struct dvb_adapter
*dvb_adapter
)
1079 if (dmxdev
->demux
->open(dmxdev
->demux
) < 0)
1082 dmxdev
->filter
= vmalloc(dmxdev
->filternum
* sizeof(struct dmxdev_filter
));
1083 if (!dmxdev
->filter
)
1086 mutex_init(&dmxdev
->mutex
);
1087 spin_lock_init(&dmxdev
->lock
);
1088 for (i
= 0; i
< dmxdev
->filternum
; i
++) {
1089 dmxdev
->filter
[i
].dev
= dmxdev
;
1090 dmxdev
->filter
[i
].buffer
.data
= NULL
;
1091 dvb_dmxdev_filter_state_set(&dmxdev
->filter
[i
],
1095 dvb_register_device(dvb_adapter
, &dmxdev
->dvbdev
, &dvbdev_demux
, dmxdev
,
1097 dvb_register_device(dvb_adapter
, &dmxdev
->dvr_dvbdev
, &dvbdev_dvr
,
1098 dmxdev
, DVB_DEVICE_DVR
);
1100 dvb_dmxdev_buffer_init(&dmxdev
->dvr_buffer
);
1105 EXPORT_SYMBOL(dvb_dmxdev_init
);
1107 void dvb_dmxdev_release(struct dmxdev
*dmxdev
)
1109 dvb_unregister_device(dmxdev
->dvbdev
);
1110 dvb_unregister_device(dmxdev
->dvr_dvbdev
);
1112 vfree(dmxdev
->filter
);
1113 dmxdev
->filter
= NULL
;
1114 dmxdev
->demux
->close(dmxdev
->demux
);
1117 EXPORT_SYMBOL(dvb_dmxdev_release
);