fix bug described here -> http://www.dream-multimedia-tv.de/board/thread.php?threadid...

[enigma2.git] / lib / dvb / frontend.cpp

diff --git a/lib/dvb/frontend.cpp b/lib/dvb/frontend.cpp
index 220d3e87ad995c92dd0206211bb7c9afde218674..8b21413025b512c905595737de6a38df8f7f9b95 100644 (file)
--- a/lib/dvb/frontend.cpp
+++ b/lib/dvb/frontend.cpp
@@ -1,5 +1,6 @@
 #include <lib/dvb/dvb.h>
 #include <lib/base/eerror.h>
 #include <lib/dvb/dvb.h>
 #include <lib/base/eerror.h>

+#include <lib/base/nconfig.h> // access to python config

 #include <errno.h>
 #include <unistd.h>
 #include <fcntl.h>
 #include <errno.h>
 #include <unistd.h>
 #include <fcntl.h>


@@ -91,7 +92,6 @@ void eDVBDiseqcCommand::setCommandString(const char *str)
                eDebug("invalid diseqc command string length (string is to long)");
                return;
        }
                eDebug("invalid diseqc command string length (string is to long)");
                return;
        }

-       eDebugNoNewLine("send diseqc:");

        unsigned char val=0;
        for (int i=0; i < slen; ++i)
        {
        unsigned char val=0;
        for (int i=0; i < slen; ++i)
        {


@@ -108,13 +108,11 @@ void eDVBDiseqcCommand::setCommandString(const char *str)
                if ( i % 2 )
                {
                        val |= c;
                if ( i % 2 )
                {
                        val |= c;

-                       eDebugNoNewLine("%02x", val);

                        data[i/2] = val;
                }
                else
                        val = c << 4;
        }
                        data[i/2] = val;
                }
                else
                        val = c << 4;
        }

-       eDebug("");

        len = slen/2;
 }
 
        len = slen/2;
 }
 


@@ -265,7 +263,7 @@ RESULT eDVBFrontendParameters::setDVBT(const eDVBFrontendParametersTerrestrial &
        return 0;
 }
 
        return 0;
 }
 

