add support for turning rotor without power measurement

(for rotors behind a powered switch or rotor behind a V-Box)
known bug .. the transponder scan loops when a transponder does not lock :/

5 files changed, 365 insertions, 237 deletions

diff --git a/lib/dvb/frontend.cpp b/lib/dvb/frontend.cpp
index a7f0c70e..464ef789 100644
--- a/lib/dvb/frontend.cpp
+++ b/lib/dvb/frontend.cpp
@@ -478,6 +478,28 @@ int eDVBFrontend::readFrontendData(int type)
 				eDebug("FE_READ_SIGNAL_STRENGTH failed (%m)");
 			return strength;
 		}
+		case Locked:
+		{
+#if HAVE_DVB_API_VERSION < 3
+			FrontendStatus status=0;
+#else
+			fe_status_t status;
+#endif
+			if ( ioctl(m_fd, FE_READ_STATUS, &status) < 0 && errno != ERANGE )
+				eDebug("FE_READ_STATUS failed (%m)");
+			return !!(status&FE_HAS_LOCK);
+		}
+		case Synced:
+		{
+#if HAVE_DVB_API_VERSION < 3
+			FrontendStatus status=0;
+#else
+			fe_status_t status;
+#endif
+			if ( ioctl(m_fd, FE_READ_STATUS, &status) < 0 && errno != ERANGE )
+				eDebug("FE_READ_STATUS failed (%m)");
+			return !!(status&FE_HAS_SYNC);
+		}
 	}
 	return 0;
 }
@@ -532,6 +554,7 @@ void eDVBFrontend::tuneLoop()  // called by m_tuneTimer
 	int delay=0;
 	if ( m_sec_sequence && m_sec_sequence.current() != m_sec_sequence.end() )
 	{
+//		eDebug("tuneLoop %d\n", m_sec_sequence.current()->cmd);
 		switch (m_sec_sequence.current()->cmd)
 		{
 			case eSecCommand::SLEEP:
@@ -586,6 +609,10 @@ void eDVBFrontend::tuneLoop()  // called by m_tuneTimer
 				setFrontend();
 				++m_sec_sequence.current();
 				break;
+			case eSecCommand::START_TUNE_TIMEOUT:
+				m_timeout->start(5000, 1); // 5 sec timeout. TODO: symbolrate dependent
+				++m_sec_sequence.current();
+				break;
 			case eSecCommand::SET_TIMEOUT:
 				m_timeoutCount = m_sec_sequence.current()++->val;
 				eDebug("[SEC] set timeout %d", m_timeoutCount);
@@ -630,6 +657,31 @@ void eDVBFrontend::tuneLoop()  // called by m_tuneTimer
 				++m_sec_sequence.current();
 				break;
 			}
+			case eSecCommand::IF_TUNER_LOCKED_GOTO:
+			{
+				eSecCommand::rotor &cmd = m_sec_sequence.current()->measure;
+				if (readFrontendData(Locked))
+				{
+					eDebug("[SEC] locked step %d ok", cmd.okcount);
+					++cmd.okcount;
+					if (cmd.okcount > 12)
+					{
+						eDebug("ok > 12 .. goto %d\n",m_sec_sequence.current()->steps);
+						setSecSequencePos(cmd.steps);
+						break;
+					}
+				}
+				else
+				{
+					eDebug("[SEC] rotor locked step %d failed", cmd.okcount);
+					--m_timeoutCount;
+					if (!m_timeoutCount && m_retryCount > 0)
+						--m_retryCount;
+					cmd.okcount=0;
+				}
+				++m_sec_sequence.current();
+				break;
+			}
 			case eSecCommand::MEASURE_RUNNING_INPUTPOWER:
 				m_runningInputpower = readInputpower();
 				eDebug("[SEC] runningInputpower is %d", m_runningInputpower);
@@ -741,7 +793,6 @@ void eDVBFrontend::setFrontend()
 		perror("FE_SET_FRONTEND failed");
 		return;
 	}
-	m_timeout->start(5000, 1); // 5 sec timeout. TODO: symbolrate dependent
 }
 
 RESULT eDVBFrontend::getFrontendType(int &t)
@@ -752,10 +803,226 @@ RESULT eDVBFrontend::getFrontendType(int &t)
 	return 0;
 }
 
