Context Navigation

source: titan/titan/frontenddev.h @ 41047

Last change on this file since 41047 was 41047, checked in by gost, 6 years ago
[titan] fix step1 fbc Port
File size: 53.9 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: