![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cvdv.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [DVB] / margi2|
Return to cvdv.c CVS log | Up to [DVB] / margi2 |
1.1 cvs 1: /*
2: cvdv.c
3:
1.13 mocm 4: Copyright (C) Christian Wolff
5: Marcus Metzler for convergence integrated media.
1.1 cvs 6:
7: This program is free software; you can redistribute it and/or modify
8: it under the terms of the GNU General Public License as published by
9: the Free Software Foundation; either version 2 of the License, or
10: (at your option) any later version.
11:
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.
16:
17: You should have received a copy of the GNU General Public License
18: along with this program; if not, write to the Free Software
19: Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20: */
21:
22: /////////////////////////////////////////////////////////////////////
23: // //
24: // Driver for the Convergence Digital Video decoder card (pci) //
25: // with L64017, L64021, PCM1723, and Bt864/Bt865 chipset //
26: // (c) Christian Wolff 19990209 for convergence integrated media //
27: // //
28: /////////////////////////////////////////////////////////////////////
29:
30: // Convergence CV2300i
31: #define __NO_VERSION__
32:
33: #include "cvdv.h"
34: #include "i2c.h"
35:
36: //////////////////////
37: // global variables //
38: //////////////////////
39:
40: // Our major device number
41: unsigned int major_device_number;
42:
43:
44: // my little random function for memory test
1.12 mocm 45: uint16_t rnd_seed;
46: uint16_t rnd(uint16_t range)
1.1 cvs 47: { // returns random 0..(range-1) range<=872
1.12 mocm 48: uint32_t b = 75 * (rnd_seed + 1) - 1;
49: rnd_seed = (uint16_t) (b & 0xFFFF);
1.1 cvs 50: return ((b * range) / 0xFFFF) - ((b / 0xFFFF) * range);
51: }
52: void rnd_omize(void)
53: {
1.12 mocm 54: rnd_seed = (uint16_t) jiffies;
1.1 cvs 55: }
56:
1.5 mocm 57: static char *cimlogo[] = {
58: ".............................................",
59: ".............................................",
60: "......................###....................",
61: ".....................#####...................",
62: ".....................######..................",
63: "..............#......#####...................",
64: "...........#####....######...................",
65: ".........########...######...................",
66: "........########....######...................",
67: ".......#########...######....................",
68: "......########.....######...####.............",
69: ".....#######.......#####...#####.............",
70: ".....######.......######...######............",
71: "....#######.......######....######...........",
72: "....######........######....######...........",
73: "....#####........######......#####...........",
74: "...######........######......#####...........",
75: "...#####.........######......######..........",
76: "...#####.........#####.......######..........",
77: "...#####........######........#####..........",
78: "...#####........######.......######..........",
79: "...#####........#####.........#####..........",
80: "...#####.......######........######..........",
81: "...#####.......######........#####...........",
82: "...######.......####.........#####...........",
83: "....#####........##.........######...........",
84: "....######..................######...........",
85: "....######.................######............",
86: ".....#######..............######.....#####...",
87: ".....########............#######....#######..",
88: "......#########........########.....#######..",
89: ".......#######################......########.",
90: "........#####################.......#######..",
91: "..........#################.........#######..",
92: "............#############............#####...",
93: "...............#.#####.................##....",
94: ".............................................",
95: "............................................."
96: };
1.1 cvs 97:
98: /////////////////////////////////////////////
99: // //
100: // Controlling the L64021 MPEG-2 Decoder //
101: // //
102: /////////////////////////////////////////////
103:
104: int OSDTest(struct cvdv_cards *card)
105: {
1.5 mocm 106: int i, j, col, x0, y0, x1, y1,aspx;
1.12 mocm 107: uint8_t b;
1.5 mocm 108:
1.1 cvs 109:
110: if (!card->OSD.open)
111: return -2;
112:
113: OSDQuery(card, &x0, &y0, &x1, &y1, &aspx);
114: OSDShow(card);
1.5 mocm 115: OSDSetColor(card, 0, 0, 0, 0, 0, 0, 0);
116: OSDSetColor(card, 1, 128, 255, 255, 0, 0, 0);
117: for ( i = 0; i < cimlogo_width; i++){
118: for ( j = 0; j < cimlogo_height; j++){
119: b = cimlogo[j][i];
120: col = (b == '#') ? 1: 0;
121: OSDSetPixel(card, x0+i, y0+j, col);
1.1 cvs 122: }
123: }
124:
125: return 0;
126: }
127:
128:
129: void SetVideoSystem(struct cvdv_cards *card)
130: {
131: // set the hsync and vsync generators in the L64017 according to the video standard
132: switch (card->videomode) {
133: case PAL: // 864*625*50Hz = 27MHz, 25fps
134: I2CWrite(card, card->i2c_addr, CS_CONTROL0, 0x41 | 0x0a);
135: I2CWrite(card, card->i2c_addr, CS_CONTROL1, 0x04);
136: I2CWrite(card, card->i2c_addr, CS_SC_AMP, 0x15);
137: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH0, 0x96);
138: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH1, 0x15);
139: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH2, 0x13);
140: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH3, 0x54);
141: write_indexed_register(card, IIO_VIDEO_CONTROL1, VMS_PAL);
142: break;
143: case PALN:
144: I2CWrite(card, card->i2c_addr, CS_CONTROL0, 0xa1 | 0x0a);
145: I2CWrite(card, card->i2c_addr, CS_CONTROL1, 0x04);
146: I2CWrite(card, card->i2c_addr, CS_SC_AMP, 0x15);
147: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH0, 0x96);
148: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH1, 0x15);
149: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH2, 0x13);
150: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH3, 0x54);
151: write_indexed_register(card, IIO_VIDEO_CONTROL1, VMS_PAL);
152: break;
153:
154: case PALNc:
155: I2CWrite(card, card->i2c_addr, CS_CONTROL0, 0x81 | 0x0a);
156: I2CWrite(card, card->i2c_addr, CS_CONTROL1, 0x04);
157: I2CWrite(card, card->i2c_addr, CS_SC_AMP, 0x15);
158: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH0, 0x8c);
159: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH1, 0x28);
160: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH2, 0xed);
161: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH3, 0x43);
162: write_indexed_register(card, IIO_VIDEO_CONTROL1, VMS_PAL);
163:
164: break;
165:
166: case NTSC: // 858*525*59.94006Hz = 27MHz, 29.97fps
167: I2CWrite(card, card->i2c_addr, CS_CONTROL0, 0x01 | 0x0a);
168: I2CWrite(card, card->i2c_addr, CS_CONTROL1, 0x04);
169: I2CWrite(card, card->i2c_addr, CS_SC_AMP, 0x1c);
170: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH0, 0x3e);
171: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH1, 0xf8);
172: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH2, 0xe0);
173: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH3, 0x43);
174: write_indexed_register(card, IIO_VIDEO_CONTROL1, VMS_NTSC);
175:
176: break;
177:
178: case PALM:
179: I2CWrite(card, card->i2c_addr, CS_CONTROL0, 0x01 | 0x0a);
180: I2CWrite(card, card->i2c_addr, CS_CONTROL1, 0x04);
181: I2CWrite(card, card->i2c_addr, CS_SC_AMP, 0x15);
182: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH0, 0x4e);
183: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH1, 0x4a);
184: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH2, 0xe1);
185: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH3, 0x43);
186: write_indexed_register(card, IIO_VIDEO_CONTROL1, VMS_PAL);
187:
188: break;
189:
190: case NTSC60: // 857*525*60.010002Hz = 27MHz, 30fps
191: I2CWrite(card, card->i2c_addr, CS_CONTROL0, 0x21 | 0x0a);
192: I2CWrite(card, card->i2c_addr, CS_CONTROL1, 0x04);
193: I2CWrite(card, card->i2c_addr, CS_SC_AMP, 0x1c);
194: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH0, 0x3e);
195: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH1, 0xf8);
196: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH2, 0xe0);
197: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH3, 0x43);
198: write_indexed_register(card, IIO_VIDEO_CONTROL1, VMS_NTSC);
199: break;
200:
201: case PALM60:
202: I2CWrite(card, card->i2c_addr, CS_CONTROL0, 0x61 | 0x0a);
203: I2CWrite(card, card->i2c_addr, CS_CONTROL1, 0x04);
204: I2CWrite(card, card->i2c_addr, CS_SC_AMP, 0x15);
205: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH0, 0x4e);
206: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH1, 0x4a);
207: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH2, 0xe1);
208: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH3, 0x43);
209: write_indexed_register(card, IIO_VIDEO_CONTROL1, VMS_PAL);
210:
211: break;
212:
213: case PAL60:
214: break;
215: }
216: // set the pixel generators according to the video standard
217: L64021Setup(card);
218: }
219:
1.12 mocm 220: int SetVideoAttr(struct cvdv_cards *card, uint16_t vattr)
1.1 cvs 221: {
1.12 mocm 222: uint8_t video_compression_mode;
223: uint8_t tv_system;
224: uint8_t aspect_ratio;
225: uint8_t display_mode;
226: uint8_t line_21_switch_1;
227: uint8_t line_21_switch_2;
228: uint8_t source_picture_resolution;
229: uint8_t source_picture_letterboxed;
230: uint8_t reserved;
231: uint8_t film_camera_mode;
232: uint16_t hsize, vsize;
1.1 cvs 233: if (vattr != card->lastvattr) {
234: video_compression_mode = (vattr >> 14) & 0x03;
235: tv_system = (vattr >> 12) & 0x03;
236: aspect_ratio = (vattr >> 10) & 0x03;
237: display_mode = (vattr >> 8) & 0x03;
238: line_21_switch_1 = (vattr >> 7) & 0x01;
239: line_21_switch_2 = (vattr >> 6) & 0x01;
240: source_picture_resolution = (vattr >> 3) & 0x07;
241: source_picture_letterboxed = (vattr >> 2) & 0x01;
242: reserved = (vattr >> 1) & 0x01;
243: film_camera_mode = (vattr >> 0) & 0x01;
244: card->videomode =
245: ((tv_system == 0) ? NTSC : ((tv_system == 1) ?
246: PAL : PAL));
247: SetVideoSystem(card);
248: hsize =
249: ((source_picture_resolution == 0) ? 720
250: : ((source_picture_resolution == 1) ? 702 : 352));
251: vsize = ((source_picture_resolution == 3)
252: ? ((tv_system == 0) ? 240 : 288)
253: : ((tv_system == 0) ? 480 : 576));
254: if (DecoderOpen
255: (card, hsize, vsize, ((aspect_ratio) ? 3 : 2),
256: ((video_compression_mode) ? 0 : 1),
257: source_picture_letterboxed, tv_system)) {
1.14 mocm 258: MDEBUG(0,
1.1 cvs 259: ": Video Decoder Open failed: On-card memory insufficient for frame stores\n");
260: }
261: card->lastvattr = vattr;
262: } else {
1.14 mocm 263: MDEBUG(0,
1.1 cvs 264: ": Video attribute not set, equal to previous one.\n");
265: }
266: return 0;
267: }
268:
1.12 mocm 269: int SetAudioAttr(struct cvdv_cards *card, uint16_t aattr)
1.1 cvs 270: {
1.12 mocm 271: uint8_t audio_coding_mode;
272: uint8_t multichannel_extension;
273: uint8_t audio_type;
274: uint8_t audio_application_mode;
275: uint8_t quantization_drc;
276: uint8_t fs;
277: uint8_t reserved;
278: uint8_t num_audio_ch;
1.1 cvs 279: if (aattr) {
280: if (aattr != card->lastaattr) {
281: audio_coding_mode = (aattr >> 13) & 0x07;
282: multichannel_extension = (aattr >> 12) & 0x01;
283: audio_type = (aattr >> 10) & 0x03;
284: audio_application_mode = (aattr >> 8) & 0x03;
285: quantization_drc = (aattr >> 6) & 0x03;
286: fs = (aattr >> 4) & 0x03;
287: reserved = (aattr >> 3) & 0x01;
288: num_audio_ch = (aattr >> 0) & 0x07;
289: switch (audio_coding_mode) {
290: case 0: // AC-3
291: card->setup.audioselect = audio_AC3;
292: break;
293: case 2: // MPEG Audio
294: card->setup.audioselect = audio_MPEG;
295: break;
296: case 3: // MPEG Audio with ext.
297: card->setup.audioselect = audio_MPEG_EXT;
298: break;
299: case 4: // Linear Pulse Code Modulation LPCM
300: card->setup.audioselect = audio_LPCM;
301: break;
302: case 6: // DTS
303: card->setup.audioselect = audio_DTS;
304: break;
305: case 7: // SDDS
306: card->setup.audioselect = audio_SDDS;
307: break;
308: }
309: DecoderPrepareAudio(card);
310: AudioInit(card, ((fs) ? 96 : 48),
311: ((audio_application_mode == 2) ? 1 : 0));
312: } else {
1.14 mocm 313: MDEBUG(0,
1.1 cvs 314: ": Audio attribute not set, equal to previous one.\n");
315: }
316: } else {
317: card->setup.audioselect = audio_none;
318: DecoderPrepareAudio(card);
319: }
320: card->lastaattr = aattr;
321: return 0;
322: }
323:
324: int Prepare(struct cvdv_cards *card)
325: {
326: int err, h;
327: struct StreamSetup *setup = &card->setup;
328:
329: if (!card->ChannelBuffersAllocated) {
330:
331: DecoderStreamReset(card);
332: if (setup->streamtype == stream_none) {
333: setup->streamtype = stream_PS;
334: }
335:
336: if (setup->audioselect == audio_none) {
337: setup->audioselect = audio_MPEG;
338: }
339:
340: DecoderPrepareAudio(card);
341: AudioMute(card, 1);
342: DecoderPrepareVideo(card);
343: VideoSetBackground(card, 1, 0, 0, 0); // black
344:
345: switch (setup->streamtype) {
346: default:
347: case stream_none: // unknown stream!
1.14 mocm 348: MDEBUG(0,
1.1 cvs 349: ": Video Decoder Prepare failed: unknown stream type\n");
350: return -ENODEV; // not an MPEG stream!
351: case stream_ES: // Elementary Stream
352: err = DecoderPrepareES(card);
353: break;
354: case stream_PES: // Packetized Elementary Stream
355: err = DecoderPreparePES(card);
356: break;
357: case stream_PS: // MPEG-1 System Stream / MPEG-2 Program Stream
358: err = DecoderPreparePS(card, -1, 0, 0, 0, 0, 0);
359: break;
360: case stream_DVD: // DVD Stream
361: err = DecoderPreparePS(card, 0, 0, 0, 0, 3, 1);
362: break;
363: }
364: if (err) { // insufficient memory
1.14 mocm 365: MDEBUG(0,
1.1 cvs 366: ": Video Decoder Prepare failed: no kernel memory, please reboot if possible\n");
367: CloseCard(card);
368: return -ENODEV;
369: }
370: }
371:
372: // Set up the Video Decoder as we have the stream information
373: if ((!card->FrameBuffersAllocated)
374: && (card->ChannelBuffersAllocated) && (card->stream.sh.valid)) {
375: // Automatic PAL/NTSC-switch according to MPEG-Source
376: h = card->stream.vsize;
377: if (h < 480)
378: h *= 2; // catch quarter sized images
379: printk(KERN_INFO LOGNAME ": Video mode: %s\n",
380: ((h == 480) ? "NTSC" : "PAL"));
381: card->videomode = ((h == 480) ? NTSC : PAL);
382: SetVideoSystem(card);
383: // Open the Video Decoder with the parameters retreived from the stream
384: if (
385: (err =
386: DecoderOpen(card, card->stream.hsize,
387: card->stream.vsize,
388: card->stream.sh.aspectratio,
389: !card->stream.MPEG2, 0,
1.2 rjkm 390: (card->stream.hsize > 480)))) { // TODO: include vbvbuffersize
1.14 mocm 391: MDEBUG(0,
1.1 cvs 392: ": Video Decoder Open failed: %s\n",
393: ((err == 1) ?
394: "Picture size too big (>1440 pixel wide)" :
395: "On-card memory insufficient for frame stores"));
396: CloseCard(card);
397: return -ENODEV; // picture too big or insufficient memory
398: }
1.14 mocm 399: MDEBUG(1, ": Ready to go\n");
1.1 cvs 400: card->startingV = 1; // tell the card to start playing as soon as ES-buffers are sufficiently full
401: card->startingA = 1; // tell the card to start playing as soon as ES-buffers are sufficiently full
402: }
403:
404:
405: return 0;
406: }
407:
1.12 mocm 408: int SetSCRstart(struct cvdv_cards *card, uint32_t SCR_base)
1.1 cvs 409: {
1.12 mocm 410: uint32_t SCR_compare;
411: uint32_t SCR_compareA;
412: uint32_t SCR_compareV;
1.1 cvs 413: if (card->startingV) {
1.14 mocm 414: MDEBUG(0, ": SCR in DVD Pack: 0x%08X\n",
1.1 cvs 415: SCR_base);
416: card->startingV = 0;
417: card->startingA = 0;
418: DecoderMaskByte(card, 0x007, 0xD2, 0xD2); // Set 0x010, halt SCR counter
419: SCR_compare = SCR_base + 000;
420: if (SCR_base < 900)
421: SCR_base = 0;
422: else
423: SCR_base -= 900;
424: //DecoderWriteDWord(card,0x009,SCR_base); // Set SCR counter
425: DecoderWriteByte(card, 0x009, SCR_base & 0xFF); // Set SCR counter
426: DecoderWriteByte(card, 0x00A, (SCR_base >> 8) & 0xFF);
427: DecoderWriteByte(card, 0x00B, (SCR_base >> 16) & 0xFF);
428: DecoderWriteByte(card, 0x00C, (SCR_base >> 24) & 0xFF);
429: DecoderMaskByte(card, 0x011, 0x03, 0x02); // compare, not capture
1.14 mocm 430: MDEBUG(0, ": SCR compare value: 0x%08X\n",
1.1 cvs 431: SCR_compare);
432: //DecoderWriteDWord(card,0x00D,SCR_compare); // Set Compare register
433: DecoderWriteByte(card, 0x00D, SCR_compare & 0xFF); // Set Compare register
434: DecoderWriteByte(card, 0x00E, (SCR_compare >> 8) & 0xFF);
435: DecoderWriteByte(card, 0x00F, (SCR_compare >> 16) & 0xFF);
436: DecoderWriteByte(card, 0x010, (SCR_compare >> 24) & 0xFF);
437: //DecoderWriteDWord(card,0x014,SCR_compare); // Set audio compare reg.
438: DecoderWriteByte(card, 0x014, SCR_compare & 0xFF); // Set audio compare reg.
439: DecoderWriteByte(card, 0x015, (SCR_compare >> 8) & 0xFF);
440: DecoderWriteByte(card, 0x016, (SCR_compare >> 16) & 0xFF);
441: DecoderWriteByte(card, 0x017, (SCR_compare >> 24) & 0xFF);
442: DecoderSetByte(card, 0x013, 0x03); // Video and Audio start on cmp.
443: //DecoderSetVideoPanic(card,0,DecoderGetVideoESSize(card)/4); // video panic at 25 percent
444: VideoSetBackground(card, 1, 0, 0, 0); // black
445: SCR_base = DecoderReadByte(card, 0x009);
446: SCR_base =
1.12 mocm 447: SCR_base | ((uint32_t) DecoderReadByte(card, 0x00A) << 8);
1.1 cvs 448: SCR_base =
1.12 mocm 449: SCR_base | ((uint32_t) DecoderReadByte(card, 0x00B) << 16);
1.1 cvs 450: SCR_base =
1.12 mocm 451: SCR_base | ((uint32_t) DecoderReadByte(card, 0x00C) << 24);
1.1 cvs 452: SCR_compareA = DecoderReadByte(card, 0x014);
453: SCR_compareA =
1.12 mocm 454: SCR_compareA | ((uint32_t) DecoderReadByte(card, 0x015) <<
1.1 cvs 455: 8);
456: SCR_compareA =
1.12 mocm 457: SCR_compareA | ((uint32_t) DecoderReadByte(card, 0x016) <<
1.1 cvs 458: 16);
459: SCR_compareA =
1.12 mocm 460: SCR_compareA | ((uint32_t) DecoderReadByte(card, 0x017) <<
1.1 cvs 461: 24);
462: SCR_compareV = DecoderReadByte(card, 0x00D);
463: SCR_compareV =
1.12 mocm 464: SCR_compareV | ((uint32_t) DecoderReadByte(card, 0x00E) <<
1.1 cvs 465: 8);
466: SCR_compareV =
1.12 mocm 467: SCR_compareV | ((uint32_t) DecoderReadByte(card, 0x00F) <<
1.1 cvs 468: 16);
469: SCR_compareV =
1.12 mocm 470: SCR_compareV | ((uint32_t) DecoderReadByte(card, 0x010) <<
1.1 cvs 471: 24);
472: if (DecoderReadByte(card, 0x013) & 0x03)
1.14 mocm 473: MDEBUG(1,": SCR 0x%08X, videocmp=0x%08X, audiocmp=0x%08X %02X\n",
1.1 cvs 474: SCR_base, SCR_compareV, SCR_compareA,
475: DecoderReadByte(card, 0x013));
476: DecoderMaskByte(card, 0x007, 0xD2, 0xC2); // Del 0x010, SCR counter run
477: }
478: return 0;
479: }
480:
1.12 mocm 481: int DecoderWriteBlock(struct cvdv_cards *card, uint8_t * data, int size,
1.1 cvs 482: int initial, int setSCR)
483: {
484: //int a,v,as,vs,ap,vp;
485: int res;
1.12 mocm 486: uint32_t SCR_base;
1.1 cvs 487: int co = 0;
1.12 mocm 488: // uint32_t SCR_compare;
1.1 cvs 489: res = 0;
1.6 mocm 490:
491: Prepare(card);
1.1 cvs 492:
493: if (size > 0) {
494:
1.14 mocm 495: if (!card->use_ringA)
1.17 mocm 496: MargiSetBuffers(card, NBBUF*CHANNELBUFFERSIZE,0);
1.1 cvs 497:
498: if (card->startingDVDV || card->startingDVDA)
499: setSCR = 1;
500:
501: if (initial) {
502: DecoderStreamReset(card);
503: //TODO stop and start channel interface
504: setSCR = 1;
505: }
506:
507: if (setSCR) {
508: SCR_base = ParseSCR(data);
509: SetSCR(card, SCR_base);
510: }
1.6 mocm 511: card->DMAABusy = 0;
1.14 mocm 512: while (((res = MargiPushA(card, size, data)) < size)
1.6 mocm 513: && co < 1000) {
1.1 cvs 514: data+=res;
515: size-=res;
516: co++;
1.14 mocm 517: MDEBUG(2,
518: ": DecoderWriteBlock - buffers only filled with %d instead of %d bytes\n",res, size);
1.10 mocm 519: if (card->DMAABusy){
1.1 cvs 520: interruptible_sleep_on(&card->wqA);
1.10 mocm 521: }
1.1 cvs 522: }
523:
524: if (card->startingDVDV) {
525: card->startingDVDV = 0;
1.6 mocm 526: card->startingV = 1;
1.1 cvs 527: DecoderStartDecode(card);
528: }
529: if (card->startingDVDA) {
530: card->startingDVDA = 0;
1.6 mocm 531: card->startingA = 1;
532: AudioSetPlayMode(card, MAUDIO_PLAY);
1.1 cvs 533: }
534: }
535: return 0;
536: }
537:
538:
539:
540:
541:
542: //////////////////////////////
543: // //
544: // Char Device Procedures //
545: // //
546: //////////////////////////////
1.11 mocm 547: static long margi_write(struct cvdv_cards *card, const char *data,
1.6 mocm 548: unsigned long count, int nonblock)
1.1 cvs 549: {
1.11 mocm 550:
1.1 cvs 551: int res;
1.10 mocm 552: long int out=0;
1.17 mocm 553: int free;
554:
555: free = ring_write_rest(&(card->rbufA));
1.10 mocm 556:
557: card->nonblock = nonblock;
1.1 cvs 558:
559: if (card != NULL) {
560: if (count > 0) { // Do we have data?
561: if ((res = Prepare(card)))
562: return res;
1.17 mocm 563: if (!card->use_ringA)
564: MargiSetBuffers(card, NBBUF*CHANNELBUFFERSIZE,
565: 0);
566: if (!nonblock &&
567: !wait_event_interruptible(card->wqA,
568: free >count )){
569: out = MargiPushA(card, count,
570: data);
571: } else {
572: out = MargiPushA(card, count, data);
1.14 mocm 573: }
574: }
575: return out;
576: } else {
577: MDEBUG(0,
578: ": Video Decoder Prepare failed: device with this minor number not found\n");
579: return -ENODEV; // device with this minor number not found
580: }
581: }
582:
1.17 mocm 583:
1.14 mocm 584: static long margi_write_audio(struct cvdv_cards *card, const char *data,
585: unsigned long count, int nonblock)
586: {
587: struct StreamSetup *setup = &card->setup;
1.1 cvs 588:
1.14 mocm 589: int res;
590: long int out=0;
1.17 mocm 591: int free;
592:
593: free = ring_write_rest(&(card->rbufB));
1.1 cvs 594:
1.14 mocm 595: card->nonblock = nonblock;
1.1 cvs 596:
1.14 mocm 597: if (card != NULL) {
598: if (count > 0) { // Do we have data?
599: if ((res = Prepare(card)))
600: return res;
601: if ((setup->streamtype == stream_ES)
1.17 mocm 602: || (setup->streamtype == stream_PES)){
1.14 mocm 603: if (!card->use_ringB)
1.17 mocm 604: MargiSetBuffers(card, NBBUF*
605: CHANNELBUFFERSIZE,1);
606: if (!nonblock &&
607: !wait_event_interruptible(card->wqB,
608: free >count )){
609: out = MargiPushB(card, count,
610: data);
611: } else {
1.14 mocm 612: out = MargiPushB(card, count, data);
613: }
1.1 cvs 614: }
615: }
1.10 mocm 616: return out;
1.1 cvs 617: } else {
1.14 mocm 618: MDEBUG(0,
1.1 cvs 619: ": Video Decoder Prepare failed: device with this minor number not found\n");
620: return -ENODEV; // device with this minor number not found
621: }
1.6 mocm 622: }
623:
1.12 mocm 624: void pes_write(uint8_t *buf, int count, void *priv)
625: {
626: struct cvdv_cards *card = (struct cvdv_cards *) priv;
1.14 mocm 627:
628: margi_write(card, buf, count, 0);
1.12 mocm 629: }
630:
1.6 mocm 631:
632: static ssize_t PSwrite(struct file *file, const char *data, size_t count,
633: loff_t * offset)
634: {
635: struct cvdv_cards *card =
636: minorlist[MINOR(file->f_dentry->d_inode->i_rdev) % MAXDEV]; // minor number modulo 16
1.17 mocm 637: return margi_write(card, data, count, file->f_flags&O_NONBLOCK);
1.1 cvs 638: }
639:
640: static unsigned int PSpoll(struct file *file, poll_table * table)
641: {
642: struct cvdv_cards *card =
643: minorlist[MINOR(file->f_dentry->d_inode->i_rdev) % MAXDEV]; // minor number modulo 16
644: if (card != NULL) {
1.9 mocm 645: poll_wait(file, &card->wqA , table);
1.14 mocm 646: if ( !card->rbufA.buffy || ring_write_rest(&(card->rbufA)) )
647: return (POLLOUT | POLLWRNORM);
648: else {
649: return 0;
650: }
1.1 cvs 651: } else
1.8 mocm 652: return POLLERR;
1.1 cvs 653: }
654:
1.17 mocm 655: static unsigned int poll_audio(struct file *file, poll_table * table)
656: {
657: struct cvdv_cards *card =
658: minorlist[MINOR(file->f_dentry->d_inode->i_rdev) % MAXDEV]; // minor number modulo 16
659: if (card != NULL) {
660: poll_wait(file, &card->wqB, table);
661: if ( !card->rbufB.buffy || ring_write_rest(&(card->rbufB)) )
662: return (POLLOUT | POLLWRNORM);
663: else {
664: return 0;
665: }
666: } else
667: return POLLERR;
668: }
669:
1.13 mocm 670: static int
671: OSD_DrawCommand(struct cvdv_cards *card,osd_cmd_t *dc)
672: {
673:
674: switch (dc->cmd) {
675: case OSD_Close:
1.14 mocm 676: MDEBUG(1,": OSD Close\n");
1.13 mocm 677: return OSDClose(card);
678: case OSD_Open: // Open(x0,y0,x1,y1,BitPerPixel(2/4/8),mix(0..15))
679: return OSDOpen(card, dc->x0,
680: dc->y0, dc->x1,
681: dc->y1,
682: dc->color & 0x0F,
683: (dc->color >> 4) &
684: 0x0F);
685: case OSD_Show:
686: return OSDShow(card);
687: case OSD_Hide:
688: return OSDHide(card);
689: case OSD_Clear:
690: return OSDClear(card);
691: case OSD_Fill: // Fill(color)
692: return OSDFill(card, dc->color);
693: case OSD_SetColor: // SetColor(color,R(x0),G(y0),B(x1),opacity(y1))
694: return (OSDSetColor
695: (card, dc->color, dc->x0,
696: dc->y0, dc->x1, 0,
697: (dc->y1 != 255),
698: (dc->y1 == 0)) >= 0);
699: case OSD_SetPalette:// SetPalette(firstcolor{color},lastcolor{x0},data)
700: return OSDSetPalette(card,
701: dc->color,
702: dc->x0, (uint8_t *)
703: dc->data);
704: case OSD_SetTrans: // SetTrans(transparency{color})
705: return OSDSetTrans(card,
706: (dc->color >> 4)
707: & 0x0F);
708: case OSD_SetPixel: // SetPixel(x0,y0,color)
709: return OSDSetPixel(card, dc->x0,
710: dc->y0,
711: dc->color);
712: case OSD_GetPixel: // GetPixel(x0,y0);
713: return OSDGetPixel(card, dc->x0,
714: dc->y0);
715: case OSD_SetRow: // SetRow(x0,y0,x1,(uint8_t*)data)
716: return OSDSetRow(card, dc->x0,
717: dc->y0, dc->x1,
718: (uint8_t *) dc->data);
719: case OSD_SetBlock: // SetBlock(x0,y0,x1,y1,(uint8_t*)data)
720: return OSDSetBlock(card, dc->x0,
721: dc->y0, dc->x1,
722: dc->y1,
723: dc->color,
724: (uint8_t *)
725: dc->data);
726: case OSD_FillRow: // FillRow(x0,y0,x1,color)
727: return OSDFillRow(card, dc->x0,
728: dc->y0, dc->x1,
729: dc->color);
730: case OSD_FillBlock: // FillRow(x0,y0,x1,y1,color)
731: return OSDFillBlock(card, dc->x0,
732: dc->y0, dc->x1,
733: dc->y1,
734: dc->color);
735: case OSD_Line: // Line(x0,y0,x1,y1,color);
736: return OSDLine(card, dc->x0,
737: dc->y0, dc->x1,
738: dc->y1, dc->color);
739: case OSD_Query: // Query(x0,y0,x1,y1,aspect(color:11)
740: return OSDQuery(card, &dc->x0,
741: &dc->y0, &dc->x1,
742: &dc->y1,
743: &dc->color);
744: case OSD_Test:
745: return OSDTest(card);
746: default:
747: return -EINVAL;
748: }
749: }
750:
1.6 mocm 751:
1.1 cvs 752: static int PSioctl(struct inode *inode, struct file *file,
753: unsigned int cmd, unsigned long arg)
754: {
755: struct cvdv_cards *card = minorlist[MINOR(inode->i_rdev) % MAXDEV]; // minor number modulo 16
1.13 mocm 756: osd_cmd_t *dc;
1.1 cvs 757: struct decodercmd *command;
1.12 mocm 758: uint16_t attr;
1.10 mocm 759:
1.1 cvs 760: if (card != NULL) {
761: if (_IOC_TYPE(cmd) == CVDV_IOCTL_MAGIC)
762: switch (_IOC_NR(cmd)) {
763: case IOCTL_DRAW: // Drawing commands
1.13 mocm 764: dc = (osd_cmd_t *) arg;
765: return OSD_DrawCommand(card,dc);
766: break;
1.1 cvs 767: case IOCTL_DECODER:
768: command = (struct decodercmd *) arg;
769: switch (command->cmd) {
1.10 mocm 770:
771: case Decoder_CSS:
1.1 cvs 772: /*
773: return DecoderCSS(card,
774: command->param1,
775: command->data1);
776: */
1.10 mocm 777: break;
778:
1.1 cvs 779: case Decoder_Set_Videosystem:
1.14 mocm 780: MDEBUG(1,": -- Decoder_Set_Videosystem\n");
1.1 cvs 781: card->videomode =
782: (videosystem) command->param1;
783: SetVideoSystem(card);
784: return 0;
1.10 mocm 785: break;
786:
1.1 cvs 787: case Decoder_Set_Streamtype:
1.14 mocm 788: MDEBUG(1,": -- Decoder_Set_Streamtype\n");
1.1 cvs 789: card->setup.streamtype =
790: (stream_type) command->param1;
791: return 0;
1.10 mocm 792: break;
793:
1.1 cvs 794: case Decoder_Set_Audiotype:
1.14 mocm 795: MDEBUG(1,": -- Decoder_Set_Audiotype\n");
1.1 cvs 796: card->setup.audioselect =
797: (audio_type) command->param1;
798: DecoderPrepareAudio(card);
799: return 0;
1.10 mocm 800: break;
801:
1.1 cvs 802: case Decoder_Set_VideoStreamID:
1.14 mocm 803: MDEBUG(1,": -- Decoder_Set_VideoStreamID\n");
1.1 cvs 804: card->setup.videoID =
805: command->param1;
806: DecoderPrepareVideo(card);
807: return 0;
1.10 mocm 808: break;
809:
1.1 cvs 810: case Decoder_Set_AudioStreamID:
1.14 mocm 811: MDEBUG(1,": -- Decoder_Set_AudioStreamID 0x%02X 0x%02X\n",
812: command->param1,command->param2);
1.1 cvs 813: card->setup.audioID =
814: command->param1;
815: card->setup.audioIDext =
816: command->param2;
817: attr = card->lastaattr;
818: DecoderSelectAudioID(card);
819: card->lastaattr = attr;
820: return 0;
1.10 mocm 821: break;
822:
1.1 cvs 823: case Decoder_Still_Put:
824: return DecoderShowStill(card,
825: command->
826: param1,
827: command->
828: param2,
829: command->
830: data1,
831: command->
832: data2);
1.10 mocm 833: break;
834:
1.1 cvs 835: case Decoder_Still_Get:
836: return DecoderGetStill(card,
837: &command->
838: param1,
839: &command->
840: param2,
841: command->
842: data1,
843: command->
844: data2);
1.10 mocm 845: break;
846:
1.1 cvs 847: case Decoder_Pause: // pause{param1} 0=run 1=pause 2=toggle
848: if (command->param1 == 2) {
849: if (card->paused)
850: DecoderUnPause
851: (card);
852: else
853: DecoderPause(card);
854: } else {
855: if (!command->param1)
856: DecoderUnPause
857: (card);
858: else
859: DecoderPause(card);
860: }
861: return 0;
1.10 mocm 862:
863: /* Too buggy
864: case Decoder_FFWD: // pause{param1} =normal 1=ffwd 2=toggle
865: if (command->param1 == 2) {
866: if (card->videoffwd)
867: card->videoffwd = 0;
868: else
1.13 mocm 869: card->videoffwd = 3;
1.10 mocm 870: } else {
871: if (!command->param1)
872: card->videoffwd = 0;
873: else
1.13 mocm 874: card->videoffwd = 3;
1.10 mocm 875: }
876: return 0;
877:
878: case Decoder_Slow: // pause{param1} =normal 1=slow 2=toggle
879: if (command->param1 == 2) {
880: if (card->videoslow)
881: card->videoslow = 0;
882: else
883: card->videoslow = 4;
884: } else {
885: if (!command->param1)
886: card->videoslow = 0;
887: else
888: card->videoslow = 4;
889: }
890: return 0;
891: */
1.1 cvs 892: case Decoder_Highlight: // active{param1}, color information(SL_COLI or AC_COLI){data1[4]}, button position(BTN_POSI){data2[6]}
893: return DecoderHighlight(card,
894: command->
895: param1,
896: command->
897: data1,
898: command->
899: data2);
900: case Decoder_SPU: // stream{param1}, active{param2}
901: return DecoderSPUStream(card,
902: command->
903: param1,
904: command->
905: param2);
906: case Decoder_SPU_Palette: // length{param1}, palette{data1}
907: return DecoderSPUPalette(card,
908: command->
909: param1,
910: command->
911: data1);
912: case Decoder_GetNavi: // data1 will be filled with PCI or DSI pack, and 1024 will be returned
913: return DecoderGetNavi(card,
914: command->
915: data1);
916: case Decoder_SetKaraoke: // Vocal1{param1}, Vocal2{param2}, Melody{param3}
917: return DecoderKaraoke(card,
918: command->
919: param1,
920: command->
921: param2,
922: command->
923: param3);
924: case Decoder_Set_Videoattribute:
1.14 mocm 925: MDEBUG(1,": -- Decoder_Set_Videoattribute\n");
1.1 cvs 926: if (!card->ChannelBuffersAllocated) {
927: DecoderStreamReset(card);
928: MargiFlush(card);
929:
930: card->setup.streamtype =
931: stream_DVD;
932: card->setup.videoID = 0;
933: DecoderPrepareVideo(card);
934: DecoderPreparePS(card, 0,
935: 0, 2, 2,
936: 3, 1);
937: }
938:
939: SetVideoAttr(card,
940: command->param1);
1.6 mocm 941: card->startingDVDV = 1;
942: // tell the card to start playing as soon as ES-buffers are sufficiently full
1.1 cvs 943: return 0;
944: case Decoder_Set_Audioattribute:
1.14 mocm 945: MDEBUG(1,": -- Decoder_Set_Audioattribute\n");
1.1 cvs 946: SetAudioAttr(card,
947: command->param1);
948: card->startingDVDA =
949: ((card->setup.audioselect !=
950: audio_none)
951: && (card->setup.audioselect != audio_disable)); // tell the card to start playing as soon as ES-buffers are sufficiently full
952: return 0;
953: case Decoder_WriteBlock: // DVD-Sector{data1}, sectorsize{param1{2048}}, initialsector{param2{bool}}, set_SCR{param3}
954: return DecoderWriteBlock(card,
955: command->
956: data1,
957: command->
958: param1,
959: command->
960: param2,
961: command->
962: param3);
963: default:
964: return -EINVAL;
965: }
966: default:
967: return -EINVAL;
968: } else
969: return -EINVAL;
970: } else {
1.14 mocm 971: MDEBUG(0,
1.1 cvs 972: ": Video Decoder Prepare failed: device with this minor number not found\n");
973: return -ENODEV; // device with this minor number not found
974: }
975: }
976:
1.6 mocm 977:
1.1 cvs 978: static int PSmmap(struct file *file, struct vm_area_struct *vm)
979: {
980: return -ENODEV;
981: }
982:
1.6 mocm 983:
984:
1.11 mocm 985: static int margi_open(struct cvdv_cards *card, int flags)
1.1 cvs 986: {
1.6 mocm 987: int closed;
1.1 cvs 988: if (card != NULL) {
1.14 mocm 989: MDEBUG(1, ": -- open \n");
1.1 cvs 990: CloseCard(card);
1.5 mocm 991: OSDClose(card);
1.6 mocm 992: #ifdef NOINT
993: card->timer.function = Timerfunction;
994: card->timer.data=(unsigned long) card;
995: card->timer.expires=jiffies+1;
996: add_timer(&card->timer);
997: #endif
998:
999: if (card->open)
1.14 mocm 1000: MDEBUG(0,": PSopen - already open\n");
1.1 cvs 1001: closed = 1;
1.6 mocm 1002: if (card->open)
1003: closed = 0;
1.1 cvs 1004: if (closed) { // first open() for this card?
1.17 mocm 1005: MargiFreeBuffers(card,2);
1.1 cvs 1006: VideoSetBackground(card, 1, 0, 0, 0); // black
1007: }
1.6 mocm 1008: card->open++;
1.11 mocm 1009: MOD_INC_USE_COUNT;
1.1 cvs 1010: return 0;
1011: } else {
1.14 mocm 1012: MDEBUG(0,
1.1 cvs 1013: ": Video Decoder Prepare failed: device with this minor number not found\n");
1014: return -ENODEV; // device with this minor number not found
1015: }
1.6 mocm 1016:
1.1 cvs 1017: }
1018:
1.6 mocm 1019:
1020: static int PSopen(struct inode *inode, struct file *file)
1.1 cvs 1021: {
1.11 mocm 1022: struct cvdv_cards *card = minorlist[MINOR(inode->i_rdev) % MAXDEV];
1.15 mocm 1023: card->audiostate.AVSyncState=true;
1.17 mocm 1024: return margi_open(card, file->f_flags);
1.6 mocm 1025: }
1026:
1027:
1.11 mocm 1028: static int all_margi_close(struct cvdv_cards *card)
1.6 mocm 1029: {
1.11 mocm 1030:
1.1 cvs 1031: if (card != NULL) {
1.14 mocm 1032: MDEBUG(1, ": -- PSrelease\n");
1.11 mocm 1033: if (card->open <= 0)
1.14 mocm 1034: MDEBUG(1,": PSrelease - not open\n");
1.6 mocm 1035: card->open--;
1.4 mocm 1036:
1.11 mocm 1037: MOD_DEC_USE_COUNT;
1.6 mocm 1038: if (!card->open) {
1.14 mocm 1039: MDEBUG(1,": PSrelease - last close\n");
1.11 mocm 1040: CloseCard(card); // close immediately
1.1 cvs 1041: }
1042: return 0;
1043: } else {
1.14 mocm 1044: MDEBUG(0,": Video Decoder Prepare failed:\n");
1.1 cvs 1045: return -ENODEV; // device with this minor number not found
1046: }
1.6 mocm 1047:
1048: }
1049:
1050: static int PSrelease(struct inode *inode, struct file *file)
1051: {
1052: struct cvdv_cards *card = minorlist[MINOR(inode->i_rdev) % MAXDEV]; // minor number modulo 16
1.11 mocm 1053: return all_margi_close(card);
1.1 cvs 1054: }
1055:
1056: //////////////////////////
1057: // //
1058: // Char Device Hookup //
1059: // //
1060: //////////////////////////
1061:
1062: // Hookups for a write-only device, that accepts MPEG-2 Program Stream
1063: struct file_operations cvdv_fileops = {
1064: write: PSwrite,
1065: poll: PSpoll,
1066: ioctl: PSioctl,
1067: mmap: PSmmap,
1068: open: PSopen,
1069: release: PSrelease,
1070: };
1.6 mocm 1071:
1072:
1073: #ifdef DVB
1074:
1075: static inline int
1076: num2type(struct cvdv_cards *card, int num)
1077: {
1078: if (!card->dvb_devs)
1079: return -2;
1080: if (num>=card->dvb_devs->num)
1081: return -2;
1082: return card->dvb_devs->tab[num];
1083: }
1084:
1085: static int
1086: dvbdev_open(struct dvb_device *dvbdev, int num,
1087: struct inode *inode, struct file *file)
1088: {
1089: struct cvdv_cards *card=(struct cvdv_cards *) dvbdev->priv;
1090: int type=num2type(card, num);
1091: int ret=0;
1092:
1093: if (type<0)
1094: return -EINVAL;
1095:
1096: if (card->users[num] >= card->dvb_devs->max_users[num])
1097: return -EBUSY;
1098:
1099: if ((file->f_flags&O_ACCMODE)!=O_RDONLY)
1100: if (card->writers[num] >= card->dvb_devs->max_writers[num])
1101: return -EBUSY;
1102:
1103: switch (type) {
1104: case DVB_DEVICE_VIDEO_0:
1105: card->video_blank=true;
1.9 mocm 1106: card->audiostate.AVSyncState=true;
1.6 mocm 1107: card->videostate.streamSource=VIDEO_SOURCE_DEMUX;
1.17 mocm 1108: margi_open(card, file->f_flags);
1.7 mocm 1109: break;
1.6 mocm 1110:
1111: case DVB_DEVICE_AUDIO_0:
1.17 mocm 1112: card->audiostate.AVSyncState=true;
1.6 mocm 1113: card->audiostate.streamSource=AUDIO_SOURCE_DEMUX;
1114: break;
1115:
1116: case DVB_DEVICE_DEMUX_0:
1117: if ((file->f_flags&O_ACCMODE)!=O_RDWR)
1118: return -EINVAL;
1119: ret=DmxDevFilterAlloc(&card->dmxdev, file);
1120: break;
1.18 ! mocm 1121:
1.6 mocm 1122: case DVB_DEVICE_DVR_0:
1.17 mocm 1123: card->audiostate.AVSyncState=true;
1.18 ! mocm 1124: card->setup.streamtype = stream_PES;
1.17 mocm 1125: margi_open(card, file->f_flags);
1.6 mocm 1126: ret=DmxDevDVROpen(&card->dmxdev, file);
1127: break;
1.9 mocm 1128:
1129: case DVB_DEVICE_OSD_0:
1130: break;
1131: default:
1.6 mocm 1132: return -EINVAL;
1133: }
1134: if (ret<0)
1135: return ret;
1136: if ((file->f_flags&O_ACCMODE)!=O_RDONLY)
1137: card->writers[num]++;
1138: card->users[num]++;
1139: return ret;
1140: }
1141:
1142: static int
1143: dvbdev_close(struct dvb_device *dvbdev, int num,
1144: struct inode *inode, struct file *file)
1145: {
1146: struct cvdv_cards *card=(struct cvdv_cards *) dvbdev->priv;
1147: int type=num2type(card, num);
1148: int ret=0;
1149:
1150: if (type<0)
1151: return -EINVAL;
1152:
1153: switch (type) {
1154: case DVB_DEVICE_VIDEO_0:
1.11 mocm 1155: case DVB_DEVICE_AUDIO_0:
1156: if (card->open)
1157: all_margi_close(card);
1.6 mocm 1158: break;
1159:
1160: case DVB_DEVICE_DEMUX_0:
1161: ret=DmxDevFilterFree(&card->dmxdev, file);
1162: break;
1163:
1164: case DVB_DEVICE_DVR_0:
1165: ret=DmxDevDVRClose(&card->dmxdev, file);
1.12 mocm 1166: if (card->open)
1167: all_margi_close(card);
1.6 mocm 1168: break;
1.9 mocm 1169: case DVB_DEVICE_OSD_0:
1170: break;
1171: default:
1.6 mocm 1172: return -EINVAL;
1173: }
1174: if (ret<0)
1175: return ret;
1176: if ((file->f_flags&O_ACCMODE)!=O_RDONLY)
1177: card->writers[num]--;
1178: card->users[num]--;
1179: return ret;
1180: }
1181:
1.13 mocm 1182:
1.6 mocm 1183: static ssize_t
1184: dvbdev_write(struct dvb_device *dvbdev, int num,
1185: struct file *file,
1186: const char *buf, size_t count, loff_t *ppos)
1187: {
1188: struct cvdv_cards *card=(struct cvdv_cards *) dvbdev->priv;
1189: int type=num2type(card, num);
1190:
1191: switch (type) {
1192: case DVB_DEVICE_VIDEO_0:
1193: if (card->videostate.streamSource!=VIDEO_SOURCE_MEMORY)
1194: return -EPERM;
1.11 mocm 1195: return margi_write(card, buf, count,
1.6 mocm 1196: file->f_flags&O_NONBLOCK);
1197:
1198: case DVB_DEVICE_AUDIO_0:
1199: if (card->audiostate.streamSource!=AUDIO_SOURCE_MEMORY)
1200: return -EPERM;
1.14 mocm 1201: if ( card->setup.streamtype != stream_PES )
1202: return -EPERM;
1203:
1.17 mocm 1204: return margi_write_audio(card, buf, count,
1205: file->f_flags&O_NONBLOCK);
1.6 mocm 1206:
1207: case DVB_DEVICE_DVR_0:
1208: return DmxDevDVRWrite(&card->dmxdev, file, buf, count, ppos);
1209: default:
1210: return -EOPNOTSUPP;
1211: }
1212: return 0;
1213: }
1214:
1.12 mocm 1215: static ssize_t
1216: dvbdev_read(struct dvb_device *dvbdev, int num,
1217: struct file *file, char *buf, size_t count, loff_t *ppos)
1218: {
1219: struct cvdv_cards *card=(struct cvdv_cards *) dvbdev->priv;
1220: int type=num2type(card, num);
1221:
1222: switch (type) {
1223: case DVB_DEVICE_VIDEO_0:
1224: break;
1225: case DVB_DEVICE_AUDIO_0:
1226: break;
1227: case DVB_DEVICE_DEMUX_0:
1228: return DmxDevRead(&card->dmxdev, file, buf, count, ppos);
1229: case DVB_DEVICE_DVR_0:
1230: return DmxDevDVRRead(&card->dmxdev, file, buf, count, ppos);
1231: case DVB_DEVICE_CA_0:
1232: break;
1233: default:
1234: return -EOPNOTSUPP;
1235: }
1236: return 0;
1237: }
1238:
1239:
1240:
1.6 mocm 1241:
1242: static int
1243: dvbdev_ioctl(struct dvb_device *dvbdev, int num,
1244: struct file *file, unsigned int cmd, unsigned long arg)
1245: {
1246: struct cvdv_cards *card=(struct cvdv_cards *) dvbdev->priv;
1247: void *parg=(void *)arg;
1248: int type=num2type(card, num);
1.17 mocm 1249: uint16_t attr;
1.6 mocm 1250:
1251: switch (type) {
1252: case DVB_DEVICE_VIDEO_0:
1253: if (((file->f_flags&O_ACCMODE)==O_RDONLY) &&
1254: (cmd!=VIDEO_GET_STATUS))
1255: return -EPERM;
1256:
1257: switch (cmd) {
1258:
1259: case VIDEO_STOP:
1260: DecoderPause(card);
1.9 mocm 1261: card->videostate.playState = VIDEO_STOPPED;
1.10 mocm 1262: if (card->videostate.videoBlank)
1263: VideoSetBackground(card, 1, 0, 0, 0);
1.9 mocm 1264:
1.10 mocm 1265:
1.9 mocm 1266: return 0;
1.6 mocm 1267:
1268: case VIDEO_PLAY:
1269:
1270: if (card->videostate.streamSource==
1271: VIDEO_SOURCE_MEMORY) {
1.9 mocm 1272: if (card->videostate.playState==VIDEO_FREEZED){
1273: DecoderUnPause(card);
1274: } else {
1275: DecoderUnPause(card);
1276: }
1.6 mocm 1277: }
1278: break;
1279:
1280: case VIDEO_FREEZE:
1281: DecoderPause(card);
1282: break;
1283:
1284: case VIDEO_CONTINUE:
1285: if (card->videostate.playState==VIDEO_FREEZED) {
1286: DecoderUnPause(card);
1287: }
1288: break;
1289:
1290: case VIDEO_SELECT_SOURCE:
1291: card->videostate.streamSource=(videoStreamSource_t) arg;
1292: break;
1293:
1294: case VIDEO_SET_BLANK:
1295: card->videostate.videoBlank=(boolean) arg;
1296: break;
1297:
1298: case VIDEO_GET_STATUS:
1299: if(copy_to_user(parg, &card->videostate,
1300: sizeof(struct videoStatus)))
1301: return -EFAULT;
1302: break;
1303:
1304: case VIDEO_GET_EVENT:
1305: return -EOPNOTSUPP;
1306:
1307: case VIDEO_SET_DISPLAY_FORMAT:
1308: {
1309: videoDisplayFormat_t format=(videoDisplayFormat_t) arg;
1.12 mocm 1310: uint16_t val=0;
1.6 mocm 1311:
1312: switch(format) {
1313: case VIDEO_PAN_SCAN:
1314: val=VID_PAN_SCAN_PREF;
1315: break;
1316:
1317: case VIDEO_LETTER_BOX:
1318: val=VID_VC_AND_PS_PREF;
1319: break;
1320:
1321: case VIDEO_CENTER_CUT_OUT:
1322: val=VID_CENTRE_CUT_PREF;
1323: break;
1324:
1325: default:
1326: return -EINVAL;
1327: }
1328:
1329: card->videostate.videoFormat=format;
1330: return 0;
1331: }
1332:
1333: case VIDEO_STILLPICTURE:
1334: {
1335: struct videoDisplayStillPicture pic;
1336:
1337: if(copy_from_user(&pic, parg,
1338: sizeof(struct videoDisplayStillPicture)))
1339: return -EFAULT;
1340:
1341: break;
1342: }
1343:
1344: case VIDEO_FAST_FORWARD:
1.10 mocm 1345: if (card->videostate.streamSource !=
1346: VIDEO_SOURCE_MEMORY)
1347: return -EPERM;
1.13 mocm 1348: card->videoffwd = 3;
1.6 mocm 1349: break;
1350:
1351: case VIDEO_SLOWMOTION:
1352: if (card->videostate.streamSource!=VIDEO_SOURCE_MEMORY)
1353: return -EPERM;
1.10 mocm 1354: card->videoslow = arg;
1.6 mocm 1355:
1356: break;
1357:
1358: case VIDEO_GET_CAPABILITIES:
1359: {
1.8 mocm 1360: int cap=VIDEO_CAP_MPEG1|
1361: VIDEO_CAP_MPEG2|
1362: VIDEO_CAP_SYS|
1363: VIDEO_CAP_PROG|
1364: VIDEO_CAP_SPU|
1365: VIDEO_CAP_NAVI|
1366: VIDEO_CAP_CSS;
1367:
1.6 mocm 1368:
1369: if (copy_to_user(parg, &cap,
1370: sizeof(cap)))
1371: return -EFAULT;
1372: break;
1373: }
1.18 ! mocm 1374:
1.14 mocm 1375: case VIDEO_SET_STREAMTYPE:
1376: {
1377: int f = -1;
1378: switch(arg){
1379: case VIDEO_CAP_MPEG1:
1380: case VIDEO_CAP_MPEG2:
1381: f = stream_PES;
1382: break;
1383:
1384: case VIDEO_CAP_SYS:
1385: case VIDEO_CAP_PROG:
1386: f = stream_PS;
1387: break;
1388:
1389: case VIDEO_CAP_SPU:
1390: case VIDEO_CAP_NAVI:
1391: case VIDEO_CAP_CSS:
1392: f = stream_DVD;
1393: }
1394: card->setup.streamtype = f;
1.17 mocm 1395:
1.14 mocm 1396: }
1397: break;
1398:
1.17 mocm 1399: case VIDEO_SET_ID:
1400: card->setup.videoID = arg;
1401: DecoderPrepareVideo(card);
1402: break;
1403:
1404: case VIDEO_SET_SYSTEM:
1405: card->videomode = (videosystem) arg;
1406: SetVideoSystem(card);
1407: break;
1408:
1409: case VIDEO_SET_HIGHLIGHT:
1410: {
1411: uint8_t data1[4];
1412: uint8_t data2[6];
1413: videoHighlight_t vh;
1414:
1415: if(copy_from_user(&vh, parg, sizeof(videoHighlight_t)))
1416: return -EFAULT;
1417:
1418: data1[0] = vh.contrast1;
1419: data1[1] = vh.contrast2;
1420: data1[2] = vh.color1;
1421: data1[3] = vh.color2;
1422: data2[0] = vh.ypos & 0xFF;
1423: data2[1] = (uint8_t) ((vh.ypos >> 1) & 0xFF);
1424: data2[2] = (uint8_t) ((vh.ypos >> 2) & 0xFF);
1425: data2[3] = vh.xpos & 0xFF;
1426: data2[4] = (uint8_t) ((vh.xpos >> 1) & 0xFF);
1427: data2[5] = (uint8_t) ((vh.xpos >> 2) & 0xFF);
1428: return DecoderHighlight(card, vh.active, data1, data2);
1429: break;
1430: }
1431:
1432: case VIDEO_SET_SPU:
1433: {
1434: videoSPU_t spu;
1435:
1436: if(copy_from_user(&spu, parg, sizeof(videoSPU_t)))
1437: return -EFAULT;
1438:
1439: return DecoderSPUStream(card, spu.streamID, spu.active);
1440: break;
1441: }
1442:
1443: case VIDEO_SET_SPU_Palette:
1444: {
1445: videoSPUPalette_t spup;
1446:
1447: if(copy_from_user(&spup, parg, sizeof(videoSPUPalette_t)))
1448: return -EFAULT;
1449:
1450: return DecoderSPUPalette(card, spup.length, spup.palette);
1451: break;
1452: }
1453:
1454: case VIDEO_GET_NAVI:
1455: {
1456: videoNaviPack_t navi;
1457:
1.18 ! mocm 1458: navi.length = DecoderGetNavi(card, (u8 *)&(navi.data));
1.17 mocm 1459: if(copy_to_user(parg, &navi, sizeof(videoNaviPack_t)))
1460: return -EFAULT;
1461: }
1462: break;
1463:
1464: case VIDEO_SET_ATTRIBUTES:
1465: {
1466: if (!card->ChannelBuffersAllocated) {
1467: DecoderStreamReset(card);
1468: MargiFlush(card);
1469:
1470: card->setup.streamtype = stream_DVD;
1471: card->setup.videoID = 0;
1472: DecoderPrepareVideo(card);
1473: DecoderPreparePS(card, 0, 0, 2, 2, 3, 1);
1474: }
1475:
1476: SetVideoAttr(card, arg);
1477: card->startingDVDV = 1;
1478: }
1479: break;
1480:
1.6 mocm 1481: default:
1482: return -ENOIOCTLCMD;
1483: }
1484: return 0;
1.14 mocm 1485:
1.6 mocm 1486: case DVB_DEVICE_AUDIO_0:
1487: if (((file->f_flags&O_ACCMODE)==O_RDONLY) &&
1488: (cmd!=AUDIO_GET_STATUS))
1489: return -EPERM;
1490:
1491: switch (cmd) {
1492:
1493: case AUDIO_STOP:
1494: if (card->audiostate.streamSource!=AUDIO_SOURCE_MEMORY)
1495: break;
1496: AudioStopDecode(card);
1497: card->audiostate.playState=AUDIO_STOPPED;
1498: break;
1499:
1500: case AUDIO_PLAY:
1501: if (card->audiostate.streamSource!=AUDIO_SOURCE_MEMORY)
1502: break;
1503: AudioSetPlayMode(card, MAUDIO_PLAY);
1504: card->audiostate.playState=AUDIO_PLAYING;
1505: break;
1506:
1507: case AUDIO_PAUSE:
1508: card->audiostate.playState=AUDIO_PAUSED;
1509: AudioSetPlayMode(card, MAUDIO_PAUSE);
1510: break;
1511:
1512: case AUDIO_CONTINUE:
1513: if (card->audiostate.playState==AUDIO_PAUSED) {
1514: card->audiostate.playState=AUDIO_PLAYING;
1515: AudioSetPlayMode(card, MAUDIO_PLAY);
1516: }
1517: break;
1518:
1519: case AUDIO_SELECT_SOURCE:
1.14 mocm 1520: card->audiostate.streamSource=
1521: (audioStreamSource_t) arg;
1.6 mocm 1522: break;
1523:
1524: case AUDIO_SET_MUTE:
1525: {
1526: AudioMute(card, arg);
1527: card->audiostate.muteState=(boolean) arg;
1528: break;
1529: }
1530:
1531: case AUDIO_SET_AV_SYNC:
1.9 mocm 1532: card->videosync=(boolean) arg;
1.6 mocm 1533: card->audiostate.AVSyncState=(boolean) arg;
1534: break;
1535:
1536: case AUDIO_SET_BYPASS_MODE:
1537: return -EINVAL;
1538:
1539: case AUDIO_CHANNEL_SELECT:
1540: card->audiostate.channelSelect=(audioChannelSelect_t) arg;
1541:
1542: switch(card->audiostate.channelSelect) {
1543: case AUDIO_STEREO:
1544: break;
1545:
1546: case AUDIO_MONO_LEFT:
1547: break;
1548:
1549: case AUDIO_MONO_RIGHT:
1550: break;
1551:
1552: default:
1553: return -EINVAL;
1554: }
1555: return 0;
1556:
1557: case AUDIO_GET_STATUS:
1558: if(copy_to_user(parg, &card->audiostate,
1559: sizeof(struct audioStatus)))
1560: return -EFAULT;
1561: break;
1562:
1563: case AUDIO_GET_CAPABILITIES:
1564: {
1565: int cap=AUDIO_CAP_LPCM|
1566: AUDIO_CAP_MP1|
1.8 mocm 1567: AUDIO_CAP_MP2|
1568: AUDIO_CAP_AC3;
1.6 mocm 1569:
1570: if (copy_to_user(parg, &cap,
1571: sizeof(cap)))
1572: return -EFAULT;
1573: }
1.14 mocm 1574: break;
1575:
1576:
1577: case AUDIO_SET_STREAMTYPE:
1578: {
1579: int f = -1;
1580:
1581: switch(arg){
1582: case AUDIO_CAP_DTS:
1583: case AUDIO_CAP_MP3:
1584: case AUDIO_CAP_AAC:
1585: case AUDIO_CAP_SDDS:
1586: case AUDIO_CAP_OGG:
1587: f = audio_none;
1588: break;
1589:
1590: case AUDIO_CAP_LPCM:
1591: f = audio_LPCM;
1592: break;
1593:
1594: case AUDIO_CAP_MP1:
1595: case AUDIO_CAP_MP2:
1596: f = audio_MPEG;
1597: break;
1598:
1599: case AUDIO_CAP_AC3:
1600: f = audio_AC3;
1601: break;
1602: }
1603:
1604: card->setup.audioselect = (audio_type) f;
1605: DecoderPrepareAudio(card);
1.17 mocm 1606: break;
1.14 mocm 1607: }
1.17 mocm 1608:
1609: case AUDIO_SET_ID:
1610: if (arg < 0 || arg >32) arg = 0;
1611: card->setup.audioID = arg;
1612: arg = 0;
1613: case AUDIO_SET_EXT_ID:
1614: if (arg < 0 || arg >32) arg = 0;
1615: card->setup.audioIDext = arg;
1616:
1617: attr = card->lastaattr;
1618: DecoderSelectAudioID(card);
1619: card->lastaattr = attr;
1620: break;
1621:
1622: case AUDIO_SET_MIXER:
1623: return -EINVAL;
1624:
1625: case AUDIO_SET_ATTRIBUTES:
1626: SetAudioAttr(card,arg);
1627: card->startingDVDA = ((card->setup.audioselect != audio_none)
1628: && (card->setup.audioselect !=
1629: audio_disable));
1630: break;
1631:
1632:
1633: case AUDIO_SET_KARAOKE:
1634: {
1635: break;
1636: }
1.14 mocm 1637:
1638: default:
1.6 mocm 1639: return -ENOIOCTLCMD;
1640: }
1.14 mocm 1641: break;
1.6 mocm 1642:
1643: case DVB_DEVICE_DEMUX_0:
1644: return DmxDevIoctl(&card->dmxdev, file, cmd, arg);
1.13 mocm 1645: break;
1.6 mocm 1646:
1.9 mocm 1647: case DVB_DEVICE_OSD_0:
1648: {
1.13 mocm 1649: switch (cmd) {
1.9 mocm 1650: case OSD_SEND_CMD:
1.13 mocm 1651: {
1652: osd_cmd_t doc;
1653:
1654: if(copy_from_user(&doc, parg,
1655: sizeof(osd_cmd_t)))
1656: return -EFAULT;
1657: return OSD_DrawCommand(card, &doc);
1658: }
1.9 mocm 1659: default:
1660: return -EINVAL;
1.13 mocm 1661: }
1.9 mocm 1662: break;
1663: }
1664: default:
1.6 mocm 1665: return -EOPNOTSUPP;
1666: }
1667: return 0;
1668: }
1669:
1670: static unsigned int
1671: dvbdev_poll(struct dvb_device *dvbdev, int num,
1672: struct file *file, poll_table * wait)
1673: {
1674: struct cvdv_cards *card=(struct cvdv_cards *) dvbdev->priv;
1675: int type=num2type(card, num);
1676:
1677: switch (type) {
1678: case DVB_DEVICE_DEMUX_0:
1679: return DmxDevPoll(&card->dmxdev, file, wait);
1680:
1681: case DVB_DEVICE_VIDEO_0:
1682: return PSpoll(file, wait);
1683:
1684: case DVB_DEVICE_AUDIO_0:
1.17 mocm 1685: return poll_audio(file, wait);
1.6 mocm 1686:
1687: case DVB_DEVICE_CA_0:
1688: break;
1689:
1690: default:
1691: return -EOPNOTSUPP;
1692: }
1693:
1694: return 0;
1695: }
1696:
1697:
1698: static int
1699: dvbdev_device_type(struct dvb_device *dvbdev, unsigned int num)
1700: {
1701: struct cvdv_cards *card=(struct cvdv_cards *) dvbdev->priv;
1702:
1703: return num2type(card, num);
1704: }
1705: #endif
1706:
1707: /******************************************************************************
1708: * driver registration
1709: ******************************************************************************/
1710:
1711:
1712: #ifdef DVB
1713:
1714: #define INFU 32768
1715:
1.9 mocm 1716:
1717:
1.6 mocm 1718: static dvb_devs_t mdvb_devs = {
1.9 mocm 1719: 9,
1.6 mocm 1720: {
1.9 mocm 1721: DVB_DEVICE_VIDEO_0, DVB_DEVICE_AUDIO_0,
1722: -1, -1,
1723: DVB_DEVICE_DEMUX_0, DVB_DEVICE_DVR_0,
1724: -1, -1,
1.13 mocm 1725: DVB_DEVICE_OSD_0,
1.6 mocm 1726: },
1.9 mocm 1727: { INFU, INFU, INFU, INFU, INFU, 1, 1, INFU, 1 },
1728: { 1, 1, 1, 1, INFU, 1, 1, 1, 1}
1.6 mocm 1729: };
1730:
1.12 mocm 1731:
1732: static int
1733: dvb_start_feed(dvb_demux_feed_t *dvbdmxfeed)
1734: {
1735: dvb_demux_t *dvbdmx=dvbdmxfeed->demux;
1736: struct cvdv_cards * card = (struct cvdv_cards *)dvbdmx->priv;
1737:
1738: if (!dvbdmx->dmx.frontend || !card)
1739: return -EINVAL;
1740:
1741: if (dvbdmxfeed->type == DMX_TYPE_TS) {
1742: if ((dvbdmxfeed->ts_type & TS_DECODER)
1743: && (dvbdmxfeed->pes_type<DMX_TS_PES_OTHER)) {
1744: switch (dvbdmx->dmx.frontend->source) {
1745: case DMX_MEMORY_FE:
1746: if (dvbdmxfeed->ts_type & TS_DECODER)
1747: if (dvbdmxfeed->pes_type<2 &&
1748: dvbdmx->pids[0]!=0xffff &&
1749: dvbdmx->pids[1]!=0xffff) {
1750:
1751: setup_ts2pes( &card->tsa,
1752: &card->tsv,
1753: dvbdmx->pids,
1754: dvbdmx->pids+1,
1755: pes_write,
1756: (void *)card);
1757:
1758: dvbdmx->playing=1;
1759: }
1760: break;
1761: default:
1762: return -EINVAL;
1763: break;
1764: }
1765: }
1766: }
1767:
1768: if (dvbdmxfeed->type == DMX_TYPE_SEC) {
1769: int i;
1770:
1771: for (i=0; i<dvbdmx->filternum; i++) {
1772: if (dvbdmx->filter[i].state!=DMX_STATE_READY)
1773: continue;
1774: if (dvbdmx->filter[i].type!=DMX_TYPE_SEC)
1775: continue;
1776: if (dvbdmx->filter[i].filter.parent!=
1777: &dvbdmxfeed->feed.sec)
1778: continue;
1779:
1780: dvbdmxfeed->feed.sec.is_filtering=1;
1781: dvbdmx->filter[i].state=DMX_STATE_GO;
1782: }
1783: }
1784:
1785: return 0;
1786: }
1787:
1788:
1789: static int
1790: dvb_stop_feed(dvb_demux_feed_t *dvbdmxfeed)
1791: {
1792: dvb_demux_t *dvbdmx=dvbdmxfeed->demux;
1793: struct cvdv_cards * card = (struct cvdv_cards *)dvbdmx->priv;
1794: if (!card)
1795: return -EINVAL;
1796:
1797: if (dvbdmxfeed->type == DMX_TYPE_TS) {
1798: if ((dvbdmxfeed->ts_type & TS_DECODER)
1799: && (dvbdmxfeed->pes_type<=1)) {
1800: if (dvbdmx->playing) {
1.14 mocm 1801: free_ipack(&card->tsa);
1802: free_ipack(&card->tsv);
1.12 mocm 1803: DecoderPause(card);
1804: dvbdmx->playing=0;
1805: }
1806: }
1807:
1808: }
1809: if (dvbdmxfeed->type == DMX_TYPE_SEC) {
1810: int i;
1811:
1812: for (i=0; i<dvbdmx->filternum; i++)
1813: if (dvbdmx->filter[i].state==DMX_STATE_GO &&
1814: dvbdmx->filter[i].filter.parent==
1815: &dvbdmxfeed->feed.sec) {
1816: dvbdmx->filter[i].state=DMX_STATE_READY;
1817: }
1818:
1819: }
1820: return 0;
1821: }
1822:
1823:
1824: static int
1825: dvb_write_to_decoder(dvb_demux_feed_t *dvbdmxfeed, uint8_t *buf, size_t count)
1826: {
1827: dvb_demux_t *dvbdmx=dvbdmxfeed->demux;
1828: struct cvdv_cards * card = (struct cvdv_cards *)dvbdmx->priv;
1829: uint16_t pid = 0;
1.18 ! mocm 1830: int off = 0;
1.12 mocm 1831:
1.14 mocm 1832: ipack *p;
1.12 mocm 1833:
1834: if (!card)
1835: return -EINVAL;
1836:
1837: pid = get_pid(buf+1);
1838:
1839: if (pid == *(card->tsa.pid)) p = &(card->tsa);
1840: else if (pid == *(card->tsv.pid)) p = &(card->tsv);
1841: else return 0;
1842:
1843: if (dvbdmxfeed->pes_type>1)
1844: return -1;
1845: if (!(buf[3]&0x10)) // no payload?
1846: return -1;
1847:
1848: if (count != TS_SIZE) return -1;
1849:
1.18 ! mocm 1850: if ( buf[3] & ADAPT_FIELD) { // adaptation field?
! 1851: off = buf[4] + 1;
! 1852: }
! 1853:
! 1854:
! 1855: if (pid == *(card->tsa.pid)){
! 1856: MDEBUG(0,"AUDIO count: %d off: %d\n",count,off);
! 1857: margi_write_audio(card, buf+off+4, TS_SIZE-4-off, 0);
! 1858: } else {
! 1859: MDEBUG(0,"VIDEO count: %d off: %d\n",count,off);
! 1860: margi_write(card, buf+off+4, TS_SIZE-4-off, 0);
! 1861: }
! 1862:
! 1863: // ts_to_pes( p, buf); // don't need count (=188)
1.12 mocm 1864: return 0;
1865: }
1866:
1.6 mocm 1867: int dvb_register(struct cvdv_cards *card)
1868: {
1.12 mocm 1869: int i,ret;
1.6 mocm 1870: struct dvb_device *dvbd=&card->dvb_dev;
1.12 mocm 1871:
1872: dvb_demux_t *dvbdemux = (dvb_demux_t *)&card->demux;
1.6 mocm 1873:
1874: if (card->dvb_registered)
1875: return -1;
1876: card->dvb_registered=1;
1877:
1878: card->audiostate.AVSyncState=0;
1879: card->audiostate.muteState=0;
1880: card->audiostate.playState=AUDIO_STOPPED;
1881: card->audiostate.streamSource=AUDIO_SOURCE_MEMORY;
1882: card->audiostate.channelSelect=AUDIO_STEREO;
1883: card->audiostate.bypassMode=0;
1884:
1885: card->videostate.videoBlank=0;
1886: card->videostate.playState=VIDEO_STOPPED;
1887: card->videostate.streamSource=VIDEO_SOURCE_MEMORY;
1888: card->videostate.videoFormat=VIDEO_FORMAT_4_3;
1889: card->videostate.displayFormat=VIDEO_CENTER_CUT_OUT;
1890:
1891: // init and register demuxes
1.12 mocm 1892: memcpy(card->demux_id, "demux0_0", 9);
1893: card->demux_id[7] = 1+0x30;
1894: dvbdemux->priv = (void *) card;
1895: dvbdemux->filternum = 32;
1896: dvbdemux->feednum = 32;
1897: dvbdemux->start_feed = dvb_start_feed;
1898: dvbdemux->stop_feed = dvb_stop_feed;
1899: dvbdemux->write_to_decoder = dvb_write_to_decoder;
1900:
1901: dvbdemux->dmx.vendor="CIM";
1902: dvbdemux->dmx.model="sw";
1903: dvbdemux->dmx.id=card->demux_id;
1904: dvbdemux->dmx.capabilities=(DMX_TS_FILTERING|
1905: DMX_SECTION_FILTERING|
1906: DMX_MEMORY_BASED_FILTERING);
1907:
1908: DvbDmxInit(&card->demux);
1909:
1910: card->dmxdev.filternum=32;
1911: card->dmxdev.demux=&dvbdemux->dmx;
1912: card->dmxdev.capabilities=0;
1913:
1914: DmxDevInit(&card->dmxdev);
1.6 mocm 1915:
1.12 mocm 1916: card->mem_frontend.id="mem_frontend";
1917: card->mem_frontend.vendor="memory";
1918: card->mem_frontend.model="sw";
1919: card->mem_frontend.source=DMX_MEMORY_FE;
1920: ret=dvbdemux->dmx.add_frontend(&dvbdemux->dmx,
1921: &card->mem_frontend);
1922: if (ret<0)
1923: return ret;
1924: ret=dvbdemux->dmx.connect_frontend(&dvbdemux->dmx,
1925: &card->mem_frontend);
1926: if (ret<0)
1927: return ret;
1.6 mocm 1928:
1929: // init and register dvb device structure
1930: dvbd->priv=(void *) card;
1931: dvbd->open=dvbdev_open;
1932: dvbd->close=dvbdev_close;
1933: dvbd->write=dvbdev_write;
1.12 mocm 1934: dvbd->read=dvbdev_read;
1.6 mocm 1935: dvbd->ioctl=dvbdev_ioctl;
1936: dvbd->poll=dvbdev_poll;
1937: dvbd->device_type=dvbdev_device_type;
1938:
1939: for (i=0; i<DVB_DEVS_MAX; i++)
1940: card->users[i]=card->writers[i]=0;
1941:
1942: card->dvb_devs=0;
1943: card->dvb_devs=&mdvb_devs;
1.12 mocm 1944:
1.6 mocm 1945: return dvb_register_device(dvbd);
1946: }
1947:
1948: void dvb_unregister(struct cvdv_cards *card)
1949: {
1.12 mocm 1950: dvb_demux_t *dvbdemux=&card->demux;
1951:
1952: dvbdemux->dmx.close(&dvbdemux->dmx);
1953: dvbdemux->dmx.remove_frontend(&dvbdemux->dmx, &card->mem_frontend);
1954: DmxDevRelease(&card->dmxdev);
1955: DvbDmxRelease(&card->demux);
1.6 mocm 1956: dvb_unregister_device(&card->dvb_dev);
1957: }
1958: #endif