+RESULT eDVBFrontend::prepare_sat(const eDVBFrontendParametersSatellite &feparm)
+{
+	int res;
+	if (!m_sec)
+	{
+		eWarning("no SEC module active!");
+		return -ENOENT;
+	}
+	res = m_sec->prepare(*this, parm, feparm, 1 << m_fe);
+	if (!res)
+		eDebug("tuning to %d mhz", parm.frequency/1000);
+	return res;
+}
+
+RESULT eDVBFrontend::prepare_cable(const eDVBFrontendParametersCable &feparm)
+{
+	parm.frequency = feparm.frequency * 1000;
+	parm.u.qam.symbol_rate = feparm.symbol_rate;
+	switch (feparm.modulation)
+	{
+	case eDVBFrontendParametersCable::Modulation::QAM16:
+		parm.u.qam.modulation = QAM_16;
+		break;
+	case eDVBFrontendParametersCable::Modulation::QAM32:
+		parm.u.qam.modulation = QAM_32;
+		break;
+	case eDVBFrontendParametersCable::Modulation::QAM64:
+		parm.u.qam.modulation = QAM_64;
+		break;
+	case eDVBFrontendParametersCable::Modulation::QAM128:
+		parm.u.qam.modulation = QAM_128;
+		break;
+	case eDVBFrontendParametersCable::Modulation::QAM256:
+		parm.u.qam.modulation = QAM_256;
+		break;
+	default:
+	case eDVBFrontendParametersCable::Modulation::Auto:
+		parm.u.qam.modulation = QAM_AUTO;
+		break;
+	}
+	switch (feparm.inversion)
+	{
+	case eDVBFrontendParametersCable::Inversion::On:
+		parm.inversion = INVERSION_ON;
+		break;
+	case eDVBFrontendParametersCable::Inversion::Off:
+		parm.inversion = INVERSION_OFF;
+		break;
+	default:
+	case eDVBFrontendParametersCable::Inversion::Unknown:
+		parm.inversion = INVERSION_AUTO;
+		break;
+	}
+	switch (feparm.fec_inner)
+	{
+	case eDVBFrontendParametersCable::FEC::fNone:
+		parm.u.qam.fec_inner = FEC_NONE;
+		break;
+	case eDVBFrontendParametersCable::FEC::f1_2:
+		parm.u.qam.fec_inner = FEC_1_2;
+		break;
+	case eDVBFrontendParametersCable::FEC::f2_3:
+		parm.u.qam.fec_inner = FEC_2_3;
+		break;
+	case eDVBFrontendParametersCable::FEC::f3_4:
+		parm.u.qam.fec_inner = FEC_3_4;
+		break;
+	case eDVBFrontendParametersCable::FEC::f5_6:
+		parm.u.qam.fec_inner = FEC_5_6;
+		break;
+	case eDVBFrontendParametersCable::FEC::f7_8:
+		parm.u.qam.fec_inner = FEC_7_8;
+		break;
+	case eDVBFrontendParametersCable::FEC::f8_9:
+		parm.u.qam.fec_inner = FEC_8_9;
+		break;
+	default:
+	case eDVBFrontendParametersCable::FEC::fAuto:
+		parm.u.qam.fec_inner = FEC_AUTO;
+		break;
+	}
+	return 0;
+}
+
+RESULT eDVBFrontend::prepare_terrestrial(const eDVBFrontendParametersTerrestrial &feparm)
+{
+	parm.frequency = feparm.frequency;
+
+	switch (feparm.bandwidth)
+	{
+	case eDVBFrontendParametersTerrestrial::Bandwidth::Bw8MHz:
+		parm.u.ofdm.bandwidth = BANDWIDTH_8_MHZ;
+		break;
+	case eDVBFrontendParametersTerrestrial::Bandwidth::Bw7MHz:
+		parm.u.ofdm.bandwidth = BANDWIDTH_7_MHZ;
+		break;
+	case eDVBFrontendParametersTerrestrial::Bandwidth::Bw6MHz:
+		parm.u.ofdm.bandwidth = BANDWIDTH_6_MHZ;
+		break;
+	default:
+	case eDVBFrontendParametersTerrestrial::Bandwidth::BwAuto:
+		parm.u.ofdm.bandwidth = BANDWIDTH_AUTO;
+		break;
+	}
+	switch (feparm.code_rate_LP)
+	{
+	case eDVBFrontendParametersCable::FEC::f1_2:
+		parm.u.ofdm.code_rate_LP = FEC_1_2;
+		break;
+	case eDVBFrontendParametersCable::FEC::f2_3:
+		parm.u.ofdm.code_rate_LP = FEC_2_3;
+		break;
+	case eDVBFrontendParametersCable::FEC::f3_4:
+		parm.u.ofdm.code_rate_LP = FEC_3_4;
+		break;
+	case eDVBFrontendParametersCable::FEC::f5_6:
+		parm.u.ofdm.code_rate_LP = FEC_5_6;
+		break;
+	case eDVBFrontendParametersCable::FEC::f7_8:
+		parm.u.ofdm.code_rate_LP = FEC_7_8;
+		break;
+	default:
+	case eDVBFrontendParametersCable::FEC::fAuto:
+	case eDVBFrontendParametersCable::FEC::fNone:
+		parm.u.ofdm.code_rate_LP = FEC_AUTO;
+		break;
+	}
+	switch (feparm.code_rate_HP)
+	{
+	case eDVBFrontendParametersCable::FEC::f1_2:
+		parm.u.ofdm.code_rate_HP = FEC_1_2;
+		break;
+	case eDVBFrontendParametersCable::FEC::f2_3:
+		parm.u.ofdm.code_rate_HP = FEC_2_3;
+		break;
+	case eDVBFrontendParametersCable::FEC::f3_4:
+		parm.u.ofdm.code_rate_HP = FEC_3_4;
+		break;
+	case eDVBFrontendParametersCable::FEC::f5_6:
+		parm.u.ofdm.code_rate_HP = FEC_5_6;
+		break;
+	case eDVBFrontendParametersCable::FEC::f7_8:
+		parm.u.ofdm.code_rate_HP = FEC_7_8;
+		break;
+	default:
+	case eDVBFrontendParametersCable::FEC::fAuto:
+	case eDVBFrontendParametersCable::FEC::fNone:
+		parm.u.ofdm.code_rate_HP = FEC_AUTO;
+		break;
+	}
+	switch (feparm.modulation)
+	{
+	case eDVBFrontendParametersTerrestrial::Modulation::QPSK:
+		parm.u.ofdm.constellation = QPSK;
+		break;
+	case eDVBFrontendParametersTerrestrial::Modulation::QAM16:
+		parm.u.ofdm.constellation = QAM_16;
+		break;
+	default:
+	case eDVBFrontendParametersTerrestrial::Modulation::Auto:
+		parm.u.ofdm.constellation = QAM_AUTO;
+		break;
+	}
+	switch (feparm.transmission_mode)
+	{
+	case eDVBFrontendParametersTerrestrial::TransmissionMode::TM2k:
+		parm.u.ofdm.transmission_mode = TRANSMISSION_MODE_2K;
+		break;
+	case eDVBFrontendParametersTerrestrial::TransmissionMode::TM8k:
+		parm.u.ofdm.transmission_mode = TRANSMISSION_MODE_8K;
+		break;
+	default:
+	case eDVBFrontendParametersTerrestrial::TransmissionMode::TMAuto:
+		parm.u.ofdm.transmission_mode = TRANSMISSION_MODE_AUTO;
+		break;
+	}
+	switch (feparm.guard_interval)
+	{
+		case eDVBFrontendParametersTerrestrial::GuardInterval::GI_1_32:
+			parm.u.ofdm.guard_interval = GUARD_INTERVAL_1_32;
+			break;
+		case eDVBFrontendParametersTerrestrial::GuardInterval::GI_1_16:
+			parm.u.ofdm.guard_interval = GUARD_INTERVAL_1_16;
+			break;
+		case eDVBFrontendParametersTerrestrial::GuardInterval::GI_1_8:
+			parm.u.ofdm.guard_interval = GUARD_INTERVAL_1_8;
+			break;
+		case eDVBFrontendParametersTerrestrial::GuardInterval::GI_1_4:
+			parm.u.ofdm.guard_interval = GUARD_INTERVAL_1_4;
+			break;
+		default:
+		case eDVBFrontendParametersTerrestrial::GuardInterval::GI_Auto:
+			parm.u.ofdm.guard_interval = GUARD_INTERVAL_AUTO;
+			break;
+	}
+	switch (feparm.hierarchy)
+	{
+		case eDVBFrontendParametersTerrestrial::Hierarchy::H1:
+			parm.u.ofdm.hierarchy_information = HIERARCHY_1;
+			break;
+		case eDVBFrontendParametersTerrestrial::Hierarchy::H2:
+			parm.u.ofdm.hierarchy_information = HIERARCHY_2;
+			break;
+		case eDVBFrontendParametersTerrestrial::Hierarchy::H4:
+			parm.u.ofdm.hierarchy_information = HIERARCHY_4;
+			break;
+		default:
+		case eDVBFrontendParametersTerrestrial::Hierarchy::HAuto:
+			parm.u.ofdm.hierarchy_information = HIERARCHY_AUTO;
+			break;
+	}
+	return 0;
+}
+
 RESULT eDVBFrontend::tune(const iDVBFrontendParameters &where)
 {
 	eDebug("(%d)tune", m_fe);
 
+	int res=0;
+
 	if (m_type == -1)
 		return -ENODEV;
 
@@ -767,23 +1034,13 @@ RESULT eDVBFrontend::tune(const iDVBFrontendParameters &where)
 	{
 	case feSatellite:
 	{
-		int res;
 		eDVBFrontendParametersSatellite feparm;
 		if (where.getDVBS(feparm))
 		{
 			eDebug("no dvbs data!");
 			return -EINVAL;
 		}
-		if (!m_sec)
-		{
-			eWarning("no SEC module active!");
-			return -ENOENT;
-		}
-		
-		res = m_sec->prepare(*this, parm, feparm, 1 << m_fe);
-		if (res)
-			return res;
-		eDebug("tuning to %d mhz", parm.frequency/1000);
+		res=prepare_sat(feparm);
 		break;
 	}
 	case feCable:
@@ -791,71 +1048,9 @@ RESULT eDVBFrontend::tune(const iDVBFrontendParameters &where)
 		eDVBFrontendParametersCable feparm;
 		if (where.getDVBC(feparm))
 			return -EINVAL;
-		parm.frequency = feparm.frequency * 1000;
-		parm.u.qam.symbol_rate = feparm.symbol_rate;
-		switch (feparm.modulation)
-		{
-		case eDVBFrontendParametersCable::Modulation::QAM16:
-			parm.u.qam.modulation = QAM_16;
-			break;
-		case eDVBFrontendParametersCable::Modulation::QAM32:
-			parm.u.qam.modulation = QAM_32;
-			break;
-		case eDVBFrontendParametersCable::Modulation::QAM64:
-			parm.u.qam.modulation = QAM_64;
-			break;
-		case eDVBFrontendParametersCable::Modulation::QAM128:
-			parm.u.qam.modulation = QAM_128;
-			break;
-		case eDVBFrontendParametersCable::Modulation::QAM256:
-			parm.u.qam.modulation = QAM_256;
-			break;
-		default:
-		case eDVBFrontendParametersCable::Modulation::Auto:
-			parm.u.qam.modulation = QAM_AUTO;
-			break;
-		}
-		switch (feparm.inversion)
-		{
-		case eDVBFrontendParametersCable::Inversion::On:
-			parm.inversion = INVERSION_ON;
-			break;
-		case eDVBFrontendParametersCable::Inversion::Off:
-			parm.inversion = INVERSION_OFF;
-			break;
-		default:
-		case eDVBFrontendParametersCable::Inversion::Unknown:
-			parm.inversion = INVERSION_AUTO;
-			break;
-		}
-		switch (feparm.fec_inner)
-		{
-		case eDVBFrontendParametersCable::FEC::fNone:
-			parm.u.qam.fec_inner = FEC_NONE;
-			break;
-		case eDVBFrontendParametersCable::FEC::f1_2:
-			parm.u.qam.fec_inner = FEC_1_2;
-			break;
-		case eDVBFrontendParametersCable::FEC::f2_3:
-			parm.u.qam.fec_inner = FEC_2_3;
-			break;
-		case eDVBFrontendParametersCable::FEC::f3_4:
-			parm.u.qam.fec_inner = FEC_3_4;
-			break;
-		case eDVBFrontendParametersCable::FEC::f5_6:
-			parm.u.qam.fec_inner = FEC_5_6;
-			break;
-		case eDVBFrontendParametersCable::FEC::f7_8:
-			parm.u.qam.fec_inner = FEC_7_8;
-			break;
-		case eDVBFrontendParametersCable::FEC::f8_9:
-			parm.u.qam.fec_inner = FEC_8_9;
-			break;
-		default:
-		case eDVBFrontendParametersCable::FEC::fAuto:
-			parm.u.qam.fec_inner = FEC_AUTO;
-			break;
-		}
+		res=prepare_cable(feparm);
+		if (!res)
+			m_sec_sequence.push_back( eSecCommand(eSecCommand::SET_FRONTEND) );
 		break;
 	}
 	case feTerrestrial:
@@ -866,147 +1061,28 @@ RESULT eDVBFrontend::tune(const iDVBFrontendParameters &where)
 			eDebug("no -T data");
 			return -EINVAL;
 		}
