2 * av7110_av.c: audio and video MPEG decoder stuff
4 * Copyright (C) 1999-2002 Ralph Metzler
5 * & Marcus Metzler for convergence integrated media GmbH
7 * originally based on code by:
8 * Copyright (C) 1998,1999 Christian Theiss <mistert@rz.fh-augsburg.de>
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License
12 * as published by the Free Software Foundation; either version 2
13 * of the License, or (at your option) any later version.
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
25 * Or, point your browser to http://www.gnu.org/copyleft/gpl.html
28 * the project's page is at http://www.linuxtv.org/dvb/
31 #include <linux/types.h>
32 #include <linux/kernel.h>
33 #include <linux/string.h>
34 #include <linux/sched.h>
35 #include <linux/delay.h>
36 #include <linux/byteorder/swabb.h>
37 #include <linux/smp_lock.h>
41 #include "av7110_hw.h"
42 #include "av7110_av.h"
43 #include "av7110_ipack.h"
45 /* MPEG-2 (ISO 13818 / H.222.0) stream types */
46 #define PROG_STREAM_MAP 0xBC
47 #define PRIVATE_STREAM1 0xBD
48 #define PADDING_STREAM 0xBE
49 #define PRIVATE_STREAM2 0xBF
50 #define AUDIO_STREAM_S 0xC0
51 #define AUDIO_STREAM_E 0xDF
52 #define VIDEO_STREAM_S 0xE0
53 #define VIDEO_STREAM_E 0xEF
54 #define ECM_STREAM 0xF0
55 #define EMM_STREAM 0xF1
56 #define DSM_CC_STREAM 0xF2
57 #define ISO13522_STREAM 0xF3
58 #define PROG_STREAM_DIR 0xFF
60 #define PTS_DTS_FLAGS 0xC0
66 #define TRANS_ERROR 0x80
67 #define PAY_START 0x40
68 #define TRANS_PRIO 0x20
69 #define PID_MASK_HI 0x1F
71 #define TRANS_SCRMBL1 0x80
72 #define TRANS_SCRMBL2 0x40
73 #define ADAPT_FIELD 0x20
75 #define COUNT_MASK 0x0F
78 #define DISCON_IND 0x80
79 #define RAND_ACC_IND 0x40
80 #define ES_PRI_IND 0x20
82 #define OPCR_FLAG 0x08
83 #define SPLICE_FLAG 0x04
84 #define TRANS_PRIV 0x02
85 #define ADAP_EXT_FLAG 0x01
87 // adaptation extension flags
89 #define PIECE_RATE 0x40
90 #define SEAM_SPLICE 0x20
93 static void p_to_t(u8
const *buf
, long int length
, u16 pid
,
94 u8
*counter
, struct dvb_demux_feed
*feed
);
97 int av7110_record_cb(struct dvb_filter_pes2ts
*p2t
, u8
*buf
, size_t len
)
99 struct dvb_demux_feed
*dvbdmxfeed
= (struct dvb_demux_feed
*) p2t
->priv
;
101 if (!(dvbdmxfeed
->ts_type
& TS_PACKET
))
103 if (buf
[3] == 0xe0) // video PES do not have a length in TS
105 if (dvbdmxfeed
->ts_type
& TS_PAYLOAD_ONLY
)
106 return dvbdmxfeed
->cb
.ts(buf
, len
, NULL
, 0,
107 &dvbdmxfeed
->feed
.ts
, DMX_OK
);
109 return dvb_filter_pes2ts(p2t
, buf
, len
, 1);
112 static int dvb_filter_pes2ts_cb(void *priv
, unsigned char *data
)
114 struct dvb_demux_feed
*dvbdmxfeed
= (struct dvb_demux_feed
*) priv
;
116 dvbdmxfeed
->cb
.ts(data
, 188, NULL
, 0,
117 &dvbdmxfeed
->feed
.ts
, DMX_OK
);
121 int av7110_av_start_record(struct av7110
*av7110
, int av
,
122 struct dvb_demux_feed
*dvbdmxfeed
)
124 struct dvb_demux
*dvbdmx
= dvbdmxfeed
->demux
;
126 dprintk(2, "av7110:%p, , dvb_demux_feed:%p\n", av7110
, dvbdmxfeed
);
128 if (av7110
->playing
|| (av7110
->rec_mode
& av
))
130 av7110_fw_cmd(av7110
, COMTYPE_REC_PLAY
, __Stop
, 0);
131 dvbdmx
->recording
= 1;
132 av7110
->rec_mode
|= av
;
134 switch (av7110
->rec_mode
) {
136 dvb_filter_pes2ts_init(&av7110
->p2t
[0],
137 dvbdmx
->pesfilter
[0]->pid
,
138 dvb_filter_pes2ts_cb
,
139 (void *) dvbdmx
->pesfilter
[0]);
140 av7110_fw_cmd(av7110
, COMTYPE_REC_PLAY
, __Record
, 2, AudioPES
, 0);
144 dvb_filter_pes2ts_init(&av7110
->p2t
[1],
145 dvbdmx
->pesfilter
[1]->pid
,
146 dvb_filter_pes2ts_cb
,
147 (void *) dvbdmx
->pesfilter
[1]);
148 av7110_fw_cmd(av7110
, COMTYPE_REC_PLAY
, __Record
, 2, VideoPES
, 0);
152 dvb_filter_pes2ts_init(&av7110
->p2t
[0],
153 dvbdmx
->pesfilter
[0]->pid
,
154 dvb_filter_pes2ts_cb
,
155 (void *) dvbdmx
->pesfilter
[0]);
156 dvb_filter_pes2ts_init(&av7110
->p2t
[1],
157 dvbdmx
->pesfilter
[1]->pid
,
158 dvb_filter_pes2ts_cb
,
159 (void *) dvbdmx
->pesfilter
[1]);
160 av7110_fw_cmd(av7110
, COMTYPE_REC_PLAY
, __Record
, 2, AV_PES
, 0);
166 int av7110_av_start_play(struct av7110
*av7110
, int av
)
168 dprintk(2, "av7110:%p, \n", av7110
);
170 if (av7110
->rec_mode
)
172 if (av7110
->playing
& av
)
175 av7110_fw_cmd(av7110
, COMTYPE_REC_PLAY
, __Stop
, 0);
177 if (av7110
->playing
== RP_NONE
) {
178 av7110_ipack_reset(&av7110
->ipack
[0]);
179 av7110_ipack_reset(&av7110
->ipack
[1]);
182 av7110
->playing
|= av
;
183 switch (av7110
->playing
) {
185 av7110_fw_cmd(av7110
, COMTYPE_REC_PLAY
, __Play
, 2, AudioPES
, 0);
188 av7110_fw_cmd(av7110
, COMTYPE_REC_PLAY
, __Play
, 2, VideoPES
, 0);
193 av7110_fw_cmd(av7110
, COMTYPE_REC_PLAY
, __Play
, 2, AV_PES
, 0);
196 return av7110
->playing
;
199 void av7110_av_stop(struct av7110
*av7110
, int av
)
201 dprintk(2, "av7110:%p, \n", av7110
);
203 if (!(av7110
->playing
& av
) && !(av7110
->rec_mode
& av
))
206 av7110_fw_cmd(av7110
, COMTYPE_REC_PLAY
, __Stop
, 0);
207 if (av7110
->playing
) {
208 av7110
->playing
&= ~av
;
209 switch (av7110
->playing
) {
211 av7110_fw_cmd(av7110
, COMTYPE_REC_PLAY
, __Play
, 2, AudioPES
, 0);
214 av7110_fw_cmd(av7110
, COMTYPE_REC_PLAY
, __Play
, 2, VideoPES
, 0);
217 av7110_set_vidmode(av7110
, av7110
->vidmode
);
221 av7110
->rec_mode
&= ~av
;
222 switch (av7110
->rec_mode
) {
224 av7110_fw_cmd(av7110
, COMTYPE_REC_PLAY
, __Record
, 2, AudioPES
, 0);
227 av7110_fw_cmd(av7110
, COMTYPE_REC_PLAY
, __Record
, 2, VideoPES
, 0);
236 int av7110_pes_play(void *dest
, struct dvb_ringbuffer
*buf
, int dlen
)
243 wake_up(&buf
->queue
);
247 if ((len
= dvb_ringbuffer_avail(buf
)) < 6)
249 sync
= DVB_RINGBUFFER_PEEK(buf
, 0) << 24;
250 sync
|= DVB_RINGBUFFER_PEEK(buf
, 1) << 16;
251 sync
|= DVB_RINGBUFFER_PEEK(buf
, 2) << 8;
252 sync
|= DVB_RINGBUFFER_PEEK(buf
, 3);
254 if (((sync
&~ 0x0f) == 0x000001e0) ||
255 ((sync
&~ 0x1f) == 0x000001c0) ||
256 (sync
== 0x000001bd))
259 DVB_RINGBUFFER_SKIP(buf
, 1);
261 blen
= DVB_RINGBUFFER_PEEK(buf
, 4) << 8;
262 blen
|= DVB_RINGBUFFER_PEEK(buf
, 5);
264 if (len
< blen
|| blen
> dlen
) {
265 //printk("buffer empty - avail %d blen %u dlen %d\n", len, blen, dlen);
266 wake_up(&buf
->queue
);
270 dvb_ringbuffer_read(buf
, dest
, (size_t) blen
, 0);
272 dprintk(2, "pread=0x%08lx, pwrite=0x%08lx\n",
273 (unsigned long) buf
->pread
, (unsigned long) buf
->pwrite
);
274 wake_up(&buf
->queue
);
279 int av7110_set_volume(struct av7110
*av7110
, int volleft
, int volright
)
281 int err
, vol
, val
, balance
= 0;
283 dprintk(2, "av7110:%p, \n", av7110
);
285 av7110
->mixer
.volume_left
= volleft
;
286 av7110
->mixer
.volume_right
= volright
;
288 switch (av7110
->adac_type
) {
290 volleft
= (volleft
* 256) / 1036;
291 volright
= (volright
* 256) / 1036;
296 if ((err
= SendDAC(av7110
, 3, 0x80 + volleft
)))
298 return SendDAC(av7110
, 4, volright
);
300 case DVB_ADAC_CRYSTAL
:
301 volleft
= 127 - volleft
/ 2;
302 volright
= 127 - volright
/ 2;
303 i2c_writereg(av7110
, 0x20, 0x03, volleft
);
304 i2c_writereg(av7110
, 0x20, 0x04, volright
);
308 vol
= (volleft
> volright
) ? volleft
: volright
;
309 val
= (vol
* 0x73 / 255) << 8;
311 balance
= ((volright
- volleft
) * 127) / vol
;
312 msp_writereg(av7110
, MSP_WR_DSP
, 0x0001, balance
<< 8);
313 msp_writereg(av7110
, MSP_WR_DSP
, 0x0000, val
); /* loudspeaker */
314 msp_writereg(av7110
, MSP_WR_DSP
, 0x0006, val
); /* headphonesr */
320 void av7110_set_vidmode(struct av7110
*av7110
, int mode
)
322 dprintk(2, "av7110:%p, \n", av7110
);
324 av7110_fw_cmd(av7110
, COMTYPE_ENCODER
, LoadVidCode
, 1, mode
);
326 if (!av7110
->playing
) {
327 ChangePIDs(av7110
, av7110
->pids
[DMX_PES_VIDEO
],
328 av7110
->pids
[DMX_PES_AUDIO
],
329 av7110
->pids
[DMX_PES_TELETEXT
],
330 0, av7110
->pids
[DMX_PES_PCR
]);
331 av7110_fw_cmd(av7110
, COMTYPE_PIDFILTER
, Scan
, 0);
336 static int sw2mode
[16] = {
337 VIDEO_MODE_PAL
, VIDEO_MODE_NTSC
, VIDEO_MODE_NTSC
, VIDEO_MODE_PAL
,
338 VIDEO_MODE_NTSC
, VIDEO_MODE_NTSC
, VIDEO_MODE_PAL
, VIDEO_MODE_NTSC
,
339 VIDEO_MODE_PAL
, VIDEO_MODE_PAL
, VIDEO_MODE_PAL
, VIDEO_MODE_PAL
,
340 VIDEO_MODE_PAL
, VIDEO_MODE_PAL
, VIDEO_MODE_PAL
, VIDEO_MODE_PAL
,
343 static void get_video_format(struct av7110
*av7110
, u8
*buf
, int count
)
350 dprintk(2, "av7110:%p, \n", av7110
);
354 for (i
= 7; i
< count
- 10; i
++) {
356 if (p
[0] || p
[1] || p
[2] != 0x01 || p
[3] != 0xb3)
359 hsize
= ((p
[1] &0xF0) >> 4) | (p
[0] << 4);
360 vsize
= ((p
[1] &0x0F) << 8) | (p
[2]);
362 av7110_set_vidmode(av7110
, sw2mode
[sw
]);
363 dprintk(2, "playback %dx%d fr=%d\n", hsize
, vsize
, sw
);
370 /****************************************************************************
371 * I/O buffer management and control
372 ****************************************************************************/
374 static inline long aux_ring_buffer_write(struct dvb_ringbuffer
*rbuf
,
375 const char *buf
, unsigned long count
)
377 unsigned long todo
= count
;
381 if (dvb_ringbuffer_free(rbuf
) < 2048) {
382 if (wait_event_interruptible(rbuf
->queue
,
383 (dvb_ringbuffer_free(rbuf
) >= 2048)))
386 free
= dvb_ringbuffer_free(rbuf
);
389 dvb_ringbuffer_write(rbuf
, buf
, free
);
397 static void play_video_cb(u8
*buf
, int count
, void *priv
)
399 struct av7110
*av7110
= (struct av7110
*) priv
;
400 dprintk(2, "av7110:%p, \n", av7110
);
402 if ((buf
[3] & 0xe0) == 0xe0) {
403 get_video_format(av7110
, buf
, count
);
404 aux_ring_buffer_write(&av7110
->avout
, buf
, count
);
406 aux_ring_buffer_write(&av7110
->aout
, buf
, count
);
409 static void play_audio_cb(u8
*buf
, int count
, void *priv
)
411 struct av7110
*av7110
= (struct av7110
*) priv
;
412 dprintk(2, "av7110:%p, \n", av7110
);
414 aux_ring_buffer_write(&av7110
->aout
, buf
, count
);
417 #define FREE_COND (dvb_ringbuffer_free(&av7110->avout) >= 20 * 1024 && \
418 dvb_ringbuffer_free(&av7110->aout) >= 20 * 1024)
420 static ssize_t
dvb_play(struct av7110
*av7110
, const u8 __user
*buf
,
421 unsigned long count
, int nonblock
, int type
)
423 unsigned long todo
= count
, n
;
424 dprintk(2, "av7110:%p, \n", av7110
);
426 if (!av7110
->kbuf
[type
])
429 if (nonblock
&& !FREE_COND
)
436 if (wait_event_interruptible(av7110
->avout
.queue
,
443 if (copy_from_user(av7110
->kbuf
[type
], buf
, n
))
445 av7110_ipack_instant_repack(av7110
->kbuf
[type
], n
,
446 &av7110
->ipack
[type
]);
453 static ssize_t
dvb_play_kernel(struct av7110
*av7110
, const u8
*buf
,
454 unsigned long count
, int nonblock
, int type
)
456 unsigned long todo
= count
, n
;
457 dprintk(2, "av7110:%p, \n", av7110
);
459 if (!av7110
->kbuf
[type
])
462 if (nonblock
&& !FREE_COND
)
469 if (wait_event_interruptible(av7110
->avout
.queue
,
476 av7110_ipack_instant_repack(buf
, n
, &av7110
->ipack
[type
]);
483 static ssize_t
dvb_aplay(struct av7110
*av7110
, const u8 __user
*buf
,
484 unsigned long count
, int nonblock
, int type
)
486 unsigned long todo
= count
, n
;
487 dprintk(2, "av7110:%p, \n", av7110
);
489 if (!av7110
->kbuf
[type
])
491 if (nonblock
&& dvb_ringbuffer_free(&av7110
->aout
) < 20 * 1024)
495 if (dvb_ringbuffer_free(&av7110
->aout
) < 20 * 1024) {
498 if (wait_event_interruptible(av7110
->aout
.queue
,
499 (dvb_ringbuffer_free(&av7110
->aout
) >= 20 * 1024)))
505 if (copy_from_user(av7110
->kbuf
[type
], buf
, n
))
507 av7110_ipack_instant_repack(av7110
->kbuf
[type
], n
,
508 &av7110
->ipack
[type
]);
515 void av7110_p2t_init(struct av7110_p2t
*p
, struct dvb_demux_feed
*feed
)
517 memset(p
->pes
, 0, TS_SIZE
);
525 static void clear_p2t(struct av7110_p2t
*p
)
527 memset(p
->pes
, 0, TS_SIZE
);
534 static int find_pes_header(u8
const *buf
, long int length
, int *frags
)
541 while (c
< length
- 3 && !found
) {
542 if (buf
[c
] == 0x00 && buf
[c
+ 1] == 0x00 &&
543 buf
[c
+ 2] == 0x01) {
544 switch ( buf
[c
+ 3] ) {
545 case PROG_STREAM_MAP
:
546 case PRIVATE_STREAM2
:
547 case PROG_STREAM_DIR
:
550 case PADDING_STREAM
:
552 case ISO13522_STREAM
:
553 case PRIVATE_STREAM1
:
554 case AUDIO_STREAM_S
... AUDIO_STREAM_E
:
555 case VIDEO_STREAM_S
... VIDEO_STREAM_E
:
566 if (c
== length
- 3 && !found
) {
567 if (buf
[length
- 1] == 0x00)
569 if (buf
[length
- 2] == 0x00 &&
570 buf
[length
- 1] == 0x00)
572 if (buf
[length
- 3] == 0x00 &&
573 buf
[length
- 2] == 0x00 &&
574 buf
[length
- 1] == 0x01)
582 void av7110_p2t_write(u8
const *buf
, long int length
, u16 pid
, struct av7110_p2t
*p
)
593 if (buf
[c
] == 0x00 && buf
[c
+ 1] == 0x01) {
599 if (buf
[c
] == 0x01) {
609 case PROG_STREAM_MAP
:
610 case PRIVATE_STREAM2
:
611 case PROG_STREAM_DIR
:
614 case PADDING_STREAM
:
616 case ISO13522_STREAM
:
617 case PRIVATE_STREAM1
:
618 case AUDIO_STREAM_S
... AUDIO_STREAM_E
:
619 case VIDEO_STREAM_S
... VIDEO_STREAM_E
:
625 memcpy(p
->pes
+ p
->pos
, buf
+ c
, (TS_SIZE
- 4) - p
->pos
);
626 c
+= (TS_SIZE
- 4) - p
->pos
;
627 p_to_t(p
->pes
, (TS_SIZE
- 4), pid
, &p
->counter
, p
->feed
);
640 c2
= find_pes_header(buf
+ c
, length
- c
, &p
->frags
);
641 if (c2
>= 0 && c2
< (TS_SIZE
- 4) - p
->pos
)
644 l
= (TS_SIZE
- 4) - p
->pos
;
645 memcpy(p
->pes
+ p
->pos
, buf
, l
);
648 p_to_t(p
->pes
, p
->pos
, pid
, &p
->counter
, p
->feed
);
654 c2
= find_pes_header(buf
+ c
+ add
, length
- c
- add
, &p
->frags
);
658 p_to_t(buf
+ c
, c2
- c
, pid
, &p
->counter
, p
->feed
);
666 rest
= l
% (TS_SIZE
- 4);
668 p_to_t(buf
+ c
, l
, pid
, &p
->counter
, p
->feed
);
669 memcpy(p
->pes
, buf
+ c
+ l
, rest
);
677 int write_ts_header2(u16 pid
, u8
*counter
, int pes_start
, u8
*buf
, u8 length
)
682 u8 tshead
[4] = { 0x47, 0x00, 0x00, 0x10 };
684 fill
= (TS_SIZE
- 4) - length
;
689 tshead
[1] |= (u8
)((pid
& 0x1F00) >> 8);
690 tshead
[2] |= (u8
)(pid
& 0x00FF);
691 tshead
[3] |= ((*counter
)++ & 0x0F);
692 memcpy(buf
, tshead
, 4);
702 for (i
= 6; i
< fill
+ 4; i
++) {
712 static void p_to_t(u8
const *buf
, long int length
, u16 pid
, u8
*counter
,
713 struct dvb_demux_feed
*feed
)
721 buf
[0] == 0x00 && buf
[1] == 0x00 && buf
[2] == 0x01)
723 case PROG_STREAM_MAP
:
724 case PRIVATE_STREAM2
:
725 case PROG_STREAM_DIR
:
728 case PADDING_STREAM
:
730 case ISO13522_STREAM
:
731 case PRIVATE_STREAM1
:
732 case AUDIO_STREAM_S
... AUDIO_STREAM_E
:
733 case VIDEO_STREAM_S
... VIDEO_STREAM_E
:
742 memset(obuf
, 0, TS_SIZE
);
743 if (length
- c
>= (TS_SIZE
- 4)){
744 l
= write_ts_header2(pid
, counter
, pes_start
,
745 obuf
, (TS_SIZE
- 4));
746 memcpy(obuf
+ l
, buf
+ c
, TS_SIZE
- l
);
749 l
= write_ts_header2(pid
, counter
, pes_start
,
751 memcpy(obuf
+ l
, buf
+ c
, TS_SIZE
- l
);
754 feed
->cb
.ts(obuf
, 188, NULL
, 0, &feed
->feed
.ts
, DMX_OK
);
760 int av7110_write_to_decoder(struct dvb_demux_feed
*feed
, const u8
*buf
, size_t len
)
762 struct dvb_demux
*demux
= feed
->demux
;
763 struct av7110
*av7110
= (struct av7110
*) demux
->priv
;
764 struct ipack
*ipack
= &av7110
->ipack
[feed
->pes_type
];
766 dprintk(2, "av7110:%p, \n", av7110
);
768 switch (feed
->pes_type
) {
770 if (av7110
->audiostate
.stream_source
== AUDIO_SOURCE_MEMORY
)
774 if (av7110
->videostate
.stream_source
== VIDEO_SOURCE_MEMORY
)
781 if (!(buf
[3] & 0x10)) /* no payload? */
784 av7110_ipack_flush(ipack
);
786 if (buf
[3] & 0x20) { /* adaptation field? */
793 av7110_ipack_instant_repack(buf
+ 4, len
- 4, &av7110
->ipack
[feed
->pes_type
]);
799 /******************************************************************************
800 * Video MPEG decoder events
801 ******************************************************************************/
802 void dvb_video_add_event(struct av7110
*av7110
, struct video_event
*event
)
804 struct dvb_video_events
*events
= &av7110
->video_events
;
807 spin_lock_bh(&events
->lock
);
809 wp
= (events
->eventw
+ 1) % MAX_VIDEO_EVENT
;
810 if (wp
== events
->eventr
) {
811 events
->overflow
= 1;
812 events
->eventr
= (events
->eventr
+ 1) % MAX_VIDEO_EVENT
;
816 memcpy(&events
->events
[events
->eventw
], event
, sizeof(struct video_event
));
819 spin_unlock_bh(&events
->lock
);
821 wake_up_interruptible(&events
->wait_queue
);
825 static int dvb_video_get_event (struct av7110
*av7110
, struct video_event
*event
, int flags
)
827 struct dvb_video_events
*events
= &av7110
->video_events
;
829 if (events
->overflow
) {
830 events
->overflow
= 0;
833 if (events
->eventw
== events
->eventr
) {
836 if (flags
& O_NONBLOCK
)
839 ret
= wait_event_interruptible(events
->wait_queue
,
840 events
->eventw
!= events
->eventr
);
845 spin_lock_bh(&events
->lock
);
847 memcpy(event
, &events
->events
[events
->eventr
],
848 sizeof(struct video_event
));
849 events
->eventr
= (events
->eventr
+ 1) % MAX_VIDEO_EVENT
;
851 spin_unlock_bh(&events
->lock
);
857 /******************************************************************************
858 * DVB device file operations
859 ******************************************************************************/
861 static unsigned int dvb_video_poll(struct file
*file
, poll_table
*wait
)
863 struct dvb_device
*dvbdev
= (struct dvb_device
*) file
->private_data
;
864 struct av7110
*av7110
= (struct av7110
*) dvbdev
->priv
;
865 unsigned int mask
= 0;
867 dprintk(2, "av7110:%p, \n", av7110
);
869 if ((file
->f_flags
& O_ACCMODE
) != O_RDONLY
)
870 poll_wait(file
, &av7110
->avout
.queue
, wait
);
872 poll_wait(file
, &av7110
->video_events
.wait_queue
, wait
);
874 if (av7110
->video_events
.eventw
!= av7110
->video_events
.eventr
)
877 if ((file
->f_flags
& O_ACCMODE
) != O_RDONLY
) {
878 if (av7110
->playing
) {
880 mask
|= (POLLOUT
| POLLWRNORM
);
881 } else /* if not playing: may play if asked for */
882 mask
|= (POLLOUT
| POLLWRNORM
);
888 static ssize_t
dvb_video_write(struct file
*file
, const char __user
*buf
,
889 size_t count
, loff_t
*ppos
)
891 struct dvb_device
*dvbdev
= (struct dvb_device
*) file
->private_data
;
892 struct av7110
*av7110
= (struct av7110
*) dvbdev
->priv
;
894 dprintk(2, "av7110:%p, \n", av7110
);
896 if ((file
->f_flags
& O_ACCMODE
) == O_RDONLY
)
899 if (av7110
->videostate
.stream_source
!= VIDEO_SOURCE_MEMORY
)
902 return dvb_play(av7110
, buf
, count
, file
->f_flags
& O_NONBLOCK
, 1);
905 static unsigned int dvb_audio_poll(struct file
*file
, poll_table
*wait
)
907 struct dvb_device
*dvbdev
= (struct dvb_device
*) file
->private_data
;
908 struct av7110
*av7110
= (struct av7110
*) dvbdev
->priv
;
909 unsigned int mask
= 0;
911 dprintk(2, "av7110:%p, \n", av7110
);
913 poll_wait(file
, &av7110
->aout
.queue
, wait
);
915 if (av7110
->playing
) {
916 if (dvb_ringbuffer_free(&av7110
->aout
) >= 20 * 1024)
917 mask
|= (POLLOUT
| POLLWRNORM
);
918 } else /* if not playing: may play if asked for */
919 mask
= (POLLOUT
| POLLWRNORM
);
924 static ssize_t
dvb_audio_write(struct file
*file
, const char __user
*buf
,
925 size_t count
, loff_t
*ppos
)
927 struct dvb_device
*dvbdev
= (struct dvb_device
*) file
->private_data
;
928 struct av7110
*av7110
= (struct av7110
*) dvbdev
->priv
;
930 dprintk(2, "av7110:%p, \n", av7110
);
932 if (av7110
->audiostate
.stream_source
!= AUDIO_SOURCE_MEMORY
) {
933 printk(KERN_ERR
"not audio source memory\n");
936 return dvb_aplay(av7110
, buf
, count
, file
->f_flags
& O_NONBLOCK
, 0);
939 u8 iframe_header
[] = { 0x00, 0x00, 0x01, 0xe0, 0x00, 0x00, 0x80, 0x00, 0x00 };
941 #define MIN_IFRAME 400000
943 static int play_iframe(struct av7110
*av7110
, u8 __user
*buf
, unsigned int len
, int nonblock
)
947 dprintk(2, "av7110:%p, \n", av7110
);
949 if (!(av7110
->playing
& RP_VIDEO
)) {
950 if (av7110_av_start_play(av7110
, RP_VIDEO
) < 0)
954 /* setting n always > 1, fixes problems when playing stillframes
955 consisting of I- and P-Frames */
956 n
= MIN_IFRAME
/ len
+ 1;
958 /* FIXME: nonblock? */
959 dvb_play_kernel(av7110
, iframe_header
, sizeof(iframe_header
), 0, 1);
961 for (i
= 0; i
< n
; i
++)
962 dvb_play(av7110
, buf
, len
, 0, 1);
964 av7110_ipack_flush(&av7110
->ipack
[1]);
969 static int dvb_video_ioctl(struct inode
*inode
, struct file
*file
,
970 unsigned int cmd
, void *parg
)
972 struct dvb_device
*dvbdev
= (struct dvb_device
*) file
->private_data
;
973 struct av7110
*av7110
= (struct av7110
*) dvbdev
->priv
;
974 unsigned long arg
= (unsigned long) parg
;
977 dprintk(2, "av7110:%p, \n", av7110
);
979 if ((file
->f_flags
& O_ACCMODE
) == O_RDONLY
) {
980 if ( cmd
!= VIDEO_GET_STATUS
&& cmd
!= VIDEO_GET_EVENT
&&
981 cmd
!= VIDEO_GET_SIZE
) {
988 av7110
->videostate
.play_state
= VIDEO_STOPPED
;
989 if (av7110
->videostate
.stream_source
== VIDEO_SOURCE_MEMORY
)
990 av7110_av_stop(av7110
, RP_VIDEO
);
992 vidcom(av7110
, VIDEO_CMD_STOP
,
993 av7110
->videostate
.video_blank
? 0 : 1);
994 av7110
->trickmode
= TRICK_NONE
;
998 av7110
->trickmode
= TRICK_NONE
;
999 if (av7110
->videostate
.play_state
== VIDEO_FREEZED
) {
1000 av7110
->videostate
.play_state
= VIDEO_PLAYING
;
1001 vidcom(av7110
, VIDEO_CMD_PLAY
, 0);
1004 if (av7110
->videostate
.stream_source
== VIDEO_SOURCE_MEMORY
) {
1005 if (av7110
->playing
== RP_AV
) {
1006 av7110_fw_cmd(av7110
, COMTYPE_REC_PLAY
, __Stop
, 0);
1007 av7110
->playing
&= ~RP_VIDEO
;
1009 av7110_av_start_play(av7110
, RP_VIDEO
);
1010 vidcom(av7110
, VIDEO_CMD_PLAY
, 0);
1012 //av7110_av_stop(av7110, RP_VIDEO);
1013 vidcom(av7110
, VIDEO_CMD_PLAY
, 0);
1015 av7110
->videostate
.play_state
= VIDEO_PLAYING
;
1019 av7110
->videostate
.play_state
= VIDEO_FREEZED
;
1020 if (av7110
->playing
& RP_VIDEO
)
1021 av7110_fw_cmd(av7110
, COMTYPE_REC_PLAY
, __Pause
, 0);
1023 vidcom(av7110
, VIDEO_CMD_FREEZE
, 1);
1024 av7110
->trickmode
= TRICK_FREEZE
;
1027 case VIDEO_CONTINUE
:
1028 if (av7110
->playing
& RP_VIDEO
)
1029 av7110_fw_cmd(av7110
, COMTYPE_REC_PLAY
, __Continue
, 0);
1030 vidcom(av7110
, VIDEO_CMD_PLAY
, 0);
1031 av7110
->videostate
.play_state
= VIDEO_PLAYING
;
1032 av7110
->trickmode
= TRICK_NONE
;
1035 case VIDEO_SELECT_SOURCE
:
1036 av7110
->videostate
.stream_source
= (video_stream_source_t
) arg
;
1039 case VIDEO_SET_BLANK
:
1040 av7110
->videostate
.video_blank
= (int) arg
;
1043 case VIDEO_GET_STATUS
:
1044 memcpy(parg
, &av7110
->videostate
, sizeof(struct video_status
));
1047 case VIDEO_GET_EVENT
:
1048 ret
=dvb_video_get_event(av7110
, parg
, file
->f_flags
);
1051 case VIDEO_GET_SIZE
:
1052 memcpy(parg
, &av7110
->video_size
, sizeof(video_size_t
));
1055 case VIDEO_SET_DISPLAY_FORMAT
:
1057 video_displayformat_t format
= (video_displayformat_t
) arg
;
1061 case VIDEO_PAN_SCAN
:
1062 val
= VID_PAN_SCAN_PREF
;
1065 case VIDEO_LETTER_BOX
:
1066 val
= VID_VC_AND_PS_PREF
;
1069 case VIDEO_CENTER_CUT_OUT
:
1070 val
= VID_CENTRE_CUT_PREF
;
1078 av7110
->videostate
.video_format
= format
;
1079 ret
= av7110_fw_cmd(av7110
, COMTYPE_ENCODER
, SetPanScanType
,
1084 case VIDEO_SET_FORMAT
:
1089 av7110
->display_ar
= arg
;
1090 ret
= av7110_fw_cmd(av7110
, COMTYPE_ENCODER
, SetMonitorType
,
1094 case VIDEO_STILLPICTURE
:
1096 struct video_still_picture
*pic
=
1097 (struct video_still_picture
*) parg
;
1098 av7110
->videostate
.stream_source
= VIDEO_SOURCE_MEMORY
;
1099 dvb_ringbuffer_flush_spinlock_wakeup(&av7110
->avout
);
1100 ret
= play_iframe(av7110
, pic
->iFrame
, pic
->size
,
1101 file
->f_flags
& O_NONBLOCK
);
1105 case VIDEO_FAST_FORWARD
:
1106 //note: arg is ignored by firmware
1107 if (av7110
->playing
& RP_VIDEO
)
1108 av7110_fw_cmd(av7110
, COMTYPE_REC_PLAY
,
1109 __Scan_I
, 2, AV_PES
, 0);
1111 vidcom(av7110
, VIDEO_CMD_FFWD
, arg
);
1112 av7110
->trickmode
= TRICK_FAST
;
1113 av7110
->videostate
.play_state
= VIDEO_PLAYING
;
1116 case VIDEO_SLOWMOTION
:
1117 if (av7110
->playing
&RP_VIDEO
) {
1118 av7110_fw_cmd(av7110
, COMTYPE_REC_PLAY
, __Slow
, 2, 0, 0);
1119 vidcom(av7110
, VIDEO_CMD_SLOW
, arg
);
1121 vidcom(av7110
, VIDEO_CMD_PLAY
, 0);
1122 vidcom(av7110
, VIDEO_CMD_STOP
, 0);
1123 vidcom(av7110
, VIDEO_CMD_SLOW
, arg
);
1125 av7110
->trickmode
= TRICK_SLOW
;
1126 av7110
->videostate
.play_state
= VIDEO_PLAYING
;
1129 case VIDEO_GET_CAPABILITIES
:
1130 *(int *)parg
= VIDEO_CAP_MPEG1
| VIDEO_CAP_MPEG2
|
1131 VIDEO_CAP_SYS
| VIDEO_CAP_PROG
;
1134 case VIDEO_CLEAR_BUFFER
:
1135 dvb_ringbuffer_flush_spinlock_wakeup(&av7110
->avout
);
1136 av7110_ipack_reset(&av7110
->ipack
[1]);
1138 if (av7110
->playing
== RP_AV
) {
1139 av7110_fw_cmd(av7110
, COMTYPE_REC_PLAY
,
1140 __Play
, 2, AV_PES
, 0);
1141 if (av7110
->trickmode
== TRICK_FAST
)
1142 av7110_fw_cmd(av7110
, COMTYPE_REC_PLAY
,
1143 __Scan_I
, 2, AV_PES
, 0);
1144 if (av7110
->trickmode
== TRICK_SLOW
) {
1145 av7110_fw_cmd(av7110
, COMTYPE_REC_PLAY
,
1147 vidcom(av7110
, VIDEO_CMD_SLOW
, arg
);
1149 if (av7110
->trickmode
== TRICK_FREEZE
)
1150 vidcom(av7110
, VIDEO_CMD_STOP
, 1);
1154 case VIDEO_SET_STREAMTYPE
:
1165 static int dvb_audio_ioctl(struct inode
*inode
, struct file
*file
,
1166 unsigned int cmd
, void *parg
)
1168 struct dvb_device
*dvbdev
= (struct dvb_device
*) file
->private_data
;
1169 struct av7110
*av7110
= (struct av7110
*) dvbdev
->priv
;
1170 unsigned long arg
= (unsigned long) parg
;
1173 dprintk(2, "av7110:%p, \n", av7110
);
1175 if (((file
->f_flags
& O_ACCMODE
) == O_RDONLY
) &&
1176 (cmd
!= AUDIO_GET_STATUS
))
1181 if (av7110
->audiostate
.stream_source
== AUDIO_SOURCE_MEMORY
)
1182 av7110_av_stop(av7110
, RP_AUDIO
);
1184 audcom(av7110
, AUDIO_CMD_MUTE
);
1185 av7110
->audiostate
.play_state
= AUDIO_STOPPED
;
1189 if (av7110
->audiostate
.stream_source
== AUDIO_SOURCE_MEMORY
)
1190 av7110_av_start_play(av7110
, RP_AUDIO
);
1191 audcom(av7110
, AUDIO_CMD_UNMUTE
);
1192 av7110
->audiostate
.play_state
= AUDIO_PLAYING
;
1196 audcom(av7110
, AUDIO_CMD_MUTE
);
1197 av7110
->audiostate
.play_state
= AUDIO_PAUSED
;
1200 case AUDIO_CONTINUE
:
1201 if (av7110
->audiostate
.play_state
== AUDIO_PAUSED
) {
1202 av7110
->audiostate
.play_state
= AUDIO_PLAYING
;
1203 audcom(av7110
, AUDIO_CMD_MUTE
| AUDIO_CMD_PCM16
);
1207 case AUDIO_SELECT_SOURCE
:
1208 av7110
->audiostate
.stream_source
= (audio_stream_source_t
) arg
;
1211 case AUDIO_SET_MUTE
:
1213 audcom(av7110
, arg
? AUDIO_CMD_MUTE
: AUDIO_CMD_UNMUTE
);
1214 av7110
->audiostate
.mute_state
= (int) arg
;
1218 case AUDIO_SET_AV_SYNC
:
1219 av7110
->audiostate
.AV_sync_state
= (int) arg
;
1220 audcom(av7110
, arg
? AUDIO_CMD_SYNC_ON
: AUDIO_CMD_SYNC_OFF
);
1223 case AUDIO_SET_BYPASS_MODE
:
1227 case AUDIO_CHANNEL_SELECT
:
1228 av7110
->audiostate
.channel_select
= (audio_channel_select_t
) arg
;
1230 switch(av7110
->audiostate
.channel_select
) {
1232 audcom(av7110
, AUDIO_CMD_STEREO
);
1235 case AUDIO_MONO_LEFT
:
1236 audcom(av7110
, AUDIO_CMD_MONO_L
);
1239 case AUDIO_MONO_RIGHT
:
1240 audcom(av7110
, AUDIO_CMD_MONO_R
);
1249 case AUDIO_GET_STATUS
:
1250 memcpy(parg
, &av7110
->audiostate
, sizeof(struct audio_status
));
1253 case AUDIO_GET_CAPABILITIES
:
1254 *(int *)parg
= AUDIO_CAP_LPCM
| AUDIO_CAP_MP1
| AUDIO_CAP_MP2
;
1257 case AUDIO_CLEAR_BUFFER
:
1258 dvb_ringbuffer_flush_spinlock_wakeup(&av7110
->aout
);
1259 av7110_ipack_reset(&av7110
->ipack
[0]);
1260 if (av7110
->playing
== RP_AV
)
1261 av7110_fw_cmd(av7110
, COMTYPE_REC_PLAY
,
1262 __Play
, 2, AV_PES
, 0);
1267 case AUDIO_SET_MIXER
:
1269 struct audio_mixer
*amix
= (struct audio_mixer
*)parg
;
1271 av7110_set_volume(av7110
, amix
->volume_left
, amix
->volume_right
);
1274 case AUDIO_SET_STREAMTYPE
:
1283 static int dvb_video_open(struct inode
*inode
, struct file
*file
)
1285 struct dvb_device
*dvbdev
= (struct dvb_device
*) file
->private_data
;
1286 struct av7110
*av7110
= (struct av7110
*) dvbdev
->priv
;
1289 dprintk(2, "av7110:%p, \n", av7110
);
1291 if ((err
= dvb_generic_open(inode
, file
)) < 0)
1294 if ((file
->f_flags
& O_ACCMODE
) != O_RDONLY
) {
1295 dvb_ringbuffer_flush_spinlock_wakeup(&av7110
->aout
);
1296 dvb_ringbuffer_flush_spinlock_wakeup(&av7110
->avout
);
1297 av7110
->video_blank
= 1;
1298 av7110
->audiostate
.AV_sync_state
= 1;
1299 av7110
->videostate
.stream_source
= VIDEO_SOURCE_DEMUX
;
1301 /* empty event queue */
1302 av7110
->video_events
.eventr
= av7110
->video_events
.eventw
= 0;
1308 static int dvb_video_release(struct inode
*inode
, struct file
*file
)
1310 struct dvb_device
*dvbdev
= (struct dvb_device
*) file
->private_data
;
1311 struct av7110
*av7110
= (struct av7110
*) dvbdev
->priv
;
1313 dprintk(2, "av7110:%p, \n", av7110
);
1315 if ((file
->f_flags
& O_ACCMODE
) != O_RDONLY
) {
1316 av7110_av_stop(av7110
, RP_VIDEO
);
1319 return dvb_generic_release(inode
, file
);
1322 static int dvb_audio_open(struct inode
*inode
, struct file
*file
)
1324 struct dvb_device
*dvbdev
= (struct dvb_device
*) file
->private_data
;
1325 struct av7110
*av7110
= (struct av7110
*) dvbdev
->priv
;
1326 int err
=dvb_generic_open(inode
, file
);
1328 dprintk(2, "av7110:%p, \n", av7110
);
1332 dvb_ringbuffer_flush_spinlock_wakeup(&av7110
->aout
);
1333 av7110
->audiostate
.stream_source
= AUDIO_SOURCE_DEMUX
;
1337 static int dvb_audio_release(struct inode
*inode
, struct file
*file
)
1339 struct dvb_device
*dvbdev
= (struct dvb_device
*) file
->private_data
;
1340 struct av7110
*av7110
= (struct av7110
*) dvbdev
->priv
;
1342 dprintk(2, "av7110:%p, \n", av7110
);
1344 av7110_av_stop(av7110
, RP_AUDIO
);
1345 return dvb_generic_release(inode
, file
);
1350 /******************************************************************************
1351 * driver registration
1352 ******************************************************************************/
1354 static struct file_operations dvb_video_fops
= {
1355 .owner
= THIS_MODULE
,
1356 .write
= dvb_video_write
,
1357 .ioctl
= dvb_generic_ioctl
,
1358 .open
= dvb_video_open
,
1359 .release
= dvb_video_release
,
1360 .poll
= dvb_video_poll
,
1363 static struct dvb_device dvbdev_video
= {
1366 .readers
= 5, /* arbitrary */
1368 .fops
= &dvb_video_fops
,
1369 .kernel_ioctl
= dvb_video_ioctl
,
1372 static struct file_operations dvb_audio_fops
= {
1373 .owner
= THIS_MODULE
,
1374 .write
= dvb_audio_write
,
1375 .ioctl
= dvb_generic_ioctl
,
1376 .open
= dvb_audio_open
,
1377 .release
= dvb_audio_release
,
1378 .poll
= dvb_audio_poll
,
1381 static struct dvb_device dvbdev_audio
= {
1385 .fops
= &dvb_audio_fops
,
1386 .kernel_ioctl
= dvb_audio_ioctl
,
1390 int av7110_av_register(struct av7110
*av7110
)
1392 av7110
->audiostate
.AV_sync_state
= 0;
1393 av7110
->audiostate
.mute_state
= 0;
1394 av7110
->audiostate
.play_state
= AUDIO_STOPPED
;
1395 av7110
->audiostate
.stream_source
= AUDIO_SOURCE_DEMUX
;
1396 av7110
->audiostate
.channel_select
= AUDIO_STEREO
;
1397 av7110
->audiostate
.bypass_mode
= 0;
1399 av7110
->videostate
.video_blank
= 0;
1400 av7110
->videostate
.play_state
= VIDEO_STOPPED
;
1401 av7110
->videostate
.stream_source
= VIDEO_SOURCE_DEMUX
;
1402 av7110
->videostate
.video_format
= VIDEO_FORMAT_4_3
;
1403 av7110
->videostate
.display_format
= VIDEO_CENTER_CUT_OUT
;
1404 av7110
->display_ar
= VIDEO_FORMAT_4_3
;
1406 init_waitqueue_head(&av7110
->video_events
.wait_queue
);
1407 spin_lock_init(&av7110
->video_events
.lock
);
1408 av7110
->video_events
.eventw
= av7110
->video_events
.eventr
= 0;
1409 av7110
->video_events
.overflow
= 0;
1410 memset(&av7110
->video_size
, 0, sizeof (video_size_t
));
1412 dvb_register_device(av7110
->dvb_adapter
, &av7110
->video_dev
,
1413 &dvbdev_video
, av7110
, DVB_DEVICE_VIDEO
);
1415 dvb_register_device(av7110
->dvb_adapter
, &av7110
->audio_dev
,
1416 &dvbdev_audio
, av7110
, DVB_DEVICE_AUDIO
);
1421 void av7110_av_unregister(struct av7110
*av7110
)
1423 dvb_unregister_device(av7110
->audio_dev
);
1424 dvb_unregister_device(av7110
->video_dev
);
1427 int av7110_av_init(struct av7110
*av7110
)
1429 av7110
->vidmode
= VIDEO_MODE_PAL
;
1431 av7110_ipack_init(&av7110
->ipack
[0], IPACKS
, play_audio_cb
);
1432 av7110
->ipack
[0].data
= (void *) av7110
;
1433 av7110_ipack_init(&av7110
->ipack
[1], IPACKS
, play_video_cb
);
1434 av7110
->ipack
[1].data
= (void *) av7110
;
1436 dvb_ringbuffer_init(&av7110
->avout
, av7110
->iobuf
, AVOUTLEN
);
1437 dvb_ringbuffer_init(&av7110
->aout
, av7110
->iobuf
+ AVOUTLEN
, AOUTLEN
);
1439 av7110
->kbuf
[0] = (u8
*)(av7110
->iobuf
+ AVOUTLEN
+ AOUTLEN
+ BMPLEN
);
1440 av7110
->kbuf
[1] = av7110
->kbuf
[0] + 2 * IPACKS
;
1445 int av7110_av_exit(struct av7110
*av7110
)
1447 av7110_ipack_free(&av7110
->ipack
[0]);
1448 av7110_ipack_free(&av7110
->ipack
[1]);