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