-RESULT eDVBFrontendParameters::calculateDifference(const iDVBFrontendParameters *parm, int &diff) const
+RESULT eDVBFrontendParameters::calculateDifference(const iDVBFrontendParameters *parm, int &diff, bool exact) const

 {
        if (!parm)
                return -1;
 {
        if (!parm)
                return -1;


@@ -290,6 +288,10 @@ RESULT eDVBFrontendParameters::calculateDifference(const iDVBFrontendParameters
                        diff = 1<<29;
                else if (sat.polarisation != osat.polarisation)
                        diff = 1<<28;
                        diff = 1<<29;
                else if (sat.polarisation != osat.polarisation)
                        diff = 1<<28;

+               else if (exact && sat.fec != osat.fec && sat.fec != eDVBFrontendParametersSatellite::FEC::fAuto && osat.fec != eDVBFrontendParametersSatellite::FEC::fAuto)
+                       diff = 1<<27;
+               else if (exact && sat.modulation != osat.modulation && sat.modulation != eDVBFrontendParametersSatellite::Modulation::Auto && osat.modulation != eDVBFrontendParametersSatellite::Modulation::Auto)
+                       diff = 1<<27;

                else
                {
                        diff = abs(sat.frequency - osat.frequency);
                else
                {
                        diff = abs(sat.frequency - osat.frequency);


@@ -302,24 +304,54 @@ RESULT eDVBFrontendParameters::calculateDifference(const iDVBFrontendParameters
                if (parm->getDVBC(ocable))
                        return -2;
 
                if (parm->getDVBC(ocable))
                        return -2;
 

-               if (cable.modulation != ocable.modulation && cable.modulation != eDVBFrontendParametersCable::Modulation::Auto && ocable.modulation != eDVBFrontendParametersCable::Modulation::Auto)
+               if (exact && cable.modulation != ocable.modulation
+                       && cable.modulation != eDVBFrontendParametersCable::Modulation::Auto
+                       && ocable.modulation != eDVBFrontendParametersCable::Modulation::Auto)

                        diff = 1 << 29;
                        diff = 1 << 29;

-               else if (cable.inversion != ocable.inversion && cable.inversion != eDVBFrontendParametersCable::Inversion::Unknown && ocable.inversion != eDVBFrontendParametersCable::Inversion::Unknown)
-                       diff = 1 << 28;
+               else if (exact && cable.fec_inner != ocable.fec_inner && cable.fec_inner != eDVBFrontendParametersCable::FEC::fAuto && ocable.fec_inner != eDVBFrontendParametersCable::FEC::fAuto)
+                       diff = 1 << 27;

                else
                {
                        diff = abs(cable.frequency - ocable.frequency);
                        diff += abs(cable.symbol_rate - ocable.symbol_rate);
                }
                else
                {
                        diff = abs(cable.frequency - ocable.frequency);
                        diff += abs(cable.symbol_rate - ocable.symbol_rate);
                }

-

                return 0;
        case iDVBFrontend::feTerrestrial:
                eDVBFrontendParametersTerrestrial oterrestrial;
                if (parm->getDVBT(oterrestrial))
                        return -2;
 
                return 0;
        case iDVBFrontend::feTerrestrial:
                eDVBFrontendParametersTerrestrial oterrestrial;
                if (parm->getDVBT(oterrestrial))
                        return -2;
 

-               diff = abs(terrestrial.frequency - oterrestrial.frequency);

 
 

+               if (exact && oterrestrial.bandwidth != terrestrial.bandwidth &&
+                       oterrestrial.bandwidth != eDVBFrontendParametersTerrestrial::Bandwidth::BwAuto &&
+                       terrestrial.bandwidth != eDVBFrontendParametersTerrestrial::Bandwidth::BwAuto)
+                       diff = 1 << 30;
+               else if (exact && oterrestrial.modulation != terrestrial.modulation &&
+                       oterrestrial.modulation != eDVBFrontendParametersTerrestrial::Modulation::Auto &&
+                       terrestrial.modulation != eDVBFrontendParametersTerrestrial::Modulation::Auto)
+                       diff = 1 << 30;
+               else if (exact && oterrestrial.transmission_mode != terrestrial.transmission_mode &&
+                       oterrestrial.transmission_mode != eDVBFrontendParametersTerrestrial::TransmissionMode::TMAuto &&
+                       terrestrial.transmission_mode != eDVBFrontendParametersTerrestrial::TransmissionMode::TMAuto)
+                       diff = 1 << 30;
+               else if (exact && oterrestrial.guard_interval != terrestrial.guard_interval &&
+                       oterrestrial.guard_interval != eDVBFrontendParametersTerrestrial::GuardInterval::GI_Auto &&
+                       terrestrial.guard_interval != eDVBFrontendParametersTerrestrial::GuardInterval::GI_Auto)
+                       diff = 1 << 30;
+               else if (exact && oterrestrial.hierarchy != terrestrial.hierarchy &&
+                       oterrestrial.hierarchy != eDVBFrontendParametersTerrestrial::Hierarchy::HAuto &&
+                       terrestrial.hierarchy != eDVBFrontendParametersTerrestrial::Hierarchy::HAuto)
+                       diff = 1 << 30;
+               else if (exact && oterrestrial.code_rate_LP != terrestrial.code_rate_LP &&
+                       oterrestrial.code_rate_LP != eDVBFrontendParametersTerrestrial::FEC::fAuto &&
+                       terrestrial.code_rate_LP != eDVBFrontendParametersTerrestrial::FEC::fAuto)
+                       diff = 1 << 30;
+               else if (exact && oterrestrial.code_rate_HP != terrestrial.code_rate_HP &&
+                       oterrestrial.code_rate_HP != eDVBFrontendParametersTerrestrial::FEC::fAuto &&
+                       terrestrial.code_rate_HP != eDVBFrontendParametersTerrestrial::FEC::fAuto)
+                       diff = 1 << 30;
+               else
+                       diff = abs(terrestrial.frequency - oterrestrial.frequency);

                return 0;
        default:
                return -1;
                return 0;
        default:
                return -1;


@@ -351,7 +383,8 @@ RESULT eDVBFrontendParameters::getHash(unsigned long &hash) const
 DEFINE_REF(eDVBFrontend);
 
 eDVBFrontend::eDVBFrontend(int adap, int fe, int &ok)
 DEFINE_REF(eDVBFrontend);
 
 eDVBFrontend::eDVBFrontend(int adap, int fe, int &ok)

-       :m_type(-1), m_fe(fe), m_fd(-1), m_sn(0), m_timeout(0), m_tuneTimer(0)
+       :m_enabled(false), m_type(-1), m_dvbid(fe), m_slotid(fe)
+       ,m_fd(-1), m_need_rotor_workaround(false), m_sn(0), m_timeout(0), m_tuneTimer(0)

 #if HAVE_DVB_API_VERSION < 3
        ,m_secfd(-1)
 #endif
 #if HAVE_DVB_API_VERSION < 3
        ,m_secfd(-1)
 #endif


@@ -386,37 +419,22 @@ int eDVBFrontend::openFrontend()
        m_tuning=0;
 
 #if HAVE_DVB_API_VERSION < 3
        m_tuning=0;
 
 #if HAVE_DVB_API_VERSION < 3

-       if (m_secfd < 0)
-       {
-               m_secfd = ::open(m_sec_filename, O_RDWR);
-               if (m_secfd < 0)
-               {
-                       eWarning("failed! (%s) %m", m_sec_filename);
-                       return -1;
-               }
-       }
-       else
-               eWarning("sec %d already opened", m_fe);

        FrontendInfo fe_info;
 #else
        dvb_frontend_info fe_info;
 #endif
        FrontendInfo fe_info;
 #else
        dvb_frontend_info fe_info;
 #endif

-       eDebug("opening frontend %d", m_fe);
+       eDebug("opening frontend %d", m_dvbid);

        if (m_fd < 0)
        {
                m_fd = ::open(m_filename, O_RDWR|O_NONBLOCK);
                if (m_fd < 0)
                {
                        eWarning("failed! (%s) %m", m_filename);
        if (m_fd < 0)
        {
                m_fd = ::open(m_filename, O_RDWR|O_NONBLOCK);
                if (m_fd < 0)
                {
                        eWarning("failed! (%s) %m", m_filename);

-#if HAVE_DVB_API_VERSION < 3
-                       ::close(m_secfd);
-                       m_secfd=-1;
-#endif

                        return -1;
                }
        }
        else
                        return -1;
                }
        }
        else

-               eWarning("frontend %d already opened", m_fe);
+               eWarning("frontend %d already opened", m_dvbid);

        if (m_type == -1)
        {
                if (::ioctl(m_fd, FE_GET_INFO, &fe_info) < 0)
        if (m_type == -1)
        {
                if (::ioctl(m_fd, FE_GET_INFO, &fe_info) < 0)


@@ -424,10 +442,6 @@ int eDVBFrontend::openFrontend()
                        eWarning("ioctl FE_GET_INFO failed");
                        ::close(m_fd);
                        m_fd = -1;
                        eWarning("ioctl FE_GET_INFO failed");
                        ::close(m_fd);
                        m_fd = -1;

-#if HAVE_DVB_API_VERSION < 3
-                       ::close(m_secfd);
-                       m_secfd=-1;
-#endif

                        return -1;
                }
 
                        return -1;
                }
 


@@ -446,15 +460,30 @@ int eDVBFrontend::openFrontend()
                        eWarning("unknown frontend type.");
                        ::close(m_fd);
                        m_fd = -1;
                        eWarning("unknown frontend type.");
                        ::close(m_fd);
                        m_fd = -1;

-#if HAVE_DVB_API_VERSION < 3
-                       ::close(m_secfd);
-                       m_secfd=-1;
-#endif

                        return -1;
                }
                eDebug("detected %s frontend", "satellite\0cable\0    terrestrial"+fe_info.type*10);
        }
 
                        return -1;
                }
                eDebug("detected %s frontend", "satellite\0cable\0    terrestrial"+fe_info.type*10);
        }
 

+#if HAVE_DVB_API_VERSION < 3
+       if (m_type == iDVBFrontend::feSatellite)
+       {
+                       if (m_secfd < 0)
+                       {
+                               m_secfd = ::open(m_sec_filename, O_RDWR);
+                               if (m_secfd < 0)
+                               {
+                                       eWarning("failed! (%s) %m", m_sec_filename);
+                                       ::close(m_fd);
+                                       m_fd=-1;
+                                       return -1;
+                               }
+                       }
+                       else
+                               eWarning("sec %d already opened", m_dvbid);
+       }
+#endif
+

        setTone(iDVBFrontend::toneOff);
        setVoltage(iDVBFrontend::voltageOff);
 
        setTone(iDVBFrontend::toneOff);
        setVoltage(iDVBFrontend::voltageOff);
 


@@ -471,15 +500,15 @@ int eDVBFrontend::closeFrontend()
        {
                if (linked_fe->m_inuse)
                {
        {
                if (linked_fe->m_inuse)
                {

-                       eDebug("dont close frontend %d until the linked frontend %d is still in use",
-                               m_fe, linked_fe->m_frontend->getID());
+                       eDebug("dont close frontend %d until the linked frontend %d in slot %d is still in use",
+                               m_dvbid, linked_fe->m_frontend->getDVBID(), linked_fe->m_frontend->getSlotID());

                        return -1;
                }
                linked_fe->m_frontend->getData(LINKED_NEXT_PTR, (int&)linked_fe);
        }
        if (m_fd >= 0)
        {
                        return -1;
                }
                linked_fe->m_frontend->getData(LINKED_NEXT_PTR, (int&)linked_fe);
        }
        if (m_fd >= 0)
        {

-               eDebug("close frontend %d", m_fe);
+               eDebug("close frontend %d", m_dvbid);

                m_tuneTimer->stop();
                setTone(iDVBFrontend::toneOff);
                setVoltage(iDVBFrontend::voltageOff);
                m_tuneTimer->stop();
                setTone(iDVBFrontend::toneOff);
                setVoltage(iDVBFrontend::voltageOff);


@@ -488,7 +517,7 @@ int eDVBFrontend::closeFrontend()
                if (!::close(m_fd))
                        m_fd=-1;
                else
                if (!::close(m_fd))
                        m_fd=-1;
                else

-                       eWarning("couldnt close frontend %d", m_fe);
+                       eWarning("couldnt close frontend %d", m_dvbid);

                m_data[CSW] = m_data[UCSW] = m_data[TONEBURST] = -1;
        }
 #if HAVE_DVB_API_VERSION < 3
                m_data[CSW] = m_data[UCSW] = m_data[TONEBURST] = -1;
        }
 #if HAVE_DVB_API_VERSION < 3


@@ -497,7 +526,7 @@ int eDVBFrontend::closeFrontend()
                if (!::close(m_secfd))
                        m_secfd=-1;
                else
                if (!::close(m_secfd))
                        m_secfd=-1;
                else

-                       eWarning("couldnt close sec %d", m_fe);
+                       eWarning("couldnt close sec %d", m_dvbid);

        }
 #endif
        delete m_sn;
        }
 #endif
        delete m_sn;


