source: titan/titan/frontenddev.h @ 41137

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

reset 136 135 133

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