-		parm.frequency = feparm.frequency;
-
-		switch (feparm.bandwidth)
-		{
-		case eDVBFrontendParametersTerrestrial::Bandwidth::Bw8MHz:
-			parm.u.ofdm.bandwidth = BANDWIDTH_8_MHZ;
-			break;
-		case eDVBFrontendParametersTerrestrial::Bandwidth::Bw7MHz:
-			parm.u.ofdm.bandwidth = BANDWIDTH_7_MHZ;
-			break;
-		case eDVBFrontendParametersTerrestrial::Bandwidth::Bw6MHz:
-			parm.u.ofdm.bandwidth = BANDWIDTH_6_MHZ;
-			break;
-		default:
-		case eDVBFrontendParametersTerrestrial::Bandwidth::BwAuto:
-			parm.u.ofdm.bandwidth = BANDWIDTH_AUTO;
-			break;
-		}
-		switch (feparm.code_rate_LP)
-		{
-		case eDVBFrontendParametersCable::FEC::f1_2:
-			parm.u.ofdm.code_rate_LP = FEC_1_2;
-			break;
-		case eDVBFrontendParametersCable::FEC::f2_3:
-			parm.u.ofdm.code_rate_LP = FEC_2_3;
-			break;
-		case eDVBFrontendParametersCable::FEC::f3_4:
-			parm.u.ofdm.code_rate_LP = FEC_3_4;
-			break;
-		case eDVBFrontendParametersCable::FEC::f5_6:
-			parm.u.ofdm.code_rate_LP = FEC_5_6;
-			break;
-		case eDVBFrontendParametersCable::FEC::f7_8:
-			parm.u.ofdm.code_rate_LP = FEC_7_8;
-			break;
-		default:
-		case eDVBFrontendParametersCable::FEC::fAuto:
-		case eDVBFrontendParametersCable::FEC::fNone:
-			parm.u.ofdm.code_rate_LP = FEC_AUTO;
-			break;
-		}
-		switch (feparm.code_rate_HP)
-		{
-		case eDVBFrontendParametersCable::FEC::f1_2:
-			parm.u.ofdm.code_rate_HP = FEC_1_2;
-			break;
-		case eDVBFrontendParametersCable::FEC::f2_3:
-			parm.u.ofdm.code_rate_HP = FEC_2_3;
-			break;
-		case eDVBFrontendParametersCable::FEC::f3_4:
-			parm.u.ofdm.code_rate_HP = FEC_3_4;
-			break;
-		case eDVBFrontendParametersCable::FEC::f5_6:
-			parm.u.ofdm.code_rate_HP = FEC_5_6;
-			break;
-		case eDVBFrontendParametersCable::FEC::f7_8:
-			parm.u.ofdm.code_rate_HP = FEC_7_8;
-			break;
-		default:
-		case eDVBFrontendParametersCable::FEC::fAuto:
-		case eDVBFrontendParametersCable::FEC::fNone:
-			parm.u.ofdm.code_rate_HP = FEC_AUTO;
-			break;
-		}
-		switch (feparm.modulation)
-		{
-		case eDVBFrontendParametersTerrestrial::Modulation::QPSK:
-			parm.u.ofdm.constellation = QPSK;
-			break;
-		case eDVBFrontendParametersTerrestrial::Modulation::QAM16:
-			parm.u.ofdm.constellation = QAM_16;
-			break;
-		default:
-		case eDVBFrontendParametersTerrestrial::Modulation::Auto:
-			parm.u.ofdm.constellation = QAM_AUTO;
-			break;
-		}
-		switch (feparm.transmission_mode)
-		{
-		case eDVBFrontendParametersTerrestrial::TransmissionMode::TM2k:
-			parm.u.ofdm.transmission_mode = TRANSMISSION_MODE_2K;
-			break;
-		case eDVBFrontendParametersTerrestrial::TransmissionMode::TM8k:
-			parm.u.ofdm.transmission_mode = TRANSMISSION_MODE_8K;
-			break;
-		default:
-		case eDVBFrontendParametersTerrestrial::TransmissionMode::TMAuto:
-			parm.u.ofdm.transmission_mode = TRANSMISSION_MODE_AUTO;
-			break;
-		}
-		switch (feparm.guard_interval)
-		{
-			case eDVBFrontendParametersTerrestrial::GuardInterval::GI_1_32:
-				parm.u.ofdm.guard_interval = GUARD_INTERVAL_1_32;
-				break;
-			case eDVBFrontendParametersTerrestrial::GuardInterval::GI_1_16:
-				parm.u.ofdm.guard_interval = GUARD_INTERVAL_1_16;
-				break;
-			case eDVBFrontendParametersTerrestrial::GuardInterval::GI_1_8:
-				parm.u.ofdm.guard_interval = GUARD_INTERVAL_1_8;
-				break;
-			case eDVBFrontendParametersTerrestrial::GuardInterval::GI_1_4:
-				parm.u.ofdm.guard_interval = GUARD_INTERVAL_1_4;
-				break;
-			default:
-			case eDVBFrontendParametersTerrestrial::GuardInterval::GI_Auto:
-				parm.u.ofdm.guard_interval = GUARD_INTERVAL_AUTO;
-				break;
-		}
-		switch (feparm.hierarchy)
-		{
-			case eDVBFrontendParametersTerrestrial::Hierarchy::H1:
-				parm.u.ofdm.hierarchy_information = HIERARCHY_1;
-				break;
-			case eDVBFrontendParametersTerrestrial::Hierarchy::H2:
-				parm.u.ofdm.hierarchy_information = HIERARCHY_2;
-				break;
-			case eDVBFrontendParametersTerrestrial::Hierarchy::H4:
-				parm.u.ofdm.hierarchy_information = HIERARCHY_4;
-				break;
-			default:
-			case eDVBFrontendParametersTerrestrial::Hierarchy::HAuto:
-				parm.u.ofdm.hierarchy_information = HIERARCHY_AUTO;
-				break;
-		}
+		res=prepare_terrestrial(feparm);
+		if (!res)
+			m_sec_sequence.push_back( eSecCommand(eSecCommand::SET_FRONTEND) );
+		break;
 	}
 	}
 
