?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] DVB: misc driver updates
[linux-2.6/history.git] / drivers / media / dvb / ttpci / av7110_av.c
blobf885c72dfc244b4a55694045738c8430456689dd
1 /*
2 * av7110_av.c: audio and video MPEG decoder stuff
3 *
4 * Copyright (C) 1999-2002 Ralph Metzler
5 * & Marcus Metzler for convergence integrated media GmbH
6 *
7 * originally based on code by:
8 * Copyright (C) 1998,1999 Christian Theiss <mistert@rz.fh-augsburg.de>
9 *
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.
14 *
15 *
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.
20 *
21 *
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
26 *
27 *
28 * the project's page is at http://www.linuxtv.org/dvb/
29 */
30
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>
38 #include <linux/fs.h>
39
40 #include "av7110.h"
41 #include "av7110_hw.h"
42 #include "av7110_av.h"
43 #include "av7110_ipack.h"
44
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
59
60 #define PTS_DTS_FLAGS 0xC0
61
62 //pts_dts flags
63 #define PTS_ONLY 0x80
64 #define PTS_DTS 0xC0
65 #define TS_SIZE 188
66 #define TRANS_ERROR 0x80
67 #define PAY_START 0x40
68 #define TRANS_PRIO 0x20
69 #define PID_MASK_HI 0x1F
70 //flags
71 #define TRANS_SCRMBL1 0x80
72 #define TRANS_SCRMBL2 0x40
73 #define ADAPT_FIELD 0x20
74 #define PAYLOAD 0x10
75 #define COUNT_MASK 0x0F
76
77 // adaptation flags
78 #define DISCON_IND 0x80
79 #define RAND_ACC_IND 0x40
80 #define ES_PRI_IND 0x20
81 #define PCR_FLAG 0x10
82 #define OPCR_FLAG 0x08
83 #define SPLICE_FLAG 0x04
84 #define TRANS_PRIV 0x02
85 #define ADAP_EXT_FLAG 0x01
86
87 // adaptation extension flags
88 #define LTW_FLAG 0x80
89 #define PIECE_RATE 0x40
90 #define SEAM_SPLICE 0x20
91
92
93 static void p_to_t(u8 const *buf, long int length, u16 pid,
94 u8 *counter, struct dvb_demux_feed *feed);
95
96
97 int av7110_record_cb(struct dvb_filter_pes2ts *p2t, u8 *buf, size_t len)
98 {
99 struct dvb_demux_feed *dvbdmxfeed = (struct dvb_demux_feed *) p2t->priv;
100
101 // DEB_EE(("struct dvb_filter_pes2ts:%p\n", p2t));
102
103 if (!(dvbdmxfeed->ts_type & TS_PACKET))
104 return 0;
105 if (buf[3] == 0xe0) // video PES do not have a length in TS
106 buf[4] = buf[5] = 0;
107 if (dvbdmxfeed->ts_type & TS_PAYLOAD_ONLY)
108 return dvbdmxfeed->cb.ts(buf, len, NULL, 0,
109 &dvbdmxfeed->feed.ts, DMX_OK);
110 else
111 return dvb_filter_pes2ts(p2t, buf, len, 1);
112 }
113
114 static int dvb_filter_pes2ts_cb(void *priv, unsigned char *data)
115 {
116 struct dvb_demux_feed *dvbdmxfeed = (struct dvb_demux_feed *) priv;
117
118 // DEB_EE(("dvb_demux_feed:%p\n", dvbdmxfeed));
119
120 dvbdmxfeed->cb.ts(data, 188, NULL, 0,
121 &dvbdmxfeed->feed.ts, DMX_OK);
122 return 0;
123 }
124
125 int av7110_av_start_record(struct av7110 *av7110, int av,
126 struct dvb_demux_feed *dvbdmxfeed)
127 {
128 struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
129
130 DEB_EE(("av7110: %p, dvb_demux_feed:%p\n", av7110, dvbdmxfeed));
131
132 if (av7110->playing || (av7110->rec_mode & av))
133 return -EBUSY;
134 av7110_fw_cmd(av7110, COMTYPE_REC_PLAY, __Stop, 0);
135 dvbdmx->recording = 1;
136 av7110->rec_mode |= av;
137
138 switch (av7110->rec_mode) {
139 case RP_AUDIO:
140 dvb_filter_pes2ts_init(&av7110->p2t[0],
141 dvbdmx->pesfilter[0]->pid,
142 dvb_filter_pes2ts_cb,
143 (void *) dvbdmx->pesfilter[0]);
144 av7110_fw_cmd(av7110, COMTYPE_REC_PLAY, __Record, 2, AudioPES, 0);
145 break;
146
147 case RP_VIDEO:
148 dvb_filter_pes2ts_init(&av7110->p2t[1],
149 dvbdmx->pesfilter[1]->pid,
150 dvb_filter_pes2ts_cb,
151 (void *) dvbdmx->pesfilter[1]);
152 av7110_fw_cmd(av7110, COMTYPE_REC_PLAY, __Record, 2, VideoPES, 0);
153 break;
154
155 case RP_AV:
156 dvb_filter_pes2ts_init(&av7110->p2t[0],
157 dvbdmx->pesfilter[0]->pid,
158 dvb_filter_pes2ts_cb,
159 (void *) dvbdmx->pesfilter[0]);
160 dvb_filter_pes2ts_init(&av7110->p2t[1],
161 dvbdmx->pesfilter[1]->pid,
162 dvb_filter_pes2ts_cb,
163 (void *) dvbdmx->pesfilter[1]);
164 av7110_fw_cmd(av7110, COMTYPE_REC_PLAY, __Record, 2, AV_PES, 0);
165 break;
166 }
167 return 0;
168 }
169
170 int av7110_av_start_play(struct av7110 *av7110, int av)
171 {
172 DEB_EE(("av7110: %p\n", av7110));
173
174 if (av7110->rec_mode)
175 return -EBUSY;
176 if (av7110->playing & av)
177 return -EBUSY;
178
179 av7110_fw_cmd(av7110, COMTYPE_REC_PLAY, __Stop, 0);
180
181 if (av7110->playing == RP_NONE) {
182 av7110_ipack_reset(&av7110->ipack[0]);
183 av7110_ipack_reset(&av7110->ipack[1]);
184 }
185
186 av7110->playing |= av;
187 switch (av7110->playing) {
188 case RP_AUDIO:
189 av7110_fw_cmd(av7110, COMTYPE_REC_PLAY, __Play, 2, AudioPES, 0);
190 break;
191 case RP_VIDEO:
192 av7110_fw_cmd(av7110, COMTYPE_REC_PLAY, __Play, 2, VideoPES, 0);
193 av7110->sinfo = 0;
194 break;
195 case RP_AV:
196 av7110->sinfo = 0;
197 av7110_fw_cmd(av7110, COMTYPE_REC_PLAY, __Play, 2, AV_PES, 0);
198 break;
199 }
200 return av7110->playing;
201 }
202
203 void av7110_av_stop(struct av7110 *av7110, int av)
204 {
205 DEB_EE(("av7110: %p\n", av7110));
206
207 if (!(av7110->playing & av) && !(av7110->rec_mode & av))
208 return;
209
210 av7110_fw_cmd(av7110, COMTYPE_REC_PLAY, __Stop, 0);
211 if (av7110->playing) {
212 av7110->playing &= ~av;
213 switch (av7110->playing) {
214 case RP_AUDIO:
215 av7110_fw_cmd(av7110, COMTYPE_REC_PLAY, __Play, 2, AudioPES, 0);
216 break;
217 case RP_VIDEO:
218 av7110_fw_cmd(av7110, COMTYPE_REC_PLAY, __Play, 2, VideoPES, 0);
219 break;
220 case RP_NONE:
221 av7110_set_vidmode(av7110, av7110->vidmode);
222 break;
223 }
224 } else {
225 av7110->rec_mode &= ~av;
226 switch (av7110->rec_mode) {
227 case RP_AUDIO:
228 av7110_fw_cmd(av7110, COMTYPE_REC_PLAY, __Record, 2, AudioPES, 0);
229 break;
230 case RP_VIDEO:
231 av7110_fw_cmd(av7110, COMTYPE_REC_PLAY, __Record, 2, VideoPES, 0);
232 break;
233 case RP_NONE:
234 break;
235 }
236 }
237 }
238
239
240 int av7110_pes_play(void *dest, struct dvb_ringbuffer *buf, int dlen)
241 {
242 int len;
243 u32 sync;
244 u16 blen;
245
246 DEB_EE(("dvb_ring_buffer_t: %p\n", buf));
247
248 if (!dlen) {
249 wake_up(&buf->queue);
250 return -1;
251 }
252 while (1) {
253 if ((len = dvb_ringbuffer_avail(buf)) < 6)
254 return -1;
255 sync = DVB_RINGBUFFER_PEEK(buf, 0) << 24;
256 sync |= DVB_RINGBUFFER_PEEK(buf, 1) << 16;
257 sync |= DVB_RINGBUFFER_PEEK(buf, 2) << 8;
258 sync |= DVB_RINGBUFFER_PEEK(buf, 3);
259
260 if (((sync &~ 0x0f) == 0x000001e0) ||
261 ((sync &~ 0x1f) == 0x000001c0) ||
262 (sync == 0x000001bd))
263 break;
264 printk("resync\n");
265 DVB_RINGBUFFER_SKIP(buf, 1);
266 }
267 blen = DVB_RINGBUFFER_PEEK(buf, 4) << 8;
268 blen |= DVB_RINGBUFFER_PEEK(buf, 5);
269 blen += 6;
270 if (len < blen || blen > dlen) {
271 //printk("buffer empty - avail %d blen %u dlen %d\n", len, blen, dlen);
272 wake_up(&buf->queue);
273 return -1;
274 }
275
276 dvb_ringbuffer_read(buf, dest, (size_t) blen, 0);
277
278 DEB_S(("pread=0x%08lx, pwrite=0x%08lx\n",
279 (unsigned long) buf->pread, (unsigned long) buf->pwrite));
280 wake_up(&buf->queue);
281 return blen;
282 }
283
284
285 int av7110_set_volume(struct av7110 *av7110, int volleft, int volright)
286 {
287 int err, vol, val, balance = 0;
288
289 DEB_EE(("av7110: %p\n", av7110));
290
291 av7110->mixer.volume_left = volleft;
292 av7110->mixer.volume_right = volright;
293
294 switch (av7110->adac_type) {
295 case DVB_ADAC_TI:
296 volleft = (volleft * 256) / 1036;
297 volright = (volright * 256) / 1036;
298 if (volleft > 0x3f)
299 volleft = 0x3f;
300 if (volright > 0x3f)
301 volright = 0x3f;
302 if ((err = SendDAC(av7110, 3, 0x80 + volleft)))
303 return err;
304 return SendDAC(av7110, 4, volright);
305
306 case DVB_ADAC_CRYSTAL:
307 volleft = 127 - volleft / 2;
308 volright = 127 - volright / 2;
309 i2c_writereg(av7110, 0x20, 0x03, volleft);
310 i2c_writereg(av7110, 0x20, 0x04, volright);
311 return 0;
312
313 case DVB_ADAC_MSP:
314 vol = (volleft > volright) ? volleft : volright;
315 val = (vol * 0x73 / 255) << 8;
316 if (vol > 0)
317 balance = ((volright - volleft) * 127) / vol;
318 msp_writereg(av7110, MSP_WR_DSP, 0x0001, balance << 8);
319 msp_writereg(av7110, MSP_WR_DSP, 0x0000, val); /* loudspeaker */
320 msp_writereg(av7110, MSP_WR_DSP, 0x0006, val); /* headphonesr */
321 return 0;
322 }
323 return 0;
324 }
325
326 void av7110_set_vidmode(struct av7110 *av7110, int mode)
327 {
328 DEB_EE(("av7110: %p\n", av7110));
329
330 av7110_fw_cmd(av7110, COMTYPE_ENCODER, LoadVidCode, 1, mode);
331
332 if (!av7110->playing) {
333 ChangePIDs(av7110, av7110->pids[DMX_PES_VIDEO],
334 av7110->pids[DMX_PES_AUDIO],
335 av7110->pids[DMX_PES_TELETEXT],
336 0, av7110->pids[DMX_PES_PCR]);
337 av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, Scan, 0);
338 }
339 }
340
341
342 static int sw2mode[16] = {
343 VIDEO_MODE_PAL, VIDEO_MODE_NTSC, VIDEO_MODE_NTSC, VIDEO_MODE_PAL,
344 VIDEO_MODE_NTSC, VIDEO_MODE_NTSC, VIDEO_MODE_PAL, VIDEO_MODE_NTSC,
345 VIDEO_MODE_PAL, VIDEO_MODE_PAL, VIDEO_MODE_PAL, VIDEO_MODE_PAL,
346 VIDEO_MODE_PAL, VIDEO_MODE_PAL, VIDEO_MODE_PAL, VIDEO_MODE_PAL,
347 };
348
349 static void get_video_format(struct av7110 *av7110, u8 *buf, int count)
350 {
351 int i;
352 int hsize, vsize;
353 int sw;
354 u8 *p;
355
356 DEB_EE(("av7110: %p\n", av7110));
357
358 if (av7110->sinfo)
359 return;
360 for (i = 7; i < count - 10; i++) {
361 p = buf + i;
362 if (p[0] || p[1] || p[2] != 0x01 || p[3] != 0xb3)
363 continue;
364 p += 4;
365 hsize = ((p[1] &0xF0) >> 4) | (p[0] << 4);
366 vsize = ((p[1] &0x0F) << 8) | (p[2]);
367 sw = (p[3] & 0x0F);
368 av7110_set_vidmode(av7110, sw2mode[sw]);
369 DEB_S(("dvb: playback %dx%d fr=%d\n", hsize, vsize, sw));
370 av7110->sinfo = 1;
371 break;
372 }
373 }
374
375
376 /****************************************************************************
377 * I/O buffer management and control
378 ****************************************************************************/
379
380 static inline long aux_ring_buffer_write(struct dvb_ringbuffer *rbuf,
381 const char *buf, unsigned long count)
382 {
383 unsigned long todo = count;
384 int free;
385
386 while (todo > 0) {
387 if (dvb_ringbuffer_free(rbuf) < 2048) {
388 if (wait_event_interruptible(rbuf->queue,
389 (dvb_ringbuffer_free(rbuf) >= 2048)))
390 return count - todo;
391 }
392 free = dvb_ringbuffer_free(rbuf);
393 if (free > todo)
394 free = todo;
395 dvb_ringbuffer_write(rbuf, buf, free);
396 todo -= free;
397 buf += free;
398 }
399
400 return count - todo;
401 }
402
403 static void play_video_cb(u8 *buf, int count, void *priv)
404 {
405 struct av7110 *av7110 = (struct av7110 *) priv;
406 DEB_EE(("av7110: %p\n", av7110));
407
408 if ((buf[3] & 0xe0) == 0xe0) {
409 get_video_format(av7110, buf, count);
410 aux_ring_buffer_write(&av7110->avout, buf, count);
411 } else
412 aux_ring_buffer_write(&av7110->aout, buf, count);
413 }
414
415 static void play_audio_cb(u8 *buf, int count, void *priv)
416 {
417 struct av7110 *av7110 = (struct av7110 *) priv;
418 DEB_EE(("av7110: %p\n", av7110));
419
420 aux_ring_buffer_write(&av7110->aout, buf, count);
421 }
422
423 #define FREE_COND (dvb_ringbuffer_free(&av7110->avout) >= 20 * 1024 && \
424 dvb_ringbuffer_free(&av7110->aout) >= 20 * 1024)
425
426 static ssize_t dvb_play(struct av7110 *av7110, const u8 __user *buf,
427 unsigned long count, int nonblock, int type)
428 {
429 unsigned long todo = count, n;
430 DEB_EE(("av7110: %p\n", av7110));
431
432 if (!av7110->kbuf[type])
433 return -ENOBUFS;
434
435 if (nonblock && !FREE_COND)
436 return -EWOULDBLOCK;
437
438 while (todo > 0) {
439 if (!FREE_COND) {
440 if (nonblock)
441 return count - todo;
442 if (wait_event_interruptible(av7110->avout.queue,
443 FREE_COND))
444 return count - todo;
445 }
446 n = todo;
447 if (n > IPACKS * 2)
448 n = IPACKS * 2;
449 if (copy_from_user(av7110->kbuf[type], buf, n))
450 return -EFAULT;
451 av7110_ipack_instant_repack(av7110->kbuf[type], n,
452 &av7110->ipack[type]);
453 todo -= n;
454 buf += n;
455 }
456 return count - todo;
457 }
458
459 static ssize_t dvb_play_kernel(struct av7110 *av7110, const u8 *buf,
460 unsigned long count, int nonblock, int type)
461 {
462 unsigned long todo = count, n;
463 DEB_EE(("av7110: %p\n", av7110));
464
465 if (!av7110->kbuf[type])
466 return -ENOBUFS;
467
468 if (nonblock && !FREE_COND)
469 return -EWOULDBLOCK;
470
471 while (todo > 0) {
472 if (!FREE_COND) {
473 if (nonblock)
474 return count - todo;
475 if (wait_event_interruptible(av7110->avout.queue,
476 FREE_COND))
477 return count - todo;
478 }
479 n = todo;
480 if (n > IPACKS * 2)
481 n = IPACKS * 2;
482 av7110_ipack_instant_repack(buf, n, &av7110->ipack[type]);
483 todo -= n;
484 buf += n;
485 }
486 return count - todo;
487 }
488
489 static ssize_t dvb_aplay(struct av7110 *av7110, const u8 __user *buf,
490 unsigned long count, int nonblock, int type)
491 {
492 unsigned long todo = count, n;
493 DEB_EE(("av7110: %p\n", av7110));
494
495 if (!av7110->kbuf[type])
496 return -ENOBUFS;
497 if (nonblock && dvb_ringbuffer_free(&av7110->aout) < 20 * 1024)
498 return -EWOULDBLOCK;
499
500 while (todo > 0) {
501 if (dvb_ringbuffer_free(&av7110->aout) < 20 * 1024) {
502 if (nonblock)
503 return count - todo;
504 if (wait_event_interruptible(av7110->aout.queue,
505 (dvb_ringbuffer_free(&av7110->aout) >= 20 * 1024)))
506 return count-todo;
507 }
508 n = todo;
509 if (n > IPACKS * 2)
510 n = IPACKS * 2;
511 if (copy_from_user(av7110->kbuf[type], buf, n))
512 return -EFAULT;
513 av7110_ipack_instant_repack(av7110->kbuf[type], n,
514 &av7110->ipack[type]);
515 todo -= n;
516 buf += n;
517 }
518 return count - todo;
519 }
520
521 void av7110_p2t_init(struct av7110_p2t *p, struct dvb_demux_feed *feed)
522 {
523 memset(p->pes, 0, TS_SIZE);
524 p->counter = 0;
525 p->pos = 0;
526 p->frags = 0;
527 if (feed)
528 p->feed = feed;
529 }
530
531 static void clear_p2t(struct av7110_p2t *p)
532 {
533 memset(p->pes, 0, TS_SIZE);
534 // p->counter = 0;
535 p->pos = 0;
536 p->frags = 0;
537 }
538
539
540 static int find_pes_header(u8 const *buf, long int length, int *frags)
541 {
542 int c = 0;
543 int found = 0;
544
545 *frags = 0;
546
547 while (c < length - 3 && !found) {
548 if (buf[c] == 0x00 && buf[c + 1] == 0x00 &&
549 buf[c + 2] == 0x01) {
550 switch ( buf[c + 3] ) {
551 case PROG_STREAM_MAP:
552 case PRIVATE_STREAM2:
553 case PROG_STREAM_DIR:
554 case ECM_STREAM :
555 case EMM_STREAM :
556 case PADDING_STREAM :
557 case DSM_CC_STREAM :
558 case ISO13522_STREAM:
559 case PRIVATE_STREAM1:
560 case AUDIO_STREAM_S ... AUDIO_STREAM_E:
561 case VIDEO_STREAM_S ... VIDEO_STREAM_E:
562 found = 1;
563 break;
564
565 default:
566 c++;
567 break;
568 }
569 } else
570 c++;
571 }
572 if (c == length - 3 && !found) {
573 if (buf[length - 1] == 0x00)
574 *frags = 1;
575 if (buf[length - 2] == 0x00 &&
576 buf[length - 1] == 0x00)
577 *frags = 2;
578 if (buf[length - 3] == 0x00 &&
579 buf[length - 2] == 0x00 &&
580 buf[length - 1] == 0x01)
581 *frags = 3;
582 return -1;
583 }
584
585 return c;
586 }
587
588 void av7110_p2t_write(u8 const *buf, long int length, u16 pid, struct av7110_p2t *p)
589 {
590 int c, c2, l, add;
591 int check, rest;
592
593 c = 0;
594 c2 = 0;
595 if (p->frags){
596 check = 0;
597 switch(p->frags) {
598 case 1:
599 if (buf[c] == 0x00 && buf[c + 1] == 0x01) {
600 check = 1;
601 c += 2;
602 }
603 break;
604 case 2:
605 if (buf[c] == 0x01) {
606 check = 1;
607 c++;
608 }
609 break;
610 case 3:
611 check = 1;
612 }
613 if (check) {
614 switch (buf[c]) {
615 case PROG_STREAM_MAP:
616 case PRIVATE_STREAM2:
617 case PROG_STREAM_DIR:
618 case ECM_STREAM :
619 case EMM_STREAM :
620 case PADDING_STREAM :
621 case DSM_CC_STREAM :
622 case ISO13522_STREAM:
623 case PRIVATE_STREAM1:
624 case AUDIO_STREAM_S ... AUDIO_STREAM_E:
625 case VIDEO_STREAM_S ... VIDEO_STREAM_E:
626 p->pes[0] = 0x00;
627 p->pes[1] = 0x00;
628 p->pes[2] = 0x01;
629 p->pes[3] = buf[c];
630 p->pos = 4;
631 memcpy(p->pes + p->pos, buf + c, (TS_SIZE - 4) - p->pos);
632 c += (TS_SIZE - 4) - p->pos;
633 p_to_t(p->pes, (TS_SIZE - 4), pid, &p->counter, p->feed);
634 clear_p2t(p);
635 break;
636
637 default:
638 c = 0;
639 break;
640 }
641 }
642 p->frags = 0;
643 }
644
645 if (p->pos) {
646 c2 = find_pes_header(buf + c, length - c, &p->frags);
647 if (c2 >= 0 && c2 < (TS_SIZE - 4) - p->pos)
648 l = c2+c;
649 else
650 l = (TS_SIZE - 4) - p->pos;
651 memcpy(p->pes + p->pos, buf, l);
652 c += l;
653 p->pos += l;
654 p_to_t(p->pes, p->pos, pid, &p->counter, p->feed);
655 clear_p2t(p);
656 }
657
658 add = 0;
659 while (c < length) {
660 c2 = find_pes_header(buf + c + add, length - c - add, &p->frags);
661 if (c2 >= 0) {
662 c2 += c + add;
663 if (c2 > c){
664 p_to_t(buf + c, c2 - c, pid, &p->counter, p->feed);
665 c = c2;
666 clear_p2t(p);
667 add = 0;
668 } else
669 add = 1;
670 } else {
671 l = length - c;
672 rest = l % (TS_SIZE - 4);
673 l -= rest;
674 p_to_t(buf + c, l, pid, &p->counter, p->feed);
675 memcpy(p->pes, buf + c + l, rest);
676 p->pos = rest;
677 c = length;
678 }
679 }
680 }
681
682
683 int write_ts_header2(u16 pid, u8 *counter, int pes_start, u8 *buf, u8 length)
684 {
685 int i;
686 int c = 0;
687 int fill;
688 u8 tshead[4] = { 0x47, 0x00, 0x00, 0x10 };
689
690 fill = (TS_SIZE - 4) - length;
691 if (pes_start)
692 tshead[1] = 0x40;
693 if (fill)
694 tshead[3] = 0x30;
695 tshead[1] |= (u8)((pid & 0x1F00) >> 8);
696 tshead[2] |= (u8)(pid & 0x00FF);
697 tshead[3] |= ((*counter)++ & 0x0F);
698 memcpy(buf, tshead, 4);
699 c += 4;
700
701 if (fill) {
702 buf[4] = fill - 1;
703 c++;
704 if (fill > 1) {
705 buf[5] = 0x00;
706 c++;
707 }
708 for (i = 6; i < fill + 4; i++) {
709 buf[i] = 0xFF;
710 c++;
711 }
712 }
713
714 return c;
715 }
716
717
718 static void p_to_t(u8 const *buf, long int length, u16 pid, u8 *counter,
719 struct dvb_demux_feed *feed)
720 {
721 int l, pes_start;
722 u8 obuf[TS_SIZE];
723 long c = 0;
724
725 pes_start = 0;
726 if (length > 3 &&
727 buf[0] == 0x00 && buf[1] == 0x00 && buf[2] == 0x01)
728 switch (buf[3]) {
729 case PROG_STREAM_MAP:
730 case PRIVATE_STREAM2:
731 case PROG_STREAM_DIR:
732 case ECM_STREAM :
733 case EMM_STREAM :
734 case PADDING_STREAM :
735 case DSM_CC_STREAM :
736 case ISO13522_STREAM:
737 case PRIVATE_STREAM1:
738 case AUDIO_STREAM_S ... AUDIO_STREAM_E:
739 case VIDEO_STREAM_S ... VIDEO_STREAM_E:
740 pes_start = 1;
741 break;
742
743 default:
744 break;
745 }
746
747 while (c < length) {
748 memset(obuf, 0, TS_SIZE);
749 if (length - c >= (TS_SIZE - 4)){
750 l = write_ts_header2(pid, counter, pes_start,
751 obuf, (TS_SIZE - 4));
752 memcpy(obuf + l, buf + c, TS_SIZE - l);
753 c += TS_SIZE - l;
754 } else {
755 l = write_ts_header2(pid, counter, pes_start,
756 obuf, length - c);
757 memcpy(obuf + l, buf + c, TS_SIZE - l);
758 c = length;
759 }
760 feed->cb.ts(obuf, 188, NULL, 0, &feed->feed.ts, DMX_OK);
761 pes_start = 0;
762 }
763 }
764
765
766 int av7110_write_to_decoder(struct dvb_demux_feed *feed, const u8 *buf, size_t len)
767 {
768 struct dvb_demux *demux = feed->demux;
769 struct av7110 *av7110 = (struct av7110 *) demux->priv;
770 struct ipack *ipack = &av7110->ipack[feed->pes_type];
771
772 DEB_EE(("av7110: %p\n", av7110));
773
774 switch (feed->pes_type) {
775 case 0:
776 if (av7110->audiostate.stream_source == AUDIO_SOURCE_MEMORY)
777 return -EINVAL;
778 break;
779 case 1:
780 if (av7110->videostate.stream_source == VIDEO_SOURCE_MEMORY)
781 return -EINVAL;
782 break;
783 default:
784 return -1;
785 }
786
787 if (!(buf[3] & 0x10)) /* no payload? */
788 return -1;
789 if (buf[1] & 0x40)
790 av7110_ipack_flush(ipack);
791
792 if (buf[3] & 0x20) { /* adaptation field? */
793 len -= buf[4] + 1;
794 buf += buf[4] + 1;
795 if (!len)
796 return 0;
797 }
798
799 av7110_ipack_instant_repack(buf + 4, len - 4, &av7110->ipack[feed->pes_type]);
800 return 0;
801 }
802
803
804
805 /******************************************************************************
806 * Video MPEG decoder events
807 ******************************************************************************/
808 void dvb_video_add_event(struct av7110 *av7110, struct video_event *event)
809 {
810 struct dvb_video_events *events = &av7110->video_events;
811 int wp;
812
813 DEB_D(("\n"));
814
815 spin_lock_bh(&events->lock);
816
817 wp = (events->eventw + 1) % MAX_VIDEO_EVENT;
818 if (wp == events->eventr) {
819 events->overflow = 1;
820 events->eventr = (events->eventr + 1) % MAX_VIDEO_EVENT;
821 }
822
823 //FIXME: timestamp?
824 memcpy(&events->events[events->eventw], event, sizeof(struct video_event));
825 events->eventw = wp;
826
827 spin_unlock_bh(&events->lock);
828
829 wake_up_interruptible(&events->wait_queue);
830 }
831
832
833 static int dvb_video_get_event (struct av7110 *av7110, struct video_event *event, int flags)
834 {
835 struct dvb_video_events *events = &av7110->video_events;
836
837 DEB_D(("\n"));
838
839 if (events->overflow) {
840 events->overflow = 0;
841 return -EOVERFLOW;
842 }
843 if (events->eventw == events->eventr) {
844 int ret;
845
846 if (flags & O_NONBLOCK)
847 return -EWOULDBLOCK;
848
849 ret = wait_event_interruptible(events->wait_queue,
850 events->eventw != events->eventr);
851 if (ret < 0)
852 return ret;
853 }
854
855 spin_lock_bh(&events->lock);
856
857 memcpy(event, &events->events[events->eventr],
858 sizeof(struct video_event));
859 events->eventr = (events->eventr + 1) % MAX_VIDEO_EVENT;
860
861 spin_unlock_bh(&events->lock);
862
863 return 0;
864 }
865
866
867 /******************************************************************************
868 * DVB device file operations
869 ******************************************************************************/
870
871 static unsigned int dvb_video_poll(struct file *file, poll_table *wait)
872 {
873 struct dvb_device *dvbdev = (struct dvb_device *) file->private_data;
874 struct av7110 *av7110 = (struct av7110 *) dvbdev->priv;
875 unsigned int mask = 0;
876
877 DEB_EE(("av7110: %p\n", av7110));
878
879 if ((file->f_flags & O_ACCMODE) != O_RDONLY)
880 poll_wait(file, &av7110->avout.queue, wait);
881
882 poll_wait(file, &av7110->video_events.wait_queue, wait);
883
884 if (av7110->video_events.eventw != av7110->video_events.eventr)
885 mask = POLLPRI;
886
887 if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
888 if (av7110->playing) {
889 if (FREE_COND)
890 mask |= (POLLOUT | POLLWRNORM);
891 } else /* if not playing: may play if asked for */
892 mask |= (POLLOUT | POLLWRNORM);
893 }
894
895 return mask;
896 }
897
898 static ssize_t dvb_video_write(struct file *file, const char __user *buf,
899 size_t count, loff_t *ppos)
900 {
901 struct dvb_device *dvbdev = (struct dvb_device *) file->private_data;
902 struct av7110 *av7110 = (struct av7110 *) dvbdev->priv;
903
904 DEB_EE(("av7110: %p\n", av7110));
905
906 if ((file->f_flags & O_ACCMODE) == O_RDONLY)
907 return -EPERM;
908
909 if (av7110->videostate.stream_source != VIDEO_SOURCE_MEMORY)
910 return -EPERM;
911
912 return dvb_play(av7110, buf, count, file->f_flags & O_NONBLOCK, 1);
913 }
914
915 static unsigned int dvb_audio_poll(struct file *file, poll_table *wait)
916 {
917 struct dvb_device *dvbdev = (struct dvb_device *) file->private_data;
918 struct av7110 *av7110 = (struct av7110 *) dvbdev->priv;
919 unsigned int mask = 0;
920
921 DEB_EE(("av7110: %p\n", av7110));
922
923 poll_wait(file, &av7110->aout.queue, wait);
924
925 if (av7110->playing) {
926 if (dvb_ringbuffer_free(&av7110->aout) >= 20 * 1024)
927 mask |= (POLLOUT | POLLWRNORM);
928 } else /* if not playing: may play if asked for */
929 mask = (POLLOUT | POLLWRNORM);
930
931 return mask;
932 }
933
934 static ssize_t dvb_audio_write(struct file *file, const char __user *buf,
935 size_t count, loff_t *ppos)
936 {
937 struct dvb_device *dvbdev = (struct dvb_device *) file->private_data;
938 struct av7110 *av7110 = (struct av7110 *) dvbdev->priv;
939
940 DEB_EE(("av7110: %p\n", av7110));
941
942 if (av7110->audiostate.stream_source != AUDIO_SOURCE_MEMORY) {
943 printk(KERN_ERR "not audio source memory\n");
944 return -EPERM;
945 }
946 return dvb_aplay(av7110, buf, count, file->f_flags & O_NONBLOCK, 0);
947 }
948
949 u8 iframe_header[] = { 0x00, 0x00, 0x01, 0xe0, 0x00, 0x00, 0x80, 0x00, 0x00 };
950
951 #define MIN_IFRAME 400000
952
953 static int play_iframe(struct av7110 *av7110, u8 __user *buf, unsigned int len, int nonblock)
954 {
955 int i, n;
956
957 DEB_EE(("av7110: %p\n", av7110));
958
959 if (!(av7110->playing & RP_VIDEO)) {
960 if (av7110_av_start_play(av7110, RP_VIDEO) < 0)
961 return -EBUSY;
962 }
963
964 /* setting n always > 1, fixes problems when playing stillframes
965 consisting of I- and P-Frames */
966 n = MIN_IFRAME / len + 1;
967
968 /* FIXME: nonblock? */
969 dvb_play_kernel(av7110, iframe_header, sizeof(iframe_header), 0, 1);
970
971 for (i = 0; i < n; i++)
972 dvb_play(av7110, buf, len, 0, 1);
973
974 av7110_ipack_flush(&av7110->ipack[1]);
975 return 0;
976 }
977
978
979 static int dvb_video_ioctl(struct inode *inode, struct file *file,
980 unsigned int cmd, void *parg)
981 {
982 struct dvb_device *dvbdev = (struct dvb_device *) file->private_data;
983 struct av7110 *av7110 = (struct av7110 *) dvbdev->priv;
984 unsigned long arg = (unsigned long) parg;
985 int ret = 0;
986
987 DEB_EE(("av7110: %p\n", av7110));
988
989 if ((file->f_flags & O_ACCMODE) == O_RDONLY) {
990 if ( cmd != VIDEO_GET_STATUS && cmd != VIDEO_GET_EVENT &&
991 cmd != VIDEO_GET_SIZE ) {
992 return -EPERM;
993 }
994 }
995
996 switch (cmd) {
997 case VIDEO_STOP:
998 av7110->videostate.play_state = VIDEO_STOPPED;
999 if (av7110->videostate.stream_source == VIDEO_SOURCE_MEMORY)
1000 av7110_av_stop(av7110, RP_VIDEO);
1001 else
1002 vidcom(av7110, VIDEO_CMD_STOP,
1003 av7110->videostate.video_blank ? 0 : 1);
1004 av7110->trickmode = TRICK_NONE;
1005 break;
1006
1007 case VIDEO_PLAY:
1008 av7110->trickmode = TRICK_NONE;
1009 if (av7110->videostate.play_state == VIDEO_FREEZED) {
1010 av7110->videostate.play_state = VIDEO_PLAYING;
1011 vidcom(av7110, VIDEO_CMD_PLAY, 0);
1012 }
1013
1014 if (av7110->videostate.stream_source == VIDEO_SOURCE_MEMORY) {
1015 if (av7110->playing == RP_AV) {
1016 av7110_fw_cmd(av7110, COMTYPE_REC_PLAY, __Stop, 0);
1017 av7110->playing &= ~RP_VIDEO;
1018 }
1019 av7110_av_start_play(av7110, RP_VIDEO);
1020 vidcom(av7110, VIDEO_CMD_PLAY, 0);
1021 } else {
1022 //av7110_av_stop(av7110, RP_VIDEO);
1023 vidcom(av7110, VIDEO_CMD_PLAY, 0);
1024 }
1025 av7110->videostate.play_state = VIDEO_PLAYING;
1026 break;
1027
1028 case VIDEO_FREEZE:
1029 av7110->videostate.play_state = VIDEO_FREEZED;
1030 if (av7110->playing & RP_VIDEO)
1031 av7110_fw_cmd(av7110, COMTYPE_REC_PLAY, __Pause, 0);
1032 else
1033 vidcom(av7110, VIDEO_CMD_FREEZE, 1);
1034 av7110->trickmode = TRICK_FREEZE;
1035 break;
1036
1037 case VIDEO_CONTINUE:
1038 if (av7110->playing & RP_VIDEO)
1039 av7110_fw_cmd(av7110, COMTYPE_REC_PLAY, __Continue, 0);
1040 vidcom(av7110, VIDEO_CMD_PLAY, 0);
1041 av7110->videostate.play_state = VIDEO_PLAYING;
1042 av7110->trickmode = TRICK_NONE;
1043 break;
1044
1045 case VIDEO_SELECT_SOURCE:
1046 av7110->videostate.stream_source = (video_stream_source_t) arg;
1047 break;
1048
1049 case VIDEO_SET_BLANK:
1050 av7110->videostate.video_blank = (int) arg;
1051 break;
1052
1053 case VIDEO_GET_STATUS:
1054 memcpy(parg, &av7110->videostate, sizeof(struct video_status));
1055 break;
1056
1057 case VIDEO_GET_EVENT:
1058 ret=dvb_video_get_event(av7110, parg, file->f_flags);
1059 break;
1060
1061 case VIDEO_GET_SIZE:
1062 memcpy(parg, &av7110->video_size, sizeof(video_size_t));
1063 break;
1064
1065 case VIDEO_SET_DISPLAY_FORMAT:
1066 {
1067 video_displayformat_t format = (video_displayformat_t) arg;
1068 u16 val = 0;
1069
1070 switch (format) {
1071 case VIDEO_PAN_SCAN:
1072 val = VID_PAN_SCAN_PREF;
1073 break;
1074
1075 case VIDEO_LETTER_BOX:
1076 val = VID_VC_AND_PS_PREF;
1077 break;
1078
1079 case VIDEO_CENTER_CUT_OUT:
1080 val = VID_CENTRE_CUT_PREF;
1081 break;
1082
1083 default:
1084 ret = -EINVAL;
1085 }
1086 if (ret < 0)
1087 break;
1088 av7110->videostate.video_format = format;
1089 ret = av7110_fw_cmd(av7110, COMTYPE_ENCODER, SetPanScanType,
1090 1, (u16) val);
1091 break;
1092 }
1093
1094 case VIDEO_SET_FORMAT:
1095 if (arg > 1) {
1096 ret = -EINVAL;
1097 break;
1098 }
1099 av7110->display_ar = arg;
1100 ret = av7110_fw_cmd(av7110, COMTYPE_ENCODER, SetMonitorType,
1101 1, (u16) arg);
1102 break;
1103
1104 case VIDEO_STILLPICTURE:
1105 {
1106 struct video_still_picture *pic =
1107 (struct video_still_picture *) parg;
1108 av7110->videostate.stream_source = VIDEO_SOURCE_MEMORY;
1109 dvb_ringbuffer_flush_spinlock_wakeup(&av7110->avout);
1110 ret = play_iframe(av7110, pic->iFrame, pic->size,
1111 file->f_flags & O_NONBLOCK);
1112 break;
1113 }
1114
1115 case VIDEO_FAST_FORWARD:
1116 //note: arg is ignored by firmware
1117 if (av7110->playing & RP_VIDEO)
1118 av7110_fw_cmd(av7110, COMTYPE_REC_PLAY,
1119 __Scan_I, 2, AV_PES, 0);
1120 else
1121 vidcom(av7110, VIDEO_CMD_FFWD, arg);
1122 av7110->trickmode = TRICK_FAST;
1123 av7110->videostate.play_state = VIDEO_PLAYING;
1124 break;
1125
1126 case VIDEO_SLOWMOTION:
1127 if (av7110->playing&RP_VIDEO) {
1128 av7110_fw_cmd(av7110, COMTYPE_REC_PLAY, __Slow, 2, 0, 0);
1129 vidcom(av7110, VIDEO_CMD_SLOW, arg);
1130 } else {
1131 vidcom(av7110, VIDEO_CMD_PLAY, 0);
1132 vidcom(av7110, VIDEO_CMD_STOP, 0);
1133 vidcom(av7110, VIDEO_CMD_SLOW, arg);
1134 }
1135 av7110->trickmode = TRICK_SLOW;
1136 av7110->videostate.play_state = VIDEO_PLAYING;
1137 break;
1138
1139 case VIDEO_GET_CAPABILITIES:
1140 *(int *)parg = VIDEO_CAP_MPEG1 | VIDEO_CAP_MPEG2 |
1141 VIDEO_CAP_SYS | VIDEO_CAP_PROG;
1142 break;
1143
1144 case VIDEO_CLEAR_BUFFER:
1145 dvb_ringbuffer_flush_spinlock_wakeup(&av7110->avout);
1146 av7110_ipack_reset(&av7110->ipack[1]);
1147
1148 if (av7110->playing == RP_AV) {
1149 av7110_fw_cmd(av7110, COMTYPE_REC_PLAY,
1150 __Play, 2, AV_PES, 0);
1151 if (av7110->trickmode == TRICK_FAST)
1152 av7110_fw_cmd(av7110, COMTYPE_REC_PLAY,
1153 __Scan_I, 2, AV_PES, 0);
1154 if (av7110->trickmode == TRICK_SLOW) {
1155 av7110_fw_cmd(av7110, COMTYPE_REC_PLAY,
1156 __Slow, 2, 0, 0);
1157 vidcom(av7110, VIDEO_CMD_SLOW, arg);
1158 }
1159 if (av7110->trickmode == TRICK_FREEZE)
1160 vidcom(av7110, VIDEO_CMD_STOP, 1);
1161 }
1162 break;
1163
1164 case VIDEO_SET_STREAMTYPE:
1165
1166 break;
1167
1168 default:
1169 ret = -ENOIOCTLCMD;
1170 break;
1171 }
1172 return ret;
1173 }
1174
1175 static int dvb_audio_ioctl(struct inode *inode, struct file *file,
1176 unsigned int cmd, void *parg)
1177 {
1178 struct dvb_device *dvbdev = (struct dvb_device *) file->private_data;
1179 struct av7110 *av7110 = (struct av7110 *) dvbdev->priv;
1180 unsigned long arg = (unsigned long) parg;
1181 int ret = 0;
1182
1183 DEB_EE(("av7110: %p\n", av7110));
1184
1185 if (((file->f_flags & O_ACCMODE) == O_RDONLY) &&
1186 (cmd != AUDIO_GET_STATUS))
1187 return -EPERM;
1188
1189 switch (cmd) {
1190 case AUDIO_STOP:
1191 if (av7110->audiostate.stream_source == AUDIO_SOURCE_MEMORY)
1192 av7110_av_stop(av7110, RP_AUDIO);
1193 else
1194 audcom(av7110, AUDIO_CMD_MUTE);
1195 av7110->audiostate.play_state = AUDIO_STOPPED;
1196 break;
1197
1198 case AUDIO_PLAY:
1199 if (av7110->audiostate.stream_source == AUDIO_SOURCE_MEMORY)
1200 av7110_av_start_play(av7110, RP_AUDIO);
1201 audcom(av7110, AUDIO_CMD_UNMUTE);
1202 av7110->audiostate.play_state = AUDIO_PLAYING;
1203 break;
1204
1205 case AUDIO_PAUSE:
1206 audcom(av7110, AUDIO_CMD_MUTE);
1207 av7110->audiostate.play_state = AUDIO_PAUSED;
1208 break;
1209
1210 case AUDIO_CONTINUE:
1211 if (av7110->audiostate.play_state == AUDIO_PAUSED) {
1212 av7110->audiostate.play_state = AUDIO_PLAYING;
1213 audcom(av7110, AUDIO_CMD_MUTE | AUDIO_CMD_PCM16);
1214 }
1215 break;
1216
1217 case AUDIO_SELECT_SOURCE:
1218 av7110->audiostate.stream_source = (audio_stream_source_t) arg;
1219 break;
1220
1221 case AUDIO_SET_MUTE:
1222 {
1223 audcom(av7110, arg ? AUDIO_CMD_MUTE : AUDIO_CMD_UNMUTE);
1224 av7110->audiostate.mute_state = (int) arg;
1225 break;
1226 }
1227
1228 case AUDIO_SET_AV_SYNC:
1229 av7110->audiostate.AV_sync_state = (int) arg;
1230 audcom(av7110, arg ? AUDIO_CMD_SYNC_ON : AUDIO_CMD_SYNC_OFF);
1231 break;
1232
1233 case AUDIO_SET_BYPASS_MODE:
1234 ret = -EINVAL;
1235 break;
1236
1237 case AUDIO_CHANNEL_SELECT:
1238 av7110->audiostate.channel_select = (audio_channel_select_t) arg;
1239
1240 switch(av7110->audiostate.channel_select) {
1241 case AUDIO_STEREO:
1242 audcom(av7110, AUDIO_CMD_STEREO);
1243 break;
1244
1245 case AUDIO_MONO_LEFT:
1246 audcom(av7110, AUDIO_CMD_MONO_L);
1247 break;
1248
1249 case AUDIO_MONO_RIGHT:
1250 audcom(av7110, AUDIO_CMD_MONO_R);
1251 break;
1252
1253 default:
1254 ret = -EINVAL;
1255 break;
1256 }
1257 break;
1258
1259 case AUDIO_GET_STATUS:
1260 memcpy(parg, &av7110->audiostate, sizeof(struct audio_status));
1261 break;
1262
1263 case AUDIO_GET_CAPABILITIES:
1264 *(int *)parg = AUDIO_CAP_LPCM | AUDIO_CAP_MP1 | AUDIO_CAP_MP2;
1265 break;
1266
1267 case AUDIO_CLEAR_BUFFER:
1268 dvb_ringbuffer_flush_spinlock_wakeup(&av7110->aout);
1269 av7110_ipack_reset(&av7110->ipack[0]);
1270 if (av7110->playing == RP_AV)
1271 av7110_fw_cmd(av7110, COMTYPE_REC_PLAY,
1272 __Play, 2, AV_PES, 0);
1273 break;
1274 case AUDIO_SET_ID:
1275
1276 break;
1277 case AUDIO_SET_MIXER:
1278 {
1279 struct audio_mixer *amix = (struct audio_mixer *)parg;
1280
1281 av7110_set_volume(av7110, amix->volume_left, amix->volume_right);
1282 break;
1283 }
1284 case AUDIO_SET_STREAMTYPE:
1285 break;
1286 default:
1287 ret = -ENOIOCTLCMD;
1288 }
1289 return ret;
1290 }
1291
1292
1293 static int dvb_video_open(struct inode *inode, struct file *file)
1294 {
1295 struct dvb_device *dvbdev = (struct dvb_device *) file->private_data;
1296 struct av7110 *av7110 = (struct av7110 *) dvbdev->priv;
1297 int err;
1298
1299 DEB_EE(("av7110: %p\n", av7110));
1300
1301 if ((err = dvb_generic_open(inode, file)) < 0)
1302 return err;
1303
1304 if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
1305 dvb_ringbuffer_flush_spinlock_wakeup(&av7110->aout);
1306 dvb_ringbuffer_flush_spinlock_wakeup(&av7110->avout);
1307 av7110->video_blank = 1;
1308 av7110->audiostate.AV_sync_state = 1;
1309 av7110->videostate.stream_source = VIDEO_SOURCE_DEMUX;
1310
1311 /* empty event queue */
1312 av7110->video_events.eventr = av7110->video_events.eventw = 0;
1313 }
1314
1315 return 0;
1316 }
1317
1318 static int dvb_video_release(struct inode *inode, struct file *file)
1319 {
1320 struct dvb_device *dvbdev = (struct dvb_device *) file->private_data;
1321 struct av7110 *av7110 = (struct av7110 *) dvbdev->priv;
1322
1323 DEB_EE(("av7110: %p\n", av7110));
1324
1325 if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
1326 av7110_av_stop(av7110, RP_VIDEO);
1327 }
1328
1329 return dvb_generic_release(inode, file);
1330 }
1331
1332 static int dvb_audio_open(struct inode *inode, struct file *file)
1333 {
1334 struct dvb_device *dvbdev = (struct dvb_device *) file->private_data;
1335 struct av7110 *av7110 = (struct av7110 *) dvbdev->priv;
1336 int err=dvb_generic_open(inode, file);
1337
1338 DEB_EE(("av7110: %p\n", av7110));
1339
1340 if (err < 0)
1341 return err;
1342 dvb_ringbuffer_flush_spinlock_wakeup(&av7110->aout);
1343 av7110->audiostate.stream_source = AUDIO_SOURCE_DEMUX;
1344 return 0;
1345 }
1346
1347 static int dvb_audio_release(struct inode *inode, struct file *file)
1348 {
1349 struct dvb_device *dvbdev = (struct dvb_device *) file->private_data;
1350 struct av7110 *av7110 = (struct av7110 *) dvbdev->priv;
1351
1352 DEB_EE(("av7110: %p\n", av7110));
1353
1354 av7110_av_stop(av7110, RP_AUDIO);
1355 return dvb_generic_release(inode, file);
1356 }
1357
1358
1359
1360 /******************************************************************************
1361 * driver registration
1362 ******************************************************************************/
1363
1364 static struct file_operations dvb_video_fops = {
1365 .owner = THIS_MODULE,
1366 .write = dvb_video_write,
1367 .ioctl = dvb_generic_ioctl,
1368 .open = dvb_video_open,
1369 .release = dvb_video_release,
1370 .poll = dvb_video_poll,
1371 };
1372
1373 static struct dvb_device dvbdev_video = {
1374 .priv = NULL,
1375 .users = 6,
1376 .readers = 5, /* arbitrary */
1377 .writers = 1,
1378 .fops = &dvb_video_fops,
1379 .kernel_ioctl = dvb_video_ioctl,
1380 };
1381
1382 static struct file_operations dvb_audio_fops = {
1383 .owner = THIS_MODULE,
1384 .write = dvb_audio_write,
1385 .ioctl = dvb_generic_ioctl,
1386 .open = dvb_audio_open,
1387 .release = dvb_audio_release,
1388 .poll = dvb_audio_poll,
1389 };
1390
1391 static struct dvb_device dvbdev_audio = {
1392 .priv = NULL,
1393 .users = 1,
1394 .writers = 1,
1395 .fops = &dvb_audio_fops,
1396 .kernel_ioctl = dvb_audio_ioctl,
1397 };
1398
1399
1400 int av7110_av_register(struct av7110 *av7110)
1401 {
1402 av7110->audiostate.AV_sync_state = 0;
1403 av7110->audiostate.mute_state = 0;
1404 av7110->audiostate.play_state = AUDIO_STOPPED;
1405 av7110->audiostate.stream_source = AUDIO_SOURCE_DEMUX;
1406 av7110->audiostate.channel_select = AUDIO_STEREO;
1407 av7110->audiostate.bypass_mode = 0;
1408
1409 av7110->videostate.video_blank = 0;
1410 av7110->videostate.play_state = VIDEO_STOPPED;
1411 av7110->videostate.stream_source = VIDEO_SOURCE_DEMUX;
1412 av7110->videostate.video_format = VIDEO_FORMAT_4_3;
1413 av7110->videostate.display_format = VIDEO_CENTER_CUT_OUT;
1414 av7110->display_ar = VIDEO_FORMAT_4_3;
1415
1416 init_waitqueue_head(&av7110->video_events.wait_queue);
1417 spin_lock_init(&av7110->video_events.lock);
1418 av7110->video_events.eventw = av7110->video_events.eventr = 0;
1419 av7110->video_events.overflow = 0;
1420 memset(&av7110->video_size, 0, sizeof (video_size_t));
1421
1422 dvb_register_device(av7110->dvb_adapter, &av7110->video_dev,
1423 &dvbdev_video, av7110, DVB_DEVICE_VIDEO);
1424
1425 dvb_register_device(av7110->dvb_adapter, &av7110->audio_dev,
1426 &dvbdev_audio, av7110, DVB_DEVICE_AUDIO);
1427
1428 return 0;
1429 }
1430
1431 void av7110_av_unregister(struct av7110 *av7110)
1432 {
1433 dvb_unregister_device(av7110->audio_dev);
1434 dvb_unregister_device(av7110->video_dev);
1435 }
1436
1437 int av7110_av_init(struct av7110 *av7110)
1438 {
1439 av7110->vidmode = VIDEO_MODE_PAL;
1440
1441 av7110_ipack_init(&av7110->ipack[0], IPACKS, play_audio_cb);
1442 av7110->ipack[0].data = (void *) av7110;
1443 av7110_ipack_init(&av7110->ipack[1], IPACKS, play_video_cb);
1444 av7110->ipack[1].data = (void *) av7110;
1445
1446 dvb_ringbuffer_init(&av7110->avout, av7110->iobuf, AVOUTLEN);
1447 dvb_ringbuffer_init(&av7110->aout, av7110->iobuf + AVOUTLEN, AOUTLEN);
1448
1449 av7110->kbuf[0] = (u8 *)(av7110->iobuf + AVOUTLEN + AOUTLEN + BMPLEN);
1450 av7110->kbuf[1] = av7110->kbuf[0] + 2 * IPACKS;
1451
1452 return 0;
1453 }
1454
1455 int av7110_av_exit(struct av7110 *av7110)
1456 {
1457 av7110_ipack_free(&av7110->ipack[0]);
1458 av7110_ipack_free(&av7110->ipack[1]);
1459 return 0;
1460 }
Historical 2.5/2.6 development