Merge branch 'bug_461_play_another_timeshift_file_after_eof' into experimental

[enigma2.git] / lib / dvb / dvbtime.cpp

diff --git a/lib/dvb/dvbtime.cpp b/lib/dvb/dvbtime.cpp
index 9272462a23e12cd608578b95f0d99205cd5b666a..bb6b94b0d9e7207a9a77ed4ddaedf855dd59f1d8 100644 (file)
--- a/lib/dvb/dvbtime.cpp
+++ b/lib/dvb/dvbtime.cpp
@@ -11,35 +11,63 @@
 #define FP_IOCTL_SET_RTC         0x101
 #define FP_IOCTL_GET_RTC         0x102
 
 #define FP_IOCTL_SET_RTC         0x101
 #define FP_IOCTL_GET_RTC         0x102
 

+#define TIME_UPDATE_INTERVAL (30*60*1000)
+

 static time_t prev_time;
 
 void setRTC(time_t time)
 {
 static time_t prev_time;
 
 void setRTC(time_t time)
 {

-       int fd = open("/dev/dbox/fp0", O_RDWR);
-       if ( fd >= 0 )
+       FILE *f = fopen("/proc/stb/fp/rtc", "w");
+       if (f)

        {
        {

-               if ( ::ioctl(fd, FP_IOCTL_SET_RTC, (void*)&time ) < 0 )
-                       eDebug("FP_IOCTL_SET_RTC failed(%m)");
-               else
+               if (fprintf(f, "%u", (unsigned int)time))

                        prev_time = time;
                        prev_time = time;

-               close(fd);
+               else
+                       eDebug("write /proc/stb/fp/rtc failed (%m)");
+               fclose(f);
+       }
+       else
+       {
+               int fd = open("/dev/dbox/fp0", O_RDWR);
+               if ( fd >= 0 )
+               {
+                       if ( ::ioctl(fd, FP_IOCTL_SET_RTC, (void*)&time ) < 0 )
+                               eDebug("FP_IOCTL_SET_RTC failed(%m)");
+                       else
+                               prev_time = time;
+                       close(fd);
+               }

        }
 }
 
 time_t getRTC()
 {
        time_t rtc_time=0;
        }
 }
 
 time_t getRTC()
 {
        time_t rtc_time=0;

-       int fd = open("/dev/dbox/fp0", O_RDWR);
-       if ( fd >= 0 )
+       FILE *f = fopen("/proc/stb/fp/rtc", "r");
+       if (f)

        {
        {

-               if ( ::ioctl(fd, FP_IOCTL_GET_RTC, (void*)&rtc_time ) < 0 )
-                       eDebug("FP_IOCTL_GET_RTC failed(%m)");
-               close(fd);
+               // sanity check to detect corrupt atmel firmware
+               unsigned int tmp;
+               if (fscanf(f, "%u", &tmp) != 1)
+                       eDebug("read /proc/stb/fp/rtc failed (%m)");
+               else
+                       rtc_time=tmp;
+               fclose(f);
+       }
+       else
+       {
+               int fd = open("/dev/dbox/fp0", O_RDWR);
+               if ( fd >= 0 )
+               {
+                       if ( ::ioctl(fd, FP_IOCTL_GET_RTC, (void*)&rtc_time ) < 0 )
+                               eDebug("FP_IOCTL_GET_RTC failed(%m)");
+                       close(fd);
+               }

        }
        return rtc_time != prev_time ? rtc_time : 0;
 }
 
        }
        return rtc_time != prev_time ? rtc_time : 0;
 }
 