-	m_sec_sequence.push_back( eSecCommand(eSecCommand::SET_FRONTEND) );
-	m_tuneTimer->start(0,true);
-	m_timeout->stop();
-	m_sec_sequence.current() = m_sec_sequence.begin();
-
-	if (m_state != stateTuning)
+	if (!res)  // prepare ok
 	{
-		m_tuning = 1;
-		m_state = stateTuning;
-		m_stateChanged(this);
+		m_tuneTimer->start(0,true);
+		m_timeout->stop();
+		m_sec_sequence.current() = m_sec_sequence.begin();
+
+		if (m_state != stateTuning)
+		{
+			m_tuning = 1;
+			m_state = stateTuning;
+			m_stateChanged(this);
+		}
 	}
 
-	return 0;
+	return res;
 }
 
 RESULT eDVBFrontend::connectStateChange(const Slot1<void,iDVBFrontend*> &stateChange, ePtr<eConnection> &connection)
diff --git a/lib/dvb/frontend.h b/lib/dvb/frontend.h
index 2cccf885..c28399b4 100644
--- a/lib/dvb/frontend.h
+++ b/lib/dvb/frontend.h
@@ -69,6 +69,7 @@ class eDVBFrontend: public iDVBFrontend, public Object
 
 	int m_idleInputpower[2];  // 13V .. 18V
 	int m_runningInputpower;
