1 //<MStar Software>
2 //******************************************************************************
3 // MStar Software
4 // Copyright (c) 2010 - 2012 MStar Semiconductor, Inc. All rights reserved.
5 // All software, firmware and related documentation herein ("MStar Software") are
6 // intellectual property of MStar Semiconductor, Inc. ("MStar") and protected by
7 // law, including, but not limited to, copyright law and international treaties.
8 // Any use, modification, reproduction, retransmission, or republication of all
9 // or part of MStar Software is expressly prohibited, unless prior written
10 // permission has been granted by MStar.
11 //
12 // By accessing, browsing and/or using MStar Software, you acknowledge that you
13 // have read, understood, and agree, to be bound by below terms ("Terms") and to
14 // comply with all applicable laws and regulations:
15 //
16 // 1. MStar shall retain any and all right, ownership and interest to MStar
17 // Software and any modification/derivatives thereof.
18 // No right, ownership, or interest to MStar Software and any
19 // modification/derivatives thereof is transferred to you under Terms.
20 //
21 // 2. You understand that MStar Software might include, incorporate or be
22 // supplied together with third party`s software and the use of MStar
23 // Software may require additional licenses from third parties.
24 // Therefore, you hereby agree it is your sole responsibility to separately
25 // obtain any and all third party right and license necessary for your use of
26 // such third party`s software.
27 //
28 // 3. MStar Software and any modification/derivatives thereof shall be deemed as
29 // MStar`s confidential information and you agree to keep MStar`s
30 // confidential information in strictest confidence and not disclose to any
31 // third party.
32 //
33 // 4. MStar Software is provided on an "AS IS" basis without warranties of any
34 // kind. Any warranties are hereby expressly disclaimed by MStar, including
35 // without limitation, any warranties of merchantability, non-infringement of
36 // intellectual property rights, fitness for a particular purpose, error free
37 // and in conformity with any international standard. You agree to waive any
38 // claim against MStar for any loss, damage, cost or expense that you may
39 // incur related to your use of MStar Software.
40 // In no event shall MStar be liable for any direct, indirect, incidental or
41 // consequential damages, including without limitation, lost of profit or
42 // revenues, lost or damage of data, and unauthorized system use.
43 // You agree that this Section 4 shall still apply without being affected
44 // even if MStar Software has been modified by MStar in accordance with your
45 // request or instruction for your use, except otherwise agreed by both
46 // parties in writing.
47 //
48 // 5. If requested, MStar may from time to time provide technical supports or
49 // services in relation with MStar Software to you for your use of
50 // MStar Software in conjunction with your or your customer`s product
51 // ("Services").
52 // You understand and agree that, except otherwise agreed by both parties in
53 // writing, Services are provided on an "AS IS" basis and the warranty
54 // disclaimer set forth in Section 4 above shall apply.
55 //
56 // 6. Nothing contained herein shall be construed as by implication, estoppels
57 // or otherwise:
58 // (a) conferring any license or right to use MStar name, trademark, service
59 // mark, symbol or any other identification;
60 // (b) obligating MStar or any of its affiliates to furnish any person,
61 // including without limitation, you and your customers, any assistance
62 // of any kind whatsoever, or any information; or
63 // (c) conferring any license or right under any intellectual property right.
64 //
65 // 7. These terms shall be governed by and construed in accordance with the laws
66 // of Taiwan, R.O.C., excluding its conflict of law rules.
67 // Any and all dispute arising out hereof or related hereto shall be finally
68 // settled by arbitration referred to the Chinese Arbitration Association,
69 // Taipei in accordance with the ROC Arbitration Law and the Arbitration
70 // Rules of the Association by three (3) arbitrators appointed in accordance
71 // with the said Rules.
72 // The place of arbitration shall be in Taipei, Taiwan and the language shall
73 // be English.
74 // The arbitration award shall be final and binding to both parties.
75 //
76 //******************************************************************************
77 //<MStar Software>
78 ////////////////////////////////////////////////////////////////////////////////
79 //
80 // Copyright (c) 2008-2009 MStar Semiconductor, Inc.
81 // All rights reserved.
82 //
83 // Unless otherwise stipulated in writing, any and all information contained
84 // herein regardless in any format shall remain the sole proprietary of
85 // MStar Semiconductor Inc. and be kept in strict confidence
86 // ("MStar Confidential Information") by the recipient.
87 // Any unauthorized act including without limitation unauthorized disclosure,
88 // copying, use, reproduction, sale, distribution, modification, disassembling,
89 // reverse engineering and compiling of the contents of MStar Confidential
90 // Information is unlawful and strictly prohibited. MStar hereby reserves the
91 // rights to any and all damages, losses, costs and expenses resulting therefrom.
92 //
93 ////////////////////////////////////////////////////////////////////////////////
94
95 ///////////////////////////////////////////////////////////////////////////////////////////////////
96 ///
97 /// file drvDMD_INTERN_DVBS.c
98 /// @brief DVBS Driver Interface
99 /// @author MStar Semiconductor Inc.
100 ///////////////////////////////////////////////////////////////////////////////////////////////////
101
102
103 //-------------------------------------------------------------------------------------------------
104 // Include Files
105 //-------------------------------------------------------------------------------------------------
106 // Common Definition
107 #include "drvDMD_INTERN_DVBS.h"
108 #include "drvDMD_INTERN_DVBS_v2.h"
109 //#include <string.h>
110 #ifdef MSOS_TYPE_LINUX_KERNEL
111 #include <linux/string.h>
112 #else
113 #include <string.h>
114 #include <stdio.h>
115 #include <math.h>
116 #endif
117 #include "MsCommon.h"
118 #include "MsVersion.h"
119 #include "MsOS.h"
120 // Internal Definition
121 //#include "regCHIP.h"
122 //#include "regAVD.h"
123 //#include "mapi_tuner.h"
124 #include "drvSYS.h"
125 #include "drvDMD_VD_MBX.h"
126 #include "halDMD_INTERN_DVBS.h"
127 #include "halDMD_INTERN_common.h"
128 #include "../../include/drvSAR.h" // for Utopia2
129 #include "utopia.h"
130 #include "utopia_dapi.h"
131 #include "ULog.h"
132 #include "../../include/drvDMD_INTERN_DVBS_v2.h" // for Utopia2
133 //-------------------------------------------------------------------------------------------------
134 // Driver Compiler Options
135 //-------------------------------------------------------------------------------------------------
136
137
138 //-------------------------------------------------------------------------------------------------
139 // Local Defines
140 //-------------------------------------------------------------------------------------------------
141 #define DVBS2FEC_REG_BASE 0x3D00
142 //#define MS_DEBUG 1
143 //-------------------------------------------------------------------------------------------------
144 // Local Structurs
145 //-------------------------------------------------------------------------------------------------
146
147
148 //-------------------------------------------------------------------------------------------------
149 // Global Variables
150 //-------------------------------------------------------------------------------------------------
151 extern MS_S16 _s16CurrentCFO;
152 extern MS_U16 _u16ChannelInfoArray[2][1000];
153 extern MS_U16 _u16ChannelInfoIndex;
154 extern MS_U16 _u16LockedCenterFreq;
155 extern MS_U16 _u16LockedSymbolRate;
156 extern MS_U8 modulation_order;
157 extern DMD_DVBS_Info sDMD_DVBS_Info;
158 extern MS_U8 u8DemodLockFlag;
159 extern MS_U8 g_dvbs_lock;
160 extern MS_BOOL _bDemodType;
161 extern DMD_DVBS_DbgLv _u8DMD_DVBS_DbgLevel;
162 //-------------------------------------------------------------------------------------------------
163 // Local Variables
164 //-------------------------------------------------------------------------------------------------
165 /*
166 static MS_U16 _u16SignalLevel[185][2]=
167 {//AV2028 SR=22M, 2/3 CN=5.9
168 {32100, 920},{32200, 915},{32350, 910},{32390, 905},{32480, 900},{32550, 895},{32620, 890},{32680, 885},{32750, 880},{32830, 875},
169 {32930, 870},{33010, 865},{33100, 860},{33200, 855},{33310, 850},{33410, 845},{33520, 840},{33640, 835},{33770, 830},{33900, 825},
170 {34030, 820},{34150, 815},{34290, 810},{34390, 805},{34490, 800},{34580, 795},{34700, 790},{34800, 785},{34880, 780},{34940, 775},
171 {35030, 770},{35130, 765},{35180, 760},{35260, 755},{35310, 750},{35340, 745},{35380, 740},{35400, 735},{35450, 730},{35550, 725},
172 {35620, 720},{35700, 715},{35800, 710},{35890, 705},{36000, 700},{36120, 695},{36180, 690},{36280, 685},{36400, 680},{36570, 675},
173 {36730, 670},{36910, 665},{37060, 660},{37100, 655},{37260, 650},{37340, 645},{37410, 640},{37580, 635},{37670, 630},{37700, 625},
174 {37750, 620},{37800, 615},{37860, 610},{37980, 605},{38050, 600},{38170, 595},{38370, 590},{38540, 585},{38710, 580},{38870, 575},
175 {39020, 570},{39070, 565},{39100, 560},{39180, 555},{39280, 550},{39460, 545},{39510, 540},{39600, 535},{39620, 530},{39680, 525},
176 {39720, 520},{39830, 515},{39880, 510},{39930, 505},{39960, 500},{40000, 495},{40200, 490},{40360, 485},{40540, 480},{40730, 475},
177 {40880, 470},{41020, 465},{41150, 460},{41280, 455},{41410, 450},{41520, 445},{41620, 440},{41730, 435},{41840, 430},{41930, 425},
178 {42010, 420},{42100, 415},{42180, 410},{42260, 405},{42350, 400},{42440, 395},{42520, 390},{42580, 385},{42660, 380},{42730, 375},
179 {42800, 370},{42870, 365},{42940, 360},{43000, 355},{43060, 350},{43130, 345},{43180, 340},{43250, 335},{43310, 330},{43370, 325},
180 {43420, 320},{43460, 315},{43520, 310},{43570, 305},{43620, 300},{43660, 295},{43710, 290},{43750, 285},{43810, 280},{43860, 275},
181 {43910, 270},{43940, 265},{43990, 260},{44020, 255},{44060, 250},{44110, 245},{44140, 240},{44190, 235},{44230, 230},{44270, 225},
182 {44320, 220},{44370, 215},{44400, 210},{44450, 205},{44490, 200},{44530, 195},{44590, 190},{44630, 185},{44660, 180},{44720, 175},
183 {44750, 170},{44790, 165},{44830, 160},{44880, 155},{44910, 150},{44960, 145},{45000, 140},{45030, 135},{45070, 130},{45100, 125},
184 {45130, 120},{45160, 115},{45200, 110},{45240, 105},{45270, 100},{45300, 95},{45330, 90},{45360, 85},{45400, 80},{45430, 75},
185 {45460, 70},{45490, 65},{45530, 60},{45560, 55},{45590, 50},{45630, 45},{45670, 40},{45690, 35},{45740, 30},{45760, 25},
186 {45800, 20},{45830, 15},{45860, 10},{45880, 5},{45920, 0}
187 };
188 */
189 //-------------------------------------------------------------------------------------------------
190 // Debug Functions
191 //-------------------------------------------------------------------------------------------------
192 #ifdef MS_DEBUG
193 #define DMD_DBG(x) (x)
194 #else
195 #define DMD_DBG(x) //(x)
196 #endif
197
198 static void* ppDVBSInstant = NULL;
199 static MS_U32 u32DVBSopen = 0;
200 static MS_U8 u8DVBSUtopiaOpen = 0; //for SetStillImagePara is earlier called than Init
201
202 static DMD_DVBS_InitData AgcSsi_Para;
203 //static float intern_dvb_c_qam_ref[] = {3.0, 0.0, 0.0, 0.0, 0.0, 80.0}; //16q,32q,64q,128q,256q, and others
204
205 //-------------------------------------------------------------------------------------------------
206 // Local Functions
207 //-------------------------------------------------------------------------------------------------
208 #ifndef MSOS_TYPE_LINUX
209 #if 1
210 static float _LogApproxTableX[80] =
211 { 1.00, 1.30, 1.69, 2.20, 2.86, 3.71, 4.83, 6.27, 8.16, 10.60, 13.79,
212 17.92, 23.30, 30.29, 39.37, 51.19, 66.54, 86.50, 112.46, 146.19,
213 190.05, 247.06, 321.18, 417.54, 542.80, 705.64, 917.33, 1192.53,
214 1550.29, 2015.38, 2620.00, 3405.99, 4427.79, 5756.13, 7482.97,
215 9727.86, 12646.22, 16440.08, 21372.11, 27783.74, 36118.86,
216 46954.52, 61040.88, 79353.15, 103159.09, 134106.82, 174338.86,
217 226640.52, 294632.68, 383022.48, 497929.22, 647307.99, 841500.39, 1093950.50,
218 1422135.65, 1848776.35, 2403409.25, 3124432.03, 4061761.64, 5280290.13,
219 6864377.17, 8923690.32, 11600797.42, 15081036.65, 19605347.64, 25486951.94,
220 33133037.52, 43072948.77, 55994833.40, 72793283.42, 94631268.45,
221 123020648.99, 159926843.68, 207904896.79, 270276365.82, 351359275.57,
222 456767058.24, 593797175.72, 771936328.43, 1003517226.96
223 };
224
225 static float _LogApproxTableY[80] =
226 { 0.00, 0.11, 0.23, 0.34, 0.46, 0.57, 0.68, 0.80, 0.91, 1.03, 1.14, 1.25,
227 1.37, 1.48, 1.60, 1.71, 1.82, 1.94, 2.05, 2.16, 2.28, 2.39, 2.51, 2.62,
228 2.73, 2.85, 2.96, 3.08, 3.19, 3.30, 3.42, 3.53, 3.65, 3.76, 3.87, 3.99,
229 4.10, 4.22, 4.33, 4.44, 4.56, 4.67, 4.79, 4.90, 5.01, 5.13, 5.24, 5.36,
230 5.47, 5.58, 5.70, 5.81, 5.93, 6.04, 6.15, 6.27, 6.04, 6.15, 6.27, 6.38,
231 6.49, 6.61, 6.72, 6.84, 6.95, 7.06, 7.18, 7.29, 7.41, 7.52, 7.63, 7.75,
232 7.86, 7.98, 8.09, 8.20, 8.32, 8.43, 8.55, 8.66
233 };
234
Log10Approx(float flt_x)235 static float Log10Approx(float flt_x)
236 {
237 MS_U8 indx = 0;
238
239 do {
240 if (flt_x < _LogApproxTableX[indx])
241 break;
242 indx++;
243 }while (indx < 79); //stop at indx = 80
244
245 return _LogApproxTableY[indx];
246 }
247 #else
Log10Approx(float flt_x)248 static float Log10Approx(float flt_x)
249 {
250 MS_U32 u32_temp = 1;
251 MS_U8 indx = 0;
252
253 do {
254 u32_temp = u32_temp << 1;
255 if (flt_x < (float)u32_temp)
256 break;
257 }while (++indx < 32);
258
259 // 10*log10(X) ~= 0.3*N, when X ~= 2^N
260 return (float)0.3 * indx;
261 }
262 #endif
263 #endif
264
265 #ifdef UFO_SUPPORT_KERNEL_FLOATING
266 #define MAX_INT 0x7FFFFFFF
267 #define Pow2_62 0x4000000000000000
268
ABS_32(MS_S32 input)269 MS_U32 ABS_32(MS_S32 input)
270 {
271 MS_U32 result;
272
273 if(input < 0)
274 {
275 result = (-1)*input;
276 }
277 else
278 result = input;
279
280 return result;
281 }
282
ABS_64(MS_S64 input)283 MS_U64 ABS_64(MS_S64 input)
284 {
285 MS_U64 result;
286
287 if(input < 0)
288 {
289 result = (-1)*input;
290 }
291 else
292 result = input;
293
294 return result;
295 }
296
Find_MSB(MS_S64 input)297 MS_U8 Find_MSB(MS_S64 input)
298 {
299 MS_S8 iter = -1;
300 MS_U64 data = ABS_64(input);
301
302 while(0 != data)
303 {
304 ++iter;
305 data >>= 1;
306 }
307
308 if(iter >= 0)
309 {
310 return iter;
311 }
312
313 return 0;
314 }
315
Normalize(MS_FLOAT_ST * input)316 void Normalize(MS_FLOAT_ST *input)
317 {
318 MS_U8 LSB, sign_flag;
319
320 MS_S8 EXP;
321 MS_U32 data;
322
323 if((*input).DATA == 0)
324 {
325 (*input).EXP = 0;
326 }
327 else
328 {
329 LSB = 0;
330
331 if((*input).DATA < 0) // negative value
332 sign_flag = 1;
333 else
334 sign_flag = 0;
335
336 data = ABS_32((*input).DATA);
337 EXP = (*input).EXP;
338
339 if(EXP != 0)
340 {
341 while( (data & 0x01) == 0x00 )
342 {
343 ++LSB;
344 data >>= 1;
345 }
346
347 EXP += LSB;
348
349 (*input).DATA = data;
350 (*input).EXP = EXP;
351
352 if(sign_flag == 1)
353 {
354 (*input).DATA *= (-1);
355 }
356 }
357 }
358 }
359
MS_FLOAT_OP(MS_FLOAT_ST stRn,MS_FLOAT_ST stRd,OP_type eOpcode)360 MS_FLOAT_ST MS_FLOAT_OP(MS_FLOAT_ST stRn,MS_FLOAT_ST stRd, OP_type eOpcode)
361 {
362 MS_FLOAT_ST result;
363
364 MS_S32 data1, data2;
365 MS_U32 udata1, udata2;
366 MS_S8 EXP1, EXP2;
367 MS_S8 iter, MSB, MSB_temp;
368
369 MS_S64 temp;
370
371 Normalize(&stRn);
372 Normalize(&stRd);
373
374 data1 = stRn.DATA;
375 data2 = stRd.DATA;
376
377 udata1 = ABS_32(data1);
378 udata2 = ABS_32(data2);
379
380 EXP1 = stRn.EXP;
381 EXP2 = stRd.EXP;
382
383 switch(eOpcode)
384 {
385 case add:
386 {
387 if(EXP1 == EXP2)
388 {
389 temp = data1;
390 temp += data2;
391
392 if(temp > MAX_INT || temp < (-1)*MAX_INT)
393 {
394 temp >>= 1;
395 result.DATA = temp;
396 result.EXP = (EXP1 + 1);
397 }
398 else
399 {
400 result.DATA = (data1 + data2);
401 result.EXP = EXP1;
402 }
403 }
404 else if(EXP1 > EXP2)
405 {
406 temp = data1;
407
408 MSB = Find_MSB(temp);
409
410 if( (MSB - EXP2) < 63)
411 {
412 for(iter = EXP1; iter > EXP2;--iter)
413 {
414 temp = (temp << 1);
415 }
416
417 temp += data2;
418
419 if(temp > MAX_INT || temp < (-1)*MAX_INT)
420 {
421 MSB = Find_MSB(temp);
422
423 temp >>= (MSB-30);
424 result.DATA = temp;
425 result.EXP = (EXP2 + (MSB-30));
426 }
427 else
428 {
429 result.DATA = temp;
430 result.EXP = EXP2;
431 }
432 }
433 else
434 {
435 result.DATA = data1;
436 result.EXP = data1;
437 }
438 }
439 else
440 {
441 return MS_FLOAT_OP(stRd, stRn, add);
442 }
443 }
444 break;
445
446 case minus:
447 {
448 stRd.DATA *= (-1);
449 return MS_FLOAT_OP(stRn, stRd, add);
450 }
451 break;
452
453 case multiply:
454 {
455 if(data1 == 0 || data2 == 0)
456 {
457 result.DATA = 0;
458 result.EXP = 0;
459 }
460 else
461 {
462 temp = data1;
463 temp *= data2;
464
465 if( (temp <= MAX_INT) && (temp >= (-1*MAX_INT) ) )
466 {
467 result.DATA = data1 * data2;
468 result.EXP = EXP1 + EXP2;
469 }
470 else // overflow
471 {
472 MSB = Find_MSB(temp);
473
474 temp = temp >> (MSB-30);
475
476 result.DATA = (MS_S32)temp;
477 result.EXP = EXP1 + EXP2 + (MSB-30);
478 }
479 }
480 }
481 break;
482
483 case divide:
484 {
485 if(data1 != 0 && data2 != 0)
486 {
487 if(udata1 < udata2)
488 {
489 temp = Pow2_62;
490 temp = temp / data2 * data1;
491
492 MSB = Find_MSB(temp);
493
494 if(MSB > 30)
495 {
496 temp >>= (MSB-30);
497 result.DATA = temp;
498 result.EXP = EXP1 - EXP2 + (MSB-30) - 62;
499 }
500 else
501 {
502 result.DATA = temp;
503 result.EXP = EXP1 - EXP2 - 62;
504 }
505 }
506 else if(udata1 == udata2)
507 {
508 result.DATA = data1 / data2;
509 result.EXP = EXP1 - EXP2;
510 }
511 else // udata1 > udata2
512 {
513 MSB = Find_MSB(data1);
514 MSB_temp = Find_MSB(data2);
515
516 EXP2 -= ((MSB-MSB_temp) + 1);
517
518 temp = Pow2_62;
519 temp = temp / ( ((MS_S64)data2) << ((MSB-MSB_temp) + 1)) * data1;
520
521 MSB = Find_MSB(temp);
522
523 if(MSB > 30)
524 {
525 temp >>= (MSB-30);
526 result.DATA = temp;
527 result.EXP = EXP1 - EXP2 + (MSB-30) - 62;
528 }
529 else
530 {
531 result.DATA = temp;
532 result.EXP = EXP1 - EXP2 - 62;
533 }
534 }
535 }
536 else
537 {
538 result.DATA = 0;
539 result.EXP = 0;
540 }
541 }
542 break;
543
544 default:
545 break;
546 }
547
548 Normalize(&result);
549
550 return result;
551 }
552 #endif
553
554 #ifdef UFO_DEMOD_DVBS_SUPPORT_DMD_INT
MDrv_DMD_DVBS_Reg_INT_CB(fpIntCallBack fpCBReg)555 MS_BOOL MDrv_DMD_DVBS_Reg_INT_CB(fpIntCallBack fpCBReg)
556 {
557 DVBS_INT_MODE Drv_DVBS_INT_MODE;
558 Drv_DVBS_INT_MODE.fpCB = fpCBReg;
559 Drv_DVBS_INT_MODE.ret = FALSE;
560
561 if(u32DVBSopen==1)
562 {
563 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_INT_MODE,&Drv_DVBS_INT_MODE);
564 }
565
566 return Drv_DVBS_INT_MODE.ret;
567 }
568 #endif
569
570 //-------------------------------------------------------------------------------------------------
571 // Global Functions
572 //-------------------------------------------------------------------------------------------------
MDrv_DMD_DVBS_Init(DMD_DVBS_InitData * pDMD_DVBS_InitData,MS_U32 u32InitDataLen)573 MS_BOOL MDrv_DMD_DVBS_Init(DMD_DVBS_InitData *pDMD_DVBS_InitData, MS_U32 u32InitDataLen)
574 {
575 void* pAttribte = NULL;
576
577 #ifdef MS_DEBUG
578 ULOGD("DEMOD","******check driver layer DVBS init!!*******\n");
579 #endif
580 DMD_DBG(ULOGD("DEMOD","[drvDMD_INTERN_DVBS.c]MDrv_DMD_DVBS_Init\n"));
581
582 DVBS_Init_PARAM Drv_DVBS_Init_PARAM;
583 DMD_DVBS_InitData_Transform Init_Para_Temp;
584
585 Init_Para_Temp.u8SarChannel=pDMD_DVBS_InitData->u8SarChannel;
586 Init_Para_Temp.u8DMD_DVBS_DSPRegInitExt=pDMD_DVBS_InitData->u8DMD_DVBS_DSPRegInitExt;
587 Init_Para_Temp.u8DMD_DVBS_DSPRegInitSize=pDMD_DVBS_InitData->u8DMD_DVBS_DSPRegInitSize;
588 Init_Para_Temp.u8DMD_DVBS_InitExt=pDMD_DVBS_InitData->u8DMD_DVBS_InitExt;
589 /*
590 Init_Para_Temp.pTuner_RfagcSsi=pDMD_DVBS_InitData->pTuner_RfagcSsi;
591 Init_Para_Temp.u16Tuner_RfagcSsi_Size=pDMD_DVBS_InitData->u16Tuner_RfagcSsi_Size;
592 Init_Para_Temp.pTuner_IfagcSsi_LoRef=pDMD_DVBS_InitData->pTuner_IfagcSsi_LoRef;
593 Init_Para_Temp.u16Tuner_IfagcSsi_LoRef_Size=pDMD_DVBS_InitData->u16Tuner_IfagcSsi_LoRef_Size;
594 Init_Para_Temp.pTuner_IfagcSsi_HiRef=pDMD_DVBS_InitData->pTuner_IfagcSsi_HiRef;
595 Init_Para_Temp.u16Tuner_IfagcSsi_HiRef_Size=pDMD_DVBS_InitData->u16Tuner_IfagcSsi_HiRef_Size;
596 Init_Para_Temp.pTuner_IfagcErr_LoRef=pDMD_DVBS_InitData->pTuner_IfagcErr_LoRef;
597 Init_Para_Temp.u16Tuner_IfagcErr_LoRef_Size=pDMD_DVBS_InitData->u16Tuner_IfagcErr_LoRef_Size;
598 Init_Para_Temp.pTuner_IfagcSsi_HiRef=pDMD_DVBS_InitData->pTuner_IfagcSsi_HiRef;
599 Init_Para_Temp.u16Tuner_IfagcErr_HiRef_Size=pDMD_DVBS_InitData->u16Tuner_IfagcErr_HiRef_Size;
600 Init_Para_Temp.pSqiCnNordigP1=pDMD_DVBS_InitData->pSqiCnNordigP1;
601 Init_Para_Temp.u16SqiCnNordigP1_Size=pDMD_DVBS_InitData->u16SqiCnNordigP1_Size;
602 */
603
604 AgcSsi_Para.pTuner_RfagcSsi=pDMD_DVBS_InitData->pTuner_RfagcSsi;
605 AgcSsi_Para.u16Tuner_RfagcSsi_Size=pDMD_DVBS_InitData->u16Tuner_RfagcSsi_Size;
606 AgcSsi_Para.pTuner_IfagcSsi_LoRef=pDMD_DVBS_InitData->pTuner_IfagcSsi_LoRef;
607 AgcSsi_Para.u16Tuner_IfagcSsi_LoRef_Size=pDMD_DVBS_InitData->u16Tuner_IfagcSsi_LoRef_Size;
608 AgcSsi_Para.pTuner_IfagcSsi_HiRef=pDMD_DVBS_InitData->pTuner_IfagcSsi_HiRef;
609 AgcSsi_Para.u16Tuner_IfagcSsi_HiRef_Size=pDMD_DVBS_InitData->u16Tuner_IfagcSsi_HiRef_Size;
610 AgcSsi_Para.pTuner_IfagcErr_LoRef=pDMD_DVBS_InitData->pTuner_IfagcErr_LoRef;
611 AgcSsi_Para.u16Tuner_IfagcErr_LoRef_Size=pDMD_DVBS_InitData->u16Tuner_IfagcErr_LoRef_Size;
612 AgcSsi_Para.pTuner_IfagcSsi_HiRef=pDMD_DVBS_InitData->pTuner_IfagcSsi_HiRef;
613 AgcSsi_Para.u16Tuner_IfagcErr_HiRef_Size=pDMD_DVBS_InitData->u16Tuner_IfagcErr_HiRef_Size;
614
615 Drv_DVBS_Init_PARAM.u32InitDataLen=sizeof(Init_Para_Temp);
616 Drv_DVBS_Init_PARAM.pDMD_DVBS_InitData=&Init_Para_Temp;
617 Drv_DVBS_Init_PARAM.ret=false;
618
619 if(u8DVBSUtopiaOpen == 0) // First time open
620 {
621 if(UtopiaOpen(MODULE_DVBS/*|KERNEL_MODE*/ , &ppDVBSInstant, 0, pAttribte) == UTOPIA_STATUS_SUCCESS) //kernel space
622 //if(UtopiaOpen(MODULE_DVBS , &ppDVBSInstant, 0, pAttribte) == UTOPIA_STATUS_SUCCESS) //user space
623 {
624 u32DVBSopen = 1;
625 ULOGD("DEMOD","Leo check DVBS utopia open sucessful!!\n");
626 //return_val=true;
627 // ULOGD("DEMOD","\r\n ======== DVBS Open Successful %x =========", (WORD)u32DVBSopen);
628 }
629 else
630 {
631 // ULOGD("DEMOD","\r\n ======== DVBS Open Fail %x =========", (WORD)u32DVBSopen);
632 //return_val=false;
633 ULOGD("DEMOD","DVBS utopia open fail!!\n");
634 return false;
635 }
636
637 u8DVBSUtopiaOpen = 1;
638 }
639
640 if(u32DVBSopen==1)
641 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_Init,&Drv_DVBS_Init_PARAM);
642 else
643 return false;
644
645 return Drv_DVBS_Init_PARAM.ret;
646 }
647
MDrv_DMD_DVBS_Exit(void)648 MS_BOOL MDrv_DMD_DVBS_Exit(void)
649 {
650 DVBS_EXIT_PARAM_PARAM Drv_DVBS_EXIT_PARAM_PARAM;
651 Drv_DVBS_EXIT_PARAM_PARAM.ret=false;
652 DMD_DBG(ULOGD("DEMOD","[drvDMD_INTERN_DVBS.c]MDrv_DMD_DVBS_Exit\n"));
653
654 if(u32DVBSopen==1)
655 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_Exit,&Drv_DVBS_EXIT_PARAM_PARAM);
656 else
657 return false;
658
659 return Drv_DVBS_EXIT_PARAM_PARAM.ret;
660 }
661
MDrv_DMD_DVBS_SetDbgLevel(DMD_DVBS_DbgLv u8DbgLevel)662 MS_BOOL MDrv_DMD_DVBS_SetDbgLevel(DMD_DVBS_DbgLv u8DbgLevel)
663 {
664 DVBS_SetDbgLevel_PARAM Drv_DVBS_SetDbgLevel_PARAM;
665 Drv_DVBS_SetDbgLevel_PARAM.u8DbgLevel=u8DbgLevel;
666 Drv_DVBS_SetDbgLevel_PARAM.ret=false;
667
668 DMD_DBG(ULOGD("DEMOD","[drvDMD_INTERN_DVBS.c]MDrv_DMD_DVBS_SetDbgLevel\n"));
669 if(u32DVBSopen==1)
670 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_SetDbgLevel,&Drv_DVBS_SetDbgLevel_PARAM);
671 else
672 return false;
673
674 return Drv_DVBS_SetDbgLevel_PARAM.ret;
675 }
676
677 #ifndef MSOS_TYPE_LINUX_KERNEL
MDrv_DMD_DVBS_GetInfo(void)678 const DMD_DVBS_Info* MDrv_DMD_DVBS_GetInfo(void)
679 {
680 DVBS_GetInfo_PARAM Drv_DVBS_GetInfo_PARAM;
681 Drv_DVBS_GetInfo_PARAM.ret_info=NULL;
682
683 if(u32DVBSopen==1)
684 {
685 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_GetInfo,&Drv_DVBS_GetInfo_PARAM);
686 }
687 else
688 {
689 return false;
690 }
691
692
693 return Drv_DVBS_GetInfo_PARAM.ret_info;
694
695 }
696 #endif
697
MDrv_DMD_DVBS_GetLibVer(const MSIF_Version ** ppVersion)698 MS_BOOL MDrv_DMD_DVBS_GetLibVer(const MSIF_Version **ppVersion)
699 {
700 DVBS_GetLibVer_PARAM Drv_DVBS_GetLibVer_PARAM;
701 Drv_DVBS_GetLibVer_PARAM.ppVersion=ppVersion;
702 Drv_DVBS_GetLibVer_PARAM.ret= false;
703
704
705 if(u32DVBSopen==1)
706 {
707 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_GetLibVer,&Drv_DVBS_GetLibVer_PARAM);
708 Drv_DVBS_GetLibVer_PARAM.ret= true;
709 }
710 else
711 {
712 return false;
713 }
714
715 return Drv_DVBS_GetLibVer_PARAM.ret;
716 }
717
MDrv_DMD_DVBS_GetFWVer(MS_U16 * ver)718 MS_BOOL MDrv_DMD_DVBS_GetFWVer(MS_U16 *ver)
719 {
720 DVBS_GetFWVer_PARAM Drv_DVBS_GetFWVer_PARAM;
721 Drv_DVBS_GetFWVer_PARAM.ver=ver;
722 Drv_DVBS_GetFWVer_PARAM.ret=false;
723
724 if(u32DVBSopen==1)
725 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_GetFWVer,&Drv_DVBS_GetFWVer_PARAM);
726 else
727 {
728 return false;
729 }
730
731 return Drv_DVBS_GetFWVer_PARAM.ret;
732
733 }
734
MDrv_DMD_DVBS_GetDSPReg(MS_U16 u16Addr,MS_U8 * pu8Data)735 MS_BOOL MDrv_DMD_DVBS_GetDSPReg(MS_U16 u16Addr, MS_U8 *pu8Data)
736 {
737 #if defined(CHIP_K1)
738 DVBS_GetDSPReg_PARAM Drv_DVBS_GetDSPReg_PARAM;
739 Drv_DVBS_GetDSPReg_PARAM.u16Addr=u16Addr;
740 Drv_DVBS_GetDSPReg_PARAM.pu8Data=pu8Data;
741
742 if(u32DVBSopen==1)
743 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_GetDSPReg,&Drv_DVBS_GetDSPReg_PARAM);
744 else
745 {
746 return false;
747 }
748
749 return Drv_DVBS_GetDSPReg_PARAM.ret;
750 #else
751 ULOGD("DEMOD","Not Support function: MDrv_DMD_DVBS_GetDSPReg\n");
752 return FALSE;
753 #endif
754 }
755
MDrv_DMD_DVBS_SetDSPReg(MS_U16 u16Addr,MS_U8 pu8Data)756 MS_BOOL MDrv_DMD_DVBS_SetDSPReg(MS_U16 u16Addr, MS_U8 pu8Data)
757 {
758 #if defined(CHIP_K1)
759 DVBS_SetDSPReg_PARAM Drv_DVBS_SetDSPReg_PARAM;
760
761 Drv_DVBS_SetDSPReg_PARAM.pu8Data=pu8Data;
762 Drv_DVBS_SetDSPReg_PARAM.u16Addr=u16Addr;
763
764 if(u32DVBSopen==1)
765 {
766 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_SetDSPReg,&Drv_DVBS_SetDSPReg_PARAM);
767 }
768 else
769 {
770 return false;
771 }
772
773 return Drv_DVBS_SetDSPReg_PARAM.ret;
774 #else
775 ULOGD("DEMOD","Not Support function: MDrv_DMD_DVBS_SetDSPReg\n");
776 return FALSE;
777 #endif
778 }
779
780
MDrv_DMD_DVBS_GetReg(MS_U16 u16Addr,MS_U8 * pu8Data)781 MS_BOOL MDrv_DMD_DVBS_GetReg(MS_U16 u16Addr, MS_U8 *pu8Data)
782 {
783 DVBS_GetReg_PARAM Drv_DVBS_GetReg_PARAM;
784 Drv_DVBS_GetReg_PARAM.u16Addr=u16Addr;
785 Drv_DVBS_GetReg_PARAM.pu8Data=pu8Data;
786 Drv_DVBS_GetReg_PARAM.ret=false;
787
788 if(u32DVBSopen==1)
789 {
790 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_GetReg,&Drv_DVBS_GetReg_PARAM);
791 }
792 else
793 {
794 return false;
795 }
796
797 return Drv_DVBS_GetReg_PARAM.ret;
798
799 }
800
MDrv_DMD_DVBS_SetReg(MS_U16 u16Addr,MS_U8 u8Data)801 MS_BOOL MDrv_DMD_DVBS_SetReg(MS_U16 u16Addr, MS_U8 u8Data)
802 {
803 DVBS_SetReg_PARAM Drv_DVBS_SetReg_PARAM;
804 Drv_DVBS_SetReg_PARAM.u16Addr=u16Addr;
805 Drv_DVBS_SetReg_PARAM.u8Data=u8Data;
806 Drv_DVBS_SetReg_PARAM.ret=false;
807
808 if(u32DVBSopen==1)
809 {
810 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_SetReg,&Drv_DVBS_SetReg_PARAM);
811 }
812 else
813 {
814 return false;
815 }
816
817 return Drv_DVBS_SetReg_PARAM.ret;
818 }
819
MDrv_DMD_DVBS_SetSerialControl(MS_BOOL bEnable)820 MS_BOOL MDrv_DMD_DVBS_SetSerialControl(MS_BOOL bEnable)
821 {
822 DVBS_SetSerialControl_PARAM Drv_DVBS_SetSerialControl_PARAM;
823 Drv_DVBS_SetSerialControl_PARAM.bEnable=bEnable;
824 Drv_DVBS_SetSerialControl_PARAM.ret=false;
825
826 if(u32DVBSopen==1)
827 {
828 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_SetSerialControl,&Drv_DVBS_SetSerialControl_PARAM);
829 }
830 else
831 {
832 return false;
833 }
834
835
836 return Drv_DVBS_SetSerialControl_PARAM.ret;
837 }
838
839 #ifdef UFO_DEMOD_BLINDSCAN_NEW_FLOW
840 #ifndef MSOS_TYPE_LINUX_KERNEL
MDrv_DMD_DVBS_BlindScan_Config(MS_U32 u32SymbolRate,DMD_DVBS_MODULATION_TYPE eQamMode,MS_U32 u32IFFreq,MS_BOOL bSpecInv,MS_BOOL bSerialTS)841 MS_BOOL MDrv_DMD_DVBS_BlindScan_Config(MS_U32 u32SymbolRate, DMD_DVBS_MODULATION_TYPE eQamMode, MS_U32 u32IFFreq, MS_BOOL bSpecInv, MS_BOOL bSerialTS)
842 {
843 return MDrv_DMD_DVBS_BlindScan_Config_symbol_rate_list(u32SymbolRate, eQamMode, u32IFFreq, bSpecInv, bSerialTS, NULL, 0);
844 }
845
MDrv_DMD_DVBS_BlindScan_Config_symbol_rate_list(MS_U32 u32SymbolRate,DMD_DVBS_MODULATION_TYPE eQamMode,MS_U32 u32IFFreq,MS_BOOL bSpecInv,MS_BOOL bSerialTS,MS_U16 * pu16_symbol_rate_list,MS_U8 u8_symbol_rate_list_num)846 MS_BOOL MDrv_DMD_DVBS_BlindScan_Config_symbol_rate_list(MS_U32 u32SymbolRate, DMD_DVBS_MODULATION_TYPE eQamMode, MS_U32 u32IFFreq, MS_BOOL bSpecInv, MS_BOOL bSerialTS, MS_U16 *pu16_symbol_rate_list,MS_U8 u8_symbol_rate_list_num)
847 {
848 MS_U32 u32CurrentSR;
849 #ifdef MS_DEBUG
850 ULOGD("DEMOD","check driver layer DVBS BlindScan_Config_symbol_rate_list!!\n");
851 #endif
852
853 DVBS_BlindScan_Config_Symbol_rate_list_PARAM Drv_DVBS_BlindScan_Config_Symbol_rate_list_PARAM;
854 Drv_DVBS_BlindScan_Config_Symbol_rate_list_PARAM.u32SymbolRate=u32SymbolRate;
855 Drv_DVBS_BlindScan_Config_Symbol_rate_list_PARAM.eQamMode=eQamMode;
856 Drv_DVBS_BlindScan_Config_Symbol_rate_list_PARAM.u32IFFreq=u32IFFreq;
857 Drv_DVBS_BlindScan_Config_Symbol_rate_list_PARAM.bSpecInv=bSpecInv;
858 Drv_DVBS_BlindScan_Config_Symbol_rate_list_PARAM.bSerialTS=bSerialTS;
859 Drv_DVBS_BlindScan_Config_Symbol_rate_list_PARAM.pu16_symbol_rate_list=pu16_symbol_rate_list;
860 Drv_DVBS_BlindScan_Config_Symbol_rate_list_PARAM.u8_symbol_rate_list_num=u8_symbol_rate_list_num;
861 Drv_DVBS_BlindScan_Config_Symbol_rate_list_PARAM.ret=false;
862
863 if(u32DVBSopen==1)
864 {
865 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_BlindScan_Config_symbol_rate_list,&Drv_DVBS_BlindScan_Config_Symbol_rate_list_PARAM);
866 g_dvbs_lock = 0;
867 u8DemodLockFlag=0;
868 u32CurrentSR = u32SymbolRate/1000; //KHz
869 Drv_DVBS_BlindScan_Config_Symbol_rate_list_PARAM.ret &= MDrv_SYS_DMD_VD_MBX_WriteDSPReg(E_DMD_S2_MANUAL_TUNE_SYMBOLRATE_L, u32CurrentSR&0xff);
870 Drv_DVBS_BlindScan_Config_Symbol_rate_list_PARAM.ret &= MDrv_SYS_DMD_VD_MBX_WriteDSPReg(E_DMD_S2_MANUAL_TUNE_SYMBOLRATE_H, (u32CurrentSR>>8)&0xff);
871 Drv_DVBS_BlindScan_Config_Symbol_rate_list_PARAM.ret &= MDrv_SYS_DMD_VD_MBX_WriteDSPReg(E_DMD_S2_MB_DMDTOP_DBG_5, (u32CurrentSR>>16)&0xff);
872 ULOGD("DEMOD","drv_DMD_DVBS_BlindScan_Config u32SymbolRate = %d \n", u32CurrentSR);
873 }
874 else
875 {
876 return false;
877 }
878
879 return Drv_DVBS_BlindScan_Config_Symbol_rate_list_PARAM.ret;
880 }
881 #endif
882 #endif
883
884 #ifndef MSOS_TYPE_LINUX_KERNEL
MDrv_DMD_DVBS_SetConfig(MS_U32 u32SymbolRate,DMD_DVBS_MODULATION_TYPE eQamMode,MS_U32 u32IFFreq,MS_BOOL bSpecInv,MS_BOOL bSerialTS)885 MS_BOOL MDrv_DMD_DVBS_SetConfig(MS_U32 u32SymbolRate, DMD_DVBS_MODULATION_TYPE eQamMode, MS_U32 u32IFFreq, MS_BOOL bSpecInv, MS_BOOL bSerialTS)
886 {
887 #ifdef MS_DEBUG
888 ULOGD("DEMOD","check driver layer DVBS SetConfig!!\n");
889 #endif
890
891 return MDrv_DMD_DVBS_SetConfig_symbol_rate_list(u32SymbolRate, eQamMode, u32IFFreq, bSpecInv, bSerialTS, NULL, 0);
892 }
893
MDrv_DMD_DVBS_SetConfig_symbol_rate_list(MS_U32 u32SymbolRate,DMD_DVBS_MODULATION_TYPE eQamMode,MS_U32 u32IFFreq,MS_BOOL bSpecInv,MS_BOOL bSerialTS,MS_U16 * pu16_symbol_rate_list,MS_U8 u8_symbol_rate_list_num)894 MS_BOOL MDrv_DMD_DVBS_SetConfig_symbol_rate_list(MS_U32 u32SymbolRate, DMD_DVBS_MODULATION_TYPE eQamMode, MS_U32 u32IFFreq, MS_BOOL bSpecInv, MS_BOOL bSerialTS, MS_U16 *pu16_symbol_rate_list,MS_U8 u8_symbol_rate_list_num)
895 {
896 MS_U32 u32CurrentSR;
897 #ifdef MS_DEBUG
898 ULOGD("DEMOD","check driver layer DVBS SetConfig_symbol_rate_list!!\n");
899 #endif
900
901 DVBS_SetConfig_Symbol_rate_list_PARAM Drv_DVBS_SetConfig_Symbol_rate_list_PARAM;
902 Drv_DVBS_SetConfig_Symbol_rate_list_PARAM.u16SymbolRate=u32SymbolRate;
903 Drv_DVBS_SetConfig_Symbol_rate_list_PARAM.eQamMode=eQamMode;
904 Drv_DVBS_SetConfig_Symbol_rate_list_PARAM.u32IFFreq=u32IFFreq;
905 Drv_DVBS_SetConfig_Symbol_rate_list_PARAM.bSpecInv=bSpecInv;
906 Drv_DVBS_SetConfig_Symbol_rate_list_PARAM.bSerialTS=bSerialTS;
907 Drv_DVBS_SetConfig_Symbol_rate_list_PARAM.pu16_symbol_rate_list=pu16_symbol_rate_list;
908 Drv_DVBS_SetConfig_Symbol_rate_list_PARAM.u8_symbol_rate_list_num=u8_symbol_rate_list_num;
909 Drv_DVBS_SetConfig_Symbol_rate_list_PARAM.ret=false;
910
911 if(u32DVBSopen==1)
912 {
913 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_SetConfig_symbol_rate_list,&Drv_DVBS_SetConfig_Symbol_rate_list_PARAM);
914 g_dvbs_lock = 0;
915 u8DemodLockFlag=0;
916 u32CurrentSR = u32SymbolRate/1000; //KHz
917 Drv_DVBS_SetConfig_Symbol_rate_list_PARAM.ret &= MDrv_SYS_DMD_VD_MBX_WriteDSPReg(E_DMD_S2_MANUAL_TUNE_SYMBOLRATE_L, u32CurrentSR&0xff);
918 Drv_DVBS_SetConfig_Symbol_rate_list_PARAM.ret &= MDrv_SYS_DMD_VD_MBX_WriteDSPReg(E_DMD_S2_MANUAL_TUNE_SYMBOLRATE_H, (u32CurrentSR>>8)&0xff);
919 Drv_DVBS_SetConfig_Symbol_rate_list_PARAM.ret &= MDrv_SYS_DMD_VD_MBX_WriteDSPReg(E_DMD_S2_MB_DMDTOP_DBG_5, (u32CurrentSR>>16)&0xff);
920 ULOGD("DEMOD","drv_DMD_DVBS_SetConfig u32SymbolRate = %d \n", (int)u32CurrentSR);
921 }
922 else
923 {
924 return false;
925 }
926
927 return Drv_DVBS_SetConfig_Symbol_rate_list_PARAM.ret;
928 }
929 #endif
MDrv_DMD_DVBS_SetActive(MS_BOOL bEnable)930 MS_BOOL MDrv_DMD_DVBS_SetActive(MS_BOOL bEnable)
931 {
932 DVBS_SetActive_PARAM Drv_DVBS_SetActive_PARAM;
933 Drv_DVBS_SetActive_PARAM.bEnable=bEnable;
934 Drv_DVBS_SetActive_PARAM.ret=false;
935 DMD_DBG(ULOGD("DEMOD","[drvDMD_INTERN_DVBS.c]MDrv_DMD_DVBS_SetActive\n"));
936
937 #ifdef MS_DEBUG
938 ULOGD("DEMOD","check driver layer DVBS SetActive!!\n");
939 #endif
940
941 if(u32DVBSopen==1)
942 {
943 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_SetActive,&Drv_DVBS_SetActive_PARAM);
944 }
945 else
946 {
947 return false;
948 }
949
950 return Drv_DVBS_SetActive_PARAM.ret;
951 }
952 #ifndef MSOS_TYPE_LINUX_KERNEL
MDrv_DMD_DVBS_GetLock(DMD_DVBS_GETLOCK_TYPE eType,DMD_DVBS_LOCK_STATUS * eLockStatus)953 MS_BOOL MDrv_DMD_DVBS_GetLock(DMD_DVBS_GETLOCK_TYPE eType, DMD_DVBS_LOCK_STATUS *eLockStatus)
954 {
955 return MDrv_DMD_DVBS_GetLockWithRFPower(eType, eLockStatus, 200.0f, -200.0f);
956 }
957 #endif
958
959 #ifdef UFO_DEMOD_GetParam_NEW_FLOW
MDrv_DMD_DVBS_GetParam(HAL_DEMOD_MS_SAT_CARRIER_PARAM * pParam)960 MS_BOOL MDrv_DMD_DVBS_GetParam(HAL_DEMOD_MS_SAT_CARRIER_PARAM *pParam)
961 {
962 DVBS_GET_INFO Drv_DVBS_GET_INFO;
963
964 Drv_DVBS_GET_INFO.ret = FALSE;
965
966 if(u32DVBSopen==1)
967 {
968 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_GetParam, &Drv_DVBS_GET_INFO);
969 }
970
971 pParam->eCodeRate = Drv_DVBS_GET_INFO.eCodeRate;
972 pParam->eRollOff = Drv_DVBS_GET_INFO.eRollOff;
973 pParam->eConstellation = Drv_DVBS_GET_INFO.eConstellation;
974 pParam->eDemodType = Drv_DVBS_GET_INFO.eDemodType;
975 pParam->eFreqoff = Drv_DVBS_GET_INFO.eFreqoff;
976 pParam->eIQ_Mode = Drv_DVBS_GET_INFO.eIQ_Mode;
977
978 #ifdef MS_DEBUG
979 ULOGD("DEMOD","Code rate :%d\n",pParam->eCodeRate);
980 ULOGD("DEMOD","Roll-off Factor :%d\n",pParam->eRollOff);
981 ULOGD("DEMOD","Modulation mode :%d\n",pParam->eConstellation);
982 ULOGD("DEMOD","Demod type :%d\n",pParam->eDemodType);
983 ULOGD("DEMOD","CFO :%f\n",pParam->eFreqoff);
984 #endif
985
986 return Drv_DVBS_GET_INFO.ret;
987 }
988 #endif
989
990 #ifdef UFO_DEMOD_GET_AGC_INFO
MDrv_DMD_DVBS_GetAGCInfo(MS_U8 u8dbg_mode,MS_U16 * pu16Data)991 MS_BOOL MDrv_DMD_DVBS_GetAGCInfo(MS_U8 u8dbg_mode, MS_U16 *pu16Data)
992 {
993 DVBS_GET_AGC_INFO Drv_DVBS_GET_AGC_INFO;
994
995 Drv_DVBS_GET_AGC_INFO.u8dbg_mode = u8dbg_mode;
996 Drv_DVBS_GET_AGC_INFO.pu16Data = pu16Data;
997 Drv_DVBS_GET_AGC_INFO.ret = false;
998
999 if(u32DVBSopen==1)
1000 {
1001 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_GetAGCInfo, &Drv_DVBS_GET_AGC_INFO);
1002 }
1003
1004 return Drv_DVBS_GET_AGC_INFO.ret;
1005 }
1006 #endif
1007
1008 #ifndef MSOS_TYPE_LINUX_KERNEL
MDrv_DMD_DVBS_GetLockWithRFPower(DMD_DVBS_GETLOCK_TYPE eType,DMD_DVBS_LOCK_STATUS * eLockStatus,float fCurrRFPowerDbm,float fNoChannelRFPowerDbm)1009 MS_BOOL MDrv_DMD_DVBS_GetLockWithRFPower(DMD_DVBS_GETLOCK_TYPE eType, DMD_DVBS_LOCK_STATUS *eLockStatus, float fCurrRFPowerDbm, float fNoChannelRFPowerDbm)
1010 {
1011 MS_BOOL status = true;
1012
1013 DMD_IFAGC_SSI *ifagc_ssi;
1014 DMD_IFAGC_ERR *ifagc_err;
1015 float ch_power_rf=0.0f;
1016 float ch_power_db=0.0f;
1017 float ch_power_if=0.0f, ch_power_ifa = 0.0f, ch_power_ifb =0.0f;
1018 MS_U16 if_agc_val =0, if_agc_vala =0, if_agc_valb =0, if_agc_val_lsb =0, i;
1019 float ch_power_takeover=0.0f;
1020 MS_U8 ssi_tbl_len = 0, err_tbl_len = 0;
1021
1022 MS_U8 ifagc_reg;
1023 MS_U8 ifagc_reg_lsb;
1024 MS_U16 ifagc_err_reg;
1025 MS_U32 u32SymbolRate=0;
1026 //float fSymbolRate;
1027 //MS_U8 ISSY_EN = 0;
1028 MS_U8 code_rate_idx = 0;
1029 MS_U8 pilot_flag = 0;
1030 MS_U8 fec_type_idx = 0;
1031 MS_U16 k_bch_array[2][42] =
1032 {
1033 {
1034 16008, 21408, 25728, 32208, 38688, 43040, 48408, 51648, 53840, 57472,
1035 58192, 14208, 18528, 28968, 32208, 34368, 35448, 35808, 37248, 37248,
1036 38688, 40128, 41208, 41568, 43008, 44448, 44808, 45888, 46608, 47328,
1037 47328, 48408, 50208, 50208, 55248, 0, 0, 0, 0, 0,
1038 0, 0,
1039 },
1040 {
1041 3072, 5232, 6312, 7032, 9552, 10632, 11712, 12432, 13152, 14232,
1042 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1043 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1044 0, 0, 0, 0, 0, 3792, 4152, 4872, 7392, 8472,
1045 9192, 11352
1046 }
1047 };
1048 MS_U16 n_ldpc_array[2] = {64800, 16200};
1049
1050 MS_FLOAT pilot_term = 0;
1051 MS_FLOAT k_bch;
1052 MS_FLOAT n_ldpc;
1053 MS_FLOAT ts_div_num_offset = 1.5;
1054 MS_FLOAT ts_div_num_margin_ratio = 1.03;
1055 MS_FLOAT ftmp;
1056 //MS_U32 u32Time_start,u32Time_end;
1057 MS_U32 u32temp=0;
1058 //MS_FLOAT pkt_interval;
1059 MS_U8 system_type_reg=0;
1060 MS_U8 code_rate_reg=0;
1061 MS_FLOAT fTSDivNum;
1062 MS_U8 u8Data;
1063
1064 DVBS_GetLockWithRFPower Drv_DVBS_GetLockWithRFPower;
1065
1066 Drv_DVBS_GetLockWithRFPower.eType=eType;
1067 Drv_DVBS_GetLockWithRFPower.eLockStatus=eLockStatus;
1068 //Drv_DVBS_GetLockWithRFPower.u32CurrRFPowerDbm=(MS_U32)(fCurrRFPowerDbm*10);
1069 //Drv_DVBS_GetLockWithRFPower.u32NoChannelRFPowerDbm=(MS_U32)(fNoChannelRFPowerDbm*10);
1070 Drv_DVBS_GetLockWithRFPower.ret=false;
1071
1072 DVBS_GetIFAGC_PARAM Drv_DVBS_GetIFAGC_PARAM;
1073 Drv_DVBS_GetIFAGC_PARAM.ifagc_reg=&ifagc_reg;
1074 Drv_DVBS_GetIFAGC_PARAM.ifagc_reg_lsb=&ifagc_reg_lsb;
1075 Drv_DVBS_GetIFAGC_PARAM.ifagc_err_reg=&ifagc_err_reg;
1076 Drv_DVBS_GetIFAGC_PARAM.ret=false;
1077
1078 DVBS_GetTsDivNum_PARAM Drv_DVBS_GetTsDivNum_PARAM;
1079 Drv_DVBS_GetTsDivNum_PARAM.u32SymbolRate=&u32SymbolRate;
1080 Drv_DVBS_GetTsDivNum_PARAM.system_type_reg=&system_type_reg;
1081 Drv_DVBS_GetTsDivNum_PARAM.code_rate_idx=&code_rate_idx;
1082 Drv_DVBS_GetTsDivNum_PARAM.fec_type_idx=&fec_type_idx;
1083 Drv_DVBS_GetTsDivNum_PARAM.pilot_flag=&pilot_flag;
1084 Drv_DVBS_GetTsDivNum_PARAM.u32temp=&u32temp;
1085 Drv_DVBS_GetTsDivNum_PARAM.code_rate_reg=&code_rate_reg;
1086 Drv_DVBS_GetTsDivNum_PARAM.bRet=false;
1087
1088 if(u32DVBSopen==1)
1089 {
1090 if((AgcSsi_Para.pTuner_IfagcSsi_HiRef != NULL) && (AgcSsi_Para.pTuner_IfagcSsi_LoRef != NULL))
1091 {
1092 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_GetIFAGC,&Drv_DVBS_GetIFAGC_PARAM);
1093 status &= Drv_DVBS_GetIFAGC_PARAM.ret;
1094
1095 ch_power_rf = fCurrRFPowerDbm;
1096 if_agc_val = ifagc_reg;
1097 if_agc_val_lsb = ifagc_reg_lsb;
1098
1099 ifagc_ssi = AgcSsi_Para.pTuner_IfagcSsi_LoRef;
1100 ssi_tbl_len = AgcSsi_Para.u16Tuner_IfagcSsi_LoRef_Size;
1101 ifagc_err = AgcSsi_Para.pTuner_IfagcErr_LoRef;
1102 err_tbl_len = AgcSsi_Para.u16Tuner_IfagcErr_LoRef_Size;
1103
1104 ch_power_if=ifagc_ssi[0].power_db;
1105 if (if_agc_val >=ifagc_ssi[0].agc_val)
1106 {
1107 for(i = 1; i < ssi_tbl_len; i++)
1108 {
1109 if (if_agc_val < ifagc_ssi[i].agc_val)
1110 {
1111 if_agc_valb = ifagc_ssi[i].agc_val;
1112 ch_power_ifb = ifagc_ssi[i].power_db;
1113
1114 i--;
1115 if_agc_vala = ifagc_ssi[i].agc_val;
1116 ch_power_ifa=ifagc_ssi[i].power_db;
1117 while ((i>1) && (if_agc_vala==ifagc_ssi[i-1].agc_val))
1118 {
1119 ch_power_ifa=ifagc_ssi[i-1].power_db;
1120 i--;
1121 }
1122 ch_power_if = ch_power_ifa+(ch_power_ifb-ch_power_ifa)*(float)((if_agc_val-if_agc_vala)*256+if_agc_val_lsb)/((if_agc_valb-if_agc_vala)*256);
1123 break;
1124 }
1125 }
1126 }
1127 #ifdef MS_DEBUG
1128 ULOGD("DEMOD","if prev %f %x\n", ch_power_ifa, if_agc_vala);
1129 ULOGD("DEMOD","if next %f %x\n", ch_power_ifb, if_agc_valb);
1130 #endif
1131
1132
1133 for(i = 0; i < ssi_tbl_len; i++)
1134 {
1135 if (ifagc_ssi[i].agc_val <= ifagc_ssi[i+1].agc_val)
1136 {
1137 ch_power_takeover = ifagc_ssi[i+1].power_db;
1138 break;
1139 }
1140 }
1141
1142 #ifdef MS_DEBUG
1143 //ULOGD("DEMOD","ch_power_rf = %f\n", ch_power_rf);
1144 ULOGD("DEMOD","ch_power_if = %f\n", ch_power_if);
1145 ULOGD("DEMOD","ch_power_takeover = %f\n", ch_power_takeover);
1146 #endif
1147
1148 // ch_power_db = (ch_power_rf > ch_power_if)? ch_power_rf : ch_power_if;
1149
1150 if(ch_power_rf > (ch_power_takeover + 0.5))
1151 {
1152 ch_power_db = ch_power_rf;
1153 }
1154 else if(ch_power_if < (ch_power_takeover - 0.5))
1155 {
1156 ch_power_db = ch_power_if;
1157 }
1158 else
1159 {
1160 ch_power_db = (ch_power_if + ch_power_rf)/2;
1161 }
1162
1163 // ch_power_db = (ch_power_rf > ch_power_if)? ch_power_if : ch_power_rf;
1164
1165 if(if_agc_val == 0xff)
1166 {
1167 for(i = 0; i < err_tbl_len; i++)
1168 {
1169 if ( ifagc_err_reg <= ifagc_err[i].agc_err ) // signed char comparison
1170 {
1171 ch_power_db += ifagc_err[i].attn_db;
1172 break;
1173 }
1174 }
1175 #ifdef MS_DEBUG
1176 ULOGD("DEMOD","if_agc_err = 0x%x\n", ifagc_err_reg);
1177 #endif
1178 }
1179 }
1180 else
1181 {
1182 #ifdef MS_DEBUG
1183 if (fCurrRFPowerDbm>=100.0) // unreasonable input value, get RF level from RFAGG
1184 {
1185 ULOGD("DEMOD","Error!! please add AGC table\n");
1186 }
1187 #endif
1188 ch_power_db = fCurrRFPowerDbm;
1189 }
1190
1191 Drv_DVBS_GetLockWithRFPower.u32CurrRFPowerDbm=(MS_U32)(ch_power_db);
1192 Drv_DVBS_GetLockWithRFPower.u32NoChannelRFPowerDbm=(MS_U32)(fNoChannelRFPowerDbm);
1193 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_GetLockWithRFPower,&Drv_DVBS_GetLockWithRFPower);
1194 status &= Drv_DVBS_GetLockWithRFPower.ret;
1195 if(u8DemodLockFlag==1)
1196 {
1197 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_GetTsDivNum, &Drv_DVBS_GetTsDivNum_PARAM);
1198 status &= Drv_DVBS_GetTsDivNum_PARAM.bRet;
1199
1200 //fec_type_idx = *Drv_DVBS_GetTsDivNum_PARAM.fec_type_idx;
1201 //code_rate_idx = *Drv_DVBS_GetTsDivNum_PARAM.code_rate_idx;
1202 //pilot_flag = *Drv_DVBS_GetTsDivNum_PARAM.pilot_flag;
1203
1204 if(!system_type_reg)//DVBS2
1205 {
1206 k_bch = k_bch_array[fec_type_idx][code_rate_idx];
1207 n_ldpc = n_ldpc_array[fec_type_idx];
1208 pilot_term = ((float) n_ldpc / modulation_order / 1440 * 36) * pilot_flag;
1209
1210 //data rate
1211 ftmp = k_bch/((n_ldpc/modulation_order+90+pilot_term)/u32SymbolRate);
1212
1213 if(sDMD_DVBS_Info.bSerialTS)//serial mode
1214 {
1215 fTSDivNum = 288000.0 / (ftmp) / 2.0 - 1;
1216 //fTSDivNum = fTSDivNum/2-1;// since 288/(2(fTSDivNum+1)) = 288/TS_RATE = A ==> fTSDivNum = A/2-1
1217 }
1218 else//parallel mode
1219 {
1220 fTSDivNum = 288000.0 / (ftmp/8.0) / 2.0 - 1;
1221 //fTSDivNum = (fTSDivNum-1)/2;
1222 }
1223
1224 fTSDivNum -= ts_div_num_offset;
1225
1226 if(fTSDivNum > 0x1F)
1227 fTSDivNum = 0x1F;
1228 else if(fTSDivNum < 0x01)
1229 fTSDivNum = 0x01;
1230
1231 //ULOGD("DEMOD", ">>>Modulation Order = 0x%x<<<\n", modulation_order);
1232 //ULOGD("DEMOD", ">>>FEC Type = 0x%x<<<\n", fec_type_idx);
1233 //ULOGD("DEMOD", ">>>CR Type = 0x%x<<<\n", code_rate_idx);
1234 //ULOGD("DEMOD", ">>>Pilot Type = 0x%x<<<\n", pilot_flag);
1235 }
1236 else //S
1237 {
1238 code_rate_reg = *Drv_DVBS_GetTsDivNum_PARAM.code_rate_reg;
1239 switch (code_rate_reg)
1240 {
1241 case 0x00: //CR 1/2
1242 if(sDMD_DVBS_Info.bSerialTS)
1243 fTSDivNum = ((288000/((1.0/2.0)*(188.0/204.0)*u32SymbolRate*ts_div_num_margin_ratio*2)) /2)-ts_div_num_offset;
1244 else
1245 fTSDivNum = ((288000/((1.0/2.0)*(188.0/204.0)*u32SymbolRate*ts_div_num_margin_ratio*2/8.0))/2)-ts_div_num_offset;
1246
1247 //fTSDivNum = fTSDivNum/2-1-5;
1248
1249 break;
1250 case 0x01: //CR 2/3
1251 if(sDMD_DVBS_Info.bSerialTS)
1252 fTSDivNum = ((288000/((2.0/3.0)*(188.0/204.0)*u32SymbolRate*ts_div_num_margin_ratio*2)) /2)-ts_div_num_offset;
1253 else
1254 fTSDivNum = ((288000/((2.0/3.0)*(188.0/204.0)*u32SymbolRate*ts_div_num_margin_ratio*2/8.0))/2)-ts_div_num_offset;
1255
1256 //fTSDivNum = fTSDivNum/2-1-5;
1257
1258 break;
1259 case 0x02: //CR 3/4
1260 if(sDMD_DVBS_Info.bSerialTS)
1261 fTSDivNum = ((288000/((3.0/4.0)*(188.0/204.0)*u32SymbolRate*ts_div_num_margin_ratio*2)) /2)-ts_div_num_offset;
1262 else
1263 fTSDivNum = ((288000/((3.0/4.0)*(188.0/204.0)*u32SymbolRate*ts_div_num_margin_ratio*2/8.0))/2)-ts_div_num_offset;
1264
1265 //fTSDivNum = fTSDivNum/2-1-5;
1266 break;
1267 case 0x03: //CR 5/6
1268 if(sDMD_DVBS_Info.bSerialTS)
1269 fTSDivNum = ((288000/((5.0/6.0)*(188.0/204.0)*u32SymbolRate*ts_div_num_margin_ratio*2)) /2)-ts_div_num_offset;
1270 else
1271 fTSDivNum = ((288000/((5.0/6.0)*(188.0/204.0)*u32SymbolRate*ts_div_num_margin_ratio*2/8.0))/2)-ts_div_num_offset;
1272
1273 //fTSDivNum = fTSDivNum/2-1-5;
1274
1275 break;
1276 case 0x04: //CR 7/8
1277 if(sDMD_DVBS_Info.bSerialTS)
1278 fTSDivNum = ((288000/((7.0/8.0)*(188.0/204.0)*u32SymbolRate*ts_div_num_margin_ratio*2)) /2)-ts_div_num_offset;
1279 else
1280 fTSDivNum = ((288000/((7.0/8.0)*(188.0/204.0)*u32SymbolRate*ts_div_num_margin_ratio*2/8.0))/2)-ts_div_num_offset;
1281
1282 //fTSDivNum = fTSDivNum/2-1-5;
1283
1284 break;
1285 default:
1286 if(sDMD_DVBS_Info.bSerialTS)
1287 fTSDivNum = ((288000/((7.0/8.0)*(188.0/204.0)*u32SymbolRate*ts_div_num_margin_ratio*2)) /2)-ts_div_num_offset;
1288 else
1289 fTSDivNum = ((288000/((7.0/8.0)*(188.0/204.0)*u32SymbolRate*ts_div_num_margin_ratio*2/8.0))/2)-ts_div_num_offset;
1290
1291 //fTSDivNum = fTSDivNum/2-1-5;
1292
1293 break;
1294 }
1295 }
1296
1297 //fTSDivNum = 0x01;
1298 u8Data = (MS_U8)fTSDivNum;
1299
1300 #ifdef MS_DEBUG
1301 ULOGD("DEMOD", ">>>INTERN_DVBS_GetLock TsClkDivNum = 0x%x<<<\n", u8Data);
1302 #endif
1303
1304 if (u8Data > 0x1F)
1305 u8Data = 0x1F;
1306
1307 HAL_DMD_RIU_WriteByte(0x103300, u8Data);
1308
1309 //Ts Output Enable
1310 HAL_DMD_RIU_WriteByte(0x101eaa,0x10);
1311 }
1312
1313 }
1314 else
1315 {
1316 return false;
1317 }
1318
1319 #ifdef MS_DEBUG
1320 //if(*(Drv_DVBS_GetLockWithRFPower_Transform.eLockStatus)==DMD_DVBS_LOCK)
1321 if(*(Drv_DVBS_GetLockWithRFPower.eLockStatus)==DMD_DVBS_LOCK)
1322 {
1323 ULOGD("DEMOD","check in drv layer DVBS demod locked!!\n");
1324 }
1325 else
1326 {
1327 ULOGD("DEMOD","check in drv layer DVBS demod unlock!!\n");
1328 return false;
1329 }
1330 #endif
1331
1332 return status;
1333 }
1334 #endif
1335
1336 #ifndef MSOS_TYPE_LINUX_KERNEL
MDrv_DMD_DVBS_GetSignalStrength(MS_U16 * u16Strength)1337 MS_BOOL MDrv_DMD_DVBS_GetSignalStrength(MS_U16 *u16Strength)
1338 {
1339 return MDrv_DMD_DVBS_GetSignalStrengthWithRFPower(u16Strength, 200.0f);
1340 }
1341 #endif
1342
1343 #ifndef MSOS_TYPE_LINUX_KERNEL
MDrv_DMD_DVBS_GetSignalStrengthWithRFPower(MS_U16 * u16Strength,float fRFPowerDbm)1344 MS_BOOL MDrv_DMD_DVBS_GetSignalStrengthWithRFPower(MS_U16 *u16Strength, float fRFPowerDbm)
1345 {
1346 MS_BOOL status = true;
1347
1348 DMD_IFAGC_SSI *ifagc_ssi;
1349 DMD_IFAGC_ERR *ifagc_err;
1350 float ch_power_rf=0.0f;
1351 float ch_power_db=0.0f, ch_power_db_rel=0.0f;
1352 float ch_power_if=0.0f, ch_power_ifa = 0.0f, ch_power_ifb =0.0f;
1353 MS_U16 if_agc_val =0, if_agc_vala =0, if_agc_valb =0, if_agc_val_lsb =0, i;
1354 float ch_power_takeover=0.0f;
1355 MS_U8 ssi_tbl_len = 0, err_tbl_len = 0;
1356
1357 MS_U8 ifagc_reg;
1358 MS_U8 ifagc_reg_lsb;
1359 MS_U16 ifagc_err_reg;
1360
1361 // float ch_power_db=0.0f, ch_power_db_rel=0.0f;
1362 DMD_DVBS_DEMOD_TYPE pDemodType;
1363 MS_U8 u8_DVBS2_CurrentCodeRateLocal;
1364 MS_U8 u8_DVBS2_CurrentConstellationLocal;
1365 //MS_U16 u16Data=0;
1366 //MS_U8 u8Index;
1367 //DMD_DVBS_MODULATION_TYPE Qam_mode;
1368 // MS_U16 SymbolRate;
1369 // float FreqOff;
1370
1371 //DVBS_GetSignalStrengthWithRFPower_PARAM Drv_DVBS_GetSignalStrengthWithRFPower_PARAM;
1372 //Drv_DVBS_GetSignalStrengthWithRFPower_PARAM.u16Strength=u16Strength;
1373 //Drv_DVBS_GetSignalStrengthWithRFPower_PARAM.fRFPowerDbm=fRFPowerDbm;
1374
1375 DVBS_GetIFAGC_PARAM Drv_DVBS_GetIFAGC_PARAM;
1376 Drv_DVBS_GetIFAGC_PARAM.ifagc_reg=&ifagc_reg;
1377 Drv_DVBS_GetIFAGC_PARAM.ifagc_reg_lsb=&ifagc_reg_lsb;
1378 Drv_DVBS_GetIFAGC_PARAM.ifagc_err_reg=&ifagc_err_reg;
1379 Drv_DVBS_GetIFAGC_PARAM.ret=false;
1380
1381 /*
1382 DVBS_GetTunrSignalLevel_PWR_PARAM Drv_DVBS_GetTunrSignalLevel_PWR_PARAM;
1383 Drv_DVBS_GetTunrSignalLevel_PWR_PARAM.u16Data=&u16Data;
1384 Drv_DVBS_GetTunrSignalLevel_PWR_PARAM.bRet=false;
1385 */
1386 DVBS_GetSignalStrengthWithRFPower_PARAM Drv_DVBS_GetSignalStrengthWithRFPower_PARAM;
1387 Drv_DVBS_GetSignalStrengthWithRFPower_PARAM.fRFPowerDbm=(MS_U16)fRFPowerDbm;
1388 Drv_DVBS_GetSignalStrengthWithRFPower_PARAM.pDemodType=&pDemodType;
1389 Drv_DVBS_GetSignalStrengthWithRFPower_PARAM.u8_DVBS2_CurrentCodeRateLocal=&u8_DVBS2_CurrentCodeRateLocal;
1390 Drv_DVBS_GetSignalStrengthWithRFPower_PARAM.u8_DVBS2_CurrentConstellationLocal=&u8_DVBS2_CurrentConstellationLocal;
1391 Drv_DVBS_GetSignalStrengthWithRFPower_PARAM.ret=false;
1392
1393 if(u32DVBSopen==1)
1394 {
1395
1396 if((AgcSsi_Para.pTuner_IfagcSsi_HiRef != NULL) && (AgcSsi_Para.pTuner_IfagcSsi_LoRef != NULL))
1397 {
1398 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_GetIFAGC,&Drv_DVBS_GetIFAGC_PARAM);
1399 status &= Drv_DVBS_GetIFAGC_PARAM.ret;
1400
1401 ch_power_rf = fRFPowerDbm;
1402
1403 if_agc_val = ifagc_reg;
1404 if_agc_val_lsb = ifagc_reg_lsb;
1405
1406 ifagc_ssi = AgcSsi_Para.pTuner_IfagcSsi_LoRef;
1407 ssi_tbl_len = AgcSsi_Para.u16Tuner_IfagcSsi_LoRef_Size;
1408 ifagc_err = AgcSsi_Para.pTuner_IfagcErr_LoRef;
1409 err_tbl_len = AgcSsi_Para.u16Tuner_IfagcErr_LoRef_Size;
1410
1411 ch_power_if=ifagc_ssi[0].power_db;
1412 if (if_agc_val >=ifagc_ssi[0].agc_val)
1413 {
1414 for(i = 1; i < ssi_tbl_len; i++)
1415 {
1416 if (if_agc_val < ifagc_ssi[i].agc_val)
1417 {
1418 if_agc_valb = ifagc_ssi[i].agc_val;
1419 ch_power_ifb = ifagc_ssi[i].power_db;
1420
1421 i--;
1422 if_agc_vala = ifagc_ssi[i].agc_val;
1423 ch_power_ifa=ifagc_ssi[i].power_db;
1424 while ((i>1) && (if_agc_vala==ifagc_ssi[i-1].agc_val))
1425 {
1426 ch_power_ifa=ifagc_ssi[i-1].power_db;
1427 i--;
1428 }
1429 ch_power_if = ch_power_ifa+(ch_power_ifb-ch_power_ifa)*(float)((if_agc_val-if_agc_vala)*256+if_agc_val_lsb)/((if_agc_valb-if_agc_vala)*256);
1430 break;
1431 }
1432 }
1433 }
1434 #ifdef MS_DEBUG
1435 ULOGD("DEMOD","if prev %f %x\n", ch_power_ifa, if_agc_vala);
1436 ULOGD("DEMOD","if next %f %x\n", ch_power_ifb, if_agc_valb);
1437 #endif
1438
1439 for(i = 0; i < ssi_tbl_len; i++)
1440 {
1441 if (ifagc_ssi[i].agc_val <= ifagc_ssi[i+1].agc_val)
1442 {
1443 ch_power_takeover = ifagc_ssi[i+1].power_db;
1444 break;
1445 }
1446 }
1447
1448 #ifdef MS_DEBUG
1449 ULOGD("DEMOD","ch_power_rf = %f\n", ch_power_rf);
1450 ULOGD("DEMOD","ch_power_if = %f\n", ch_power_if);
1451 ULOGD("DEMOD","ch_power_takeover = %f\n", ch_power_takeover);
1452 #endif
1453
1454 // ch_power_db = (ch_power_rf > ch_power_if)? ch_power_rf : ch_power_if;
1455
1456 if(ch_power_rf > (ch_power_takeover + 0.5))
1457 {
1458 ch_power_db = ch_power_rf;
1459 }
1460 else if(ch_power_if < (ch_power_takeover - 0.5))
1461 {
1462 ch_power_db = ch_power_if;
1463 }
1464 else
1465 {
1466 ch_power_db = (ch_power_if + ch_power_rf)/2;
1467 }
1468
1469 // ch_power_db = (ch_power_rf > ch_power_if)? ch_power_if : ch_power_rf;
1470
1471 if(if_agc_val == 0xff)
1472 {
1473 for(i = 0; i < err_tbl_len; i++)
1474 {
1475 if ( ifagc_err_reg <= ifagc_err[i].agc_err ) // signed char comparison
1476 {
1477 ch_power_db += ifagc_err[i].attn_db;
1478 break;
1479 }
1480 }
1481 #ifdef MS_DEBUG
1482 ULOGD("DEMOD","if_agc_err = 0x%x\n", ifagc_err_reg);
1483 #endif
1484 }
1485 }
1486 else
1487 {
1488 #ifdef MS_DEBUG
1489 if (fRFPowerDbm>=100.0) // unreasonable input value, get RF level from RFAGG
1490 {
1491 ULOGD("DEMOD","Error!! please add AGC table\n");
1492 }
1493 #endif
1494 ch_power_db = fRFPowerDbm;
1495 }
1496 /*
1497 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_GetTunrSignalLevel_PWR,&Drv_DVBS_GetTunrSignalLevel_PWR_PARAM);
1498 status &= Drv_DVBS_GetTunrSignalLevel_PWR_PARAM.bRet;
1499 if (u8DemodLockFlag == 0 || status == FALSE)//Demod unlock
1500 {
1501 ch_power_db = 0;
1502 DMD_DBG(ULOGD("DEMOD","[drvDMD_INTERN_DVBS.c]INTERN_DVBS GetSignalStrength failed\n"));
1503 }
1504 else
1505 {
1506 for (u8Index=0; u8Index < (sizeof(_u16SignalLevel)/sizeof(_u16SignalLevel[0])); u8Index++)
1507 {
1508 if ((65535 - u16Data) <= _u16SignalLevel[u8Index][0])
1509 {
1510 if (u8Index >=1)
1511 {
1512 ch_power_db = (float)(_u16SignalLevel[u8Index][1])+((float)(_u16SignalLevel[u8Index][0] - (65535 - u16Data)) / (float)(_u16SignalLevel[u8Index][0] - _u16SignalLevel[u8Index-1][0]))*(float)(_u16SignalLevel[u8Index-1][1] - _u16SignalLevel[u8Index][1]);
1513 }
1514 else
1515 {
1516 ch_power_db = _u16SignalLevel[u8Index][1];
1517 }
1518 break;
1519 }
1520 }
1521 //----------
1522 if (ch_power_db >= 350)
1523 ch_power_db = ch_power_db - 35;
1524 else if ((ch_power_db < 350) && (ch_power_db >= 250))
1525 ch_power_db = ch_power_db - 25;
1526 else
1527 ch_power_db = ch_power_db - 5;
1528
1529 if (ch_power_db < 0)
1530 ch_power_db = 0;
1531 if (ch_power_db > 920)
1532 ch_power_db = 920;
1533
1534 ch_power_db = (-1.0)*(ch_power_db/10.0);
1535 //DBG_INTERN_DVBS(printf("INTERN_DVBS GetSignalStrength %f\n", ch_power_db));
1536 DMD_DBG(ULOGD("DEMOD","[drvDMD_INTERN_DVBS.c]INTERN_DVBS GetSignalStrength %f\n", ch_power_db));
1537 }
1538 */
1539 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_GetSignalStrengthWithRFPower,&Drv_DVBS_GetSignalStrengthWithRFPower_PARAM);
1540 status &= Drv_DVBS_GetSignalStrengthWithRFPower_PARAM.ret;
1541
1542 #if 1
1543 if((MS_U8)pDemodType == (MS_U8)DMD_SAT_DVBS)//S
1544 {
1545 float fDVBS_SSI_Pref[]=
1546 {
1547 //0, 1, 2, 3, 4
1548 -78.9, -77.15, -76.14, -75.19, -74.57,//QPSK
1549 };
1550 //status &= MDrv_SYS_DMD_VD_MBX_ReadReg(DVBSTFEC_REG_BASE + 0x84, &u8Data);
1551 //u8_DVBS2_CurrentCodeRateLocal = (u8Data & 0x07);
1552 ch_power_db_rel = ch_power_db - fDVBS_SSI_Pref[u8_DVBS2_CurrentCodeRateLocal];
1553 }
1554 else
1555 {
1556 #if 0
1557 float fDVBS2_SSI_Pref[][11]=
1558 {
1559 // 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
1560 //1/4, 1/3, 2/5, 1/2, 3/5, 2/3, 3/4, 4/5, 5/6, 8/9, 9/10
1561 {-85.17, -84.08, -83.15, -81.86, -80.63, -79.77, -78.84, -78.19, -77.69, -76.68, -76.46}, //QPSK
1562 { 0.0, 0.0, 0.0, 0.0, -77.36, -76.24, -74.95, 0.0, -73.52, -72.18, -71.84} //8PSK
1563 };
1564 #endif
1565 /*
1566 status &= MDrv_SYS_DMD_VD_MBX_ReadReg(DVBS2_INNER_REG_BASE + 0xD7, &u8Data);
1567 u8_DVBS2_CurrentCodeRateLocal = (u8Data & 0x3C)>>2;
1568
1569 status &= MDrv_SYS_DMD_VD_MBX_ReadReg(DVBS2_INNER_REG_BASE + 0xD7, &u8Data);
1570 status &= MDrv_SYS_DMD_VD_MBX_ReadReg(DVBS2_INNER_REG_BASE + 0xD6, &u8Data2);
1571
1572 if(((u8Data & 0x03)==0x01) && ((u8Data2 & 0x80)==0x00))
1573 {
1574 _u8_DVBS2_CurrentConstellationLocal = DMD_DVBS_QPSK;
1575 }
1576 else if (((u8Data & 0x03)==0x01) && ((u8Data2 & 0x80)==0x80))
1577 {
1578 _u8_DVBS2_CurrentConstellationLocal = DMD_DVBS_8PSK;//8PSK
1579 }
1580 */
1581 ch_power_db_rel = ch_power_db - (-80);//fDVBS2_SSI_Pref[u8_DVBS2_CurrentConstellationLocal][u8_DVBS2_CurrentCodeRateLocal];
1582 }
1583 #endif
1584
1585 if(ch_power_db_rel <= -15.0f)
1586 {
1587 *u16Strength= 0;
1588 }
1589 else if (ch_power_db_rel <= 0.0f)
1590 {
1591 *u16Strength = (MS_U16)(2.0f/3 * (ch_power_db_rel+15.0f));
1592 }
1593 else if (ch_power_db_rel <= 20.0f)
1594 {
1595 *u16Strength = (MS_U16)(4.0f * ch_power_db_rel + 10.0f);
1596 }
1597 else if (ch_power_db_rel <= 35.0f)
1598 {
1599 *u16Strength = (MS_U16)(2.0f/3 * (ch_power_db_rel-20.0f) + 90.0);
1600 }
1601 else
1602 {
1603 *u16Strength = 100;
1604 }
1605
1606 //ULOGD("DEMOD","Signal Strength(SSI) = %d \n", (int)*u16Strength);
1607 sDMD_DVBS_Info.u16Strength=*u16Strength;
1608 }
1609
1610 else
1611 {
1612 return false;
1613 }
1614
1615 return status;
1616 }
1617 #endif
1618
1619 #ifndef MSOS_TYPE_LINUX_KERNEL
MDrv_DMD_DVBS_GetSignalQuality(MS_U16 * u16Quality)1620 MS_BOOL MDrv_DMD_DVBS_GetSignalQuality(MS_U16 *u16Quality)
1621 {
1622 return MDrv_DMD_DVBS_GetSignalQualityWithRFPower(u16Quality, 200.0f);
1623 }
1624 #endif
1625
1626 #ifndef MSOS_TYPE_LINUX_KERNEL
MDrv_DMD_DVBS_GetSignalQualityWithRFPower(MS_U16 * u16Quality,float fRFPowerDbm)1627 MS_BOOL MDrv_DMD_DVBS_GetSignalQualityWithRFPower(MS_U16 *u16Quality, float fRFPowerDbm)
1628 {
1629 MS_BOOL bRet;
1630 float fber = 0.0;
1631 //float log_ber;
1632 MS_BOOL status = TRUE;
1633 float f_snr = 0.0, ber_sqi = 0.0, cn_rel = 0.0;
1634 //MS_U8 u8Data =0;
1635 DMD_DVBS_CODE_RATE_TYPE _u8_DVBS2_CurrentCodeRateLocal ;
1636 MS_U16 bchpkt_error,BCH_Eflag2_Window;
1637 //fRFPowerDbm = fRFPowerDbm;
1638 float snr_poly =0.0;
1639 float Fixed_SNR =0.0;
1640 double eFlag_PER=0.0;
1641
1642
1643 if(u32DVBSopen==1)
1644 {
1645 if (u8DemodLockFlag == 1)
1646 // if (TRUE == INTERN_DVBS_GetLock(DMD_DVBS_GETLOCK, 200.0f, -200.0f, 0))
1647 {
1648 if(_bDemodType) //S2
1649 {
1650
1651 MDrv_DMD_DVBS_GetSNR(&f_snr);
1652 snr_poly = 0.005261367463671*pow(f_snr, 3)-0.116517828301214*pow(f_snr, 2)+0.744836970505452*pow(f_snr, 1)-0.86727609780167;
1653 Fixed_SNR = f_snr + snr_poly;
1654
1655 if (Fixed_SNR < 17.0)
1656 Fixed_SNR = Fixed_SNR;
1657 else if ((Fixed_SNR < 20.0) && (Fixed_SNR >= 17.0))
1658 Fixed_SNR = Fixed_SNR - 0.8;
1659 else if ((Fixed_SNR < 22.5) && (Fixed_SNR >= 20.0))
1660 Fixed_SNR = Fixed_SNR - 2.0;
1661 else if ((Fixed_SNR < 27.0) && (Fixed_SNR >= 22.5))
1662 Fixed_SNR = Fixed_SNR - 3.0;
1663 else if ((Fixed_SNR < 29.0) && (Fixed_SNR >= 27.0))
1664 Fixed_SNR = Fixed_SNR - 3.5;
1665 else if (Fixed_SNR >= 29.0)
1666 Fixed_SNR = Fixed_SNR - 3.0;
1667
1668
1669 if (Fixed_SNR < 1.0)
1670 Fixed_SNR = 1.0;
1671 if (Fixed_SNR > 30.0)
1672 Fixed_SNR = 30.0;
1673
1674 //BCH EFLAG2_Window, window size 0x2000
1675 BCH_Eflag2_Window=0x2000;
1676 MDrv_SYS_DMD_VD_MBX_WriteReg(DVBS2FEC_REG_BASE + 0x25*2 + 1, (BCH_Eflag2_Window>>8));
1677 MDrv_SYS_DMD_VD_MBX_WriteReg(DVBS2FEC_REG_BASE + 0x25*2 , (BCH_Eflag2_Window&0xff));
1678 MDrv_DMD_DVBS_GetPacketErr(&bchpkt_error);
1679 eFlag_PER = (float)(bchpkt_error)/(float)(BCH_Eflag2_Window);
1680 if(eFlag_PER>0)
1681 fber = 0.089267531133002*pow(eFlag_PER, 2) + 0.019640560289510*eFlag_PER + 0.0000001;
1682 else
1683 fber = 0;
1684
1685 #ifdef MSOS_TYPE_LINUX
1686 //log_ber = ( - 1) *log10f(1 / fber);
1687 if (fber > 1.0E-1)
1688 ber_sqi = (log10f(1.0f/fber))*20.0f + 8.0f;
1689 else if(fber > 8.5E-7)
1690 ber_sqi = (log10f(1.0f/fber))*20.0f - 30.0f;
1691 else
1692 ber_sqi = 100.0;
1693 #else
1694 //log_ber = ( - 1) *Log10Approx(1 / fber);
1695 if (fber > 1.0E-1)
1696 ber_sqi = (Log10Approx(1.0f/fber))*20.0f + 8.0f;
1697 else if(fber > 8.5E-7)
1698 ber_sqi = (Log10Approx(1.0f/fber))*20.0f - 30.0f;
1699 else
1700 ber_sqi = 100.0;
1701
1702 #endif
1703
1704 *u16Quality = Fixed_SNR/30*ber_sqi;
1705 //DBG_INTERN_DVBS(printf(" Fixed_SNR %f\n",Fixed_SNR));
1706 //DBG_INTERN_DVBS(printf(" BCH_Eflag2_Window %d\n",BCH_Eflag2_Window));
1707 //DBG_INTERN_DVBS(printf(" eFlag_PER [%f]\n fber [%8.3e]\n ber_sqi [%f]\n",eFlag_PER,fber,ber_sqi));
1708 }
1709 else //S
1710 {
1711 if (MDrv_DMD_DVBS_GetPostViterbiBer(&fber) == FALSE)//ViterbiBer
1712 {
1713 ULOGD("DEMOD","GetPostViterbiBer Fail! \n");
1714 bRet= FALSE;
1715 }
1716 //_fPostBer=fber;
1717
1718
1719 if (status==FALSE)
1720 {
1721 ULOGD("DEMOD","Maserati_GetSignalQuality GetPostViterbiBer Fail! \n");
1722 bRet= FALSE;
1723 }
1724 float fDVBS_SQI_CNref[]=
1725 { //0, 1, 2, 3, 4
1726 4.2, 5.9, 6, 6.9, 7.5,//QPSK
1727 };
1728
1729 DVBS_GetCurrentDemodCodeRate_PARAM Drv_DVBS_GetCurrentDemodCodeRate_PARAM;
1730 Drv_DVBS_GetCurrentDemodCodeRate_PARAM.pCodeRate=&_u8_DVBS2_CurrentCodeRateLocal;
1731 Drv_DVBS_GetCurrentDemodCodeRate_PARAM.bRet=false;
1732 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_GetCurrentDemodCodeRate,&Drv_DVBS_GetCurrentDemodCodeRate_PARAM);
1733 #if 0
1734 #ifdef MSOS_TYPE_LINUX
1735 log_ber = ( - 1.0f) *log10f(1.0f / fber); //BY modify
1736 #else
1737 log_ber = ( - 1.0f) *Log10Approx(1.0f / fber); //BY modify
1738 #endif
1739 DBG_INTERN_DVBS(printf("\nLog(BER) = %f\n",log_ber));
1740 #endif
1741 if (fber > 2.5E-2)
1742 ber_sqi = 0.0;
1743 else if(fber > 8.5E-7)
1744 #ifdef MSOS_TYPE_LINUX
1745 ber_sqi = (log10f(1.0f/fber))*20.0f - 32.0f; //40.0f;
1746 #else
1747 ber_sqi = (Log10Approx(1.0f/fber))*20.0f - 32.0f;//40.0f;
1748 #endif
1749 else
1750 ber_sqi = 100.0;
1751
1752 status &= MDrv_DMD_DVBS_GetSNR(&f_snr);
1753 ULOGD("DEMOD","drv_DVBS_GetSNR = %d \n", (int)f_snr );
1754 cn_rel = f_snr - fDVBS_SQI_CNref[_u8_DVBS2_CurrentCodeRateLocal];
1755
1756 ULOGD("DEMOD","fber = %f\n", fber );
1757 ULOGD("DEMOD","f_snr = %f\n", f_snr );
1758 ULOGD("DEMOD","cn_nordig_s1 = %f\n", fDVBS_SQI_CNref[_u8_DVBS2_CurrentCodeRateLocal] );
1759 ULOGD("DEMOD","cn_rel = %f\n", cn_rel );
1760 ULOGD("DEMOD","ber_sqi = %f\n", ber_sqi );
1761
1762 if (cn_rel < -7.0f)
1763 {
1764 *u16Quality = 0;
1765 }
1766 else if (cn_rel < 3.0)
1767 {
1768 *u16Quality = (MS_U16)(ber_sqi*((cn_rel - 3.0)/10.0 + 1.0));
1769 }
1770 else
1771 {
1772 *u16Quality = (MS_U16)ber_sqi;
1773 }
1774
1775
1776 }
1777 //INTERN_DVBS_GetTunrSignalLevel_PWR();//For Debug.
1778 //ULOGD("DEMOD","Signal Quility(SQI) = %d\n", *u16Quality );
1779 bRet= TRUE;
1780 }
1781 else
1782 {
1783 *u16Quality = 0;
1784 }
1785 bRet= TRUE;
1786 sDMD_DVBS_Info.u16Quality=*u16Quality;
1787 }
1788 else
1789 {
1790 return false;
1791 }
1792 return bRet;
1793 }
1794 #endif
1795
1796 #ifdef CHIP_KAISER
MDrv_DMD_DVBS_ActiveDmdSwitch(MS_U8 demod_no)1797 MS_BOOL MDrv_DMD_DVBS_ActiveDmdSwitch(MS_U8 demod_no)
1798 {
1799 DVBS_ActiveDmdSwitch_PARAM Drv_DVBS_ActiveDmdSwitch_PARAM;
1800 Drv_DVBS_ActiveDmdSwitch_PARAM.demod_no=demod_no;
1801
1802 if(u32DVBSopen==1)
1803 {
1804 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_ActiveDmdSwitch,&Drv_DVBS_ActiveDmdSwitch_PARAM);
1805 }
1806 else
1807 {
1808 return false;
1809 }
1810
1811 return Drv_DVBS_ActiveDmdSwitch_PARAM.ret;
1812 }
1813 #else
MDrv_DMD_DVBS_ActiveDmdSwitch(MS_U8 demod_no)1814 MS_BOOL MDrv_DMD_DVBS_ActiveDmdSwitch(MS_U8 demod_no)
1815 {
1816 ULOGD("DEMOD","Doesn't support DVBS_ActiveDmdSwitch function!!!\n");
1817 return false;
1818 }
1819 #endif
1820
1821 #ifndef MSOS_TYPE_LINUX_KERNEL
MDrv_DMD_DVBS_GetSNR(float * fSNR)1822 MS_BOOL MDrv_DMD_DVBS_GetSNR(float *fSNR)
1823 {
1824 MS_U32 u32NDA_SNR_A =0;
1825 MS_U32 u32NDA_SNR_AB =0;
1826 //float NDA_SNR_A =0.0;
1827 //float NDA_SNR_AB =0.0;
1828 float NDA_SNR =0.0;
1829 //double NDA_SNR_LINEAR=0.0;
1830
1831 DVBS_GetSNR_PARAM Drv_DVBS_GetSNR_PARAM;
1832 Drv_DVBS_GetSNR_PARAM.u32NDA_SNR_A=&u32NDA_SNR_A;
1833 Drv_DVBS_GetSNR_PARAM.u32NDA_SNR_AB=&u32NDA_SNR_AB;
1834 Drv_DVBS_GetSNR_PARAM.ret = false;
1835
1836 if(u32DVBSopen==1)
1837 {
1838 if (u8DemodLockFlag == 0)
1839 {
1840 Drv_DVBS_GetSNR_PARAM.ret=FALSE;
1841 }
1842 else
1843 {
1844 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_GetSNR,&Drv_DVBS_GetSNR_PARAM);
1845 }
1846
1847 if (Drv_DVBS_GetSNR_PARAM.ret== FALSE)
1848 {
1849 ULOGD("DEMOD","DVBS_GetSNR Fail! \n");
1850 }
1851 else
1852 {
1853 #if 0
1854 //NDA SNR
1855 NDA_SNR_A=(float)u32NDA_SNR_A/65536;
1856 NDA_SNR_AB=(float)u32NDA_SNR_AB/4194304;
1857 //
1858 //since support 16,32APSK we need to add judgement
1859 if(modulation_order==4)
1860 NDA_SNR_AB=(float)sqrt(NDA_SNR_AB/(2-1.252295758529242));//for 16APSK CR2/3
1861 else if(modulation_order==5)//(2-1.41333232789)
1862 NDA_SNR_AB=(float)sqrt(NDA_SNR_AB/(2-1.41333232789));//for 32APSK CR3/4
1863 else
1864 NDA_SNR_AB=(float)sqrt(NDA_SNR_AB);
1865
1866 NDA_SNR_LINEAR =(1/((NDA_SNR_A/NDA_SNR_AB)-1)) ;
1867
1868 if(NDA_SNR_LINEAR<=0)
1869 NDA_SNR=1.0;
1870 else
1871 NDA_SNR=10*log10(NDA_SNR_LINEAR);
1872
1873 //printf("[DVBS]: NDA_SNR ================================: %.1f\n", NDA_SNR);
1874 //_f_DVBS_CurrentSNR = NDA_SNR;
1875 /*
1876 //[DVBS/S2, QPSK/8PSK, 1/2~9/10 the same CN]
1877 snr_poly = 0.0; //use Polynomial curve fitting to fix SNR
1878 snr_poly = 0.005261367463671*pow(NDA_SNR, 3)-0.116517828301214*pow(NDA_SNR, 2)+0.744836970505452*pow(NDA_SNR, 1)-0.86727609780167;
1879 Fixed_SNR = NDA_SNR + snr_poly;
1880 //printf("[DVBS]: NDA_SNR + snr_poly =====================: %.1f\n", Fixed_SNR);
1881
1882 if (Fixed_SNR < 17.0)
1883 Fixed_SNR = Fixed_SNR;
1884 else if ((Fixed_SNR < 20.0) && (Fixed_SNR >= 17.0))
1885 Fixed_SNR = Fixed_SNR - 0.8;
1886 else if ((Fixed_SNR < 22.5) && (Fixed_SNR >= 20.0))
1887 Fixed_SNR = Fixed_SNR - 2.0;
1888 else if ((Fixed_SNR < 27.0) && (Fixed_SNR >= 22.5))
1889 Fixed_SNR = Fixed_SNR - 3.0;
1890 else if ((Fixed_SNR < 29.0) && (Fixed_SNR >= 27.0))
1891 Fixed_SNR = Fixed_SNR - 3.5;
1892 else if (Fixed_SNR >= 29.0)
1893 Fixed_SNR = Fixed_SNR - 3.0;
1894
1895 if (Fixed_SNR < 1.0)
1896 Fixed_SNR = 1.0;
1897 if (Fixed_SNR > 30.0)
1898 Fixed_SNR = 30.0;
1899 */
1900
1901 #endif
1902
1903 NDA_SNR = u32NDA_SNR_A + ((float)u32NDA_SNR_AB / 256.0);
1904
1905 *fSNR = NDA_SNR;
1906 #ifdef MS_DEBUG
1907 ULOGD("DEMOD", "[DVBS]: NDA_SNR=============================: %.1f\n", NDA_SNR);
1908 #endif
1909 }
1910
1911 Drv_DVBS_GetSNR_PARAM.ret = true;
1912 }
1913 else
1914 {
1915 return false;
1916 }
1917
1918 return Drv_DVBS_GetSNR_PARAM.ret;
1919 }
1920 #endif
1921
1922 #ifdef UFO_SUPPORT_KERNEL_FLOATING
MDrv_DMD_DVBS_GetSNR_Kernel(MS_FLOAT_ST * fSNR)1923 MS_BOOL MDrv_DMD_DVBS_GetSNR_Kernel(MS_FLOAT_ST *fSNR)
1924 {
1925 MS_U32 u32NDA_SNR_A =0;
1926 MS_U32 u32NDA_SNR_AB =0;
1927 //float NDA_SNR_A =0.0;
1928 //float NDA_SNR_AB =0.0;
1929 //float NDA_SNR =0.0;
1930 MS_FLOAT_ST NDA_SNR;
1931 //double NDA_SNR_LINEAR=0.0;
1932
1933 DVBS_GetSNR_PARAM Drv_DVBS_GetSNR_PARAM;
1934 Drv_DVBS_GetSNR_PARAM.u32NDA_SNR_A=&u32NDA_SNR_A;
1935 Drv_DVBS_GetSNR_PARAM.u32NDA_SNR_AB=&u32NDA_SNR_AB;
1936 Drv_DVBS_GetSNR_PARAM.ret = false;
1937
1938 if(u32DVBSopen==1)
1939 {
1940 if (u8DemodLockFlag == 0)
1941 {
1942 Drv_DVBS_GetSNR_PARAM.ret=FALSE;
1943 }
1944 else
1945 {
1946 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_GetSNR,&Drv_DVBS_GetSNR_PARAM);
1947 }
1948
1949 if (Drv_DVBS_GetSNR_PARAM.ret== FALSE)
1950 {
1951 ULOGD("DEMOD","DVBS_GetSNR Fail! \n");
1952 }
1953 else
1954 {
1955 #if 0
1956 //NDA SNR
1957 NDA_SNR_A=(float)u32NDA_SNR_A/65536;
1958 NDA_SNR_AB=(float)u32NDA_SNR_AB/4194304;
1959 //
1960 //since support 16,32APSK we need to add judgement
1961 if(modulation_order==4)
1962 NDA_SNR_AB=(float)sqrt(NDA_SNR_AB/(2-1.252295758529242));//for 16APSK CR2/3
1963 else if(modulation_order==5)//(2-1.41333232789)
1964 NDA_SNR_AB=(float)sqrt(NDA_SNR_AB/(2-1.41333232789));//for 32APSK CR3/4
1965 else
1966 NDA_SNR_AB=(float)sqrt(NDA_SNR_AB);
1967
1968 NDA_SNR_LINEAR =(1/((NDA_SNR_A/NDA_SNR_AB)-1)) ;
1969
1970 if(NDA_SNR_LINEAR<=0)
1971 NDA_SNR=1.0;
1972 else
1973 NDA_SNR=10*log10(NDA_SNR_LINEAR);
1974
1975 //printf("[DVBS]: NDA_SNR ================================: %.1f\n", NDA_SNR);
1976 //_f_DVBS_CurrentSNR = NDA_SNR;
1977 /*
1978 //[DVBS/S2, QPSK/8PSK, 1/2~9/10 the same CN]
1979 snr_poly = 0.0; //use Polynomial curve fitting to fix SNR
1980 snr_poly = 0.005261367463671*pow(NDA_SNR, 3)-0.116517828301214*pow(NDA_SNR, 2)+0.744836970505452*pow(NDA_SNR, 1)-0.86727609780167;
1981 Fixed_SNR = NDA_SNR + snr_poly;
1982 //printf("[DVBS]: NDA_SNR + snr_poly =====================: %.1f\n", Fixed_SNR);
1983
1984 if (Fixed_SNR < 17.0)
1985 Fixed_SNR = Fixed_SNR;
1986 else if ((Fixed_SNR < 20.0) && (Fixed_SNR >= 17.0))
1987 Fixed_SNR = Fixed_SNR - 0.8;
1988 else if ((Fixed_SNR < 22.5) && (Fixed_SNR >= 20.0))
1989 Fixed_SNR = Fixed_SNR - 2.0;
1990 else if ((Fixed_SNR < 27.0) && (Fixed_SNR >= 22.5))
1991 Fixed_SNR = Fixed_SNR - 3.0;
1992 else if ((Fixed_SNR < 29.0) && (Fixed_SNR >= 27.0))
1993 Fixed_SNR = Fixed_SNR - 3.5;
1994 else if (Fixed_SNR >= 29.0)
1995 Fixed_SNR = Fixed_SNR - 3.0;
1996
1997 if (Fixed_SNR < 1.0)
1998 Fixed_SNR = 1.0;
1999 if (Fixed_SNR > 30.0)
2000 Fixed_SNR = 30.0;
2001 */
2002
2003 #endif
2004
2005 //NDA_SNR = u32NDA_SNR_A + ((float)u32NDA_SNR_AB / 256.0);
2006
2007 NDA_SNR.DATA = ((u32NDA_SNR_A << 8) | u32NDA_SNR_AB);
2008 NDA_SNR.EXP = -8;
2009
2010 *fSNR = NDA_SNR;
2011 #ifdef MS_DEBUG
2012 ULOGD("DEMOD", "[DVBS]: NDA_SNR=============================: %d*2^%d\n", NDA_SNR.DATA, NDA_SNR.EXP);
2013 #endif
2014 }
2015 }
2016
2017 return Drv_DVBS_GetSNR_PARAM.ret;
2018 }
2019 #endif
2020
2021 #ifndef MSOS_TYPE_LINUX_KERNEL
MDrv_DMD_DVBS_GetPostViterbiBer(float * ber)2022 MS_BOOL MDrv_DMD_DVBS_GetPostViterbiBer(float *ber)
2023 {
2024 MS_U16 BitErrPeriod_reg;
2025 MS_U32 BitErr_reg;
2026
2027 DVBS_GetPostViterbiBer_PARAM Drv_DVBS_GetPostViterbiBer_PARAM;
2028 Drv_DVBS_GetPostViterbiBer_PARAM.BitErr_reg=&BitErr_reg;
2029 Drv_DVBS_GetPostViterbiBer_PARAM.BitErrPeriod_reg=&BitErrPeriod_reg;
2030 Drv_DVBS_GetPostViterbiBer_PARAM.ret=false;
2031
2032 if(u32DVBSopen==1)
2033 {
2034 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_GetPostViterbiBer,&Drv_DVBS_GetPostViterbiBer_PARAM);
2035
2036 if (BitErrPeriod_reg == 0 ) //PRD
2037 BitErrPeriod_reg = 1;
2038
2039 if(_bDemodType) //DVBS2
2040 {
2041 if (BitErr_reg <= 0 )
2042 *ber = 0.5f / (float)(BitErrPeriod_reg) / 64800.0;
2043 else
2044 *ber = (float)BitErr_reg / (float)(BitErrPeriod_reg) / 64800.0;
2045
2046 if (*ber <= 0.0f)
2047 *ber = 1.0e-10f;
2048
2049 DMD_DBG(ULOGD("DEMOD","BER = %8.3e \n ", *ber));
2050 }
2051 else
2052 {
2053 if (BitErr_reg <= 0 )
2054 *ber = 0.5f / ((float)BitErrPeriod_reg*128*188*8);
2055 else
2056 *ber = (float)BitErr_reg / ((float)BitErrPeriod_reg*128*188*8);
2057
2058 if (*ber <= 0.0f)
2059 *ber = 1.0e-10f;
2060
2061 DMD_DBG(ULOGD("DEMOD","PostVitBER = %8.3e \n ", *ber));
2062 }
2063
2064 Drv_DVBS_GetPostViterbiBer_PARAM.ret=true;
2065 }
2066
2067 return Drv_DVBS_GetPostViterbiBer_PARAM.ret;
2068 }
2069 #endif
2070
2071 #ifdef UFO_SUPPORT_KERNEL_FLOATING
MDrv_DMD_DVBS_GetBER_Kernel(MS_FLOAT_ST * ber)2072 MS_BOOL MDrv_DMD_DVBS_GetBER_Kernel(MS_FLOAT_ST *ber)
2073 {
2074 MS_U16 BitErrPeriod_reg;
2075 MS_U32 BitErr_reg;
2076
2077 MS_FLOAT_ST temp;
2078
2079 DVBS_GetPostViterbiBer_PARAM Drv_DVBS_GetPostViterbiBer_PARAM;
2080 Drv_DVBS_GetPostViterbiBer_PARAM.BitErr_reg=&BitErr_reg;
2081 Drv_DVBS_GetPostViterbiBer_PARAM.BitErrPeriod_reg=&BitErrPeriod_reg;
2082 Drv_DVBS_GetPostViterbiBer_PARAM.ret=false;
2083
2084 if(u32DVBSopen==1)
2085 {
2086 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_GetPostViterbiBer,&Drv_DVBS_GetPostViterbiBer_PARAM);
2087
2088 if(BitErrPeriod_reg == 0)
2089 {
2090 (*ber).DATA = 1;
2091 (*ber).EXP = 0;
2092 }
2093 else if(BitErr_reg == 0)
2094 {
2095 (*ber).DATA = 0;
2096 (*ber).EXP = 0;
2097 }
2098 else
2099 {
2100 (*ber).DATA = BitErr_reg;
2101 (*ber).EXP = 0;
2102
2103 if(_bDemodType) //DVBS2
2104 {
2105 temp.DATA = BitErrPeriod_reg*64800;
2106 temp.EXP = 0;
2107 }
2108 else
2109 {
2110 temp.DATA = BitErrPeriod_reg*128*188*8;
2111 temp.EXP = 0;
2112 }
2113
2114 *ber = MS_FLOAT_OP(*ber, temp, divide);
2115 }
2116
2117 DMD_DBG(ULOGD("DEMOD","BER = %d*2^%d \n", (*ber).DATA, (*ber).EXP));
2118 }
2119
2120 return Drv_DVBS_GetPostViterbiBer_PARAM.ret;
2121 }
2122 #endif
MDrv_DMD_DVBS_GetPacketErr(MS_U16 * pktErr)2123 MS_BOOL MDrv_DMD_DVBS_GetPacketErr(MS_U16 *pktErr)
2124 {
2125 DVBS_GetPacketErr_PARAM Drv_DVBS_GetPacketErr_PARAM;
2126 Drv_DVBS_GetPacketErr_PARAM.pktErr=pktErr;
2127 Drv_DVBS_GetPacketErr_PARAM.ret=false;
2128
2129 if(u32DVBSopen==1)
2130 {
2131 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_GetPacketErr,&Drv_DVBS_GetPacketErr_PARAM);
2132 }
2133
2134 return Drv_DVBS_GetPacketErr_PARAM.ret;
2135 }
2136
MDrv_DMD_DVBS_GetCellID(MS_U16 * u16CellID)2137 MS_BOOL MDrv_DMD_DVBS_GetCellID(MS_U16 *u16CellID)
2138 {
2139 DVBS_GetCellID_PARAM Drv_DVBS_GetCellID_PARAM;
2140 Drv_DVBS_GetCellID_PARAM.u16CellID=u16CellID;
2141 Drv_DVBS_GetCellID_PARAM.ret=false;
2142
2143 if(u32DVBSopen==1)
2144 {
2145 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_GetCellID,&Drv_DVBS_GetCellID_PARAM);
2146 }
2147 else
2148 {
2149 return false;
2150 }
2151
2152 return Drv_DVBS_GetCellID_PARAM.ret;
2153
2154 }
2155
2156
2157 #ifndef MSOS_TYPE_LINUX_KERNEL
MDrv_DMD_DVBS_GetStatus(DMD_DVBS_MODULATION_TYPE * pQAMMode,MS_U32 * u32SymbolRate,float * pFreqOff)2158 MS_BOOL MDrv_DMD_DVBS_GetStatus(DMD_DVBS_MODULATION_TYPE *pQAMMode, MS_U32 *u32SymbolRate, float *pFreqOff)
2159 {
2160 MS_S16 s16CFO=0;
2161
2162 DVBS_GetStatus_PARAM Drv_DVBS_GetStatus_PARAM;
2163 Drv_DVBS_GetStatus_PARAM.pQAMMode=pQAMMode;
2164 Drv_DVBS_GetStatus_PARAM.u32SymbolRate=u32SymbolRate;
2165 Drv_DVBS_GetStatus_PARAM.s16CFO=&s16CFO;
2166 Drv_DVBS_GetStatus_PARAM.ret=false;
2167
2168 //float f_Fc, FreqCfo_offset;
2169
2170 if(u32DVBSopen==1)
2171 {
2172 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_GetStatus,&Drv_DVBS_GetStatus_PARAM);
2173 if(abs(s16CFO)%1000 >= 500)
2174 {
2175 if(s16CFO < 0)
2176 *pFreqOff=(s16CFO/1000)-1.0;
2177 else
2178 *pFreqOff=(s16CFO/1000)+1.0;
2179 }
2180 else
2181 *pFreqOff = s16CFO/1000;
2182
2183 *pQAMMode = *(Drv_DVBS_GetStatus_PARAM.pQAMMode);
2184 *u32SymbolRate = *(Drv_DVBS_GetStatus_PARAM.u32SymbolRate);
2185
2186 #ifdef MS_DEBUG
2187 if (_u8DMD_DVBS_DbgLevel >= DMD_DVBS_DBGLV_INFO)
2188 {
2189 ULOGD("DEMOD","MDrv_DMD_DVBS_GetStatus %d %d %f \n", *pQAMMode, *u32SymbolRate, *pFreqOff);
2190 }
2191 #endif
2192 }
2193 else
2194 {
2195 return false;
2196 }
2197
2198 return Drv_DVBS_GetStatus_PARAM.ret;
2199 }
2200 #endif
2201
MDrv_DMD_DVBS_SetPowerState(EN_POWER_MODE u16PowerState)2202 MS_U32 MDrv_DMD_DVBS_SetPowerState(EN_POWER_MODE u16PowerState)
2203 {
2204 DVBS_SetPowerState_PARAM Drv_DVBS_SetPowerState_PARAM;
2205 Drv_DVBS_SetPowerState_PARAM.u16PowerState=u16PowerState;
2206 Drv_DVBS_SetPowerState_PARAM.ret_U32=false;
2207 DMD_DBG(ULOGD("DEMOD","[drvDMD_INTERN_DVBS.c]MDrv_DMD_DVBS_SetPowerState\n"));
2208 if(u32DVBSopen==1)
2209 {
2210 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_SetPowerState,&Drv_DVBS_SetPowerState_PARAM);
2211 }
2212 else
2213 {
2214 return false;
2215 }
2216
2217 return Drv_DVBS_SetPowerState_PARAM.ret_U32;
2218 }
2219
2220 #ifndef MSOS_TYPE_LINUX_KERNEL
MDrv_DMD_DVBS_Get_FreqOffset(float * pFreqOff,MS_U8 u8BW)2221 MS_BOOL MDrv_DMD_DVBS_Get_FreqOffset(float *pFreqOff, MS_U8 u8BW)
2222 {
2223 MS_S16 s16CFO=0;
2224 DVBS_Get_FreqOffset_PARAM Drv_DVBS_Get_FreqOffset_PARAM;
2225 Drv_DVBS_Get_FreqOffset_PARAM.s16CFO=&s16CFO;
2226 Drv_DVBS_Get_FreqOffset_PARAM.bRet=false;
2227 DMD_DBG(ULOGD("DEMOD","[drvDMD_INTERN_DVBS.c]MDrv_DMD_DVBS_Get_FreqOffset\n"));
2228 if(u32DVBSopen==1)
2229 {
2230 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_Get_FreqOffset,&Drv_DVBS_Get_FreqOffset_PARAM);
2231 if(abs(s16CFO)%1000 >= 500)
2232 {
2233 if(s16CFO < 0)
2234 *pFreqOff=(s16CFO/1000)-1.0;
2235 else
2236 *pFreqOff=(s16CFO/1000)+1.0;
2237 }
2238 else
2239 *pFreqOff = s16CFO/1000;
2240 #ifdef MS_DEBUG
2241 ULOGD("DEMOD","MDrv_DMD_DVBS_Get_FreqOffset %f \n", *pFreqOff);
2242 #endif
2243 //DBG_INTERN_DVBS(printf(">>> INTERN_DVBS_Get_FreqOffset *pFreqOff = %d[MHz] <<<\n", (MS_S16)*pFreqOff));
2244 }
2245 else
2246 {
2247 return false;
2248 }
2249
2250 return Drv_DVBS_Get_FreqOffset_PARAM.bRet;
2251 }
2252 #endif
2253
MDrv_DMD_DVBS_BlindScan_Start(MS_U16 u16StartFreq,MS_U16 u16EndFreq)2254 MS_BOOL MDrv_DMD_DVBS_BlindScan_Start(MS_U16 u16StartFreq, MS_U16 u16EndFreq)
2255 {
2256 DVBS_BlindScan_Start_PARAM Drv_DVBS_BlindScan_Start_PARAM;
2257 Drv_DVBS_BlindScan_Start_PARAM.u16StartFreq=u16StartFreq;
2258 Drv_DVBS_BlindScan_Start_PARAM.u16EndFreq=u16EndFreq;
2259 Drv_DVBS_BlindScan_Start_PARAM.bRet=false;
2260 DMD_DBG(ULOGD("DEMOD","[drvDMD_INTERN_DVBS.c]MDrv_DMD_DVBS_BlindScan_Start\n"));
2261 if(u32DVBSopen==1)
2262 {
2263 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_BlindScan_Start,&Drv_DVBS_BlindScan_Start_PARAM);
2264 }
2265 else
2266 {
2267 return false;
2268 }
2269
2270 return Drv_DVBS_BlindScan_Start_PARAM.bRet;
2271 }
2272
MDrv_DMD_DVBS_BlindScan_NextFreq(MS_BOOL * bBlindScanEnd)2273 MS_BOOL MDrv_DMD_DVBS_BlindScan_NextFreq(MS_BOOL* bBlindScanEnd)
2274 {
2275 DVBS_BlindScan_NextFreq_PARAM Drv_DVBS_BlindScan_NextFreq_PARAM;
2276 Drv_DVBS_BlindScan_NextFreq_PARAM.bBlindScanEnd=bBlindScanEnd;
2277 Drv_DVBS_BlindScan_NextFreq_PARAM.bRet=false;
2278 DMD_DBG(ULOGD("DEMOD","[drvDMD_INTERN_DVBS.c]MDrv_DMD_DVBS_BlindScan_NextFreq\n"));
2279 if(u32DVBSopen==1)
2280 {
2281 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_BlindScan_NextFreq,&Drv_DVBS_BlindScan_NextFreq_PARAM);
2282 }
2283 else
2284 {
2285 return false;
2286 }
2287
2288 return Drv_DVBS_BlindScan_NextFreq_PARAM.bRet;
2289 }
2290
MDrv_DMD_DVBS_BlindScan_Cancel(void)2291 MS_BOOL MDrv_DMD_DVBS_BlindScan_Cancel(void)
2292 {
2293 DVBS_BlindScan_Cancel_PARAM Drv_DVBS_BlindScan_Cancel_PARAM;
2294 Drv_DVBS_BlindScan_Cancel_PARAM.bRet=false;
2295 DMD_DBG(ULOGD("DEMOD","[drvDMD_INTERN_DVBS.c]MDrv_DMD_DVBS_BlindScan_Cancel\n"));
2296 if(u32DVBSopen==1)
2297 {
2298 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_BlindScan_Cancel,&Drv_DVBS_BlindScan_Cancel_PARAM);
2299 }
2300 else
2301 {
2302 return false;
2303 }
2304
2305 return Drv_DVBS_BlindScan_Cancel_PARAM.bRet;
2306 }
2307
MDrv_DMD_DVBS_BlindScan_End(void)2308 MS_BOOL MDrv_DMD_DVBS_BlindScan_End(void)
2309 {
2310 DVBS_BlindScan_End_PARAM Drv_DVBS_Blindscan_End_PARAM;
2311 Drv_DVBS_Blindscan_End_PARAM.bRet=false;
2312 DMD_DBG(ULOGD("DEMOD","[drvDMD_INTERN_DVBS.c]MDrv_DMD_DVBS_BlindScan_End\n"));
2313 if(u32DVBSopen==1)
2314 {
2315 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_BlindScan_End,&Drv_DVBS_Blindscan_End_PARAM);
2316 }
2317 else
2318 {
2319 return false;
2320 }
2321
2322 return Drv_DVBS_Blindscan_End_PARAM.bRet;
2323 }
2324
MDrv_DMD_DVBS_BlindScan_GetChannel(MS_U16 u16ReadStart,MS_U16 * u16TPNum,HAL_DEMOD_MS_FE_CARRIER_PARAM * pTable)2325 MS_BOOL MDrv_DMD_DVBS_BlindScan_GetChannel(MS_U16 u16ReadStart, MS_U16* u16TPNum, HAL_DEMOD_MS_FE_CARRIER_PARAM *pTable)
2326 {
2327 DVBS_BlindScan_GetChannel_PARAM Drv_DVBS_BlindScan_Getchannel_PARAM;
2328 Drv_DVBS_BlindScan_Getchannel_PARAM.u16ReadStart=u16ReadStart;
2329 Drv_DVBS_BlindScan_Getchannel_PARAM.u16TPNum=u16TPNum;
2330 Drv_DVBS_BlindScan_Getchannel_PARAM.pTable=pTable;
2331 Drv_DVBS_BlindScan_Getchannel_PARAM.bRet=false;
2332 DMD_DBG(ULOGD("DEMOD","[drvDMD_INTERN_DVBS.c]MDrv_DMD_DVBS_BlindScan_GetChannel\n"));
2333 if(u32DVBSopen==1)
2334 {
2335 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_BlindScan_GetChannel,&Drv_DVBS_BlindScan_Getchannel_PARAM);
2336 }
2337 else
2338 {
2339 return false;
2340 }
2341
2342 return Drv_DVBS_BlindScan_Getchannel_PARAM.bRet;
2343 }
2344
MDrv_DMD_DVBS_BlindScan_GetCurrentFreq(MS_U32 * u32CurrentFreq)2345 MS_BOOL MDrv_DMD_DVBS_BlindScan_GetCurrentFreq(MS_U32 *u32CurrentFreq)
2346 {
2347 DVBS_BlindScan_GetCurrentFreq_PARAM Drv_DVBS_BlindScan_GetCurrentFreq_PARAM;
2348 Drv_DVBS_BlindScan_GetCurrentFreq_PARAM.u32CurrentFreq=u32CurrentFreq;
2349 Drv_DVBS_BlindScan_GetCurrentFreq_PARAM.bRet=false;
2350 DMD_DBG(ULOGD("DEMOD","[drvDMD_INTERN_DVBS.c]MDrv_DMD_DVBS_BlindScan_GetCurrentFreq\n"));
2351 if(u32DVBSopen==1)
2352 {
2353 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_BlindScan_GetCurrentFreq,&Drv_DVBS_BlindScan_GetCurrentFreq_PARAM);
2354 }
2355 else
2356 {
2357 return false;
2358 }
2359
2360 return Drv_DVBS_BlindScan_GetCurrentFreq_PARAM.bRet;
2361 }
2362
2363 #ifndef MSOS_TYPE_LINUX_KERNEL
MDrv_DMD_DVBS_BlindScan_WaitCurFreqFinished(MS_U8 * u8Progress,MS_U8 * u8FindNum)2364 MS_BOOL MDrv_DMD_DVBS_BlindScan_WaitCurFreqFinished(MS_U8* u8Progress,MS_U8 *u8FindNum)
2365 {
2366 MS_U8 substate_reg=2;
2367 MS_U32 u32Data=0;
2368 MS_U16 symbolrate_reg=0;
2369 MS_U16 CFO_reg;
2370 DVBS_BlindScan_WaitCurFreqFinished_PARAM Drv_DVBS_BlindScan_WaitCurFreqFinished_PARAM;
2371 Drv_DVBS_BlindScan_WaitCurFreqFinished_PARAM.u8Progress=u8Progress;
2372 Drv_DVBS_BlindScan_WaitCurFreqFinished_PARAM.u8FindNum=u8FindNum;
2373 Drv_DVBS_BlindScan_WaitCurFreqFinished_PARAM.substate_reg=&substate_reg;
2374 Drv_DVBS_BlindScan_WaitCurFreqFinished_PARAM.u32Data=&u32Data;
2375 Drv_DVBS_BlindScan_WaitCurFreqFinished_PARAM.symbolrate_reg=&symbolrate_reg;
2376 Drv_DVBS_BlindScan_WaitCurFreqFinished_PARAM.CFO_reg=&CFO_reg;
2377 Drv_DVBS_BlindScan_WaitCurFreqFinished_PARAM.bRet=false;
2378 DMD_DBG(ULOGD("DEMOD","[drvDMD_INTERN_DVBS.c]MDrv_DMD_DVBS_BlindScan_WaitCurFreqFinished\n"));
2379 if(u32DVBSopen==1)
2380 {
2381 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_BlindScan_WaitCurFreqFinished,&Drv_DVBS_BlindScan_WaitCurFreqFinished_PARAM);
2382
2383 substate_reg = *Drv_DVBS_BlindScan_WaitCurFreqFinished_PARAM.substate_reg;
2384 u32Data = *Drv_DVBS_BlindScan_WaitCurFreqFinished_PARAM.u32Data;
2385 symbolrate_reg = *Drv_DVBS_BlindScan_WaitCurFreqFinished_PARAM.symbolrate_reg;
2386 CFO_reg = *Drv_DVBS_BlindScan_WaitCurFreqFinished_PARAM.CFO_reg;
2387 //CFO_reg = 0;
2388
2389 if(substate_reg==0)
2390 {
2391 _u16ChannelInfoArray[0][_u16ChannelInfoIndex]=((u32Data+500)/1000);
2392 _u16LockedCenterFreq=((u32Data+500)/1000); //Center Freq
2393 _u16ChannelInfoArray[1][_u16ChannelInfoIndex]=(symbolrate_reg);//Symbol Rate
2394 _u16LockedSymbolRate=symbolrate_reg;
2395 _u16ChannelInfoIndex++;
2396 *u8FindNum=_u16ChannelInfoIndex;
2397 if (CFO_reg*1000 >= 0x8000)
2398 {
2399 CFO_reg=0x10000- CFO_reg*1000;
2400 _s16CurrentCFO=-1*CFO_reg/1000;
2401 }
2402 else
2403 {
2404 _s16CurrentCFO=CFO_reg;
2405 }
2406 DMD_DBG(ULOGD("DEMOD","Current Locked CF:%d BW:%d CFO:%d \n ", _u16LockedCenterFreq, _u16LockedSymbolRate, _s16CurrentCFO));
2407 }
2408 else if(substate_reg==1)
2409 {
2410 if (CFO_reg*1000 >= 0x8000)
2411 {
2412 CFO_reg=0x1000- CFO_reg*1000;
2413 _s16CurrentCFO=-1*CFO_reg/1000;
2414 }
2415 else
2416 {
2417 _s16CurrentCFO=CFO_reg;
2418 }
2419 DMD_DBG(ULOGD("DEMOD","Pre Locked CF:%d BW:%d CFO:%d \n ", _u16LockedCenterFreq, _u16LockedSymbolRate, _s16CurrentCFO));
2420 }
2421 DMD_DBG(ULOGD("DEMOD","MDrv_Demod_BlindScan_WaitCurFreqFinished- u8Progress: %d u8FindNum %d\n", *u8Progress, *u8FindNum));
2422
2423 }
2424 else
2425 {
2426 return false;
2427 }
2428
2429 return Drv_DVBS_BlindScan_WaitCurFreqFinished_PARAM.bRet;
2430 }
2431 #endif
2432
MDrv_DMD_DVBS_BlindScan_GetTunerFreq_EX(MS_U16 * u16TunerCenterFreq,MS_U16 * u16TunerCutOffFreq)2433 MS_BOOL MDrv_DMD_DVBS_BlindScan_GetTunerFreq_EX(MS_U16 *u16TunerCenterFreq, MS_U16 *u16TunerCutOffFreq)
2434 {
2435 DVBS_BlindScan_GetTunerFreq_PARAM Drv_DVBS_BlindScan_GetTunerFreq_PARAM;
2436 Drv_DVBS_BlindScan_GetTunerFreq_PARAM.u16TunerCenterFreq=u16TunerCenterFreq;
2437 Drv_DVBS_BlindScan_GetTunerFreq_PARAM.u16TunerCutOffFreq=u16TunerCutOffFreq;
2438 Drv_DVBS_BlindScan_GetTunerFreq_PARAM.bRet=false;
2439 DMD_DBG(ULOGD("DEMOD","[drvDMD_INTERN_DVBS.c]MDrv_DMD_DVBS_BlindScan_GetTunerFreq_EX\n"));
2440 if(u32DVBSopen==1)
2441 {
2442 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_BlindScan_GetTunerFreq,&Drv_DVBS_BlindScan_GetTunerFreq_PARAM);
2443 }
2444 else
2445 {
2446 return false;
2447 }
2448
2449 return Drv_DVBS_BlindScan_GetTunerFreq_PARAM.bRet;
2450 }
2451
2452 //------------------------------------------------------------------------------
MDrv_DMD_DVBS_DiSEqC_Init(void)2453 MS_BOOL MDrv_DMD_DVBS_DiSEqC_Init(void)
2454 {
2455 DVBS_DiSEqC_Init_PARAM Drv_DVBS_DiSEqC_Init_PARAM;
2456 Drv_DVBS_DiSEqC_Init_PARAM.bRet=false;
2457 DMD_DBG(ULOGD("DEMOD","[drvDMD_INTERN_DVBS.c]MDrv_DMD_DVBS_DiSEqC_Init\n"));
2458 if(u32DVBSopen==1)
2459 {
2460 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_DiSEqC_Init,&Drv_DVBS_DiSEqC_Init_PARAM);
2461 }
2462 else
2463 {
2464 return false;
2465 }
2466 return Drv_DVBS_DiSEqC_Init_PARAM.bRet;
2467 }
2468
MDrv_DMD_DVBS_DiSEqC_SetLNBOut(MS_BOOL bLow)2469 MS_BOOL MDrv_DMD_DVBS_DiSEqC_SetLNBOut(MS_BOOL bLow)
2470 {
2471 DVBS_DiSEqC_SetLNBOut_PARAM Drv_DVBS_DiSEqC_SetLNBOut_PARAM;
2472 Drv_DVBS_DiSEqC_SetLNBOut_PARAM.bLow=bLow;
2473 Drv_DVBS_DiSEqC_SetLNBOut_PARAM.bRet=false;
2474 DMD_DBG(ULOGD("DEMOD","[drvDMD_INTERN_DVBS.c]MDrv_DMD_DVBS_DiSEqC_SetLNBOut\n"));
2475 if(u32DVBSopen==1)
2476 {
2477 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_DiSEqC_SetLNBOut,&Drv_DVBS_DiSEqC_SetLNBOut_PARAM);
2478 }
2479 else
2480 {
2481 return false;
2482 }
2483 return Drv_DVBS_DiSEqC_SetLNBOut_PARAM.bRet;
2484 }
2485
MDrv_DMD_DVBS_DiSEqC_GetLNBOut(MS_BOOL * bLNBOutLow)2486 MS_BOOL MDrv_DMD_DVBS_DiSEqC_GetLNBOut(MS_BOOL* bLNBOutLow)
2487 {
2488 DVBS_DiSEqC_GetLNBOut_PARAM Drv_DVBS_DiSEqC_GetLNBOut_PARAM;
2489 Drv_DVBS_DiSEqC_GetLNBOut_PARAM.bLNBOutLow=bLNBOutLow;
2490 Drv_DVBS_DiSEqC_GetLNBOut_PARAM.bRet=false;
2491 DMD_DBG(ULOGD("DEMOD","[drvDMD_INTERN_DVBS.c]MDrv_DMD_DVBS_DiSEqC_GetLNBOut\n"));
2492 if(u32DVBSopen==1)
2493 {
2494 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_DiSEqC_GetLNBOut,&Drv_DVBS_DiSEqC_GetLNBOut_PARAM);
2495 }
2496 else
2497 {
2498 return false;
2499 }
2500 return Drv_DVBS_DiSEqC_GetLNBOut_PARAM.bRet;
2501 }
2502
MDrv_DMD_DVBS_DiSEqC_Set22kOnOff(MS_BOOL b22kOn)2503 MS_BOOL MDrv_DMD_DVBS_DiSEqC_Set22kOnOff(MS_BOOL b22kOn)
2504 {
2505 DVBS_DiSEqC_Set22kOnOff_PARAM Drv_DVBS_DiSEqC_Set22kOnOff_PARAM;
2506 Drv_DVBS_DiSEqC_Set22kOnOff_PARAM.b22kOn=b22kOn;
2507 Drv_DVBS_DiSEqC_Set22kOnOff_PARAM.bRet=false;
2508 DMD_DBG(ULOGD("DEMOD","[drvDMD_INTERN_DVBS.c]MDrv_DMD_DVBS_DiSEqC_Set22kOnOff\n"));
2509 if(u32DVBSopen==1)
2510 {
2511 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_DiSEqC_Set22kOnOff,&Drv_DVBS_DiSEqC_Set22kOnOff_PARAM);
2512 }
2513 else
2514 {
2515 return false;
2516 }
2517 return Drv_DVBS_DiSEqC_Set22kOnOff_PARAM.bRet;
2518 }
2519
MDrv_DMD_DVBS_DiSEqC_Get22kOnOff(MS_BOOL * b22kOn)2520 MS_BOOL MDrv_DMD_DVBS_DiSEqC_Get22kOnOff(MS_BOOL* b22kOn)
2521 {
2522 DVBS_DiSEqC_Get22kOnOff_PARAM Drv_DVBS_DiSEqC_Get22kOnOff_PARAM;
2523 Drv_DVBS_DiSEqC_Get22kOnOff_PARAM.b22kOn=b22kOn;
2524 Drv_DVBS_DiSEqC_Get22kOnOff_PARAM.bRet=false;
2525 DMD_DBG(ULOGD("DEMOD","[drvDMD_INTERN_DVBS.c]MDrv_DMD_DVBS_DiSEqC_Get22kOnOff\n"));
2526 if(u32DVBSopen==1)
2527 {
2528 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_DiSEqC_Get22kOnOff,&Drv_DVBS_DiSEqC_Get22kOnOff_PARAM);
2529 }
2530 else
2531 {
2532 return false;
2533 }
2534 return Drv_DVBS_DiSEqC_Get22kOnOff_PARAM.bRet;
2535 }
2536
MDrv_DMD_DVBS_DiSEqC_SendCmd(MS_U8 * pCmd,MS_U8 u8CmdSize)2537 MS_BOOL MDrv_DMD_DVBS_DiSEqC_SendCmd(MS_U8* pCmd,MS_U8 u8CmdSize)
2538 {
2539 DVBS_DiSEqC_SendCmd_PARAM Drv_DVBS_DiSEqC_SendCmd_PARAM;
2540 Drv_DVBS_DiSEqC_SendCmd_PARAM.pCmd=pCmd;
2541 Drv_DVBS_DiSEqC_SendCmd_PARAM.u8CmdSize=u8CmdSize;
2542 Drv_DVBS_DiSEqC_SendCmd_PARAM.bRet=false;
2543 DMD_DBG(ULOGD("DEMOD","[drvDMD_INTERN_DVBS.c]MDrv_DMD_DVBS_DiSEqC_SendCmd\n"));
2544 if(u32DVBSopen==1)
2545 {
2546 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_DiSEqC_SendCmd,&Drv_DVBS_DiSEqC_SendCmd_PARAM);
2547 }
2548 else
2549 {
2550 return false;
2551 }
2552 return Drv_DVBS_DiSEqC_SendCmd_PARAM.bRet;
2553 }
2554
MDrv_DMD_DVBS_DiSEqC_SetTxToneMode(MS_BOOL bTxTone22kOff)2555 MS_BOOL MDrv_DMD_DVBS_DiSEqC_SetTxToneMode(MS_BOOL bTxTone22kOff)
2556 {
2557 DVBS_DiSEqC_SetTxToneMode_PARAM Drv_DVBS_DiSEqC_SetTxToneMode_PARAM;
2558 Drv_DVBS_DiSEqC_SetTxToneMode_PARAM.bTxTone22kOff=bTxTone22kOff;
2559 Drv_DVBS_DiSEqC_SetTxToneMode_PARAM.bRet=false;
2560 DMD_DBG(ULOGD("DEMOD","[drvDMD_INTERN_DVBS.c]MDrv_DMD_DVBS_DiSEqC_SetTxToneMode\n"));
2561 if(u32DVBSopen==1)
2562 {
2563 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_DiSEqC_SetTxToneMode,&Drv_DVBS_DiSEqC_SetTxToneMode_PARAM);
2564 }
2565 else
2566 {
2567 return false;
2568 }
2569 return Drv_DVBS_DiSEqC_SetTxToneMode_PARAM.bRet;
2570 }
2571
MDrv_DMD_DVBS_DiSEqC_SetTone(MS_BOOL bTone1)2572 MS_BOOL MDrv_DMD_DVBS_DiSEqC_SetTone(MS_BOOL bTone1)
2573 {
2574 DVBS_DiSEqC_SetTone_PARAM Drv_DVBS_DiSEqC_SetTone_PARAM;
2575 Drv_DVBS_DiSEqC_SetTone_PARAM.bTone1=bTone1;
2576 Drv_DVBS_DiSEqC_SetTone_PARAM.bRet=false;
2577 DMD_DBG(ULOGD("DEMOD","[drvDMD_INTERN_DVBS.c]MDrv_DMD_DVBS_DiSEqC_SetTone\n"));
2578 if(u32DVBSopen==1)
2579 {
2580 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_DiSEqC_SetTone,&Drv_DVBS_DiSEqC_SetTone_PARAM);
2581 }
2582 else
2583 {
2584 return false;
2585 }
2586 return Drv_DVBS_DiSEqC_SetTone_PARAM.bRet;
2587 }
2588
MDrv_DMD_DVBS_UnicableAGCCheckPower(MS_BOOL pbAGCCheckPower)2589 MS_BOOL MDrv_DMD_DVBS_UnicableAGCCheckPower(MS_BOOL pbAGCCheckPower)
2590 {
2591 DVBS_UnicableAGCCheckPower_PARAM Drv_DVBS_UnicableAGCCheckPower_PARAM;
2592 Drv_DVBS_UnicableAGCCheckPower_PARAM.pbAGCCheckPower=pbAGCCheckPower;
2593 Drv_DVBS_UnicableAGCCheckPower_PARAM.bRet=false;
2594 DMD_DBG(ULOGD("DEMOD","[drvDMD_INTERN_DVBS.c]MDrv_DMD_DVBS_UnicableAGCCheckPower\n"));
2595 if(u32DVBSopen==1)
2596 {
2597 UtopiaIoctl(ppDVBSInstant,DMD_DVBS_DRV_CMD_UnicableAGCCheckPower,&Drv_DVBS_UnicableAGCCheckPower_PARAM);
2598 }
2599 else
2600 {
2601 return false;
2602 }
2603 return Drv_DVBS_UnicableAGCCheckPower_PARAM.bRet;
2604 }
2605
2606 #if defined UFO_SUPPORT_VCM || defined UFO_DEMOD_DVBS_SUPPORT_DMD_INT
MDrv_DMD_DVBS2_TS_DivNum_Calculation(void)2607 MS_BOOL MDrv_DMD_DVBS2_TS_DivNum_Calculation(void)
2608 {
2609 DMD_DBG(ULOGD("DEMOD","[drvDMD_INTERN_DVBS.c]MDrv_DMD_DVBS2_TS_DivNum_Calculation\n"));
2610
2611 MS_U32 u32SymbolRate=0;
2612 //float fSymbolRate;
2613 //MS_U8 ISSY_EN = 0;
2614 MS_U8 code_rate_idx = 0;
2615 MS_U8 pilot_flag = 0;
2616 MS_U8 fec_type_idx = 0;
2617 MS_U16 k_bch_array[2][42] =
2618 {
2619 {
2620 16008, 21408, 25728, 32208, 38688, 43040, 48408, 51648, 53840, 57472,
2621 58192, 14208, 18528, 28968, 32208, 34368, 35448, 35808, 37248, 37248,
2622 38688, 40128, 41208, 41568, 43008, 44448, 44808, 45888, 46608, 47328,
2623 47328, 48408, 50208, 50208, 55248, 0, 0, 0, 0, 0,
2624 0, 0,
2625 },
2626 {
2627 3072, 5232, 6312, 7032, 9552, 10632, 11712, 12432, 13152, 14232,
2628 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2629 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2630 0, 0, 0, 0, 0, 3792, 4152, 4872, 7392, 8472,
2631 9192, 11352
2632 }
2633 };
2634 MS_U16 n_ldpc_array[2] = {64800, 16200};
2635
2636 MS_FLOAT pilot_term = 0;
2637 MS_FLOAT k_bch;
2638 MS_FLOAT n_ldpc;
2639 MS_FLOAT ts_div_num_offset = 1.5;
2640 MS_FLOAT ts_div_num_margin_ratio = 1.03;
2641 MS_FLOAT ftmp;
2642 MS_U32 u32temp;
2643 MS_U8 system_type_reg;
2644 MS_U8 code_rate_reg;
2645 MS_FLOAT fTSDivNum;
2646 MS_U8 u8Data;
2647 MS_BOOL status = TRUE;
2648
2649 DVBS_GetTsDivNum_PARAM Drv_DVBS_GetTsDivNum_PARAM;
2650 Drv_DVBS_GetTsDivNum_PARAM.u32SymbolRate=&u32SymbolRate;
2651 Drv_DVBS_GetTsDivNum_PARAM.system_type_reg=&system_type_reg;
2652 Drv_DVBS_GetTsDivNum_PARAM.code_rate_idx=&code_rate_idx;
2653 Drv_DVBS_GetTsDivNum_PARAM.fec_type_idx=&fec_type_idx;
2654 Drv_DVBS_GetTsDivNum_PARAM.pilot_flag=&pilot_flag;
2655 Drv_DVBS_GetTsDivNum_PARAM.u32temp=&u32temp;
2656 Drv_DVBS_GetTsDivNum_PARAM.code_rate_reg=&code_rate_reg;
2657 Drv_DVBS_GetTsDivNum_PARAM.bRet=false;
2658
2659 if(u8DemodLockFlag==1)
2660 {
2661 UtopiaIoctl(ppDVBSInstant, DMD_DVBS_DRV_CMD_GetTsDivNum, &Drv_DVBS_GetTsDivNum_PARAM);
2662 status &= Drv_DVBS_GetTsDivNum_PARAM.bRet;
2663
2664 if(!system_type_reg)//DVBS2
2665 {
2666 k_bch = k_bch_array[fec_type_idx][code_rate_idx];
2667 n_ldpc = n_ldpc_array[fec_type_idx];
2668 pilot_term = ((float) n_ldpc / modulation_order / 1440 * 36) * pilot_flag;
2669
2670 //data rate
2671 ftmp = k_bch/((n_ldpc/modulation_order+90+pilot_term)/u32SymbolRate);
2672
2673 if(sDMD_DVBS_Info.bSerialTS)//serial mode
2674 {
2675 fTSDivNum = 288000.0 / ftmp / 2.0 - 1;
2676 //fTSDivNum = fTSDivNum/2-1;// since 288/(2(fTSDivNum+1)) = 288/TS_RATE = A ==> fTSDivNum = A/2-1
2677 }
2678 else//parallel mode
2679 {
2680 fTSDivNum = 288000.0 / (ftmp/8.0) / 2.0 - 1;
2681 //fTSDivNum = (fTSDivNum-1)/2;
2682 }
2683
2684 fTSDivNum -= ts_div_num_offset;
2685 }
2686 else
2687 {
2688 code_rate_reg = *Drv_DVBS_GetTsDivNum_PARAM.code_rate_reg;
2689 switch (code_rate_reg)
2690 {
2691 case 0x00: //CR 1/2
2692 if(sDMD_DVBS_Info.bSerialTS)
2693 fTSDivNum = ((288000/((1.0/2.0)*(188.0/204.0)*u32SymbolRate*ts_div_num_margin_ratio*2)) /2)-ts_div_num_offset;
2694 else
2695 fTSDivNum = ((288000/((1.0/2.0)*(188.0/204.0)*u32SymbolRate*ts_div_num_margin_ratio*2/8.0))/2)-ts_div_num_offset;
2696
2697 //fTSDivNum = fTSDivNum/2-1-5;
2698
2699 break;
2700 case 0x01: //CR 2/3
2701 if(sDMD_DVBS_Info.bSerialTS)
2702 fTSDivNum = ((288000/((2.0/3.0)*(188.0/204.0)*u32SymbolRate*ts_div_num_margin_ratio*2)) /2)-ts_div_num_offset;
2703 else
2704 fTSDivNum = ((288000/((2.0/3.0)*(188.0/204.0)*u32SymbolRate*ts_div_num_margin_ratio*2/8.0))/2)-ts_div_num_offset;
2705
2706 //fTSDivNum = fTSDivNum/2-1-5;
2707
2708 break;
2709 case 0x02: //CR 3/4
2710 if(sDMD_DVBS_Info.bSerialTS)
2711 fTSDivNum = ((288000/((3.0/4.0)*(188.0/204.0)*u32SymbolRate*ts_div_num_margin_ratio*2)) /2)-ts_div_num_offset;
2712 else
2713 fTSDivNum = ((288000/((3.0/4.0)*(188.0/204.0)*u32SymbolRate*ts_div_num_margin_ratio*2/8.0))/2)-ts_div_num_offset;
2714
2715 //fTSDivNum = fTSDivNum/2-1-5;
2716 break;
2717 case 0x03: //CR 5/6
2718 if(sDMD_DVBS_Info.bSerialTS)
2719 fTSDivNum = ((288000/((5.0/6.0)*(188.0/204.0)*u32SymbolRate*ts_div_num_margin_ratio*2)) /2)-ts_div_num_offset;
2720 else
2721 fTSDivNum = ((288000/((5.0/6.0)*(188.0/204.0)*u32SymbolRate*ts_div_num_margin_ratio*2/8.0))/2)-ts_div_num_offset;
2722
2723 //fTSDivNum = fTSDivNum/2-1-5;
2724
2725 break;
2726 case 0x04: //CR 7/8
2727 if(sDMD_DVBS_Info.bSerialTS)
2728 fTSDivNum = ((288000/((7.0/8.0)*(188.0/204.0)*u32SymbolRate*ts_div_num_margin_ratio*2)) /2)-ts_div_num_offset;
2729 else
2730 fTSDivNum = ((288000/((7.0/8.0)*(188.0/204.0)*u32SymbolRate*ts_div_num_margin_ratio*2/8.0))/2)-ts_div_num_offset;
2731
2732 //fTSDivNum = fTSDivNum/2-1-5;
2733
2734 break;
2735 default:
2736 if(sDMD_DVBS_Info.bSerialTS)
2737 fTSDivNum = ((288000/((7.0/8.0)*(188.0/204.0)*u32SymbolRate*ts_div_num_margin_ratio*2)) /2)-ts_div_num_offset;
2738 else
2739 fTSDivNum = ((288000/((7.0/8.0)*(188.0/204.0)*u32SymbolRate*ts_div_num_margin_ratio*2/8.0))/2)-ts_div_num_offset;
2740
2741 //fTSDivNum = fTSDivNum/2-1-5;
2742
2743 break;
2744 }
2745 }
2746
2747 if(fTSDivNum > 0x1F)
2748 fTSDivNum = 0x1F;
2749 else if(fTSDivNum < 0x01)
2750 fTSDivNum = 0x01;
2751
2752 u8Data = (MS_U8)fTSDivNum;
2753
2754 #ifdef MS_DEBUG
2755 ULOGD("DEMOD", ">>>INTERN_DVBS_GetLock TsClkDivNum = 0x%x<<<\n", u8Data);
2756 #endif
2757
2758 HAL_DMD_RIU_WriteByte(0x103300, u8Data);
2759
2760 //Ts Output Enable
2761 HAL_DMD_RIU_WriteByte(0x101eaa,0x10);
2762 }
2763
2764 return status;
2765 }
2766
MDrv_DMD_DVBS2_Set_Default_IS_ID(MS_U8 * u8IS_ID_table)2767 MS_BOOL MDrv_DMD_DVBS2_Set_Default_IS_ID(MS_U8 *u8IS_ID_table)
2768 {
2769 MS_U8 IS_ID = 0;
2770 DVBS_SetDefaultVCM_PARAM Drv_DVBS_SetDefaultVCM_PARAM;
2771 Drv_DVBS_SetDefaultVCM_PARAM.u8IS_ID = &IS_ID;
2772 Drv_DVBS_SetDefaultVCM_PARAM.u8IS_ID_table = u8IS_ID_table;
2773 Drv_DVBS_SetDefaultVCM_PARAM.ret = false;
2774 DMD_DBG(ULOGD("DEMOD","[drvDMD_INTERN_DVBS.c]MDrv_DMD_DVBS2_Set_Default_IS_ID\n"));
2775
2776 if(u32DVBSopen==1)
2777 {
2778 UtopiaIoctl(ppDVBSInstant, DMD_DVBS_DRV_CMD_Set_Default_IS_ID, &Drv_DVBS_SetDefaultVCM_PARAM);
2779 }
2780
2781 ULOGD("DEMOD","[drvDMD_INTERN_DVBS.c]Defalut IS_ID = %d\n",IS_ID);
2782
2783 return Drv_DVBS_SetDefaultVCM_PARAM.ret;
2784 }
2785
2786
MDrv_DMD_DVBS2_Set_IS_ID(MS_U8 u8IS_ID)2787 MS_BOOL MDrv_DMD_DVBS2_Set_IS_ID(MS_U8 u8IS_ID)
2788 {
2789 DMD_DBG(ULOGD("DEMOD","[drvDMD_INTERN_DVBS.c]MDrv_DMD_DVBS2_Set_IS_ID\n"));
2790
2791 DVBS_SetVCM_PARAM Drv_DVBS_SetVCM_PARAM;
2792 Drv_DVBS_SetVCM_PARAM.u8IS_ID=u8IS_ID;
2793 Drv_DVBS_SetVCM_PARAM.ret=false;
2794 if(u32DVBSopen==1)
2795 {
2796 UtopiaIoctl(ppDVBSInstant, DMD_DVBS_DRV_CMD_Set_IS_ID, &Drv_DVBS_SetVCM_PARAM);
2797 }
2798 return Drv_DVBS_SetVCM_PARAM.ret;
2799 }
2800
2801
MDrv_DMD_DVBS2_Get_IS_ID_INFO(MS_U8 * u8IS_ID,MS_U8 * u8IS_ID_table)2802 MS_BOOL MDrv_DMD_DVBS2_Get_IS_ID_INFO(MS_U8 *u8IS_ID, MS_U8 *u8IS_ID_table)
2803 {
2804 DMD_DBG(ULOGD("DEMOD","[drvDMD_INTERN_DVBS.c]MDrv_DMD_DVBS2_Get_IS_ID_INFO\n"));
2805
2806 DVBS_GetVCM_PARAM Drv_DVBS_GetVCM_PARAM;
2807 Drv_DVBS_GetVCM_PARAM.u8IS_ID=u8IS_ID;
2808 Drv_DVBS_GetVCM_PARAM.u8IS_ID_table=u8IS_ID_table;
2809 Drv_DVBS_GetVCM_PARAM.ret=false;
2810 if(u32DVBSopen==1)
2811 {
2812 UtopiaIoctl(ppDVBSInstant, DMD_DVBS_DRV_CMD_Get_IS_ID_INFO, &Drv_DVBS_GetVCM_PARAM);
2813 }
2814
2815 return Drv_DVBS_GetVCM_PARAM.ret;
2816 }
2817
MDrv_DMD_DVBS2_VCM_Init(DMD_DVBS_VCM_OPT u8VCM_OPT,MS_U8 u8IS_ID,MS_U32 u32DVBS2_DJB_START_ADDR)2818 MS_BOOL MDrv_DMD_DVBS2_VCM_Init(DMD_DVBS_VCM_OPT u8VCM_OPT, MS_U8 u8IS_ID, MS_U32 u32DVBS2_DJB_START_ADDR)
2819 {
2820 void* pAttribte = NULL;
2821
2822 DMD_DBG(ULOGD("DEMOD","[drvDMD_INTERN_DVBS.c]MDrv_DMD_DVBS2_VCM_Init\n"));
2823
2824 DVBS_VCM_INIT_PARAM Drv_DVBS_VCM_INIT_PARAM;
2825 Drv_DVBS_VCM_INIT_PARAM.u8VCM_OPT = u8VCM_OPT;
2826 Drv_DVBS_VCM_INIT_PARAM.u8IS_ID = u8IS_ID;
2827 Drv_DVBS_VCM_INIT_PARAM.u32DVBS2_DJB_START_ADDR = u32DVBS2_DJB_START_ADDR;
2828 Drv_DVBS_VCM_INIT_PARAM.ret = false;
2829
2830 if(u8DVBSUtopiaOpen == 0) // First time open
2831 {
2832 if(UtopiaOpen(MODULE_DVBS/*|KERNEL_MODE*/ , &ppDVBSInstant, 0, pAttribte) == UTOPIA_STATUS_SUCCESS) //kernel space
2833 //if(UtopiaOpen(MODULE_DVBS , &ppDVBSInstant, 0, pAttribte) == UTOPIA_STATUS_SUCCESS) //user space
2834 {
2835 u32DVBSopen = 1;
2836 ULOGD("DEMOD","Leo check DVBS utopia open sucessful!!\n");
2837 //return_val=true;
2838 // ULOGD("DEMOD","\r\n ======== DVBS Open Successful %x =========", (WORD)u32DVBSopen);
2839 }
2840 else
2841 {
2842 // ULOGD("DEMOD","\r\n ======== DVBS Open Fail %x =========", (WORD)u32DVBSopen);
2843 //return_val=false;
2844 ULOGD("DEMOD","DVBS utopia open fail!!\n");
2845 return false;
2846 }
2847
2848 u8DVBSUtopiaOpen = 1;
2849 }
2850
2851 if(u32DVBSopen==1)
2852 {
2853 UtopiaIoctl(ppDVBSInstant, DMD_DVBS_DRV_CMD_VCM_Init, &Drv_DVBS_VCM_INIT_PARAM);
2854 }
2855
2856 return Drv_DVBS_VCM_INIT_PARAM.ret;
2857 }
2858
MDrv_DMD_DVBS2_VCM_Check(void)2859 MS_BOOL MDrv_DMD_DVBS2_VCM_Check(void)
2860 {
2861 DMD_DBG(ULOGD("DEMOD","[drvDMD_INTERN_DVBS.c]MDrv_DMD_DVBS2_VCM_Check\n"));
2862
2863 DVBS_VCM_CHECK Drv_DVBS_VCM_CHECK;
2864 Drv_DVBS_VCM_CHECK.ret = false;
2865
2866 if(u32DVBSopen==1)
2867 {
2868 UtopiaIoctl(ppDVBSInstant, DMD_DVBS_DRV_CMD_VCM_Check, &Drv_DVBS_VCM_CHECK);
2869 }
2870
2871 return Drv_DVBS_VCM_CHECK.ret;
2872 }
2873
MDrv_DMD_DVBS2_VCM_Enabled(MS_U8 u8VCM_ENABLED)2874 MS_BOOL MDrv_DMD_DVBS2_VCM_Enabled(MS_U8 u8VCM_ENABLED)
2875 {
2876 DMD_DBG(ULOGD("DEMOD","[drvDMD_INTERN_DVBS.c]MDrv_DMD_DVBS2_VCM_Enabled\n"));
2877 DVBS_VCM_ENABLED Drv_DVBS_VCM_ENABLED;
2878 Drv_DVBS_VCM_ENABLED.u8VCM_ENABLED = u8VCM_ENABLED;
2879 Drv_DVBS_VCM_ENABLED.ret = false;
2880
2881 if(u32DVBSopen==1)
2882 {
2883 UtopiaIoctl(ppDVBSInstant, DMD_DVBS_DRV_CMD_VCM_Enabled, &Drv_DVBS_VCM_ENABLED);
2884 }
2885
2886 return Drv_DVBS_VCM_ENABLED.ret;
2887
2888 }
2889
MDrv_DMD_DVBS2_VCM_Change_Mode(DMD_DVBS_VCM_OPT u8VCM_OPT)2890 MS_BOOL MDrv_DMD_DVBS2_VCM_Change_Mode(DMD_DVBS_VCM_OPT u8VCM_OPT)
2891 {
2892 DMD_DBG(ULOGD("DEMOD","[drvDMD_INTERN_DVBS.c]MDrv_DMD_DVBS2_VCM_Change_Mode\n"));
2893 DVBS_VCM_MODE Drv_DVBS_VCM_MODE;
2894 Drv_DVBS_VCM_MODE.u8VCM_OPT = u8VCM_OPT;
2895 Drv_DVBS_VCM_MODE.ret = false;
2896
2897 if(u32DVBSopen==1)
2898 {
2899 UtopiaIoctl(ppDVBSInstant, DMD_DVBS_DRV_CMD_VCM_Mode, &Drv_DVBS_VCM_MODE);
2900 }
2901
2902 return Drv_DVBS_VCM_MODE.ret;
2903 }
2904 #endif
2905
2906 #ifdef UFO_SUPPORT_KERNEL_FLOATING
MDrv_DMD_DVBS_TS_DivNum_Calculation_Kernel(void)2907 MS_BOOL MDrv_DMD_DVBS_TS_DivNum_Calculation_Kernel(void)
2908 {
2909 DMD_DBG(ULOGD("DEMOD","[drvDMD_INTERN_DVBS.c]MDrv_DMD_DVBS2_TS_DivNum_Calculation\n"));
2910
2911 MS_U32 u32SymbolRate=0;
2912 //float fSymbolRate;
2913 //MS_U8 ISSY_EN = 0;
2914 MS_U8 code_rate_idx = 0;
2915 MS_U8 pilot_flag = 0;
2916 MS_U8 fec_type_idx = 0;
2917 MS_U16 k_bch_array[2][42] =
2918 {
2919 {
2920 16008, 21408, 25728, 32208, 38688, 43040, 48408, 51648, 53840, 57472,
2921 58192, 14208, 18528, 28968, 32208, 34368, 35448, 35808, 37248, 37248,
2922 38688, 40128, 41208, 41568, 43008, 44448, 44808, 45888, 46608, 47328,
2923 47328, 48408, 50208, 50208, 55248, 0, 0, 0, 0, 0,
2924 0, 0,
2925 },
2926 {
2927 3072, 5232, 6312, 7032, 9552, 10632, 11712, 12432, 13152, 14232,
2928 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2929 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2930 0, 0, 0, 0, 0, 3792, 4152, 4872, 7392, 8472,
2931 9192, 11352
2932 }
2933 };
2934 MS_U16 n_ldpc_array[2] = {64800, 16200};
2935
2936 MS_U8 DVBS_CR_TABLE[5] = {2,3,4,6,8}; // 1/2, 2/3, 3/4, 5/6, 7/8
2937
2938 MS_FLOAT_ST pilot_term;
2939 MS_FLOAT_ST k_bch;
2940 MS_FLOAT_ST n_ldpc;
2941 MS_FLOAT_ST ts_div_num_offset; // 1.5
2942
2943 ts_div_num_offset.DATA = 3;
2944 ts_div_num_offset.EXP = -1;
2945
2946 MS_FLOAT_ST ts_div_num_margin_ratio; // 1.03
2947
2948 ts_div_num_margin_ratio.DATA = 1105954079;
2949 ts_div_num_margin_ratio.EXP = -30;
2950
2951 MS_FLOAT_ST ftmp;
2952 MS_FLOAT_ST temp, temp1;
2953
2954 MS_U32 u32temp;
2955 MS_U8 system_type_reg;
2956 MS_U8 code_rate_reg;
2957 MS_FLOAT_ST fTSDivNum;
2958 MS_U8 u8Data;
2959 MS_BOOL status = TRUE;
2960
2961 DVBS_GetTsDivNum_PARAM Drv_DVBS_GetTsDivNum_PARAM;
2962 Drv_DVBS_GetTsDivNum_PARAM.u32SymbolRate=&u32SymbolRate;
2963 Drv_DVBS_GetTsDivNum_PARAM.system_type_reg=&system_type_reg;
2964 Drv_DVBS_GetTsDivNum_PARAM.code_rate_idx=&code_rate_idx;
2965 Drv_DVBS_GetTsDivNum_PARAM.fec_type_idx=&fec_type_idx;
2966 Drv_DVBS_GetTsDivNum_PARAM.pilot_flag=&pilot_flag;
2967 Drv_DVBS_GetTsDivNum_PARAM.u32temp=&u32temp;
2968 Drv_DVBS_GetTsDivNum_PARAM.code_rate_reg=&code_rate_reg;
2969 Drv_DVBS_GetTsDivNum_PARAM.bRet=false;
2970
2971 if(u8DemodLockFlag==1)
2972 {
2973 UtopiaIoctl(ppDVBSInstant, DMD_DVBS_DRV_CMD_GetTsDivNum, &Drv_DVBS_GetTsDivNum_PARAM);
2974 status &= Drv_DVBS_GetTsDivNum_PARAM.bRet;
2975
2976 if(!system_type_reg) // DVBS2
2977 {
2978 k_bch.DATA = k_bch_array[fec_type_idx][code_rate_idx];
2979 k_bch.EXP = 0;
2980 n_ldpc.DATA = n_ldpc_array[fec_type_idx];
2981 n_ldpc.EXP = 0;
2982
2983 pilot_term.DATA = ( n_ldpc.DATA / modulation_order / 1440 * 36) * pilot_flag + 90; // pilot_term + header
2984 pilot_term.EXP = 0;
2985
2986 //data rate
2987 //ftmp = k_bch/( (n_ldpc/modulation_order+90+pilot_term) / u32SymbolRate);
2988
2989 temp.DATA = modulation_order;
2990 temp.EXP = 0;
2991
2992 temp = MS_FLOAT_OP(n_ldpc, temp, divide); // temp = n_ldpc / modulation_order
2993 //ULOGD("DEMOD", ">>>n_ldpc / modulation_order = %d*2^%d<<<\n", temp.DATA, temp.EXP);
2994
2995 temp = MS_FLOAT_OP(temp, pilot_term, add); // temp += pilot_term + header(90)
2996 //ULOGD("DEMOD", ">>>n_ldpc / modulation_order + pilot_term + header(90) = %d*2^%d<<<\n", temp.DATA, temp.EXP);
2997
2998 ftmp.DATA = u32SymbolRate;
2999 ftmp.EXP = 0;
3000
3001 ftmp = MS_FLOAT_OP(temp, ftmp, divide); // ftmp = temp /= u32SymbolRate = (n_ldpc/modulation_order+pilot_term+header(90)) / u32SymbolRate
3002
3003 ftmp = MS_FLOAT_OP(k_bch, ftmp, divide); // ftmp = k_bch / ( (n_ldpc/modulation_order+pilot_term+header(90)) / u32SymbolRate)
3004
3005 //ULOGD("DEMOD", ">>>ftmp = %d*2^%d<<<\n", ftmp.DATA, ftmp.EXP);
3006
3007 if(sDMD_DVBS_Info.bSerialTS)//serial mode
3008 {
3009 //fTSDivNum = 288000.0 / ftmp / 2.0 - 1;
3010
3011 temp.DATA = 288000;
3012 temp.EXP = 0;
3013
3014 fTSDivNum = MS_FLOAT_OP(temp, ftmp, divide); // fTSDivNum = 288000 / ftmp
3015
3016 fTSDivNum.EXP -= 1; // fTSDivNum /= 2
3017
3018 temp.DATA = 1;
3019 temp.EXP = 0;
3020
3021 fTSDivNum = MS_FLOAT_OP(fTSDivNum, temp, minus); // fTSDivNum -= 1
3022 }
3023 else//parallel mode
3024 {
3025 //fTSDivNum = 288000.0 / (ftmp/8.0) / 2.0 - 1;
3026
3027 temp.DATA = 288000;
3028 temp.EXP = 3;
3029
3030 fTSDivNum = MS_FLOAT_OP(temp, ftmp, divide); // fTSDivNum = 288000 / (ftmp/8)
3031
3032 fTSDivNum.EXP -= 1; // fTSDivNum /= 2
3033
3034 temp.DATA = 1;
3035 temp.EXP = 0;
3036
3037 fTSDivNum = MS_FLOAT_OP(fTSDivNum, temp, minus); // fTSDivNum -= 1
3038
3039 //ULOGD("DEMOD", ">>>fTSDivNum = %d*2^%d<<<\n", fTSDivNum.DATA, fTSDivNum.EXP);
3040 }
3041
3042 fTSDivNum = MS_FLOAT_OP(fTSDivNum, ts_div_num_offset, minus); // fTSDivNum -= ts_div_num_offset
3043 }
3044 else // DVBS
3045 {
3046 if(code_rate_reg < 5)
3047 code_rate_reg = DVBS_CR_TABLE[code_rate_reg]; // mapping code_rate_reg => CR
3048 else
3049 code_rate_reg = 8; // default set CR = 7/8
3050
3051 temp.DATA = code_rate_reg;
3052 temp.EXP = 0;
3053 temp1.DATA = code_rate_reg-1;
3054 temp1.EXP = 0;
3055
3056 ftmp = MS_FLOAT_OP(temp1, temp, divide); // ftmp = (CR_REG-1) / CR_REG = CR
3057
3058 temp.DATA = 204;
3059 temp.EXP = 0;
3060 temp1.DATA = 188;
3061 temp1.EXP = 0;
3062
3063 temp = MS_FLOAT_OP(temp1, temp, divide); // temp = 188 / 204
3064
3065 ftmp = MS_FLOAT_OP(ftmp, temp, multiply); // ftmp = CR * (188/204)
3066
3067 temp.DATA = u32SymbolRate*2;
3068 temp.EXP = 0;
3069
3070 temp = MS_FLOAT_OP(temp, ts_div_num_margin_ratio, multiply); // temp = u32SymbolRate * 2 * ts_div_num_margin_ratio
3071
3072 ftmp = MS_FLOAT_OP(ftmp, temp, multiply); // ftmp = CR * (188/204) * u32SymbolRate * 2 * ts_div_num_margin_ratio;
3073
3074 if(sDMD_DVBS_Info.bSerialTS) // serial mode
3075 {
3076 temp.DATA = 288000;
3077 temp.EXP = 0;
3078 }
3079 else // parallel mode
3080 {
3081 temp.DATA = 288000*8;
3082 temp.EXP = 0;
3083 }
3084
3085 fTSDivNum = MS_FLOAT_OP(temp, ftmp, divide); // fTSDivNum = (288000*(parallel mode*8) / (CR*(188.0/204.0)*u32SymbolRate*ts_div_num_margin_ratio*2));
3086
3087 fTSDivNum.EXP -= 1;// fTSDivNum /= 2
3088
3089 fTSDivNum = MS_FLOAT_OP(fTSDivNum, ts_div_num_offset, minus); // fTSDivNum -= ts_div_num_offset
3090 }
3091
3092 temp.DATA = 0x1F;
3093 temp.EXP = 0;
3094
3095 if( MS_FLOAT_OP(fTSDivNum, temp, minus).DATA > 0 ) // fTSDivNum > 0x1F
3096 {
3097 fTSDivNum.DATA = 0x1F;
3098 fTSDivNum.EXP = 0;
3099 }
3100
3101 temp.DATA = 0x01;
3102 temp.EXP = 0;
3103
3104 if( MS_FLOAT_OP(fTSDivNum, temp, minus).DATA < 0 ) // fTSDivNum < 0x01
3105 {
3106 fTSDivNum.DATA = 0x01;
3107 fTSDivNum.EXP = 0;
3108 }
3109
3110 // shift bits
3111 if(fTSDivNum.EXP >= 0)
3112 u8Data = (fTSDivNum.DATA) << (fTSDivNum.EXP);
3113 else
3114 u8Data = (fTSDivNum.DATA) >> ((-1)*(fTSDivNum.EXP));
3115
3116 #ifdef MS_DEBUG
3117 ULOGD("DEMOD", ">>>INTERN_DVBS_Kernel_Mode TsClkDivNum = 0x%x<<<\n", u8Data);
3118 #endif
3119
3120 HAL_DMD_RIU_WriteByte(0x103300, u8Data);
3121
3122 //Ts Output Enable
3123 HAL_DMD_RIU_WriteByte(0x101eaa,0x10);
3124 }
3125
3126 return status;
3127 }
3128 #endif
3129