X-Git-Url: https://git.cweiske.de/enigma2.git/blobdiff_plain/d0caa966095e23501dcc6ad850fe6d7416169a76..a29bbc0a4ee2eb5f0d86407088380de9887359a0:/lib/dvb/frontend.cpp

diff --git a/lib/dvb/frontend.cpp b/lib/dvb/frontend.cpp
index 7c29e9a6..af627e26 100644
--- a/lib/dvb/frontend.cpp
+++ b/lib/dvb/frontend.cpp
@@ -204,7 +204,8 @@ void eDVBFrontendParametersTerrestrial::set(const TerrestrialDeliverySystemDescr
 		guard_interval, hierarchy, modulation);
 }
 
-eDVBFrontendParameters::eDVBFrontendParameters(): m_type(-1)
+eDVBFrontendParameters::eDVBFrontendParameters()
+	:m_type(-1), m_flags(0)
 {
 }
 
@@ -559,7 +560,6 @@ int eDVBFrontend::closeFrontend(bool force)
 			m_fd=-1;
 		else
 			eWarning("couldnt close frontend %d", m_dvbid);
-		m_data[CSW] = m_data[UCSW] = m_data[TONEBURST] = -1;
 	}
 #if HAVE_DVB_API_VERSION < 3
 	if (m_secfd >= 0)
@@ -587,6 +587,14 @@ eDVBFrontend::~eDVBFrontend()
 
 void eDVBFrontend::feEvent(int w)
 {
+	eDVBFrontend *sec_fe = this;
+	long tmp = m_data[LINKED_PREV_PTR];
+	while (tmp != -1)
+	{
+		eDVBRegisteredFrontend *linked_fe = (eDVBRegisteredFrontend*)tmp;
+		sec_fe = linked_fe->m_frontend;
+		sec_fe->getData(LINKED_NEXT_PTR, tmp);
+	}
 	while (1)
 	{
 #if HAVE_DVB_API_VERSION < 3
@@ -626,7 +634,7 @@ void eDVBFrontend::feEvent(int w)
 			{
 				eDebug("stateLostLock");
 				state = stateLostLock;
-				m_data[CSW] = m_data[UCSW] = m_data[TONEBURST] = -1; // reset diseqc
+				sec_fe->m_data[CSW] = sec_fe->m_data[UCSW] = sec_fe->m_data[TONEBURST] = -1; // reset diseqc
 			}
 		}
 		if (m_state != state)
@@ -647,6 +655,8 @@ void eDVBFrontend::timeout()
 	}
 }
 
+#define INRANGE(X,Y,Z) (((X<=Y) && (Y<=Z))||((Z<=Y) && (Y<=X)) ? 1 : 0)
+
 int eDVBFrontend::readFrontendData(int type)
 {
 	switch(type)
@@ -703,6 +713,50 @@ int eDVBFrontend::readFrontendData(int type)
 			
 				return (int)(snr_in_db * 100.0);
 			}
+			else if (strstr(m_description, "Alps BSBE1 C01A") ||
+				!strcmp(m_description, "Alps -S(STV0288)"))
+			{
+				if (snr == 0)
+					return 0;
+				else if (snr == 0xFFFF) // i think this should not happen
+					return 100*100;
+				else
+				{
+					enum { REALVAL, REGVAL };
+					const long CN_lookup[31][2] = {
+						{20,8900}, {25,8680}, {30,8420}, {35,8217}, {40,7897},
+						{50,7333}, {60,6747}, {70,6162}, {80,5580}, {90,5029},
+						{100,4529}, {110,4080}, {120,3685}, {130,3316}, {140,2982},
+						{150,2688}, {160,2418}, {170,2188}, {180,1982}, {190,1802},
+						{200,1663}, {210,1520}, {220,1400}, {230,1295}, {240,1201},
+						{250,1123}, {260,1058}, {270,1004}, {280,957}, {290,920},
+						{300,890}
+					};
+					int add=strchr(m_description, '.') ? 0xA250 : 0xA100;
+					long regval = 0xFFFF - ((snr / 3) + add), // revert some dvb api calulations to get the real register value
+						Imin=0,
+						Imax=30,
+						i;
+					if(INRANGE(CN_lookup[Imin][REGVAL],regval,CN_lookup[Imax][REGVAL]))
+					{
+						long val;
+						while((Imax-Imin)>1)
+						{
+							i=(Imax+Imin)/2;
+							if(INRANGE(CN_lookup[Imin][REGVAL],regval,CN_lookup[i][REGVAL]))
+								Imax = i;
+							else
+								Imin = i;
+						}
+						return (((regval - CN_lookup[Imin][REGVAL])
+								* (CN_lookup[Imax][REALVAL] - CN_lookup[Imin][REALVAL])
+								/ (CN_lookup[Imax][REGVAL] - CN_lookup[Imin][REGVAL]))
+								+ CN_lookup[Imin][REALVAL]) * 10;
+					}
+					return 100;
+				}
+				return 0;
+			}
 			else if (!strcmp(m_description, "Alps BSBE1 702A") ||  // some frontends with STV0299
 				!strcmp(m_description, "Alps -S") ||
 				!strcmp(m_description, "Philips -S") ||
@@ -793,9 +847,7 @@ void PutToDict(ePyObject &dict, const char*key, const char *value)
 void fillDictWithSatelliteData(ePyObject dict, const FRONTENDPARAMETERS &parm, eDVBFrontend *fe)
 {
 	long freq_offset=0;
-	long csw=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);
@@ -1291,52 +1343,23 @@ bool eDVBFrontend::setSecSequencePos(int steps)
 	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;
-	eDVBFrontend *fe = this;
+	eDVBFrontend *sec_fe = this;
 	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];