+
 	int m_timeoutCount; // needed for timeout
 	int m_retryCount; // diseqc retry for rotor
 	int m_curVoltage;
@@ -85,6 +86,9 @@ public:
 
 	RESULT getFrontendType(int &type);
 	RESULT tune(const iDVBFrontendParameters &where);
+	RESULT prepare_sat(const eDVBFrontendParametersSatellite &);
+	RESULT prepare_cable(const eDVBFrontendParametersCable &);
+	RESULT prepare_terrestrial(const eDVBFrontendParametersTerrestrial &);
 	RESULT connectStateChange(const Slot1<void,iDVBFrontend*> &stateChange, ePtr<eConnection> &connection);
 	RESULT getState(int &state);
 	RESULT setTone(int tone);
@@ -96,7 +100,7 @@ public:
 	RESULT getData(int num, int &data);
 	RESULT setData(int num, int val);
 
-	int readFrontendData(int type); // bitErrorRate, signalPower, signalQuality
+	int readFrontendData(int type); // bitErrorRate, signalPower, signalQuality, Locked, Synced
 	int isCompatibleWith(ePtr<iDVBFrontendParameters> &feparm);
 	int getID() { return m_fe; }
 
diff --git a/lib/dvb/idvb.h b/lib/dvb/idvb.h
index da7ac3b5..ada337c8 100644
--- a/lib/dvb/idvb.h
+++ b/lib/dvb/idvb.h
@@ -358,7 +358,7 @@ public:
 	virtual RESULT setSecSequence(const eSecCommandList &list)=0;
 
 	enum {
-		bitErrorRate, signalPower, signalQuality
+		bitErrorRate, signalPower, signalQuality, Locked, Synced
 	};
 	virtual int readFrontendData(int type)=0;
 