-time_t parseDVBtime(__u8 t1, __u8 t2, __u8 t3, __u8 t4, __u8 t5)
+time_t parseDVBtime(__u8 t1, __u8 t2, __u8 t3, __u8 t4, __u8 t5, __u16 *hash)

 {
        tm t;
        t.tm_sec=fromBCD(t5);
 {
        tm t;
        t.tm_sec=fromBCD(t5);


@@ -59,14 +87,19 @@ time_t parseDVBtime(__u8 t1, __u8 t2, __u8 t3, __u8 t4, __u8 t5)
        t.tm_isdst =  0;
        t.tm_gmtoff = 0;
 
        t.tm_isdst =  0;
        t.tm_gmtoff = 0;
 

+       if (hash) {
+               *hash = t.tm_hour * 60 + t.tm_min;
+               *hash |= t.tm_mday << 11;
+       }
+

        return timegm(&t);
 }
 
 TDT::TDT(eDVBChannel *chan, int update_count)
        return timegm(&t);
 }
 
 TDT::TDT(eDVBChannel *chan, int update_count)

-       :chan(chan), update_count(update_count)
+       :chan(chan), m_interval_timer(eTimer::create()), update_count(update_count)

 {
        CONNECT(tableReady, TDT::ready);
 {
        CONNECT(tableReady, TDT::ready);

-       CONNECT(m_interval_timer.timeout, TDT::start);
+       CONNECT(m_interval_timer->timeout, TDT::start);

        if (chan)
                chan->getDemux(demux, 0);
 }
        if (chan)
                chan->getDemux(demux, 0);
 }


@@ -113,14 +146,14 @@ void TDT::start()
 
 void TDT::startTimer( int interval )
 {
 
 void TDT::startTimer( int interval )
 {

-       m_interval_timer.start(interval, true);
+       m_interval_timer->start(interval, true);

 }
 
 eDVBLocalTimeHandler *eDVBLocalTimeHandler::instance;
 DEFINE_REF(eDVBLocalTimeHandler);
 
 eDVBLocalTimeHandler::eDVBLocalTimeHandler()
 }
 
 eDVBLocalTimeHandler *eDVBLocalTimeHandler::instance;
 DEFINE_REF(eDVBLocalTimeHandler);
 
 eDVBLocalTimeHandler::eDVBLocalTimeHandler()

-       :m_time_ready(false), m_time_difference(0)
+       :m_use_dvb_time(false), m_updateNonTunedTimer(eTimer::create(eApp)), m_time_ready(false)

 {
        if ( !instance )
                instance=this;
 {
        if ( !instance )
                instance=this;


@@ -141,17 +174,16 @@ eDVBLocalTimeHandler::eDVBLocalTimeHandler()
                        /*emit*/ m_timeUpdated();
                }
        }
                        /*emit*/ m_timeUpdated();
                }
        }

+       CONNECT(m_updateNonTunedTimer->timeout, eDVBLocalTimeHandler::updateNonTuned);

 }
 
 eDVBLocalTimeHandler::~eDVBLocalTimeHandler()
 {
        instance=0;
 }
 
 eDVBLocalTimeHandler::~eDVBLocalTimeHandler()
 {
        instance=0;

-       for (std::map<iDVBChannel*, channel_data>::iterator it=m_knownChannels.begin(); it != m_knownChannels.end(); ++it)
-               delete it->second.tdt;

        if (ready())
        {
                eDebug("set RTC to previous valid time");
        if (ready())
        {
                eDebug("set RTC to previous valid time");

-               setRTC(nowTime());
+               setRTC(::time(0));

        }
 }
 
        }
 }
 


@@ -190,8 +222,42 @@ void eDVBLocalTimeHandler::writeTimeOffsetData( const char* filename )
        }
 }
 
        }
 }
 

