Changeset 3168 for trunk/reader-common.c


Ignore:
Timestamp:
09/22/10 19:16:59 (10 years ago)
Author:
_network
Message:

merge modular branch with trunk

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/reader-common.c

    r3161 r3168  
    225225    cs_ri_brk(reader, 0);
    226226    do_emm_from_file(reader);
    227     switch(reader->card_system)
    228     {
    229       case SC_NAGRA:
    230         nagra2_card_info(reader); break;
    231       case SC_IRDETO:
    232         irdeto_card_info(reader); break;
    233       case SC_CRYPTOWORKS:
    234         cryptoworks_card_info(reader); break;
    235       case SC_VIACCESS:
    236         viaccess_card_info(reader); break;
    237       case SC_CONAX:
    238         conax_card_info(reader); break;
    239       case SC_VIDEOGUARD2:
    240         videoguard2_card_info(reader); break;
    241       case SC_VIDEOGUARD1:
    242         videoguard1_card_info(reader); break;
    243       case SC_VIDEOGUARD12:
    244         videoguard12_card_info(reader); break;
    245       case SC_SECA:
    246          seca_card_info(reader); break;
    247       case SC_DRE:
    248          dre_card_info(); break;
    249       case SC_TONGFANG:
    250          tongfang_card_info(reader); break;
    251     }
     227
     228    if (cardsystem[reader->card_system-1].card_info) {
     229        cardsystem[reader->card_system-1].card_info(reader);
     230    }
    252231  }
    253232}
     
    255234static int reader_get_cardsystem(struct s_reader * reader, ATR atr)
    256235{
    257 
    258     if (nagra2_card_init(reader, atr))
    259         reader->card_system=SC_NAGRA;
    260     else if (irdeto_card_init(reader, atr))
    261         reader->card_system=SC_IRDETO;
    262     else if (conax_card_init(reader, atr))
    263         reader->card_system=SC_CONAX;
    264     else if (cryptoworks_card_init(reader, atr))
    265         reader->card_system=SC_CRYPTOWORKS;
    266     else if (seca_card_init(reader, atr))
    267         reader->card_system=SC_SECA;
    268     else if (viaccess_card_init(reader, atr))
    269         reader->card_system=SC_VIACCESS;
    270     else if (videoguard1_card_init(reader, atr))
    271             reader->card_system=SC_VIDEOGUARD1;
    272     else if (videoguard12_card_init(reader, atr))
    273             reader->card_system=SC_VIDEOGUARD12;
    274     else if (videoguard2_card_init(reader, atr))
    275         reader->card_system=SC_VIDEOGUARD2;
    276     else if (dre_card_init(reader, atr))
    277         reader->card_system=SC_DRE;
    278     else if (tongfang_card_init(reader, atr))
    279         reader->card_system=SC_TONGFANG;
    280     else
     236    int i;
     237    for (i=0; i<CS_MAX_MOD; i++) {
     238        if (cardsystem[i].card_init) {
     239            if (cardsystem[i].card_init(reader, atr)) {
     240                reader->card_system=i+1;
     241                cs_log("found cardsystem");
     242                break;
     243            }
     244        }
     245    }
     246
     247    if (reader->card_system==0)
    281248        cs_ri_log(reader, "card system not supported");
    282249
    283250    cs_ri_brk(reader, 1);
     251
    284252    return(reader->card_system);
    285253}
     
    397365  // some systems eg. nagra2/3 needs post process after receiving cw from card
    398366  // To save ECM/CW time we added this function after writing ecm answer
    399   switch(reader->card_system)
    400     {
    401       case SC_NAGRA:
    402         nagra2_post_process(reader); break;
    403       default: break;
    404     }
     367
     368    if (cardsystem[reader->card_system-1].post_process) {
     369        cardsystem[reader->card_system-1].post_process(reader);
     370    }
    405371}
    406372
     
    415381      client[cs_idx].last_caid=er->caid;
    416382      client[cs_idx].last=time((time_t)0);
    417       switch(reader->card_system)
    418       {
    419         case SC_NAGRA:
    420           rc=(nagra2_do_ecm(reader, er)) ? 1 : 0; break;
    421         case SC_IRDETO:
    422           rc=(irdeto_do_ecm(reader, er)) ? 1 : 0; break;
    423         case SC_CRYPTOWORKS:
    424           rc=(cryptoworks_do_ecm(reader, er)) ? 1 : 0; break;
    425         case SC_VIACCESS:
    426           rc=(viaccess_do_ecm(reader, er)) ? 1 : 0; break;
    427         case SC_CONAX:
    428           rc=(conax_do_ecm(reader, er)) ? 1 : 0; break;
    429         case SC_SECA:
    430           rc=(seca_do_ecm(reader, er)) ? 1 : 0; break;
    431         case SC_VIDEOGUARD2:
    432           rc=(videoguard2_do_ecm(reader, er)) ? 1 : 0; break;
    433         case SC_VIDEOGUARD1:
    434           rc=(videoguard1_do_ecm(reader, er)) ? 1 : 0; break;
    435         case SC_VIDEOGUARD12:
    436           rc=(videoguard12_do_ecm(reader, er)) ? 1 : 0; break;
    437         case SC_DRE:
    438           rc=(dre_do_ecm(reader, er)) ? 1: 0; break;
    439         case SC_TONGFANG:
    440           rc=(tongfang_do_ecm(reader, er)) ? 1: 0; break;
    441         default:
    442           rc=0;
    443       }
     383
     384    if (cardsystem[reader->card_system-1].do_ecm)
     385        rc=cardsystem[reader->card_system-1].do_ecm(reader, er);
     386    else
     387        rc=0;
     388
    444389    }
    445390    else
     
    453398    cs_debug_mask(D_EMM,"Entered reader_get_emm_type cardsystem %i",rdr->card_system);
    454399    int rc;
    455     switch(rdr->card_system) {
    456     case SC_NAGRA:
    457       rc=nagra2_get_emm_type(ep, rdr); break;
    458     case SC_IRDETO:
    459       rc=irdeto_get_emm_type(ep, rdr); break;
    460     case SC_CRYPTOWORKS:
    461       rc=cryptoworks_get_emm_type(ep, rdr); break;
    462     case SC_VIACCESS:
    463       rc=viaccess_get_emm_type(ep, rdr); break;
    464     case SC_CONAX:
    465       rc=conax_get_emm_type(ep, rdr); break;
    466     case SC_SECA:
    467       rc=seca_get_emm_type(ep, rdr); break;
    468     case SC_VIDEOGUARD2:
    469       rc=videoguard2_get_emm_type(ep, rdr); break;
    470     case SC_VIDEOGUARD1:
    471       rc=videoguard1_get_emm_type(ep, rdr); break;
    472     case SC_VIDEOGUARD12:
    473       rc=videoguard12_get_emm_type(ep, rdr); break;
    474     case SC_DRE:
    475       rc=dre_get_emm_type(ep, rdr); break;
    476     case SC_TONGFANG:
    477       rc=tongfang_get_emm_type(ep, rdr); break;
    478     default:
    479       rc=0;
    480   }
     400
     401    if (rdr->card_system<1)
     402        return 0;
     403
     404    if (cardsystem[rdr->card_system-1].get_emm_type)
     405        rc=cardsystem[rdr->card_system-1].get_emm_type(ep, rdr);
     406    else
     407        rc=0;
     408
    481409    return rc;
    482410}
    483411
    484412int get_cardsystem(ushort caid) {
    485     switch(caid >> 8) {
    486         case 0x01:
    487             return SC_SECA;
    488         case 0x05:
    489             return SC_VIACCESS;
    490         case 0x06:
    491             return SC_IRDETO;
    492         case 0x09:
    493             if(caid == 0x0969 ) {
    494                           return SC_VIDEOGUARD1;
    495                         }
    496                         else {
    497                           return SC_VIDEOGUARD2;
    498                         };
    499         case 0x0B:
    500             return SC_CONAX;
    501         case 0x0D:
    502             return SC_CRYPTOWORKS;
    503         case 0x17:
    504             return SC_IRDETO;
    505         case 0x18:
    506             return SC_NAGRA;
    507         case 0x4A:
    508             return SC_DRE;
    509         case 0x4B:
    510             return SC_TONGFANG;
    511         default:
    512             return 0;
    513     }
     413    int i,j;
     414    for (i=0; i<CS_MAX_MOD; i++) {
     415        if (cardsystem[i].caids) {
     416            for (j=0;j<2;j++) {
     417                if ((cardsystem[i].caids[j]==caid >> 8)) {
     418                    return i+1;
     419                }
     420            }
     421        }
     422    }
     423    return 0;
    514424}
    515425
     
    518428    filter[1]=0;
    519429
    520     switch(rdr->card_system) {
    521         case SC_NAGRA:
    522             nagra2_get_emm_filter(rdr, filter);
    523             break;
    524         case SC_IRDETO:
    525             irdeto_get_emm_filter(rdr, filter);
    526             break;
    527         case SC_CRYPTOWORKS:
    528             cryptoworks_get_emm_filter(rdr, filter);
    529             break;
    530         case SC_VIACCESS:
    531             viaccess_get_emm_filter(rdr, filter);
    532             break;
    533         case SC_CONAX:
    534             conax_get_emm_filter(rdr, filter);
    535             break;
    536         case SC_SECA:
    537             seca_get_emm_filter(rdr, filter);
    538             break;
    539         case SC_VIDEOGUARD2:
    540             videoguard2_get_emm_filter(rdr, filter);
    541             break;
    542                 case SC_VIDEOGUARD1:
    543                         videoguard1_get_emm_filter(rdr, filter);
    544                         break;
    545                 case SC_VIDEOGUARD12:
    546                         videoguard12_get_emm_filter(rdr, filter);
    547                         break;
    548         case SC_DRE:
    549             dre_get_emm_filter(rdr, filter);
    550             break;
    551         default:
    552             break;
     430    if (cardsystem[rdr->card_system-1].get_emm_filter) {
     431        cardsystem[rdr->card_system-1].get_emm_filter(rdr, filter);
    553432    }
    554433
     
    566445      return 3;
    567446
    568     switch(reader->card_system)
    569     {
    570       case SC_NAGRA:
    571         rc=nagra2_do_emm(reader, ep); break;
    572       case SC_IRDETO:
    573         rc=irdeto_do_emm(reader, ep); break;
    574       case SC_CRYPTOWORKS:
    575         rc=cryptoworks_do_emm(reader, ep); break;
    576       case SC_VIACCESS:
    577         rc=viaccess_do_emm(reader, ep); break;
    578       case SC_CONAX:
    579         rc=conax_do_emm(reader, ep); break;
    580       case SC_SECA:
    581         rc=seca_do_emm(reader, ep); break;
    582       case SC_VIDEOGUARD2:
    583         rc=videoguard2_do_emm(reader, ep); break;
    584       case SC_VIDEOGUARD1:
    585         rc=videoguard1_do_emm(reader, ep); break;
    586       case SC_VIDEOGUARD12:
    587         rc=videoguard12_do_emm(reader, ep); break;
    588       case SC_DRE:
    589         rc=dre_do_emm(reader, ep); break;
    590       case SC_TONGFANG:
    591         rc=tongfang_do_emm(reader, ep); break;
    592       default: rc=0;
    593     }
     447    if (cardsystem[reader->card_system-1].do_emm)
     448        rc=cardsystem[reader->card_system-1].do_emm(reader, ep);
     449    else
     450        rc=0;
    594451  }
    595452  return(rc);
Note: See TracChangeset for help on using the changeset viewer.