2 #include <lib/dvb/dvb.h>
3 #include <lib/base/eerror.h>
9 #ifndef I2C_SLAVE_FORCE
10 #define I2C_SLAVE_FORCE 0x0706
13 #if HAVE_DVB_API_VERSION < 3
14 #include <ost/frontend.h>
16 #define QAM_AUTO (Modulation)6
17 #define TRANSMISSION_MODE_AUTO (TransmitMode)2
18 #define BANDWIDTH_AUTO (BandWidth)3
19 #define GUARD_INTERVAL_AUTO (GuardInterval)4
20 #define HIERARCHY_AUTO (Hierarchy)4
21 #define constellation Constellation
22 #define guard_interval guardInterval
23 #define hierarchy_information HierarchyInformation
24 #define code_rate_HP HP_CodeRate
25 #define code_rate_LP LP_CodeRate
27 #include <linux/dvb/frontend.h>
30 #include <dvbsi++/satellite_delivery_system_descriptor.h>
31 #include <dvbsi++/cable_delivery_system_descriptor.h>
32 #include <dvbsi++/terrestrial_delivery_system_descriptor.h>
34 void eDVBFrontendParametersSatellite::set(const SatelliteDeliverySystemDescriptor &descriptor)
36 frequency = descriptor.getFrequency() * 10;
37 symbol_rate = descriptor.getSymbolRate() * 100;
38 switch (descriptor.getPolarization())
41 polarisation = Polarisation::Horizontal;
44 polarisation = Polarisation::Vertical;
47 polarisation = Polarisation::CircularLeft;
50 polarisation = Polarisation::CircularRight;
53 switch (descriptor.getFecInner())
77 inversion = Inversion::Unknown;
78 orbital_position = ((descriptor.getOrbitalPosition() >> 12) & 0xF) * 1000;
79 orbital_position += ((descriptor.getOrbitalPosition() >> 8) & 0xF) * 100;
80 orbital_position += ((descriptor.getOrbitalPosition() >> 4) & 0xF) * 10;
81 orbital_position += ((descriptor.getOrbitalPosition()) & 0xF);
82 if (orbital_position && (!descriptor.getWestEastFlag()))
83 orbital_position = 3600 - orbital_position;
86 void eDVBFrontendParametersCable::set(const CableDeliverySystemDescriptor &descriptor)
91 void eDVBFrontendParametersTerrestrial::set(const TerrestrialDeliverySystemDescriptor &)
96 eDVBFrontendParameters::eDVBFrontendParameters(): m_type(-1)
100 DEFINE_REF(eDVBFrontendParameters);
102 RESULT eDVBFrontendParameters::getSystem(int &t) const
110 RESULT eDVBFrontendParameters::getDVBS(eDVBFrontendParametersSatellite &p) const
112 if (m_type != iDVBFrontend::feSatellite)
118 RESULT eDVBFrontendParameters::getDVBC(eDVBFrontendParametersCable &p) const
120 if (m_type != iDVBFrontend::feCable)
126 RESULT eDVBFrontendParameters::getDVBT(eDVBFrontendParametersTerrestrial &p) const
128 if (m_type != iDVBFrontend::feTerrestrial)
134 RESULT eDVBFrontendParameters::setDVBS(eDVBFrontendParametersSatellite &p)
137 m_type = iDVBFrontend::feSatellite;
141 RESULT eDVBFrontendParameters::setDVBC(eDVBFrontendParametersCable &p)
144 m_type = iDVBFrontend::feCable;
148 RESULT eDVBFrontendParameters::setDVBT(eDVBFrontendParametersTerrestrial &p)
151 m_type = iDVBFrontend::feTerrestrial;
155 RESULT eDVBFrontendParameters::calculateDifference(const iDVBFrontendParameters *parm, int &diff) const
160 if (parm->getSystem(type))
164 diff = 1<<30; // big difference
170 case iDVBFrontend::feSatellite:
172 eDVBFrontendParametersSatellite osat;
173 if (parm->getDVBS(osat))
176 if (sat.orbital_position != osat.orbital_position)
178 else if (sat.polarisation != osat.polarisation)
181 diff = abs(sat.frequency - osat.frequency);
184 case iDVBFrontend::feCable:
185 case iDVBFrontend::feTerrestrial:
192 RESULT eDVBFrontendParameters::getHash(unsigned long &hash) const
196 case iDVBFrontend::feSatellite:
198 hash = sat.frequency & 0xFFFF;
199 hash |= sat.orbital_position << 16;
202 case iDVBFrontend::feCable:
203 case iDVBFrontend::feTerrestrial:
209 DEFINE_REF(eDVBFrontend);
211 eDVBFrontend::eDVBFrontend(int adap, int fe, int &ok): m_type(-1), m_curVoltage(-1)
213 #if HAVE_DVB_API_VERSION < 3
214 char sec_filename[128];
223 #if HAVE_DVB_API_VERSION < 3
224 sprintf(sec_filename, "/dev/dvb/card%d/sec%d", adap, fe);
225 m_secfd = ::open(sec_filename, O_RDWR);
228 eWarning("failed! (%s) %m", sec_filename);
233 eDebug("m_secfd is %d", m_secfd);
235 FrontendInfo fe_info;
236 sprintf(filename, "/dev/dvb/card%d/frontend%d", adap, fe);
238 dvb_frontend_info fe_info;
239 sprintf(filename, "/dev/dvb/adapter%d/frontend%d", adap, fe);
241 eDebug("opening frontend.");
242 m_fd = ::open(filename, O_RDWR|O_NONBLOCK);
245 eWarning("failed! (%s) %m", filename);
250 result = ::ioctl(m_fd, FE_GET_INFO, &fe_info);
253 eWarning("ioctl FE_GET_INFO failed");
260 switch (fe_info.type)
263 m_type = feSatellite;
269 m_type = feTerrestrial;
272 eWarning("unknown frontend type.");
278 eDebug("detected %s frontend", "satellite\0cable\0 terrestrial"+fe_info.type*9);
281 m_sn = new eSocketNotifier(eApp, m_fd, eSocketNotifier::Read);
282 CONNECT(m_sn->activated, eDVBFrontend::feEvent);
285 m_timeout = new eTimer(eApp);
286 CONNECT(m_timeout->timeout, eDVBFrontend::timeout);
288 m_tuneTimer = new eTimer(eApp);
289 CONNECT(m_tuneTimer->timeout, eDVBFrontend::tuneLoop);
291 memset(m_data, 0xFFFF, sizeof(m_data));
296 eDVBFrontend::~eDVBFrontend()
306 void eDVBFrontend::feEvent(int w)
310 #if HAVE_DVB_API_VERSION < 3
313 dvb_frontend_event event;
317 res = ::ioctl(m_fd, FE_GET_EVENT, &event);
319 if (res && (errno == EAGAIN))
324 eWarning("FE_GET_EVENT failed! %m");
331 #if HAVE_DVB_API_VERSION < 3
332 if (event.type == FE_COMPLETION_EV)
334 eDebug("fe event: status %x, inversion %s", event.status, (event.parameters.inversion == INVERSION_ON) ? "on" : "off");
335 if (event.status & FE_HAS_LOCK)
346 if (m_state != state)
349 m_stateChanged(this);
354 void eDVBFrontend::timeout()
357 if (m_state == stateTuning)
360 eDebug("DVBFrontend: timeout");
361 if (m_state != state)
364 m_stateChanged(this);
370 #ifndef FP_IOCTL_GET_ID
371 #define FP_IOCTL_GET_ID 0
373 int eDVBFrontend::readInputpower()
376 // if ( eSystemInfo::getInstance()->canMeasureLNBCurrent() )
378 // switch ( eSystemInfo::getInstance()->getHwType() )
380 // case eSystemInfo::DM7000:
381 // case eSystemInfo::DM7020:
383 // open front prozessor
384 int fp=::open("/dev/dbox/fp0", O_RDWR);
387 eDebug("couldn't open fp");
390 static bool old_fp = (::ioctl(fp, FP_IOCTL_GET_ID) < 0);
391 if ( ioctl( fp, old_fp ? 9 : 0x100, &power ) < 0 )
393 eDebug("FP_IOCTL_GET_LNB_CURRENT failed (%m)");
400 // eDebug("Inputpower read for platform %d not yet implemented", eSystemInfo::getInstance()->getHwType());
406 bool eDVBFrontend::setSecSequencePos(int steps)
408 eDebug("set sequence pos %d", steps);
413 if (m_sec_sequence.current() != m_sec_sequence.end())
414 ++m_sec_sequence.current();
419 if (m_sec_sequence.current() != m_sec_sequence.begin() && m_sec_sequence.current() != m_sec_sequence.end())
420 --m_sec_sequence.current();
426 void eDVBFrontend::tuneLoop() // called by m_tuneTimer
429 if ( m_sec_sequence && m_sec_sequence.current() != m_sec_sequence.end() )
431 switch (m_sec_sequence.current()->cmd)
433 case eSecCommand::SLEEP:
434 delay = m_sec_sequence.current()++->msec;
435 eDebug("[SEC] sleep %dms", delay);
437 case eSecCommand::GOTO:
438 if ( !setSecSequencePos(m_sec_sequence.current()->steps) )
439 ++m_sec_sequence.current();
441 case eSecCommand::SET_VOLTAGE:
442 int voltage = m_sec_sequence.current()++->voltage;
443 eDebug("[SEC] setVoltage %d", voltage);
446 case eSecCommand::SET_TONE:
447 eDebug("[SEC] setTone %d", m_sec_sequence.current()->tone);
448 setTone(m_sec_sequence.current()++->tone);
450 case eSecCommand::SEND_DISEQC:
451 sendDiseqc(m_sec_sequence.current()->diseqc);
452 eDebugNoNewLine("[SEC] sendDiseqc: ");
453 for (int i=0; i < m_sec_sequence.current()->diseqc.len; ++i)
454 eDebugNoNewLine("%02x", m_sec_sequence.current()->diseqc.data[i]);
456 ++m_sec_sequence.current();
458 case eSecCommand::SEND_TONEBURST:
459 eDebug("[SEC] sendToneburst: %d", m_sec_sequence.current()->toneburst);
460 sendToneburst(m_sec_sequence.current()++->toneburst);
462 case eSecCommand::SET_FRONTEND:
463 eDebug("[SEC] setFrontend");
465 ++m_sec_sequence.current();
467 case eSecCommand::MEASURE_IDLE_INPUTPOWER:
469 int idx = m_sec_sequence.current()++->val;
470 if ( idx == 0 || idx == 1 )
472 m_idleInputpower[idx] = readInputpower();
473 eDebug("[SEC] idleInputpower[%d] is %d", idx, m_idleInputpower[idx]);
476 eDebug("[SEC] idleInputpower measure index(%d) out of bound !!!", idx);
479 case eSecCommand::MEASURE_RUNNING_INPUTPOWER:
480 m_runningInputpower = readInputpower();
481 eDebug("[SEC] runningInputpower is %d", m_runningInputpower);
482 ++m_sec_sequence.current();
484 case eSecCommand::SET_TIMEOUT:
485 m_timeoutCount = m_sec_sequence.current()++->val;
486 eDebug("[SEC] set timeout %d", m_timeoutCount);
488 case eSecCommand::UPDATE_CURRENT_ROTORPARAMS:
489 m_data[5] = m_data[3];
490 m_data[6] = m_data[4];
491 eDebug("[SEC] update current rotorparams %d %04x %d", m_timeoutCount, m_data[5], m_data[6]);
492 ++m_sec_sequence.current();
494 case eSecCommand::IF_TIMEOUT_GOTO:
497 eDebug("[SEC] rotor timout");
498 setSecSequencePos(m_sec_sequence.current()->steps);
501 ++m_sec_sequence.current();
503 case eSecCommand::SET_POWER_LIMITING_MODE:
505 int fd=::open("/dev/i2c/0", O_RDWR);
506 unsigned char data[2];
507 ::ioctl(fd, I2C_SLAVE_FORCE, 0x10 >> 1);
508 if(::read(fd, data, 1) != 1)
509 eDebug("[SEC] error read lnbp (%m)");
510 if ( m_sec_sequence.current()->mode == eSecCommand::modeStatic )
512 data[0] |= 0x90; // enable static current limiting
513 eDebug("[SEC] set static current limiting");
517 data[0] &= ~0x90; // enable dynamic current limiting
518 eDebug("[SEC] set dynamic current limiting");
520 if(::write(fd, data, 1) != 1)
521 eDebug("[SEC] error write lnbp (%m)");
523 ++m_sec_sequence.current();
526 case eSecCommand::IF_IDLE_INPUTPOWER_AVAIL_GOTO:
527 if (m_idleInputpower[0] && m_idleInputpower[1] && setSecSequencePos(m_sec_sequence.current()->steps))
529 ++m_sec_sequence.current();
531 case eSecCommand::IF_INPUTPOWER_DELTA_GOTO:
533 int idleInputpower = m_idleInputpower[m_curVoltage == iDVBFrontend::voltage13 ? 0 : 1];
534 eSecCommand::rotor &cmd = m_sec_sequence.current()->measure;
535 const char *txt = cmd.direction ? "running" : "stopped";
536 eDebug("[SEC] waiting for rotor %s %d, idle %d, delta %d",
541 if ( (cmd.direction && abs(m_runningInputpower - idleInputpower) >= cmd.deltaA)
542 || (!cmd.direction && abs(m_runningInputpower - idleInputpower) <= cmd.deltaA) )
545 eDebug("[SEC] rotor %s step %d ok", txt, cmd.okcount);
546 if ( cmd.okcount > 6 )
548 eDebug("[SEC] rotor is %s", txt);
549 if (setSecSequencePos(cmd.steps))
555 eDebug("[SEC] rotor not %s... reset counter.. increase timeout", txt);
559 ++m_sec_sequence.current();
562 case eSecCommand::IF_VOLTAGE_GOTO:
564 eSecCommand::pair &compare = m_sec_sequence.current()->compare;
565 if ( compare.voltage == m_curVoltage && setSecSequencePos(compare.steps) )
567 ++m_sec_sequence.current();
571 ++m_sec_sequence.current();
572 eDebug("[SEC] unhandled sec command");
574 m_tuneTimer->start(delay,true);
578 void eDVBFrontend::setFrontend()
580 eDebug("setting frontend..\n");
581 if (ioctl(m_fd, FE_SET_FRONTEND, &parm) == -1)
583 perror("FE_SET_FRONTEND failed");
587 if (m_state != stateTuning)
590 m_state = stateTuning;
591 m_stateChanged(this);
593 m_timeout->start(5000, 1); // 5 sec timeout. TODO: symbolrate dependent
596 RESULT eDVBFrontend::getFrontendType(int &t)
604 RESULT eDVBFrontend::tune(const iDVBFrontendParameters &where)
611 m_sec_sequence.clear();
613 eDebug("eDVBFrontend::tune. type: %d", m_type);
620 eDVBFrontendParametersSatellite feparm;
621 if (where.getDVBS(feparm))
623 eDebug("no dvbs data!");
628 eWarning("no SEC module active!");
632 res = m_sec->prepare(*this, parm, feparm);
635 #if HAVE_DVB_API_VERSION < 3
636 eDebug("tuning to %d mhz", parm.Frequency/1000);
638 eDebug("tuning to %d mhz", parm.frequency/1000);
644 eDVBFrontendParametersCable feparm;
645 if (where.getDVBC(feparm))
647 eFatal("cable tuning nyi");
651 eDVBFrontendParametersTerrestrial feparm;
652 if (where.getDVBT(feparm))
654 eDebug("no -T data");
657 #if HAVE_DVB_API_VERSION < 3
658 parm.Frequency = feparm.frequency;
660 parm.frequency = feparm.frequency;
663 switch (feparm.bandwidth)
665 case eDVBFrontendParametersTerrestrial::Bandwidth::Bw8MHz:
666 #if HAVE_DVB_API_VERSION < 3
667 parm.u.ofdm.bandWidth =
669 parm.u.ofdm.bandwidth =
673 case eDVBFrontendParametersTerrestrial::Bandwidth::Bw7MHz:
674 #if HAVE_DVB_API_VERSION < 3
675 parm.u.ofdm.bandWidth =
677 parm.u.ofdm.bandwidth =
681 case eDVBFrontendParametersTerrestrial::Bandwidth::Bw6MHz:
682 #if HAVE_DVB_API_VERSION < 3
683 parm.u.ofdm.bandWidth =
685 parm.u.ofdm.bandwidth =
689 case eDVBFrontendParametersTerrestrial::Bandwidth::BwAuto:
690 #if HAVE_DVB_API_VERSION < 3
691 parm.u.ofdm.bandWidth =
693 parm.u.ofdm.bandwidth =
698 eWarning("invalid OFDM bandwith");
702 parm.u.ofdm.code_rate_HP = FEC_AUTO;
703 parm.u.ofdm.code_rate_LP = FEC_AUTO;
705 switch (feparm.modulation)
707 case eDVBFrontendParametersTerrestrial::Modulation::QPSK:
708 parm.u.ofdm.constellation = QPSK;
710 case eDVBFrontendParametersTerrestrial::Modulation::QAM16:
711 parm.u.ofdm.constellation = QAM_16;
713 case eDVBFrontendParametersTerrestrial::Modulation::Auto:
714 parm.u.ofdm.constellation = QAM_AUTO;
718 switch (feparm.transmission_mode)
720 case eDVBFrontendParametersTerrestrial::TransmissionMode::TM2k:
721 #if HAVE_DVB_API_VERSION < 3
722 parm.u.ofdm.TransmissionMode =
724 parm.u.ofdm.transmission_mode =
726 TRANSMISSION_MODE_2K;
728 case eDVBFrontendParametersTerrestrial::TransmissionMode::TM8k:
729 #if HAVE_DVB_API_VERSION < 3
730 parm.u.ofdm.TransmissionMode =
732 parm.u.ofdm.transmission_mode =
734 TRANSMISSION_MODE_8K;
736 case eDVBFrontendParametersTerrestrial::TransmissionMode::TMAuto:
737 #if HAVE_DVB_API_VERSION < 3
738 parm.u.ofdm.TransmissionMode =
740 parm.u.ofdm.transmission_mode =
742 TRANSMISSION_MODE_AUTO;
746 parm.u.ofdm.guard_interval = GUARD_INTERVAL_AUTO;
747 parm.u.ofdm.hierarchy_information = HIERARCHY_AUTO;
748 #if HAVE_DVB_API_VERSION < 3
758 m_sec_sequence.push_back( eSecCommand(eSecCommand::SET_FRONTEND) );
759 m_tuneTimer->start(0,true);
760 m_sec_sequence.current() = m_sec_sequence.begin();
765 RESULT eDVBFrontend::connectStateChange(const Slot1<void,iDVBFrontend*> &stateChange, ePtr<eConnection> &connection)
767 connection = new eConnection(this, m_stateChanged.connect(stateChange));
771 RESULT eDVBFrontend::setVoltage(int voltage)
773 #if HAVE_DVB_API_VERSION < 3
776 fe_sec_voltage_t vlt;
779 m_curVoltage=voltage;
783 vlt = SEC_VOLTAGE_OFF;
786 vlt = SEC_VOLTAGE_13;
789 vlt = SEC_VOLTAGE_18;
794 #if HAVE_DVB_API_VERSION < 3
795 return ::ioctl(m_secfd, SEC_SET_VOLTAGE, vlt);
797 return ::ioctl(m_fd, FE_SET_VOLTAGE, vlt);
801 RESULT eDVBFrontend::getState(int &state)
807 RESULT eDVBFrontend::setTone(int t)
809 #if HAVE_DVB_API_VERSION < 3
812 fe_sec_tone_mode_t tone;
826 #if HAVE_DVB_API_VERSION < 3
827 return ::ioctl(m_secfd, SEC_SET_TONE, tone);
829 return ::ioctl(m_fd, FE_SET_TONE, tone);
833 #if HAVE_DVB_API_VERSION < 3 && !defined(SEC_DISEQC_SEND_MASTER_CMD)
834 #define SEC_DISEQC_SEND_MASTER_CMD _IOW('o', 97, struct secCommand *)
837 RESULT eDVBFrontend::sendDiseqc(const eDVBDiseqcCommand &diseqc)
839 #if HAVE_DVB_API_VERSION < 3
840 struct secCommand cmd;
841 cmd.type = SEC_CMDTYPE_DISEQC_RAW;
842 cmd.u.diseqc.cmdtype = diseqc.data[0];
843 cmd.u.diseqc.addr = diseqc.data[1];
844 cmd.u.diseqc.cmd = diseqc.data[2];
845 cmd.u.diseqc.numParams = diseqc.len-3;
846 memcpy(cmd.u.diseqc.params, diseqc.data+3, diseqc.len-3);
847 if (::ioctl(m_secfd, SEC_DISEQC_SEND_MASTER_CMD, &cmd))
849 struct dvb_diseqc_master_cmd cmd;
850 memcpy(cmd.msg, diseqc.data, diseqc.len);
851 cmd.msg_len = diseqc.len;
852 if (::ioctl(m_fd, FE_DISEQC_SEND_MASTER_CMD, &cmd))
858 #if HAVE_DVB_API_VERSION < 3 && !defined(SEC_DISEQC_SEND_BURST)
859 #define SEC_DISEQC_SEND_BURST _IO('o', 96)
861 RESULT eDVBFrontend::sendToneburst(int burst)
863 #if HAVE_DVB_API_VERSION < 3
864 secMiniCmd cmd = SEC_MINI_NONE;
865 if ( burst == eDVBSatelliteDiseqcParameters::A )
867 else if ( burst == eDVBSatelliteDiseqcParameters::B )
869 if (::ioctl(m_secfd, SEC_DISEQC_SEND_BURST, cmd))
875 RESULT eDVBFrontend::setSEC(iDVBSatelliteEquipmentControl *sec)
881 RESULT eDVBFrontend::setSecSequence(const eSecCommandList &list)
883 m_sec_sequence = list;
887 RESULT eDVBFrontend::getData(int num, int &data)
897 RESULT eDVBFrontend::setData(int num, int val)