code.vuplus.com Git - vuplus_dvbapp/blob - lib/dvb_ci/dvbci.cpp

   1 #include <fcntl.h>
   2 #include <sys/ioctl.h>
   3
   4 #include <lib/base/init.h>
   5 #include <lib/base/init_num.h>
   6 #include <lib/base/ebase.h>
   7
   8 #include <lib/base/eerror.h>
   9 #include <lib/base/nconfig.h> // access to python config
  10 #include <lib/dvb/db.h>
  11 #include <lib/dvb/pmt.h>
  12 #include <lib/dvb_ci/dvbci.h>
  13 #include <lib/dvb_ci/dvbci_session.h>
  14 #include <lib/dvb_ci/dvbci_camgr.h>
  15 #include <lib/dvb_ci/dvbci_ui.h>
  16 #include <lib/dvb_ci/dvbci_appmgr.h>
  17 #include <lib/dvb_ci/dvbci_mmi.h>
  18
  19 #include <dvbsi++/ca_program_map_section.h>
  20
  21 //#define CIDEBUG 1
  22
  23 #ifdef CIDEBUG
  24         #define eDebugCI(x...) eDebug(x)
  25 #else
  26         #define eDebugCI(x...)
  27 #endif
  28
  29 eDVBCIInterfaces *eDVBCIInterfaces::instance = 0;
  30
  31 eDVBCIInterfaces::eDVBCIInterfaces()
  32 {
  33         int num_ci = 0;
  34
  35         instance = this;
  36
  37         eDebug("scanning for common interfaces..");
  38
  39         while (1)
  40         {
  41                 struct stat s;
  42                 char filename[128];
  43                 sprintf(filename, "/dev/ci%d", num_ci);
  44
  45                 if (stat(filename, &s))
  46                         break;
  47
  48                 ePtr<eDVBCISlot> cislot;
  49
  50                 cislot = new eDVBCISlot(eApp, num_ci);
  51                 m_slots.push_back(cislot);
  52
  53                 ++num_ci;
  54         }
  55
  56         for (eSmartPtrList<eDVBCISlot>::iterator it(m_slots.begin()); it != m_slots.end(); ++it)
  57                 it->setSource(TUNER_A);
  58
  59         if (num_ci > 1) // // FIXME .. we force DM8000 when more than one CI Slot is avail
  60         {
  61                 setInputSource(0, TUNER_A);
  62                 setInputSource(1, TUNER_B);
  63                 setInputSource(2, TUNER_C);
  64                 setInputSource(3, TUNER_D);
  65         }
  66         else
  67         {
  68                 setInputSource(0, TUNER_A);
  69                 setInputSource(1, TUNER_B);
  70         }
  71
  72         eDebug("done, found %d common interface slots", num_ci);
  73 }
  74
  75 eDVBCIInterfaces::~eDVBCIInterfaces()
  76 {
  77 }
  78
  79 eDVBCIInterfaces *eDVBCIInterfaces::getInstance()
  80 {
  81         return instance;
  82 }
  83
  84 eDVBCISlot *eDVBCIInterfaces::getSlot(int slotid)
  85 {
  86         for(eSmartPtrList<eDVBCISlot>::iterator i(m_slots.begin()); i != m_slots.end(); ++i)
  87                 if(i->getSlotID() == slotid)
  88                         return i;
  89
  90         eDebug("FIXME: request for unknown slot");
  91
  92         return 0;
  93 }
  94
  95 int eDVBCIInterfaces::getSlotState(int slotid)
  96 {
  97         eDVBCISlot *slot;
  98
  99         if( (slot = getSlot(slotid)) == 0 )
 100                 return eDVBCISlot::stateInvalid;
 101
 102         return slot->getState();
 103 }
 104
 105 int eDVBCIInterfaces::reset(int slotid)
 106 {
 107         eDVBCISlot *slot;
 108
 109         if( (slot = getSlot(slotid)) == 0 )
 110                 return -1;
 111
 112         return slot->reset();
 113 }
 114
 115 int eDVBCIInterfaces::initialize(int slotid)
 116 {
 117         eDVBCISlot *slot;
 118
 119         if( (slot = getSlot(slotid)) == 0 )
 120                 return -1;
 121
 122         slot->removeService();
 123
 124         return sendCAPMT(slotid);
 125 }
 126
 127 int eDVBCIInterfaces::sendCAPMT(int slotid)
 128 {
 129         eDVBCISlot *slot;
 130
 131         if( (slot = getSlot(slotid)) == 0 )
 132                 return -1;
 133
 134         PMTHandlerList::iterator it = m_pmt_handlers.begin();
 135         while (it != m_pmt_handlers.end())
 136         {
 137                 eDVBCISlot *tmp = it->cislot;
 138                 while (tmp && tmp != slot)
 139                         tmp = tmp->linked_next;
 140                 if (tmp)
 141                 {
 142                         tmp->sendCAPMT(it->pmthandler);  // send capmt
 143                         break;
 144                 }
 145                 ++it;
 146         }
 147
 148         return 0;
 149 }
 150
 151 int eDVBCIInterfaces::startMMI(int slotid)
 152 {
 153         eDVBCISlot *slot;
 154
 155         if( (slot = getSlot(slotid)) == 0 )
 156                 return -1;
 157
 158         return slot->startMMI();
 159 }
 160
 161 int eDVBCIInterfaces::stopMMI(int slotid)
 162 {
 163         eDVBCISlot *slot;
 164
 165         if( (slot = getSlot(slotid)) == 0 )
 166                 return -1;
 167
 168         return slot->stopMMI();
 169 }
 170
 171 int eDVBCIInterfaces::answerText(int slotid, int answer)
 172 {
 173         eDVBCISlot *slot;
 174
 175         if( (slot = getSlot(slotid)) == 0 )
 176                 return -1;
 177
 178         return slot->answerText(answer);
 179 }
 180
 181 int eDVBCIInterfaces::answerEnq(int slotid, char *value)
 182 {
 183         eDVBCISlot *slot;
 184
 185         if( (slot = getSlot(slotid)) == 0 )
 186                 return -1;
 187
 188         return slot->answerEnq(value);
 189 }
 190
 191 int eDVBCIInterfaces::cancelEnq(int slotid)
 192 {
 193         eDVBCISlot *slot;
 194
 195         if( (slot = getSlot(slotid)) == 0 )
 196                 return -1;
 197
 198         return slot->cancelEnq();
 199 }
 200
 201 void eDVBCIInterfaces::ciRemoved(eDVBCISlot *slot)
 202 {
 203         if (slot->use_count)
 204         {
 205                 eDebug("CI Slot %d: removed... usecount %d", slot->getSlotID(), slot->use_count);
 206                 for (PMTHandlerList::iterator it(m_pmt_handlers.begin());
 207                         it != m_pmt_handlers.end(); ++it)
 208                 {
 209                         if (it->cislot == slot) // remove the base slot
 210                                 it->cislot = slot->linked_next;
 211                         else if (it->cislot)
 212                         {
 213                                 eDVBCISlot *prevSlot = it->cislot, *hSlot = it->cislot->linked_next;
 214                                 while (hSlot)
 215                                 {
 216                                         if (hSlot == slot) {
 217                                                 prevSlot->linked_next = slot->linked_next;
 218                                                 break;
 219                                         }
 220                                         prevSlot = hSlot;
 221                                         hSlot = hSlot->linked_next;
 222                                 }
 223                         }
 224                 }
 225                 if (slot->linked_next)
 226                         slot->linked_next->setSource(slot->current_source);
 227                 else // last CI in chain
 228                         setInputSource(slot->current_tuner, slot->current_source);
 229                 slot->linked_next = 0;
 230                 slot->use_count=0;
 231                 slot->plugged=true;
 232                 slot->user_mapped=false;
 233                 slot->removeService(0xFFFF);
 234                 recheckPMTHandlers();
 235         }
 236 }
 237
 238 static bool canDescrambleMultipleServices(int slotid)
 239 {
 240         char configStr[255];
 241         snprintf(configStr, 255, "config.ci.%d.canDescrambleMultipleServices", slotid);
 242         std::string str;
 243         ePythonConfigQuery::getConfigValue(configStr, str);
 244         if ( str == "auto" )
 245         {
 246                 std::string appname = eDVBCI_UI::getInstance()->getAppName(slotid);
 247                 if (appname.find("AlphaCrypt") != std::string::npos)
 248                         return true;
 249         }
 250         else if (str == "yes")
 251                 return true;
 252         return false;
 253 }
 254
 255 void eDVBCIInterfaces::recheckPMTHandlers()
 256 {
 257         eDebugCI("recheckPMTHAndlers()");
 258         for (PMTHandlerList::iterator it(m_pmt_handlers.begin());
 259                 it != m_pmt_handlers.end(); ++it)
 260         {
 261                 CAID_LIST caids;
 262                 ePtr<eDVBService> service;
 263                 eServiceReferenceDVB ref;
 264                 eDVBCISlot *tmp = it->cislot;
 265                 eDVBServicePMTHandler *pmthandler = it->pmthandler;
 266                 eDVBServicePMTHandler::program p;
 267                 bool plugged_cis_exist = false;
 268
 269                 pmthandler->getServiceReference(ref);
 270                 pmthandler->getService(service);
 271
 272                 eDebugCI("recheck %p %s", pmthandler, ref.toString().c_str());
 273                 for (eSmartPtrList<eDVBCISlot>::iterator ci_it(m_slots.begin()); ci_it != m_slots.end(); ++ci_it)
 274                         if (ci_it->plugged && ci_it->getCAManager())
 275                         {
 276                                 eDebug("Slot %d plugged", ci_it->getSlotID());
 277                                 ci_it->plugged = false;
 278                                 plugged_cis_exist = true;
 279                         }
 280
 281                 // check if this pmt handler has already assigned CI(s) .. and this CI(s) are already running
 282                 if (!plugged_cis_exist)
 283                 {
 284                         while(tmp)
 285                         {
 286                                 if (!tmp->running_services.empty())
 287                                         break;
 288                                 tmp=tmp->linked_next;
 289                         }
 290                         if (tmp) // we dont like to change tsmux for running services
 291                         {
 292                                 eDebugCI("already assigned and running CI!\n");
 293                                 continue;
 294                         }
 295                 }
 296
 297                 if (!pmthandler->getProgramInfo(p))
 298                 {
 299                         int cnt=0;
 300                         for (caidSet::reverse_iterator x(p.caids.rbegin()); x != p.caids.rend(); ++x, ++cnt)
 301                                 caids.push_front(*x);
 302                         if (service && cnt)
 303                                 service->m_ca = caids;
 304                 }
 305
 306                 if (service)
 307                         caids = service->m_ca;
 308
 309                 if (caids.empty())
 310                         continue; // unscrambled service
 311
 312                 for (eSmartPtrList<eDVBCISlot>::iterator ci_it(m_slots.begin()); ci_it != m_slots.end(); ++ci_it)
 313                 {
 314                         eDebugCI("check Slot %d", ci_it->getSlotID());
 315                         bool useThis=false;
 316                         bool user_mapped=true;
 317                         eDVBCICAManagerSession *ca_manager = ci_it->getCAManager();
 318
 319                         if (ca_manager)
 320                         {
 321                                 int mask=0;
 322                                 if (!ci_it->possible_services.empty())
 323                                 {
 324                                         mask |= 1;
 325                                         serviceSet::iterator it = ci_it->possible_services.find(ref);
 326                                         if (it != ci_it->possible_services.end())
 327                                         {
 328                                                 eDebug("'%s' is in service list of slot %d... so use it", ref.toString().c_str(), ci_it->getSlotID());
 329                                                 useThis = true;
 330                                         }
 331                                         else // check parent
 332                                         {
 333                                                 eServiceReferenceDVB parent_ref = ref.getParentServiceReference();
 334                                                 if (parent_ref)
 335                                                 {
 336                                                         it = ci_it->possible_services.find(ref);
 337                                                         if (it != ci_it->possible_services.end())
 338                                                         {
 339                                                                 eDebug("parent '%s' of '%s' is in service list of slot %d... so use it",
 340                                                                         parent_ref.toString().c_str(), ref.toString().c_str(), ci_it->getSlotID());
 341                                                                 useThis = true;
 342                                                         }
 343                                                 }
 344                                         }
 345                                 }
 346                                 if (!useThis && !ci_it->possible_providers.empty())
 347                                 {
 348                                         eDVBNamespace ns = ref.getDVBNamespace();
 349                                         mask |= 2;
 350                                         if (!service) // subservice?
 351                                         {
 352                                                 eServiceReferenceDVB parent_ref = ref.getParentServiceReference();
 353                                                 eDVBDB::getInstance()->getService(parent_ref, service);
 354                                         }
 355                                         if (service)
 356                                         {
 357                                                 providerSet::iterator it = ci_it->possible_providers.find(providerPair(service->m_provider_name, ns.get()));
 358                                                 if (it != ci_it->possible_providers.end())
 359                                                 {
 360                                                         eDebug("'%s/%08x' is in provider list of slot %d... so use it", service->m_provider_name.c_str(), ns.get(), ci_it->getSlotID());
 361                                                         useThis = true;
 362                                                 }
 363                                         }
 364                                 }
 365                                 if (!useThis && !ci_it->possible_caids.empty())
 366                                 {
 367                                         mask |= 4;
 368                                         for (CAID_LIST::iterator ca(caids.begin()); ca != caids.end(); ++ca)
 369                                         {
 370                                                 caidSet::iterator it = ci_it->possible_caids.find(*ca);
 371                                                 if (it != ci_it->possible_caids.end())
 372                                                 {
 373                                                         eDebug("caid '%04x' is in caid list of slot %d... so use it", *ca, ci_it->getSlotID());
 374                                                         useThis = true;
 375                                                         break;
 376                                                 }
 377                                         }
 378                                 }
 379                                 if (!useThis && !mask)
 380                                 {
 381                                         const std::vector<uint16_t> &ci_caids = ca_manager->getCAIDs();
 382                                         for (CAID_LIST::iterator ca(caids.begin()); ca != caids.end(); ++ca)
 383                                         {
 384                                                 std::vector<uint16_t>::const_iterator z =
 385                                                         std::lower_bound(ci_caids.begin(), ci_caids.end(), *ca);
 386                                                 if ( z != ci_caids.end() && *z == *ca )
 387                                                 {
 388                                                         eDebug("The CI in Slot %d has said it can handle caid %04x... so use it", ci_it->getSlotID(), *z);
 389                                                         useThis = true;
 390                                                         user_mapped = false;
 391                                                         break;
 392                                                 }
 393                                         }
 394                                 }
 395                         }
 396
 397                         if (useThis)
 398                         {
 399                                 // check if this CI is already assigned to this pmthandler
 400                                 eDVBCISlot *tmp = it->cislot;
 401                                 while(tmp)
 402                                 {
 403                                         if (tmp == ci_it)
 404                                                 break;
 405                                         tmp=tmp->linked_next;
 406                                 }
 407                                 if (tmp) // ignore already assigned cislots...
 408                                 {
 409                                         eDebugCI("already assigned!");
 410                                         continue;
 411                                 }
 412                                 eDebugCI("current slot %d usecount %d", ci_it->getSlotID(), ci_it->use_count);
 413                                 if (ci_it->use_count)  // check if this CI can descramble more than one service
 414                                 {
 415                                         bool found = false;
 416                                         useThis = false;
 417                                         PMTHandlerList::iterator tmp = m_pmt_handlers.begin();
 418                                         while (!found && tmp != m_pmt_handlers.end())
 419                                         {
 420                                                 eDebugCI(".");
 421                                                 eDVBCISlot *tmp_cislot = tmp->cislot;
 422                                                 while (!found && tmp_cislot)
 423                                                 {
 424                                                         eDebugCI("..");
 425                                                         eServiceReferenceDVB ref2;
 426                                                         tmp->pmthandler->getServiceReference(ref2);
 427                                                         if ( tmp_cislot == ci_it && it->pmthandler != tmp->pmthandler )
 428                                                         {
 429                                                                 eDebugCI("check pmthandler %s for same service/tp", ref2.toString().c_str());
 430                                                                 eDVBChannelID s1, s2;
 431                                                                 if (ref != ref2)
 432                                                                 {
 433                                                                         eDebugCI("different services!");
 434                                                                         ref.getChannelID(s1);
 435                                                                         ref2.getChannelID(s2);
 436                                                                 }
 437                                                                 if (ref == ref2 || (s1 == s2 && canDescrambleMultipleServices(tmp_cislot->getSlotID())))
 438                                                                 {
 439                                                                         found = true;
 440                                                                         eDebugCI("found!");
 441                                                                         eDVBCISlot *tmpci = it->cislot = tmp->cislot;
 442                                                                         while(tmpci)
 443                                                                         {
 444                                                                                 ++tmpci->use_count;
 445                                                                                 eDebug("(2)CISlot %d, usecount now %d", tmpci->getSlotID(), tmpci->use_count);
 446                                                                                 tmpci=tmpci->linked_next;
 447                                                                         }
 448                                                                 }
 449                                                         }
 450                                                         tmp_cislot=tmp_cislot->linked_next;
 451                                                 }
 452                                                 eDebugCI("...");
 453                                                 ++tmp;
 454                                         }
 455                                 }
 456
 457                                 if (useThis)
 458                                 {
 459                                         if (ci_it->user_mapped)  // we dont like to link user mapped CIs
 460                                         {
 461                                                 eDebugCI("user mapped CI already in use... dont link!");
 462                                                 continue;
 463                                         }
 464
 465                                         ++ci_it->use_count;
 466                                         eDebug("(1)CISlot %d, usecount now %d", ci_it->getSlotID(), ci_it->use_count);
 467
 468                                         data_source ci_source=CI_A;
 469                                         switch(ci_it->getSlotID())
 470                                         {
 471                                                 case 0: ci_source = CI_A; break;
 472                                                 case 1: ci_source = CI_B; break;
 473                                                 case 2: ci_source = CI_C; break;
 474                                                 case 3: ci_source = CI_D; break;
 475                                                 default:
 476                                                         eDebug("try to get source for CI %d!!\n", ci_it->getSlotID());
 477                                                         break;
 478                                         }
 479
 480                                         if (!it->cislot)
 481                                         {
 482                                                 int tunernum = -1;
 483                                                 eUsePtr<iDVBChannel> channel;
 484                                                 if (!pmthandler->getChannel(channel))
 485                                                 {
 486                                                         ePtr<iDVBFrontend> frontend;
 487                                                         if (!channel->getFrontend(frontend))
 488                                                         {
 489                                                                 eDVBFrontend *fe = (eDVBFrontend*) &(*frontend);
 490                                                                 tunernum = fe->getSlotID();
 491                                                         }
 492                                                 }
 493                                                 ASSERT(tunernum != -1);
 494                                                 data_source tuner_source = TUNER_A;
 495                                                 switch (tunernum)
 496                                                 {
 497                                                         case 0: tuner_source = TUNER_A; break;
 498                                                         case 1: tuner_source = TUNER_B; break;
 499                                                         case 2: tuner_source = TUNER_C; break;
 500                                                         case 3: tuner_source = TUNER_D; break;
 501                                                         default:
 502                                                                 eDebug("try to get source for tuner %d!!\n", tunernum);
 503                                                                 break;
 504                                                 }
 505                                                 ci_it->current_tuner = tunernum;
 506                                                 setInputSource(tunernum, ci_source);
 507                                                 ci_it->setSource(tuner_source);
 508                                         }
 509                                         else
 510                                         {
 511                                                 ci_it->current_tuner = it->cislot->current_tuner;
 512                                                 ci_it->linked_next = it->cislot;
 513                                                 ci_it->setSource(ci_it->linked_next->current_source);
 514                                                 ci_it->linked_next->setSource(ci_source);
 515                                         }
 516                                         it->cislot = ci_it;
 517                                         eDebugCI("assigned!");
 518                                         gotPMT(pmthandler);
 519                                 }
 520
 521                                 if (it->cislot && user_mapped) // CI assigned to this pmthandler in this run.. and user mapped? then we break here.. we dont like to link other CIs to user mapped CIs
 522                                 {
 523                                         eDebugCI("user mapped CI assigned... dont link CIs!");
 524                                         break;
 525                                 }
 526                         }
 527                 }
 528         }
 529 }
 530
 531 void eDVBCIInterfaces::addPMTHandler(eDVBServicePMTHandler *pmthandler)
 532 {
 533         // check if this pmthandler is already registered
 534         PMTHandlerList::iterator it = m_pmt_handlers.begin();
 535         while (it != m_pmt_handlers.end())
 536         {
 537                 if ( *it++ == pmthandler )
 538                         return;
 539         }
 540
 541         eServiceReferenceDVB ref;
 542         pmthandler->getServiceReference(ref);
 543         eDebug("[eDVBCIInterfaces] addPMTHandler %s", ref.toString().c_str());
 544
 545         m_pmt_handlers.push_back(CIPmtHandler(pmthandler));
 546         recheckPMTHandlers();
 547 }
 548
 549 void eDVBCIInterfaces::removePMTHandler(eDVBServicePMTHandler *pmthandler)
 550 {
 551         PMTHandlerList::iterator it=std::find(m_pmt_handlers.begin(),m_pmt_handlers.end(),pmthandler);
 552         if (it != m_pmt_handlers.end())
 553         {
 554                 eDVBCISlot *slot = it->cislot;
 555                 eDVBServicePMTHandler *pmthandler = it->pmthandler;
 556                 m_pmt_handlers.erase(it);
 557
 558                 eServiceReferenceDVB service_to_remove;
 559                 pmthandler->getServiceReference(service_to_remove);
 560
 561                 bool sameServiceExist=false;
 562                 for (PMTHandlerList::iterator i=m_pmt_handlers.begin(); i != m_pmt_handlers.end(); ++i)
 563                 {
 564                         if (i->cislot)
 565                         {
 566                                 eServiceReferenceDVB ref;
 567                                 i->pmthandler->getServiceReference(ref);
 568                                 if ( ref == service_to_remove )
 569                                 {
 570                                         sameServiceExist=true;
 571                                         break;
 572                                 }
 573                         }
 574                 }
 575
 576                 while(slot)
 577                 {
 578                         if (!sameServiceExist)
 579                         {
 580                                 if (slot->getNumOfServices() > 1)
 581                                 {
 582                                         eDebug("[eDVBCIInterfaces] remove last pmt handler for service %s send empty capmt",
 583                                                 service_to_remove.toString().c_str());
 584                                                 std::vector<uint16_t> caids;
 585                                         caids.push_back(0xFFFF);
 586                                         slot->sendCAPMT(pmthandler, caids);  // send a capmt without caids to remove a running service
 587                                 }
 588                                 slot->removeService(service_to_remove.getServiceID().get());
 589                         }
 590
 591                         eDVBCISlot *next = slot->linked_next;
 592                         if (!--slot->use_count)
 593                         {
 594                                 if (slot->linked_next)
 595                                         slot->linked_next->setSource(slot->current_source);
 596                                 else
 597                                         setInputSource(slot->current_tuner, slot->current_source);
 598
 599                                 if (it->cislot == slot) // remove the base slot
 600                                         it->cislot = slot->linked_next;
 601                                 else
 602                                 {
 603                                         eDVBCISlot *tmp = it->cislot;
 604                                         while(tmp->linked_next != slot)
 605                                                 tmp = tmp->linked_next;
 606                                         ASSERT(tmp);
 607                                         if (slot->linked_next)
 608                                                 tmp->linked_next = slot->linked_next;
 609                                         else
 610                                                 tmp->linked_next = 0;
 611                                 }
 612                                 slot->linked_next = 0;
 613                                 slot->user_mapped = false;
 614                         }
 615                         eDebug("(3) slot %d usecount is now %d", slot->getSlotID(), slot->use_count);
 616                         slot = next;
 617                 }
 618                 // check if another service is waiting for the CI
 619                 recheckPMTHandlers();
 620         }
 621 }
 622
 623 void eDVBCIInterfaces::gotPMT(eDVBServicePMTHandler *pmthandler)
 624 {
 625         eDebug("[eDVBCIInterfaces] gotPMT");
 626         PMTHandlerList::iterator it=std::find(m_pmt_handlers.begin(), m_pmt_handlers.end(), pmthandler);
 627         if (it != m_pmt_handlers.end() && it->cislot)
 628         {
 629                 eDVBCISlot *tmp = it->cislot;
 630                 while(tmp)
 631                 {
 632                         eDebugCI("check slot %d %d %d", tmp->getSlotID(), tmp->running_services.empty(), canDescrambleMultipleServices(tmp->getSlotID()));
 633                         if (tmp->running_services.empty() || canDescrambleMultipleServices(tmp->getSlotID()))
 634                                 tmp->sendCAPMT(pmthandler);
 635                         tmp = tmp->linked_next;
 636                 }
 637         }
 638 }
 639
 640 int eDVBCIInterfaces::getMMIState(int slotid)
 641 {
 642         eDVBCISlot *slot;
 643
 644         if( (slot = getSlot(slotid)) == 0 )
 645                 return -1;
 646
 647         return slot->getMMIState();
 648 }
 649
 650 int eDVBCIInterfaces::setInputSource(int tuner_no, data_source source)
 651 {
 652 //      eDebug("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
 653 //      eDebug("eDVBCIInterfaces::setInputSource(%d %d)", tuner_no, (int)source);
 654         if (getNumOfSlots() > 1) // FIXME .. we force DM8000 when more than one CI Slot is avail
 655         {
 656                 char buf[64];
 657                 snprintf(buf, 64, "/proc/stb/tsmux/input%d", tuner_no);
 658
 659                 FILE *input=0;
 660                 if((input = fopen(buf, "wb")) == NULL) {
 661                         eDebug("cannot open %s", buf);
 662                         return 0;
 663                 }
 664
 665                 if (tuner_no > 3)
 666                         eDebug("setInputSource(%d, %d) failed... dm8000 just have four inputs", tuner_no, (int)source);
 667
 668                 switch(source)
 669                 {
 670                         case CI_A:
 671                                 fprintf(input, "CI0");
 672                                 break;
 673                         case CI_B:
 674                                 fprintf(input, "CI1");
 675                                 break;
 676                         case CI_C:
 677                                 fprintf(input, "CI2");
 678                         break;
 679                         case CI_D:
 680                                 fprintf(input, "CI3");
 681                                 break;
 682                         case TUNER_A:
 683                                 fprintf(input, "A");
 684                                 break;
 685                         case TUNER_B:
 686                                 fprintf(input, "B");
 687                                 break;
 688                         case TUNER_C:
 689                                 fprintf(input, "C");
 690                                 break;
 691                         case TUNER_D:
 692                                 fprintf(input, "D");
 693                                 break;
 694                         default:
 695                                 eDebug("setInputSource for input %d failed!!!\n", (int)source);
 696                                 break;
 697                 }
 698
 699                 fclose(input);
 700         }
 701         else  // DM7025
 702         {
 703                 char buf[64];
 704                 snprintf(buf, 64, "/proc/stb/tsmux/input%d", tuner_no);
 705
 706                 if (tuner_no > 1)
 707                         eDebug("setInputSource(%d, %d) failed... dm7025 just have two inputs", tuner_no, (int)source);
 708
 709                 FILE *input=0;
 710                 if((input = fopen(buf, "wb")) == NULL) {
 711                         eDebug("cannot open %s", buf);
 712                         return 0;
 713                 }
 714
 715                 switch(source)
 716                 {
 717                         case CI_A:
 718                                 fprintf(input, "CI");
 719                                 break;
 720                         case TUNER_A:
 721                                 fprintf(input, "A");
 722                                 break;
 723                         case TUNER_B:
 724                                 fprintf(input, "B");
 725                                 break;
 726                         default:
 727                                 eDebug("setInputSource for input %d failed!!!\n", (int)source);
 728                                 break;
 729                 }
 730
 731                 fclose(input);
 732         }
 733         eDebug("eDVBCIInterfaces->setInputSource(%d, %d)", tuner_no, (int)source);
 734         return 0;
 735 }
 736
 737 PyObject *eDVBCIInterfaces::getDescrambleRules(int slotid)
 738 {
 739         eDVBCISlot *slot = getSlot(slotid);
 740         if (!slot)
 741         {
 742                 char tmp[255];
 743                 snprintf(tmp, 255, "eDVBCIInterfaces::getDescrambleRules try to get rules for CI Slot %d... but just %d slots are available", slotid, m_slots.size());
 744                 PyErr_SetString(PyExc_StandardError, tmp);
 745                 return 0;
 746         }
 747         ePyObject tuple = PyTuple_New(3);
 748         int caids = slot->possible_caids.size();
 749         int services = slot->possible_services.size();
 750         int providers = slot->possible_providers.size();
 751         ePyObject caid_list = PyList_New(caids);
 752         ePyObject service_list = PyList_New(services);
 753         ePyObject provider_list = PyList_New(providers);
 754         caidSet::iterator caid_it(slot->possible_caids.begin());
 755         while(caids)
 756         {
 757                 --caids;
 758                 PyList_SET_ITEM(caid_list, caids, PyLong_FromLong(*caid_it));
 759                 ++caid_it;
 760         }
 761         serviceSet::iterator ref_it(slot->possible_services.begin());
 762         while(services)
 763         {
 764                 --services;
 765                 PyList_SET_ITEM(service_list, services, PyString_FromString(ref_it->toString().c_str()));
 766                 ++ref_it;
 767         }
 768         providerSet::iterator provider_it(slot->possible_providers.begin());
 769         while(providers)
 770         {
 771                 ePyObject tuple = PyTuple_New(2);
 772                 PyTuple_SET_ITEM(tuple, 0, PyString_FromString(provider_it->first.c_str()));
 773                 PyTuple_SET_ITEM(tuple, 1, PyLong_FromUnsignedLong(provider_it->second));
 774                 --providers;
 775                 PyList_SET_ITEM(provider_list, providers, tuple);
 776                 ++provider_it;
 777         }
 778         PyTuple_SET_ITEM(tuple, 0, service_list);
 779         PyTuple_SET_ITEM(tuple, 1, provider_list);
 780         PyTuple_SET_ITEM(tuple, 2, caid_list);
 781         return tuple;
 782 }
 783
 784 const char *PyObject_TypeStr(PyObject *o)
 785 {
 786         return o->ob_type && o->ob_type->tp_name ? o->ob_type->tp_name : "unknown object type";
 787 }
 788
 789 RESULT eDVBCIInterfaces::setDescrambleRules(int slotid, SWIG_PYOBJECT(ePyObject) obj )
 790 {
 791         eDVBCISlot *slot = getSlot(slotid);
 792         if (!slot)
 793         {
 794                 char tmp[255];
 795                 snprintf(tmp, 255, "eDVBCIInterfaces::setDescrambleRules try to set rules for CI Slot %d... but just %d slots are available", slotid, m_slots.size());
 796                 PyErr_SetString(PyExc_StandardError, tmp);
 797                 return -1;
 798         }
 799         if (!PyTuple_Check(obj))
 800         {
 801                 char tmp[255];
 802                 snprintf(tmp, 255, "2nd argument of setDescrambleRules is not a tuple.. it is a '%s'!!", PyObject_TypeStr(obj));
 803                 PyErr_SetString(PyExc_StandardError, tmp);
 804                 return -1;
 805         }
 806         if (PyTuple_Size(obj) != 3)
 807         {
 808                 const char *errstr = "eDVBCIInterfaces::setDescrambleRules not enough entrys in argument tuple!!\n"
 809                         "first argument should be a pythonlist with possible services\n"
 810                         "second argument should be a pythonlist with possible providers/dvbnamespace tuples\n"
 811                         "third argument should be a pythonlist with possible caids";
 812                 PyErr_SetString(PyExc_StandardError, errstr);
 813                 return -1;
 814         }
 815         ePyObject service_list = PyTuple_GET_ITEM(obj, 0);
 816         ePyObject provider_list = PyTuple_GET_ITEM(obj, 1);
 817         ePyObject caid_list = PyTuple_GET_ITEM(obj, 2);
 818         if (!PyList_Check(service_list) || !PyList_Check(provider_list) || !PyList_Check(caid_list))
 819         {
 820                 char errstr[512];
 821                 snprintf(errstr, 512, "eDVBCIInterfaces::setDescrambleRules incorrect data types in argument tuple!!\n"
 822                         "first argument(%s) should be a pythonlist with possible services (reference strings)\n"
 823                         "second argument(%s) should be a pythonlist with possible providers (providername strings)\n"
 824                         "third argument(%s) should be a pythonlist with possible caids (ints)",
 825                         PyObject_TypeStr(service_list), PyObject_TypeStr(provider_list), PyObject_TypeStr(caid_list));
 826                 PyErr_SetString(PyExc_StandardError, errstr);
 827                 return -1;
 828         }
 829         slot->possible_caids.clear();
 830         slot->possible_services.clear();
 831         slot->possible_providers.clear();
 832         int size = PyList_Size(service_list);
 833         while(size)
 834         {
 835                 --size;
 836                 ePyObject refstr = PyList_GET_ITEM(service_list, size);
 837                 if (!PyString_Check(refstr))
 838                 {
 839                         char buf[255];
 840                         snprintf(buf, 255, "eDVBCIInterfaces::setDescrambleRules entry in service list is not a string.. it is '%s'!!", PyObject_TypeStr(refstr));
 841                         PyErr_SetString(PyExc_StandardError, buf);
 842                         return -1;
 843                 }
 844                 char *tmpstr = PyString_AS_STRING(refstr);
 845                 eServiceReference ref(tmpstr);
 846                 if (ref.valid())
 847                         slot->possible_services.insert(ref);
 848                 else
 849                         eDebug("eDVBCIInterfaces::setDescrambleRules '%s' is not a valid service reference... ignore!!", tmpstr);
 850         };
 851         size = PyList_Size(provider_list);
 852         while(size)
 853         {
 854                 --size;
 855                 ePyObject tuple = PyList_GET_ITEM(provider_list, size);
 856                 if (!PyTuple_Check(tuple))
 857                 {
 858                         char buf[255];
 859                         snprintf(buf, 255, "eDVBCIInterfaces::setDescrambleRules entry in provider list is not a tuple it is '%s'!!", PyObject_TypeStr(tuple));
 860                         PyErr_SetString(PyExc_StandardError, buf);
 861                         return -1;
 862                 }
 863                 if (PyTuple_Size(tuple) != 2)
 864                 {
 865                         char buf[255];
 866                         snprintf(buf, 255, "eDVBCIInterfaces::setDescrambleRules provider tuple has %d instead of 2 entries!!", PyTuple_Size(tuple));
 867                         PyErr_SetString(PyExc_StandardError, buf);
 868                         return -1;
 869                 }
 870                 if (!PyString_Check(PyTuple_GET_ITEM(tuple, 0)))
 871                 {
 872                         char buf[255];
 873                         snprintf(buf, 255, "eDVBCIInterfaces::setDescrambleRules 1st entry in provider tuple is not a string it is '%s'", PyObject_TypeStr(PyTuple_GET_ITEM(tuple, 0)));
 874                         PyErr_SetString(PyExc_StandardError, buf);
 875                         return -1;
 876                 }
 877                 if (!PyLong_Check(PyTuple_GET_ITEM(tuple, 1)))
 878                 {
 879                         char buf[255];
 880                         snprintf(buf, 255, "eDVBCIInterfaces::setDescrambleRules 2nd entry in provider tuple is not a long it is '%s'", PyObject_TypeStr(PyTuple_GET_ITEM(tuple, 1)));
 881                         PyErr_SetString(PyExc_StandardError, buf);
 882                         return -1;
 883                 }
 884                 char *tmpstr = PyString_AS_STRING(PyTuple_GET_ITEM(tuple, 0));
 885                 uint32_t orbpos = PyLong_AsUnsignedLong(PyTuple_GET_ITEM(tuple, 1));
 886                 if (strlen(tmpstr))
 887                         slot->possible_providers.insert(std::pair<std::string, uint32_t>(tmpstr, orbpos));
 888                 else
 889                         eDebug("eDVBCIInterfaces::setDescrambleRules ignore invalid entry in provider tuple (string is empty)!!");
 890         };
 891         size = PyList_Size(caid_list);
 892         while(size)
 893         {
 894                 --size;
 895                 ePyObject caid = PyList_GET_ITEM(caid_list, size);
 896                 if (!PyLong_Check(caid))
 897                 {
 898                         char buf[255];
 899                         snprintf(buf, 255, "eDVBCIInterfaces::setDescrambleRules entry in caid list is not a long it is '%s'!!", PyObject_TypeStr(caid));
 900                         PyErr_SetString(PyExc_StandardError, buf);
 901                         return -1;
 902                 }
 903                 int tmpcaid = PyLong_AsLong(caid);
 904                 if (tmpcaid > 0 && tmpcaid < 0x10000)
 905                         slot->possible_caids.insert(tmpcaid);
 906                 else
 907                         eDebug("eDVBCIInterfaces::setDescrambleRules %d is not a valid caid... ignore!!", tmpcaid);
 908         };
 909         return 0;
 910 }
 911
 912 PyObject *eDVBCIInterfaces::readCICaIds(int slotid)
 913 {
 914         eDVBCISlot *slot = getSlot(slotid);
 915         if (!slot)
 916         {
 917                 char tmp[255];
 918                 snprintf(tmp, 255, "eDVBCIInterfaces::readCICaIds try to get CAIds for CI Slot %d... but just %d slots are available", slotid, m_slots.size());
 919                 PyErr_SetString(PyExc_StandardError, tmp);
 920         }
 921         else
 922         {
 923                 int idx=0;
 924                 eDVBCICAManagerSession *ca_manager = slot->getCAManager();
 925                 const std::vector<uint16_t> *ci_caids = ca_manager ? &ca_manager->getCAIDs() : 0;
 926                 ePyObject list = PyList_New(ci_caids ? ci_caids->size() : 0);
 927                 if (ci_caids)
 928                 {
 929                         for (std::vector<uint16_t>::const_iterator it = ci_caids->begin(); it != ci_caids->end(); ++it)
 930                                 PyList_SET_ITEM(list, idx++, PyLong_FromLong(*it));
 931                 }
 932                 return list;
 933         }
 934         return 0;
 935 }
 936
 937 int eDVBCIInterfaces::setCIClockRate(int slotid, int rate)
 938 {
 939         eDVBCISlot *slot = getSlot(slotid);
 940         if (slot)
 941                 return slot->setClockRate(rate);
 942         return -1;
 943 }
 944
 945 int eDVBCISlot::send(const unsigned char *data, size_t len)
 946 {
 947         int res=0;
 948         //int i;
 949         //eDebugNoNewLine("< ");
 950         //for(i=0;i<len;i++)
 951         //      eDebugNoNewLine("%02x ",data[i]);
 952         //eDebug("");
 953
 954         if (sendqueue.empty())
 955                 res = ::write(fd, data, len);
 956
 957         if (res < 0 || (unsigned int)res != len)
 958         {
 959                 unsigned char *d = new unsigned char[len];
 960                 memcpy(d, data, len);
 961                 sendqueue.push( queueData(d, len) );
 962                 notifier->setRequested(eSocketNotifier::Read | eSocketNotifier::Priority | eSocketNotifier::Write);
 963         }
 964
 965         return res;
 966 }
 967
 968 void eDVBCISlot::data(int what)
 969 {
 970         eDebugCI("CISlot %d what %d\n", getSlotID(), what);
 971         if(what == eSocketNotifier::Priority) {
 972                 if(state != stateRemoved) {
 973                         state = stateRemoved;
 974                         while(sendqueue.size())
 975                         {
 976                                 delete [] sendqueue.top().data;
 977                                 sendqueue.pop();
 978                         }
 979                         eDVBCISession::deleteSessions(this);
 980                         eDVBCIInterfaces::getInstance()->ciRemoved(this);
 981                         notifier->setRequested(eSocketNotifier::Read);
 982                         eDVBCI_UI::getInstance()->setState(getSlotID(),0);
 983                 }
 984                 return;
 985         }
 986
 987         if (state == stateInvalid)
 988                 reset();
 989
 990         if(state != stateInserted) {
 991                 eDebug("ci inserted in slot %d", getSlotID());
 992                 state = stateInserted;
 993                 eDVBCI_UI::getInstance()->setState(getSlotID(),1);
 994                 notifier->setRequested(eSocketNotifier::Read|eSocketNotifier::Priority);
 995                 /* enable PRI to detect removal or errors */
 996         }
 997
 998         if (what & eSocketNotifier::Read) {
 999                 __u8 data[4096];
1000                 int r;
1001                 r = ::read(fd, data, 4096);
1002                 if(r > 0) {
1003 //                      int i;
1004 //                      eDebugNoNewLine("> ");
1005 //                      for(i=0;i<r;i++)
1006 //                              eDebugNoNewLine("%02x ",data[i]);
1007 //                      eDebug("");
1008                         eDVBCISession::receiveData(this, data, r);
1009                         eDVBCISession::pollAll();
1010                         return;
1011                 }
1012         }
1013         else if (what & eSocketNotifier::Write) {
1014                 if (!sendqueue.empty()) {
1015                         const queueData &qe = sendqueue.top();
1016                         int res = ::write(fd, qe.data, qe.len);
1017                         if (res >= 0 && (unsigned int)res == qe.len)
1018                         {
1019                                 delete [] qe.data;
1020                                 sendqueue.pop();
1021                         }
1022                 }
1023                 else
1024                         notifier->setRequested(eSocketNotifier::Read|eSocketNotifier::Priority);
1025         }
1026 }
1027
1028 DEFINE_REF(eDVBCISlot);
1029
1030 eDVBCISlot::eDVBCISlot(eMainloop *context, int nr)
1031 {
1032         char filename[128];
1033
1034         application_manager = 0;
1035         mmi_session = 0;
1036         ca_manager = 0;
1037         use_count = 0;
1038         linked_next = 0;
1039         user_mapped = false;
1040         plugged = true;
1041
1042         slotid = nr;
1043
1044         sprintf(filename, "/dev/ci%d", nr);
1045
1046 //      possible_caids.insert(0x1702);
1047 //      possible_providers.insert(providerPair("PREMIERE", 0xC00000));
1048 //      possible_services.insert(eServiceReference("1:0:1:2A:4:85:C00000:0:0:0:"));
1049
1050         fd = ::open(filename, O_RDWR | O_NONBLOCK);
1051
1052         eDebugCI("CI Slot %d has fd %d", getSlotID(), fd);
1053         state = stateInvalid;
1054
1055         if (fd >= 0)
1056         {
1057                 notifier = eSocketNotifier::create(context, fd, eSocketNotifier::Read | eSocketNotifier::Priority | eSocketNotifier::Write);
1058                 CONNECT(notifier->activated, eDVBCISlot::data);
1059         } else
1060         {
1061                 perror(filename);
1062         }
1063 }
1064
1065 eDVBCISlot::~eDVBCISlot()
1066 {
1067         eDVBCISession::deleteSessions(this);
1068 }
1069
1070 void eDVBCISlot::setAppManager( eDVBCIApplicationManagerSession *session )
1071 {
1072         application_manager=session;
1073 }
1074
1075 void eDVBCISlot::setMMIManager( eDVBCIMMISession *session )
1076 {
1077         mmi_session = session;
1078 }
1079
1080 void eDVBCISlot::setCAManager( eDVBCICAManagerSession *session )
1081 {
1082         ca_manager = session;
1083 }
1084
1085 int eDVBCISlot::getSlotID()
1086 {
1087         return slotid;
1088 }
1089
1090 int eDVBCISlot::reset()
1091 {
1092         eDebug("CI Slot %d: reset requested", getSlotID());
1093
1094         if (state == stateInvalid)
1095         {
1096                 unsigned char buf[256];
1097                 eDebug("ci flush");
1098                 while(::read(fd, buf, 256)>0);
1099                 state = stateResetted;
1100         }
1101
1102         while(sendqueue.size())
1103         {
1104                 delete [] sendqueue.top().data;
1105                 sendqueue.pop();
1106         }
1107
1108         ioctl(fd, 0);
1109
1110         return 0;
1111 }
1112
1113 int eDVBCISlot::startMMI()
1114 {
1115         eDebug("CI Slot %d: startMMI()", getSlotID());
1116
1117         if(application_manager)
1118                 application_manager->startMMI();
1119
1120         return 0;
1121 }
1122
1123 int eDVBCISlot::stopMMI()
1124 {
1125         eDebug("CI Slot %d: stopMMI()", getSlotID());
1126
1127         if(mmi_session)
1128                 mmi_session->stopMMI();
1129
1130         return 0;
1131 }
1132
1133 int eDVBCISlot::answerText(int answer)
1134 {
1135         eDebug("CI Slot %d: answerText(%d)", getSlotID(), answer);
1136
1137         if(mmi_session)
1138                 mmi_session->answerText(answer);
1139
1140         return 0;
1141 }
1142
1143 int eDVBCISlot::getMMIState()
1144 {
1145         if(mmi_session)
1146                 return 1;
1147
1148         return 0;
1149 }
1150
1151 int eDVBCISlot::answerEnq(char *value)
1152 {
1153         eDebug("CI Slot %d: answerENQ(%s)", getSlotID(), value);
1154
1155         if(mmi_session)
1156                 mmi_session->answerEnq(value);
1157
1158         return 0;
1159 }
1160
1161 int eDVBCISlot::cancelEnq()
1162 {
1163         eDebug("CI Slot %d: cancelENQ", getSlotID());
1164
1165         if(mmi_session)
1166                 mmi_session->cancelEnq();
1167
1168         return 0;
1169 }
1170
1171 int eDVBCISlot::sendCAPMT(eDVBServicePMTHandler *pmthandler, const std::vector<uint16_t> &ids)
1172 {
1173         if (!ca_manager)
1174         {
1175                 eDebug("no ca_manager (no CI plugged?)");
1176                 return -1;
1177         }
1178         const std::vector<uint16_t> &caids = ids.empty() ? ca_manager->getCAIDs() : ids;
1179         ePtr<eTable<ProgramMapSection> > ptr;
1180         if (pmthandler->getPMT(ptr))
1181                 return -1;
1182         else
1183         {
1184                 eDVBTableSpec table_spec;
1185                 ptr->getSpec(table_spec);
1186                 int pmt_version = table_spec.version & 0x1F; // just 5 bits
1187
1188                 eServiceReferenceDVB ref;
1189                 pmthandler->getServiceReference(ref);
1190                 uint16_t program_number = ref.getServiceID().get();
1191                 std::map<uint16_t, uint8_t>::iterator it =
1192                         running_services.find(program_number);
1193
1194                 if ( it != running_services.end() &&
1195                         (pmt_version == it->second) &&
1196                         !(caids.size() == 1 && caids[0] == 0xFFFF) )
1197                 {
1198                         eDebug("[eDVBCISlot] dont send self capmt version twice");
1199                         return -1;
1200                 }
1201
1202                 std::vector<ProgramMapSection*>::const_iterator i=ptr->getSections().begin();
1203                 if ( i == ptr->getSections().end() )
1204                         return -1;
1205                 else
1206                 {
1207                         unsigned char raw_data[2048];
1208
1209 //                      eDebug("send %s capmt for service %04x to slot %d",
1210 //                              it != running_services.end() ? "UPDATE" : running_services.empty() ? "ONLY" : "ADD",
1211 //                              program_number, slotid);
1212
1213                         CaProgramMapSection capmt(*i++,
1214                                 it != running_services.end() ? 0x05 /*update*/ : running_services.empty() ? 0x03 /*only*/ : 0x04 /*add*/, 0x01, caids );
1215                         while( i != ptr->getSections().end() )
1216                         {
1217                 //                      eDebug("append");
1218                                 capmt.append(*i++);
1219                         }
1220                         capmt.writeToBuffer(raw_data);
1221 #if 1
1222 // begin calc capmt length
1223                         int wp=0;
1224                         int hlen;
1225                         if ( raw_data[3] & 0x80 )
1226                         {
1227                                 int i=0;
1228                                 int lenbytes = raw_data[3] & ~0x80;
1229                                 while(i < lenbytes)
1230                                         wp = (wp << 8) | raw_data[4 + i++];
1231                                 wp+=4;
1232                                 wp+=lenbytes;
1233                                 hlen = 4 + lenbytes;
1234                         }
1235                         else
1236                         {
1237                                 wp = raw_data[3];
1238                                 wp+=4;
1239                                 hlen = 4;
1240                         }
1241 // end calc capmt length
1242 //                      eDebug("ca_manager %p dump capmt:", ca_manager);
1243 //                      for(int i=0;i<wp;i++)
1244 //                              eDebugNoNewLine("%02x ", raw_data[i]);
1245 //                      eDebug("");
1246 #endif
1247                         if (caids.size() == 1 && caids[0] == 0xFFFF)
1248                         {
1249 //                              eDebugNoNewLine("SEND EMPTY CAPMT.. old version is %02x", raw_data[hlen+3]);
1250                                 raw_data[hlen+3] &= ~0x3E;
1251                                 raw_data[hlen+3] |= ((pmt_version+1) & 0x1F) << 1;
1252 //                              eDebug(" new version is %02x", raw_data[hlen+3]);
1253                         }
1254
1255                         //dont need tag and lenfield
1256                         ca_manager->sendCAPMT(raw_data + hlen, wp - hlen);
1257                         running_services[program_number] = pmt_version;
1258                 }
1259         }
1260         return 0;
1261 }
1262
1263 void eDVBCISlot::removeService(uint16_t program_number)
1264 {
1265         if (program_number == 0xFFFF)
1266                 running_services.clear();  // remove all
1267         else
1268                 running_services.erase(program_number);  // remove single service
1269 }
1270
1271 int eDVBCISlot::setSource(data_source source)
1272 {
1273         current_source = source;
1274         if (eDVBCIInterfaces::getInstance()->getNumOfSlots() > 1) // FIXME .. we force DM8000 when more than one CI Slot is avail
1275         {
1276                 char buf[64];
1277                 snprintf(buf, 64, "/proc/stb/tsmux/ci%d_input", slotid);
1278                 FILE *ci = fopen(buf, "wb");
1279                 switch(source)
1280                 {
1281                         case CI_A:
1282                                 fprintf(ci, "CI0");
1283                                 break;
1284                         case CI_B:
1285                                 fprintf(ci, "CI1");
1286                                 break;
1287                         case CI_C:
1288                                 fprintf(ci, "CI2");
1289                                 break;
1290                         case CI_D:
1291                                 fprintf(ci, "CI3");
1292                                 break;
1293                         case TUNER_A:
1294                                 fprintf(ci, "A");
1295                                 break;
1296                         case TUNER_B:
1297                                 fprintf(ci, "B");
1298                                 break;
1299                         case TUNER_C:
1300                                 fprintf(ci, "C");
1301                                 break;
1302                                 case TUNER_D:
1303                                 fprintf(ci, "D");
1304                                 break;
1305                         default:
1306                                 eDebug("CI Slot %d: setSource %d failed!!!\n", getSlotID(), (int)source);
1307                                 break;
1308                 }
1309                 fclose(ci);
1310         }
1311         else // DM7025
1312         {
1313 //              eDebug("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
1314 //              eDebug("eDVBCISlot::enableTS(%d %d)", enable, (int)source);
1315                 FILE *ci = fopen("/proc/stb/tsmux/input2", "wb");
1316                 if(ci == NULL) {
1317                         eDebug("cannot open /proc/stb/tsmux/input2");
1318                         return 0;
1319                 }
1320                 if (source != TUNER_A && source != TUNER_B)
1321                         eDebug("CI Slot %d: setSource %d failed!!!\n", getSlotID(), (int)source);
1322                 else
1323                         fprintf(ci, "%s", source==TUNER_A ? "A" : "B");  // configure CI data source (TunerA, TunerB)
1324                 fclose(ci);
1325         }
1326         eDebug("CI Slot %d setSource(%d)", getSlotID(), (int)source);
1327         return 0;
1328 }
1329
1330 int eDVBCISlot::setClockRate(int rate)
1331 {
1332         char buf[64];
1333         snprintf(buf, 64, "/proc/stb/tsmux/ci%d_tsclk", slotid);
1334         FILE *ci = fopen(buf, "wb");
1335         if (ci)
1336         {
1337                 if (rate)
1338                         fprintf(ci, "high");
1339                 else
1340                         fprintf(ci, "normal");
1341                 fclose(ci);
1342                 return 0;
1343         }
1344         return -1;
1345 }
1346
1347 eAutoInitP0<eDVBCIInterfaces> init_eDVBCIInterfaces(eAutoInitNumbers::dvb, "CI Slots");