optimize linked tuner handling

diff --git a/lib/dvb/frontend.cpp b/lib/dvb/frontend.cpp
index 7c29e9a6591b68ee64c3622fb87cbdc5434e3a02..02297243160044ce6d29855f0b422b4ab8bf18ce 100644 (file)
--- a/lib/dvb/frontend.cpp
+++ b/lib/dvb/frontend.cpp
@@ -624,9 +624,19 @@ void eDVBFrontend::feEvent(int w)
                                state = stateTuning;
                        else
                        {
                                state = stateTuning;
                        else
                        {

+                               eDVBFrontend *sec_fe = this;
+                               long tmp = m_data[LINKED_PREV_PTR];
+

                                eDebug("stateLostLock");
                                state = stateLostLock;
                                eDebug("stateLostLock");
                                state = stateLostLock;

-                               m_data[CSW] = m_data[UCSW] = m_data[TONEBURST] = -1; // reset diseqc
+
+                               while (tmp != -1)
+                               {
+                                       eDVBRegisteredFrontend *linked_fe = (eDVBRegisteredFrontend*)tmp;
+                                       sec_fe = linked_fe->m_frontend;
+                                       sec_fe->getData(LINKED_NEXT_PTR, tmp);
+                               }
+                               sec_fe->m_data[CSW] = sec_fe->m_data[UCSW] = sec_fe->m_data[TONEBURST] = -1; // reset diseqc

                        }
                }
                if (m_state != state)
                        }
                }
                if (m_state != state)