+void eDVBLocalTimeHandler::setUseDVBTime(bool b)
+{
+       if (m_use_dvb_time != b) {
+               if (m_use_dvb_time) {
+                       eDebug("[eDVBLocalTimeHandler] disable sync local time with transponder time!");
+                       std::map<iDVBChannel*, channel_data>::iterator it =
+                               m_knownChannels.begin();
+                       for (; it != m_knownChannels.end(); ++it) {
+                               if (it->second.m_prevChannelState == iDVBChannel::state_ok)
+                                       it->second.tdt = 0;
+                       }
+               }
+               else {
+                       eDebug("[eDVBLocalTimeHandler] enable sync local time with transponder time!");
+                       std::map<iDVBChannel*, channel_data>::iterator it =
+                               m_knownChannels.begin();
+                       for (; it != m_knownChannels.end(); ++it) {
+                               if (it->second.m_prevChannelState == iDVBChannel::state_ok) {
+                                       it->second.tdt = new TDT(it->second.channel);
+                                       it->second.tdt->start();
+                               }
+                       }
+               }
+               m_use_dvb_time = b;
+       }
+}
+
+void eDVBLocalTimeHandler::updateNonTuned()
+{
+       updateTime(-1, 0, 0);
+       m_updateNonTunedTimer->start(TIME_UPDATE_INTERVAL, true);
+}
+

 void eDVBLocalTimeHandler::updateTime( time_t tp_time, eDVBChannel *chan, int update_count )
 {
 void eDVBLocalTimeHandler::updateTime( time_t tp_time, eDVBChannel *chan, int update_count )
 {

+       int time_difference;

        bool restart_tdt = false;
        if (!tp_time)
                restart_tdt = true;
        bool restart_tdt = false;
        if (!tp_time)
                restart_tdt = true;


@@ -213,24 +279,22 @@ void eDVBLocalTimeHandler::updateTime( time_t tp_time, eDVBChannel *chan, int up
                                        now.tm_min,
                                        now.tm_sec);
                                time_t linuxTime=time(0);
                                        now.tm_min,
                                        now.tm_sec);
                                time_t linuxTime=time(0);

-                               time_t nowTime=linuxTime+m_time_difference;
-                               localtime_r(&nowTime, &now);
+                               localtime_r(&linuxTime, &now);

                                eDebug("[eDVBLocalTimerHandler] Receiver time is %02d:%02d:%02d",
                                        now.tm_hour,
                                        now.tm_min,
                                        now.tm_sec);
                                eDebug("[eDVBLocalTimerHandler] Receiver time is %02d:%02d:%02d",
                                        now.tm_hour,
                                        now.tm_min,
                                        now.tm_sec);

-                               m_time_difference = rtc_time - linuxTime;
-                               eDebug("[eDVBLocalTimerHandler] RTC to Receiver time difference is %ld seconds", nowTime - rtc_time );
-                               if ( m_time_difference )
+                               time_difference = rtc_time - linuxTime;
+                               eDebug("[eDVBLocalTimerHandler] RTC to Receiver time difference is %ld seconds", linuxTime - rtc_time );
+                               if ( time_difference )

                                {
                                        eDebug("[eDVBLocalTimerHandler] set Linux Time to RTC Time");
                                        timeval tnow;
                                        gettimeofday(&tnow,0);
                                        tnow.tv_sec=rtc_time;
                                        settimeofday(&tnow,0);
                                {
                                        eDebug("[eDVBLocalTimerHandler] set Linux Time to RTC Time");
                                        timeval tnow;
                                        gettimeofday(&tnow,0);
                                        tnow.tv_sec=rtc_time;
                                        settimeofday(&tnow,0);

-                                       m_time_difference=0;

                                }
                                }

-                               else if ( !m_time_difference )
+                               else if ( !time_difference )

                                        eDebug("[eDVBLocalTimerHandler] no change needed");
                                else
                                        eDebug("[eDVBLocalTimerHandler] set to RTC time");
                                        eDebug("[eDVBLocalTimerHandler] no change needed");
                                else
                                        eDebug("[eDVBLocalTimerHandler] set to RTC time");


@@ -247,11 +311,8 @@ void eDVBLocalTimeHandler::updateTime( time_t tp_time, eDVBChannel *chan, int up
  // current linux time
                time_t linuxTime = time(0);
 
  // current linux time
                time_t linuxTime = time(0);
 

- // current enigma time
-               time_t nowTime=linuxTime+m_time_difference;
-

        // difference between current enigma time and transponder time
        // difference between current enigma time and transponder time

-               int enigma_diff = tp_time-nowTime;
+               int enigma_diff = tp_time-linuxTime;

 
                int new_diff=0;
 
 
                int new_diff=0;
 


@@ -272,19 +333,18 @@ void eDVBLocalTimeHandler::updateTime( time_t tp_time, eDVBChannel *chan, int up
                        {
                                eDebug("[eDVBLocalTimerHandler] we have correction %d", it->second);
                                time_t CorrectedTpTime = tp_time+it->second;
                        {
                                eDebug("[eDVBLocalTimerHandler] we have correction %d", it->second);
                                time_t CorrectedTpTime = tp_time+it->second;

-                               int ddiff = CorrectedTpTime-nowTime;
+                               int ddiff = CorrectedTpTime-linuxTime;

                                eDebug("[eDVBLocalTimerHandler] diff after add correction is %d", ddiff);
                                if ( abs(it->second) < 300 ) // stored correction < 5 min
                                {
                                        eDebug("[eDVBLocalTimerHandler] use stored correction(<5 min)");
                                        new_diff = ddiff;
                                }
                                eDebug("[eDVBLocalTimerHandler] diff after add correction is %d", ddiff);
                                if ( abs(it->second) < 300 ) // stored correction < 5 min
                                {
                                        eDebug("[eDVBLocalTimerHandler] use stored correction(<5 min)");
                                        new_diff = ddiff;
                                }

-                               else if ( /*eSystemInfo::getInstance()->getHwType() == eSystemInfo::DM7020 &&  TODO !!!*/
-                                               getRTC() )
+                               else if ( getRTC() )

                                {
                                        time_t rtc=getRTC();
                                        m_timeOffsetMap[chan->getChannelID()] = rtc-tp_time;
                                {
                                        time_t rtc=getRTC();
                                        m_timeOffsetMap[chan->getChannelID()] = rtc-tp_time;

-                                       new_diff = rtc-nowTime;  // set enigma time to rtc
+                                       new_diff = rtc-linuxTime;  // set enigma time to rtc

                                        eDebug("[eDVBLocalTimerHandler] update stored correction to %ld (calced against RTC time)", rtc-tp_time );
                                }
                                else if ( abs(ddiff) <= 120 )
                                        eDebug("[eDVBLocalTimerHandler] update stored correction to %ld (calced against RTC time)", rtc-tp_time );
                                }
                                else if ( abs(ddiff) <= 120 )


@@ -320,7 +380,7 @@ void eDVBLocalTimeHandler::updateTime( time_t tp_time, eDVBChannel *chan, int up
                        m_time_ready=true;
                }
 
                        m_time_ready=true;
                }
 

-               time_t t = nowTime+new_diff;
+               time_t t = linuxTime+new_diff;

                m_last_tp_time_difference=tp_time-t;
 
                if (!new_diff &&
                m_last_tp_time_difference=tp_time-t;
 
                if (!new_diff &&


@@ -330,17 +390,6 @@ void eDVBLocalTimeHandler::updateTime( time_t tp_time, eDVBChannel *chan, int up
                        return;
                }
 
                        return;
                }
 

-               tm now;
-               localtime_r(&t, &now);
-               eDebug("[eDVBLocalTimerHandler] time update to %02d:%02d:%02d",
-                       now.tm_hour,
-                       now.tm_min,
-                       now.tm_sec);
-
-               m_time_difference = t - linuxTime;   // calc our new linux_time -> enigma_time correction
-               eDebug("[eDVBLocalTimerHandler] m_time_difference is %d", m_time_difference );
-
-//             if ( eSystemInfo::getInstance()->getHwType() == eSystemInfo::DM7020 )  TODO !!

                if ( !update_count )
                {
                        // set rtc to calced transponder time when the first tdt is received on this
                if ( !update_count )
                {
                        // set rtc to calced transponder time when the first tdt is received on this


@@ -348,17 +397,36 @@ void eDVBLocalTimeHandler::updateTime( time_t tp_time, eDVBChannel *chan, int up
                        setRTC(t);
                        eDebug("[eDVBLocalTimerHandler] update RTC");
                }
                        setRTC(t);
                        eDebug("[eDVBLocalTimerHandler] update RTC");
                }

+               else if (getRTC())
+               {
+                       if (abs(getRTC() - t) > 60)
+                       {
+                               eDebug("[eDVBLocalTimerHandler] difference between new linux time and RTC time is > 60 sec... transponder time looks not ok... use rtc time");
+                               t = getRTC();
+                       }
+                       else
+                               eDebug("[eDVBLocalTimerHandler] difference between linux time and RTC time is < 60 sec... so the transponder time looks ok");
+               }

                else
                else

-                       eDebug("[eDVBLocalTimerHandler] don't update RTC");
+                       eDebug("[eDVBLocalTimerHandler] no RTC available :(");
+
+               tm now;
+               localtime_r(&t, &now);
+               eDebug("[eDVBLocalTimerHandler] time update to %02d:%02d:%02d",
+                       now.tm_hour,
+                       now.tm_min,
+                       now.tm_sec);

 
 

-               if ( m_time_difference )
+               time_difference = t - linuxTime;   // calc our new linux_time -> enigma_time correction
+               eDebug("[eDVBLocalTimerHandler] m_time_difference is %d", time_difference );
+
+               if ( time_difference )

                {
                        eDebug("[eDVBLocalTimerHandler] set Linux Time");
                        timeval tnow;
                        gettimeofday(&tnow,0);
                        tnow.tv_sec=t;
                        settimeofday(&tnow,0);
                {
                        eDebug("[eDVBLocalTimerHandler] set Linux Time");
                        timeval tnow;
                        gettimeofday(&tnow,0);
                        tnow.tv_sec=t;
                        settimeofday(&tnow,0);

-                       m_time_difference=0;

                }
 
                 /*emit*/ m_timeUpdated();
                }
 
                 /*emit*/ m_timeUpdated();


@@ -370,10 +438,10 @@ void eDVBLocalTimeHandler::updateTime( time_t tp_time, eDVBChannel *chan, int up
                        m_knownChannels.find(chan);
                if ( it != m_knownChannels.end() )
                {
                        m_knownChannels.find(chan);
                if ( it != m_knownChannels.end() )
                {

-                       TDT *prev_tdt = it->second.tdt;
-                       it->second.tdt = new TDT(chan, prev_tdt->getUpdateCount());
-                       it->second.tdt->startTimer(60*60*1000);  // restart TDT for this transponder in 60min
-                       delete prev_tdt;
+                       int updateCount = it->second.tdt->getUpdateCount();
+                       it->second.tdt = 0;
+                       it->second.tdt = new TDT(chan, updateCount);
+                       it->second.tdt->startTimer(TIME_UPDATE_INTERVAL);  // restart TDT for this transponder in 30min

                }
        }
 }
                }
        }
 }


@@ -406,13 +474,17 @@ void eDVBLocalTimeHandler::DVBChannelStateChanged(iDVBChannel *chan)
                        {
                                case iDVBChannel::state_ok:
                                        eDebug("[eDVBLocalTimerHandler] channel %p running", chan);
                        {
                                case iDVBChannel::state_ok:
                                        eDebug("[eDVBLocalTimerHandler] channel %p running", chan);

-                                       it->second.tdt = new TDT(it->second.channel);
-                                       it->second.tdt->start();
+                                       m_updateNonTunedTimer->stop();
+                                       if (m_use_dvb_time) {
+                                               it->second.tdt = new TDT(it->second.channel);
+                                               it->second.tdt->start();
+                                       }

                                        break;
                                case iDVBChannel::state_release:
                                        eDebug("[eDVBLocalTimerHandler] remove channel %p", chan);
                                        break;
                                case iDVBChannel::state_release:
                                        eDebug("[eDVBLocalTimerHandler] remove channel %p", chan);

-                                       delete it->second.tdt;

                                        m_knownChannels.erase(it);
                                        m_knownChannels.erase(it);

+                                       if (m_knownChannels.empty())
+                                               m_updateNonTunedTimer->start(TIME_UPDATE_INTERVAL, true);

                                        break;
                                default: // ignore all other events
                                        return;
                                        break;
                                default: // ignore all other events
                                        return;