@@ -372,7 +372,7 @@ public:
 class iDVBSatelliteEquipmentControl: public iObject
 {
 public:
-	virtual RESULT prepare(iDVBFrontend &frontend, FRONTENDPARAMETERS &parm, eDVBFrontendParametersSatellite &sat, int frontend_id)=0;
+	virtual RESULT prepare(iDVBFrontend &frontend, FRONTENDPARAMETERS &parm, const eDVBFrontendParametersSatellite &sat, int frontend_id)=0;
 	virtual int canTune(const eDVBFrontendParametersSatellite &feparm, iDVBFrontend *fe, int frontend_id)=0;
 	virtual void setRotorMoving(bool)=0;
 };
diff --git a/lib/dvb/sec.cpp b/lib/dvb/sec.cpp
index aeaf5a2a..4d6558da 100644
--- a/lib/dvb/sec.cpp
+++ b/lib/dvb/sec.cpp
@@ -271,7 +271,7 @@ int eDVBSatelliteEquipmentControl::canTune(const eDVBFrontendParametersSatellite
 
 #define VOLTAGE(x) (lnb_param.m_increased_voltage ? iDVBFrontend::voltage##x##_5 : iDVBFrontend::voltage##x)
 
-RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPARAMETERS &parm, eDVBFrontendParametersSatellite &sat, int frontend_id)
+RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPARAMETERS &parm, const eDVBFrontendParametersSatellite &sat, int frontend_id)
 {
 	bool linked=false;
 	bool depend_satpos_mode=false;
@@ -289,7 +289,7 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA
 		if ( sit != lnb_param.m_satellites.end())
 		{
 			eDVBSatelliteSwitchParameters &sw_param = sit->second;
-
+			bool doSetVoltageToneFrontend = true;
 			int band=0,
 				linked_to=-1, // linked tuner
 				satpos_depends_to=-1,
@@ -554,8 +554,12 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA
 					sec_sequence.push_back( eSecCommand(eSecCommand::IF_NOT_VOLTAGE_GOTO, compare) );
 
 					if ( RotorCmd != -1 && RotorCmd != lastRotorCmd )
-						// TODO .. add handling for turning rotor without measure inputpower
-						compare.voltage = VOLTAGE(18);
+					{
+						if (rotor_param.m_inputpower_parameters.m_use)
+							compare.voltage = VOLTAGE(18);  // in input power mode turn rotor always with 18V (fast)
+						else
+							compare.voltage = VOLTAGE(13);  // in normal mode start turning with 13V
+					}
 					else
 						compare.voltage = voltage;
 
@@ -652,8 +656,11 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA
 					// else we set voltage after all diseqc stuff..
 					sec_sequence.push_back( eSecCommand(eSecCommand::IF_NOT_VOLTAGE_GOTO, compare) );
 
-					// TODO .. add handling for turning rotor without measure inputpower
-					sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, VOLTAGE(18)) );
+					if (rotor_param.m_inputpower_parameters.m_use)
+						sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, VOLTAGE(13)) ); // in normal mode start turning with 13V
+					else
+						sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, VOLTAGE(18)) ); // turn always with 18V
+
 					// voltage was disabled..so we wait a longer time ..
 					sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 500) );
 					sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, +7) );  // no need to send stop rotor cmd