@@ -541,14 +570,11 @@ void eDVBFrontend::feEvent(int w)
 #if HAVE_DVB_API_VERSION < 3
                if (event.type == FE_COMPLETION_EV)
 #else
 #if HAVE_DVB_API_VERSION < 3
                if (event.type == FE_COMPLETION_EV)
 #else

-               eDebug("(%d)fe event: status %x, inversion %s", m_fe, event.status, (event.parameters.inversion == INVERSION_ON) ? "on" : "off");
+               eDebug("(%d)fe event: status %x, inversion %s", m_dvbid, event.status, (event.parameters.inversion == INVERSION_ON) ? "on" : "off");

                if (event.status & FE_HAS_LOCK)
 #endif
                {
                        state = stateLock;
                if (event.status & FE_HAS_LOCK)
 #endif
                {
                        state = stateLock;

-                       m_data[CSW] = m_data[NEW_CSW];
-                       m_data[UCSW] = m_data[NEW_UCSW];
-                       m_data[TONEBURST] = m_data[NEW_TONEBURST];

                } else
                {
                        if (m_tuning)
                } else
                {
                        if (m_tuning)


@@ -596,6 +622,56 @@ int eDVBFrontend::readFrontendData(int type)
                                eDebug("FE_READ_SNR failed (%m)");
                        return snr;
                }
                                eDebug("FE_READ_SNR failed (%m)");
                        return snr;
                }

+               case signalPowerdB: /* this will move into the driver */
+               {
+                       uint16_t snr=0;
+                       if (ioctl(m_fd, FE_READ_SNR, &snr) < 0 && errno != ERANGE)
+                               eDebug("FE_READ_SNR failed (%m)");
+                       if (!strcmp(m_description, "BCM4501 (internal)"))
+                       {
+                               unsigned int SDS_SNRE = snr << 16;
+
+                               static float SNR_COEFF[6] = {
+                                       100.0 / 4194304.0,
+                                       -7136.0 / 4194304.0,
+                                       197418.0 / 4194304.0,
+                                       -2602183.0 / 4194304.0,
+                                       20377212.0 / 4194304.0,
+                                       -37791203.0 / 4194304.0,
+                               };
+                       
+                               float fval1, fval2, snr_in_db;
+                               int i;
+                               fval1 = 12.44714 - (2.0 * log10(SDS_SNRE / 256.0));
+                               fval2 = pow(10.0, fval1)-1;
+                               fval1 = 10.0 * log10(fval2);
+                       
+                               if (fval1 < 10.0)
+                               {
+                                       fval2 = SNR_COEFF[0];
+                                       for (i=0; i<6; ++i)
+                                       {
+                                               fval2 *= fval1;
+                                               fval2 += SNR_COEFF[i];
+                                       }
+                                       fval1 = fval2;
+                               }
+                               snr_in_db = fval1;
+                       
+                               return (int)(snr_in_db * 100.0);
+                       }
+                       else if (!strcmp(m_description, "Alps BSBE1 702A") ||  // some frontends with STV0299
+                               !strcmp(m_description, "Alps -S") ||
+                               !strcmp(m_description, "Philips -S") ||
+                               !strcmp(m_description, "LG -S") )
+                       {
+                               float snr_in_db=(snr-39075)/1764.7;
+                               return (int)(snr_in_db * 100.0);
+                       }
+                       else
+                               eDebug("no SNR dB caluclation for frontendtype %s yet", m_description);
+                       return 0x12345678;
+               }

                case signalQuality:
                {
                        uint16_t strength=0;
                case signalQuality:
                {
                        uint16_t strength=0;


@@ -626,14 +702,14 @@ int eDVBFrontend::readFrontendData(int type)
                        return !!(status&FE_HAS_SYNC);
                }
                case frontendNumber:
                        return !!(status&FE_HAS_SYNC);
                }
                case frontendNumber:

-                       return m_fe;
+                       return m_slotid;

        }
        return 0;
 }
 
        }
        return 0;
 }
 