-		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)
 			{
-				fe->closeFrontend(true);
-				state = fe->m_state;
+				sec_fe->closeFrontend(true);
+				state = sec_fe->m_state;
 			}
 			if (state == eDVBFrontend::stateClosed)
 			{
@@ -1348,7 +1371,7 @@ void eDVBFrontend::tuneLoop()  // called by m_tuneTimer
 
 	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)
 		{
@@ -1364,13 +1387,13 @@ void eDVBFrontend::tuneLoop()  // called by m_tuneTimer
 			{
 				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;
-				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;
@@ -1378,7 +1401,7 @@ void eDVBFrontend::tuneLoop()  // called by m_tuneTimer
 			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;
@@ -1386,7 +1409,7 @@ void eDVBFrontend::tuneLoop()  // called by m_tuneTimer
 			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;
@@ -1394,17 +1417,17 @@ void eDVBFrontend::tuneLoop()  // called by m_tuneTimer
 			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);
-				fe->setTone(m_sec_sequence.current()++->tone);
+				sec_fe->setTone(m_sec_sequence.current()++->tone);
 				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]);
@@ -1413,7 +1436,7 @@ void eDVBFrontend::tuneLoop()  // called by m_tuneTimer
 				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");
@@ -1434,7 +1457,6 @@ void eDVBFrontend::tuneLoop()  // called by m_tuneTimer
 				if (!m_timeoutCount)
 				{
 					eDebug("[SEC] rotor timout");
-					m_sec->setRotorMoving(false);
 					setSecSequencePos(m_sec_sequence.current()->steps);
 				}
 				else
@@ -1445,7 +1467,7 @@ void eDVBFrontend::tuneLoop()  // called by m_tuneTimer
 				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
