1 #include <lib/dvb/dvb.h>
2 #include <lib/base/eerror.h>
8 #ifndef I2C_SLAVE_FORCE
9 #define I2C_SLAVE_FORCE 0x0706
12 #if HAVE_DVB_API_VERSION < 3
13 #include <ost/frontend.h>
15 #define QAM_AUTO (Modulation)6
16 #define TRANSMISSION_MODE_AUTO (TransmitMode)2
17 #define BANDWIDTH_AUTO (BandWidth)3
18 #define GUARD_INTERVAL_AUTO (GuardInterval)4
19 #define HIERARCHY_AUTO (Hierarchy)4
20 #define parm_frequency parm.Frequency
21 #define parm_inversion parm.Inversion
22 #define parm_u_qpsk_symbol_rate parm.u.qpsk.SymbolRate
23 #define parm_u_qpsk_fec_inner parm.u.qpsk.FEC_inner
24 #define parm_u_qam_symbol_rate parm.u.qam.SymbolRate
25 #define parm_u_qam_fec_inner parm.u.qam.FEC_inner
26 #define parm_u_qam_modulation parm.u.qam.QAM
27 #define parm_u_ofdm_bandwidth parm.u.ofdm.bandWidth
28 #define parm_u_ofdm_code_rate_LP parm.u.ofdm.LP_CodeRate
29 #define parm_u_ofdm_code_rate_HP parm.u.ofdm.HP_CodeRate
30 #define parm_u_ofdm_constellation parm.u.ofdm.Constellation
31 #define parm_u_ofdm_transmission_mode parm.u.ofdm.TransmissionMode
32 #define parm_u_ofdm_guard_interval parm.u.ofdm.guardInterval
33 #define parm_u_ofdm_hierarchy_information parm.u.ofdm.HierarchyInformation
35 #include <linux/dvb/frontend.h>
36 #define parm_frequency parm.frequency
37 #define parm_inversion parm.inversion
38 #define parm_u_qpsk_symbol_rate parm.u.qpsk.symbol_rate
39 #define parm_u_qpsk_fec_inner parm.u.qpsk.fec_inner
40 #define parm_u_qam_symbol_rate parm.u.qam.symbol_rate
41 #define parm_u_qam_fec_inner parm.u.qam.fec_inner
42 #define parm_u_qam_modulation parm.u.qam.modulation
43 #define parm_u_ofdm_bandwidth parm.u.ofdm.bandwidth
44 #define parm_u_ofdm_code_rate_LP parm.u.ofdm.code_rate_LP
45 #define parm_u_ofdm_code_rate_HP parm.u.ofdm.code_rate_HP
46 #define parm_u_ofdm_constellation parm.u.ofdm.constellation
47 #define parm_u_ofdm_transmission_mode parm.u.ofdm.transmission_mode
48 #define parm_u_ofdm_guard_interval parm.u.ofdm.guard_interval
49 #define parm_u_ofdm_hierarchy_information parm.u.ofdm.hierarchy_information
51 #warning "FEC_9_10 already exist in dvb api ... it seems it is now ready for DVB-S2"
53 #define FEC_S2_1_2 (fe_code_rate_t)(FEC_AUTO+1)
54 #define FEC_S2_2_3 (fe_code_rate_t)(FEC_S2_1_2+1)
55 #define FEC_S2_3_4 (fe_code_rate_t)(FEC_S2_2_3+1)
56 #define FEC_S2_5_6 (fe_code_rate_t)(FEC_S2_3_4+1)
57 #define FEC_S2_7_8 (fe_code_rate_t)(FEC_S2_5_6+1)
58 #define FEC_S2_8_9 (fe_code_rate_t)(FEC_S2_7_8+1)
59 #define FEC_S2_3_5 (fe_code_rate_t)(FEC_S2_8_9+1)
60 #define FEC_S2_4_5 (fe_code_rate_t)(FEC_S2_3_5+1)
61 #define FEC_S2_9_10 (fe_code_rate_t)(FEC_S2_4_5+1)
65 #include <dvbsi++/satellite_delivery_system_descriptor.h>
66 #include <dvbsi++/cable_delivery_system_descriptor.h>
67 #include <dvbsi++/terrestrial_delivery_system_descriptor.h>
69 void eDVBDiseqcCommand::setCommandString(const char *str)
74 int slen = strlen(str);
77 eDebug("invalid diseqc command string length (not 2 byte aligned)");
80 if (slen > MAX_DISEQC_LENGTH*2)
82 eDebug("invalid diseqc command string length (string is to long)");
86 for (int i=0; i < slen; ++i)
88 unsigned char c = str[i];
91 case '0' ... '9': c-=48; break;
92 case 'a' ... 'f': c-=87; break;
93 case 'A' ... 'F': c-=55; break;
95 eDebug("invalid character in hex string..ignore complete diseqc command !");
109 void eDVBFrontendParametersSatellite::set(const SatelliteDeliverySystemDescriptor &descriptor)
111 frequency = descriptor.getFrequency() * 10;
112 symbol_rate = descriptor.getSymbolRate() * 100;
113 polarisation = descriptor.getPolarization();
114 fec = descriptor.getFecInner();
115 if ( fec != FEC::fNone && fec > FEC::f9_10 )
117 inversion = Inversion::Unknown;
118 orbital_position = ((descriptor.getOrbitalPosition() >> 12) & 0xF) * 1000;
119 orbital_position += ((descriptor.getOrbitalPosition() >> 8) & 0xF) * 100;
120 orbital_position += ((descriptor.getOrbitalPosition() >> 4) & 0xF) * 10;
121 orbital_position += ((descriptor.getOrbitalPosition()) & 0xF);
122 if (orbital_position && (!descriptor.getWestEastFlag()))
123 orbital_position = 3600 - orbital_position;
124 system = descriptor.getModulationSystem();
125 modulation = descriptor.getModulation();
126 if (system == System::DVB_S && modulation == Modulation::M8PSK)
128 eDebug("satellite_delivery_descriptor non valid modulation type.. force QPSK");
131 roll_off = descriptor.getRollOff();
132 if (system == System::DVB_S2)
134 eDebug("SAT DVB-S2 freq %d, %s, pos %d, sr %d, fec %d, modulation %d, roll_off %d",
136 polarisation ? "hor" : "vert",
144 eDebug("SAT DVB-S freq %d, %s, pos %d, sr %d, fec %d",
146 polarisation ? "hor" : "vert",
152 void eDVBFrontendParametersCable::set(const CableDeliverySystemDescriptor &descriptor)
154 frequency = descriptor.getFrequency() / 10;
155 symbol_rate = descriptor.getSymbolRate() * 100;
156 fec_inner = descriptor.getFecInner();
157 if ( fec_inner == 0xF )
158 fec_inner = FEC::fNone;
159 modulation = descriptor.getModulation();
160 if ( modulation > 0x5 )
161 modulation = Modulation::Auto;
162 inversion = Inversion::Unknown;
163 eDebug("Cable freq %d, mod %d, sr %d, fec %d",
165 modulation, symbol_rate, fec_inner);
168 void eDVBFrontendParametersTerrestrial::set(const TerrestrialDeliverySystemDescriptor &descriptor)
170 frequency = descriptor.getCentreFrequency() * 10;
171 bandwidth = descriptor.getBandwidth();
172 if ( bandwidth > 2 ) // 5Mhz forced to auto
173 bandwidth = Bandwidth::BwAuto;
174 code_rate_HP = descriptor.getCodeRateHpStream();
175 if (code_rate_HP > 4)
176 code_rate_HP = FEC::fAuto;
177 code_rate_LP = descriptor.getCodeRateLpStream();
178 if (code_rate_LP > 4)
179 code_rate_LP = FEC::fAuto;
180 transmission_mode = descriptor.getTransmissionMode();
181 if (transmission_mode > 1) // TM4k forced to auto
182 transmission_mode = TransmissionMode::TMAuto;
183 guard_interval = descriptor.getGuardInterval();
184 if (guard_interval > 3)
185 guard_interval = GuardInterval::GI_Auto;
186 hierarchy = descriptor.getHierarchyInformation()&3;
187 modulation = descriptor.getConstellation();
189 modulation = Modulation::Auto;
190 inversion = Inversion::Unknown;
191 eDebug("Terr freq %d, bw %d, cr_hp %d, cr_lp %d, tm_mode %d, guard %d, hierarchy %d, const %d",
192 frequency, bandwidth, code_rate_HP, code_rate_LP, transmission_mode,
193 guard_interval, hierarchy, modulation);
196 eDVBFrontendParameters::eDVBFrontendParameters(): m_type(-1)
200 DEFINE_REF(eDVBFrontendParameters);
202 RESULT eDVBFrontendParameters::getSystem(int &t) const
210 RESULT eDVBFrontendParameters::getDVBS(eDVBFrontendParametersSatellite &p) const
212 if (m_type != iDVBFrontend::feSatellite)
218 RESULT eDVBFrontendParameters::getDVBC(eDVBFrontendParametersCable &p) const
220 if (m_type != iDVBFrontend::feCable)
226 RESULT eDVBFrontendParameters::getDVBT(eDVBFrontendParametersTerrestrial &p) const
228 if (m_type != iDVBFrontend::feTerrestrial)
234 RESULT eDVBFrontendParameters::setDVBS(const eDVBFrontendParametersSatellite &p, bool no_rotor_command_on_tune)
237 sat.no_rotor_command_on_tune = no_rotor_command_on_tune;
238 m_type = iDVBFrontend::feSatellite;
242 RESULT eDVBFrontendParameters::setDVBC(const eDVBFrontendParametersCable &p)
245 m_type = iDVBFrontend::feCable;
249 RESULT eDVBFrontendParameters::setDVBT(const eDVBFrontendParametersTerrestrial &p)
252 m_type = iDVBFrontend::feTerrestrial;
256 RESULT eDVBFrontendParameters::calculateDifference(const iDVBFrontendParameters *parm, int &diff) const
261 if (parm->getSystem(type))
265 diff = 1<<30; // big difference
271 case iDVBFrontend::feSatellite:
273 eDVBFrontendParametersSatellite osat;
274 if (parm->getDVBS(osat))
277 if (sat.orbital_position != osat.orbital_position)
279 else if (sat.polarisation != osat.polarisation)
283 diff = abs(sat.frequency - osat.frequency);
284 diff += abs(sat.symbol_rate - osat.symbol_rate);
288 case iDVBFrontend::feCable:
289 eDVBFrontendParametersCable ocable;
290 if (parm->getDVBC(ocable))
293 if (cable.modulation != ocable.modulation && cable.modulation != eDVBFrontendParametersCable::Modulation::Auto && ocable.modulation != eDVBFrontendParametersCable::Modulation::Auto)
295 else if (cable.inversion != ocable.inversion && cable.inversion != eDVBFrontendParametersCable::Inversion::Unknown && ocable.inversion != eDVBFrontendParametersCable::Inversion::Unknown)
299 diff = abs(cable.frequency - ocable.frequency);
300 diff += abs(cable.symbol_rate - ocable.symbol_rate);
304 case iDVBFrontend::feTerrestrial:
305 eDVBFrontendParametersTerrestrial oterrestrial;
306 if (parm->getDVBT(oterrestrial))
309 diff = abs(terrestrial.frequency - oterrestrial.frequency);
318 RESULT eDVBFrontendParameters::getHash(unsigned long &hash) const
322 case iDVBFrontend::feSatellite:
324 hash = (sat.orbital_position << 16);
325 hash |= ((sat.frequency/1000)&0xFFFF)|((sat.polarisation&1) << 15);
328 case iDVBFrontend::feCable:
331 case iDVBFrontend::feTerrestrial:
339 DEFINE_REF(eDVBFrontend);
341 eDVBFrontend::eDVBFrontend(int adap, int fe, int &ok)
342 :m_type(-1), m_fe(fe), m_fd(-1), m_sn(0), m_timeout(0), m_tuneTimer(0)
343 #if HAVE_DVB_API_VERSION < 3
347 #if HAVE_DVB_API_VERSION < 3
348 sprintf(m_filename, "/dev/dvb/card%d/frontend%d", adap, fe);
349 sprintf(m_sec_filename, "/dev/dvb/card%d/sec%d", adap, fe);
351 sprintf(m_filename, "/dev/dvb/adapter%d/frontend%d", adap, fe);
353 m_timeout = new eTimer(eApp);
354 CONNECT(m_timeout->timeout, eDVBFrontend::timeout);
356 m_tuneTimer = new eTimer(eApp);
357 CONNECT(m_tuneTimer->timeout, eDVBFrontend::tuneLoop);
359 for (int i=0; i<eDVBFrontend::NUM_DATA_ENTRIES; ++i)
362 m_idleInputpower[0]=m_idleInputpower[1]=0;
364 ok = !openFrontend();
368 int eDVBFrontend::openFrontend()
371 return -1; // already opened
376 #if HAVE_DVB_API_VERSION < 3
379 m_secfd = ::open(m_sec_filename, O_RDWR);
382 eWarning("failed! (%s) %m", m_sec_filename);
387 eWarning("sec %d already opened", m_fe);
388 FrontendInfo fe_info;
390 dvb_frontend_info fe_info;
392 eDebug("opening frontend %d", m_fe);
395 m_fd = ::open(m_filename, O_RDWR|O_NONBLOCK);
398 eWarning("failed! (%s) %m", m_filename);
399 #if HAVE_DVB_API_VERSION < 3
407 eWarning("frontend %d already opened", m_fe);
410 if (::ioctl(m_fd, FE_GET_INFO, &fe_info) < 0)
412 eWarning("ioctl FE_GET_INFO failed");
415 #if HAVE_DVB_API_VERSION < 3
422 switch (fe_info.type)
425 m_type = iDVBFrontend::feSatellite;
428 m_type = iDVBFrontend::feCable;
431 m_type = iDVBFrontend::feTerrestrial;
434 eWarning("unknown frontend type.");
437 #if HAVE_DVB_API_VERSION < 3
443 eDebug("detected %s frontend", "satellite\0cable\0 terrestrial"+fe_info.type*10);
446 setTone(iDVBFrontend::toneOff);
447 setVoltage(iDVBFrontend::voltageOff);
449 m_sn = new eSocketNotifier(eApp, m_fd, eSocketNotifier::Read);
450 CONNECT(m_sn->activated, eDVBFrontend::feEvent);
455 int eDVBFrontend::closeFrontend()
457 eDVBRegisteredFrontend *linked_fe = (eDVBRegisteredFrontend*)m_data[LINKED_NEXT_PTR];
458 while (linked_fe != (eDVBRegisteredFrontend*)-1)
460 if (linked_fe->m_inuse)
462 eDebug("dont close frontend %d until the linked frontend %d is still in use",
463 m_fe, linked_fe->m_frontend->getID());
466 linked_fe->m_frontend->getData(LINKED_NEXT_PTR, (int&)linked_fe);
470 eDebug("close frontend %d", m_fe);
472 setTone(iDVBFrontend::toneOff);
473 setVoltage(iDVBFrontend::voltageOff);
475 m_sec->setRotorMoving(false);
479 eWarning("couldnt close frontend %d", m_fe);
480 m_data[CSW] = m_data[UCSW] = m_data[TONEBURST] = -1;
482 #if HAVE_DVB_API_VERSION < 3
485 if (!::close(m_secfd))
488 eWarning("couldnt close sec %d", m_fe);
497 eDVBFrontend::~eDVBFrontend()
504 void eDVBFrontend::feEvent(int w)
508 #if HAVE_DVB_API_VERSION < 3
511 dvb_frontend_event event;
515 res = ::ioctl(m_fd, FE_GET_EVENT, &event);
517 if (res && (errno == EAGAIN))
522 eWarning("FE_GET_EVENT failed! %m");
529 #if HAVE_DVB_API_VERSION < 3
530 if (event.type == FE_COMPLETION_EV)
532 eDebug("(%d)fe event: status %x, inversion %s", m_fe, event.status, (event.parameters.inversion == INVERSION_ON) ? "on" : "off");
533 if (event.status & FE_HAS_LOCK)
543 state = stateLostLock;
544 m_data[CSW] = m_data[UCSW] = m_data[TONEBURST] = -1; // reset diseqc
547 if (m_state != state)
550 m_stateChanged(this);
555 void eDVBFrontend::timeout()
558 if (m_state == stateTuning)
560 m_state = stateFailed;
561 m_stateChanged(this);
565 int eDVBFrontend::readFrontendData(int type)
572 if (ioctl(m_fd, FE_READ_BER, &ber) < 0 && errno != ERANGE)
573 eDebug("FE_READ_BER failed (%m)");
579 if (ioctl(m_fd, FE_READ_SNR, &snr) < 0 && errno != ERANGE)
580 eDebug("FE_READ_SNR failed (%m)");
586 if (ioctl(m_fd, FE_READ_SIGNAL_STRENGTH, &strength) < 0 && errno != ERANGE)
587 eDebug("FE_READ_SIGNAL_STRENGTH failed (%m)");
592 #if HAVE_DVB_API_VERSION < 3
593 FrontendStatus status=0;
597 if ( ioctl(m_fd, FE_READ_STATUS, &status) < 0 && errno != ERANGE )
598 eDebug("FE_READ_STATUS failed (%m)");
599 return !!(status&FE_HAS_LOCK);
603 #if HAVE_DVB_API_VERSION < 3
604 FrontendStatus status=0;
608 if ( ioctl(m_fd, FE_READ_STATUS, &status) < 0 && errno != ERANGE )
609 eDebug("FE_READ_STATUS failed (%m)");
610 return !!(status&FE_HAS_SYNC);
618 void PutToDict(PyObject *dict, const char*key, long value)
620 PyObject *item = PyInt_FromLong(value);
623 if (PyDict_SetItemString(dict, key, item))
624 eDebug("put %s to dict failed", key);
628 eDebug("could not create PyObject for %s", key);
631 void PutToDict(PyObject *dict, const char*key, const char *value)
633 PyObject *item = PyString_FromString(value);
636 if (PyDict_SetItemString(dict, key, item))
637 eDebug("put %s to dict failed", key);
641 eDebug("could not create PyObject for %s", key);
644 void fillDictWithSatelliteData(PyObject *dict, const FRONTENDPARAMETERS &parm, eDVBFrontend *fe)
649 fe->getData(eDVBFrontend::CSW, csw);
650 fe->getData(eDVBFrontend::FREQ_OFFSET, freq_offset);
651 int frequency = parm_frequency + freq_offset;
652 PutToDict(dict, "frequency", frequency);
653 PutToDict(dict, "symbol_rate", parm_u_qpsk_symbol_rate);
654 switch(parm_u_qpsk_fec_inner)
677 #if HAVE_DVB_API_VERSION >=3
707 PutToDict(dict, "fec_inner", tmp);
708 tmp = parm_u_qpsk_fec_inner > FEC_AUTO ?
710 PutToDict(dict, "system", tmp);
713 void fillDictWithCableData(PyObject *dict, const FRONTENDPARAMETERS &parm)
716 PutToDict(dict, "frequency", parm_frequency/1000);
717 PutToDict(dict, "symbol_rate", parm_u_qam_symbol_rate);
718 switch(parm_u_qam_fec_inner)
738 #if HAVE_DVB_API_VERSION >= 3
748 PutToDict(dict, "fec_inner", tmp);
749 switch(parm_u_qam_modulation)
771 PutToDict(dict, "modulation", tmp);
774 void fillDictWithTerrestrialData(PyObject *dict, const FRONTENDPARAMETERS &parm)
777 PutToDict(dict, "frequency", parm_frequency);
778 switch (parm_u_ofdm_bandwidth)
780 case BANDWIDTH_8_MHZ:
781 tmp = "BANDWIDTH_8_MHZ";
783 case BANDWIDTH_7_MHZ:
784 tmp = "BANDWIDTH_7_MHZ";
786 case BANDWIDTH_6_MHZ:
787 tmp = "BANDWIDTH_6_MHZ";
791 tmp = "BANDWIDTH_AUTO";
794 PutToDict(dict, "bandwidth", tmp);
795 switch (parm_u_ofdm_code_rate_LP)
817 PutToDict(dict, "code_rate_lp", tmp);
818 switch (parm_u_ofdm_code_rate_HP)
840 PutToDict(dict, "code_rate_hp", tmp);
841 switch (parm_u_ofdm_constellation)
857 PutToDict(dict, "constellation", tmp);
858 switch (parm_u_ofdm_transmission_mode)
860 case TRANSMISSION_MODE_2K:
861 tmp = "TRANSMISSION_MODE_2K";
863 case TRANSMISSION_MODE_8K:
864 tmp = "TRANSMISSION_MODE_8K";
867 case TRANSMISSION_MODE_AUTO:
868 tmp = "TRANSMISSION_MODE_AUTO";
871 PutToDict(dict, "transmission_mode", tmp);
872 switch (parm_u_ofdm_guard_interval)
874 case GUARD_INTERVAL_1_32:
875 tmp = "GUARD_INTERVAL_1_32";
877 case GUARD_INTERVAL_1_16:
878 tmp = "GUARD_INTERVAL_1_16";
880 case GUARD_INTERVAL_1_8:
881 tmp = "GUARD_INTERVAL_1_8";
883 case GUARD_INTERVAL_1_4:
884 tmp = "GUARD_INTERVAL_1_4";
887 case GUARD_INTERVAL_AUTO:
888 tmp = "GUARD_INTERVAL_AUTO";
891 PutToDict(dict, "guard_interval", tmp);
892 switch (parm_u_ofdm_hierarchy_information)
895 tmp = "HIERARCHY_NONE";
908 tmp = "HIERARCHY_AUTO";
911 PutToDict(dict, "hierarchy_information", tmp);
914 PyObject *eDVBFrontend::readTransponderData(bool original)
916 PyObject *ret=PyDict_New();
920 bool read=m_fd != -1;
923 PutToDict(ret, "tuner_number", m_fe);
941 PutToDict(ret, "tuner_type", tmp);
945 FRONTENDPARAMETERS front;
968 PutToDict(ret, "tuner_state", tmp);
970 PutToDict(ret, "tuner_locked", readFrontendData(locked));
971 PutToDict(ret, "tuner_synced", readFrontendData(synced));
972 PutToDict(ret, "tuner_bit_error_rate", readFrontendData(bitErrorRate));
973 PutToDict(ret, "tuner_signal_power", readFrontendData(signalPower));
974 PutToDict(ret, "tuner_signal_quality", readFrontendData(signalQuality));
976 if (!original && ioctl(m_fd, FE_GET_FRONTEND, &front)<0)
977 eDebug("FE_GET_FRONTEND (%m)");
980 tmp = "INVERSION_AUTO";
981 switch(parm_inversion)
984 tmp = "INVERSION_ON";
987 tmp = "INVERSION_OFF";
993 PutToDict(ret, "inversion", tmp);
998 fillDictWithSatelliteData(ret, original?parm:front, this);
1001 fillDictWithCableData(ret, original?parm:front);
1004 fillDictWithTerrestrialData(ret, original?parm:front);
1018 #ifndef FP_IOCTL_GET_ID
1019 #define FP_IOCTL_GET_ID 0
1021 int eDVBFrontend::readInputpower()
1023 int power=m_fe; // this is needed for read inputpower from the correct tuner !
1025 // open front prozessor
1026 int fp=::open("/dev/dbox/fp0", O_RDWR);
1029 eDebug("couldn't open fp");
1032 static bool old_fp = (::ioctl(fp, FP_IOCTL_GET_ID) < 0);
1033 if ( ioctl( fp, old_fp ? 9 : 0x100, &power ) < 0 )
1035 eDebug("FP_IOCTL_GET_LNB_CURRENT failed (%m)");
1043 bool eDVBFrontend::setSecSequencePos(int steps)
1045 eDebug("set sequence pos %d", steps);
1050 if (m_sec_sequence.current() != m_sec_sequence.end())
1051 ++m_sec_sequence.current();
1056 if (m_sec_sequence.current() != m_sec_sequence.begin() && m_sec_sequence.current() != m_sec_sequence.end())
1057 --m_sec_sequence.current();
1063 void eDVBFrontend::tuneLoop() // called by m_tuneTimer
1066 if ( m_sec_sequence && m_sec_sequence.current() != m_sec_sequence.end() )
1068 // eDebug("tuneLoop %d\n", m_sec_sequence.current()->cmd);
1069 switch (m_sec_sequence.current()->cmd)
1071 case eSecCommand::SLEEP:
1072 delay = m_sec_sequence.current()++->msec;
1073 eDebug("[SEC] sleep %dms", delay);
1075 case eSecCommand::GOTO:
1076 if ( !setSecSequencePos(m_sec_sequence.current()->steps) )
1077 ++m_sec_sequence.current();
1079 case eSecCommand::SET_VOLTAGE:
1081 int voltage = m_sec_sequence.current()++->voltage;
1082 eDebug("[SEC] setVoltage %d", voltage);
1083 setVoltage(voltage);
1086 case eSecCommand::IF_VOLTAGE_GOTO:
1088 eSecCommand::pair &compare = m_sec_sequence.current()->compare;
1089 if ( compare.voltage == m_curVoltage && setSecSequencePos(compare.steps) )
1091 ++m_sec_sequence.current();
1094 case eSecCommand::IF_NOT_VOLTAGE_GOTO:
1096 eSecCommand::pair &compare = m_sec_sequence.current()->compare;
1097 if ( compare.voltage != m_curVoltage && setSecSequencePos(compare.steps) )
1099 ++m_sec_sequence.current();
1102 case eSecCommand::SET_TONE:
1103 eDebug("[SEC] setTone %d", m_sec_sequence.current()->tone);
1104 setTone(m_sec_sequence.current()++->tone);
1106 case eSecCommand::SEND_DISEQC:
1107 sendDiseqc(m_sec_sequence.current()->diseqc);
1108 eDebugNoNewLine("[SEC] sendDiseqc: ");
1109 for (int i=0; i < m_sec_sequence.current()->diseqc.len; ++i)
1110 eDebugNoNewLine("%02x", m_sec_sequence.current()->diseqc.data[i]);
1112 ++m_sec_sequence.current();
1114 case eSecCommand::SEND_TONEBURST:
1115 eDebug("[SEC] sendToneburst: %d", m_sec_sequence.current()->toneburst);
1116 sendToneburst(m_sec_sequence.current()++->toneburst);
1118 case eSecCommand::SET_FRONTEND:
1119 eDebug("[SEC] setFrontend");
1121 ++m_sec_sequence.current();
1123 case eSecCommand::START_TUNE_TIMEOUT:
1124 m_timeout->start(5000, 1); // 5 sec timeout. TODO: symbolrate dependent
1125 ++m_sec_sequence.current();
1127 case eSecCommand::SET_TIMEOUT:
1128 m_timeoutCount = m_sec_sequence.current()++->val;
1129 eDebug("[SEC] set timeout %d", m_timeoutCount);
1131 case eSecCommand::IF_TIMEOUT_GOTO:
1132 if (!m_timeoutCount)
1134 eDebug("[SEC] rotor timout");
1135 m_sec->setRotorMoving(false);
1136 setSecSequencePos(m_sec_sequence.current()->steps);
1139 ++m_sec_sequence.current();
1141 case eSecCommand::MEASURE_IDLE_INPUTPOWER:
1143 int idx = m_sec_sequence.current()++->val;
1144 if ( idx == 0 || idx == 1 )
1146 m_idleInputpower[idx] = readInputpower();
1147 eDebug("[SEC] idleInputpower[%d] is %d", idx, m_idleInputpower[idx]);
1150 eDebug("[SEC] idleInputpower measure index(%d) out of bound !!!", idx);
1153 case eSecCommand::IF_MEASURE_IDLE_WAS_NOT_OK_GOTO:
1155 eSecCommand::pair &compare = m_sec_sequence.current()->compare;
1156 int idx = compare.voltage;
1157 if ( idx == 0 || idx == 1 )
1159 int idle = readInputpower();
1160 int diff = abs(idle-m_idleInputpower[idx]);
1163 eDebug("measure idle(%d) was not okay.. (%d - %d = %d) retry", idx, m_idleInputpower[idx], idle, diff);
1164 setSecSequencePos(compare.steps);
1168 ++m_sec_sequence.current();
1171 case eSecCommand::IF_TUNER_LOCKED_GOTO:
1173 eSecCommand::rotor &cmd = m_sec_sequence.current()->measure;
1174 if (readFrontendData(locked))
1176 eDebug("[SEC] locked step %d ok", cmd.okcount);
1178 if (cmd.okcount > 12)
1180 eDebug("ok > 12 .. goto %d\n",m_sec_sequence.current()->steps);
1181 setSecSequencePos(cmd.steps);
1187 eDebug("[SEC] rotor locked step %d failed", cmd.okcount);
1189 if (!m_timeoutCount && m_retryCount > 0)
1193 ++m_sec_sequence.current();
1196 case eSecCommand::MEASURE_RUNNING_INPUTPOWER:
1197 m_runningInputpower = readInputpower();
1198 eDebug("[SEC] runningInputpower is %d", m_runningInputpower);
1199 ++m_sec_sequence.current();
1201 case eSecCommand::IF_INPUTPOWER_DELTA_GOTO:
1203 int idleInputpower = m_idleInputpower[ (m_curVoltage&1) ? 0 : 1];
1204 eSecCommand::rotor &cmd = m_sec_sequence.current()->measure;
1205 const char *txt = cmd.direction ? "running" : "stopped";
1206 eDebug("[SEC] waiting for rotor %s %d, idle %d, delta %d",
1208 m_runningInputpower,
1211 if ( (cmd.direction && abs(m_runningInputpower - idleInputpower) >= cmd.deltaA)
1212 || (!cmd.direction && abs(m_runningInputpower - idleInputpower) <= cmd.deltaA) )
1215 eDebug("[SEC] rotor %s step %d ok", txt, cmd.okcount);
1216 if ( cmd.okcount > 6 )
1218 m_sec->setRotorMoving(cmd.direction);
1219 eDebug("[SEC] rotor is %s", txt);
1220 if (setSecSequencePos(cmd.steps))
1226 eDebug("[SEC] rotor not %s... reset counter.. increase timeout", txt);
1228 if (!m_timeoutCount && m_retryCount > 0)
1232 ++m_sec_sequence.current();
1235 case eSecCommand::IF_ROTORPOS_VALID_GOTO:
1236 if (m_data[ROTOR_CMD] != -1 && m_data[ROTOR_POS] != -1)
1237 setSecSequencePos(m_sec_sequence.current()->steps);
1239 ++m_sec_sequence.current();
1241 case eSecCommand::INVALIDATE_CURRENT_ROTORPARMS:
1242 m_data[ROTOR_CMD] = m_data[ROTOR_POS] = -1;
1243 eDebug("[SEC] invalidate current rotorparams");
1244 ++m_sec_sequence.current();
1246 case eSecCommand::UPDATE_CURRENT_ROTORPARAMS:
1247 m_data[ROTOR_CMD] = m_data[NEW_ROTOR_CMD];
1248 m_data[ROTOR_POS] = m_data[NEW_ROTOR_POS];
1249 eDebug("[SEC] update current rotorparams %d %04x %d", m_timeoutCount, m_data[5], m_data[6]);
1250 ++m_sec_sequence.current();
1252 case eSecCommand::SET_ROTOR_DISEQC_RETRYS:
1253 m_retryCount = m_sec_sequence.current()++->val;
1254 eDebug("[SEC] set rotor retries %d", m_retryCount);
1256 case eSecCommand::IF_NO_MORE_ROTOR_DISEQC_RETRYS_GOTO:
1259 eDebug("[SEC] no more rotor retrys");
1260 setSecSequencePos(m_sec_sequence.current()->steps);
1263 ++m_sec_sequence.current();
1265 case eSecCommand::SET_POWER_LIMITING_MODE:
1268 ::open("/dev/i2c/1", O_RDWR) :
1269 ::open("/dev/i2c/0", O_RDWR);
1271 unsigned char data[2];
1272 ::ioctl(fd, I2C_SLAVE_FORCE, 0x10 >> 1);
1273 if(::read(fd, data, 1) != 1)
1274 eDebug("[SEC] error read lnbp (%m)");
1275 if ( m_sec_sequence.current()->mode == eSecCommand::modeStatic )
1277 data[0] |= 0x80; // enable static current limiting
1278 eDebug("[SEC] set static current limiting");
1282 data[0] &= ~0x80; // enable dynamic current limiting
1283 eDebug("[SEC] set dynamic current limiting");
1285 if(::write(fd, data, 1) != 1)
1286 eDebug("[SEC] error write lnbp (%m)");
1288 ++m_sec_sequence.current();
1292 ++m_sec_sequence.current();
1293 eDebug("[SEC] unhandled sec command");
1295 m_tuneTimer->start(delay,true);
1299 void eDVBFrontend::setFrontend()
1301 eDebug("setting frontend %d", m_fe);
1304 if (ioctl(m_fd, FE_SET_FRONTEND, &parm) == -1)
1306 perror("FE_SET_FRONTEND failed");
1311 RESULT eDVBFrontend::getFrontendType(int &t)
1319 RESULT eDVBFrontend::prepare_sat(const eDVBFrontendParametersSatellite &feparm)
1324 eWarning("no SEC module active!");
1327 res = m_sec->prepare(*this, parm, feparm, 1 << m_fe);
1330 parm_u_qpsk_symbol_rate = feparm.symbol_rate;
1331 switch (feparm.inversion)
1333 case eDVBFrontendParametersSatellite::Inversion::On:
1334 parm_inversion = INVERSION_ON;
1336 case eDVBFrontendParametersSatellite::Inversion::Off:
1337 parm_inversion = INVERSION_OFF;
1340 case eDVBFrontendParametersSatellite::Inversion::Unknown:
1341 parm_inversion = INVERSION_AUTO;
1344 if (feparm.system == eDVBFrontendParametersSatellite::System::DVB_S)
1347 case eDVBFrontendParametersSatellite::FEC::fNone:
1348 parm_u_qpsk_fec_inner = FEC_NONE;
1350 case eDVBFrontendParametersSatellite::FEC::f1_2:
1351 parm_u_qpsk_fec_inner = FEC_1_2;
1353 case eDVBFrontendParametersSatellite::FEC::f2_3:
1354 parm_u_qpsk_fec_inner = FEC_2_3;
1356 case eDVBFrontendParametersSatellite::FEC::f3_4:
1357 parm_u_qpsk_fec_inner = FEC_3_4;
1359 case eDVBFrontendParametersSatellite::FEC::f5_6:
1360 parm_u_qpsk_fec_inner = FEC_5_6;
1362 case eDVBFrontendParametersSatellite::FEC::f7_8:
1363 parm_u_qpsk_fec_inner = FEC_7_8;
1366 eDebug("no valid fec for DVB-S set.. assume auto");
1367 case eDVBFrontendParametersSatellite::FEC::fAuto:
1368 parm_u_qpsk_fec_inner = FEC_AUTO;
1371 #if HAVE_DVB_API_VERSION >= 3
1375 case eDVBFrontendParametersSatellite::FEC::f1_2:
1376 parm_u_qpsk_fec_inner = FEC_S2_1_2;
1378 case eDVBFrontendParametersSatellite::FEC::f2_3:
1379 parm_u_qpsk_fec_inner = FEC_S2_2_3;
1381 case eDVBFrontendParametersSatellite::FEC::f3_4:
1382 parm_u_qpsk_fec_inner = FEC_S2_3_4;
1384 case eDVBFrontendParametersSatellite::FEC::f3_5:
1385 parm_u_qpsk_fec_inner = FEC_S2_3_5;
1387 case eDVBFrontendParametersSatellite::FEC::f4_5:
1388 parm_u_qpsk_fec_inner = FEC_S2_4_5;
1390 case eDVBFrontendParametersSatellite::FEC::f5_6:
1391 parm_u_qpsk_fec_inner = FEC_S2_5_6;
1393 case eDVBFrontendParametersSatellite::FEC::f7_8:
1394 parm_u_qpsk_fec_inner = FEC_S2_7_8;
1396 case eDVBFrontendParametersSatellite::FEC::f8_9:
1397 parm_u_qpsk_fec_inner = FEC_S2_8_9;
1399 case eDVBFrontendParametersSatellite::FEC::f9_10:
1400 parm_u_qpsk_fec_inner = FEC_S2_9_10;
1403 eDebug("no valid fec for DVB-S2 set.. abort !!");
1407 // FIXME !!! get frequency range from tuner
1408 if ( parm_frequency < 900000 || parm_frequency > 2200000 )
1410 eDebug("%d mhz out of tuner range.. dont tune", parm_frequency/1000);
1413 eDebug("tuning to %d mhz", parm_frequency/1000);
1418 RESULT eDVBFrontend::prepare_cable(const eDVBFrontendParametersCable &feparm)
1420 parm_frequency = feparm.frequency * 1000;
1421 parm_u_qam_symbol_rate = feparm.symbol_rate;
1422 switch (feparm.modulation)
1424 case eDVBFrontendParametersCable::Modulation::QAM16:
1425 parm_u_qam_modulation = QAM_16;
1427 case eDVBFrontendParametersCable::Modulation::QAM32:
1428 parm_u_qam_modulation = QAM_32;
1430 case eDVBFrontendParametersCable::Modulation::QAM64:
1431 parm_u_qam_modulation = QAM_64;
1433 case eDVBFrontendParametersCable::Modulation::QAM128:
1434 parm_u_qam_modulation = QAM_128;
1436 case eDVBFrontendParametersCable::Modulation::QAM256:
1437 parm_u_qam_modulation = QAM_256;
1440 case eDVBFrontendParametersCable::Modulation::Auto:
1441 parm_u_qam_modulation = QAM_AUTO;
1444 switch (feparm.inversion)
1446 case eDVBFrontendParametersCable::Inversion::On:
1447 parm_inversion = INVERSION_ON;
1449 case eDVBFrontendParametersCable::Inversion::Off:
1450 parm_inversion = INVERSION_OFF;
1453 case eDVBFrontendParametersCable::Inversion::Unknown:
1454 parm_inversion = INVERSION_AUTO;
1457 switch (feparm.fec_inner)
1459 case eDVBFrontendParametersCable::FEC::fNone:
1460 parm_u_qam_fec_inner = FEC_NONE;
1462 case eDVBFrontendParametersCable::FEC::f1_2:
1463 parm_u_qam_fec_inner = FEC_1_2;
1465 case eDVBFrontendParametersCable::FEC::f2_3:
1466 parm_u_qam_fec_inner = FEC_2_3;
1468 case eDVBFrontendParametersCable::FEC::f3_4:
1469 parm_u_qam_fec_inner = FEC_3_4;
1471 case eDVBFrontendParametersCable::FEC::f5_6:
1472 parm_u_qam_fec_inner = FEC_5_6;
1474 case eDVBFrontendParametersCable::FEC::f7_8:
1475 parm_u_qam_fec_inner = FEC_7_8;
1477 #if HAVE_DVB_API_VERSION >= 3
1478 case eDVBFrontendParametersCable::FEC::f8_9:
1479 parm_u_qam_fec_inner = FEC_8_9;
1483 case eDVBFrontendParametersCable::FEC::fAuto:
1484 parm_u_qam_fec_inner = FEC_AUTO;
1490 RESULT eDVBFrontend::prepare_terrestrial(const eDVBFrontendParametersTerrestrial &feparm)
1492 parm_frequency = feparm.frequency;
1494 switch (feparm.bandwidth)
1496 case eDVBFrontendParametersTerrestrial::Bandwidth::Bw8MHz:
1497 parm_u_ofdm_bandwidth = BANDWIDTH_8_MHZ;
1499 case eDVBFrontendParametersTerrestrial::Bandwidth::Bw7MHz:
1500 parm_u_ofdm_bandwidth = BANDWIDTH_7_MHZ;
1502 case eDVBFrontendParametersTerrestrial::Bandwidth::Bw6MHz:
1503 parm_u_ofdm_bandwidth = BANDWIDTH_6_MHZ;
1506 case eDVBFrontendParametersTerrestrial::Bandwidth::BwAuto:
1507 parm_u_ofdm_bandwidth = BANDWIDTH_AUTO;
1510 switch (feparm.code_rate_LP)
1512 case eDVBFrontendParametersTerrestrial::FEC::f1_2:
1513 parm_u_ofdm_code_rate_LP = FEC_1_2;
1515 case eDVBFrontendParametersTerrestrial::FEC::f2_3:
1516 parm_u_ofdm_code_rate_LP = FEC_2_3;
1518 case eDVBFrontendParametersTerrestrial::FEC::f3_4:
1519 parm_u_ofdm_code_rate_LP = FEC_3_4;
1521 case eDVBFrontendParametersTerrestrial::FEC::f5_6:
1522 parm_u_ofdm_code_rate_LP = FEC_5_6;
1524 case eDVBFrontendParametersTerrestrial::FEC::f7_8:
1525 parm_u_ofdm_code_rate_LP = FEC_7_8;
1528 case eDVBFrontendParametersTerrestrial::FEC::fAuto:
1529 parm_u_ofdm_code_rate_LP = FEC_AUTO;
1532 switch (feparm.code_rate_HP)
1534 case eDVBFrontendParametersTerrestrial::FEC::f1_2:
1535 parm_u_ofdm_code_rate_HP = FEC_1_2;
1537 case eDVBFrontendParametersTerrestrial::FEC::f2_3:
1538 parm_u_ofdm_code_rate_HP = FEC_2_3;
1540 case eDVBFrontendParametersTerrestrial::FEC::f3_4:
1541 parm_u_ofdm_code_rate_HP = FEC_3_4;
1543 case eDVBFrontendParametersTerrestrial::FEC::f5_6:
1544 parm_u_ofdm_code_rate_HP = FEC_5_6;
1546 case eDVBFrontendParametersTerrestrial::FEC::f7_8:
1547 parm_u_ofdm_code_rate_HP = FEC_7_8;
1550 case eDVBFrontendParametersTerrestrial::FEC::fAuto:
1551 parm_u_ofdm_code_rate_HP = FEC_AUTO;
1554 switch (feparm.modulation)
1556 case eDVBFrontendParametersTerrestrial::Modulation::QPSK:
1557 parm_u_ofdm_constellation = QPSK;
1559 case eDVBFrontendParametersTerrestrial::Modulation::QAM16:
1560 parm_u_ofdm_constellation = QAM_16;
1562 case eDVBFrontendParametersTerrestrial::Modulation::QAM64:
1563 parm_u_ofdm_constellation = QAM_64;
1566 case eDVBFrontendParametersTerrestrial::Modulation::Auto:
1567 parm_u_ofdm_constellation = QAM_AUTO;
1570 switch (feparm.transmission_mode)
1572 case eDVBFrontendParametersTerrestrial::TransmissionMode::TM2k:
1573 parm_u_ofdm_transmission_mode = TRANSMISSION_MODE_2K;
1575 case eDVBFrontendParametersTerrestrial::TransmissionMode::TM8k:
1576 parm_u_ofdm_transmission_mode = TRANSMISSION_MODE_8K;
1579 case eDVBFrontendParametersTerrestrial::TransmissionMode::TMAuto:
1580 parm_u_ofdm_transmission_mode = TRANSMISSION_MODE_AUTO;
1583 switch (feparm.guard_interval)
1585 case eDVBFrontendParametersTerrestrial::GuardInterval::GI_1_32:
1586 parm_u_ofdm_guard_interval = GUARD_INTERVAL_1_32;
1588 case eDVBFrontendParametersTerrestrial::GuardInterval::GI_1_16:
1589 parm_u_ofdm_guard_interval = GUARD_INTERVAL_1_16;
1591 case eDVBFrontendParametersTerrestrial::GuardInterval::GI_1_8:
1592 parm_u_ofdm_guard_interval = GUARD_INTERVAL_1_8;
1594 case eDVBFrontendParametersTerrestrial::GuardInterval::GI_1_4:
1595 parm_u_ofdm_guard_interval = GUARD_INTERVAL_1_4;
1598 case eDVBFrontendParametersTerrestrial::GuardInterval::GI_Auto:
1599 parm_u_ofdm_guard_interval = GUARD_INTERVAL_AUTO;
1602 switch (feparm.hierarchy)
1604 case eDVBFrontendParametersTerrestrial::Hierarchy::HNone:
1605 parm_u_ofdm_hierarchy_information = HIERARCHY_NONE;
1607 case eDVBFrontendParametersTerrestrial::Hierarchy::H1:
1608 parm_u_ofdm_hierarchy_information = HIERARCHY_1;
1610 case eDVBFrontendParametersTerrestrial::Hierarchy::H2:
1611 parm_u_ofdm_hierarchy_information = HIERARCHY_2;
1613 case eDVBFrontendParametersTerrestrial::Hierarchy::H4:
1614 parm_u_ofdm_hierarchy_information = HIERARCHY_4;
1617 case eDVBFrontendParametersTerrestrial::Hierarchy::HAuto:
1618 parm_u_ofdm_hierarchy_information = HIERARCHY_AUTO;
1621 switch (feparm.inversion)
1623 case eDVBFrontendParametersTerrestrial::Inversion::On:
1624 parm_inversion = INVERSION_ON;
1626 case eDVBFrontendParametersTerrestrial::Inversion::Off:
1627 parm_inversion = INVERSION_OFF;
1630 case eDVBFrontendParametersTerrestrial::Inversion::Unknown:
1631 parm_inversion = INVERSION_AUTO;
1637 RESULT eDVBFrontend::tune(const iDVBFrontendParameters &where)
1639 eDebug("(%d)tune", m_fe);
1649 m_sec_sequence.clear();
1655 eDVBFrontendParametersSatellite feparm;
1656 if (where.getDVBS(feparm))
1658 eDebug("no dvbs data!");
1661 res=prepare_sat(feparm);
1662 m_sec->setRotorMoving(false);
1667 eDVBFrontendParametersCable feparm;
1668 if (where.getDVBC(feparm))
1670 res=prepare_cable(feparm);
1673 m_sec_sequence.push_back( eSecCommand(eSecCommand::START_TUNE_TIMEOUT) );
1674 m_sec_sequence.push_back( eSecCommand(eSecCommand::SET_FRONTEND) );
1680 eDVBFrontendParametersTerrestrial feparm;
1681 if (where.getDVBT(feparm))
1683 eDebug("no -T data");
1686 res=prepare_terrestrial(feparm);
1689 m_sec_sequence.push_back( eSecCommand(eSecCommand::START_TUNE_TIMEOUT) );
1690 m_sec_sequence.push_back( eSecCommand(eSecCommand::SET_FRONTEND) );
1696 if (!res) // prepare ok
1698 m_tuneTimer->start(0,true);
1699 m_sec_sequence.current() = m_sec_sequence.begin();
1701 if (m_state != stateTuning)
1704 m_state = stateTuning;
1705 m_stateChanged(this);
1712 RESULT eDVBFrontend::connectStateChange(const Slot1<void,iDVBFrontend*> &stateChange, ePtr<eConnection> &connection)
1714 connection = new eConnection(this, m_stateChanged.connect(stateChange));
1718 RESULT eDVBFrontend::setVoltage(int voltage)
1720 if (m_type != feSatellite)
1722 #if HAVE_DVB_API_VERSION < 3
1725 bool increased=false;
1726 fe_sec_voltage_t vlt;
1728 m_curVoltage=voltage;
1732 for (int i=0; i < 3; ++i) // reset diseqc
1734 vlt = SEC_VOLTAGE_OFF;
1737 #if HAVE_DVB_API_VERSION < 3
1738 vlt = SEC_VOLTAGE_13_5;
1744 vlt = SEC_VOLTAGE_13;
1747 #if HAVE_DVB_API_VERSION < 3
1748 vlt = SEC_VOLTAGE_18_5;
1754 vlt = SEC_VOLTAGE_18;
1759 #if HAVE_DVB_API_VERSION < 3
1760 return ::ioctl(m_secfd, SEC_SET_VOLTAGE, vlt);
1762 if (::ioctl(m_fd, FE_ENABLE_HIGH_LNB_VOLTAGE, increased) < 0)
1763 perror("FE_ENABLE_HIGH_LNB_VOLTAGE");
1764 return ::ioctl(m_fd, FE_SET_VOLTAGE, vlt);
1768 RESULT eDVBFrontend::getState(int &state)
1774 RESULT eDVBFrontend::setTone(int t)
1776 if (m_type != feSatellite)
1778 #if HAVE_DVB_API_VERSION < 3
1781 fe_sec_tone_mode_t tone;
1790 tone = SEC_TONE_OFF;
1795 #if HAVE_DVB_API_VERSION < 3
1796 return ::ioctl(m_secfd, SEC_SET_TONE, tone);
1798 return ::ioctl(m_fd, FE_SET_TONE, tone);
1802 #if HAVE_DVB_API_VERSION < 3 && !defined(SEC_DISEQC_SEND_MASTER_CMD)
1803 #define SEC_DISEQC_SEND_MASTER_CMD _IOW('o', 97, struct secCommand *)
1806 RESULT eDVBFrontend::sendDiseqc(const eDVBDiseqcCommand &diseqc)
1808 #if HAVE_DVB_API_VERSION < 3
1809 struct secCommand cmd;
1810 cmd.type = SEC_CMDTYPE_DISEQC_RAW;
1811 cmd.u.diseqc.cmdtype = diseqc.data[0];
1812 cmd.u.diseqc.addr = diseqc.data[1];
1813 cmd.u.diseqc.cmd = diseqc.data[2];
1814 cmd.u.diseqc.numParams = diseqc.len-3;
1815 memcpy(cmd.u.diseqc.params, diseqc.data+3, diseqc.len-3);
1816 if (::ioctl(m_secfd, SEC_DISEQC_SEND_MASTER_CMD, &cmd))
1818 struct dvb_diseqc_master_cmd cmd;
1819 memcpy(cmd.msg, diseqc.data, diseqc.len);
1820 cmd.msg_len = diseqc.len;
1821 if (::ioctl(m_fd, FE_DISEQC_SEND_MASTER_CMD, &cmd))
1827 #if HAVE_DVB_API_VERSION < 3 && !defined(SEC_DISEQC_SEND_BURST)
1828 #define SEC_DISEQC_SEND_BURST _IO('o', 96)
1830 RESULT eDVBFrontend::sendToneburst(int burst)
1832 #if HAVE_DVB_API_VERSION < 3
1833 secMiniCmd cmd = SEC_MINI_NONE;
1835 fe_sec_mini_cmd_t cmd = SEC_MINI_A;
1837 if ( burst == eDVBSatelliteDiseqcParameters::A )
1839 else if ( burst == eDVBSatelliteDiseqcParameters::B )
1841 #if HAVE_DVB_API_VERSION < 3
1842 if (::ioctl(m_secfd, SEC_DISEQC_SEND_BURST, cmd))
1845 if (::ioctl(m_fd, FE_DISEQC_SEND_BURST, cmd))
1851 RESULT eDVBFrontend::setSEC(iDVBSatelliteEquipmentControl *sec)
1857 RESULT eDVBFrontend::setSecSequence(const eSecCommandList &list)
1859 m_sec_sequence = list;
1863 RESULT eDVBFrontend::getData(int num, int &data)
1865 if ( num < NUM_DATA_ENTRIES )
1873 RESULT eDVBFrontend::setData(int num, int val)
1875 if ( num < NUM_DATA_ENTRIES )
1883 int eDVBFrontend::isCompatibleWith(ePtr<iDVBFrontendParameters> &feparm)
1886 if (feparm->getSystem(type) || type != m_type)
1889 if (m_type == eDVBFrontend::feSatellite)
1892 eDVBFrontendParametersSatellite sat_parm;
1893 ASSERT(!feparm->getDVBS(sat_parm));
1894 return m_sec->canTune(sat_parm, this, 1 << m_fe);