-void PutToDict(PyObject *dict, const char*key, long value)
+void PutToDict(ePyObject &dict, const char*key, long value)

 {
 {

-       PyObject *item = PyInt_FromLong(value);
+       ePyObject item = PyInt_FromLong(value);

        if (item)
        {
                if (PyDict_SetItemString(dict, key, item))
        if (item)
        {
                if (PyDict_SetItemString(dict, key, item))


@@ -644,9 +720,21 @@ void PutToDict(PyObject *dict, const char*key, long value)
                eDebug("could not create PyObject for %s", key);
 }
 
                eDebug("could not create PyObject for %s", key);
 }
 

-void PutToDict(PyObject *dict, const char*key, const char *value)
+void PutToDict(ePyObject &dict, const char*key, ePyObject item)
+{
+       if (item)
+       {
+               if (PyDict_SetItemString(dict, key, item))
+                       eDebug("put %s to dict failed", key);
+               Py_DECREF(item);
+       }
+       else
+               eDebug("invalid PyObject for %s", key);
+}
+
+void PutToDict(ePyObject &dict, const char*key, const char *value)

 {
 {

-       PyObject *item = PyString_FromString(value);
+       ePyObject item = PyString_FromString(value);

        if (item)
        {
                if (PyDict_SetItemString(dict, key, item))
        if (item)
        {
                if (PyDict_SetItemString(dict, key, item))


@@ -657,7 +745,7 @@ void PutToDict(PyObject *dict, const char*key, const char *value)
                eDebug("could not create PyObject for %s", key);
 }
 
                eDebug("could not create PyObject for %s", key);
 }
 

-void fillDictWithSatelliteData(PyObject *dict, const FRONTENDPARAMETERS &parm, eDVBFrontend *fe)
+void fillDictWithSatelliteData(ePyObject dict, const FRONTENDPARAMETERS &parm, eDVBFrontend *fe)

 {
        int freq_offset=0;
        int csw=0;
 {
        int freq_offset=0;
        int csw=0;


@@ -741,7 +829,7 @@ void fillDictWithSatelliteData(PyObject *dict, const FRONTENDPARAMETERS &parm, e
        PutToDict(dict, "system", tmp);
 }
 
        PutToDict(dict, "system", tmp);
 }
 

-void fillDictWithCableData(PyObject *dict, const FRONTENDPARAMETERS &parm)
+void fillDictWithCableData(ePyObject dict, const FRONTENDPARAMETERS &parm)

 {
        const char *tmp=0;
        PutToDict(dict, "frequency", parm_frequency/1000);
 {
        const char *tmp=0;
        PutToDict(dict, "frequency", parm_frequency/1000);


@@ -802,7 +890,7 @@ void fillDictWithCableData(PyObject *dict, const FRONTENDPARAMETERS &parm)
        PutToDict(dict, "modulation", tmp);
 }
 
        PutToDict(dict, "modulation", tmp);
 }
 

-void fillDictWithTerrestrialData(PyObject *dict, const FRONTENDPARAMETERS &parm)
+void fillDictWithTerrestrialData(ePyObject dict, const FRONTENDPARAMETERS &parm)

 {
        const char *tmp=0;
        PutToDict(dict, "frequency", parm_frequency);
 {
        const char *tmp=0;
        PutToDict(dict, "frequency", parm_frequency);


@@ -942,17 +1030,106 @@ void fillDictWithTerrestrialData(PyObject *dict, const FRONTENDPARAMETERS &parm)
        PutToDict(dict, "hierarchy_information", tmp);
 }
 
        PutToDict(dict, "hierarchy_information", tmp);
 }
 

-PyObject *eDVBFrontend::readTransponderData(bool original)
+void eDVBFrontend::getFrontendStatus(ePyObject dest)

 {
 {

-       PyObject *ret=PyDict_New();
+       if (dest && PyDict_Check(dest))
+       {
+               const char *tmp = "UNKNOWN";
+               switch(m_state)
+               {
+                       case stateIdle:
+                               tmp="IDLE";
+                               break;
+                       case stateTuning:
+                               tmp="TUNING";
+                               break;
+                       case stateFailed:
+                               tmp="FAILED";
+                               break;
+                       case stateLock:
+                               tmp="LOCKED";
+                               break;
+                       case stateLostLock:
+                               tmp="LOSTLOCK";
+                               break;
+                       default:
+                               break;
+               }
+               PutToDict(dest, "tuner_state", tmp);
+               PutToDict(dest, "tuner_locked", readFrontendData(locked));
+               PutToDict(dest, "tuner_synced", readFrontendData(synced));
+               PutToDict(dest, "tuner_bit_error_rate", readFrontendData(bitErrorRate));
+               PutToDict(dest, "tuner_signal_power", readFrontendData(signalPower));
+               int sigPowerdB = readFrontendData(signalPowerdB);
+               if (sigPowerdB == 0x12345678) // not support yet
+               {
+                       ePyObject obj=Py_None;
+                       Py_INCREF(obj);
+                       PutToDict(dest, "tuner_signal_power_db", obj);
+               }
+               else
+                       PutToDict(dest, "tuner_signal_power_db", sigPowerdB);
+               PutToDict(dest, "tuner_signal_quality", readFrontendData(signalQuality));
+       }
+}

 
 

-       if (ret)
+void eDVBFrontend::getTransponderData(ePyObject dest, bool original)
+{
+       if (m_fd != -1 && dest && PyDict_Check(dest))

        {
        {

-               bool read=m_fd != -1;
-               const char *tmp=0;
+               switch(m_type)
+               {
+                       case feSatellite:
+                       case feCable:
+                       case feTerrestrial:
+                       {
+                               FRONTENDPARAMETERS front;
+                               if (!original && ioctl(m_fd, FE_GET_FRONTEND, &front)<0)
+                                       eDebug("FE_GET_FRONTEND (%m)");
+                               else
+                               {
+                                       const FRONTENDPARAMETERS &parm = original ? this->parm : front;
+                                       const char *tmp = "INVERSION_AUTO";
+                                       switch(parm_inversion)
+                                       {
+                                               case INVERSION_ON:
+                                                       tmp = "INVERSION_ON";
+                                                       break;
+                                               case INVERSION_OFF:
+                                                       tmp = "INVERSION_OFF";
+                                                       break;
+                                               default:
+                                                       break;
+                                       }
+                                       if (tmp)
+                                               PutToDict(dest, "inversion", tmp);

 
 

-               PutToDict(ret, "tuner_number", m_fe);
+                                       switch(m_type)
+                                       {
+                                               case feSatellite:
+                                                       fillDictWithSatelliteData(dest, original?parm:front, this);
+                                                       break;
+                                               case feCable:
+                                                       fillDictWithCableData(dest, original?parm:front);
+                                                       break;
+                                               case feTerrestrial:
+                                                       fillDictWithTerrestrialData(dest, original?parm:front);
+                                                       break;
+                                       }
+                               }
+                       }
+                       default:
+                               break;
+               }
+       }
+}

 
 

+void eDVBFrontend::getFrontendData(ePyObject dest)
+{
+       if (dest && PyDict_Check(dest))
+       {
+               const char *tmp=0;
+               PutToDict(dest, "tuner_number", m_dvbid);

                switch(m_type)
                {
                        case feSatellite:
                switch(m_type)
                {
                        case feSatellite:


@@ -966,84 +1143,10 @@ PyObject *eDVBFrontend::readTransponderData(bool original)
                                break;
                        default:
                                tmp = "UNKNOWN";
                                break;
                        default:
                                tmp = "UNKNOWN";

-                               read=false;

                                break;
                }
                                break;
                }

-               PutToDict(ret, "tuner_type", tmp);
-
-               if (read)
-               {
-                       FRONTENDPARAMETERS front;
-
-                       tmp = "UNKNOWN";
-                       switch(m_state)
-                       {
-                               case stateIdle:
-                                       tmp="IDLE";
-                                       break;
-                               case stateTuning:
-                                       tmp="TUNING";
-                                       break;
-                               case stateFailed:
-                                       tmp="FAILED";
-                                       break;
-                               case stateLock:
-                                       tmp="LOCKED";
-                                       break;
-                               case stateLostLock:
-                                       tmp="LOSTLOCK";
-                                       break;
-                               default:
-                                       break;
-                       }
-                       PutToDict(ret, "tuner_state", tmp);
-
-                       PutToDict(ret, "tuner_locked", readFrontendData(locked));
-                       PutToDict(ret, "tuner_synced", readFrontendData(synced));
-                       PutToDict(ret, "tuner_bit_error_rate", readFrontendData(bitErrorRate));
-                       PutToDict(ret, "tuner_signal_power", readFrontendData(signalPower));
-                       PutToDict(ret, "tuner_signal_quality", readFrontendData(signalQuality));
-
-                       if (!original && ioctl(m_fd, FE_GET_FRONTEND, &front)<0)
-                               eDebug("FE_GET_FRONTEND (%m)");
-                       else
-                       {
-                               tmp = "INVERSION_AUTO";
-                               switch(parm_inversion)
-                               {
-                                       case INVERSION_ON:
-                                               tmp = "INVERSION_ON";
-                                               break;
-                                       case INVERSION_OFF:
-                                               tmp = "INVERSION_OFF";
-                                               break;
-                                       default:
-                                               break;
-                               }
-                               if (tmp)
-                                       PutToDict(ret, "inversion", tmp);
-
-                               switch(m_type)
-                               {
-                                       case feSatellite:
-                                               fillDictWithSatelliteData(ret, original?parm:front, this);
-                                               break;
-                                       case feCable:
-                                               fillDictWithCableData(ret, original?parm:front);
-                                               break;
-                                       case feTerrestrial:
-                                               fillDictWithTerrestrialData(ret, original?parm:front);
-                                               break;
-                               }
-                       }
-               }
-       }
-       else
-       {
-               Py_INCREF(Py_None);
-               ret = Py_None;
+               PutToDict(dest, "tuner_type", tmp);

        }
        }

-       return ret;

 }
 
 #ifndef FP_IOCTL_GET_ID
 }
 
 #ifndef FP_IOCTL_GET_ID


@@ -1051,7 +1154,7 @@ PyObject *eDVBFrontend::readTransponderData(bool original)
 #endif
 int eDVBFrontend::readInputpower()
 {
 #endif
 int eDVBFrontend::readInputpower()
 {

-       int power=m_fe;  // this is needed for read inputpower from the correct tuner !
+       int power=m_slotid;  // this is needed for read inputpower from the correct tuner !

 
        // open front prozessor
        int fp=::open("/dev/dbox/fp0", O_RDWR);
 
        // open front prozessor
        int fp=::open("/dev/dbox/fp0", O_RDWR);


@@ -1091,6 +1194,35 @@ bool eDVBFrontend::setSecSequencePos(int steps)
        return true;
 }
 
        return true;
 }
 

+void eDVBFrontend::setRotorData(int pos, int cmd)
+{
+       m_data[ROTOR_CMD] = cmd;
+       m_data[ROTOR_POS] = pos;
+       if ( m_data[SATPOS_DEPENDS_PTR] != -1 )
+       {
+               eDVBRegisteredFrontend *satpos_depends_to_fe = (eDVBRegisteredFrontend*) m_data[SATPOS_DEPENDS_PTR];
+               satpos_depends_to_fe->m_frontend->m_data[ROTOR_CMD] = cmd;
+               satpos_depends_to_fe->m_frontend->m_data[ROTOR_POS] = pos;
+       }
+       else
+       {
+               eDVBRegisteredFrontend *next = (eDVBRegisteredFrontend *)m_data[LINKED_NEXT_PTR];
+               while ( (int)next != -1 )
+               {
+                       next->m_frontend->m_data[ROTOR_CMD] = cmd;
+                       next->m_frontend->m_data[ROTOR_POS] = pos;
+                       next = (eDVBRegisteredFrontend *)next->m_frontend->m_data[LINKED_NEXT_PTR];
+               }
+               eDVBRegisteredFrontend *prev = (eDVBRegisteredFrontend *)m_data[LINKED_PREV_PTR];
+               while ( (int)prev != -1 )
+               {
+                       prev->m_frontend->m_data[ROTOR_CMD] = cmd;
+                       prev->m_frontend->m_data[ROTOR_POS] = pos;
+                       prev = (eDVBRegisteredFrontend *)prev->m_frontend->m_data[LINKED_PREV_PTR];
+               }
+       }
+}
+

 void eDVBFrontend::tuneLoop()  // called by m_tuneTimer
 {
        int delay=0;
 void eDVBFrontend::tuneLoop()  // called by m_tuneTimer
 {
        int delay=0;


@@ -1117,7 +1249,7 @@ void eDVBFrontend::tuneLoop()  // called by m_tuneTimer
                        case eSecCommand::IF_VOLTAGE_GOTO:
                        {
                                eSecCommand::pair &compare = m_sec_sequence.current()->compare;
                        case eSecCommand::IF_VOLTAGE_GOTO:
                        {
                                eSecCommand::pair &compare = m_sec_sequence.current()->compare;

-                               if ( compare.voltage == m_curVoltage && setSecSequencePos(compare.steps) )
+                               if ( compare.voltage == m_data[CUR_VOLTAGE] && setSecSequencePos(compare.steps) )

                                        break;
                                ++m_sec_sequence.current();
                                break;
                                        break;
                                ++m_sec_sequence.current();
                                break;


@@ -1125,7 +1257,23 @@ void eDVBFrontend::tuneLoop()  // called by m_tuneTimer
                        case eSecCommand::IF_NOT_VOLTAGE_GOTO:
                        {
                                eSecCommand::pair &compare = m_sec_sequence.current()->compare;
                        case eSecCommand::IF_NOT_VOLTAGE_GOTO:
                        {
                                eSecCommand::pair &compare = m_sec_sequence.current()->compare;

-                               if ( compare.voltage != m_curVoltage && setSecSequencePos(compare.steps) )
+                               if ( compare.voltage != m_data[CUR_VOLTAGE] && setSecSequencePos(compare.steps) )
+                                       break;
+                               ++m_sec_sequence.current();
+                               break;
+                       }
+                       case eSecCommand::IF_TONE_GOTO:
+                       {
+                               eSecCommand::pair &compare = m_sec_sequence.current()->compare;
+                               if ( compare.tone == m_data[CUR_TONE] && setSecSequencePos(compare.steps) )
+                                       break;
+                               ++m_sec_sequence.current();
+                               break;
+                       }
+                       case eSecCommand::IF_NOT_TONE_GOTO:
+                       {
+                               eSecCommand::pair &compare = m_sec_sequence.current()->compare;
+                               if ( compare.tone != m_data[CUR_TONE] && setSecSequencePos(compare.steps) )

                                        break;
                                ++m_sec_sequence.current();
                                break;
                                        break;
                                ++m_sec_sequence.current();
                                break;


@@ -1184,7 +1332,7 @@ void eDVBFrontend::tuneLoop()  // called by m_tuneTimer
                        case eSecCommand::IF_MEASURE_IDLE_WAS_NOT_OK_GOTO:
                        {
                                eSecCommand::pair &compare = m_sec_sequence.current()->compare;
                        case eSecCommand::IF_MEASURE_IDLE_WAS_NOT_OK_GOTO:
                        {
                                eSecCommand::pair &compare = m_sec_sequence.current()->compare;

-                               int idx = compare.voltage;
+                               int idx = compare.val;

                                if ( idx == 0 || idx == 1 )
                                {
                                        int idle = readInputpower();
                                if ( idx == 0 || idx == 1 )
                                {
                                        int idle = readInputpower();


@@ -1231,7 +1379,7 @@ void eDVBFrontend::tuneLoop()  // called by m_tuneTimer
                                break;
                        case eSecCommand::IF_INPUTPOWER_DELTA_GOTO:
                        {
                                break;
                        case eSecCommand::IF_INPUTPOWER_DELTA_GOTO:
                        {

-                               int idleInputpower = m_idleInputpower[ (m_curVoltage&1) ? 0 : 1];
+                               int idleInputpower = m_idleInputpower[ (m_data[CUR_VOLTAGE]&1) ? 0 : 1];

                                eSecCommand::rotor &cmd = m_sec_sequence.current()->measure;
                                const char *txt = cmd.direction ? "running" : "stopped";
                                eDebug("[SEC] waiting for rotor %s %d, idle %d, delta %d",
                                eSecCommand::rotor &cmd = m_sec_sequence.current()->measure;
                                const char *txt = cmd.direction ? "running" : "stopped";
                                eDebug("[SEC] waiting for rotor %s %d, idle %d, delta %d",


@@ -1270,14 +1418,13 @@ void eDVBFrontend::tuneLoop()  // called by m_tuneTimer
                                        ++m_sec_sequence.current();
                                break;
                        case eSecCommand::INVALIDATE_CURRENT_ROTORPARMS:
                                        ++m_sec_sequence.current();
                                break;
                        case eSecCommand::INVALIDATE_CURRENT_ROTORPARMS:

-                               m_data[ROTOR_CMD] = m_data[ROTOR_POS] = -1;

                                eDebug("[SEC] invalidate current rotorparams");
                                eDebug("[SEC] invalidate current rotorparams");

+                               setRotorData(-1,-1);    

                                ++m_sec_sequence.current();
                                break;
                        case eSecCommand::UPDATE_CURRENT_ROTORPARAMS:
                                ++m_sec_sequence.current();
                                break;
                        case eSecCommand::UPDATE_CURRENT_ROTORPARAMS:

-                               m_data[ROTOR_CMD] = m_data[NEW_ROTOR_CMD];
-                               m_data[ROTOR_POS] = m_data[NEW_ROTOR_POS];
-                               eDebug("[SEC] update current rotorparams %d %04x %d", m_timeoutCount, m_data[5], m_data[6]);
+                               setRotorData(m_data[NEW_ROTOR_POS], m_data[NEW_ROTOR_CMD]);
+                               eDebug("[SEC] update current rotorparams %d %04x %d", m_timeoutCount, m_data[ROTOR_CMD], m_data[ROTOR_POS]);

                                ++m_sec_sequence.current();
                                break;
                        case eSecCommand::SET_ROTOR_DISEQC_RETRYS:
                                ++m_sec_sequence.current();
                                break;
                        case eSecCommand::SET_ROTOR_DISEQC_RETRYS:


@@ -1295,9 +1442,19 @@ void eDVBFrontend::tuneLoop()  // called by m_tuneTimer
                                break;
                        case eSecCommand::SET_POWER_LIMITING_MODE:
                        {
                                break;
                        case eSecCommand::SET_POWER_LIMITING_MODE:
                        {

-                               int fd = m_fe ?
-                                       ::open("/dev/i2c/1", O_RDWR) :
-                                       ::open("/dev/i2c/0", O_RDWR);
+                               if (!m_need_rotor_workaround)
+                                       break;
+
+                               char dev[16];
+
+                               // FIXMEEEEEE hardcoded i2c devices for dm7025 and dm8000
+                               if (m_slotid < 2)
+                                       sprintf(dev, "/dev/i2c/%d", m_slotid);
+                               else if (m_slotid == 2)
+                                       sprintf(dev, "/dev/i2c/2"); // first nim socket on DM8000 use /dev/i2c/2
+                               else if (m_slotid == 3)
+                                       sprintf(dev, "/dev/i2c/4"); // second nim socket on DM8000 use /dev/i2c/4
+                               int fd = ::open(dev, O_RDWR);

 
                                unsigned char data[2];
                                ::ioctl(fd, I2C_SLAVE_FORCE, 0x10 >> 1);
 
                                unsigned char data[2];
                                ::ioctl(fd, I2C_SLAVE_FORCE, 0x10 >> 1);


@@ -1320,8 +1477,9 @@ void eDVBFrontend::tuneLoop()  // called by m_tuneTimer
                                break;
                        }
                        default:
                                break;
                        }
                        default:

+                               eDebug("[SEC] unhandled sec command %d",
+                                       ++m_sec_sequence.current()->cmd);

                                ++m_sec_sequence.current();
                                ++m_sec_sequence.current();

-                               eDebug("[SEC] unhandled sec command");

                }
                m_tuneTimer->start(delay,true);
        }
                }
                m_tuneTimer->start(delay,true);
        }


@@ -1329,7 +1487,7 @@ void eDVBFrontend::tuneLoop()  // called by m_tuneTimer
 
 void eDVBFrontend::setFrontend()
 {
 
 void eDVBFrontend::setFrontend()
 {

-       eDebug("setting frontend %d", m_fe);
+       eDebug("setting frontend %d", m_dvbid);

        m_sn->start();
        feEvent(-1);
        if (ioctl(m_fd, FE_SET_FRONTEND, &parm) == -1)
        m_sn->start();
        feEvent(-1);
        if (ioctl(m_fd, FE_SET_FRONTEND, &parm) == -1)


@@ -1355,16 +1513,17 @@ RESULT eDVBFrontend::prepare_sat(const eDVBFrontendParametersSatellite &feparm)
                eWarning("no SEC module active!");
                return -ENOENT;
        }
                eWarning("no SEC module active!");
                return -ENOENT;
        }

-       res = m_sec->prepare(*this, parm, feparm, 1 << m_fe);
+       res = m_sec->prepare(*this, parm, feparm, 1 << m_slotid);

        if (!res)
        {
        if (!res)
        {

-               eDebug("prepare_sat System %d Freq %d Pol %d SR %d INV %d FEC %d",
+               eDebug("prepare_sat System %d Freq %d Pol %d SR %d INV %d FEC %d orbpos %d",

                        feparm.system,
                        feparm.frequency,
                        feparm.polarisation,
                        feparm.symbol_rate,
                        feparm.inversion,
                        feparm.system,
                        feparm.frequency,
                        feparm.polarisation,
                        feparm.symbol_rate,
                        feparm.inversion,

-                       feparm.fec);
+                       feparm.fec,
+                       feparm.orbital_position);

                parm_u_qpsk_symbol_rate = feparm.symbol_rate;
                switch (feparm.inversion)
                {
                parm_u_qpsk_symbol_rate = feparm.symbol_rate;
                switch (feparm.inversion)
                {


@@ -1527,6 +1686,12 @@ RESULT eDVBFrontend::prepare_cable(const eDVBFrontendParametersCable &feparm)
                parm_u_qam_fec_inner = FEC_AUTO;
                break;
        }
                parm_u_qam_fec_inner = FEC_AUTO;
                break;
        }

+       eDebug("tuning to %d khz, sr %d, fec %d, modulation %d, inversion %d",
+               parm_frequency/1000,
+               parm_u_qam_symbol_rate,
+               parm_u_qam_fec_inner,
+               parm_u_qam_modulation,
+               parm_inversion);

        return 0;
 }
 
        return 0;
 }
 


@@ -1679,14 +1844,24 @@ RESULT eDVBFrontend::prepare_terrestrial(const eDVBFrontendParametersTerrestrial
 
 RESULT eDVBFrontend::tune(const iDVBFrontendParameters &where)
 {
 
 RESULT eDVBFrontend::tune(const iDVBFrontendParameters &where)
 {

-       eDebug("(%d)tune", m_fe);
+       eDebug("(%d)tune", m_dvbid);

 
        m_timeout->stop();
 
        int res=0;
 
 
        m_timeout->stop();
 
        int res=0;
 

+       if (!m_sn)
+       {
+               eDebug("no frontend device opened... do not try to tune !!!");
+               res = -ENODEV;
+               goto tune_error;
+       }
+

        if (m_type == -1)
        if (m_type == -1)

-               return -ENODEV;
+       {
+               res = -ENODEV;
+               goto tune_error;
+       }

 
        m_sn->stop();
        m_sec_sequence.clear();
 
        m_sn->stop();
        m_sec_sequence.clear();


@@ -1699,23 +1874,30 @@ RESULT eDVBFrontend::tune(const iDVBFrontendParameters &where)
                if (where.getDVBS(feparm))
                {
                        eDebug("no dvbs data!");
                if (where.getDVBS(feparm))
                {
                        eDebug("no dvbs data!");

-                       return -EINVAL;
+                       res = -EINVAL;
+                       goto tune_error;

                }
                }

-               res=prepare_sat(feparm);

                m_sec->setRotorMoving(false);
                m_sec->setRotorMoving(false);

+               res=prepare_sat(feparm);
+               if (res)
+                       goto tune_error;
+

                break;
        }
        case feCable:
        {
                eDVBFrontendParametersCable feparm;
                if (where.getDVBC(feparm))
                break;
        }
        case feCable:
        {
                eDVBFrontendParametersCable feparm;
                if (where.getDVBC(feparm))

-                       return -EINVAL;
-               res=prepare_cable(feparm);
-               if (!res)

                {
                {

-                       m_sec_sequence.push_back( eSecCommand(eSecCommand::START_TUNE_TIMEOUT) );
-                       m_sec_sequence.push_back( eSecCommand(eSecCommand::SET_FRONTEND) );
+                       res = -EINVAL;
+                       goto tune_error;

                }
                }

+               res=prepare_cable(feparm);
+               if (res)
+                       goto tune_error;
+
+               m_sec_sequence.push_back( eSecCommand(eSecCommand::START_TUNE_TIMEOUT) );
+               m_sec_sequence.push_back( eSecCommand(eSecCommand::SET_FRONTEND) );

                break;
        }
        case feTerrestrial:
                break;
        }
        case feTerrestrial:


@@ -1724,32 +1906,43 @@ RESULT eDVBFrontend::tune(const iDVBFrontendParameters &where)
                if (where.getDVBT(feparm))
                {
                        eDebug("no -T data");
                if (where.getDVBT(feparm))
                {
                        eDebug("no -T data");

-                       return -EINVAL;
+                       res = -EINVAL;
+                       goto tune_error;

                }
                res=prepare_terrestrial(feparm);
                }
                res=prepare_terrestrial(feparm);

-               if (!res)
-               {
-                       m_sec_sequence.push_back( eSecCommand(eSecCommand::START_TUNE_TIMEOUT) );
-                       m_sec_sequence.push_back( eSecCommand(eSecCommand::SET_FRONTEND) );
-               }
+               if (res)
+                       goto tune_error;
+
+               std::string enable_5V;
+               char configStr[255];
+               snprintf(configStr, 255, "config.Nims.%d.terrestrial_5V", m_slotid);
+               m_sec_sequence.push_back( eSecCommand(eSecCommand::START_TUNE_TIMEOUT) );
+               ePythonConfigQuery::getConfigValue(configStr, enable_5V);
+               if (enable_5V == "True")
+                       m_sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, iDVBFrontend::voltage13) );
+               else
+                       m_sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, iDVBFrontend::voltageOff) );
+               m_sec_sequence.push_back( eSecCommand(eSecCommand::SET_FRONTEND) );
+

                break;
        }
        }
 
                break;
        }
        }
 

-       if (!res)  // prepare ok
-       {
-               m_tuneTimer->start(0,true);
-               m_sec_sequence.current() = m_sec_sequence.begin();
+       m_tuneTimer->start(0,true);
+       m_sec_sequence.current() = m_sec_sequence.begin();

 
 

-               if (m_state != stateTuning)
-               {
-                       m_tuning = 1;
-                       m_state = stateTuning;
-                       m_stateChanged(this);
-               }
+       if (m_state != stateTuning)
+       {
+               m_tuning = 1;
+               m_state = stateTuning;
+               m_stateChanged(this);

        }
 
        return res;
        }
 
        return res;

+
+tune_error:
+       m_tuneTimer->stop();
+       return res;

 }
 
 RESULT eDVBFrontend::connectStateChange(const Slot1<void,iDVBFrontend*> &stateChange, ePtr<eConnection> &connection)
 }
 
 RESULT eDVBFrontend::connectStateChange(const Slot1<void,iDVBFrontend*> &stateChange, ePtr<eConnection> &connection)


@@ -1760,7 +1953,7 @@ RESULT eDVBFrontend::connectStateChange(const Slot1<void,iDVBFrontend*> &stateCh
 
 RESULT eDVBFrontend::setVoltage(int voltage)
 {
 
 RESULT eDVBFrontend::setVoltage(int voltage)
 {

-       if (m_type != feSatellite)
+       if (m_type == feCable)

                return -1;
 #if HAVE_DVB_API_VERSION < 3
        secVoltage vlt;
                return -1;
 #if HAVE_DVB_API_VERSION < 3
        secVoltage vlt;


@@ -1768,7 +1961,7 @@ RESULT eDVBFrontend::setVoltage(int voltage)
        bool increased=false;
        fe_sec_voltage_t vlt;
 #endif
        bool increased=false;
        fe_sec_voltage_t vlt;
 #endif

-       m_curVoltage=voltage;
+       m_data[CUR_VOLTAGE]=voltage;

        switch (voltage)
        {
        case voltageOff:
        switch (voltage)
        {
        case voltageOff:


@@ -1802,7 +1995,7 @@ RESULT eDVBFrontend::setVoltage(int voltage)
 #if HAVE_DVB_API_VERSION < 3
        return ::ioctl(m_secfd, SEC_SET_VOLTAGE, vlt);
 #else
 #if HAVE_DVB_API_VERSION < 3
        return ::ioctl(m_secfd, SEC_SET_VOLTAGE, vlt);
 #else

-       if (::ioctl(m_fd, FE_ENABLE_HIGH_LNB_VOLTAGE, increased) < 0)
+       if (m_type == feSatellite && ::ioctl(m_fd, FE_ENABLE_HIGH_LNB_VOLTAGE, increased) < 0)

                perror("FE_ENABLE_HIGH_LNB_VOLTAGE");
        return ::ioctl(m_fd, FE_SET_VOLTAGE, vlt);
 #endif
                perror("FE_ENABLE_HIGH_LNB_VOLTAGE");
        return ::ioctl(m_fd, FE_SET_VOLTAGE, vlt);
 #endif


@@ -1823,7 +2016,7 @@ RESULT eDVBFrontend::setTone(int t)
 #else
        fe_sec_tone_mode_t tone;
 #endif
 #else
        fe_sec_tone_mode_t tone;
 #endif

-
+       m_data[CUR_TONE]=t;

        switch (t)
        {
        case toneOn:
        switch (t)
        {
        case toneOn:


@@ -1926,15 +2119,42 @@ RESULT eDVBFrontend::setData(int num, int val)
 int eDVBFrontend::isCompatibleWith(ePtr<iDVBFrontendParameters> &feparm)
 {
        int type;
 int eDVBFrontend::isCompatibleWith(ePtr<iDVBFrontendParameters> &feparm)
 {
        int type;

-       if (feparm->getSystem(type) || type != m_type)
+       if (feparm->getSystem(type) || type != m_type || !m_enabled)

                return 0;
 
        if (m_type == eDVBFrontend::feSatellite)
        {
                ASSERT(m_sec);
                eDVBFrontendParametersSatellite sat_parm;
                return 0;
 
        if (m_type == eDVBFrontend::feSatellite)
        {
                ASSERT(m_sec);
                eDVBFrontendParametersSatellite sat_parm;

-               ASSERT(!feparm->getDVBS(sat_parm));
-               return m_sec->canTune(sat_parm, this, 1 << m_fe);
+               int ret = feparm->getDVBS(sat_parm);
+               ASSERT(!ret);
+               return m_sec->canTune(sat_parm, this, 1 << m_slotid);

        }
        }

+       else if (m_type == eDVBFrontend::feCable)
+               return 2;  // more prio for cable frontends

        return 1;
 }
        return 1;
 }

+
+bool eDVBFrontend::setSlotInfo(ePyObject obj)
+{
+       ePyObject Id, Descr, Enabled;
+       if (!PyTuple_Check(obj) || PyTuple_Size(obj) != 3)
+               goto arg_error;
+       Id = PyTuple_GET_ITEM(obj, 0);
+       Descr = PyTuple_GET_ITEM(obj, 1);
+       Enabled = PyTuple_GET_ITEM(obj, 2);
+       if (!PyInt_Check(Id) || !PyString_Check(Descr) || !PyBool_Check(Enabled))
+               goto arg_error;
+       strcpy(m_description, PyString_AS_STRING(Descr));
+       m_slotid = PyInt_AsLong(Id);
+       m_enabled = Enabled == Py_True;
+       // HACK.. the rotor workaround is neede for all NIMs with LNBP21 voltage regulator...
+       m_need_rotor_workaround = !!strstr(m_description, "Alps BSBE1") || !!strstr(m_description, "Alps -S");
+       eDebug("setSlotInfo for dvb frontend %d to slotid %d, descr %s, need rotorworkaround %s, enabled %s",
+               m_dvbid, m_slotid, m_description, m_need_rotor_workaround ? "Yes" : "No", m_enabled ? "Yes" : "No" );
+       return true;
+arg_error:
+       PyErr_SetString(PyExc_StandardError,
+               "eDVBFrontend::setSlotInfo must get a tuple with first param slotid, second param slot description and third param enabled boolean");
+       return false;
+}