source: titan/titan/frontenddev.h @ 40798

Last change on this file since 40798 was 40798, checked in by gost, 6 years ago

[titan] add new dvb-t2 test
File size: 51.1 KB
Line 
1#ifndef FRONTENDDEV_H
2#define FRONTENDDEV_H
3
4int calclof(struct dvbdev* node, struct transponder* tpnode, char* feaktnr, int flag)
5{
6        int loftype = 0;
7        int lofl, lofh, lofthreshold;
8        int satcrfrequ = 0;
9        char* tmpstr = NULL;
10
11        if(node == NULL || tpnode == NULL)
12        {
13                err("NULL detect");
14                return -1;
15        }
16
17        if(node->feinfo->type != FE_QPSK)
18                return 0;
19
20        unsigned int frequency = tpnode->frequency;
21        node->feunicable = 0;
22
23        if(feaktnr == NULL) feaktnr = node->feaktnr;
24
25        tmpstr = ostrcat(node->feshortname, "_lnb_loftype", 0, 0);
26        loftype = getconfigint(tmpstr, feaktnr);
27        free(tmpstr); tmpstr = NULL;
28        switch(loftype)
29        {
30                case 1: //c-band
31                        lofl = 5150 * 1000;
32                        lofh = 5150 * 1000;
33                        lofthreshold = 5150 * 1000;
34                        break;
35                case 2: //user
36                        tmpstr = ostrcat(node->feshortname, "_lnb_lofl", 0, 0);
37                        lofl = getconfigint(tmpstr, feaktnr) * 1000;
38                        free(tmpstr); tmpstr = NULL;
39                        tmpstr = ostrcat(node->feshortname, "_lnb_lofh", 0, 0);
40                        lofh = getconfigint(tmpstr, feaktnr) * 1000;
41                        free(tmpstr); tmpstr = NULL;
42                        tmpstr = ostrcat(node->feshortname, "_lnb_lofthreshold", 0, 0);
43                        lofthreshold = getconfigint(tmpstr, feaktnr) * 1000;
44                        free(tmpstr); tmpstr = NULL;
45                        break;
46                case 3: //unicable
47                case 4: //user unicable
48                        tmpstr = ostrcat(node->feshortname, "_lnb_lofl", 0, 0);
49                        lofl = getconfigint(tmpstr, feaktnr) * 1000;
50                        free(tmpstr); tmpstr = NULL;
51                        if(lofl == 0) lofl = 9750 * 1000;
52                        tmpstr = ostrcat(node->feshortname, "_lnb_lofh", 0, 0);
53                        lofh = getconfigint(tmpstr, feaktnr) * 1000;
54                        free(tmpstr); tmpstr = NULL;
55                        if(lofh == 0) lofh = 10600 * 1000;
56                        tmpstr = ostrcat(node->feshortname, "_lnb_lofthreshold", 0, 0);
57                        lofthreshold = getconfigint(tmpstr, feaktnr) * 1000;
58                        free(tmpstr); tmpstr = NULL;
59                        if(lofthreshold == 0) lofthreshold = 11700 * 1000;
60                        tmpstr = ostrcat(node->feshortname, "_lnb_satcrfrequ", 0, 0);
61                        satcrfrequ = getconfigint(tmpstr, feaktnr) * 1000;
62                        free(tmpstr); tmpstr = NULL;
63                        break;
64                default: //standard lnb
65                        lofl = 9750 * 1000;
66                        lofh = 10600 * 1000;
67                        lofthreshold = 11700 * 1000;
68        }
69
70        if(lofthreshold && lofh && frequency >= lofthreshold)
71        {
72                if(flag == 1) return 1;
73                node->feaktband = 1;
74        }
75        else
76        {
77                if(flag == 1) return 0;
78                node->feaktband = 0;
79        }
80
81        if(satcrfrequ == 0)
82        {
83                if(node->feaktband)
84                        node->feloffrequency = frequency - lofh;
85                else
86                {
87                        if(frequency < lofl)
88                                node->feloffrequency = lofl - frequency;
89                        else
90                                node->feloffrequency = frequency - lofl;
91                }
92        }
93        else
94        {
95                int lof = (node->feaktband & 1) ? lofh : lofl;
96                unsigned int tmp = (frequency - lof) + satcrfrequ;
97                node->feloffrequency = (tmp / 4) - 350000;
98                node->feunicable = 1;
99        }
100
101        debug(200, "tuning to freq %d (befor lof %d), band=%d, unicable=%d", node->feloffrequency, frequency, node->feaktband, node->feunicable);
102        return node->feaktband;
103}
104
105char* fegettypestr(struct dvbdev* dvbnode)
106{
107        char* text = NULL;
108
109        if(dvbnode == NULL)
110        {
111                err("NULL detect");
112                return NULL;
113        }
114
115        switch(dvbnode->feinfo->type)
116        {
117                case FE_QPSK: text = ostrcat(text, "DVB-S", 1, 0); break;
118                case FE_QAM: text = ostrcat(text, "DVB-C", 1, 0); break;
119                case FE_OFDM: text = ostrcat(text, "DVB-T", 1, 0); break;
120                default: text = ostrcat(text, "unknown", 1, 0);
121        }
122
123        return text;
124}
125
126struct dvbdev* fegetbyshortname(char* feshortname)
127{
128        struct dvbdev* dvbnode = dvbdev;
129       
130        while(dvbnode != NULL)
131        {
132                if(dvbnode->type == FRONTENDDEV && ostrcmp(dvbnode->feshortname, feshortname) == 0)
133                        return dvbnode;
134                dvbnode = dvbnode->next;
135        }
136        return NULL;
137}
138
139void fegetconfig(struct dvbdev *dvbnode, struct transponder *tpnode, char** aktnr, char* tmpnr)
140{
141        char* tmpstr = NULL;
142
143        if(dvbnode == NULL || tpnode == NULL)
144        {
145                err("NULL detect");
146                return;
147        }
148
149        tmpstr = ostrcat(dvbnode->feshortname, "_satnr", 0, 0);
150        *aktnr = getconfig(tmpstr, tmpnr);
151        free(tmpstr); tmpstr = NULL;
152}
153
154struct dvbdev* fegetdummy()
155{
156        struct dvbdev* dvbnode = dvbdev;
157
158        while(dvbnode != NULL)
159        {
160                if(dvbnode->type == FRONTENDDEVDUMMY)
161                        return dvbnode;
162                dvbnode = dvbnode->next;
163        }
164        return NULL;
165}
166
167void settunerstatus()
168{
169        struct dvbdev* dvbnode = dvbdev;
170
171        while(dvbnode != NULL)
172        {
173                //FRONTENDDEV first in the list
174                if(dvbnode->type != FRONTENDDEV) break;
175
176                if(checkbox("DM900") == 1 || checkbox("DM520") == 1 || checkbox("DM525") == 1)
177                {
178                        if(ostrcmp("fe_01", dvbnode->feshortname) == 0)
179                        {
180                                if(ostrcmp("fe_00", getconfig(dvbnode->feshortname, NULL)) == 0)
181                                        system("echo internal > /proc/stb/frontend/1/rf_switch");
182                                else
183                                        system("echo external > /proc/stb/frontend/1/rf_switch");
184                        }
185                }
186                //check if tuner is deactivate
187                if(ostrcmp("x", getconfig(dvbnode->feshortname, NULL)) == 0)
188                        dvbnode->deactive = 1;
189                else
190                        dvbnode->deactive = 0;
191
192                dvbnode = dvbnode->next;
193        }
194}
195
196//flag 0 = normal
197//flag 1 = check only
198//flag 2 = from record
199//flag 3 = from rectimer
200struct dvbdev* fegetfree(struct transponder* tpnode, int flag, struct dvbdev* dvbfirst)
201{
202        struct dvbdev* dvbnode = NULL;
203        struct dvbdev* tmpdvbnode = NULL;
204        char* tmpstr = NULL, *tmpnr = NULL, *aktnr = NULL;
205        int i, orbitalpos = 0, band = 0;
206
207        if(dvbfirst != NULL)
208                dvbnode = dvbfirst;
209        else
210                dvbnode = dvbdev;
211
212        if(tpnode == NULL)
213        {
214                err("NULL detect");
215                return NULL;
216        }
217
218        //suche tuner der auf der gleichen orbitalpos/frequency/pol/band ist
219        while(dvbnode != NULL)
220        {
221                //FRONTENDDEV first in the list
222                if(dvbnode->type != FRONTENDDEV) break;
223
224                //check if tuner is deactivate
225                if(dvbnode->deactive == 1)
226                {
227                        dvbnode = dvbnode->next;
228                        continue;
229                }
230
231                if(dvbnode->type == FRONTENDDEV && dvbnode->feinfo->type == tpnode->fetype)
232                {
233                        if(dvbnode->feakttransponder != NULL && dvbnode->feakttransponder->orbitalpos == tpnode->orbitalpos && dvbnode->feakttransponder->frequency == tpnode->frequency && dvbnode->feaktpolarization == tpnode->polarization)
234                        {
235                                band = calclof(dvbnode, tpnode, dvbnode->feaktnr, 1);
236                                if(dvbnode->feaktband != band)
237                                {
238                                        dvbnode = dvbnode->next;
239                                        continue;
240                                }
241                                dvbnode->felasttransponder = dvbnode->feakttransponder;
242                                dvbnode->feakttransponder = tpnode;
243                                if(flag != 1) debug(200, "found tuner with same orbitalpos/frequency/pol/band %s", dvbnode->feshortname);
244                                return(dvbnode);
245                        }
246                }
247                dvbnode = dvbnode->next;
248        }
249        if(dvbfirst != NULL)
250                dvbnode = dvbfirst;
251        else
252                dvbnode = dvbdev;
253
254        //suche tuner der die gewuenschte orbitalpos kann und nicht belegt ist
255        while(dvbnode != NULL)
256        {
257                //FRONTENDDEV first in the list
258                if(dvbnode->type != FRONTENDDEV) break;
259
260                //check if tuner is deactivate
261                if(dvbnode->deactive == 1)
262                {
263                        dvbnode = dvbnode->next;
264                        continue;
265                }
266
267                if(dvbnode->type == FRONTENDDEV && dvbnode->feinfo->type == tpnode->fetype && dvbnode->felock == 0)
268                {
269                        if(flag == 2 && status.aktservice->fedev == dvbnode)
270                        {
271                                dvbnode = dvbnode->next;
272                                continue;
273                        }
274
275                        //check if tuner is loop and looptuner is locked
276                        tmpstr = getconfigbyval(dvbnode->feshortname, NULL);
277                        if(tmpstr != NULL) //found loop tuner
278                        {
279                                tmpdvbnode = fegetbyshortname(tmpstr);
280                                if(tmpdvbnode != NULL && tmpdvbnode->feakttransponder != NULL && tmpdvbnode->feaktpolarization != tpnode->polarization && (tmpdvbnode->felock != 0 || (flag == 2 && tmpdvbnode->felock == 0)))
281                                {
282                                        dvbnode = dvbnode->next;
283                                        continue;
284                                }
285                        }
286
287                        tmpstr = ostrcat(dvbnode->feshortname, "_sat", 0, 0);
288                        for(i = 1; i <= getmaxsat(dvbnode->feshortname); i++)
289                        {
290                                tmpnr = oitoa(i);
291
292                                orbitalpos = getconfigint(tmpstr, tmpnr);
293                                if(orbitalpos == tpnode->orbitalpos)
294                                {
295                                        fegetconfig(dvbnode, tpnode, &aktnr, tmpnr);
296                                        if(flag == 3)
297                                                band = calclof(dvbnode, tpnode, aktnr, 0);
298                                        else
299                                                band = calclof(dvbnode, tpnode, aktnr, 1);
300                                        if(tmpdvbnode != NULL && tmpdvbnode->feaktband != band && (tmpdvbnode->felock != 0 || (flag == 2 && tmpdvbnode->felock == 0)))
301                                        {
302                                                free(tmpnr); tmpnr = NULL;
303                                                continue;
304                                        }
305                                        if(flag == 1)
306                                        {
307                                                free(tmpstr); tmpstr = NULL;
308                                                free(tmpnr); tmpnr = NULL;
309                                                return dvbnode;
310                                        }
311                                        if(tmpdvbnode != NULL)
312                                        {
313                                                tmpdvbnode->feaktband = band;
314                                                tmpdvbnode->feaktpolarization = tpnode->polarization;
315                                        }
316                                        dvbnode->felasttransponder = dvbnode->feakttransponder;
317                                        dvbnode->feakttransponder = tpnode;
318                                        dvbnode->feaktpolarization = tpnode->polarization;
319                                        free(dvbnode->feaktnr);
320                                        if(aktnr != NULL)
321                                                dvbnode->feaktnr = ostrcat(aktnr, NULL, 0, 0);
322                                        else
323                                                dvbnode->feaktnr = NULL;
324
325                                        free(tmpstr); tmpstr = NULL;
326                                        free(tmpnr); tmpnr = NULL;
327                                        if(flag != 1) debug(200, "found free tuner witch same orbitalpos %s", dvbnode->feshortname);
328                                        return dvbnode;
329                                }
330                                free(tmpnr); tmpnr = NULL;
331                        }
332                        free(tmpstr); tmpstr = NULL;
333                }
334                dvbnode = dvbnode->next;
335        }
336        if(dvbfirst != NULL)
337                dvbnode = dvbfirst;
338        else
339                dvbnode = dvbdev;
340
341        //suche loop tuner, wo der haupttuner
342        //die gewuenschte orbitalpos kann, nicht belegt ist
343        //und auf der gleichen poarization/band ist, wo wir hintunen wollen
344        while(dvbnode != NULL)
345        {
346                //FRONTENDDEV first in the list
347                if(dvbnode->type != FRONTENDDEV) break;
348
349                //check if tuner is deactivate
350                if(dvbnode->deactive == 1)
351                {
352                        dvbnode = dvbnode->next;
353                        continue;
354                }
355
356                if(dvbnode->type == FRONTENDDEV && dvbnode->feinfo->type == tpnode->fetype && dvbnode->felock == 0)
357                {
358                        if(flag == 2 && status.aktservice->fedev == dvbnode)
359                        {
360                                dvbnode = dvbnode->next;
361                                continue;
362                        }
363
364                        //check if tuner is loop an looptuner is locked
365                        tmpstr = getconfig(dvbnode->feshortname, NULL);
366                        if(tmpstr != NULL) //found loop tuner
367                        {
368                                tmpdvbnode = fegetbyshortname(tmpstr);
369                                if(tmpdvbnode != NULL && tmpdvbnode->feakttransponder != NULL && tmpdvbnode->feaktpolarization != tpnode->polarization && (tmpdvbnode->felock != 0 || (flag == 2 && tmpdvbnode->felock == 0)))
370                                {
371                                        dvbnode = dvbnode->next;
372                                        continue;
373                                }
374                        }
375                        else
376                        {
377                                dvbnode = dvbnode->next;
378                                continue;
379                        }
380
381                        tmpstr = ostrcat(tmpdvbnode->feshortname, "_sat", 0, 0);
382                        for(i = 1; i <= getmaxsat(tmpdvbnode->feshortname); i++)
383                        {
384                                tmpnr = oitoa(i);
385                                orbitalpos = getconfigint(tmpstr, tmpnr);
386                                if(orbitalpos == tpnode->orbitalpos)
387                                {
388                                        fegetconfig(tmpdvbnode, tpnode, &aktnr, tmpnr);
389                                        if(flag == 3)
390                                                band = calclof(dvbnode, tpnode, aktnr, 0);
391                                        else
392                                                band = calclof(dvbnode, tpnode, aktnr, 1);
393                                        if(tmpdvbnode != NULL && tmpdvbnode->feaktband != band && (tmpdvbnode->felock != 0 || (flag >= 2 && tmpdvbnode->felock == 0)))
394                                        {
395                                                free(tmpnr); tmpnr = NULL;
396                                                continue;
397                                        }
398                                        if(flag == 1)
399                                        {
400                                                free(tmpstr); tmpstr = NULL;
401                                                free(tmpnr); tmpnr = NULL;
402                                                return dvbnode;
403                                        }
404                                        if(tmpdvbnode != NULL)
405                                        {
406                                                tmpdvbnode->feaktband = band;
407                                                tmpdvbnode->feaktpolarization = tpnode->polarization;
408                                        }
409                                        dvbnode->felasttransponder = dvbnode->feakttransponder;
410                                        dvbnode->feakttransponder = tpnode;
411                                        dvbnode->feaktpolarization = tpnode->polarization;
412                                        free(dvbnode->feaktnr);
413                                        if(aktnr != NULL)
414                                                dvbnode->feaktnr = ostrcat(aktnr, NULL, 0, 0);
415                                        else
416                                                dvbnode->feaktnr = NULL;
417                                        free(tmpstr); tmpstr = NULL;
418                                        free(tmpnr); tmpnr = NULL;
419                                        if(flag != 1) debug(200, "found free looptuner witch same orbitalpos/polarization/band %s", dvbnode->feshortname);
420                                        return dvbnode;
421                                }
422                                free(tmpnr); tmpnr = NULL;
423                        }
424                        free(tmpstr); tmpstr = NULL;
425                }
426                dvbnode = dvbnode->next;
427        }
428
429        return NULL;
430}
431
432int feopen(struct dvbdev* node, char *fedev)
433{
434        int fd = -1;
435
436        if(node != NULL)
437        {       
438                if((fd = open(node->dev, O_RDWR | O_NONBLOCK)) < 0)
439                        debug(200, "open frontend failed %s", node->dev);
440                node->fd = fd;
441        }
442        else
443        {
444                if((fd = open(fedev, O_RDWR | O_NONBLOCK)) < 0)
445                        debug(200, "open frontend failed %s", fedev);
446        }
447
448        closeonexec(fd);
449        return fd;
450}
451
452void feclose(struct dvbdev* node, int fd)
453{
454        if(node != NULL)
455        {
456                close(node->fd);
457                node->fd = -1;
458        }
459        else
460                close(fd);
461}
462
463int fegetunlock(struct dvbdev* node)
464{
465        fe_status_t status;
466
467        if(node == NULL)
468        {
469                err("NULL detect");
470                return 1;
471        }
472
473#ifdef SIMULATE
474        return 0;
475#endif
476
477        if(ioctl(node->fd, FE_READ_STATUS, &status) == -1)
478                perr("FE_READ_STATUS");
479
480        if(status & FE_HAS_LOCK)
481                return 0;
482        else
483                return 1;
484}
485
486int fewait(struct dvbdev* node)
487{
488        //struct dvb_frontend_event ev;
489        fe_status_t status;
490        fe_status_t status_m = 0;
491
492        int count = 0;
493
494        if(node == NULL)
495        {
496                err("NULL detect");
497                return 1;
498        }
499
500#ifdef SIMULATE
501        return 0;
502#endif
503
504        int timer = 500;
505
506#ifdef MIPSEL
507        timer = 2000;
508#endif
509
510        //wait for tuner ready
511        debug(200, "wait for tuner");
512        while(count <= timer)
513        {
514                count++;
515
516                //ioctl(node->fd, FE_GET_EVENT, &ev);
517                //if(ev.status & FE_HAS_LOCK)
518                //      return 0;
519                ioctl(node->fd, FE_READ_STATUS, &status);
520                if(status != 0)
521                {
522                        if(status_m != status)
523                        {
524                                debug(200, "status=%d, fe_lock=%d", status, FE_HAS_LOCK);
525                                status_m = status;
526                        }
527                }
528
529                if(errno == ERANGE)
530                {
531                        usleep(1000);
532                        continue;
533                }
534
535                if(status & FE_HAS_LOCK)
536        //              if(FE_HAS_SYNC | FE_HAS_LOCK)
537                        return 0;
538                usleep(1000);
539        }
540
541        //if(ev.status & FE_HAS_LOCK)
542        //      return 0;
543        if(status & FE_HAS_LOCK)
544//      if(FE_HAS_SYNC | FE_HAS_LOCK)
545                return 0;
546        else
547                return 1;
548}
549
550void fegetfrontend(struct dvbdev* node)
551{
552        if(node == NULL)
553        {
554                err("NULL detect");
555                return;
556        }
557
558#if DVB_API_VERSION >= 5
559        struct dtv_property p[8];
560        struct dtv_properties cmdseq;
561        cmdseq.props = p;
562
563        p[0].cmd = DTV_DELIVERY_SYSTEM;
564        p[1].cmd = DTV_FREQUENCY;
565        p[2].cmd = DTV_MODULATION;
566        p[3].cmd = DTV_SYMBOL_RATE;
567        p[4].cmd = DTV_INNER_FEC;
568        p[5].cmd = DTV_INVERSION;
569        p[6].cmd = DTV_ROLLOFF;
570        p[7].cmd = DTV_PILOT;
571        cmdseq.num = 8;
572       
573        if(ioctl(node->fd, FE_GET_PROPERTY, &cmdseq) < 0)
574        {
575                perr("FE_GET_PROPERTY");
576        }
577        else
578        {
579                debug(200, "frontend akt delivery system = %d", p[0].u.data);
580                debug(200, "frontend akt frequency = %d", p[1].u.data);
581                debug(200, "frontend akt inversion = %d", p[5].u.data);
582                debug(200, "frontend akt symbol_rate = %d", p[3].u.data);
583                debug(200, "frontend akt fec_inner = %d", p[4].u.data);
584                debug(200, "frontend akt modulation = %d", p[2].u.data);
585                debug(200, "frontend akt rolloff = %d", p[6].u.data);
586                debug(200, "frontend akt pilot = %d", p[7].u.data);
587        }
588#else
589        struct dvb_frontend_parameters fe_param;
590
591        if(ioctl(node->fd, FE_GET_FRONTEND, &fe_param) < 0)
592        {
593                perr("FE_GET_FRONTEND");
594        }
595        else
596        {
597                debug(200, "frontend akt frequency = %d", fe_param.frequency);
598                debug(200, "frontend akt inversion = %d", fe_param.inversion);
599                debug(200, "frontend akt u.qpsk.symbol_rate = %d", fe_param.u.qpsk.symbol_rate);
600                debug(200, "frontend akt u.qam.symbol_rate = %d", fe_param.u.qam.symbol_rate);
601                debug(200, "frontend akt u.qpsk.fec_inner = %d", fe_param.u.qpsk.fec_inner);
602                debug(200, "frontend akt u.qam.fec_inner = %d", fe_param.u.qam.fec_inner);
603                debug(200, "frontend akt u.qam.modulation = %d", fe_param.u.qam.modulation);
604        }
605#endif
606}
607
608int fesettone(struct dvbdev* node, fe_sec_tone_mode_t tone, int wait)
609{
610        int ret = 0;
611       
612        if(node == NULL)
613        {
614                err("NULL detect");
615                return 1;
616        }
617
618        debug(200, "FE_SET_TONE: %d (%s)", tone, node->feshortname);
619        if(ioctl(node->fd, FE_SET_TONE, tone) == -1)
620        {
621                perr("FE_SET_TONE");
622                ret = 1;
623        }
624        else
625        {
626                node->feakttone = tone;
627                usleep(wait * 1000);
628        }
629       
630        return ret;
631}
632
633//flag 0: reset tuner params on volt off
634//flag 1: don't reset tuner params on volt off
635int fesetvoltage(struct dvbdev* node, fe_sec_voltage_t volt, int wait)
636{
637        int ret = 0;
638       
639        if(node == NULL)
640        {
641                err("NULL detect");
642                return 1;
643        }
644
645        debug(200, "FE_SET_VOLT: %d (%s)", volt, node->feshortname);
646        if(ioctl(node->fd, FE_SET_VOLTAGE, volt) == -1)
647        {
648                perr("FE_SET_VOLTAGE");
649                ret = 1;
650        }
651        else
652        {
653                node->feaktvolt = volt;
654                if(wait > 0) usleep(wait * 1000);
655
656                if(volt == SEC_VOLTAGE_OFF)
657                {
658                        node->feakttransponder = NULL;
659                        node->felasttransponder = NULL;
660                        node->feunicable = 0;
661                        node->feloffrequency = 0;
662                        node->feaktband = 0;
663                        node->feaktpolarization = 0;
664                        node->feakttone = 0;
665                }
666        }
667
668        return ret;
669}
670
671void fediseqcsendburst(struct dvbdev* node, fe_sec_mini_cmd_t burst, int wait)
672{
673        if(node == NULL)
674        {
675                err("NULL detect");
676                return;
677        }
678
679        debug(200, "FE_DISEQC_SEND_BURST: %d (%s)", burst, node->feshortname);
680        if(ioctl(node->fd, FE_DISEQC_SEND_BURST, burst) == -1)
681                perr("FE_DISEQC_SEND_BURST");
682        usleep(wait * 1000);
683}
684
685void fediseqcsendmastercmd(struct dvbdev* node, struct dvb_diseqc_master_cmd *cmd, int wait)
686{
687        int i, repeat = 0, imsg = 0;
688        char* tmpstr = NULL;
689
690        if(node == NULL)
691        {
692                err("NULL detect");
693                return;
694        }
695       
696        if(cmd == NULL) return;
697        if(cmd->msg_len == 0) return;
698
699        tmpstr = ostrcat(node->feshortname, "_diseqc_repeat", 0, 0);
700        repeat = getconfigint(tmpstr, node->feaktnr);
701        free(tmpstr); tmpstr = NULL;
702        if(repeat < 1) repeat = 1;
703
704        for(i = 0; i < repeat; i++)
705        {
706                if(ioctl(node->fd, FE_DISEQC_SEND_MASTER_CMD, cmd) == -1)
707                {
708                        perr("FE_DISEQC_SEND_MASTER_CMD");
709                }
710                usleep(wait * 1000);
711        }
712        imsg = (cmd->msg[0] << 24) | (cmd->msg[1] << 16) | (cmd->msg[2] << 8) | cmd->msg[3];
713        debug(200, "DISEQC Master cmd (%s -> %04X)", node->feshortname, imsg);
714}
715
716void fesdiseqcpoweron(struct dvbdev* node)
717{
718        struct dvb_diseqc_master_cmd cmd = {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 0};
719
720        if(node == NULL)
721        {
722                err("NULL detect");
723                return;
724        }
725
726        cmd.msg[0] = 0xE0;
727        cmd.msg[1] = 0x00;
728        cmd.msg[2] = 0x03;
729        cmd.msg_len = 3;
730
731        debug(200, "DISEQC Power on (%s)", node->feshortname);
732        fediseqcsendmastercmd(node, &cmd, 100);
733}
734
735void fesdiseqcreset(struct dvbdev* node)
736{
737        struct dvb_diseqc_master_cmd cmd = {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 0};
738       
739        if(node == NULL)
740        {
741                err("NULL detect");
742                return;
743        }
744
745        cmd.msg[0] = 0xE0;
746        cmd.msg[1] = 0x00;
747        cmd.msg[2] = 0x00;
748        cmd.msg_len = 3;
749
750        debug(200, "DISEQC Reset (%s)", node->feshortname);
751        fediseqcsendmastercmd(node, &cmd, 100);
752}
753
754void fesdiseqcstandby(struct dvbdev* node)
755{
756        struct dvb_diseqc_master_cmd cmd = {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 0};
757       
758        if(node == NULL)
759        {
760                err("NULL detect");
761                return;
762        }
763       
764        cmd.msg[0] = 0xE0;
765        cmd.msg[1] = 0x00;
766        cmd.msg[2] = 0x02;
767        cmd.msg_len = 3;
768
769        debug(200, "DISEQC Standby (%s)", node->feshortname);
770        fediseqcsendmastercmd(node, &cmd, 100);
771}
772
773void fediseqcrotor(struct dvbdev* node, struct transponder* tpnode, int pos, int flag)
774{
775        int orbitalpos = 0;
776        fe_sec_voltage_t oldvolt = 0;
777        fe_sec_tone_mode_t oldtone = 0;
778        struct dvb_diseqc_master_cmd cmd = {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 0};
779       
780        if(node == NULL)
781        {
782                err("NULL detect");
783                return;
784        }
785       
786        fesdiseqcpoweron(node);
787       
788        oldvolt = node->feaktvolt;
789        oldtone = node->feakttone;
790
791        if(tpnode == NULL)
792                orbitalpos = 0;
793        else
794                orbitalpos = tpnode->orbitalpos;
795       
796        //float speed13V = 1.5; //1.5 Grad pro sec
797        float speed18V = 1; //2.4 Grad pro sek
798        float degreesmov, waittime;
799       
800        switch(flag)
801        {
802                case 0: //stop move
803                        cmd.msg[0] = 0xE0; cmd.msg[1] = 0x31; cmd.msg[2] = 0x60; cmd.msg_len = 3;
804                        debug(200, "DISEQC Rotorpos stop move (%s)", node->feshortname);
805                        break;
806                case 1: //disable limits
807                        cmd.msg[0] = 0xE0; cmd.msg[1] = 0x31; cmd.msg[2] = 0x63; cmd.msg_len = 3;
808                        debug(200, "DISEQC Rotorpos disable limits (%s)", node->feshortname);
809                        break;
810                case 2: //enable limits
811                        cmd.msg[0] = 0xE0; cmd.msg[1] = 0x31; cmd.msg[2] = 0x6A; cmd.msg[3] = 0x00; cmd.msg_len = 4;
812                        debug(200, "DISEQC Rotorpos enable limits (%s)", node->feshortname);
813                        break;
814                case 3: //set east limit
815                        cmd.msg[0] = 0xE0; cmd.msg[1] = 0x31; cmd.msg[2] = 0x66; cmd.msg_len = 3;
816                        debug(200, "DISEQC Rotorpos set east limit (%s)", node->feshortname);
817                        break;
818                case 4: //set west limit
819                        cmd.msg[0] = 0xE0; cmd.msg[1] = 0x31; cmd.msg[2] = 0x67; cmd.msg_len = 3;
820                        debug(200, "DISEQC Rotorpos set west limit (%s)", node->feshortname);
821                        break;
822                case 5: //move east cont.
823                        cmd.msg[0] = 0xE0; cmd.msg[1] = 0x31; cmd.msg[2] = 0x68; cmd.msg[3] = 0x00; cmd.msg_len = 4;
824                        debug(200, "DISEQC Rotorpos move east cont. (%s)", node->feshortname);
825                        break;
826                case 6: //move west cont.
827                        cmd.msg[0] = 0xE0; cmd.msg[1] = 0x31; cmd.msg[2] = 0x69; cmd.msg[3] = 0x00; cmd.msg_len = 4;
828                        debug(200, "DISEQC Rotorpos move west cont. (%s)", node->feshortname);
829                        break;
830                case 7: //store pos
831                        cmd.msg[0] = 0xE0; cmd.msg[1] = 0x31; cmd.msg[2] = 0x6A; cmd.msg[3] = pos; cmd.msg_len = 4;
832                        debug(200, "DISEQC Rotorpos store pos=%d (%s)", pos, node->feshortname);
833                        break;
834                case 8: //goto pos
835                        cmd.msg[0] = 0xE0; cmd.msg[1] = 0x31; cmd.msg[2] = 0x6B; cmd.msg[3] = pos; cmd.msg_len = 4;
836                        debug(200, "DISEQC Rotorpos goto pos=%d (%s)", pos, node->feshortname);
837                        break;
838                case 9: //step xx pos east
839                        cmd.msg[0] = 0xE0; cmd.msg[1] = 0x31; cmd.msg[2] = 0x68; cmd.msg[3] = 256 - pos; cmd.msg_len = 4;
840                        debug(200, "DISEQC Rotorpos step east pos=%d (%s)", pos, node->feshortname);
841                        break;
842                case 10: //step xx pos west
843                        cmd.msg[0] = 0xE0; cmd.msg[1] = 0x31; cmd.msg[2] = 0x69; cmd.msg[3] = 256 - pos; cmd.msg_len = 4;
844                        debug(200, "DISEQC Rotorpos step west pos=%d (%s)", pos, node->feshortname);
845                        break;
846                case 11: //goto xx
847                        cmd.msg[0] = 0xE0; cmd.msg[1] = 0x31; cmd.msg[2] = 0x6E; cmd.msg[3] = (pos >> 8) & 0xff; cmd.msg[4] = pos & 0xff; cmd.msg_len = 5;
848                        debug(200, "DISEQC Rotorpos goto xx pos=%d (%s)", pos, node->feshortname);
849                        break;
850        }
851
852        if(flag >= 0 && flag < 7)
853        {
854                fesetvoltage(node, SEC_VOLTAGE_18, 15);
855                fesettone(node, SEC_TONE_OFF, 15);
856                fediseqcsendmastercmd(node, &cmd, 100);
857        }
858
859        if((flag == 7 || flag == 9 || flag == 10) && pos != 0)
860        {
861                fesetvoltage(node, SEC_VOLTAGE_18, 15);
862                fesettone(node, SEC_TONE_OFF, 15);
863                fediseqcsendmastercmd(node, &cmd, 100);
864        }
865
866        if((flag == 8 || flag == 11) && (orbitalpos == 0 || status.rotoroldorbitalpos == 0 || orbitalpos != status.rotoroldorbitalpos))
867        {
868                fesetvoltage(node, SEC_VOLTAGE_18, 15);
869                fesettone(node, SEC_TONE_OFF, 15);
870                fediseqcsendmastercmd(node, &cmd, 100);
871
872                if(status.rotoroldorbitalpos == 0 || orbitalpos == 0)
873                        waittime = 15;
874                else
875                {
876                        degreesmov = abs(orbitalpos - status.rotoroldorbitalpos) / 10;
877                        waittime = (int)ceil((float)degreesmov / (float)speed18V);
878                }
879
880                status.rotoroldorbitalpos = orbitalpos;
881                sleep(waittime);
882        }
883       
884        fesetvoltage(node, oldvolt, 15);
885        fesettone(node, oldtone, 15);
886}
887
888void fesetunicable(struct dvbdev* node)
889{
890        int unicabletune = 0;
891        char* tmpstr = NULL;
892        struct dvb_diseqc_master_cmd cmd = {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 0};
893
894        if(node == NULL)
895        {
896                err("NULL detect");
897                return;
898        }
899
900        tmpstr = ostrcat(node->feshortname, "_lnb_satcr", 0, 0);
901        int satcr = getconfigint(tmpstr, node->feaktnr) - 1;
902        if(satcr < 0) satcr = 0;
903        free(tmpstr); tmpstr = NULL;
904
905        tmpstr = ostrcat(node->feshortname, "_diseqc", 0, 0);
906        int aktdiseqc = getconfigint(tmpstr, node->feaktnr);
907        if(aktdiseqc < 1) aktdiseqc = 1;
908        free(tmpstr); tmpstr = NULL;
909
910        unicabletune |= ((satcr & 0x7) << 13);
911        unicabletune |= (((aktdiseqc - 1) & 0x1) << 12);
912        unicabletune |= (((!node->feaktpolarization) & 0x1) << 11);
913        unicabletune |= ((node->feaktband & 0x1) << 10);
914        unicabletune |= ((node->feloffrequency / 1000) & 0x3ff);
915
916        debug(200, "unicabletune %04X", unicabletune);
917       
918        if(status.firstunicablewait == 0)
919        {
920                status.firstunicablewait = getconfigint("firstunicablewait", NULL);
921                if(status.firstunicablewait == 0)
922                        status.firstunicablewait = 1000;
923        }               
924       
925        if(status.firstunicablewait > 0)
926        {
927                usleep(status.firstunicablewait * 1000);
928                status.firstunicablewait = -1;
929        }
930       
931        fesetvoltage(node, SEC_VOLTAGE_13, 15);
932        fesetvoltage(node, SEC_VOLTAGE_18, 15);
933        fesettone(node, SEC_TONE_OFF, 15);
934
935        //feunicable
936        //byte1 (bit 7/6/5) -> satcr number
937        //byte1 (bit 4/3/2) -> lnb number
938        //byte1 (bit 1/0) -> frequ
939        //byte0 -> frequ
940       
941        cmd.msg[0] = 0xE0;
942        cmd.msg[1] = 0x10;
943        cmd.msg[2] = 0x5A;
944        cmd.msg[3] = (unicabletune >> 8) & 0xff;
945        cmd.msg[4] = unicabletune & 0xff;
946        cmd.msg_len = 5;
947
948        debug(200, "send diseqc unicable cmd (%s)", node->feshortname);
949        fediseqcsendmastercmd(node, &cmd, 100);
950        fesetvoltage(node, SEC_VOLTAGE_13, 15);
951}
952
953void fediseqcset(struct dvbdev* node, struct transponder* tpnode)
954{
955        char* tmpstr = NULL;
956        int toneburst = 0, cmdorder = 0, input = 0, uinput = 0, diseqmode = 0, rotorpos = 0, latpos = 0, longpos = 0;
957        float latitude = 0, longitude = 0;
958        fe_sec_mini_cmd_t mini = -1;
959        struct dvb_diseqc_master_cmd cmd = {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 0};
960        struct dvb_diseqc_master_cmd ucmd = {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 0};
961       
962        if(node == NULL) return;
963       
964        tmpstr = ostrcat(node->feshortname, "_diseqc_committedcmd", 0, 0);
965        input = getconfigint(tmpstr, node->feaktnr);
966        free(tmpstr); tmpstr = NULL;
967        tmpstr = ostrcat(node->feshortname, "_diseqc_uncommittedcmd", 0, 0);
968        uinput = getconfigint(tmpstr, node->feaktnr);
969        free(tmpstr); tmpstr = NULL;
970        tmpstr = ostrcat(node->feshortname, "_diseqc_mode", 0, 0);
971        diseqmode = getconfigint(tmpstr, node->feaktnr);
972        free(tmpstr); tmpstr = NULL;
973        tmpstr = ostrcat(node->feshortname, "_diseqc_cmdorder", 0, 0);
974        cmdorder = getconfigint(tmpstr, node->feaktnr);
975        free(tmpstr); tmpstr = NULL;
976        tmpstr = ostrcat(node->feshortname, "_diseqc_toneburst", 0, 0);
977        toneburst = getconfigint(tmpstr, node->feaktnr);
978        free(tmpstr); tmpstr = NULL;
979        tmpstr = ostrcat(node->feshortname, "_diseqc_rotorpos", 0, 0);
980        rotorpos = getconfigint(tmpstr, node->feaktnr);
981        free(tmpstr); tmpstr = NULL;
982       
983        latitude = getconfigfloat("latitude", NULL);
984        longitude = getconfigfloat("longitude", NULL);
985        latpos = getconfigint("latpos", NULL);
986        longpos = getconfigint("longpos", NULL);
987
988        tmpstr = ostrcat(node->feshortname, "_diseqc", 0, 0);
989        int aktdiseqc = getconfigint(tmpstr, node->feaktnr);
990        if(aktdiseqc < 1) aktdiseqc = 1;
991        free(tmpstr); tmpstr = NULL;
992
993        debug(200, "set diseqc: number=%d, band=%d, pol=%d, diseqmode=%d, input=%d, uinput=%d, cmdorder=%d, toneburst=%d (%s)", aktdiseqc, node->feaktband, node->feaktpolarization, diseqmode, input, uinput, cmdorder, toneburst, node->feshortname);
994         
995        switch(toneburst)
996        {
997                case 1: mini = SEC_MINI_A; break;
998                case 2: mini = SEC_MINI_B; break;
999        }
1000       
1001        if(diseqmode == 100) // Tonburst A/B
1002        {
1003                debug(200, "set diseqc: Tonburst A/B (%s)", node->feshortname);
1004                if(mini == -1)
1005                        mini = (aktdiseqc - 1) % 2 ? SEC_MINI_B : SEC_MINI_A;
1006                fediseqcsendburst(node, mini, 15);
1007                return;
1008        }
1009               
1010        if(diseqmode == 0 || diseqmode == 1) // Diseqc 1.0 + 1.1
1011        {
1012                debug(200, "set committed switch (%s)", node->feshortname);
1013                fesdiseqcpoweron(node);
1014                cmd.msg[0] = 0xE0;
1015                cmd.msg[1] = 0x10;
1016                cmd.msg[2] = 0x38;
1017
1018                if(input == 0)
1019                        cmd.msg[3] = 0xF0 | ((((aktdiseqc - 1) * 4) & 0x0F) | (node->feaktband ? 1 : 0) | (node->feaktpolarization ? 0 : 2));
1020                else
1021                        cmd.msg[3] = 0xF0 + ((input - 1) & 0x0F);
1022
1023                cmd.msg_len = 4;
1024        }
1025
1026        if(diseqmode == 1) // Diseqc 1.1
1027        {
1028                if(uinput > 0)
1029                {
1030                        debug(200, "set uncommitted switch (%s)", node->feshortname);
1031                        fesdiseqcpoweron(node);
1032                        ucmd.msg[0] = 0xE0;
1033                        ucmd.msg[1] = 0x10;
1034                        ucmd.msg[2] = 0x39;
1035                        ucmd.msg[3] = 0xF0 + ((uinput - 1) & 0x0F);
1036                        ucmd.msg_len = 4;
1037                }
1038        }
1039                 
1040        switch(cmdorder)
1041        {
1042                case 1:
1043                        if(mini != -1) fediseqcsendburst(node, mini, 15);
1044                        fediseqcsendmastercmd(node, &cmd, 100);
1045                        break;
1046                case 2:
1047                        fediseqcsendmastercmd(node, &cmd, 100);
1048                        if(uinput > 0) fediseqcsendmastercmd(node, &ucmd, 100);
1049                        if(mini != -1) fediseqcsendburst(node, mini, 15);
1050                        break;
1051                case 3:
1052                        if(mini != -1) fediseqcsendburst(node, mini, 15);
1053                        fediseqcsendmastercmd(node, &cmd, 100);
1054                        if(uinput > 0) fediseqcsendmastercmd(node, &ucmd, 100);
1055                        break;
1056                case 4:
1057                        if(uinput > 0) fediseqcsendmastercmd(node, &ucmd, 100);
1058                        fediseqcsendmastercmd(node, &cmd, 100);
1059                        if(mini != -1) fediseqcsendburst(node, mini, 15);
1060                        break;
1061                case 5:
1062                        if(mini != -1) fediseqcsendburst(node, mini, 15);
1063                        if(uinput > 0) fediseqcsendmastercmd(node, &ucmd, 100);
1064                        fediseqcsendmastercmd(node, &cmd, 100);
1065                        break;
1066                default:
1067                        fediseqcsendmastercmd(node, &cmd, 100);
1068                        if(mini != -1) fediseqcsendburst(node, mini, 15);
1069                        break;
1070        }
1071       
1072        if(diseqmode == 2) // Diseqc 1.2
1073        {
1074                fediseqcrotor(node, tpnode, rotorpos, 8);
1075        }
1076       
1077        if(diseqmode == 3) // Diseqc 1.3 (USALS)
1078        {
1079                double orbitalpos = tpnode->orbitalpos / 10.00;
1080
1081                if(latpos == 1) // south
1082                        latitude = -latitude;
1083
1084                if(longpos == 1) // west
1085                        longitude = 360 - longitude;
1086
1087                double satHourAngle = calcSatHourangle(orbitalpos, latitude, longitude);
1088                int gotoXTable[10] = {0x00, 0x02, 0x03, 0x05, 0x06, 0x08, 0x0A, 0x0B, 0x0D, 0x0E};
1089
1090                if(latitude >= 0) // Northern Hemisphere
1091                {
1092                        int tmp = (int)round(fabs(180 - satHourAngle) * 10.0);
1093                        rotorpos = (tmp / 10) * 0x10 + gotoXTable[tmp % 10];
1094
1095                        if(satHourAngle < 180) // the east
1096                                rotorpos |= 0xE000;
1097                        else // west
1098                                rotorpos |= 0xD000;
1099                }
1100                else // Southern Hemisphere
1101                {
1102                        if(satHourAngle < 180) // the east
1103                        {
1104                                int tmp = (int)round(fabs(satHourAngle) * 10.0);
1105                                rotorpos = (tmp / 10) * 0x10 + gotoXTable[tmp % 10];
1106                                rotorpos |= 0xD000;
1107                        }
1108                        else // west
1109                        {
1110                                int tmp = (int)round(fabs(360 - satHourAngle) * 10.0);
1111                                rotorpos = (tmp / 10) * 0x10 + gotoXTable[tmp % 10];
1112                                rotorpos |= 0xE000;
1113                        }
1114                }
1115                debug(200, "orbitalpos=%f, latitude=%f, longitude=%f, rotorpos=%04x", orbitalpos, latitude, longitude, rotorpos);
1116
1117                fediseqcrotor(node, tpnode, rotorpos, 11);
1118        }
1119}
1120
1121void feset(struct dvbdev* node, struct transponder* tpnode)
1122{
1123        int voltagemode = 0, tonemode = 0;
1124        fe_sec_tone_mode_t tone;
1125        fe_sec_voltage_t volt;
1126        struct dvbdev* dvbnode = dvbdev;
1127        char* tmpstr = NULL;
1128
1129        if(node == NULL)
1130        {
1131                err("NULL detect");
1132                return;
1133        }
1134
1135        // set volage off from other unused frontend
1136        while(dvbnode != NULL)
1137        {
1138                if(dvbnode->type != FRONTENDDEV) break;
1139                if(dvbnode->type == FRONTENDDEV && dvbnode != node && dvbnode->felock == 0 && dvbnode != status.aktservice->fedev)
1140                {
1141                        fesetvoltage(dvbnode, SEC_VOLTAGE_OFF, 0);
1142                }
1143                dvbnode = dvbnode->next;
1144        }
1145
1146        calclof(node, tpnode, NULL, 0);
1147
1148        tmpstr = ostrcat(node->feshortname, "lnb_voltagemode", 0, 0);
1149        voltagemode = getconfigint(tmpstr, node->feaktnr);
1150        free(tmpstr); tmpstr = NULL;
1151        switch(voltagemode)
1152        {
1153                case 1: volt = SEC_VOLTAGE_13; break;
1154                case 2: volt = SEC_VOLTAGE_18; break;
1155                default: volt = node->feaktpolarization ? SEC_VOLTAGE_13 : SEC_VOLTAGE_18;
1156                         if(node->feunicable == 1) volt = SEC_VOLTAGE_13;
1157        }
1158        fesetvoltage(node, volt, 15);
1159
1160        tmpstr = ostrcat(node->feshortname, "_diseqc", 0, 0);
1161        if(getconfigint(tmpstr, node->feaktnr) == 0 || node->feunicable == 1)
1162        {
1163                debug(200, "don't use diseqc");
1164        }
1165        else
1166        {
1167                fesettone(node, SEC_TONE_OFF, 15);
1168                fediseqcset(node, tpnode);
1169        }
1170        free(tmpstr); tmpstr = NULL;
1171
1172        tmpstr = ostrcat(node->feshortname, "_lnb_tonemode", 0, 0);
1173        tonemode = getconfigint(tmpstr, node->feaktnr);
1174        free(tmpstr); tmpstr = NULL;
1175        switch(tonemode)
1176        {
1177                case 1: tone = SEC_TONE_ON; break;
1178                case 2: tone = SEC_TONE_OFF; break;
1179                default: tone = node->feaktband ? SEC_TONE_ON : SEC_TONE_OFF;
1180                         if(node->feunicable == 1) tone = SEC_TONE_OFF;
1181        }
1182        fesettone(node, tone, 15);
1183}
1184
1185void fediscard(struct dvbdev* node)
1186{
1187        struct dvb_frontend_event ev;
1188        int count = 0;
1189
1190        if(node == NULL)
1191        {
1192                err("NULL detect");
1193                return;
1194        }
1195
1196        /* discard stale QPSK events */
1197        while(count < 20)
1198        {
1199                count++;
1200                if(ioctl(node->fd, FE_GET_EVENT, &ev) == -1)
1201                        break;
1202        }
1203}
1204
1205uint16_t fereadsnr(struct dvbdev* node)
1206{
1207        uint16_t snr = 0;
1208        if(node == NULL)
1209        {
1210                err("NULL detect");
1211                return 0;
1212        }
1213       
1214#ifdef ARM
1215        int signalquality = 0;
1216        int signalqualitydb = 0;
1217       
1218        struct dtv_property prop[1];
1219        prop[0].cmd = DTV_STAT_CNR;
1220        struct dtv_properties props;
1221        props.props = prop;
1222        props.num = 1;
1223       
1224        if(ioctl(node->fd, FE_GET_PROPERTY,  &props) < 0)
1225        {
1226                perr("FE_GET_PROPERTY");
1227        }
1228        for(unsigned int i=0; i<prop[0].u.st.len; i++)
1229        {
1230                if (prop[0].u.st.stat[i].scale == FE_SCALE_DECIBEL)
1231                        signalqualitydb = prop[0].u.st.stat[i].svalue / 10;
1232                else if (prop[0].u.st.stat[i].scale == FE_SCALE_RELATIVE)
1233                        signalquality = prop[0].u.st.stat[i].svalue;
1234        }
1235        if(!signalquality && !signalqualitydb)
1236        {
1237                int ret = 0x12345678;
1238                int sat_max = 1600; // we assume a max of 16db here
1239                int ter_max = 2900; // we assume a max of 29db here
1240                int cab_max = 4200; // we assume a max of 42db here
1241                //int atsc_max = 4200; // we assume a max of 42db here
1242               
1243                ioctl(node->fd, FE_READ_SNR, &snr);
1244                               
1245                if(ostrstr(node->feinfo->name, "Si2166B") != NULL)
1246                        ret = (snr * 240) >> 8;
1247               
1248                signalqualitydb = ret;
1249                if (ret == 0x12345678) // no snr db calculation avail.. return untouched snr value..
1250                {
1251                        signalquality = snr;
1252                }
1253                if(node->feinfo->type == FE_QPSK)
1254                        signalquality = (ret >= sat_max ? 65536 : ret * 65536 / sat_max);
1255                else if(node->feinfo->type == FE_QAM)
1256                        signalquality = (ret >= cab_max ? 65536 : ret * 65536 / cab_max);
1257                else if(node->feinfo->type == FE_OFDM)
1258                        signalquality = (ret >= ter_max ? 65536 : ret * 65536 / ter_max);
1259        }
1260        debug(200, "frontend snr = %02x", (signalquality * 100) / 0xffff);
1261        return signalquality;
1262#else   
1263        ioctl(node->fd, FE_READ_SNR, &snr);
1264        debug(200, "frontend snr = %02x", (snr * 100) / 0xffff);
1265        return snr;
1266#endif
1267       
1268}
1269
1270uint16_t fereadsignalstrength(struct dvbdev* node)
1271{
1272        uint16_t signal = 0;
1273
1274        if(node == NULL)
1275        {
1276                err("NULL detect");
1277                return 0;
1278        }
1279       
1280#ifdef ARM             
1281        struct dtv_property prop[1];
1282        prop[0].cmd = DTV_STAT_SIGNAL_STRENGTH;
1283        struct dtv_properties props;
1284        props.props = prop;
1285        props.num = 1;
1286        ioctl(node->fd, FE_GET_PROPERTY, &props);
1287        for(unsigned int i=0; i<prop[0].u.st.len; i++)
1288        {
1289                if (prop[0].u.st.stat[i].scale == FE_SCALE_RELATIVE)
1290                        signal = prop[0].u.st.stat[i].uvalue;
1291        }
1292        if (!signal)
1293        {
1294                ioctl(node->fd, FE_READ_SIGNAL_STRENGTH, &signal);
1295                if(ostrstr(node->feinfo->name, "Si2166B") != NULL)
1296                        signal = signal * 1000;
1297                debug(200, "frontend signal = %02x", (signal * 100) / 0xffff);
1298        }
1299        return signal;
1300#else   
1301        ioctl(node->fd, FE_READ_SIGNAL_STRENGTH, &signal);
1302        debug(200, "frontend signal = %02x", (signal * 100) / 0xffff);
1303        return signal;
1304#endif
1305}
1306
1307uint32_t fereadber(struct dvbdev* node)
1308{
1309        uint32_t ber = 0;
1310
1311        if(node == NULL)
1312        {
1313                err("NULL detect");
1314                return 0;
1315        }
1316
1317        ioctl(node->fd, FE_READ_BER, &ber);
1318        debug(200, "frontend ber = %02x", ber);
1319        return ber;
1320}
1321
1322uint32_t fereaduncorrectedblocks(struct dvbdev* node)
1323{
1324        uint32_t unc = 0;
1325
1326        if(node == NULL)
1327        {
1328                err("NULL detect");
1329                return 0;
1330        }
1331
1332        ioctl(node->fd, FE_READ_UNCORRECTED_BLOCKS, &unc);
1333        debug(200, "frontend unc = %02x", unc);
1334        return unc;
1335}
1336
1337fe_status_t fereadstatus(struct dvbdev* node)
1338{
1339        fe_status_t status;
1340
1341        if(node == NULL)
1342        {
1343                err("NULL detect");
1344                return -1;
1345        }
1346
1347        if(ioctl(node->fd, FE_READ_STATUS, &status) == -1)
1348                perr("FE_READ_STATUS");
1349
1350        debug(200, "frontend status = %02x", status);
1351        if(status & FE_HAS_LOCK) debug(200, "frontend = FE_HAS_LOCK");
1352        if(status & FE_HAS_SIGNAL) debug(200, "frontend = FE_HAS_SIGNAL");
1353        if(status & FE_HAS_CARRIER) debug(200, "frontend = FE_HAS_CARRIER");
1354        if(status & FE_HAS_VITERBI) debug(200, "frontend = FE_HAS_VITERBI");
1355        if(status & FE_HAS_SYNC) debug(200, "frontend = FE_HAS_SYNC");
1356        if(status & FE_TIMEDOUT) debug(200, "frontend = FE_TIMEDOUT");
1357        if(status & FE_REINIT) debug(200, "frontend = FE_REINIT");
1358
1359        return status;
1360}
1361
1362int fetunedvbs(struct dvbdev* node, struct transponder* tpnode)
1363{
1364        if(node == NULL || tpnode == NULL)
1365        {
1366                err("NULL detect");
1367                return 1;
1368        }
1369       
1370        if(node->feunicable == 1)
1371        {
1372                fesetunicable(node);
1373                char* tmpstr = ostrcat(node->feshortname, "_lnb_satcrfrequ", 0, 0);
1374                node->feloffrequency = getconfigint(tmpstr, node->feaktnr) * 1000;
1375                free(tmpstr); tmpstr = NULL;
1376        }
1377
1378#if DVB_API_VERSION >= 5
1379        struct dtv_property p[10];
1380        struct dtv_properties cmdseq;
1381        cmdseq.props = p;
1382
1383        //convert transponderlist for dvbapi5
1384        int system = tpnode->system;
1385        switch(system)
1386        {
1387                case 0: system = SYS_DVBS; break;
1388                case 1: system = SYS_DVBS2; break;
1389                default: system = SYS_DVBS; break;
1390        }
1391
1392        int fec = tpnode->fec;
1393        switch(fec)
1394        {
1395                case 0: fec = FEC_AUTO; break;
1396                case 1: fec = FEC_1_2; break;
1397                case 2: fec = FEC_2_3; break;
1398                case 3: fec = FEC_3_4; break;
1399                case 4: fec = FEC_5_6; break;
1400                case 5: fec = FEC_7_8; break;
1401                case 6: fec = FEC_8_9; break;
1402                case 7: fec = FEC_3_5; break;
1403                case 8: fec = FEC_4_5; break;
1404                case 9: fec = FEC_9_10; break;
1405                case 15: fec = FEC_NONE; break;
1406                default: fec = FEC_AUTO; break;
1407        }
1408       
1409        int pilot = tpnode->pilot;
1410        switch(pilot)
1411        {
1412                case 0: pilot = PILOT_OFF; break;
1413                case 1: pilot = PILOT_ON; break;
1414                case 2: pilot = PILOT_AUTO; break;
1415                default: pilot = PILOT_AUTO; break;
1416        }
1417
1418        int rolloff = tpnode->rolloff;
1419        switch(rolloff)
1420        {
1421                case 0: rolloff = ROLLOFF_35; break;
1422                case 1: rolloff = ROLLOFF_25; break;
1423                case 2: rolloff = ROLLOFF_20; break;
1424                default: rolloff = ROLLOFF_35; break;
1425        }
1426
1427        int modulation = tpnode->modulation;
1428        switch(modulation)
1429        {
1430                case 0: modulation = QPSK; break;
1431                case 1: modulation = QPSK; break;
1432                case 2: modulation = PSK_8; break;
1433                case 3: modulation = QAM_16; break;
1434                default: modulation = QPSK; break;
1435        }
1436
1437        p[0].cmd = DTV_CLEAR;
1438        p[1].cmd = DTV_DELIVERY_SYSTEM, p[1].u.data = system;
1439        p[2].cmd = DTV_FREQUENCY,       p[2].u.data = node->feloffrequency;
1440        p[3].cmd = DTV_MODULATION,      p[3].u.data = modulation;
1441        p[4].cmd = DTV_SYMBOL_RATE,     p[4].u.data = tpnode->symbolrate;
1442        p[5].cmd = DTV_INNER_FEC,       p[5].u.data = fec;
1443        p[6].cmd = DTV_INVERSION,       p[6].u.data = (fe_spectral_inversion_t) tpnode->inversion;
1444        if(system == SYS_DVBS2)
1445        {
1446                p[7].cmd = DTV_ROLLOFF,         p[7].u.data = rolloff;
1447                p[8].cmd = DTV_PILOT,           p[8].u.data = pilot;
1448                p[9].cmd = DTV_TUNE;
1449                cmdseq.num = 10;
1450        }
1451        else
1452        {
1453                p[7].cmd = DTV_TUNE;
1454                cmdseq.num = 8;
1455        }
1456
1457        debug(200, "new dvbapi: frequ=%d, inversion=%d, pilot=%d, rolloff=%d, fec=%d, sr=%d, modulation=%d, system=%d (%s)", node->feloffrequency, tpnode->inversion, pilot, rolloff, fec, tpnode->symbolrate, modulation, system, node->feshortname);
1458#else
1459        struct dvb_frontend_parameters tuneto;
1460        fe_spectral_inversion_t inversion = tpnode->inversion;
1461
1462        //convert transponderlist for dvbapi3
1463        int fec = tpnode->fec;
1464        if(tpnode->system == 1)
1465        {
1466                if(tpnode->modulation == 1) fec = fec + 9;
1467                if(tpnode->modulation == 2) fec = fec + 18;
1468        }
1469
1470        inversion |= (tpnode->rolloff << 2) | inversion; // use bit 2..3 of inversion for rolloff
1471        inversion |= (tpnode->pilot << 4) | inversion; // use bit 4..5 of inversion for pilot
1472
1473        tuneto.frequency = node->feloffrequency;
1474        tuneto.inversion = inversion;
1475        tuneto.u.qpsk.symbol_rate = tpnode->symbolrate;
1476        tuneto.u.qpsk.fec_inner = fec;
1477
1478        debug(200, "old dvbapi: frequ=%d, inversion=%d, pilot=%d, rolloff=%d, fec=%d, sr=%d modulation=%d, system=%d (%s)", node->feloffrequency, inversion, tpnode->pilot, tpnode->rolloff, fec, tpnode->symbolrate, tpnode->modulation, tpnode->system, node->feshortname);
1479#endif
1480
1481        fediscard(node);
1482
1483#if DVB_API_VERSION >= 5
1484        if((ioctl(node->fd, FE_SET_PROPERTY, &cmdseq)) == -1)
1485        {
1486                perr("FE_SET_PROPERTY");
1487                return 1;
1488        }
1489#else
1490        if(ioctl(node->fd, FE_SET_FRONTEND, &tuneto) == -1)
1491        {
1492                perr("FE_SET_FRONTEND");
1493                return 1;
1494        }
1495#endif
1496
1497        return 0;
1498}
1499
1500int fetunedvbc(struct dvbdev* node, struct transponder* tpnode)
1501{
1502        if(node == NULL || tpnode == NULL)
1503        {
1504                err("NULL detect");
1505                return 1;
1506        }
1507       
1508        int fec = tpnode->fec;
1509        switch(fec)
1510        {
1511                case 0: fec = FEC_AUTO; break;
1512                case 1: fec = FEC_1_2; break;
1513                case 2: fec = FEC_2_3; break;
1514                case 3: fec = FEC_3_4; break;
1515                case 4: fec = FEC_5_6; break;
1516                case 5: fec = FEC_7_8; break;
1517                case 6: fec = FEC_8_9; break;
1518                case 7: fec = FEC_3_5; break;
1519                case 8: fec = FEC_4_5; break;
1520                case 9: fec = FEC_9_10; break;
1521                case 15: fec = FEC_NONE; break;
1522                default: fec = FEC_AUTO; break;
1523        }
1524
1525        int modulation = tpnode->modulation;
1526        switch(modulation)
1527        {
1528                case 0: modulation = QAM_AUTO; break;
1529                case 1: modulation = QAM_16; break;
1530                case 2: modulation = QAM_32; break;
1531                case 3: modulation = QAM_64; break;
1532                case 4: modulation = QAM_128; break;
1533                case 5: modulation = QAM_256; break;
1534                default: modulation = QAM_AUTO; break;
1535        }
1536
1537#if DVB_API_VERSION >= 5
1538        struct dtv_property p[8];
1539        struct dtv_properties cmdseq;
1540        cmdseq.props = p;
1541       
1542        int system = tpnode->system;
1543       
1544#if DREAMBOX
1545        switch(system)
1546        {
1547                //case 0: system = SYS_DVBC_ANNEX_A; break;
1548                //case 1: system = SYS_DVBC_ANNEX_C; break;
1549                //default: system = SYS_DVBC_ANNEX_A; break;
1550                case 0: system = 1; break;
1551                case 1: system = 18; break;
1552                default: system = 1; break;
1553        }
1554#endif
1555
1556        p[0].cmd = DTV_CLEAR;
1557        p[1].cmd = DTV_DELIVERY_SYSTEM, p[1].u.data = system;
1558        p[2].cmd = DTV_FREQUENCY,       p[2].u.data = tpnode->frequency;
1559        p[3].cmd = DTV_MODULATION,      p[3].u.data = modulation;
1560        p[4].cmd = DTV_SYMBOL_RATE,     p[4].u.data = tpnode->symbolrate;
1561        p[5].cmd = DTV_INVERSION,       p[5].u.data = (fe_spectral_inversion_t) tpnode->inversion;
1562        p[6].cmd = DTV_INNER_FEC,       p[6].u.data = fec;
1563        p[7].cmd = DTV_TUNE;
1564        cmdseq.num = 8;
1565
1566        debug(200, "new dvbapi: frequ=%d, inversion=%d, fec=%d, sr=%d, modulation=%d, system=%d (%s)", tpnode->frequency, tpnode->inversion, fec, tpnode->symbolrate, modulation, tpnode->system, node->feshortname);
1567#else
1568        struct dvb_frontend_parameters tuneto;
1569
1570        tuneto.frequency = tpnode->frequency;
1571        tuneto.inversion = tpnode->inversion;
1572        tuneto.u.qam.symbol_rate = tpnode->symbolrate;
1573        tuneto.u.qam.fec_inner = tpnode->fec;
1574        tuneto.u.qam.modulation = tpnode->modulation;
1575
1576        debug(200, "old dvbapi: frequ=%d, inversion=%d, fec=%d, sr=%d, modulation=%d (%s)", tpnode->frequency, tpnode->inversion, fec, tpnode->symbolrate, modulation, node->feshortname);
1577#endif
1578
1579        fediscard(node);
1580
1581#if DVB_API_VERSION >= 5
1582        if((ioctl(node->fd, FE_SET_PROPERTY, &cmdseq)) == -1)
1583        {
1584                perr("FE_SET_PROPERTY");
1585                return 1;
1586        }
1587#else
1588        if(ioctl(node->fd, FE_SET_FRONTEND, &tuneto) == -1)
1589        {
1590                perr("FE_SET_FRONTEND");
1591                return 1;
1592        }
1593#endif
1594
1595        return 0;
1596}
1597
1598int fetunedvbt(struct dvbdev* node, struct transponder* tpnode)
1599{
1600        if(node == NULL || tpnode == NULL)
1601        {
1602                err("NULL detect");
1603                return 1;
1604        }
1605        debug(200, "transponder:frequ=%d, inversion=%d, bandwidth=%d, hp=%d, lp=%d, modulation=%d transmission=%d guardinterval=%d hierarchy=%d system=%d (%s)", tpnode->frequency, tpnode->inversion, tpnode->symbolrate, tpnode->fec, tpnode->polarization, tpnode->modulation, tpnode->pilot, tpnode->rolloff, tpnode->system, tpnode->system, node->feshortname);
1606        int hp = tpnode->fec; //fec = hp on DVBT
1607        switch(hp)
1608        {
1609                case 0: hp = FEC_1_2; break;
1610                case 1: hp = FEC_2_3; break;
1611                case 2: hp = FEC_3_4; break;
1612                case 3: hp = FEC_5_6; break;
1613                case 4: hp = FEC_7_8; break;
1614                case 5: hp = FEC_AUTO; break;
1615                default: hp = FEC_AUTO; break;
1616        }
1617
1618        int lp = tpnode->polarization; //polarization = lp on DVBT
1619        switch(lp)
1620        {
1621                case 0: lp = FEC_1_2; break;
1622                case 1: lp = FEC_2_3; break;
1623                case 2: lp = FEC_3_4; break;
1624                case 3: lp = FEC_5_6; break;
1625                case 4: lp = FEC_7_8; break;
1626                case 5: lp = FEC_AUTO; break;
1627                default: lp = FEC_AUTO; break;
1628        }
1629       
1630        int modulation = tpnode->modulation;
1631        switch(modulation)
1632#if DVB_API_VERSION >= 5       
1633        {
1634                case 0: modulation = QPSK; break;
1635                case 1: modulation = QAM_16; break;
1636                case 2: modulation = QAM_32; break;
1637                case 3: modulation = QAM_64; break;
1638                case 5: modulation = QAM_128; break;
1639                case 6: modulation = QAM_256; break;
1640                case 7: modulation = QAM_AUTO; break;
1641                default: modulation = QAM_AUTO; break;
1642        }
1643#else   
1644        {
1645                case 0: modulation = QPSK; break;
1646                case 1: modulation = QAM_16; break;
1647                case 2: modulation = QAM_64; break;
1648                case 3: modulation = QAM_256; break;
1649                case 4: modulation = QAM_AUTO; break;
1650                default: modulation = QAM_AUTO; break;
1651        }
1652#endif
1653       
1654        int bandwidth = tpnode->symbolrate; //symbolrate = bandwidth on DVBT
1655        switch(bandwidth)
1656
1657#if DVB_API_VERSION >= 5       
1658        {
1659                case 0: bandwidth = 8000000; break;
1660                case 1: bandwidth = 7000000; break;
1661                case 2: bandwidth = 6000000; break;
1662                case 3: bandwidth = 5000000; break;
1663                default: bandwidth = 0; break;
1664        }
1665#else   
1666        {
1667                case 0: bandwidth = BANDWIDTH_8_MHZ; break;
1668                case 1: bandwidth = BANDWIDTH_7_MHZ; break;
1669                case 2: bandwidth = BANDWIDTH_6_MHZ; break;
1670                case 3: bandwidth = BANDWIDTH_AUTO; break;
1671                default: bandwidth = BANDWIDTH_AUTO; break;
1672        }
1673#endif
1674       
1675        int transmission = tpnode->pilot; //pilot = transmission on DVBT
1676        switch(transmission)
1677        {
1678                case 0: transmission = TRANSMISSION_MODE_2K; break;
1679                case 1: transmission = TRANSMISSION_MODE_8K; break;
1680                case 2: transmission = TRANSMISSION_MODE_AUTO; break;
1681#if defined TRANSMISSION_MODE_1K
1682                case 3: transmission = TRANSMISSION_MODE_1K; break;
1683                case 4: transmission = TRANSMISSION_MODE_16K; break;
1684                case 5: transmission = TRANSMISSION_MODE_32K; break;
1685#endif
1686                default: transmission = TRANSMISSION_MODE_AUTO; break;
1687        }
1688       
1689        int guardinterval = tpnode->rolloff; //rolloff = guardinterval on DVBT
1690        switch(guardinterval)
1691        {
1692                case 0: guardinterval = GUARD_INTERVAL_1_32; break;
1693                case 1: guardinterval = GUARD_INTERVAL_1_16; break;
1694                case 2: guardinterval = GUARD_INTERVAL_1_8; break;
1695                case 3: guardinterval = GUARD_INTERVAL_1_4; break;
1696                case 4: guardinterval = GUARD_INTERVAL_AUTO; break;
1697#if defined GUARD_INTERVAL_1_128
1698                case 5: guardinterval = GUARD_INTERVAL_1_128; break;
1699                case 6: guardinterval = GUARD_INTERVAL_19_128; break;
1700                case 7: guardinterval = GUARD_INTERVAL_19_256; break;
1701#endif
1702                default: guardinterval = GUARD_INTERVAL_AUTO; break;
1703        }
1704       
1705        int hierarchy = tpnode->system; //system = hierarchy on DVBT
1706       
1707        if(tpnode->system == 1) //system = DVB-T2 then hierarchy = HIERARCHY_AUTO
1708                hierarchy = 4;
1709       
1710        //switch(guardinterval)
1711        switch(hierarchy)
1712        {
1713                case 0: hierarchy = HIERARCHY_NONE;
1714                case 1: hierarchy = HIERARCHY_1;
1715                case 2: hierarchy = HIERARCHY_2;
1716                case 3: hierarchy = HIERARCHY_4;
1717                case 4: hierarchy = HIERARCHY_AUTO;
1718                default: hierarchy = HIERARCHY_AUTO; break;
1719        }
1720
1721#if DVB_API_VERSION >= 5
1722        struct dtv_property p[12];
1723        struct dtv_properties cmdseq;
1724        cmdseq.props = p;
1725
1726        int system = tpnode->system;
1727
1728// suchlauf geht an nemesis mit system=0
1729#if DREAMBOX
1730        switch(system)
1731        {
1732                case 0: system = SYS_DVBT; break; //3
1733                case 1: system = SYS_DVBT2; break; //16
1734                default: system = SYS_DVBT; break;
1735        }
1736#endif
1737
1738        p[0].cmd = DTV_CLEAR;
1739        p[1].cmd = DTV_DELIVERY_SYSTEM, p[1].u.data = system;
1740        p[2].cmd = DTV_FREQUENCY,       p[2].u.data = tpnode->frequency;
1741        p[3].cmd = DTV_INVERSION,       p[3].u.data = (fe_spectral_inversion_t) tpnode->inversion;
1742        p[4].cmd = DTV_BANDWIDTH_HZ, p[4].u.data = bandwidth;
1743        p[5].cmd = DTV_CODE_RATE_LP, p[5].u.data = lp;
1744        p[6].cmd = DTV_CODE_RATE_HP, p[6].u.data = hp;
1745        p[7].cmd = DTV_MODULATION, p[7].u.data = modulation;
1746        p[8].cmd = DTV_TRANSMISSION_MODE,       p[8].u.data = transmission;
1747        p[9].cmd = DTV_GUARD_INTERVAL, p[9].u.data = guardinterval;
1748        p[10].cmd = DTV_HIERARCHY, p[10].u.data = hierarchy;
1749        p[11].cmd = DTV_TUNE;
1750        cmdseq.num = 12;
1751
1752        debug(200, "new dvbapi: frequ=%d, inversion=%d, bandwidth=%d, hp=%d, lp=%d, modulation=%d transmission=%d guardinterval=%d hierarchy=%d system=%d (%s)", tpnode->frequency, tpnode->inversion, bandwidth, hp, lp, modulation, transmission, guardinterval, hierarchy, system, node->feshortname);
1753
1754
1755#else
1756        struct dvb_frontend_parameters tuneto;
1757
1758        tuneto.frequency = tpnode->frequency;
1759        tuneto.inversion = tpnode->inversion;
1760        tuneto.u.ofdm.bandwidth = bandwidth;
1761        tuneto.u.ofdm.code_rate_HP = hp;
1762        tuneto.u.ofdm.code_rate_LP = lp;
1763        tuneto.u.ofdm.constellation = modulation;
1764        tuneto.u.ofdm.transmission_mode = transmission;
1765        tuneto.u.ofdm.guard_interval = guardinterval;
1766        tuneto.u.ofdm.hierarchy_information = hierarchy;
1767
1768        debug(200, "old dvbapi: frequ=%d, inversion=%d, bandwidth=%d, hp=%d, lp=%d, modulation=%d transmission=%d guardinterval=%d hierarchy=%d system=%d (%s)", tpnode->frequency, tpnode->inversion, bandwidth, hp, lp, modulation, transmission, guardinterval, hierarchy, system, node->feshortname);
1769
1770#endif
1771
1772
1773        fediscard(node);
1774
1775#if DVB_API_VERSION >= 5
1776        if((ioctl(node->fd, FE_SET_PROPERTY, &cmdseq)) == -1)
1777        {
1778                perr("FE_SET_PROPERTY");
1779                return 1;
1780        }
1781#else
1782        if(ioctl(node->fd, FE_SET_FRONTEND, &tuneto) == -1)
1783        {
1784                perr("FE_SET_FRONTEND");
1785                return 1;
1786        }
1787#endif
1788        return 0;
1789}
1790
1791#ifdef SIMULATE
1792int tunercount = 0;
1793#endif
1794struct dvb_frontend_info* fegetinfo(struct dvbdev* node, int fd)
1795{
1796        struct dvb_frontend_info* feinfo = NULL;
1797        int tmpfd = -1;
1798
1799        if(node != NULL)
1800                tmpfd = node->fd;
1801        else
1802                tmpfd = fd;
1803
1804        feinfo = (struct dvb_frontend_info*)malloc(sizeof(struct dvb_frontend_info));
1805        if(feinfo == NULL)
1806        {
1807                err("no mem");
1808                return NULL;
1809        }
1810
1811#ifndef SIMULATE
1812        if(ioctl(tmpfd, FE_GET_INFO, feinfo) < 0)
1813        {
1814                perr("FE_GET_INFO");
1815                free(feinfo);
1816                return NULL;
1817        }
1818#else
1819        tunercount++;
1820        if(tunercount == 1)
1821        {
1822                sprintf(feinfo->name, "%s", "Conax 7500 DVB-C");
1823                feinfo->type = FE_QAM;
1824        }
1825        else
1826        {
1827                sprintf(feinfo->name, "%s", "Conax 7500 DVB-S");
1828                feinfo->type = FE_QPSK;
1829                //feinfo->type = FE_QAM;
1830        }
1831#endif
1832        return feinfo;
1833}
1834
1835int fegetdev()
1836{
1837        int i, y, fd = -1, count = 0;
1838        char *buf = NULL, *frontenddev = NULL, *fehyprid = NULL, *tmpstr = NULL;
1839        struct dvb_frontend_info* feinfo = NULL;
1840        struct dvbdev* dvbnode = NULL;
1841
1842        frontenddev = getconfig("frontenddev", NULL);
1843        if(frontenddev == NULL)
1844        {
1845                err("NULL detect");
1846                return count;
1847        }
1848
1849        buf = malloc(MINMALLOC);
1850        if(buf == NULL)
1851        {
1852                err("no memory");
1853                return count;
1854        }
1855
1856        for(i = 0; i < MAXDVBADAPTER; i++)
1857        {
1858                for(y = 0; y < MAXFRONTENDDEV; y++)
1859                {
1860                        sprintf(buf, frontenddev, i, y);
1861                        fd = feopen(NULL, buf);
1862                        if(fd >= 0)
1863                        {
1864                                fehyprid = gethypridtunerchoicesvalue(y);
1865                                if(fehyprid != NULL)
1866                                {
1867                                        if(y < 10)
1868                                                tmpstr = ostrcat(tmpstr, "fe_0", 1, 0);
1869                                        else
1870                                                tmpstr = ostrcat(tmpstr, "fe_1", 1, 0);
1871
1872                                        tmpstr = ostrcat(tmpstr, oitoa(y), 1, 1);
1873                                        tmpstr = ostrcat(tmpstr, "_hyprid", 1, 0);
1874#ifndef MIPSEL
1875                                        if(getconfig(tmpstr, NULL) != NULL)
1876                                                sethypridtuner(y, getconfig(tmpstr, NULL));
1877                                        free(tmpstr), tmpstr = NULL;
1878#endif
1879                                }
1880                               
1881                                feinfo = fegetinfo(NULL, fd);
1882                                if(feinfo != NULL)
1883                                {
1884                                        count++;
1885                                        dvbnode = adddvbdev(buf, i, y, fd, FRONTENDDEV, feinfo, NULL, fehyprid, 0);
1886#ifdef MIPSEL
1887                                        if(fehyprid != NULL && getconfig(tmpstr, NULL) != NULL)
1888                                                sethypridtunernew(dvbnode, getconfig(tmpstr, NULL));
1889                                        free(tmpstr), tmpstr = NULL;
1890#endif                                 
1891                                        if(dvbnode->feinfo->type == FE_QPSK)
1892                                                fesetvoltage(dvbnode, SEC_VOLTAGE_OFF, 15);
1893                                }
1894                        }
1895                }
1896        }
1897
1898        free(buf);
1899        return count;
1900}
1901
1902int fecreatedummy()
1903{
1904        //create dummy frontend for playback
1905        char *buf = NULL, *frontenddev = NULL;
1906        struct dvbdev* dvbnode = NULL;
1907
1908        frontenddev = getconfig("frontenddev", NULL);
1909        if(frontenddev == NULL)
1910        {
1911                err("NULL detect");
1912                return 1;
1913        }
1914
1915        buf = malloc(MINMALLOC);
1916        if(buf == NULL)
1917        {
1918                err("no memory");
1919                return 1;
1920        }
1921
1922        dvbnode = dmxgetlast(0);
1923        if(dvbnode != NULL)
1924        {
1925                sprintf(buf, frontenddev, 0, dvbnode->devnr);
1926                adddvbdev(buf, 0, dvbnode->devnr, -1, FRONTENDDEVDUMMY, NULL, NULL, NULL, 0);
1927        }
1928
1929        free(buf);
1930        return 0;
1931}
1932
1933int fegetlock(int tunernr)
1934{
1935        struct dvbdev* dvbnode = NULL;
1936        dvbnode = dvbdev;
1937
1938        while(dvbnode != NULL)
1939        {
1940                if(dvbnode->deactive == 1)
1941                {
1942                        dvbnode = dvbnode->next;
1943                        continue;
1944                }
1945                if(dvbnode->type == FRONTENDDEV && dvbnode->devnr == tunernr)
1946                {
1947                        return dvbnode->felock;
1948                }
1949                dvbnode = dvbnode->next;
1950        }
1951        return -1;
1952}
1953
1954#ifdef MIPSEL
1955int fechangetype(struct dvbdev* tuner, char* value)
1956{
1957#if DVB_API_VERSION >= 5       
1958
1959        struct dtv_property p[2];
1960        memset(p, 0, sizeof(p));
1961        struct dtv_properties cmdseq;
1962        cmdseq.props = p;
1963        cmdseq.num = 2;
1964        p[0].cmd = DTV_CLEAR;
1965        p[1].cmd = DTV_DELIVERY_SYSTEM;
1966        p[1].u.data = SYS_UNDEFINED;
1967       
1968        int type = 0;
1969        char* realname = gethypridtunerchoicesvaluename(tuner->devnr, value);
1970       
1971        printf("**** > realname: %s\n", realname);
1972       
1973        if(realname != NULL && ostrstr(realname, "DVB-S") != NULL)
1974                type = feSatellite;
1975        else if(realname != NULL && ostrstr(realname, "DVB-C") != NULL)
1976                type = feCable;
1977        else if(realname != NULL && ostrstr(realname, "DVB-T") != NULL)
1978                type = feTerrestrial;
1979        else
1980                type = -1;
1981       
1982        switch (type)
1983        {
1984                case feSatellite:
1985                {
1986                        p[1].u.data = SYS_DVBS;
1987                        break;
1988                }
1989                case feTerrestrial:
1990                {
1991                        //fesetvoltage(tuner, SEC_VOLTAGE_OFF, 10);
1992                        //to do set voltage --> wenn der Tuner es kann
1993                        //fesetvoltage(tuner, SEC_VOLTAGE_13, 10);
1994                        if(realname != NULL && ostrstr(realname, "DVB-T2") != NULL)
1995                                p[1].u.data = SYS_DVBT2;
1996                        else
1997                                p[1].u.data = SYS_DVBT;
1998                        break;
1999                }
2000                case feCable:
2001                {
2002                         fesetvoltage(tuner, SEC_VOLTAGE_OFF, 10);
2003#ifdef SYS_DVBC_ANNEX_A
2004                        p[1].u.data = SYS_DVBC_ANNEX_A;
2005#else
2006                        p[1].u.data = SYS_DVBC_ANNEX_AC;
2007#endif
2008                        break;
2009                }
2010#ifdef feATSC
2011                case feATSC:
2012                {
2013                        p[1].u.data = SYS_ATSC;
2014                        break;
2015                }
2016#endif
2017                default:
2018                        debug(200, "not supported delivery system type %i", type);
2019                        return 0; //false
2020        }
2021        debug(200, "data %d",p[1].u.data );
2022        if (ioctl(tuner->fd, FE_SET_PROPERTY, &cmdseq) == -1)
2023                err("FE_SET_PROPERTY failed -> system tuner %d mode %s type %d ",tuner->devnr ,value, type);
2024        return 1; //true
2025
2026#else //if DVB_API_VERSION < 5
2027        return 0; //false
2028#endif
2029}               
2030#endif
2031       
2032
2033#endif
Note: See TracBrowser for help on using the repository browser.