@@ -741,13 +748,46 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA
 						sec_sequence.push_back( eSecCommand(eSecCommand::IF_TIMEOUT_GOTO, +3 ) );  // timeout ? this should never happen
 						sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, -4) );  // running loop start
 /////////////////////
-						sec_sequence.push_back( eSecCommand(eSecCommand::UPDATE_CURRENT_ROTORPARAMS) );
-						sec_sequence.push_back( eSecCommand(eSecCommand::SET_POWER_LIMITING_MODE, eSecCommand::modeDynamic) );
-						frontend.setData(3, RotorCmd);
-						frontend.setData(4, sat.orbital_position);
 					}
 					else
-						eFatal("rotor turning without inputpowermeasure not implemented yet");
+					{  // use normal turning mode
+						doSetVoltageToneFrontend=false;
+						eSecCommand::rotor cmd;
+						eSecCommand::pair compare;
+						compare.voltage = VOLTAGE(13);
+						compare.steps = +2;
+						sec_sequence.push_back( eSecCommand(eSecCommand::IF_VOLTAGE_GOTO, compare) );
+						sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, compare.voltage) );
+						sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 200) );  // wait 200msec after voltage change
+
+						sec_sequence.push_back( eSecCommand(eSecCommand::SET_POWER_LIMITING_MODE, eSecCommand::modeStatic) );
+						sec_sequence.push_back( eSecCommand(eSecCommand::INVALIDATE_CURRENT_ROTORPARMS) );
+						sec_sequence.push_back( eSecCommand(eSecCommand::SEND_DISEQC, diseqc) );
+
+						compare.voltage = voltage;
+						compare.steps = +3;
+						sec_sequence.push_back( eSecCommand(eSecCommand::IF_VOLTAGE_GOTO, compare) ); // correct final voltage?
+						sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 2000) );  // wait 2 second before set high voltage
+						sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, voltage) );
+
+						sec_sequence.push_back( eSecCommand(eSecCommand::SET_TONE, tone) );
+						sec_sequence.push_back( eSecCommand(eSecCommand::SET_FRONTEND) );
+
+						cmd.direction=1;  // check for running rotor
+						cmd.deltaA=0;
+						cmd.steps=+3;
+						cmd.okcount=0;
+
+						sec_sequence.push_back( eSecCommand(eSecCommand::SET_TIMEOUT, 480) );  // 2 minutes running timeout
+						sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 250) );  // 250msec delay
+						sec_sequence.push_back( eSecCommand(eSecCommand::IF_TUNER_LOCKED_GOTO, cmd ) );
+						sec_sequence.push_back( eSecCommand(eSecCommand::IF_TIMEOUT_GOTO, +3 ) ); 
+						sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, -3) );  // goto loop start
+					}
+					sec_sequence.push_back( eSecCommand(eSecCommand::UPDATE_CURRENT_ROTORPARAMS) );
+					sec_sequence.push_back( eSecCommand(eSecCommand::SET_POWER_LIMITING_MODE, eSecCommand::modeDynamic) );
+					frontend.setData(3, RotorCmd);
+					frontend.setData(4, sat.orbital_position);
 				}
 			}
 			else