@@ -793,9 +803,7 @@ void PutToDict(ePyObject &dict, const char*key, const char *value)
 void fillDictWithSatelliteData(ePyObject dict, const FRONTENDPARAMETERS &parm, eDVBFrontend *fe)
 {
        long freq_offset=0;
 void fillDictWithSatelliteData(ePyObject dict, const FRONTENDPARAMETERS &parm, eDVBFrontend *fe)
 {
        long freq_offset=0;

-       long csw=0;

        const char *tmp=0;
        const char *tmp=0;

-       fe->getData(eDVBFrontend::CSW, csw);

        fe->getData(eDVBFrontend::FREQ_OFFSET, freq_offset);
        int frequency = parm_frequency + freq_offset;
        PutToDict(dict, "frequency", frequency);
        fe->getData(eDVBFrontend::FREQ_OFFSET, freq_offset);
        int frequency = parm_frequency + freq_offset;
        PutToDict(dict, "frequency", frequency);


@@ -1291,52 +1299,23 @@ 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 ( (long)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 ( (long)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;

-       eDVBFrontend *fe = this;
+       eDVBFrontend *sec_fe = this;

        eDVBRegisteredFrontend *regFE = 0;
        long tmp = m_data[LINKED_PREV_PTR];
        while ( tmp != -1 )
        {
                eDVBRegisteredFrontend *prev = (eDVBRegisteredFrontend *)tmp;
        eDVBRegisteredFrontend *regFE = 0;
        long tmp = m_data[LINKED_PREV_PTR];
        while ( tmp != -1 )
        {
                eDVBRegisteredFrontend *prev = (eDVBRegisteredFrontend *)tmp;

-               fe = prev->m_frontend;
+               sec_fe = prev->m_frontend;

                tmp = prev->m_frontend->m_data[LINKED_PREV_PTR];
                tmp = prev->m_frontend->m_data[LINKED_PREV_PTR];

-               if (tmp == -1 && fe != this && !prev->m_inuse) {
-                       int state = fe->m_state;
+               if (tmp == -1 && sec_fe != this && !prev->m_inuse) {
+                       int state = sec_fe->m_state;

                        if (state != eDVBFrontend::stateIdle && state != stateClosed)
                        {
                        if (state != eDVBFrontend::stateIdle && state != stateClosed)
                        {

-                               fe->closeFrontend(true);
-                               state = fe->m_state;
+                               sec_fe->closeFrontend(true);
+                               state = sec_fe->m_state;

                        }
                        if (state == eDVBFrontend::stateClosed)
                        {
                        }
                        if (state == eDVBFrontend::stateClosed)
                        {


@@ -1348,7 +1327,7 @@ void eDVBFrontend::tuneLoop()  // called by m_tuneTimer
 
        if ( m_sec_sequence && m_sec_sequence.current() != m_sec_sequence.end() )
        {
 
        if ( m_sec_sequence && m_sec_sequence.current() != m_sec_sequence.end() )
        {

-               long *m_data = fe->m_data;
+               long *sec_fe_data = sec_fe->m_data;

 //             eDebug("tuneLoop %d\n", m_sec_sequence.current()->cmd);
                switch (m_sec_sequence.current()->cmd)
                {
 //             eDebug("tuneLoop %d\n", m_sec_sequence.current()->cmd);
                switch (m_sec_sequence.current()->cmd)
                {


@@ -1364,13 +1343,13 @@ void eDVBFrontend::tuneLoop()  // called by m_tuneTimer
                        {
                                int voltage = m_sec_sequence.current()++->voltage;
                                eDebug("[SEC] setVoltage %d", voltage);
                        {
                                int voltage = m_sec_sequence.current()++->voltage;
                                eDebug("[SEC] setVoltage %d", voltage);

-                               fe->setVoltage(voltage);
+                               sec_fe->setVoltage(voltage);

                                break;
                        }
                        case eSecCommand::IF_VOLTAGE_GOTO:
                        {
                                eSecCommand::pair &compare = m_sec_sequence.current()->compare;
                                break;
                        }
                        case eSecCommand::IF_VOLTAGE_GOTO:
                        {
                                eSecCommand::pair &compare = m_sec_sequence.current()->compare;

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

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


@@ -1378,7 +1357,7 @@ 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_data[CUR_VOLTAGE] && setSecSequencePos(compare.steps) )
+                               if ( compare.voltage != sec_fe_data[CUR_VOLTAGE] && setSecSequencePos(compare.steps) )

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


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

-                               if ( compare.tone == m_data[CUR_TONE] && setSecSequencePos(compare.steps) )
+                               if ( compare.tone == sec_fe_data[CUR_TONE] && setSecSequencePos(compare.steps) )

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


@@ -1394,17 +1373,17 @@ void eDVBFrontend::tuneLoop()  // called by m_tuneTimer
                        case eSecCommand::IF_NOT_TONE_GOTO:
                        {
                                eSecCommand::pair &compare = m_sec_sequence.current()->compare;
                        case eSecCommand::IF_NOT_TONE_GOTO:
                        {
                                eSecCommand::pair &compare = m_sec_sequence.current()->compare;

-                               if ( compare.tone != m_data[CUR_TONE] && setSecSequencePos(compare.steps) )
+                               if ( compare.tone != sec_fe_data[CUR_TONE] && setSecSequencePos(compare.steps) )

                                        break;
                                ++m_sec_sequence.current();
                                break;
                        }
                        case eSecCommand::SET_TONE:
                                eDebug("[SEC] setTone %d", m_sec_sequence.current()->tone);
                                        break;
                                ++m_sec_sequence.current();
                                break;
                        }
                        case eSecCommand::SET_TONE:
                                eDebug("[SEC] setTone %d", m_sec_sequence.current()->tone);

-                               fe->setTone(m_sec_sequence.current()++->tone);
+                               sec_fe->setTone(m_sec_sequence.current()++->tone);

                                break;
                        case eSecCommand::SEND_DISEQC:
                                break;
                        case eSecCommand::SEND_DISEQC:

-                               fe->sendDiseqc(m_sec_sequence.current()->diseqc);
+                               sec_fe->sendDiseqc(m_sec_sequence.current()->diseqc);

                                eDebugNoNewLine("[SEC] sendDiseqc: ");
                                for (int i=0; i < m_sec_sequence.current()->diseqc.len; ++i)
                                    eDebugNoNewLine("%02x", m_sec_sequence.current()->diseqc.data[i]);
                                eDebugNoNewLine("[SEC] sendDiseqc: ");
                                for (int i=0; i < m_sec_sequence.current()->diseqc.len; ++i)
                                    eDebugNoNewLine("%02x", m_sec_sequence.current()->diseqc.data[i]);


@@ -1413,7 +1392,7 @@ void eDVBFrontend::tuneLoop()  // called by m_tuneTimer
                                break;
                        case eSecCommand::SEND_TONEBURST:
                                eDebug("[SEC] sendToneburst: %d", m_sec_sequence.current()->toneburst);
                                break;
                        case eSecCommand::SEND_TONEBURST:
                                eDebug("[SEC] sendToneburst: %d", m_sec_sequence.current()->toneburst);

-                               fe->sendToneburst(m_sec_sequence.current()++->toneburst);
+                               sec_fe->sendToneburst(m_sec_sequence.current()++->toneburst);

                                break;
                        case eSecCommand::SET_FRONTEND:
                                eDebug("[SEC] setFrontend");
                                break;
                        case eSecCommand::SET_FRONTEND:
                                eDebug("[SEC] setFrontend");


@@ -1445,7 +1424,7 @@ void eDVBFrontend::tuneLoop()  // called by m_tuneTimer
                                int idx = m_sec_sequence.current()++->val;
                                if ( idx == 0 || idx == 1 )
                                {
                                int idx = m_sec_sequence.current()++->val;
                                if ( idx == 0 || idx == 1 )
                                {

-                                       m_idleInputpower[idx] = fe->readInputpower();
+                                       m_idleInputpower[idx] = sec_fe->readInputpower();

                                        eDebug("[SEC] idleInputpower[%d] is %d", idx, m_idleInputpower[idx]);
                                }
                                else
                                        eDebug("[SEC] idleInputpower[%d] is %d", idx, m_idleInputpower[idx]);
                                }
                                else


@@ -1458,7 +1437,7 @@ void eDVBFrontend::tuneLoop()  // called by m_tuneTimer
                                int idx = compare.val;
                                if ( idx == 0 || idx == 1 )
                                {
                                int idx = compare.val;
                                if ( idx == 0 || idx == 1 )
                                {

-                                       int idle = fe->readInputpower();
+                                       int idle = sec_fe->readInputpower();

                                        int diff = abs(idle-m_idleInputpower[idx]);
                                        if ( diff > 0)
                                        {
                                        int diff = abs(idle-m_idleInputpower[idx]);
                                        if ( diff > 0)
                                        {


@@ -1496,13 +1475,13 @@ void eDVBFrontend::tuneLoop()  // called by m_tuneTimer
                                break;
                        }
                        case eSecCommand::MEASURE_RUNNING_INPUTPOWER:
                                break;
                        }
                        case eSecCommand::MEASURE_RUNNING_INPUTPOWER:

-                               m_runningInputpower = fe->readInputpower();
+                               m_runningInputpower = sec_fe->readInputpower();

                                eDebug("[SEC] runningInputpower is %d", m_runningInputpower);
                                ++m_sec_sequence.current();
                                break;
                        case eSecCommand::IF_INPUTPOWER_DELTA_GOTO:
                        {
                                eDebug("[SEC] runningInputpower is %d", m_runningInputpower);
                                ++m_sec_sequence.current();
                                break;
                        case eSecCommand::IF_INPUTPOWER_DELTA_GOTO:
                        {

-                               int idleInputpower = m_idleInputpower[ (m_data[CUR_VOLTAGE]&1) ? 0 : 1];
+                               int idleInputpower = m_idleInputpower[ (sec_fe_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",


@@ -1535,19 +1514,21 @@ void eDVBFrontend::tuneLoop()  // called by m_tuneTimer
                                break;
                        }
                        case eSecCommand::IF_ROTORPOS_VALID_GOTO:
                                break;
                        }
                        case eSecCommand::IF_ROTORPOS_VALID_GOTO:

-                               if (m_data[ROTOR_CMD] != -1 && m_data[ROTOR_POS] != -1)
+                               if (sec_fe_data[ROTOR_CMD] != -1 && sec_fe_data[ROTOR_POS] != -1)

                                        setSecSequencePos(m_sec_sequence.current()->steps);
                                else
                                        ++m_sec_sequence.current();
                                break;
                        case eSecCommand::INVALIDATE_CURRENT_ROTORPARMS:
                                eDebug("[SEC] invalidate current rotorparams");
                                        setSecSequencePos(m_sec_sequence.current()->steps);
                                else
                                        ++m_sec_sequence.current();
                                break;
                        case eSecCommand::INVALIDATE_CURRENT_ROTORPARMS:
                                eDebug("[SEC] invalidate current rotorparams");

-                               fe->setRotorData(-1,-1);        
+                               sec_fe_data[ROTOR_CMD] = -1;
+                               sec_fe_data[ROTOR_POS] = -1;

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

-                               fe->setRotorData(m_data[NEW_ROTOR_POS], m_data[NEW_ROTOR_CMD]);
-                               eDebug("[SEC] update current rotorparams %d %04lx %ld", m_timeoutCount, m_data[ROTOR_CMD], m_data[ROTOR_POS]);
+                               sec_fe_data[ROTOR_CMD] = sec_fe_data[NEW_ROTOR_CMD];
+                               sec_fe_data[ROTOR_POS] = sec_fe_data[NEW_ROTOR_POS];
+                               eDebug("[SEC] update current rotorparams %d %04lx %ld", m_timeoutCount, sec_fe_data[ROTOR_CMD], sec_fe_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:


@@ -1566,7 +1547,7 @@ void eDVBFrontend::tuneLoop()  // called by m_tuneTimer
                        case eSecCommand::SET_POWER_LIMITING_MODE:
                        {
                                char proc_name[64];
                        case eSecCommand::SET_POWER_LIMITING_MODE:
                        {
                                char proc_name[64];

-                               sprintf(proc_name, "/proc/stb/frontend/%d/static_current_limiting", fe->m_dvbid);
+                               sprintf(proc_name, "/proc/stb/frontend/%d/static_current_limiting", sec_fe->m_dvbid);

                                FILE *f=fopen(proc_name, "w");
                                if (f) // new interface exist?
                                {
                                FILE *f=fopen(proc_name, "w");
                                if (f) // new interface exist?
                                {


@@ -1577,10 +1558,10 @@ void eDVBFrontend::tuneLoop()  // called by m_tuneTimer
                                                eDebug("[SEC] set %s current limiting", slimiting ? "static" : "dynamic");
                                        fclose(f);
                                }
                                                eDebug("[SEC] set %s current limiting", slimiting ? "static" : "dynamic");
                                        fclose(f);
                                }

-                               else if (fe->m_need_rotor_workaround)
+                               else if (sec_fe->m_need_rotor_workaround)

                                {
                                        char dev[16];
                                {
                                        char dev[16];

-                                       int slotid = fe->m_slotid;
+                                       int slotid = sec_fe->m_slotid;

                                        // FIXMEEEEEE hardcoded i2c devices for dm7025 and dm8000
                                        if (slotid < 2)
                                                sprintf(dev, "/dev/i2c/%d", slotid);
                                        // FIXMEEEEEE hardcoded i2c devices for dm7025 and dm8000
                                        if (slotid < 2)
                                                sprintf(dev, "/dev/i2c/%d", slotid);


@@ -2112,8 +2093,7 @@ RESULT eDVBFrontend::setVoltage(int voltage)
        switch (voltage)
        {
        case voltageOff:
        switch (voltage)
        {
        case voltageOff:

-               for (int i=0; i < 3; ++i)  // reset diseqc
-                       m_data[i]=-1;
+               m_data[CSW]=m_data[UCSW]=m_data[TONEBURST]=-1; // reset diseqc

                vlt = SEC_VOLTAGE_OFF;
                break;
        case voltage13_5:
                vlt = SEC_VOLTAGE_OFF;
                break;
        case voltage13_5:

diff --git a/lib/dvb/frontend.h b/lib/dvb/frontend.h
index 111e715dbe10b61ee06924b9d72823641c6743ce..6643db03edc9705899fff1f23efdee16f1769c32 100644 (file)
--- a/lib/dvb/frontend.h
+++ b/lib/dvb/frontend.h
@@ -97,7 +97,6 @@ private:
        void tuneLoop();  // called by m_tuneTimer
        void setFrontend();
        bool setSecSequencePos(int steps);
        void tuneLoop();  // called by m_tuneTimer
        void setFrontend();
        bool setSecSequencePos(int steps);

-       void setRotorData(int pos, int cmd);

        static int PriorityOrder;
 public:
        eDVBFrontend(int adap, int fe, int &ok);        
        static int PriorityOrder;
 public:
        eDVBFrontend(int adap, int fe, int &ok);        

diff --git a/lib/dvb/sec.cpp b/lib/dvb/sec.cpp
index 8a186014f792f1209e5d128bcb22b962b49c58b2..9e76bb907606b715a75f17a6731764e14a6edf8c 100644 (file)
--- a/lib/dvb/sec.cpp
+++ b/lib/dvb/sec.cpp
@@ -114,40 +114,6 @@ eDVBSatelliteEquipmentControl::eDVBSatelliteEquipmentControl(eSmartPtrList<eDVBR
        setRotorPosNum(1); // stored pos 1
 }
 
        setRotorPosNum(1); // stored pos 1
 }
 

-static void checkLinkedParams(int direction, long &linked_ptr, int &ret, const eDVBFrontendParametersSatellite &sat, int csw, int ucsw, int toneburst, bool diseqc, bool rotor, int RotorPos)
-{
-       eDVBRegisteredFrontend *linked_fe = (eDVBRegisteredFrontend*) linked_ptr;
-       if (linked_fe->m_inuse)
-       {
-               long ocsw = -1,
-                       oucsw = -1,
-                       oToneburst = -1;
-               linked_fe->m_frontend->getData(eDVBFrontend::CSW, ocsw);
-               linked_fe->m_frontend->getData(eDVBFrontend::UCSW, oucsw);
-               linked_fe->m_frontend->getData(eDVBFrontend::TONEBURST, oToneburst);
-#if 0
-               eDebug("compare csw %02x == lcsw %02x",
-                       csw, ocsw);
-               if ( diseqc )
-                       eDebug("compare ucsw %02x == lucsw %02x\ncompare toneburst %02x == oToneburst %02x",
-                               ucsw, oucsw, toneburst, oToneburst);
-               if ( rotor )
-                       eDebug("compare pos %d == current pos %d",
-                               sat.orbital_position, oRotorPos);
-#endif
-               if ( (csw != ocsw) ||
-                       ( diseqc && (ucsw != oucsw || toneburst != oToneburst) ) ||
-                       ( rotor && RotorPos != sat.orbital_position ) )
-               {
-//                     eDebug("can not tune this transponder with linked tuner in use!!");
-                       ret=0;
-               }
-//             else
-//                     eDebug("OK .. can tune this transponder with linked tuner in use :)");
-       }
-       linked_fe->m_frontend->getData(direction, (long&)linked_ptr);
-}
-

 int eDVBSatelliteEquipmentControl::canTune(const eDVBFrontendParametersSatellite &sat, iDVBFrontend *fe, int slot_id )
 {
        int ret=0, satcount=0;
 int eDVBSatelliteEquipmentControl::canTune(const eDVBFrontendParametersSatellite &sat, iDVBFrontend *fe, int slot_id )
 {
        int ret=0, satcount=0;


@@ -175,9 +141,7 @@ int eDVBSatelliteEquipmentControl::canTune(const eDVBFrontendParametersSatellite
                                        toneburst = di_param.m_toneburst_param,
                                        curRotorPos;
 
                                        toneburst = di_param.m_toneburst_param,
                                        curRotorPos;
 

-                               fe->getData(eDVBFrontend::ROTOR_POS, curRotorPos);

                                fe->getData(eDVBFrontend::LINKED_PREV_PTR, linked_prev_ptr);
                                fe->getData(eDVBFrontend::LINKED_PREV_PTR, linked_prev_ptr);

-                               fe->getData(eDVBFrontend::LINKED_NEXT_PTR, linked_next_ptr);

                                fe->getData(eDVBFrontend::SATPOS_DEPENDS_PTR, satpos_depends_ptr);
 
                                if ( sat.frequency > lnb_param.m_lof_threshold )
                                fe->getData(eDVBFrontend::SATPOS_DEPENDS_PTR, satpos_depends_ptr);
 
                                if ( sat.frequency > lnb_param.m_lof_threshold )


@@ -200,8 +164,6 @@ int eDVBSatelliteEquipmentControl::canTune(const eDVBFrontendParametersSatellite
                                                rotor = true;
 
                                        ret=10000;
                                                rotor = true;
 
                                        ret=10000;

-                                       if (rotor && curRotorPos != -1)
-                                               ret -= abs(curRotorPos-sat.orbital_position);

                                }
                                else
                                {
                                }
                                else
                                {


@@ -209,11 +171,76 @@ int eDVBSatelliteEquipmentControl::canTune(const eDVBFrontendParametersSatellite
                                        ret = 15000;
                                }
 
                                        ret = 15000;
                                }
 

-                               while (ret && linked_prev_ptr != -1)  // check for linked tuners..
-                                       checkLinkedParams(eDVBFrontend::LINKED_PREV_PTR, linked_prev_ptr, ret, sat, csw, ucsw, toneburst, diseqc, rotor, curRotorPos);
+                               if (m_not_linked_slot_mask & slot_id)  // frontend with direct connection?
+                               {
+                                       long ocsw = -1,
+                                               oucsw = -1,
+                                               oToneburst = -1;
+                                       fe->getData(eDVBFrontend::ROTOR_POS, curRotorPos);
+                                       fe->getData(eDVBFrontend::LINKED_NEXT_PTR, linked_next_ptr);
+                                       fe->getData(eDVBFrontend::CSW, ocsw);
+                                       fe->getData(eDVBFrontend::UCSW, oucsw);
+                                       fe->getData(eDVBFrontend::TONEBURST, oToneburst);
+                                       while (ret && linked_prev_ptr != -1)  // check for linked tuners..
+                                       {
+                                               eDVBRegisteredFrontend *linked_fe = (eDVBRegisteredFrontend*) linked_prev_ptr;
+                                               if (linked_fe->m_inuse)
+                                               {
+                                                       if ( (csw != ocsw) ||
+                                                               ( diseqc && (ucsw != oucsw || toneburst != oToneburst) ) ||
+                                                               ( rotor && curRotorPos != sat.orbital_position ) )
+                                                       {
+                                                               ret=0;
+                                                       }
+                                               }
+                                               linked_fe->m_frontend->getData(eDVBFrontend::LINKED_PREV_PTR, (long&)linked_prev_ptr);
+                                       }
+                                       while (ret && linked_next_ptr != -1)  // check for linked tuners..
+                                       {
+                                               eDVBRegisteredFrontend *linked_fe = (eDVBRegisteredFrontend*) linked_next_ptr;
+                                               if (linked_fe->m_inuse)
+                                               {
+                                                       if ( (csw != ocsw) ||
+                                                               ( diseqc && (ucsw != oucsw || toneburst != oToneburst) ) ||
+                                                               ( rotor && curRotorPos != sat.orbital_position ) )
+                                                       {
+                                                               ret=0;
+                                                       }
+                                               }
+                                               linked_fe->m_frontend->getData(eDVBFrontend::LINKED_NEXT_PTR, (long&)linked_next_ptr);
+                                       }
+                               }
+                               else // linked frontend..
+                               {
+                                       long ocsw = -1,
+                                               oucsw = -1,
+                                               oToneburst = -1;
+                                       while (linked_prev_ptr != -1)
+                                       {
+                                               eDVBRegisteredFrontend *linked_fe = (eDVBRegisteredFrontend*) linked_prev_ptr;
+                                               linked_fe->m_frontend->getData(eDVBFrontend::LINKED_PREV_PTR, (long&)linked_prev_ptr);
+                                               if (linked_prev_ptr == -1)
+                                               {
+                                                       iDVBFrontend *sec_fe = linked_fe->m_frontend;
+                                                       sec_fe->getData(eDVBFrontend::ROTOR_POS, curRotorPos);
+                                                       if (linked_fe->m_inuse)
+                                                       {
+                                                               sec_fe->getData(eDVBFrontend::CSW, ocsw);
+                                                               sec_fe->getData(eDVBFrontend::UCSW, oucsw);
+                                                               sec_fe->getData(eDVBFrontend::TONEBURST, oToneburst);
+                                                               if ( (csw != ocsw) ||
+                                                                       ( diseqc && (ucsw != oucsw || toneburst != oToneburst) ) ||
+                                                                       ( rotor && curRotorPos != sat.orbital_position ) )
+                                                               {
+                                                                       ret=0;
+                                                               }
+                                                       }
+                                               }
+                                       }
+                               }

 
 

-                               while (ret && linked_next_ptr != -1)  // check for linked tuners..
-                                       checkLinkedParams(eDVBFrontend::LINKED_NEXT_PTR, linked_next_ptr, ret, sat, csw, ucsw, toneburst, diseqc, rotor, curRotorPos);
+                               if (ret && rotor && curRotorPos != -1)
+                                       ret -= abs(curRotorPos-sat.orbital_position);

 
                                if (ret)
                                        if (satpos_depends_ptr != -1)
 
                                if (ret)
                                        if (satpos_depends_ptr != -1)


@@ -222,13 +249,8 @@ int eDVBSatelliteEquipmentControl::canTune(const eDVBFrontendParametersSatellite
                                                if ( satpos_depends_to_fe->m_inuse )
                                                {
                                                        if (!rotor || curRotorPos != sat.orbital_position)
                                                if ( satpos_depends_to_fe->m_inuse )
                                                {
                                                        if (!rotor || curRotorPos != sat.orbital_position)

-                                                       {
-//                                                             eDebug("can not tune this transponder ... rotor on other tuner is positioned to %d", oRotorPos);

                                                                ret=0;
                                                                ret=0;

-                                                       }

                                                }
                                                }

-//                                             else
-//                                                     eDebug("OK .. can tune this transponder satpos is correct :)");

                                        }
 
                                if (ret)
                                        }
 
                                if (ret)


@@ -236,13 +258,8 @@ int eDVBSatelliteEquipmentControl::canTune(const eDVBFrontendParametersSatellite
                                        int lof = sat.frequency > lnb_param.m_lof_threshold ?
                                                lnb_param.m_lof_hi : lnb_param.m_lof_lo;
                                        int tuner_freq = abs(sat.frequency - lof);
                                        int lof = sat.frequency > lnb_param.m_lof_threshold ?
                                                lnb_param.m_lof_hi : lnb_param.m_lof_lo;
                                        int tuner_freq = abs(sat.frequency - lof);

-//                                     eDebug("tuner freq %d", tuner_freq);

                                        if (tuner_freq < 900000 || tuner_freq > 2200000)
                                        if (tuner_freq < 900000 || tuner_freq > 2200000)

-                                       {

                                                ret=0;
                                                ret=0;

-//                                             eDebug("Transponder not tuneable with this lnb... %d Khz out of tuner range",
-//                                                     tuner_freq);
-                                       }

                                }
                        }
                }
                                }
                        }
                }


@@ -310,16 +327,29 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA
                                lastRotorCmd = -1,
                                curRotorPos = -1,
                                satposDependPtr = -1;
                                lastRotorCmd = -1,
                                curRotorPos = -1,
                                satposDependPtr = -1;

+                       iDVBFrontend *sec_fe=&frontend;

 
 

-                       frontend.getData(eDVBFrontend::CSW, lastcsw);
-                       frontend.getData(eDVBFrontend::UCSW, lastucsw);
-                       frontend.getData(eDVBFrontend::TONEBURST, lastToneburst);
-                       frontend.getData(eDVBFrontend::ROTOR_CMD, lastRotorCmd);
-                       frontend.getData(eDVBFrontend::ROTOR_POS, curRotorPos);

                        frontend.getData(eDVBFrontend::SATPOS_DEPENDS_PTR, satposDependPtr);
 
                        frontend.getData(eDVBFrontend::SATPOS_DEPENDS_PTR, satposDependPtr);
 

-                       if (satposDependPtr != -1 && !(m_not_linked_slot_mask & slot_id))
-                               allowDiseqc1_2 = false;
+                       if (!(m_not_linked_slot_mask & slot_id))  // frontend with direct connection?
+                       {
+                               long linked_prev_ptr;
+                               frontend.getData(eDVBFrontend::LINKED_PREV_PTR, linked_prev_ptr);
+                               while (linked_prev_ptr != -1)
+                               {
+                                       eDVBRegisteredFrontend *linked_fe = (eDVBRegisteredFrontend*) linked_prev_ptr;
+                                       sec_fe = linked_fe->m_frontend;
+                                       sec_fe->getData(eDVBFrontend::LINKED_PREV_PTR, (long&)linked_prev_ptr);
+                               }
+                               if (satposDependPtr != -1)
+                                       allowDiseqc1_2 = false;
+                       }
+
+                       sec_fe->getData(eDVBFrontend::CSW, lastcsw);
+                       sec_fe->getData(eDVBFrontend::UCSW, lastucsw);
+                       sec_fe->getData(eDVBFrontend::TONEBURST, lastToneburst);
+                       sec_fe->getData(eDVBFrontend::ROTOR_CMD, lastRotorCmd);
+                       sec_fe->getData(eDVBFrontend::ROTOR_POS, curRotorPos);

 
                        if ( sat.frequency > lnb_param.m_lof_threshold )
                                band |= 1;
 
                        if ( sat.frequency > lnb_param.m_lof_threshold )
                                band |= 1;


@@ -757,17 +787,17 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA
                                                        sec_sequence.push_back( eSecCommand(eSecCommand::UPDATE_CURRENT_ROTORPARAMS) );
                                                        sec_sequence.push_back( eSecCommand(eSecCommand::SET_POWER_LIMITING_MODE, eSecCommand::modeDynamic) );
                                                }
                                                        sec_sequence.push_back( eSecCommand(eSecCommand::UPDATE_CURRENT_ROTORPARAMS) );
                                                        sec_sequence.push_back( eSecCommand(eSecCommand::SET_POWER_LIMITING_MODE, eSecCommand::modeDynamic) );
                                                }

-                                               frontend.setData(eDVBFrontend::NEW_ROTOR_CMD, RotorCmd);
-                                               frontend.setData(eDVBFrontend::NEW_ROTOR_POS, sat.orbital_position);
+                                               sec_fe->setData(eDVBFrontend::NEW_ROTOR_CMD, RotorCmd);
+                                               sec_fe->setData(eDVBFrontend::NEW_ROTOR_POS, sat.orbital_position);

                                        }
                                }
                        }
                        else
                                csw = band;
 
                                        }
                                }
                        }
                        else
                                csw = band;
 

-                       frontend.setData(eDVBFrontend::CSW, csw);
-                       frontend.setData(eDVBFrontend::UCSW, ucsw);
-                       frontend.setData(eDVBFrontend::TONEBURST, di_param.m_toneburst_param);
+                       sec_fe->setData(eDVBFrontend::CSW, csw);
+                       sec_fe->setData(eDVBFrontend::UCSW, ucsw);
+                       sec_fe->setData(eDVBFrontend::TONEBURST, di_param.m_toneburst_param);

 
                        if (doSetVoltageToneFrontend)
                        {
 
                        if (doSetVoltageToneFrontend)
                        {