source: titan/titan/frontenddev.h @ 41142

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

test fbc

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