@@ -1458,7 +1480,7 @@ void eDVBFrontend::tuneLoop()  // called by m_tuneTimer
 				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)
 					{
@@ -1472,37 +1494,62 @@ void eDVBFrontend::tuneLoop()  // called by m_tuneTimer
 			}
 			case eSecCommand::IF_TUNER_LOCKED_GOTO:
 			{
+				int signal = 0;
+				int isLocked = readFrontendData(locked);
+				m_idleInputpower[0] = m_idleInputpower[1] = 0;
 				eSecCommand::rotor &cmd = m_sec_sequence.current()->measure;
-				if (readFrontendData(locked))
+				if (isLocked && ((abs((signal = readFrontendData(signalQualitydB)) - cmd.lastSignal) < 50) || !cmd.lastSignal))
 				{
-					eDebug("[SEC] locked step %d ok", cmd.okcount);
+					if (cmd.lastSignal)
+						eDebug("[SEC] locked step %d ok (%d %d)", cmd.okcount, signal, cmd.lastSignal);
+					else
+					{
+						eDebug("[SEC] locked step %d ok", cmd.okcount);
+						cmd.lastSignal = signal;
+					}
 					++cmd.okcount;
-					if (cmd.okcount > 12)
+					if (cmd.okcount > 4)
 					{
-						eDebug("ok > 12 .. goto %d\n",m_sec_sequence.current()->steps);
+						eDebug("ok > 4 .. goto %d\n",cmd.steps);
 						setSecSequencePos(cmd.steps);
+						m_state = stateLock;
+						m_stateChanged(this);
+						feEvent(-1);
+						m_sn->start();
 						break;
 					}
 				}
 				else
 				{
-					eDebug("[SEC] rotor locked step %d failed", cmd.okcount);
+					if (isLocked)
+						eDebug("[SEC] rotor locked step %d failed (oldSignal %d, curSignal %d)", cmd.okcount, signal, cmd.lastSignal);
+					else
+						eDebug("[SEC] rotor locked step %d failed (not locked)", cmd.okcount);
 					--m_timeoutCount;
 					if (!m_timeoutCount && m_retryCount > 0)
 						--m_retryCount;
 					cmd.okcount=0;
+					cmd.lastSignal=0;
 				}
 				++m_sec_sequence.current();
 				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::SET_ROTOR_MOVING:
+				m_sec->setRotorMoving(true);
+				++m_sec_sequence.current();
+				break;
+			case eSecCommand::SET_ROTOR_STOPPED:
+				m_sec->setRotorMoving(false);
+				++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",
@@ -1517,7 +1564,6 @@ void eDVBFrontend::tuneLoop()  // called by m_tuneTimer
 					eDebug("[SEC] rotor %s step %d ok", txt, cmd.okcount);
 					if ( cmd.okcount > 6 )
 					{
-						m_sec->setRotorMoving(cmd.direction);
 						eDebug("[SEC] rotor is %s", txt);
 						if (setSecSequencePos(cmd.steps))
 							break;
@@ -1535,19 +1581,35 @@ void eDVBFrontend::tuneLoop()  // called by m_tuneTimer
 				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_SWITCHPARMS:
+				eDebug("[SEC] invalidate current switch params");
+				sec_fe_data[CSW] = -1;
+				sec_fe_data[UCSW] = -1;
+				sec_fe_data[TONEBURST] = -1;
+				++m_sec_sequence.current();
+				break;
+			case eSecCommand::UPDATE_CURRENT_SWITCHPARMS:
+				sec_fe_data[CSW] = sec_fe_data[NEW_CSW];
+				sec_fe_data[UCSW] = sec_fe_data[NEW_UCSW];
+				sec_fe_data[TONEBURST] = sec_fe_data[NEW_TONEBURST];
+				eDebug("[SEC] update current switch params");
+				++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:
-				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:
@@ -1566,7 +1628,7 @@ void eDVBFrontend::tuneLoop()  // called by m_tuneTimer
 			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?
 				{
@@ -1577,10 +1639,10 @@ void eDVBFrontend::tuneLoop()  // called by m_tuneTimer
 						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];
-					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);
@@ -2112,8 +2174,7 @@ RESULT eDVBFrontend::setVoltage(int voltage)
 	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:
@@ -2290,13 +2351,14 @@ int eDVBFrontend::isCompatibleWith(ePtr<iDVBFrontendParameters> &feparm)
 
 bool eDVBFrontend::setSlotInfo(ePyObject obj)
 {
-	ePyObject Id, Descr, Enabled;
-	if (!PyTuple_Check(obj) || PyTuple_Size(obj) != 3)
+	ePyObject Id, Descr, Enabled, IsDVBS2;
+	if (!PyTuple_Check(obj) || PyTuple_Size(obj) != 4)
 		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))
+	IsDVBS2 = PyTuple_GET_ITEM(obj, 3);
+	if (!PyInt_Check(Id) || !PyString_Check(Descr) || !PyBool_Check(Enabled) || !PyBool_Check(IsDVBS2))
 		goto arg_error;
 	strcpy(m_description, PyString_AS_STRING(Descr));
 	m_slotid = PyInt_AsLong(Id);
@@ -2306,7 +2368,7 @@ bool eDVBFrontend::setSlotInfo(ePyObject obj)
 		!!strstr(m_description, "Alps BSBE2") ||
 		!!strstr(m_description, "Alps -S") ||
 		!!strstr(m_description, "BCM4501");
-	m_can_handle_dvbs2 = !!strstr(m_description, "Alps BSBE2") || !!strstr(m_description, "BCM4501");
+	m_can_handle_dvbs2 = IsDVBS2 == Py_True;
 	eDebug("setSlotInfo for dvb frontend %d to slotid %d, descr %s, need rotorworkaround %s, enabled %s, DVB-S2 %s",
 		m_dvbid, m_slotid, m_description, m_need_rotor_workaround ? "Yes" : "No", m_enabled ? "Yes" : "No", m_can_handle_dvbs2 ? "Yes" : "No" );
 	return true;