Annotation of margi2/decoder.c, revision 1.1.1.1

1.1       cvs         1: /* 
                      2:     decoder.c
                      3: 
                      4:     Copyright (C) Christian Wolff for convergence integrated media.
                      5: 
                      6:     This program is free software; you can redistribute it and/or modify
                      7:     it under the terms of the GNU General Public License as published by
                      8:     the Free Software Foundation; either version 2 of the License, or
                      9:     (at your option) any later version.
                     10: 
                     11:     This program is distributed in the hope that it will be useful,
                     12:     but WITHOUT ANY WARRANTY; without even the implied warranty of
                     13:     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
                     14:     GNU General Public License for more details.
                     15: 
                     16:     You should have received a copy of the GNU General Public License
                     17:     along with this program; if not, write to the Free Software
                     18:     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
                     19: */
                     20: 
                     21: #define __NO_VERSION__
                     22: 
                     23: #include "decoder.h"
                     24: #include "l64021.h"
                     25: #include "video.h"
                     26: #include "audio.h"
                     27: #include "streams.h"
                     28: #include "osd.h"
                     29: #include "dram.h"
                     30: 
                     31: int DecoderGetNavi(struct cvdv_cards *card, u8 *navidata) 
                     32: {
                     33:        if (card->navihead == card->navitail) return 0;
                     34: //      printk(KERN_DEBUG LOGNAME ": Retreiving NaviPack\n");
                     35:        memcpy(navidata, &card->navibuffer[card->navitail], NAVISIZE);
                     36:        card->navitail += NAVISIZE;
                     37:        if (card->navitail >= NAVIBUFFERSIZE) card->navitail = 0;
                     38:        return NAVISIZE;
                     39: }
                     40: 
                     41: // returns 1 on overrun, 0 on no error
                     42: int DecoderQueueNavi(struct cvdv_cards *card, u8 *navidata) 
                     43: {
                     44:        memcpy(&card->navibuffer[card->navihead], navidata, NAVISIZE);
                     45:        card->navihead += NAVISIZE;
                     46:        if (card->navihead >= NAVIBUFFERSIZE) card->navihead = 0;
                     47:        if (card->navihead == card->navitail) {
                     48: //      printk(KERN_DEBUG LOGNAME ": NaviPack buffer overflow\n");
                     49:                card->navitail += NAVISIZE;
                     50:                if (card->navitail >= NAVIBUFFERSIZE) card->navitail = 0;
                     51:                return 1;
                     52:        }
                     53:        return 0;
                     54: }
                     55: 
                     56: u32 ParseSCR(const u8 *scrdata) 
                     57: {
                     58:        u32 SCR_base=0;
                     59:        
                     60:        if ((!scrdata[0]) && (!scrdata[1]) && (scrdata[2]==1) 
                     61:            && (scrdata[3]==0xBA) && ((scrdata[4]&0xC0)==0x40)) {
                     62:                SCR_base=((scrdata[4]>>3)&0x07);
                     63:                SCR_base=(SCR_base<<2) | (scrdata[4]&0x03);
                     64:                SCR_base=(SCR_base<<8) | scrdata[5];
                     65:                SCR_base=(SCR_base<<5) | ((scrdata[6]>>3)&0x1F);
                     66:                SCR_base=(SCR_base<<2) | (scrdata[6]&0x03);
                     67:                SCR_base=(SCR_base<<8) | scrdata[7];
                     68:                SCR_base=(SCR_base<<5) | ((scrdata[8]>>3)&0x1F);
                     69:        }
                     70:        return SCR_base;
                     71: }
                     72: 
                     73: u32 SetSCR(struct cvdv_cards *card, u32 SCR_base) 
                     74: {
                     75: //  printk(KERN_ERR LOGNAME ": SCR in DVD Pack: 0x%08X\n",SCR_base);
                     76:        if (DecoderReadByte(card, 0x007) & 0x10) {  // SCR already stopped
                     77:                DecoderWriteByte(card,0x009,SCR_base&0xFF);  // Set SCR counter
                     78:                DecoderWriteByte(card,0x00A,(SCR_base>>8)&0xFF);
                     79:                DecoderWriteByte(card,0x00B,(SCR_base>>16)&0xFF);
                     80:                DecoderWriteByte(card,0x00C,(SCR_base>>24)&0xFF);
                     81:        } else {
                     82:                DecoderMaskByte(card,0x007,0xD2,0xD2);   
                     83:                 // Set 0x10, halt SCR counter
                     84:                DecoderWriteByte(card,0x009,SCR_base&0xFF);  // Set SCR counter
                     85:                DecoderWriteByte(card,0x00A,(SCR_base>>8)&0xFF);
                     86:                DecoderWriteByte(card,0x00B,(SCR_base>>16)&0xFF);
                     87:                DecoderWriteByte(card,0x00C,(SCR_base>>24)&0xFF);
                     88:                DecoderMaskByte(card,0x007,0xD2,0xC2);   
                     89:                // Del 0x10, SCR counter run
                     90:        }
                     91:        return SCR_base;
                     92: }
                     93: 
                     94: void DecoderPause(struct cvdv_cards *card) 
                     95: {
                     96:        DecoderMaskByte(card, 0x007, 0xD2, 0xD2);   
                     97:         // Set 0x010, halt SCR counter
                     98:        AudioSetPlayMode(card, AUDIO_PAUSE);
                     99:        DecoderStopDecode(card);
                    100:        card->paused = 1;
                    101: }
                    102: 
                    103: void DecoderUnPause(struct cvdv_cards *card) 
                    104: {
                    105:        DecoderStartDecode(card);
                    106:        AudioSetPlayMode(card, AUDIO_PLAY);
                    107:        DecoderMaskByte(card, 0x007, 0xD2, 0xC2);   
                    108:         // Del 0x010, SCR counter run
                    109:        card->paused = 0;
                    110: }
                    111: 
                    112: void CloseCard(struct cvdv_cards *card) 
                    113: {
                    114:        printk(KERN_DEBUG LOGNAME ": Closing card\n");
                    115:        DecoderStreamReset(card);
                    116:        DecoderSetupReset(card);
                    117:        DecoderUnPrepare(card);
                    118:        DecoderClose(card);
                    119: 
                    120:        AudioClose(card);
                    121:        OSDClose(card);
                    122: }
                    123: 
                    124: 
                    125: void DecoderReadAudioInfo(struct cvdv_cards *card) 
                    126: {
                    127:        u8 data;
                    128:        static int bitrates[17] = {0, 32, 40, 48, 56, 64, 80, 96, 112, 
                    129:                                   128, 160, 192, 224, 256, 320, 384, 0};
                    130:        struct AudioParam *audio = &card->stream.audio;
                    131:        data = DecoderReadByte(card, 0x150);
                    132:        audio->mpeg.present = data & 0x60;  
                    133:         // MPEG Layer Code 00 reserverd, we can assume valid MPEG params
                    134:        if (audio->mpeg.present) {
                    135:                audio->mpeg.MPEG2 = data & 0x80;
                    136:                audio->mpeg.layer = 4 - ((data >> 5) & 0x03);
                    137:                if (data & 0x0F) {
                    138:                        if ((data & 0x0F) == 1) audio->mpeg.bitrate = 32; 
                    139:                        else switch (audio->mpeg.layer) {
                    140:                        case 1: 
                    141:                                audio->mpeg.bitrate = 32 * (data & 0x0F); 
                    142:                                break;  // Layer I
                    143:                        case 2: 
                    144:                                audio->mpeg.bitrate = bitrates[(data & 0x0F) +
                    145:                                                              1]; 
                    146:                                break;  // Layer II
                    147:                        default: 
                    148:                                audio->mpeg.bitrate = bitrates[data & 0x0F];
                    149:                                // Layer III
                    150:                        }
                    151:                } else audio->mpeg.bitrate = 0;
                    152:                data = DecoderReadByte(card, 0x151);
                    153:                switch ((data >> 6) & 0x03) {
                    154:                case 0: 
                    155:                        audio->mpeg.samplefreq = 44; 
                    156:                        break;
                    157:                case 1: 
                    158:                        audio->mpeg.samplefreq = 48; 
                    159:                        break;
                    160:                case 2: 
                    161:                        audio->mpeg.samplefreq = 32; 
                    162:                        break;
                    163:                default: 
                    164:                        audio->mpeg.samplefreq = 0; // invalid
                    165:                }
                    166:                audio->mpeg.mode = (data >> 3) & 0x03;
                    167:                audio->mpeg.modeext = (data >> 1) & 0x03;
                    168:                audio->mpeg.copyright = data & 0x01;
                    169:                data=DecoderReadByte(card, 0x152);
                    170:                audio->mpeg.original = data & 0x80;
                    171:                audio->mpeg.emphasis = (data >> 5) & 0x03;
                    172:        }
                    173:        data = DecoderReadByte(card, 0x153);
                    174:        audio->ac3.present = (data != 0);  
                    175:        // value 0 for bits 0..5 forbidden, we can assume valid ac3 params
                    176:        if (audio->ac3.present) {
                    177:                audio->ac3.acmod = (data >> 5) & 0x07;
                    178:                audio->ac3.dialnorm = data & 0x1F;
                    179:                data = DecoderReadByte(card, 0x154);
                    180:                audio->ac3.bsmod = (data >> 5) & 0x07;
                    181:                audio->ac3.dialnorm2 = data > 0x1F;
                    182:                data = DecoderReadByte(card, 0x155);
                    183:                audio->ac3.surmixlev = (data >> 6) & 0x03;
                    184:                audio->ac3.mixlevel = (data >> 1) & 0x1F;
                    185:                data = DecoderReadByte(card, 0x156);
                    186:                audio->ac3.cmixlev = (data >> 6) & 0x03;
                    187:                audio->ac3.mixlevel2 = (data >> 1) & 0x1F;
                    188:                data = DecoderReadByte(card, 0x157);
                    189:                audio->ac3.fscod = (data >> 6) & 0x03;
                    190:                audio->ac3.lfeon = (data >> 5) & 0x01;
                    191:                audio->ac3.bsid = data & 0x1F;
                    192:                data = DecoderReadByte(card, 0x158);
                    193:                audio->ac3.dsurmod = (data >> 6) & 0x03;
                    194:                audio->ac3.frmsizecod = data & 0x3F;
                    195:                audio->ac3.langcod = DecoderReadByte(card, 0x159);
                    196:                audio->ac3.langcod2 = DecoderReadByte(card, 0x15A);
                    197:                audio->ac3.timecod = DecoderReadByte(card, 0x15B);
                    198:                data = DecoderReadByte(card, 0x15C);
                    199:                audio->ac3.timecod = (audio->ac3.timecod << 6) | 
                    200:                  ((data >> 2) & 0x3F);
                    201:                audio->ac3.roomtyp = data & 0x03;
                    202:                audio->ac3.timecod2 = DecoderReadByte(card, 0x15D);
                    203:                data = DecoderReadByte(card, 0x15E);
                    204:                audio->ac3.timecod2 = (audio->ac3.timecod2 << 6) | 
                    205:                  ((data >> 2) & 0x3F);
                    206:                audio->ac3.roomtyp2 = data & 0x03;
                    207:        }
                    208:        audio->pcm.present =! (DecoderReadByte(card, 0x161) & 0x20);  
                    209:        // PCM FIFO not empty? Then, we can assume valid LPCM params
                    210:        if (audio->pcm.present) {
                    211:                data = DecoderReadByte(card, 0x15F);
                    212:                audio->pcm.audio_frm_num = (data >> 3) & 0x1F;
                    213:                audio->pcm.num_of_audio_ch = data & 0x07;
                    214:                data = DecoderReadByte(card, 0x160);
                    215:                audio->pcm.Fs = (data >> 6) & 0x03;
                    216:                audio->pcm.quantization = (data >> 4) & 0x03;
                    217:                audio->pcm.emphasis = (data >> 2) & 0x03;
                    218:                audio->pcm.mute_bit = (data >> 1) & 0x01;
                    219:        }
                    220:        switch (card->setup.audioselect) {
                    221:        case audio_disable:
                    222:                audio->valid = 0;
                    223:                break;
                    224:        case audio_none:
                    225:        case audio_DTS:
                    226:        case audio_SDDS:
                    227:                if ((audio->valid = (audio->ac3.present || 
                    228:                                     audio->pcm.present || 
                    229:                                     audio->mpeg.present))) {
                    230:                        if (audio->mpeg.present) {
                    231:                                card->setup.audioselect = audio_MPEG;
                    232:                        } else if (audio->pcm.present) {
                    233:                                card->setup.audioselect = audio_LPCM;
                    234:                        } else if (audio->ac3.present) {
                    235:                                card->setup.audioselect = audio_AC3;
                    236:                        } 
                    237:                } else {
                    238:                        audio->valid = 0;
                    239:                        card->setup.audioselect = audio_none;
                    240:                }
                    241:                break;
                    242:        case audio_MPEG:  // MPEG Audio
                    243:        case audio_MPEG_EXT:  // MPEG Audio with extension stream
                    244:                audio->valid = audio->mpeg.present;
                    245:                break;
                    246:        case audio_LPCM:  // Linear Pulse Code Modulation LPCM
                    247:                audio->valid = audio->pcm.present;
                    248:                break;
                    249:        case audio_AC3:  // AC-3
                    250:                audio->valid = audio->ac3.present;
                    251:                break;
                    252:        }
                    253:        printk(KERN_DEBUG LOGNAME ": -- DecoderReadAudioInfo - type/valid %d/%d:\n", card->setup.audioselect, audio->valid);
                    254:        if (audio->mpeg.present || audio->ac3.present || audio->pcm.present)
                    255:                printk(KERN_DEBUG LOGNAME ": Audio - Decoded parameters:\n");
                    256:        if (audio->mpeg.present) printk(KERN_DEBUG LOGNAME ":   MPEG%s Layer %d, %d kHz, %d kbps, %s, %s%s, %s emphasis\n", 
                    257:                                        ((audio->mpeg.MPEG2) ? "2" : "1"), 
                    258:                                        audio->mpeg.layer, 
                    259:                                        audio->mpeg.samplefreq, 
                    260:                                        audio->mpeg.bitrate, 
                    261:                                        ((audio->mpeg.mode == 0) ? "stereo" : ((audio->mpeg.mode == 1) ? "joint stereo" : ((audio->mpeg.mode == 2) ? "dual channel" : "single channel"))), 
                    262:                                        ((audio->mpeg.copyright) ? "copyrighted " : ""), 
                    263:                                        ((audio->mpeg.original) ? "original" : "copy"), 
                    264:                                        ((audio->mpeg.emphasis == 0) ? "no" : ((audio->mpeg.emphasis == 1) ? "50/15 usec." : ((audio->mpeg.emphasis == 2) ? "invalid" : "J.17")))
                    265:                );
                    266:        if (audio->ac3.present) printk(KERN_DEBUG LOGNAME ":   AC3 acmod=%d bsmod=%d dialnorm=%d dialnorm2=%d surmixlev=%d mixlevel=%d cmixlev=%d mixlevel2=%d fscod=%d lfeon=%d bsid=%d dsurmod=%d frmsizecod=%d langcod=%d langcod2=%d timecod=%d roomtyp=%d timecod2=%d roomtyp2=%d\n", 
                    267:                                       audio->ac3.acmod, 
                    268:                                       audio->ac3.bsmod, 
                    269:                                       audio->ac3.dialnorm, 
                    270:                                       audio->ac3.dialnorm2, 
                    271:                                       audio->ac3.surmixlev, 
                    272:                                       audio->ac3.mixlevel, 
                    273:                                       audio->ac3.cmixlev, 
                    274:                                       audio->ac3.mixlevel2, 
                    275:                                       audio->ac3.fscod, 
                    276:                                       audio->ac3.lfeon, 
                    277:                                       audio->ac3.bsid, 
                    278:                                       audio->ac3.dsurmod, 
                    279:                                       audio->ac3.frmsizecod, 
                    280:                                       audio->ac3.langcod, 
                    281:                                       audio->ac3.langcod2, 
                    282:                                       audio->ac3.timecod, 
                    283:                                       audio->ac3.roomtyp, 
                    284:                                       audio->ac3.timecod2, 
                    285:                                       audio->ac3.roomtyp2);
                    286:        if (audio->pcm.present) printk(KERN_DEBUG LOGNAME ":   LPCM audio_frm_num=%d num_of_audio_ch=%d Fs=%d quantization=%d emphasis=%d mute_bit=%d\n", 
                    287:                                       audio->pcm.audio_frm_num, 
                    288:                                       audio->pcm.num_of_audio_ch, 
                    289:                                       audio->pcm.Fs, 
                    290:                                       audio->pcm.quantization, 
                    291:                                       audio->pcm.emphasis, 
                    292:                                       audio->pcm.mute_bit);
                    293: }
                    294: 
                    295: void DecoderReadAuxFifo(struct cvdv_cards *card) 
                    296: {
                    297:        int i = 0;
                    298:        u8 data;
                    299:        int layer;
                    300: 
                    301:        struct StreamInfo *stream = &card->stream;
                    302: //      printk(KERN_DEBUG LOGNAME ": AUX - ");
                    303: //      printk("%03X ", card->AuxFifo[card->AuxFifoTail]);
                    304:         while (card->AuxFifoHead != card->AuxFifoTail) {
                    305:                
                    306:                layer = (card->AuxFifo[card->AuxFifoTail] >> 8) & 0x07;
                    307:                data = card->AuxFifo[card->AuxFifoTail] & 0xFF;
                    308:                card->AuxFifoTail = (card->AuxFifoTail + 1) & FIFO_MASK;
                    309:                if (layer != card->AuxFifoLayer) {  // start of a new layer?
                    310:                        i = 0;
                    311:                        card->AuxFifoLayer = layer;
                    312:                } else i++;
                    313:                switch (layer) {  // layer code
                    314:                case 0:  // sequence header
                    315:                        if (! stream->sh.valid) switch (i) {
                    316:                        case 0: 
                    317:                                stream->sh.hsize = data & 0x0F; 
                    318:                                break;
                    319:                        case 1: 
                    320:                                stream->sh.hsize = (stream->sh.hsize << 8)
                    321:                                        | data; 
                    322:                                stream->hsize = stream->sh.hsize; 
                    323:                                break;
                    324:                        case 2: 
                    325:                                stream->sh.vsize = data & 0x0F; 
                    326:                                break;
                    327:                        case 3: 
                    328:                                stream->sh.vsize = (stream->sh.vsize << 8) | 
                    329:                                        data; 
                    330:                                stream->vsize = stream->sh.vsize; 
                    331:                                break;
                    332:                        case 4: 
                    333:                                stream->sh.aspectratio = data & 0x0F; 
                    334:                                break;
                    335:                        case 5: 
                    336:                                stream->sh.frameratecode = data & 0x0F; 
                    337:                                break;
                    338:                        case 6: 
                    339:                                stream->sh.bitrate = data & 0x03; 
                    340:                                break;
                    341:                        case 7: 
                    342:                                stream->sh.bitrate = (stream->sh.bitrate << 8)
                    343:                                        | data; 
                    344:                                break;
                    345:                        case 8: 
                    346:                                stream->sh.bitrate = (stream->sh.bitrate << 8)
                    347:                                        | data; 
                    348:                                stream->bitrate = stream->sh.bitrate; 
                    349:                                break;
                    350:                        case 9: 
                    351:                                stream->sh.vbvbuffersize = data & 0x03; 
                    352:                                break;
                    353:                        case 10: 
                    354:                                stream->sh.vbvbuffersize = 
                    355:                                        (stream->sh.vbvbuffersize << 8) | 
                    356:                                        data; 
                    357:                                stream->vbvbuffersize = 
                    358:                                        stream->sh.vbvbuffersize; 
                    359:                                break;
                    360:                        case 11: 
                    361:                                stream->sh.constrained = data & 0x01; 
                    362:                                stream->sh.valid = 1;
                    363:                                printk(KERN_DEBUG LOGNAME ": AUX - MPEG1 - %dx%d %s %s fps, %d bps, %d kByte vbv%s\n", stream->sh.hsize, stream->sh.vsize, 
                    364:                                       ((stream->sh.aspectratio == 1) ? "1:1" : 
                    365:                                        ((stream->sh.aspectratio == 2) ? "3:4" : 
                    366:                                         ((stream->sh.aspectratio == 3) ? "9:16" : 
                    367:                                          ((stream->sh.aspectratio == 4) ? "1:2.21" : 
                    368:                                           "?:?")))), 
                    369:                                       ((stream->sh.frameratecode == 1) ? "23.976" : 
                    370:                                        ((stream->sh.frameratecode == 2) ? "24" : 
                    371:                                         ((stream->sh.frameratecode == 3) ? "25" : 
                    372:                                          ((stream->sh.frameratecode == 4) ? "29.97" : 
                    373:                                           ((stream->sh.frameratecode == 5) ? "30" : 
                    374:                                            ((stream->sh.frameratecode == 6) ? "50" : 
                    375:                                             ((stream->sh.frameratecode == 7) ? "59.94" : 
                    376:                                              ((stream->sh.frameratecode == 8) ? "60" : 
                    377:                                               "?")))))))), 
                    378:                                       stream->sh.bitrate * 400, 
                    379:                                       stream->sh.vbvbuffersize * 16, 
                    380:                                       ((stream->sh.constrained) ? ", constrained" : "")
                    381:                                        );
                    382:                                break;
                    383:                        }
                    384:                        break;
                    385:                case 1:  // group of pictures
                    386:                        if (! stream->gop.valid) 
                    387:                                switch (i) {
                    388:                                case 0: 
                    389:                                        stream->gop.timecode = data & 0x01; 
                    390:                                        break;
                    391:                                case 1: 
                    392:                                        stream->gop.timecode = 
                    393:                                                (stream->gop.timecode << 8) | 
                    394:                                                data; 
                    395:                                        break;
                    396:                                case 2: 
                    397:                                        stream->gop.timecode = 
                    398:                                                (stream->gop.timecode << 8) | 
                    399:                                                data; 
                    400:                                        break;
                    401:                                case 3: 
                    402:                                        stream->gop.timecode = 
                    403:                                                (stream->gop.timecode << 8) | 
                    404:                                                data; 
                    405:                                        break;
                    406:                                case 4: 
                    407:                                        stream->gop.closedgop = data & 0x01; 
                    408:                                        break;
                    409:                                case 5: 
                    410:                                        stream->gop.brokenlink = data & 0x01;
                    411:                                        stream->gop.valid = 1;
                    412:                                        break;
                    413:                                }
                    414:                        break;
                    415:                case 2:  // picture
                    416:                        if (0) 
                    417:                                switch (i) {
                    418:                                case 0: 
                    419:                                        break;
                    420:                                }
                    421:                        break;
                    422:                case 7:  // extension layer
                    423:                        if (i == 0) card->AuxFifoExt = data;
                    424:                        else 
                    425:                                switch (card->AuxFifoExt) {  // extension code
                    426:                                case 1:  // sequence extension
                    427:                                        if ((stream->sh.valid) && 
                    428:                                            (! stream->se.valid))
                    429:                                                switch (i) {
                    430:                                                case 1: 
                    431:                                                        stream->se.profilelevel
                    432:                                                                = data; 
                    433:                                                        break;
                    434:                                                case 2: 
                    435:                                                        stream->se.progressive
                    436:                                                                = data & 0x01; 
                    437:                                                        break;
                    438:                                                case 3: 
                    439:                                                        stream->se.chroma = 
                    440:                                                                (data >> 4) & 
                    441:                                                                0x03; 
                    442:                                                        stream->se.hsizeext = 
                    443:                                                                (data >> 2) & 
                    444:                                                                0x03;
                    445:                                                        stream->se.vsizeext = 
                    446:                                                                data & 0x03;
                    447:                                                        stream->hsize |= 
                    448:                                                                (stream->se.hsizeext << 12);
                    449:                                                        stream->vsize |= 
                    450:                                                                (stream->se.vsizeext << 12);
                    451:                                                        break;
                    452:                                                case 4: 
                    453:                                                        stream->se.bitrateext =
                    454:                                                                data & 0x0F; 
                    455:                                                        break;
                    456:                                                case 5: 
                    457:                                                        stream->se.bitrateext =
                    458:                                                                (stream->se.bitrateext << 8) | data; 
                    459:                                                        stream->bitrate |= 
                    460:                                                                (stream->se.bitrateext << 18); 
                    461:                                                        break;
                    462:                                                case 6: 
                    463:                                                        stream->se.vbvbuffersizeext = data; 
                    464:                                                        stream->vbvbuffersize |= (stream->se.vbvbuffersizeext << 10); 
                    465:                                                        break;
                    466:                                                case 7:
                    467:                                                        stream->se.lowdelay =
                    468:                                                                (data >> 7) & 
                    469:                                                                0x01;
                    470:                                                        stream->se.frextn = 
                    471:                                                                (data >> 5) & 
                    472:                                                                0x03;
                    473:                                                        stream->se.frextd = 
                    474:                                                                data & 0x1F;
                    475:                                                        stream->se.valid = 1;
                    476:                                                        stream->MPEG2 = 1;
                    477:                                                        printk(KERN_DEBUG LOGNAME ": AUX - MPEG2 - %dx%d %s %s*%d/%d fps, %d bps, %d kByte vbv%s%s\n", stream->hsize, stream->vsize, 
                    478:                                                               ((stream->sh.aspectratio == 1) ? "1:1" : 
                    479:                                                                ((stream->sh.aspectratio == 2) ? "3:4" : 
                    480:                                                                 ((stream->sh.aspectratio == 3) ? "9:16" : 
                    481:                                                                  ((stream->sh.aspectratio == 4) ? "1:2.21" : 
                    482:                                                                   "?:?")))), 
                    483:                                                               ((stream->sh.frameratecode == 1) ? "23.976" : 
                    484:                                                                ((stream->sh.frameratecode == 2) ? "24" : 
                    485:                                                                 ((stream->sh.frameratecode == 3) ? "25" : 
                    486:                                                                  ((stream->sh.frameratecode == 4) ? "29.97" : 
                    487:                                                                   ((stream->sh.frameratecode == 5) ? "30" : 
                    488:                                                                    ((stream->sh.frameratecode == 6) ? "50" : 
                    489:                                                                     ((stream->sh.frameratecode == 7) ? "59.94" : 
                    490:                                                                      ((stream->sh.frameratecode == 8) ? "60" : 
                    491:                                                                       "?")))))))), 
                    492:                                                               stream->se.frextn + 1, 
                    493:                                                               stream->se.frextd + 1, 
                    494:                                                               stream->bitrate * 400, 
                    495:                                                               stream->vbvbuffersize * 16, 
                    496:                                                               ((stream->sh.constrained) ? ", constrained" : ""), 
                    497:                                                               ((stream->se.lowdelay) ? ", low delay" : "")
                    498:                                                                );
                    499:                                                        break;
                    500:                                                }
                    501:                                        break;
                    502:                                case 2:  // sequence display extension
                    503:                                        if (0)
                    504:                                                switch (i) {
                    505:                                                case 0: 
                    506:                                                        break;
                    507:                                                }
                    508:                                        break;
                    509:                                case 3:  // quant matrix extension
                    510:                                        if (0) 
                    511:                                                switch (i) {
                    512:                                                case 0: 
                    513:                                                        break;
                    514:                                                }
                    515:                                        break;
                    516:                                case 4:  // copyright  extension
                    517:                                        if (0) 
                    518:                                                switch (i) {
                    519:                                                case 0: 
                    520:                                                        break;
                    521:                                                }
                    522:                                        break;
                    523:                                case 7:  // picture display extension
                    524:                                        if (0) switch (i) {
                    525:                                        case 0: 
                    526:                                                break;
                    527:                                        }
                    528:                                        break;
                    529:                                case 8:  // picture coding extension
                    530:                                        if (0) 
                    531:                                                switch (i) {
                    532:                                                case 0: 
                    533:                                                        break;
                    534:                                                }
                    535:                                        break;
                    536:                                default:
                    537:                                        break;
                    538:                                }
                    539:                        break;
                    540:                default:break;
                    541:                }
                    542:                
                    543:        }  
                    544: }
                    545: 
                    546: void DecoderReadDataFifo(struct cvdv_cards *card) 
                    547: {
                    548:        //      printk(KERN_DEBUG LOGNAME ": DATA - ");
                    549:        while (card->DataFifoHead != card->DataFifoTail) {
                    550: //             printk("%03X ", card->DataFifo[card->DataFifoTail]);
                    551:                card->DataFifoTail = (card->DataFifoTail + 1) & FIFO_MASK;
                    552:        }
                    553: //     printk("\n");
                    554: }
                    555: 
                    556: int DecoderReadNavipack(struct cvdv_cards *card) 
                    557: {
                    558:        u32 startaddr, endaddr, writeaddr;
                    559:        u8 navipack[1024];
                    560:        u16 PacketLength;
                    561:        u8 SubStreamID;
                    562:        //struct Navi navi;
                    563:        int i;
                    564:        startaddr = (DecoderReadWord(card, 0x05C) & 0x3FFF) << 7;   
                    565:         // 21 bit word address
                    566:        endaddr = (DecoderReadWord(card, 0x05E) & 0x3FFF) << 7;     
                    567:         // 21 bit word address
                    568:        writeaddr = DecoderReadByte(card, 0x075) & 0xFF;
                    569:        writeaddr |= (DecoderReadWord(card, 0x077) & 0x0FFF) << 8;
                    570:        //writeaddr <<= 3;
                    571: //printk(KERN_DEBUG LOGNAME ": -- DecoderReadNavipack 0x%08X-0x%08X, ->0x%08X <-0x%08X\n", startaddr, endaddr, writeaddr, card->NaviPackAddress);
                    572:        
                    573:        if (DecoderReadByte(card, 0x07B) & 0xC0) {  // navi pack available?
                    574:                DRAMReadByte(card, card->NaviPackAddress, 1024, navipack, 0);
                    575:                card->reg07B |= 0x20;  // decrement navi counter
                    576:                DecoderWriteByte(card, 0x07B, card->reg07B);
                    577:                card->reg07B &= ~0x20;
                    578:                //DecoderSetByte(card, 0x07B, 0x20);  // decrement navi counter
                    579:                card->NaviPackAddress += 512;       // increment in words
                    580:                if (card->NaviPackAddress >= endaddr) 
                    581:                        card->NaviPackAddress = startaddr;
                    582: //printk(KERN_DEBUG LOGNAME ": Navipack %02X %02X %02X %02X  %02X %02X %02X %02X\n", 
                    583: //  navipack[0], navipack[1], navipack[2], navipack[3], navipack[4], navipack[5], navipack[6], navipack[7]);
                    584:                if ((!navipack[0]) && (!navipack[1]) && (navipack[2] == 1) && (navipack[3] == 0xBF)) {
                    585:                        PacketLength = (navipack[4] << 8) | navipack[5];
                    586:                        SubStreamID = navipack[6];
                    587: //printk(KERN_DEBUG LOGNAME ": Navipack Len=%d, ID=%d\n", PacketLength, SubStreamID);
                    588:                        i = 7;  // start of payload data in navipack[]
                    589:                        switch (SubStreamID) {
                    590:                        case 0:  // Presentation Control Information (PCI)
                    591:                                if (PacketLength < 980) return 1;  // Packet too small
                    592:                                DecoderQueueNavi(card, navipack);
                    593:                                break;
                    594:                        case 1:  // Data Search Information (DSI)
                    595:                                if (PacketLength < 1018) return 1;  // Packet too small
                    596:                                DecoderQueueNavi(card, navipack);
                    597:                                break;
                    598:                        default:
                    599:                                break;
                    600:                        }
                    601: //    } else {
                    602: //      printk(KERN_DEBUG LOGNAME ": navi pack format error: %02X %02X %02X %02X %02X %02X %02X %02X.\n", 
                    603: //        navipack[0], navipack[1], navipack[2], navipack[3], navipack[4], navipack[5], navipack[6], navipack[7]);
                    604:                }
                    605: //  } else {
                    606: //    printk(KERN_DEBUG LOGNAME ": no navi pack avail.\n");
                    607:        }
                    608:        return 0;
                    609: }
                    610: 
                    611: int AudioStart(struct cvdv_cards *card) 
                    612: {
                    613:        DecoderReadAudioInfo(card);  // detect audio type
                    614:        if (card->stream.audio.valid) {
                    615:                printk(KERN_DEBUG LOGNAME ": Audio Init in delayed decoder start\n");
                    616:                if (card->AudioInitialized) AudioClose(card);
                    617:                switch (card->setup.audioselect) {
                    618:                case audio_MPEG:  // MPEG Audio
                    619:                case audio_MPEG_EXT:  // MPEG Audio with ext.
                    620:                        printk(KERN_DEBUG LOGNAME ": Using MPEG Audio\n");
                    621:                        AudioInit(card, card->stream.audio.mpeg.samplefreq, 0);
                    622:                        if (card->stream.audio.mpeg.mode == 3) AudioDualMono(card, 2);  // left channel only
                    623:                        else AudioDualMono(card, 0);
                    624:                        break;
                    625:                case audio_DTS:
                    626:                case audio_LPCM:  // Linear Pulse Code Modulation LPCM
                    627:                        printk(KERN_DEBUG LOGNAME ": Using LPCM Audio\n");
                    628:                        AudioInit(card, 48, 0);  // or 96
                    629:                        break;
                    630:                case audio_AC3:  // AC-3
                    631:                        printk(KERN_DEBUG LOGNAME ": Using AC-3 Audio\n");
                    632:                        switch (card->stream.audio.ac3.fscod) {
                    633:                        case 0:AudioInit(card, 48, 0); break;
                    634:                        case 1:AudioInit(card, 44, 0); break;
                    635:                        case 2:AudioInit(card, 32, 0); break;
                    636:                        }
                    637:                        break;
                    638:                case audio_none:
                    639:                case audio_disable:
                    640:                case audio_SDDS:
                    641:                }
                    642:        } else return 1;
                    643:        return 0;
                    644: }
                    645: 
                    646: // Slow mode: displays every field <slowfactor> times
                    647: // slowfactor=0 disables this mode.
                    648: void VideoSlow(struct cvdv_cards *card, int slowfactor) 
                    649: {
                    650:        if (!slowfactor && card->slowdown) DecoderWriteByte(card, 0x0ED, 0x00);  // run
                    651:        card->lastslow = 0;
                    652:        card->slowdown = slowfactor;
                    653: }
                    654: 
                    655: // Puts decoder in pause after so many fields
                    656: void StepsToPause(struct cvdv_cards *card, int steps) 
                    657: {
                    658:        card->videosteps = steps;
                    659: }
                    660: 
                    661: u32 DecoderReadSCR(struct cvdv_cards *card, u16 address)
                    662: {
                    663:        u32 SCR;
                    664:        SCR = DecoderReadByte(card, address);
                    665:        SCR |= ((u32)DecoderReadByte(card, address+1) << 8);
                    666:        SCR |= ((u32)DecoderReadByte(card, address+2) << 16);
                    667:        SCR |= ((u32)DecoderReadByte(card, address+3) << 24);
                    668:        return SCR;
                    669: }
                    670: 
                    671: u32 DecoderReadRWAddr(struct cvdv_cards *card, u16 address)
                    672: {
                    673:        u32 addr;
                    674:        addr = DecoderReadByte(card, address) & 0xFF;
                    675:        addr |= (((u32)DecoderReadByte(card, address+1) & 0xFF) << 8);
                    676:        addr |= (((u32)DecoderReadByte(card, address+2) & 0x0F) << 16);
                    677:        return addr;
                    678: }
                    679: 
                    680: int PTSGetFirstPTS(PTSStorage *store, u32 *PTS)
                    681: {
                    682:        if ( store->end == store->begin ) {
                    683:                return 0;
                    684:        } else {
                    685:                *PTS = store->PTS[store->begin];
                    686:                return 1;
                    687:        }
                    688: }
                    689: 
                    690: void PTSStoreAdd(PTSStorage *store, u32 PTS, u32 AddrB, u32 AddrE)
                    691: {
                    692:        int new;
                    693: 
                    694: //printk(KERN_DEBUG LOGNAME ": PTSStoreAdd - store in [%d] %08X - %08X\n", store->end, AddrB, AddrE);
                    695: 
                    696:  // cheap fix: don't store if address rollover
                    697:        if ((AddrB & 0x00080000) != (AddrE & 0x00080000)) return;
                    698: 
                    699:        new = store->end;
                    700: 
                    701:        store->end++;
                    702:        if (store->end >= store->size) store->end = 0;
                    703:        if (store->end == store->begin) {
                    704:                store->begin++;
                    705:                if (store->begin >= store->size) store->begin = 0;
                    706:        }
                    707: 
                    708:        store->AddrB[new] = AddrB;
                    709:        store->AddrE[new] = AddrE;
                    710:        store->PTS[new] = PTS;
                    711: }
                    712: 
                    713: int PTSGetPTS (PTSStorage *store, u32 Addr, u32 *PTS )
                    714: {
                    715:        u32 AddrB;
                    716:        u32 AddrE;
                    717:        int i;
                    718:        int found;
                    719:        int search;
                    720: 
                    721: //printk(KERN_DEBUG LOGNAME ": PTSGetPTS - search %08X\n", Addr);
                    722: 
                    723:        if (store->end == store->begin) {
                    724:                store->LastAddr = Addr;
                    725:                return 0;
                    726:        }
                    727: 
                    728:        // Search for the PTS in the array
                    729:        found = 0;
                    730:        search = 1;
                    731:        while (search && !found) {
                    732:         // Get the first value
                    733:                i = store->begin;
                    734:                AddrB = store->AddrB[i];
                    735:                AddrE = store->AddrE[i];
                    736: 
                    737: //printk(KERN_DEBUG LOGNAME ": PTSGetPTS - search in [%d] %08X - %08X\n", i, AddrB, AddrE);
                    738: 
                    739:         //If in range, keep it
                    740:                if ((Addr >= AddrB) && (Addr <= AddrE)) {
                    741:                        *PTS = store->PTS[i];
                    742:                        found = 1;
                    743:                } else {
                    744:                        if ((Addr & 0x00080000) == (AddrB & 0x00080000)) {
                    745:                                if (Addr < AddrB ) search = 0;
                    746:                        } else {
                    747:                                if ((store->LastAddr & 0x00080000) == (Addr & 0x00080000)) search = 0;
                    748:                        }
                    749:                }
                    750:                if (search) {
                    751:                        store->begin++;
                    752:                        if (store->begin >= store->size) store->begin = 0;
                    753:                        if (store->end == store->begin ) search = 0;
                    754:                }
                    755:        }
                    756:        store->LastAddr = Addr;
                    757:        return found;
                    758: }
                    759: 
                    760: 
                    761: u32 GetPTS(u8 *data, u32* MediaPointer, int mpeg, int hlength,int off)
                    762: {
                    763:        u32 PTS = 0xFFFFFFFFUL;
                    764:        int p = 0;
                    765:        
                    766:        // Read PTS, if present
                    767:        if ((mpeg == 2 && data[p + 7] & 0x80) ||
                    768:            (mpeg == 1 && off)) {
                    769:                if (mpeg == 1) p = off-9;
                    770:                PTS = (data[p + 9] >> 1) & 0x03UL;
                    771:                PTS = (PTS << 8) | (data[p + 10] & 0xFFUL);
                    772:                PTS = (PTS << 7) | ((data[p + 11] >> 1) & 0x7FUL);
                    773:                PTS = (PTS << 8) | (data[p + 12] & 0xFFULL);
                    774:                PTS = (PTS << 7) | ((data[p + 13] >> 1) & 0x7FUL);
                    775:        }
                    776:        // Now, skip rest of PES header and stuffing
                    777:        if (mpeg == 2){
                    778:                p += (9 + (data[p + 8] & 0xFF));
                    779:                p = ((p + 7) / 8) * 8;
                    780:        } else p = hlength+7;
                    781:        if (!(data[p++] | data[p++] | data[p++] | data[p++])) {
                    782:                *MediaPointer = (u32)data[p++] & 0xFF;
                    783:                *MediaPointer = (*MediaPointer << 8) | ((u32)data[p++] & 0xFF);
                    784:                *MediaPointer = (*MediaPointer << 8) | ((u32)data[p++] & 0xFF);
                    785:                *MediaPointer = (*MediaPointer << 8) | ((u32)data[p++] & 0xFF);
                    786:        } else {
                    787:                *MediaPointer = 0xFFFFFFFFUL;
                    788:        }
                    789:        return PTS;
                    790: }
                    791: 
                    792: int ReadPESChunk(struct cvdv_cards *card, u32 *addr, u8 *data, u32 start, u32 end)
                    793: {
                    794:        int i = 5, err = -1;
                    795:        while (err && (i--)) err &= DRAMReadByte(card, *addr << 2, 8, &data[0], 0);
                    796:        if (err) return 1;
                    797:        (*addr)++;
                    798:        if (*addr >= end) *addr = start;
                    799:        return 0;
                    800: }
                    801: 
                    802: void ReadPESHeaders(struct cvdv_cards *card)
                    803: {
                    804:        u8 startcode[] = {0x00, 0x00, 0x01};
                    805:        int LoopCount;
                    806:        u32 LastVAddr; // Current Video Address
                    807:        u32 LastAAddr; // Current Audio Address
                    808:        u32 Addr;      // Current Header Address
                    809:        u32 PESAddr;   // Pointer from Header Block
                    810:        u32 PTS;       // PTS from Header Block
                    811:        u8 Data[32];
                    812:        u32 AudioPESStart;
                    813:        u32 AudioPESEnd;
                    814:        int i, j, p, fail;
                    815:        u32 FailAddr;
                    816:        int hlength=0;
                    817:        int mpeg=0;
                    818:        int check;
                    819:        int mp=0;
                    820:        int off=0;
                    821:        
                    822:        AudioPESStart = (DecoderReadWord(card, 0x058) & 0x3FFF) << 5;
                    823:        AudioPESEnd = ((DecoderReadWord(card, 0x05A) & 0x3FFF) + 1) << 5;
                    824: 
                    825:        LastVAddr = DecoderReadRWAddr(card, 0x060);
                    826:        LastAAddr = DecoderReadRWAddr(card, 0x063);
                    827:        
                    828:        if (card->LastAddr == 0) card->LastAddr = AudioPESStart;
                    829: 
                    830: //card->AudioPES .. (((DecoderReadWord(card,0x05A) & 0x3FFF) + 1) << 5)
                    831: 
                    832:        //Read the PES header buffer
                    833:        Addr  = DecoderReadRWAddr(card, 0x072) & 0x0007FFFF;
                    834:        if (Addr >= AudioPESEnd) {
                    835:                Addr = card->LastAddr = AudioPESStart;
                    836:        }
                    837: 
                    838:        LoopCount = 0;
                    839:        while ((card->LastAddr != Addr) && (LoopCount++ < 200)) {
                    840: //printk(KERN_DEBUG LOGNAME ": Read PES header: round %d 0x%08X -> 0x%08X\n", LoopCount, card->LastAddr, Addr);
                    841:                FailAddr = card->LastAddr;
                    842:                fail = 0;
                    843:                p = 0;
                    844: 
                    845:                if (ReadPESChunk(card, &card->LastAddr, &Data[p], AudioPESStart, AudioPESEnd)) continue;
                    846:                p+=8;
                    847:                j=1;
                    848:                
                    849: 
                    850: //printk(KERN_DEBUG LOGNAME ":  PES header: %02X %02X %02X %02X %02X %02X %02X %02X\n", Data[0],Data[1],Data[2],Data[3],Data[4],Data[5],Data[6],Data[7]);
                    851:                if (memcmp(Data, startcode, 3)) continue;
                    852:                if ((Data[3] == 0xE0) || (Data[3] == 0xBD) 
                    853:                    || ((Data[3] & 0xE0) == 0xC0)) {
                    854:                  
                    855:                        fail |= ReadPESChunk(card, &card->LastAddr, 
                    856:                                             &Data[p], AudioPESStart, 
                    857:                                             AudioPESEnd);
                    858: 
                    859: 
                    860:                        p+=8;
                    861:                        j++;
                    862:                        if ( (Data[6] & 0xC0) == 0x80 ){
                    863:                                hlength = 9+Data[8];
                    864:                                mpeg = 2;
                    865:                        } else {
                    866:                                mpeg = 1;
                    867:                                mp = 6;
                    868:                                check = Data[mp];
                    869:                                mp++;
                    870:                                while (check == 0xFF){
                    871:                                        if (!fail && mp == p) {
                    872:                                                fail |= ReadPESChunk(
                    873:                                                        card, 
                    874:                                                        &card->LastAddr, 
                    875:                                                        &Data[p], 
                    876:                                                        AudioPESStart, 
                    877:                                                        AudioPESEnd);
                    878:                                                p+=8;
                    879:                                                j++;
                    880:                                        }
                    881:                                        check = Data[mp];
                    882:                                        mp++;
                    883:                                }
                    884:                                if (!fail && mp == p) {
                    885:                                        fail |= ReadPESChunk(
                    886:                                                card, 
                    887:                                                &card->LastAddr, 
                    888:                                                &Data[p], 
                    889:                                                AudioPESStart, 
                    890:                                                AudioPESEnd);
                    891:                                        p+=8;
                    892:                                        j++;
                    893:                                }
                    894:                                
                    895:                                if ( !fail && (check & 0xC0) == 0x40){
                    896:                                        check = Data[mp];
                    897:                                        mp++;
                    898:                                        if (!fail && mp == p) {
                    899:                                                fail |= ReadPESChunk(
                    900:                                                        card, 
                    901:                                                        &card->LastAddr, 
                    902:                                                        &Data[p], 
                    903:                                                        AudioPESStart, 
                    904:                                                        AudioPESEnd);
                    905:                                          p+=8;
                    906:                                          j++;
                    907:                                        }
                    908:                                        check = Data[mp];
                    909:                                        mp++;
                    910:                                }
                    911:                                if ( !fail && (check & 0x20)){
                    912:                                        if (check & 0x30) hlength = mp+10;
                    913:                                        else hlength = mp+5;
                    914:                                        off = mp-1;
                    915:                                }
                    916:        //printk(KERN_DEBUG LOGNAME ":  PTS: %02X %02X %02X %02X %02X\n", Data[off],Data[off+1],Data[off+2],Data[off+3],Data[off+4]);
                    917:                                
                    918:                                
                    919:                        }
                    920: 
                    921:                        for (i = 1; (i < ((hlength+7) / 8)) && (!fail);
                    922:                             i++) {
                    923:                                fail |= ReadPESChunk(card, &card->LastAddr, &Data[p], AudioPESStart, AudioPESEnd);
                    924:                                p+=8;
                    925:                                j++;
                    926:                        }
                    927: 
                    928: //printk(KERN_DEBUG LOGNAME ":  PES header: %d chunks read, HL = %d\n", j, Data[8]);
                    929:                        if (!fail) {
                    930:                                PTS = GetPTS(Data, &PESAddr, 
                    931:                                             mpeg, hlength,off);
                    932: //printk(KERN_DEBUG LOGNAME ":   PTS from PES header: %d @ 0x%08X\n", PTS, PESAddr);
                    933:                                if ((PTS != 0xFFFFFFFF) && (PESAddr != 0xFFFFFFFF)) {
                    934:                                        if (Data[3] == 0xE0) {  // Video
                    935: //printk(KERN_DEBUG LOGNAME ":   Video PTS from PES header: %d @ 0x%08X - 0x%08X\n", PTS, PESAddr, LastVAddr);
                    936:                                                PTSStoreAdd(&card->VideoPTSStore, PTS, PESAddr, LastVAddr);
                    937:                                        } else {  // Audio
                    938: //printk(KERN_DEBUG LOGNAME ":   Audio PTS from PES header: %d @ 0x%08X - 0x%08X\n", PTS, PESAddr, LastAAddr);
                    939:                                                PTSStoreAdd(&card->AudioPTSStore, PTS, PESAddr, LastAAddr);
                    940:                                        }
                    941:                                }
                    942:                        }
                    943:                } else {
                    944:                        //card->LastAddr = Addr;
                    945:                }
                    946:                // In case of error, rewind and try again
                    947:                if (fail) card->LastAddr = FailAddr; 
                    948:                }
                    949: }
                    950: 
                    951: void L64021Intr(struct cvdv_cards *card) 
                    952: {
                    953: //static void L64021Intr(struct cvdv_cards *card) {
                    954: //  struct cvdv_cards *card=dev_id;
                    955:        u32 SCR_base, SCR_compareV, SCR_compareA;
                    956:        u32 VideoAddr, AudioAddr, PTS;
                    957:        int i, a, v, as, vs, ap, vp;
                    958: //  int err, h;
                    959:        u8 intr[5];
                    960:        u8 layer;
                    961:        //u8 oldlayer = 0;
                    962:        long ISRTime, DeltaSyncTime, Offset;
                    963:        
                    964:        int used = 0;
                    965:        u8 err;
                    966: 
                    967:        err = DecoderReadByte(card, 0x095);
                    968:        if (err & 0x17) {
                    969:                printk(KERN_DEBUG LOGNAME ": Packet Error: 0x%02X\n", err);
                    970:        }
                    971: 
                    972:        ISRTime = 0;  // TODO system time
                    973:   
                    974:        for (i = 0; i < 5; i++) 
                    975:                if ((intr[i] = DecoderReadByte(card, i))) used = 1;
                    976:        if (used) {
                    977: //printk(KERN_DEBUG LOGNAME ": Int - L64021: %02X %02X %02X %02X %02X\n", intr[0], intr[1], intr[2], intr[3], intr[4]);
                    978: //printk(KERN_DEBUG LOGNAME ": Int - L64021 Aux/Data Fifo: %02X %02X\n", 
                    979: //  DecoderReadByte(card, 0x040), 
                    980: //  DecoderReadByte(card, 0x041));
                    981: //printk(KERN_DEBUG LOGNAME ": Int - L64021 VideoES w/r addr: %08X %08X\n", 
                    982: //  (DecoderReadByte(card, 0x060) | (DecoderReadByte(card, 0x061) << 8) | (DecoderReadByte(card, 0x062) << 16)) << 2, 
                    983: //  (DecoderReadByte(card, 0x06C) | (DecoderReadByte(card, 0x06D) << 8) | (DecoderReadByte(card, 0x06E) << 16)) << 2);
                    984: 
                    985: 
                    986: //if (DecoderReadByte(card, 0x005) & 0x04) DecoderDelByte(card, 0x005, 0x04);
                    987: //if (DecoderReadByte(card, 0x005) & 0x04) DecoderWriteByte(card, 0x005, 0x03);
                    988: //DecoderMaskByte(card, 0x007, 0x0C, 1 << 2);  // Stream Select: MPEG1 System / MPEG2 Program Stream
                    989: //DecoderWriteByte(card, 0x005, 0x03);
                    990: //DecoderWriteByte(card, 0x007, 0xC7);
                    991: //printk(KERN_DEBUG LOGNAME ": Int - L64021 Channel Status: %02X %02X\n", 
                    992: //  DecoderReadByte(card, 0x007), 
                    993: //  DecoderReadByte(card, 0x005));
                    994: 
                    995: 
                    996:                if (intr[0] & 0x80) {  // new field
                    997:                        card->fields++;
                    998:                        
                    999:                        if (card->slowdown > 0) {
                   1000:                                if (card->lastslow == 0) {
                   1001:                                        DecoderWriteByte(card, 0x0ED, 0x03);  // repeat frame
                   1002:                                        card->lastslow++;
                   1003:                                } else if (card->lastslow == card->slowdown) {
                   1004:                                        DecoderWriteByte(card, 0x0ED, 0x00);  // run
                   1005:                                } else card->lastslow++;
                   1006:                        }
                   1007:                        
                   1008:                        if (card->videosteps > 0) {
                   1009:                                card->videosteps--;
                   1010:                                if (!card->videosteps) DecoderPause(card);
                   1011:                        }
                   1012: 
                   1013:                        if (card->videodelay > 0) {
                   1014: //printk(KERN_DEBUG LOGNAME ": Video delay %d\n", card->videodelay);
                   1015:                                if( (DecoderReadByte(card, 0x0ED) & 0x01) == 0x00)      {
                   1016:                                        card->videodelay--;
                   1017:                                        if(card->videodelay){
                   1018:                                                DecoderWriteByte(card, 0x0ED, 0x01);
                   1019:                                        } else {
                   1020:                                                DecoderWriteByte(card, 0x0ED, 0x00);
                   1021:                                        }
                   1022:                                }
                   1023:                        } else if (card->videorip > 0) {
                   1024: //printk(KERN_DEBUG LOGNAME ": Video rip %d\n", card->videorip);
                   1025:                                if ((DecoderReadByte(card, 0x0EC) & 0x03) == 0x00) {
                   1026:                                        if (DecoderReadWord(card, 0x096) > 5) {  // pictures in video ES channel
                   1027:                                                card->videorip--;
                   1028:                                                if(card->videorip) {
                   1029:                                                        DecoderWriteByte(card, 0x0EC, 0x01);
                   1030:                                                } else {
                   1031:                                                        DecoderWriteByte(card, 0x0EC, 0x00);
                   1032:                                                }
                   1033:                                        } else {
                   1034:                                                card->videorip = 0;
                   1035:                                                DecoderWriteByte (card, 0x0EC, 0x00);
                   1036:                                        }
                   1037:                                }
                   1038:                        }
                   1039: 
                   1040: 
                   1041:                        i = (DecoderReadByte(card, 0x113) & 0xFC) | (DecoderReadByte(card, 0x114) & 0x01);
                   1042:                        v = DecoderGetVideoESLevel(card);
                   1043:                        if (card->startingV) {
                   1044:                                vs = card->VideoESSize;
                   1045:                                if (vs > 0) vp = (100 * v) / vs;
                   1046:                                else vp = 0;
                   1047:                                if (vp > 60) {
                   1048: printk(KERN_DEBUG LOGNAME ": Delayed Video Decoder start\n");
                   1049:                                        card->startingV = 0;
                   1050:                                        DecoderStartDecode(card);
                   1051: //DecoderWriteByte(card, 0x0EC, 0x05);  // Skip B Frames
                   1052: //DecoderWriteByte(card, 0x0EC, 0x06);  // Skip B and P Frames
                   1053: //DecoderWriteByte(card, 0x0EE, 0x03);  // Rip forward mode
                   1054: //DecoderWriteByte(card, 0x0ED, 0x03);  // Repeat frame mode
                   1055: //          DecoderSetVideoPanic(card, 1, 3);  // video panic at 3 pictures
                   1056:                                        //DecoderSetVideoPanic(card, 0, DecoderGetVideoESSize(card) / 4);  // video panic at 25 percent
                   1057:                                        //VideoSetBackground(card, 0, 0, 0, 0);      // Video on black
                   1058:                                }
                   1059:                        }
                   1060:                        a = DecoderGetAudioESLevel(card);
                   1061:                        if (card->startingA) {
                   1062:                                as = card->AudioESSize;
                   1063:                                if (as > 0) ap = (100 * a) / as;
                   1064:                                else ap = 0;
                   1065:                                if (ap > 60) {
                   1066: printk(KERN_DEBUG LOGNAME ": Delayed Audio Decoder start\n");
                   1067:                                        AudioSetPlayMode(card, AUDIO_PLAY);
                   1068:                                        if (!AudioStart(card)) {
                   1069:                                                card->startingA = 0;
                   1070:                                        }
                   1071:                                }
                   1072:                        }
                   1073:                        if (card->fields >= 250) {  // 5 seconds (PAL)
                   1074:                                //SCR_base = DecoderReadByte(card, 0x09);
                   1075:                                //SCR_base = SCR_base | (DecoderReadMWord(card, 0x0A) << 8);
                   1076:                                SCR_base = DecoderReadSCR(card, 0x009);
                   1077:                                SCR_compareA = DecoderReadSCR(card, 0x014);
                   1078:                                SCR_compareV = DecoderReadSCR(card, 0x00D);
                   1079:                                if (DecoderReadByte(card, 0x013) & 0x03)
                   1080: //                                     printk(KERN_DEBUG LOGNAME ": SCR 0x%08X, videocmp=0x%08X, audiocmp=0x%08X %02X\n", SCR_base, SCR_compareV, SCR_compareA, DecoderReadByte(card, 0x013));
                   1081:                                //if (DecoderReadByte(card, 0x013) & 0x03)
                   1082:                                        //printk(KERN_DEBUG LOGNAME ": SCR 0x%08X, videocmp=0x%08X, audiocmp=0x%08X %02X\n", SCR_base, DecoderReadDWord(card, 0x00D), DecoderReadDWord(card, 0x014), DecoderReadByte(card, 0x013));
                   1083:                                card->fields = 0;
                   1084:                        }
                   1085:                }
                   1086: 
                   1087:                if (intr[0] & 0x04) {  // First Slice Start Code
                   1088: //printk(KERN_DEBUG LOGNAME ": Int - First Slice Start Code\n");
                   1089:                        if (card->showvideo) {
                   1090:                                // Unmute card video if first picture slice detected
                   1091:                                VideoSetBackground(card, 0, 0, 0, 0);      // Video on black
                   1092:                                card->showvideo = 0;
                   1093:                        }
                   1094:                }
                   1095:                
                   1096:                if (intr[0] & 0x02 ) {  // Aux/User Data Fifo
                   1097: //               printk(KERN_DEBUG LOGNAME ": Int - Aux/Data FIFO Ready\n");
                   1098:                        used = 0;
                   1099:                        while ( (used++ < 1000) && 
                   1100:                                (layer = DecoderReadByte(card, 0x040)) & 0x03){
                   1101:                                card->AuxFifo[card->AuxFifoHead] = ((layer << 6) & 0x0700) | DecoderReadByte(card, 0x043);
                   1102:                                card->AuxFifoHead = (card->AuxFifoHead + 1) & FIFO_MASK;
                   1103:                        }
                   1104:                        if (used < 1000) DecoderReadAuxFifo(card);
                   1105:                        used = 0;
                   1106: 
                   1107:                        while ( (used++ < 1000) && 
                   1108:                                (layer = DecoderReadByte(card, 0x041)) & 0x03){
                   1109:                                card->DataFifo[card->DataFifoHead] = ((layer << 6) & 0x0300) | DecoderReadByte(card, 0x043);
                   1110:                                card->DataFifoHead = (card->DataFifoHead + 1) & FIFO_MASK;
                   1111:                        }
                   1112:                        if (used < 1000 ) DecoderReadDataFifo(card);
                   1113:                }
                   1114: 
                   1115:                if ((intr[0] & 0x01) != card->intdecodestatus) {  // decode status
                   1116:                        card->intdecodestatus = intr[0] & 0x01;
                   1117: printk(KERN_DEBUG LOGNAME ": Int - decode status now %s\n", ((card->intdecodestatus) ? "running" : "stopped"));
                   1118:                        if (card->intdecodestatus) {  // now running
                   1119: //        DecoderSetVideoPanic(card, 1, 3);  // video panic at 3 pictures
                   1120:                                DecoderSetVideoPanic(card, 0, card->VideoESSize / 4);  
                   1121:                        card->showvideo = 1;
                   1122:                                //VideoSetBackground(card, 0, 0, 0, 0);      // Video on black
                   1123:                        } else {  // now stopped
                   1124:                                if (card->closing) {
                   1125:                                        card->closing = 0;
                   1126:                                        CloseCard(card);
                   1127:                                } 
                   1128:                        }
                   1129:                 
                   1130:                }
                   1131: 
                   1132: //             if (intr[1] & 0x80) {  // SCR compare
                   1133: //printk(KERN_DEBUG LOGNAME ": Int - SCR compare\n");
                   1134:                        //DecoderDelByte(card, 0x013, 0x02);
                   1135:                        //VideoSetBackground(card, 0, 0, 0, 0);      // Video on black
                   1136: //             }
                   1137: //             if (intr[1] & 0x40) {  // SCR Overflow
                   1138: //printk(KERN_DEBUG LOGNAME ": Int - SCR Overflow\n");
                   1139: //             }
                   1140: //    if (intr[1] & 0x20) {  // Begin Vertical Blank
                   1141: //    }
                   1142:                if (intr[1] & 0x10) {  // Begin Active Video
                   1143:                        if (card->highlight_valid) {
                   1144:                                for (i = 0; i < 10; i++) DecoderWriteByte(card, 0x1C0 + i, card->highlight[i]);
                   1145:                                card->highlight_valid = 0;
                   1146:                        }
                   1147:                }
                   1148:                //if (intr[1] & 0x08) {  // SPU Start Code Detected
                   1149:           //printk(KERN_DEBUG LOGNAME ": Int - SPU Start Code Detected\n");
                   1150:                //}
                   1151:                if (intr[1] & 0x04) {  // SCR compare audio
                   1152: printk(KERN_DEBUG LOGNAME ": Int - SCR compare audio\n");
                   1153:                        DecoderDelByte(card, 0x013, 0x01);
                   1154:                        AudioStart(card);
                   1155:                }
                   1156:                // both follwing are used in A/V-sync below
                   1157: //             if (intr[1] & 0x02) {  // picture start code detected
                   1158: //printk(KERN_DEBUG LOGNAME ": Int - picture start code detected\n");
                   1159: //             }
                   1160: //             if (intr[1] & 0x01) {  // audio sync code detected
                   1161: //printk(KERN_DEBUG LOGNAME ": Int - audio sync code detected\n");
                   1162: //             }
                   1163: 
                   1164:     //      if (! card->stream.audio.valid) DecoderReadAudioInfo(card);
                   1165: 
                   1166:                if (intr[2] & 0x20) {  // DSI PES data ready
                   1167: //printk(KERN_DEBUG LOGNAME ": Int - DSI PES data ready\n");
                   1168:                        DecoderReadNavipack(card);
                   1169:                }
                   1170: 
                   1171:                if (intr[2] & 0x06) {  // Audio / Video PES data ready
                   1172:                  ReadPESHeaders(card);
                   1173:                }
                   1174: 
                   1175:                if (intr[3] & 0x40) {  // CSS
                   1176:                        card->css.status = DecoderReadByte(card, 0x0B0);
                   1177: printk(KERN_DEBUG LOGNAME ": Int - CSS Status 0x%02X\n", card->css.status);
                   1178:                        if (card->css.status&0x01) card->css.ChallengeReady = 1;  // challenge ready
                   1179:                        if (card->css.status&0x02) card->css.ResponseReady = 1;   // response ready
                   1180:                        if (card->css.status&0x04) card->css.DiskKey = 1;         // Disk key ready
                   1181:                        if (card->css.status&0x08) card->css.Error = 1;           // Disk key error
                   1182:                        if (card->css.status&0x10) card->css.TitleKey = 1;        // Title key ready
                   1183:                        if (card->css.status&0x20) card->css.TitleKeyDiff = 1;    // Title key error
                   1184:                }
                   1185: 
                   1186: 
                   1187:                if (intr[3] & 0x30) {  // Audio/Video ES channel buffer underflow
                   1188: //printk(KERN_DEBUG LOGNAME ": Int - ES channel buffer underflow\n");
                   1189:                        if (card->closing) {
                   1190:                                card->closing = 0;
                   1191:                                CloseCard(card);
                   1192:                        }
                   1193:                }
                   1194: 
                   1195: //    if (intr[3] & 0x08) {  // Data Dump channel PES data ready
                   1196: //    }
                   1197: 
                   1198:                if (intr[4] & 0x10 ) {  // SPU decode error
                   1199: printk(KERN_DEBUG LOGNAME ": Int - SPU decode error: (1CA)=0x%02X\n", DecoderReadByte(card, 0x1CA));
                   1200:                        DecoderDelByte(card, 0x1A0, 0x01);  // SPU decode stop
                   1201:                        DecoderSetByte(card, 0x1A0, 0x01);  // SPU decode start
                   1202:                }
                   1203:                
                   1204:                // Audio / Video Syncronisation
                   1205: 
                   1206:                if (card->videosync && !card->videorip && !card->videodelay && !card->slowdown) {
                   1207:                        SCR_base = DecoderReadSCR(card, 0x009);
                   1208:                        SCR_compareV = DecoderReadSCR(card, 0x00D);
                   1209: //printk(KERN_DEBUG LOGNAME ": Sync: SCR = %08X\n", SCR_compareV);
                   1210:                        if (intr[1] & 0x02) {  // picture start code detected
                   1211: //printk(KERN_DEBUG LOGNAME ": Sync: picture start code\n");
                   1212:                                DecoderMaskByte(card, 0x011, 0x03, 0x01);   // Set SCR compare/capture mode to capture
                   1213:                                DecoderSetByte(card, 0x11, 0x04);           // Set "capture on picture start"
                   1214:                                if (intr[1] & 0x01) {  // audio sync code detected
                   1215: //printk(KERN_DEBUG LOGNAME ": Sync: audio sync code, too\n");
                   1216:                                        DecoderSetByte(card, 0x11, 0x08);         // Set "capture on audio sync code"
                   1217:                                }
                   1218:                                VideoAddr = DecoderReadRWAddr(card,0x080);
                   1219:                                if (PTSGetPTS(&card->VideoPTSStore, VideoAddr, &PTS)) {
                   1220: //printk(KERN_DEBUG LOGNAME ": Sync: video PTS found for 0x%08X = %08X\n", VideoAddr, PTS);
                   1221:                                        card->oldVPTS = card->VPTS;
                   1222:                                        card->VPTS = PTS;
                   1223:                                        card->VSCR = ((long)SCR_compareV - (long)PTS) / 2;
                   1224: //                                     card->VideoTime = ISRTime;
                   1225:                                }
                   1226:                        } else if (intr[1] & 0x01) {  // audio sync code detected
                   1227: //printk(KERN_DEBUG LOGNAME ": Sync: audio sync code, only\n");
                   1228:                                DecoderMaskByte(card, 0x011, 0x03, 0x01);   // Set SCR compare/capture mode to capture
                   1229:                                DecoderSetByte(card, 0x11, 0x08);           // Set "capture on audio sync code"
                   1230:                                AudioAddr = DecoderReadRWAddr(card,0x083);
                   1231: //printk(KERN_DEBUG LOGNAME ": Sync: audio PTS search for 0x%08X\n", AudioAddr);
                   1232:                                if (PTSGetPTS(&card->AudioPTSStore, AudioAddr, &PTS)) {
                   1233: //printk(KERN_DEBUG LOGNAME ": Sync: audio PTS found for 0x%08X = %08X\n", AudioAddr, PTS);
                   1234:                                        card->oldAPTS = card->APTS;
                   1235:                                        card->APTS = PTS;
                   1236:                                        card->ASCR = ((long)SCR_compareV - (long)PTS) / 2;
                   1237: //                                     card->AudioTime = ISRTime;
                   1238:                                } else {
                   1239:                                        card->ASCR = 0x7FFFFFFF;
                   1240:                                }
                   1241: 
                   1242:                                if (card->VSCR != 0x7FFFFFFF) {
                   1243:                                        if (card->ASCR != 0x7FFFFFFF) {
                   1244:                                                DeltaSyncTime = ISRTime - card->SyncTime;
                   1245:                                                card->SyncTime = ISRTime;
                   1246:        
                   1247:                                                // Calculate Audio and Video SCR difference
                   1248:                                                Offset = (card->ASCR - card->VSCR - (10 * 736)) / 736;
                   1249: //printk(KERN_DEBUG LOGNAME ": Sync: compare SCRs: Audio = %ld  Video = %ld  -> %ld\n", card->ASCR, card->VSCR, Offset);
                   1250:        
                   1251:                                                // if the APTS and SCR are off update SCR to keep SubPic synced
                   1252:                                                if ((SCR_compareV > card->APTS) || ((card->APTS - SCR_compareV) > 10000)) {
                   1253:                                                        Offset = 0;
                   1254:                                                        SetSCR(card, card->APTS);
                   1255:                                                }
                   1256:        
                   1257:                                                // if more than 3 frames away
                   1258:                                                if ((Offset > 3) || (Offset < -3)) {
                   1259:                                                        if (Offset > 0 ) {
                   1260:                                                                card->videodelay = 0;
                   1261:                                                                if (Offset < 100) {
                   1262:                                                                        if (Offset < 10) {
                   1263:                                                                                card->videodelay = 1;
                   1264:                                                                        } else {
                   1265:                                                                                card->videodelay = Offset / 2;
                   1266:                                                                                if (card->videodelay > 20) {
                   1267:                                                                                        card->videodelay = 20;
                   1268:                                                                                }
                   1269:                                                                        }
                   1270: printk(KERN_DEBUG LOGNAME ": <<< Pausing  %d\n", card->videodelay);
                   1271:                                                                } else {
                   1272:                                                                }
                   1273:                                                        } else {
                   1274:                                                                card->videorip = 0;
                   1275:                                                                if (Offset > -100) {
                   1276:                                                                        if (Offset < -10) {
                   1277:                                                                                card->videorip = 10;
                   1278:                                                                        } else {
                   1279:                                                                                card->videorip = 3;
                   1280:                                                                        }
                   1281: printk(KERN_DEBUG LOGNAME ": >>> FForward  %d\n", card->videorip);
                   1282:                                                                }
                   1283:                                                        }
                   1284:                                                } else {
                   1285:                                                }
                   1286:                                                card->VSCR = 0x7FFFFFFF;
                   1287:                                        }
                   1288:                                }
                   1289:                        }
                   1290:                }
                   1291:        }
                   1292:        DecoderWriteByte(card, 0x006, 0x01);  // Clear Interrupt Pin
                   1293: }
                   1294: 
                   1295: // Enable the IRQ Masks
                   1296: void L64021InstallIntr(struct cvdv_cards *card) {
                   1297:        u8 data;
                   1298:        
                   1299:        data=0;
                   1300:        data |= 0x80;  // new field
                   1301:        data |= 0x40;  // audio sync recovery
                   1302:        data |= 0x20;  // SPU SCR compare
                   1303:        // data |= 0x10;  // SDRAM Transfer Done
                   1304:        // data |= 0x08;  // Sequence End Code Detect
                   1305:        data |= 0x04;  // First Slice Start Code
                   1306:        data |= 0x02;  // Aux/User Data Fifo
                   1307:        data |= 0x01;  // decode status
                   1308:        DecoderWriteByte(card, 0x000, (~data) & 0xFF);
                   1309: 
                   1310:        data = 0;
                   1311:        // data |= 0x80;  // SCR compare
                   1312:        // data |= 0x40;  // SCR Overflow
                   1313:        // data |= 0x20;  // Begin Vertical Blank
                   1314:        data |= 0x10;  // Begin Active Video
                   1315:        data |= 0x08;  // SPU Start Code Detected
                   1316:        data |= 0x04;  // SCR compare audio
                   1317:        data |= 0x02;  // picture start code detected
                   1318:        data |= 0x01;  // audio sync code detected
                   1319:        DecoderWriteByte(card, 0x001, (~data) & 0xFF);
                   1320: 
                   1321:        data = 0;
                   1322:        // data |= 0x80;  // DTS video event
                   1323:        // data |= 0x40;  // DTS audio event
                   1324:        data |= 0x20;  // DSI PES data ready
                   1325:        // data |= 0x10;  // Seq end code in video channel
                   1326:        data |= 0x08;  // SPU PES data ready
                   1327:        data |= 0x04;  // Video PES data ready
                   1328:        data |= 0x02;  // Audio PES data ready
                   1329:        // data |= 0x01;  // Pack data ready
                   1330:        DecoderWriteByte(card, 0x002, (~data) & 0xFF);
                   1331: 
                   1332:        data = 0;
                   1333:        // data |= 0x80;  // Reserved
                   1334:        data |= 0x40;  // CSS
                   1335:        data |= 0x20;  // Video ES channel buffer underflow
                   1336:        data |= 0x10;  // Audio ES channel buffer underflow
                   1337:        // data |= 0x08;  // Data Dump channel PES data ready
                   1338:        data |= 0x04;  // SPU channel buffer overflow
                   1339:        data |= 0x02;  // Video ES channel buffer overflow
                   1340:        data |= 0x01;  // Audio ES channel buffer overflow
                   1341:        DecoderWriteByte(card, 0x003, (~data) & 0xFF);
                   1342: 
                   1343:        data = 0;
                   1344: //     data |= 0x80;  // S/PDIF channel buffer underflow
                   1345:        // data |= 0x40;  // packet error
                   1346:        // data |= 0x20;  // reserved
                   1347:        data |= 0x10;  // SPU decode error
                   1348: //     data |= 0x08;  // Audio Sync error
                   1349: //     data |= 0x04;  // Audio CRC or illegal bit error
                   1350: //     data |= 0x02;  // context error
                   1351: //     data |= 0x01;  // VLC or Run length error
                   1352:        DecoderWriteByte(card, 0x004, (~data) & 0xFF);
                   1353:        card->IntInstalled = 1;
                   1354: }
                   1355: 
                   1356: int L64021RemoveIntr(struct cvdv_cards *card) {
                   1357:        // Disable the IRQ Masks
                   1358:        DecoderWriteByte(card, 0x000, 0xFF);   // No ints
                   1359:        DecoderWriteByte(card, 0x001, 0xFF);   // No ints
                   1360:        DecoderWriteByte(card, 0x002, 0xFF);   // No ints
                   1361:        DecoderWriteByte(card, 0x003, 0xFF);   // No ints
                   1362:        DecoderWriteByte(card, 0x004, 0xFF);   // No ints
                   1363:        card->IntInstalled = 0;
                   1364:        return 0;
                   1365: }
                   1366: 
                   1367: int L64021Reset(struct cvdv_cards *card) {
                   1368:        L64021RemoveIntr(card);  // Stop interrupts
                   1369:        // Reset
                   1370:        printk(KERN_DEBUG LOGNAME ": L64021 Software reset...\n");
                   1371:        //DecoderSetByte(card, 0x007, 0x20);  // reset on
                   1372:        DecoderMaskByte(card, 0x007, 0xE2, 0xE2);  // reset on
                   1373:        while (!(DecoderReadByte(card, 0x007) & 0x02)) ;  // wait until reset is done
                   1374:        //DecoderDelByte(card, 0x007, 0x20);  // reset off
                   1375:        DecoderMaskByte(card, 0x007, 0xE2, 0xC2);  // reset off
                   1376:        printk(KERN_DEBUG LOGNAME ": L64021 Software reset done.\n");
                   1377:        L64021RemoveIntr(card);  // Stop interrupts
                   1378:        DecoderStopChannel(card);
                   1379:        DecoderStopDecode(card);
                   1380:        DecoderStreamReset(card);
                   1381:        DecoderSetupReset(card);
                   1382:        printk(KERN_INFO LOGNAME ": L64021 Rev. 0x%02X reset successfully.\n", DecoderReadByte(card, 0x0F5));
                   1383:        return 0;
                   1384: }
                   1385: 
                   1386: int L64021Setup(struct cvdv_cards *card) {
                   1387: printk(KERN_DEBUG LOGNAME ": -- L64021Setup\n");
                   1388:        DecoderWriteByte(card, 0x0C1, 0x88);  // 
                   1389:        switch (card->videomode) {
                   1390:                case NTSC:  // NTSC M, N. America, Taiwan, Japan
                   1391:                        DecoderMaskByte(card, 0x122, 0x03, 0x01);  // Television Standard: NTSC
                   1392:                        /* Default values:
                   1393:                        DecoderWriteByte(card, 0x116, 90);    // Main Reads per Line
                   1394:                        DecoderWriteByte(card, 0x11A, 4);     // Vline Count Init
                   1395:                        DecoderWriteByte(card, 0x11C, 0x13);  // Pixel State Reset Value / BT.656 Mode / Sync Active Low
                   1396:                        DecoderWriteByte(card, 0x129, 23);    // Start- and End Row
                   1397:                        DecoderWriteByte(card, 0x12A, 262 & 0xFF);
                   1398:                        DecoderWriteByte(card, 0x12B, (262>>4)&0x70);
                   1399:                        DecoderWriteByte(card, 0x12C, 244 & 0xFF);    // Start- and End Column
                   1400:                        DecoderWriteByte(card, 0x12D, 1683 & 0xFF);
                   1401:                        DecoderWriteByte(card, 0x12E, ((1683>>4)&0x70)|((244>>8)&0x07));
                   1402:                        DecoderWriteByte(card, 0x132, 240 & 0xFF);    // SAV Column
                   1403:                        DecoderWriteByte(card, 0x133, 1684 & 0xFF);   // EAV Column
                   1404:                        DecoderWriteByte(card, 0x134, ((1684>>4)&0x70)|((240>>8)&0x07));
                   1405:                        DecoderWriteByte(card, 0x12F, (21&0x1F)|((262>>3)&0x20)|(1<<6)|((265>>1)&0x80));  // VCode Zero...
                   1406:                        DecoderWriteByte(card, 0x130, 262&0xFF);      // ... and VCode Even
                   1407:                        DecoderWriteByte(card, 0x131, 265&0xFF);      // ... and FCode
                   1408:                        */
                   1409:                        break;
                   1410:                case PAL:  // PAL-B, D, G, H, I, Europe, Asia
                   1411:                        DecoderMaskByte(card, 0x122, 0x03, 0x02);  // Television Standard: PAL
                   1412:                        /* Default values:
                   1413:                        DecoderWriteByte(card, 0x116, 90);    // Main Reads per Line
                   1414:                        DecoderWriteByte(card, 0x11A, 1);     // Vline Count Init
                   1415:                        DecoderWriteByte(card, 0x11C, 0x13);  // Pixel State Reset Value / BT.656 Mode / Sync Active Low
                   1416:                        DecoderWriteByte(card, 0x129, 23);    // Start- and End Row
                   1417:                        DecoderWriteByte(card, 0x12A, 310 & 0xFF);
                   1418:                        DecoderWriteByte(card, 0x12B, (310>>4)&0x70);
                   1419:                        DecoderWriteByte(card, 0x12C, 264 & 0xFF);    // Start- and End Column
                   1420:                        DecoderWriteByte(card, 0x12D, 1703 & 0xFF);
                   1421:                        DecoderWriteByte(card, 0x12E, ((1703>>4)&0x70)|((264>>8)&0x07));
                   1422:                        DecoderWriteByte(card, 0x132, 260 & 0xFF);    // SAV Column
                   1423:                        DecoderWriteByte(card, 0x133, 1704 & 0xFF);   // EAV Column
                   1424:                        DecoderWriteByte(card, 0x134, ((1704>>4)&0x70)|((260>>8)&0x07));
                   1425:                        DecoderWriteByte(card, 0x12F, (21&0x1F)|((310>>3)&0x20)|(0<<6)|((312>>1)&0x80));  // VCode Zero...
                   1426:                        DecoderWriteByte(card, 0x130, 310&0xFF);      // ... and VCode Even
                   1427:                        DecoderWriteByte(card, 0x131, 312&0xFF);      // ... and FCode
                   1428:                        */
                   1429:                        break;
                   1430:                case PAL60:  // PAL 60Hz
                   1431:                case NTSC60:  // NTSC 60Hz, USA HDTV
                   1432:                case PALM:  // PAL-M normal, Brazil
                   1433:                case PALM60:  // PAL-M HDTV, Brazil
                   1434:                case PALN:  // PAL-N, Uruguay, Paraguay
                   1435:                case PALNc:  // PAL-Nc, Argentinia
                   1436:                default:  // TODO: set mode according to other standards
                   1437:                        DecoderMaskByte(card, 0x122, 0x03, 0x00);  // Television Standard: User programmed
                   1438:                        DecoderWriteByte(card, 0x116, 90);    // Main Reads per Line
                   1439:                        DecoderWriteByte(card, 0x11A, 1);     // Vline Count Init
                   1440:                        DecoderWriteByte(card, 0x11C, 0x13);  // Pixel State Reset Value / BT.656 Mode / Sync Active Low
                   1441:                        DecoderWriteByte(card, 0x129, 23);    // Start- and End Row
                   1442:                        DecoderWriteByte(card, 0x12A, 310 & 0xFF);
                   1443:                        DecoderWriteByte(card, 0x12B, (310>>4)&0x70);
                   1444:                        DecoderWriteByte(card, 0x12C, 264 & 0xFF);    // Start- and End Column
                   1445:                        DecoderWriteByte(card, 0x12D, 1703 & 0xFF);
                   1446:                        DecoderWriteByte(card, 0x12E, ((1703>>4)&0x70)|((264>>8)&0x07));
                   1447:                        DecoderWriteByte(card, 0x132, 260 & 0xFF);    // SAV Column
                   1448:                        DecoderWriteByte(card, 0x133, 1704 & 0xFF);   // EAV Column
                   1449:                        DecoderWriteByte(card, 0x134, ((1704>>4)&0x70)|((260>>8)&0x07));
                   1450:                        DecoderWriteByte(card, 0x12F, (21&0x1F)|((310>>3)&0x20)|(0<<6)|((312>>1)&0x80));  // VCode Zero...
                   1451:                        DecoderWriteByte(card, 0x130, 310&0xFF);      // ... and VCode Even
                   1452:                        DecoderWriteByte(card, 0x131, 312&0xFF);      // ... and FCode
                   1453:                        break;
                   1454:        }
                   1455:        DecoderWriteByte(card, 0x045, 0x00);  // disable compares and panic mode
                   1456:        DecoderWriteByte(card, 0x094, 0x00);    // disable TOS Detect
                   1457:        DecoderMaskByte(card, 0x109, 0x30, 0x00);  // Display Override off, don't change OSD, Background
                   1458:        DecoderWriteByte(card, 0x112, 0x00);  // Disable Horizontal 2:1 Filter
                   1459:        DecoderWriteByte(card, 0x113, 0x14);  // FreezeMode 1 / 3:2 Pulldown / Repeat First Field / Top Field First
                   1460:        DecoderWriteByte(card, 0x114, ( 5 <<3)|( 0 <<1)|( 0 <<2)|( 1 <<7));  // VideoMode/FilterEnable/FilterAB/FieldSyncEnable
                   1461:        DecoderWriteByte(card, 0x115, 0);     // Horizontal Filter Scale
                   1462:        DecoderWriteByte(card, 0x117, 0x80);  // Automatic Field Inversion Correction
                   1463: //  DecoderWriteByte(card, 0x117, 0x00);  // no Automatic Field Inversion Correction
                   1464:        DecoderWriteByte(card, 0x118, 0);     // Horizontal Pan and Scan Word Offset (signed)
                   1465:        DecoderWriteByte(card, 0x119, 0);     // Vertical Pan and Scan Line Offset
                   1466:        DecoderWriteByte(card, 0x11B, 0x00);  // Override Picture Width
                   1467: //    if (0) {  // letterbox
                   1468: //      DecoderWriteByte(card, 0x114, (DecoderReadByte(card, 0x114) & ~0x78) | 0x40);  // mode 8
                   1469: //      DecoderWriteByte(card, 0x129, 0x35);
                   1470: //      DecoderWriteByte(card, 0x12A, 0xE7);
                   1471: //      DecoderWriteByte(card, 0x114, DecoderReadByte(card, 0x114) & ~0x77);  // ???
                   1472: //    } else {
                   1473: //      if (0) {  // MPEG-1
                   1474: //        DecoderWriteByte(card, 0x114, (DecoderReadByte(card, 0x114) & ~0x78) | 0x10);  // mode 2
                   1475: //      } else {  // MPEG-2
                   1476: //        DecoderWriteByte(card, 0x114, (DecoderReadByte(card, 0x114) & ~0x78) | 0x28);  // mode 5
                   1477: //      }
                   1478: //    }
                   1479:        L64021InstallIntr(card);  // Set the interrupt masks, again
                   1480:        
                   1481:        return 0;
                   1482: }
                   1483: 
                   1484: int L64021Init(struct cvdv_cards *card) {
                   1485: printk(KERN_DEBUG LOGNAME ": -- L64021Init\n");
                   1486:        L64021Reset(card);
                   1487:        L64021Setup(card);
                   1488:        VideoSetBackground(card, 1, 0, 0, 0);  // black
                   1489:        DecoderWriteByte(card, 0x135, 0x01);  // Enable Video Out, Disable SPU Mix
                   1490:        DecoderWriteByte(card,0x11C,0x13);  // Pixel State Reset Value / BT.656 Mode / Sync Active Low
                   1491:        L64021InstallIntr(card);
                   1492:        return 0;
                   1493: }
                   1494: 
                   1495: 

LinuxTV legacy CVS <linuxtv.org/cvs>