fix small bug introduced with v2 merging
[enigma2.git] / lib / dvb / frontend.cpp
1 #include <config.h>
2 #include <lib/dvb/dvb.h>
3 #include <lib/base/eerror.h>
4 #include <errno.h>
5 #include <unistd.h>
6 #include <fcntl.h>
7 #include <sys/ioctl.h>
8
9 #if HAVE_DVB_API_VERSION < 3
10 #include <ost/frontend.h>
11 #include <ost/sec.h>
12 #else
13 #include <linux/dvb/frontend.h>
14 #endif
15
16 #include <lib/dvb_si/satellite_delivery_system_descriptor.h>
17 #include <lib/dvb_si/cable_delivery_system_descriptor.h>
18 #include <lib/dvb_si/terrestrial_delivery_system_descriptor.h>
19
20 void eDVBFrontendParametersSatellite::set(const SatelliteDeliverySystemDescriptor &descriptor)
21 {
22         frequency    = descriptor.getFrequency() * 10;
23         symbol_rate  = descriptor.getSymbolRate() * 100;
24         switch (descriptor.getPolarization())
25         {
26         case 0:
27                 polarisation = Polarisation::Horizontal;
28                 break;
29         case 1:
30                 polarisation = Polarisation::Vertical;
31                 break;
32         case 2:
33                 polarisation = Polarisation::CircularLeft;
34                 break;
35         case 3:
36                 polarisation = Polarisation::CircularRight;
37                 break;
38         }
39         switch (descriptor.getFecInner())
40         {
41         case 1:
42                 fec = FEC::f1_2;
43                 break;
44         case 2:
45                 fec = FEC::f2_3;
46                 break;
47         case 3:
48                 fec = FEC::f3_4;
49                 break;
50         case 4:
51                 fec = FEC::f5_6;
52                 break;
53         case 5:
54                 fec = FEC::f7_8;
55                 break;
56         case 0xF:
57                 fec = FEC::fNone;
58                 break;
59         default:
60                 fec = FEC::fAuto;
61                 break;
62         }
63         inversion = Inversion::Unknown;
64         orbital_position  = ((descriptor.getOrbitalPosition() >> 12) & 0xF) * 1000;
65         orbital_position += ((descriptor.getOrbitalPosition() >> 8) & 0xF) * 100;
66         orbital_position += ((descriptor.getOrbitalPosition() >> 4) & 0xF) * 10;
67         orbital_position += ((descriptor.getOrbitalPosition()) & 0xF);
68         if (orbital_position && (!descriptor.getWestEastFlag()))
69                 orbital_position = 3600 - orbital_position;
70 }
71
72 void eDVBFrontendParametersCable::set(const CableDeliverySystemDescriptor &descriptor)
73 {
74         eFatal("nyi");
75 }
76
77 void eDVBFrontendParametersTerrestrial::set(const TerrestrialDeliverySystemDescriptor  &)
78 {
79         eFatal("nyi");
80 }
81
82 eDVBFrontendParameters::eDVBFrontendParameters(): m_type(-1)
83 {
84 }
85
86 DEFINE_REF(eDVBFrontendParameters);
87
88 RESULT eDVBFrontendParameters::getSystem(int &t) const
89 {
90         if (m_type == -1)
91                 return -1;
92         t = m_type;
93         return 0;
94 }
95
96 RESULT eDVBFrontendParameters::getDVBS(eDVBFrontendParametersSatellite &p) const
97 {
98         if (m_type != iDVBFrontend::feSatellite)
99                 return -1;
100         p = sat;
101         return 0;
102 }
103
104 RESULT eDVBFrontendParameters::getDVBC(eDVBFrontendParametersCable &p) const
105 {
106         if (m_type != iDVBFrontend::feCable)
107                 return -1;
108         p = cable;
109         return 0;
110 }
111
112 RESULT eDVBFrontendParameters::getDVBT(eDVBFrontendParametersTerrestrial &p) const
113 {
114         if (m_type != iDVBFrontend::feTerrestrial)
115                 return -1;
116         p = terrestrial;
117         return 0;
118 }
119
120 RESULT eDVBFrontendParameters::setDVBS(eDVBFrontendParametersSatellite &p)
121 {
122         sat = p;
123         m_type = iDVBFrontend::feSatellite;
124         return 0;
125 }
126
127 RESULT eDVBFrontendParameters::setDVBC(eDVBFrontendParametersCable &p)
128 {
129         cable = p;
130         m_type = iDVBFrontend::feCable;
131         return 0;
132 }
133
134 RESULT eDVBFrontendParameters::setDVBT(eDVBFrontendParametersTerrestrial &p)
135 {
136         terrestrial = p;
137         m_type = iDVBFrontend::feTerrestrial;
138         return 0;
139 }
140
141 RESULT eDVBFrontendParameters::calculateDifference(const iDVBFrontendParameters *parm, int &diff) const
142 {
143         if (!parm)
144                 return -1;
145         int type;
146         if (parm->getSystem(type))
147                 return -1;
148         if (type != m_type)
149         {
150                 diff = 1<<30; // big difference
151                 return 0;
152         }
153         
154         switch (type)
155         {
156         case iDVBFrontend::feSatellite:
157         {
158                 eDVBFrontendParametersSatellite osat;
159                 if (parm->getDVBS(osat))
160                         return -2;
161                 
162                 if (sat.orbital_position != osat.orbital_position)
163                         diff = 1<<29;
164                 else if (sat.polarisation != osat.polarisation)
165                         diff = 1<<28;
166                 else 
167                         diff = abs(sat.frequency - osat.frequency);
168                 return 0;
169         }
170         case iDVBFrontend::feCable:
171         case iDVBFrontend::feTerrestrial:
172         default:
173                 return -1;
174         }
175         return 0;
176 }
177
178 RESULT eDVBFrontendParameters::getHash(unsigned long &hash) const 
179 {
180         switch (m_type)
181         {
182         case iDVBFrontend::feSatellite:
183         {
184                 hash  = sat.frequency & 0xFFFF;
185                 hash |= sat.orbital_position << 16;
186                 return 0;
187         }
188         case iDVBFrontend::feCable:
189         case iDVBFrontend::feTerrestrial:
190         default:
191                 return -1;
192         }
193 }
194
195 DEFINE_REF(eDVBFrontend);
196
197 eDVBFrontend::eDVBFrontend(int adap, int fe, int &ok): m_type(-1)
198 {
199 #if HAVE_DVB_API_VERSION < 3
200         char sec_filename[128];
201 #endif
202         char filename[128];
203
204         int result;
205
206         m_sn = 0;
207         m_timeout = 0;
208
209 #if HAVE_DVB_API_VERSION < 3
210         sprintf(sec_filename, "/dev/dvb/card%d/sec%d", adap, fe);
211         m_secfd = ::open(sec_filename, O_RDWR);
212         if (m_secfd < 0)
213         {
214                 eWarning("failed! (%s) %m", sec_filename);
215                 ok = 0;
216                 return;
217         }
218         else
219                 eDebug("m_secfd is %d", m_secfd);
220
221         FrontendInfo fe_info;
222         sprintf(filename, "/dev/dvb/card%d/frontend%d", adap, fe);
223 #else
224         dvb_frontend_info fe_info;      
225         sprintf(filename, "/dev/dvb/adapter%d/frontend%d", adap, fe);
226 #endif
227         eDebug("opening frontend.");
228         m_fd = ::open(filename, O_RDWR|O_NONBLOCK);
229         if (m_fd < 0)
230         {
231                 eWarning("failed! (%s) %m", filename);
232                 ok = 0;
233                 return;
234         }
235
236         result = ::ioctl(m_fd, FE_GET_INFO, &fe_info);
237         
238         if (result < 0) {
239                 eWarning("ioctl FE_GET_INFO failed");
240                 ::close(m_fd);
241                 m_fd = -1;
242                 ok = 0;
243                 return;
244         }
245
246         switch (fe_info.type) 
247         {
248         case FE_QPSK:
249                 m_type = feSatellite;
250                 break;
251         case FE_QAM:
252                 m_type = feCable;
253                 break;
254         case FE_OFDM:
255                 m_type = feTerrestrial;
256                 break;
257         default:
258                 eWarning("unknown frontend type.");
259                 ::close(m_fd);
260                 m_fd = -1;
261                 ok = 0;
262                 return;
263         }
264         eDebug("detected %s frontend", "satellite\0cable\0    terrestrial"+feSatellite*9);
265         ok = 1;
266
267         m_sn = new eSocketNotifier(eApp, m_fd, eSocketNotifier::Read);
268         CONNECT(m_sn->activated, eDVBFrontend::feEvent);
269         m_sn->start();
270         
271         m_timeout = new eTimer(eApp);
272         CONNECT(m_timeout->timeout, eDVBFrontend::timeout);
273         
274         return;
275 }
276
277 eDVBFrontend::~eDVBFrontend()
278 {
279         if (m_fd >= 0)
280                 ::close(m_fd);
281         if (m_sn)
282                 delete m_sn;
283         if (m_timeout)
284                 delete m_timeout;
285 }
286
287 void eDVBFrontend::feEvent(int w)
288 {
289         while (1)
290         {
291 #if HAVE_DVB_API_VERSION < 3
292                 FrontendEvent event;
293 #else
294                 dvb_frontend_event event;
295 #endif
296                 int res;
297                 int state;
298                 res = ::ioctl(m_fd, FE_GET_EVENT, &event);
299                 
300                 if (res && (errno == EAGAIN))
301                         break;
302
303                 if (res)
304                 {
305                         eWarning("FE_GET_EVENT failed! %m");
306                         return;
307                 }
308                 
309                 if (w < 0)
310                         continue;
311
312 #if HAVE_DVB_API_VERSION < 3
313                 if (event.type == FE_COMPLETION_EV)
314 #else
315                 eDebug("fe event: status %x, inversion %s", event.status, (event.parameters.inversion == INVERSION_ON) ? "on" : "off");
316                 if (event.status & FE_HAS_LOCK)
317 #endif
318                 {
319                         state = stateLock;
320                 } else
321                 {
322                         if (m_tuning)
323                                 state = stateTuning;
324                         else
325                                 state = stateFailed;
326                 }
327                 if (m_state != state)
328                 {
329                         m_state = state;
330                         m_stateChanged(this);
331                 }
332         }
333 }
334
335 void eDVBFrontend::timeout()
336 {
337         int state;
338         if (m_state == stateTuning)
339         {
340                 state = stateFailed;
341                 eDebug("DVBFrontend: timeout");
342                 if (m_state != state)
343                 {
344                         m_state = state;
345                         m_stateChanged(this);
346                 }
347         } else
348                 m_tuning = 0;
349 }
350
351 RESULT eDVBFrontend::getFrontendType(int &t)
352 {
353         if (m_type == -1)
354                 return -ENODEV;
355         t = m_type;
356         return 0;
357 }
358
359 RESULT eDVBFrontend::tune(const iDVBFrontendParameters &where)
360 {
361         if (m_type == -1)
362                 return -ENODEV;
363
364 #if HAVE_DVB_API_VERSION < 3
365         FrontendParameters parm;
366 #else
367         dvb_frontend_parameters parm;
368 #endif
369
370         feEvent(-1);
371         
372         switch (m_type)
373         {
374         case feSatellite:
375         {
376                 int res;
377                 eDVBFrontendParametersSatellite feparm;
378                 if (where.getDVBS(feparm))
379                 {
380                         eDebug("no dvbs data!");
381                         return -EINVAL;
382                 }
383                 if (!m_sec)
384                 {
385                         eWarning("no SEC module active!");
386                         return -ENOENT;
387                 }
388                 
389                 res = m_sec->prepare(*this, parm, feparm);
390                 if (res)
391                         return res;
392 #if HAVE_DVB_API_VERSION < 3
393                 eDebug("tuning to %d mhz", parm.Frequency/1000);
394 #else
395                 eDebug("tuning to %d mhz", parm.frequency/1000);
396 #endif
397                 break;
398         }
399         case feCable:
400         {
401                 eDVBFrontendParametersCable feparm;
402                 if (where.getDVBC(feparm))
403                         return -EINVAL;
404                 eFatal("cable tuning nyi");
405         }
406         case feTerrestrial:
407         {
408                 eDVBFrontendParametersTerrestrial feparm;
409                 if (where.getDVBT(feparm))
410                         return -EINVAL;
411                 eFatal("terrestrial tuning nyi");
412         }
413         }
414         
415         if (ioctl(m_fd, FE_SET_FRONTEND, &parm) == -1)
416         {
417                 perror("FE_SET_FRONTEND failed");
418                 return errno;
419         }
420         
421         if (m_state != stateTuning)
422         {
423                 m_tuning = 1;
424                 m_state = stateTuning;
425                 m_stateChanged(this);
426         }
427         
428         m_timeout->start(5000, 1); // 5 sec timeout. TODO: symbolrate dependent
429
430         return 0;
431 }
432
433 RESULT eDVBFrontend::connectStateChange(const Slot1<void,iDVBFrontend*> &stateChange, ePtr<eConnection> &connection)
434 {
435         connection = new eConnection(this, m_stateChanged.connect(stateChange));
436         return 0;
437 }
438
439 RESULT eDVBFrontend::setVoltage(int voltage)
440 {
441 #if HAVE_DVB_API_VERSION < 3
442         secVoltage vlt;
443 #else
444         fe_sec_voltage_t vlt;
445 #endif
446
447         switch (voltage)
448         {
449         case voltageOff:
450                 vlt = SEC_VOLTAGE_OFF;
451                 break;
452         case voltage13:
453                 vlt = SEC_VOLTAGE_13;
454                 break;
455         case voltage18:
456                 vlt = SEC_VOLTAGE_18;
457                 break;
458         default:
459                 return -ENODEV;
460         }
461 #if HAVE_DVB_API_VERSION < 3
462         return ::ioctl(m_secfd, SEC_SET_VOLTAGE, vlt);
463 #else
464         return ::ioctl(m_fd, FE_SET_VOLTAGE, vlt);
465 #endif
466 }
467
468 RESULT eDVBFrontend::getState(int &state)
469 {
470         state = m_state;
471         return 0;
472 }
473
474 RESULT eDVBFrontend::setTone(int t)
475 {
476 #if HAVE_DVB_API_VERSION < 3
477         secToneMode_t tone;
478 #else
479         fe_sec_tone_mode_t tone;
480 #endif
481
482         switch (t)
483         {
484         case toneOn:
485                 tone = SEC_TONE_ON;
486                 break;
487         case toneOff:
488                 tone = SEC_TONE_OFF;
489                 break;
490         default:
491                 return -ENODEV;
492         }
493 #if HAVE_DVB_API_VERSION < 3    
494         return ::ioctl(m_secfd, SEC_SET_TONE, tone);
495 #else   
496         return ::ioctl(m_fd, FE_SET_TONE, tone);
497 #endif
498 }
499
500 RESULT eDVBFrontend::sendDiseqc(const eDVBDiseqcCommand &diseqc)
501 {
502 #if HAVE_DVB_API_VERSION < 3
503         secCmdSequence seq;
504         secCommand cmd;
505
506         cmd.type = SEC_CMDTYPE_DISEQC_RAW;
507         cmd.u.diseqc.cmdtype = diseqc.data[0];
508         eDebug("cmdtype is %02x", diseqc.data[0]);
509         cmd.u.diseqc.addr = diseqc.data[1];
510         eDebug("cmdaddr is %02x", diseqc.data[1]);
511         cmd.u.diseqc.cmd = diseqc.data[2];
512         eDebug("cmd is %02x", diseqc.data[2]);
513         cmd.u.diseqc.numParams = diseqc.len-3;
514         eDebug("numparams %d", diseqc.len-3);
515
516         memcpy(cmd.u.diseqc.params, diseqc.data+3, diseqc.len-3);
517         for (int i=0; i < diseqc.len-3; ++i )
518                 eDebugNoNewLine("%02x ", diseqc.data[3+i]);
519         eDebug("");
520
521         seq.continuousTone = SEC_TONE_OFF;
522         seq.voltage = SEC_VOLTAGE_13;
523         seq.miniCommand = SEC_MINI_NONE;
524         seq.commands=&cmd;
525         seq.numCommands=1;
526
527
528         if ( ioctl(m_secfd, SEC_SEND_SEQUENCE, &seq) < 0 )
529         {
530                 eDebug("SEC_SEND_SEQUENCE failed ( %m )");
531                 return -EINVAL;
532         }
533         return 0;
534 #else
535         struct dvb_diseqc_master_cmd cmd;
536         if (::ioctl(m_fd, FE_SET_TONE, SEC_TONE_OFF))
537                 return -EINVAL;
538         usleep(15 * 1000);
539         memcpy(cmd.msg, diseqc.data, diseqc.len);
540         cmd.msg_len = diseqc.len;
541         
542         if (::ioctl(m_fd, FE_DISEQC_SEND_MASTER_CMD, &cmd))
543                 return -EINVAL;
544         usleep(15 * 1000);
545 #endif
546         eDebug("diseqc ok");
547         return 0;
548 }
549
550 RESULT eDVBFrontend::setSEC(iDVBSatelliteEquipmentControl *sec)
551 {
552         m_sec = sec;
553         return 0;
554 }