Merge commit 'origin/bug_449_fix_wlan_usbstick_recognition'
[enigma2.git] / lib / dvb / dvbtime.cpp
1 #include <lib/dvb/dvbtime.h>
2 #include <lib/dvb/dvb.h>
3
4 #include <sys/ioctl.h>
5 #include <stdio.h>
6 #include <sys/types.h>
7 #include <sys/stat.h>
8 #include <fcntl.h>
9
10 // defines for DM7000 / DM7020
11 #define FP_IOCTL_SET_RTC         0x101
12 #define FP_IOCTL_GET_RTC         0x102
13
14 #define TIME_UPDATE_INTERVAL (30*60*1000)
15
16 static time_t prev_time;
17
18 void setRTC(time_t time)
19 {
20         FILE *f = fopen("/proc/stb/fp/rtc", "w");
21         if (f)
22         {
23                 if (fprintf(f, "%u", (unsigned int)time))
24                         prev_time = time;
25                 else
26                         eDebug("write /proc/stb/fp/rtc failed (%m)");
27                 fclose(f);
28         }
29         else
30         {
31                 int fd = open("/dev/dbox/fp0", O_RDWR);
32                 if ( fd >= 0 )
33                 {
34                         if ( ::ioctl(fd, FP_IOCTL_SET_RTC, (void*)&time ) < 0 )
35                                 eDebug("FP_IOCTL_SET_RTC failed(%m)");
36                         else
37                                 prev_time = time;
38                         close(fd);
39                 }
40         }
41 }
42
43 time_t getRTC()
44 {
45         time_t rtc_time=0;
46         FILE *f = fopen("/proc/stb/fp/rtc", "r");
47         if (f)
48         {
49                 // sanity check to detect corrupt atmel firmware
50                 unsigned int tmp;
51                 if (fscanf(f, "%u", &tmp) != 1)
52                         eDebug("read /proc/stb/fp/rtc failed (%m)");
53                 else
54                         rtc_time=tmp;
55                 fclose(f);
56         }
57         else
58         {
59                 int fd = open("/dev/dbox/fp0", O_RDWR);
60                 if ( fd >= 0 )
61                 {
62                         if ( ::ioctl(fd, FP_IOCTL_GET_RTC, (void*)&rtc_time ) < 0 )
63                                 eDebug("FP_IOCTL_GET_RTC failed(%m)");
64                         close(fd);
65                 }
66         }
67         return rtc_time != prev_time ? rtc_time : 0;
68 }
69
70 time_t parseDVBtime(__u8 t1, __u8 t2, __u8 t3, __u8 t4, __u8 t5, __u16 *hash)
71 {
72         tm t;
73         t.tm_sec=fromBCD(t5);
74         t.tm_min=fromBCD(t4);
75         t.tm_hour=fromBCD(t3);
76         int mjd=(t1<<8)|t2;
77         int k;
78
79         t.tm_year = (int) ((mjd - 15078.2) / 365.25);
80         t.tm_mon = (int) ((mjd - 14956.1 - (int)(t.tm_year * 365.25)) / 30.6001);
81         t.tm_mday = (int) (mjd - 14956 - (int)(t.tm_year * 365.25) - (int)(t.tm_mon * 30.6001));
82         k = (t.tm_mon == 14 || t.tm_mon == 15) ? 1 : 0;
83         t.tm_year = t.tm_year + k;
84         t.tm_mon = t.tm_mon - 1 - k * 12;
85         t.tm_mon--;
86
87         t.tm_isdst =  0;
88         t.tm_gmtoff = 0;
89
90         if (hash) {
91                 *hash = t.tm_hour * 60 + t.tm_min;
92                 *hash |= t.tm_mday << 11;
93         }
94
95         return timegm(&t);
96 }
97
98 TDT::TDT(eDVBChannel *chan, int update_count)
99         :chan(chan), m_interval_timer(eTimer::create()), update_count(update_count)
100 {
101         CONNECT(tableReady, TDT::ready);
102         CONNECT(m_interval_timer->timeout, TDT::start);
103         if (chan)
104                 chan->getDemux(demux, 0);
105 }
106
107 void TDT::ready(int error)
108 {
109         eDVBLocalTimeHandler::getInstance()->updateTime(error, chan, ++update_count);
110 }
111
112 int TDT::createTable(unsigned int nr, const __u8 *data, unsigned int max)
113 {
114         if ( data && data[0] == 0x70 || data[0] == 0x73 )
115         {
116                 int length = ((data[1] & 0x0F) << 8) | data[2];
117                 if ( length >= 5 )
118                 {
119                         time_t tptime = parseDVBtime(data[3], data[4], data[5], data[6], data[7]);
120                         if (tptime && tptime != -1)
121                                 eDVBLocalTimeHandler::getInstance()->updateTime(tptime, chan, update_count);
122                         error=0;
123                         return 1;
124                 }
125         }
126         return 0;
127 }
128
129 void TDT::start()
130 {
131         if ( chan )
132         {
133                 eDVBTableSpec spec;
134                 spec.pid = TimeAndDateSection::PID;
135                 spec.tid = TimeAndDateSection::TID;
136                 spec.tid_mask = 0xFC;
137                 spec.timeout = TimeAndDateSection::TIMEOUT;
138                 spec.flags= eDVBTableSpec::tfAnyVersion |
139                                         eDVBTableSpec::tfHaveTID |
140                                         eDVBTableSpec::tfHaveTIDMask |
141                                         eDVBTableSpec::tfHaveTimeout;
142                 if ( demux )
143                         eGTable::start( demux, spec );
144         }
145 }
146
147 void TDT::startTimer( int interval )
148 {
149         m_interval_timer->start(interval, true);
150 }
151
152 eDVBLocalTimeHandler *eDVBLocalTimeHandler::instance;
153 DEFINE_REF(eDVBLocalTimeHandler);
154
155 eDVBLocalTimeHandler::eDVBLocalTimeHandler()
156         :m_use_dvb_time(false), m_updateNonTunedTimer(eTimer::create(eApp)), m_time_ready(false)
157 {
158         if ( !instance )
159                 instance=this;
160         ePtr<eDVBResourceManager> res_mgr;
161         eDVBResourceManager::getInstance(res_mgr);
162         if (!res_mgr)
163                 eDebug("[eDVBLocalTimerHandler] no resource manager !!!!!!!");
164         else
165         {
166                 res_mgr->connectChannelAdded(slot(*this,&eDVBLocalTimeHandler::DVBChannelAdded), m_chanAddedConn);
167                 time_t now = time(0);
168                 if ( now < 1072224000 ) // 01.01.2004
169                         eDebug("RTC not ready... wait for transponder time");
170                 else // inform all who's waiting for valid system time..
171                 {
172                         eDebug("Use valid Linux Time :) (RTC?)");
173                         m_time_ready = true;
174                         /*emit*/ m_timeUpdated();
175                 }
176         }
177         CONNECT(m_updateNonTunedTimer->timeout, eDVBLocalTimeHandler::updateNonTuned);
178 }
179
180 eDVBLocalTimeHandler::~eDVBLocalTimeHandler()
181 {
182         instance=0;
183         if (ready())
184         {
185                 eDebug("set RTC to previous valid time");
186                 setRTC(::time(0));
187         }
188 }
189
190 void eDVBLocalTimeHandler::readTimeOffsetData( const char* filename )
191 {
192         m_timeOffsetMap.clear();
193         FILE *f=fopen(filename, "r");
194         if (!f)
195                 return;
196         char line[256];
197         fgets(line, 256, f);
198         while (true)
199         {
200                 if (!fgets( line, 256, f ))
201                         break;
202                 if (strstr(line, "Transponder UTC Time Offsets\n"))
203                         continue;
204                 int dvbnamespace,tsid,onid,offs;
205                 if ( sscanf( line, "%08x,%04x,%04x:%d\n",&dvbnamespace,&tsid,&onid,&offs ) == 4 )
206                         m_timeOffsetMap[eDVBChannelID(dvbnamespace,tsid,onid)]=offs;
207         }
208         fclose(f);
209 }
210
211 void eDVBLocalTimeHandler::writeTimeOffsetData( const char* filename )
212 {
213         FILE *f=fopen(filename, "w+");
214         if ( f )
215         {
216                 fprintf(f, "Transponder UTC Time Offsets\n");
217                 for ( std::map<eDVBChannelID,int>::iterator it ( m_timeOffsetMap.begin() ); it != m_timeOffsetMap.end(); ++it )
218                         fprintf(f, "%08x,%04x,%04x:%d\n",
219                                 it->first.dvbnamespace.get(),
220                                 it->first.transport_stream_id.get(), it->first.original_network_id.get(), it->second );
221                 fclose(f);
222         }
223 }
224
225 void eDVBLocalTimeHandler::setUseDVBTime(bool b)
226 {
227         if (m_use_dvb_time != b) {
228                 if (m_use_dvb_time) {
229                         eDebug("[eDVBLocalTimeHandler] disable sync local time with transponder time!");
230                         std::map<iDVBChannel*, channel_data>::iterator it =
231                                 m_knownChannels.begin();
232                         for (; it != m_knownChannels.end(); ++it) {
233                                 if (it->second.m_prevChannelState == iDVBChannel::state_ok)
234                                         it->second.tdt = 0;
235                         }
236                 }
237                 else {
238                         eDebug("[eDVBLocalTimeHandler] enable sync local time with transponder time!");
239                         std::map<iDVBChannel*, channel_data>::iterator it =
240                                 m_knownChannels.begin();
241                         for (; it != m_knownChannels.end(); ++it) {
242                                 if (it->second.m_prevChannelState == iDVBChannel::state_ok) {
243                                         it->second.tdt = new TDT(it->second.channel);
244                                         it->second.tdt->start();
245                                 }
246                         }
247                 }
248                 m_use_dvb_time = b;
249         }
250 }
251
252 void eDVBLocalTimeHandler::updateNonTuned()
253 {
254         updateTime(-1, 0, 0);
255         m_updateNonTunedTimer->start(TIME_UPDATE_INTERVAL, true);
256 }
257
258 void eDVBLocalTimeHandler::updateTime( time_t tp_time, eDVBChannel *chan, int update_count )
259 {
260         int time_difference;
261         bool restart_tdt = false;
262         if (!tp_time)
263                 restart_tdt = true;
264         else if (tp_time == -1)
265         {
266                 restart_tdt = true;
267                 /*if ( eSystemInfo::getInstance()->getHwType() == eSystemInfo::DM7020 ||
268                 ( eSystemInfo::getInstance()->getHwType() == eSystemInfo::DM7000
269                         && eSystemInfo::getInstance()->hasStandbyWakeupTimer() ) )     TODO !!!!!!! */
270                 {
271                         eDebug("[eDVBLocalTimerHandler] no transponder tuned... or no TDT/TOT avail .. try to use RTC :)");
272                         time_t rtc_time = getRTC();
273                         if ( rtc_time ) // RTC Ready?
274                         {
275                                 tm now;
276                                 localtime_r(&rtc_time, &now);
277                                 eDebug("[eDVBLocalTimerHandler] RTC time is %02d:%02d:%02d",
278                                         now.tm_hour,
279                                         now.tm_min,
280                                         now.tm_sec);
281                                 time_t linuxTime=time(0);
282                                 localtime_r(&linuxTime, &now);
283                                 eDebug("[eDVBLocalTimerHandler] Receiver time is %02d:%02d:%02d",
284                                         now.tm_hour,
285                                         now.tm_min,
286                                         now.tm_sec);
287                                 time_difference = rtc_time - linuxTime;
288                                 eDebug("[eDVBLocalTimerHandler] RTC to Receiver time difference is %ld seconds", linuxTime - rtc_time );
289                                 if ( time_difference )
290                                 {
291                                         eDebug("[eDVBLocalTimerHandler] set Linux Time to RTC Time");
292                                         timeval tnow;
293                                         gettimeofday(&tnow,0);
294                                         tnow.tv_sec=rtc_time;
295                                         settimeofday(&tnow,0);
296                                 }
297                                 else if ( !time_difference )
298                                         eDebug("[eDVBLocalTimerHandler] no change needed");
299                                 else
300                                         eDebug("[eDVBLocalTimerHandler] set to RTC time");
301                                 /*emit*/ m_timeUpdated();
302                         }
303                         else
304                                 eDebug("[eDVBLocalTimerHandler] shit RTC not ready :(");
305                 }
306         }
307         else
308         {
309                 std::map< eDVBChannelID, int >::iterator it( m_timeOffsetMap.find( chan->getChannelID() ) );
310
311  // current linux time
312                 time_t linuxTime = time(0);
313
314         // difference between current enigma time and transponder time
315                 int enigma_diff = tp_time-linuxTime;
316
317                 int new_diff=0;
318
319                 bool updated = m_time_ready;
320
321                 if ( m_time_ready )  // ref time ready?
322                 {
323                         // difference between reference time (current enigma time)
324                         // and the transponder time
325                         eDebug("[eDVBLocalTimerHandler] diff is %d", enigma_diff);
326                         if ( abs(enigma_diff) < 120 )
327                         {
328                                 eDebug("[eDVBLocalTimerHandler] diff < 120 .. use Transponder Time");
329                                 m_timeOffsetMap[chan->getChannelID()] = 0;
330                                 new_diff = enigma_diff;
331                         }
332                         else if ( it != m_timeOffsetMap.end() ) // correction saved?
333                         {
334                                 eDebug("[eDVBLocalTimerHandler] we have correction %d", it->second);
335                                 time_t CorrectedTpTime = tp_time+it->second;
336                                 int ddiff = CorrectedTpTime-linuxTime;
337                                 eDebug("[eDVBLocalTimerHandler] diff after add correction is %d", ddiff);
338                                 if ( abs(it->second) < 300 ) // stored correction < 5 min
339                                 {
340                                         eDebug("[eDVBLocalTimerHandler] use stored correction(<5 min)");
341                                         new_diff = ddiff;
342                                 }
343                                 else if ( getRTC() )
344                                 {
345                                         time_t rtc=getRTC();
346                                         m_timeOffsetMap[chan->getChannelID()] = rtc-tp_time;
347                                         new_diff = rtc-linuxTime;  // set enigma time to rtc
348                                         eDebug("[eDVBLocalTimerHandler] update stored correction to %ld (calced against RTC time)", rtc-tp_time );
349                                 }
350                                 else if ( abs(ddiff) <= 120 )
351                                 {
352 // with stored correction calced time difference is lower 2 min
353 // this don't help when a transponder have a clock running to slow or to fast
354 // then its better to have a DM7020 with always running RTC
355                                         eDebug("[eDVBLocalTimerHandler] use stored correction(corr < 2 min)");
356                                         new_diff = ddiff;
357                                 }
358                                 else  // big change in calced correction.. hold current time and update correction
359                                 {
360                                         eDebug("[eDVBLocalTimerHandler] update stored correction to %d", -enigma_diff);
361                                         m_timeOffsetMap[chan->getChannelID()] = -enigma_diff;
362                                 }
363                         }
364                         else
365                         {
366                                 eDebug("[eDVBLocalTimerHandler] no correction found... store calced correction(%d)",-enigma_diff);
367                                 m_timeOffsetMap[chan->getChannelID()] = -enigma_diff;
368                         }
369                 }
370                 else  // no time setted yet
371                 {
372                         if ( it != m_timeOffsetMap.end() )
373                         {
374                                 enigma_diff += it->second;
375                                 eDebug("[eDVBLocalTimerHandler] we have correction (%d)... use", it->second );
376                         }
377                         else
378                                 eDebug("[eDVBLocalTimerHandler] dont have correction.. set Transponder Diff");
379                         new_diff=enigma_diff;
380                         m_time_ready=true;
381                 }
382
383                 time_t t = linuxTime+new_diff;
384                 m_last_tp_time_difference=tp_time-t;
385
386                 if (!new_diff &&
387                         updated) // overrride this check on first received TDT
388                 {
389                         eDebug("[eDVBLocalTimerHandler] not changed");
390                         return;
391                 }
392
393                 if ( !update_count )
394                 {
395                         // set rtc to calced transponder time when the first tdt is received on this
396                         // transponder
397                         setRTC(t);
398                         eDebug("[eDVBLocalTimerHandler] update RTC");
399                 }
400                 else if (getRTC())
401                 {
402                         if (abs(getRTC() - t) > 60)
403                         {
404                                 eDebug("[eDVBLocalTimerHandler] difference between new linux time and RTC time is > 60 sec... transponder time looks not ok... use rtc time");
405                                 t = getRTC();
406                         }
407                         else
408                                 eDebug("[eDVBLocalTimerHandler] difference between linux time and RTC time is < 60 sec... so the transponder time looks ok");
409                 }
410                 else
411                         eDebug("[eDVBLocalTimerHandler] no RTC available :(");
412
413                 tm now;
414                 localtime_r(&t, &now);
415                 eDebug("[eDVBLocalTimerHandler] time update to %02d:%02d:%02d",
416                         now.tm_hour,
417                         now.tm_min,
418                         now.tm_sec);
419
420                 time_difference = t - linuxTime;   // calc our new linux_time -> enigma_time correction
421                 eDebug("[eDVBLocalTimerHandler] m_time_difference is %d", time_difference );
422
423                 if ( time_difference )
424                 {
425                         eDebug("[eDVBLocalTimerHandler] set Linux Time");
426                         timeval tnow;
427                         gettimeofday(&tnow,0);
428                         tnow.tv_sec=t;
429                         settimeofday(&tnow,0);
430                 }
431
432                  /*emit*/ m_timeUpdated();
433         }
434
435         if ( restart_tdt )
436         {
437                 std::map<iDVBChannel*, channel_data>::iterator it =
438                         m_knownChannels.find(chan);
439                 if ( it != m_knownChannels.end() )
440                 {
441                         int updateCount = it->second.tdt->getUpdateCount();
442                         it->second.tdt = 0;
443                         it->second.tdt = new TDT(chan, updateCount);
444                         it->second.tdt->startTimer(TIME_UPDATE_INTERVAL);  // restart TDT for this transponder in 30min
445                 }
446         }
447 }
448
449 void eDVBLocalTimeHandler::DVBChannelAdded(eDVBChannel *chan)
450 {
451         if ( chan )
452         {
453 //              eDebug("[eDVBLocalTimerHandler] add channel %p", chan);
454                 std::pair<std::map<iDVBChannel*, channel_data>::iterator, bool> tmp =
455                         m_knownChannels.insert( std::pair<iDVBChannel*, channel_data>(chan, channel_data()) );
456                 tmp.first->second.tdt = NULL;
457                 tmp.first->second.channel = chan;
458                 tmp.first->second.m_prevChannelState = -1;
459                 chan->connectStateChange(slot(*this, &eDVBLocalTimeHandler::DVBChannelStateChanged), tmp.first->second.m_stateChangedConn);
460         }
461 }
462
463 void eDVBLocalTimeHandler::DVBChannelStateChanged(iDVBChannel *chan)
464 {
465         std::map<iDVBChannel*, channel_data>::iterator it =
466                 m_knownChannels.find(chan);
467         if ( it != m_knownChannels.end() )
468         {
469                 int state=0;
470                 chan->getState(state);
471                 if ( state != it->second.m_prevChannelState )
472                 {
473                         switch (state)
474                         {
475                                 case iDVBChannel::state_ok:
476                                         eDebug("[eDVBLocalTimerHandler] channel %p running", chan);
477                                         m_updateNonTunedTimer->stop();
478                                         if (m_use_dvb_time) {
479                                                 it->second.tdt = new TDT(it->second.channel);
480                                                 it->second.tdt->start();
481                                         }
482                                         break;
483                                 case iDVBChannel::state_release:
484                                         eDebug("[eDVBLocalTimerHandler] remove channel %p", chan);
485                                         m_knownChannels.erase(it);
486                                         if (m_knownChannels.empty())
487                                                 m_updateNonTunedTimer->start(TIME_UPDATE_INTERVAL, true);
488                                         break;
489                                 default: // ignore all other events
490                                         return;
491                         }
492                         it->second.m_prevChannelState = state;
493                 }
494         }
495 }