@@ -760,15 +800,21 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA
 			if ( linked )
 				return 0;
 
-			eSecCommand::pair compare;
-			compare.voltage = voltage;
-			compare.steps = +3;
-			sec_sequence.push_back( eSecCommand(eSecCommand::IF_VOLTAGE_GOTO, compare) ); // voltage already correct ?
-			sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, voltage) );
-			sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 10) );
-
-			sec_sequence.push_back( eSecCommand(eSecCommand::SET_TONE, tone) );
-			sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 15) );
+			if (doSetVoltageToneFrontend)
+			{
+				eSecCommand::pair compare;
+				compare.voltage = voltage;
+				compare.steps = +3;
+				sec_sequence.push_back( eSecCommand(eSecCommand::IF_VOLTAGE_GOTO, compare) ); // voltage already correct ?
+				sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, voltage) );
+				sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 10) );
+
+				sec_sequence.push_back( eSecCommand(eSecCommand::SET_TONE, tone) );
+				sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 15) );
+
+				sec_sequence.push_back( eSecCommand(eSecCommand::START_TUNE_TIMEOUT) );
+				sec_sequence.push_back( eSecCommand(eSecCommand::SET_FRONTEND) );
+			}
 
 			frontend.setSecSequence(sec_sequence);
 
diff --git a/lib/dvb/sec.h b/lib/dvb/sec.h
index ac18f3c6..d86d96ea 100644
--- a/lib/dvb/sec.h
+++ b/lib/dvb/sec.h
@@ -19,7 +19,9 @@ public:
 		MEASURE_IDLE_INPUTPOWER, MEASURE_RUNNING_INPUTPOWER,
 		IF_MEASURE_IDLE_WAS_NOT_OK_GOTO, IF_INPUTPOWER_DELTA_GOTO,
 		UPDATE_CURRENT_ROTORPARAMS, INVALIDATE_CURRENT_ROTORPARMS,
-		IF_ROTORPOS_VALID_GOTO
+		IF_ROTORPOS_VALID_GOTO,
+		IF_TUNER_LOCKED_GOTO,
+		START_TUNE_TIMEOUT
 	};
 	int cmd;
 	struct rotor
@@ -250,7 +252,7 @@ public:
 #ifndef SWIG
 	eDVBSatelliteEquipmentControl(eSmartPtrList<eDVBRegisteredFrontend> &avail_frontends);
 	DECLARE_REF(eDVBSatelliteEquipmentControl);
-	RESULT prepare(iDVBFrontend &frontend, FRONTENDPARAMETERS &parm, eDVBFrontendParametersSatellite &sat, int frontend_id);
+	RESULT prepare(iDVBFrontend &frontend, FRONTENDPARAMETERS &parm, const eDVBFrontendParametersSatellite &sat, int frontend_id);
 	int canTune(const eDVBFrontendParametersSatellite &feparm, iDVBFrontend *, int frontend_id);
 	bool currentLNBValid() { return m_lnbidx > -1 && m_lnbidx < (int)(sizeof(m_lnbs) / sizeof(eDVBSatelliteLNBParameters)); }
 #endif