source: svn/zas_dstar/devices/Tuner/S5H1409/S5H1409Core.c

Last change on this file was 76, checked in by megakiss, 10 years ago

1W 대기전력을 만족시키기 위하여 POWEROFF시 튜너를 Standby 상태로 함
File size: 28.6 KB
Line 
1/****************************************************************************
2*
3*                       Copyright (c) 2001 Trident Microsystems, Inc.
4*                                                       All rights reserved
5*
6* The content of this file or document is CONFIDENTIAL and PROPRIETARY
7* to Trident Microsystems, Inc.  It is subject to the terms of a License
8* Agreement between Licensee and Trident Microsystems, Inc.
9* restricting among other things, the use, reproduction, distribution
10* and transfer.  Each of the embodiments, including this information and
11* any derivative work shall retain this copyright notice
12*
13* FileName: S5H1409.c
14*
15* modification history
16* Created by Alex
17* Date: 2006-2-28
18*******************************************************************************/
19#include "IicComm.h"
20//#include "TunerDebug.h"
21//#include "TunerDefs.h"
22#include "S5H1409Core.h"
23
24static DS_BOOL s_bSetQamInterleaver = FALSE;
25static DS_U8 Sdm_1409xModeControl(int isParallel);
26
27/**************************************************************************
28* S5H1409 Initialization Driver
29* Conditions:
30*
31* Description:
32* This function is called to initialize the register values.
33* This function must be called once to run the system properly.
34* After this function is called, the bypass on mode and VSB mode are set.
35
36***************************************************************************/
37
38DS_U8 Sdm_1409xInitialize(int output_mode)
39{       
40               
41                DS_U8 result = 0; 
42
43                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0xfa, 0x00);
44                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0xe2, 0x100);
45                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0x1c, 0x2d);
46                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0x1f, 0x2d);
47                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0x20, 0x1d);
48                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0x22, 0x4a);
49                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0x23, 0x20); // 0x10 --> 0x20
50                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0x29, 0x110f);
51                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0x44, 0x510);
52                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0x2a, 0x10b4);
53                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0x2b, 0x10ae);
54                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0x61, 0x10);
55                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0x71, 0x23);
56                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0x72, 0x05c0);
57                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0x58, 0x2222);
58                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0x59, 0x1162); //Alex,2006-8-3, 0x3262 ==>0x1162, VSB CO-CHANNEL mode
59                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0x5a, 0x3211);
60                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0x63, 0x4a00);
61                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0x65, 0x800);       
62                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0x54, 0x104);
63                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0x31, 0x020d);
64                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0x2c, 0x31);
65                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0x5d, 0x370);
66                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0x5e, 0x296);
67                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0x32, 0x100);
68                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0x82, 0x600);        //0x100->0x600  ,2006-8-1, // Alex added, 2006-5-13
69                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0x96, 0x0c);
70                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0x99, 0x101);
71                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0x9c, 0x2e37);
72                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0x9d, 0x2c37);
73                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0x9e, 0x2e37);
74                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0xad, 0x103f);       //modifify,2006-8-2,0x301f ==>> 0x103f
75                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0xf5, 0x00);
76                //OS_mDelay(100);
77                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0xf5, 0x01);
78
79                //Alex adde,2006-8-1
80                //
81                // (07/02/27, hwatk)
82                //
83                // result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0x92, 0x2f2f);
84                // result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0x93, 0x3232);
85                // 0x92: 0x2f2f --> 0x302f
86                // 0x93: 0x3332 --> 0x3232
87                //
88                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0x92, 0x302f);
89                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0x93, 0x3332);
90               
91                //
92                // (07/02/27, hwatk)
93                //
94                // result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0x81, 0x0004);
95                // result |= S5H_IicWriteOneRegister(IIC_1409x_RegId,0x86,0x003);
96                //
97                // 0x81: 0x0004 --> 0x0002
98                // 0x86: 0x0003 --> 0x0003
99                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0x81, 0x0002);
100                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0x8b, 0x2a37);
101                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId,0x86,0x002);
102                // Alex added, 2006-8-2
103                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId,0xac,0x1003);
104
105//////////////////The following is for QAM 6.0 MHz////////////////////////
106                //
107                // (07/02/27, hwatk)
108                //
109                //result |= S5H_IicWriteOneRegister(IIC_1409x_RegId,0x8a,0x2e39);
110                // 0x8A: 0x2e39 --> 0x2c38
111                //
112                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId,0x8a,0x2c38);
113                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId,0x86,0x0002);
114////////////////////////////////////////////////////////////////////
115                // Alex added, 2006-8-3
116                // 0xB1: 0x0E00 --> 0x000E (hwatk/070227)
117                //result |= S5H_IicWriteOneRegister(IIC_1409x_RegId,0xb1,0x0e00); //QAM
118                //
119                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId,0xb1,0x0e); //QAM
120               
121                // Alex added,2006-10-17,fix bug found in  SENCORE 996.
122                //result |= S5H_IicWriteOneRegister(IIC_1409x_RegId,0x28,0x1212);
123                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId,0x28,0x1010);
124                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId,0x21,0x01);
125                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId,0x09,0x50);
126                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId,0x50,0x30e);
127
128                //Sdm_1409xModeControl(SERIAL_OUTPUT);
129                Sdm_1409xModeControl(output_mode);
130                if(result !=0)
131                        printf("Failed in Sdm_1409xInitialize\n");
132               
133                return result;
134}
135
136
137/**************************************************************************
138* S5H1409 Soft reset Driver
139*       Conditions  :
140*       When a channel is changed or LNA is on/off,
141*       this function is called.
142*       Description :
143*       This function is called in order to reset all software conditions.
144*       But it does not reset the register values.
145
146*       Addr : 0xf5 
147*       Value: 0x00 -> Chip Reset Start
148*       Value: 0x01 -> Chip Reset End
149***************************************************************************/
150
151DS_U8 Sdm_1409xSoftReset(void)
152{       
153        DS_U8 result = 0;
154        result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0xf5, 0x00);
155        //OS_mDelay(100);
156        result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0xf5, 0x01);
157
158        return result;
159}
160
161
162
163 /**************************************************************************
164 * Name:
165 *              Sdm_1409xModeControl
166 * Description:
167 *              Select Parallel or Serial output for Mepg data
168                   Reg 0xab[8],  0:Parallel mode;    1: Serial Mode     
169 * Author:
170 *              Alex
171 ***************************************************************************/
172static DS_U8 Sdm_1409xModeControl(int bParallel)
173{
174        DS_U16 data;
175        DS_U8 result = 0;
176       
177        data = S5H_IicReadOneRegister(IIC_1409x_RegId, 0xab);
178        if (bParallel)
179        {
180                data &= 0xfeff;
181                printf("TS parallel mode output\n\n");
182        }
183        else if(!bParallel)
184        {
185                data |= 0x0100;
186                printf("TS Serial mode output\n\n");
187        }
188        result = S5H_IicWriteOneRegister(IIC_1409x_RegId, 0xab, data);
189
190        return result;         
191}
192 
193 /**************************************************************************
194 * Name:
195 *              Sdm_1409xGetQAMMode
196 * Description:
197 *              Check Qam 64/256
198 * Author:
199 *              Alex
200 ********************************************************************/
201DS_U8  Sdm_1409xGetQAMMode(TunerDemod *QamMode)
202 {
203        DS_U16 QamModeAuto,QamModeOut;
204
205        QamModeAuto = S5H_IicReadOneRegister(IIC_1409x_RegId,0x85);
206        QamModeOut = S5H_IicReadOneRegister(IIC_1409x_RegId,0xf0);
207        QamModeOut = ((unsigned int)QamModeOut>>8 & 0x01);
208
209        switch(QamModeAuto)
210        {
211                case 0x100:
212                        *QamMode = DEMOD_64QAM;
213                break; 
214                       
215                case 0x101:
216                        *QamMode = DEMOD_256QAM;
217                break; 
218
219                case 0x110:     // Auto detect
220                        if(QamModeOut)
221                                *QamMode = DEMOD_256QAM ;
222                        else
223                                *QamMode = DEMOD_64QAM;
224                break;
225
226                default:
227                        *QamMode = DEMOD_256QAM;
228                        printf("This is not QAM mode,please check.\n\n");
229                        return -1;                     
230                break; 
231        }
232
233        return 0;
234 }
235
236
237/**************************************************************************
238* S5H1409 Register Value reset Driver
239*       Conditions  :
240*       This function is called when the system needs initialization.
241*       Description :
242*       A register value is reset following this call.
243*       The system needs to call initialization function to be run properly
244*       after this function is called.
245*       Addr : 0xfa 
246*       Value:
247*       Following this call, a register value of the 0xf6 address is changed
248*       from '0x01' to '0x00'.
249*       After that the value is back to '0x01' automatically.
250***************************************************************************/
251
252DS_U8 Sdm_1409xRegReset(void)
253{       
254        DS_U8 result = 0;
255        result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0xfa, 0x00);
256
257       
258        return result;
259}
260
261/**************************************************************************
262* S5H1409 Repeater Control Driver
263*       Conditions:
264*       Description :
265*       This function is used to set the bypass mode or normal mode.
266*       (Repeater Enable or Disable)
267*       In the bypass mode, the host PC controls a channel chip first
268*       and the channel chip controls a tuner using GPIO.
269*       Addr : 0xf3 
270*       Value:
271*       0x00 -> Tuner by pass close (Repeater Disable)(Default)
272*       0x01 -> Tuner by pass open (Repeater Enable)
273***************************************************************************/
274
275DS_U8 Sdm_1409xRepeaterEnable(void)
276{       
277        DS_U8 result = 0;
278        result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0xf3, 0x01);
279
280       
281        return result;
282}
283DS_U8 Sdm_1409xRepeaterDisable(void)
284{       
285        DS_U8 result = 0;
286        result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0xf3, 0x00);
287
288       
289        return result;
290}
291
292/**************************************************************************
293* S5H1409 VSB,QAM mode change Driver
294*       Conditions:
295*       Description : These functions set an 8-VSB & QAM (64/256) mode
296*       Addr : 0xf4 
297*       Value: 0x00 -> VSB mode(Default)
298*       Value: 0x01 -> QAM mode
299*
300*       Addr : 0x85
301*       Value: 0x110 -> QAM (Detect 64/256 QAM automatically)   
302*       Value: 0x100 -> 64 QAM mode
303*       Value: 0x101 -> 256 QAM mode
304***************************************************************************/
305
306DS_U8 Sdm_1409xVsbMode(void)
307{       
308        DS_U8 result = 0;
309        result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0xf4, 0x00);
310        Sdm_1409xSoftReset();
311        Sdm_1409xSetQamInterleave(FALSE);
312       
313        return result;
314}
315
316DS_U8 Sdm_1409xQamMode(void)
317{       
318        DS_U8 result = 0;
319        result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0xf4,0x01);
320        result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0x85,0x110);
321       
322        Sdm_1409xSoftReset();
323        Sdm_1409xSetQamInterleave(TRUE);
324       
325        return result;
326}
327
328DS_U8 Sdm_1409x64QamMode(void)
329{       
330        DS_U8 ret = 0;
331
332        ret |=S5H_IicWriteOneRegister(IIC_1409x_RegId, 0xf4,0x01);
333        ret |=S5H_IicWriteOneRegister(IIC_1409x_RegId, 0x85,0x100);
334       
335        Sdm_1409xSoftReset();
336        Sdm_1409xSetQamInterleave(TRUE);
337       
338        return ret;
339}
340
341DS_U8 Sdm_1409x256QamMode(void)
342{       
343        DS_U8 result = 0;
344        result |=S5H_IicWriteOneRegister(IIC_1409x_RegId, 0xf4,0x01);
345        result |=S5H_IicWriteOneRegister(IIC_1409x_RegId, 0x85,0x101);
346        Sdm_1409xSoftReset();
347        Sdm_1409xSetQamInterleave(TRUE);
348       
349        return result;
350}
351
352/**************************************************************************
353* S5H1409 Sleep mode change Driver
354*       Conditions:
355*       Description :
356*       The software-based power down function is as follows.
357*       This function is called in order to set a sleep on mode or sleep off mode.
358*       Addr : 0xf2 
359*       Value:
360*       0x01 -> Sleep mode
361*       0x00 -> Running mode (Default)
362***************************************************************************/
363
364DS_U8 Sdm_1409xSleepOn(void)
365{       
366        DS_U8 result = 0;
367        result |=S5H_IicWriteOneRegister(IIC_1409x_RegId, 0xf2,0x01);
368
369       
370        return result;
371}
372DS_U8 Sdm_1409xSleepOff(void)
373{       
374        DS_U8 result = 0;
375        result |=S5H_IicWriteOneRegister(IIC_1409x_RegId, 0xf2,0x00);
376        Sdm_1409xSoftReset();
377
378       
379        return result;
380}
381
382//// Status Read Register Start
383/**************************************************************************
384* S5H1409 VSB/QAM Master Lock Check Driver
385*       Conditions:
386*       Description :
387*       This function is used to check whether the channel chip is lock
388*       or not in VSB mode.
389*       Addr : 0xf1 
390*       Value:
391*       15bit -> 1:Lock , 0:Unlock
392***************************************************************************/
393
394DS_U16 Sdm_1409xVsbQAMMasterLock(void)  //Master Lock!
395{       
396        DS_U16 value;
397        DS_U16 result;
398
399        value = S5H_IicReadOneRegister(IIC_1409x_RegId,0xf1);
400        result = ((unsigned int)value >>15)& 0x01;           
401
402        //printf("Register 0xf1 -> Value : 0x%hx\n",value);
403       
404        return (result);
405}
406
407/**************************************************************************
408* S5H1409 VSB Sync Lock Check Driver
409*       Conditions:
410*       Description :
411*       This function is used to check whether the channel chip is lock
412*       or not in VSB mode.
413*       Addr : 0x40 
414*       Value:
415*       bit 0 -> 1:Lock , 0:Unlock
416***************************************************************************/
417
418DS_U16 Sdm_1409xVsbSyncLock(void)       //Sync Lock!
419{       
420        DS_U16 value;
421        DS_U16 result;
422
423        value = S5H_IicReadOneRegister(IIC_1409x_RegId,0x40);
424        result = value & 0x01;           
425
426        //printf("Register 0x40 -> Value : 0x%hx\n",value);
427       
428        return (result);
429}
430
431/**************************************************************************
432* S5H1409 QAM EQ Lock Check Driver
433*       Conditions:
434*       Description :
435*       This function is used to check whether the channel chip is lock
436*       in QAM mode.
437*       Addr : 0xf0 
438*       Value:
439*       13bit -> 1:Lock , 0:Unlock
440***************************************************************************/
441
442DS_U16 Sdm_1409xQAMEQLock(void) //EQ Lock!
443{       
444        DS_U16 value;
445        DS_U16 result;
446
447        value = S5H_IicReadOneRegister(IIC_1409x_RegId,0xf0);
448        result = ((unsigned int)value >>13)& 0x01;           
449
450        //printf("Register 0xf0 -> Value : 0x%hx\n",value);
451       
452        return (result);
453}
454/**************************************************************************
455* S5H1409 VSB SNR value(Signal Strength) Check Driver
456*       Conditions:
457*       Description :
458*       This function lets the user's application software read a value
459*       that is related to the SNR through the SNR Look Up Table in VSB mode.
460*       Addr : 0xf1 
461*       Value: [9:0]
462**************************************************************************/
463
464double Sdm_1409xSnrLookUpTable(int SnrRead)
465{
466        double SnrLookUP;
467        if(SnrRead == 1023 ) SnrLookUP = 77 ;  // Something Wrong
468//      else if(SnrRead > 938 ) SnrLookUP = 0 ; // 0X3aa,masiac
469        else if(SnrRead > 923 ) SnrLookUP = 30.0f ;
470        else if(SnrRead > 918 ) SnrLookUP = 29.5f ;
471        else if(SnrRead > 915 ) SnrLookUP = 28.5f ;
472        else if(SnrRead > 911 ) SnrLookUP = 28.5f ;
473        else if(SnrRead > 906 ) SnrLookUP = 28.0f ;
474        else if(SnrRead > 901 ) SnrLookUP = 27.5f ;
475        else if(SnrRead > 896 ) SnrLookUP = 27.0f ;
476        else if(SnrRead > 891 ) SnrLookUP = 26.5f ;
477        else if(SnrRead > 885 ) SnrLookUP = 26.0f ;
478        else if(SnrRead > 879 ) SnrLookUP = 25.5f ;
479        else if(SnrRead > 873 ) SnrLookUP = 25.0f ;
480        else if(SnrRead > 864 ) SnrLookUP = 24.5f ;
481        else if(SnrRead > 858 ) SnrLookUP = 24.0f ;
482        else if(SnrRead > 850 ) SnrLookUP = 23.5f ;
483        else if(SnrRead > 841 ) SnrLookUP = 23.0f ;
484        else if(SnrRead > 832 ) SnrLookUP = 22.5f ;
485        else if(SnrRead > 823 ) SnrLookUP = 22.0f ;
486        else if(SnrRead > 812 ) SnrLookUP = 21.5f ;
487        else if(SnrRead > 802 ) SnrLookUP = 21.0f ;
488        else if(SnrRead > 788 ) SnrLookUP = 20.5f ;
489        else if(SnrRead > 778 ) SnrLookUP = 20.0f ;
490        else if(SnrRead > 767 ) SnrLookUP = 19.5f ;
491        else if(SnrRead > 753 ) SnrLookUP = 19.0f ;
492        else if(SnrRead > 740 ) SnrLookUP = 18.5f ;
493        else if(SnrRead > 725 ) SnrLookUP = 18.0f ;
494        else if(SnrRead > 707 ) SnrLookUP = 17.5f ;
495        else if(SnrRead > 689 ) SnrLookUP = 17.0f ;
496        else if(SnrRead > 671 ) SnrLookUP = 16.5f ;
497        else if(SnrRead > 656 ) SnrLookUP = 16.0f ;
498        else if(SnrRead > 637 ) SnrLookUP = 15.5f ;
499        else if(SnrRead > 616 ) SnrLookUP = 15.0f ;
500        else if(SnrRead > 542 ) SnrLookUP = 14.5f ;
501        else if(SnrRead > 519 ) SnrLookUP = 14.0f ;
502        else if(SnrRead > 507 ) SnrLookUP = 13.5f ;
503        else if(SnrRead > 497 ) SnrLookUP = 13.0f ;
504        else if(SnrRead > 492 ) SnrLookUP = 12.5f ;
505        else if(SnrRead > 474 ) SnrLookUP = 12.0f ;
506        else if(SnrRead > 300 ) SnrLookUP = 1.11f ;
507        else SnrLookUP = 0.0f; 
508        return SnrLookUP;
509}
510
511
512double Sdm_1409xVsbSnrResultCheck(void)
513{       
514        DS_U16 value;
515        double SnrValue;
516        value = S5H_IicReadOneRegister(IIC_1409x_RegId,0xf1);
517        //printf("Sdm_1409xVsbSnrResultCheck: 0xf1 = 0x%hx\n",value);
518        value = (value & 0x3ff);
519       
520        SnrValue = Sdm_1409xSnrLookUpTable(value);
521
522        //printf("value = %d , SnrValue = %f  \n",value,SnrValue);
523       
524        return SnrValue;
525}
526
527
528/**************************************************************************
529* S5H1409 QAM SNR value(Signal Strength) Check Driver
530*       Conditions:
531*       Description:
532*       This function lets the user's application software read a value
533*       that is related to the SNR through the SNR Look Up Table in QAM mode.
534*       Addr : 0xf0 
535*       Value: [13:0]
536**************************************************************************/
537
538double Sdm_1409xQam64SnrLookUpTable(int SnrRead)
539{
540        double SnrLookUP;
541        if(!SnrRead) SnrLookUP = 0;
542        else if(SnrRead<        12      ) SnrLookUP =   30      ;
543        else if(SnrRead <       15      ) SnrLookUP =   29      ;
544        else if(SnrRead <       18      ) SnrLookUP =   28      ;
545        else if(SnrRead <       22      ) SnrLookUP =   27      ;
546        else if(SnrRead <       23      ) SnrLookUP =   26.8    ;
547        else if(SnrRead <       24      ) SnrLookUP =   26.6    ;
548        else if(SnrRead <       25      ) SnrLookUP =   26.4    ;
549        else if(SnrRead <       27      ) SnrLookUP =   26.2    ;
550        else if(SnrRead <       28      ) SnrLookUP =   26      ;
551        else if(SnrRead <       29      ) SnrLookUP =   25.8    ;
552        else if(SnrRead <       30      ) SnrLookUP =   25.6    ;
553        else if(SnrRead <       32      ) SnrLookUP =   25.4    ;
554        else if(SnrRead <       33      ) SnrLookUP =   25.2    ;
555        else if(SnrRead <       34      ) SnrLookUP =   25      ;
556        else if(SnrRead <       35      ) SnrLookUP =   24.9    ;
557        else if(SnrRead <       36      ) SnrLookUP =   24.8    ;
558        else if(SnrRead <       37      ) SnrLookUP =   24.7    ;
559        else if(SnrRead <       38      ) SnrLookUP =   24.6    ;
560        else if(SnrRead <       39      ) SnrLookUP =   24.5    ;
561        else if(SnrRead <       40      ) SnrLookUP =   24.4    ;
562        else if(SnrRead <       41      ) SnrLookUP =   24.3    ;
563        else if(SnrRead <       41      ) SnrLookUP =   24.2    ;
564        else if(SnrRead <       42      ) SnrLookUP =   24.1    ;
565        else if(SnrRead <       43      ) SnrLookUP =   24      ;
566        else if(SnrRead <       44      ) SnrLookUP =   23.9    ;
567        else if(SnrRead <       45      ) SnrLookUP =   23.8    ;
568        else if(SnrRead <       46      ) SnrLookUP =   23.7    ;
569        else if(SnrRead <       47      ) SnrLookUP =   23.6    ;
570        else if(SnrRead <       48      ) SnrLookUP =   23.5    ;
571        else if(SnrRead <       49      ) SnrLookUP =   23.4    ;
572        else if(SnrRead <       50      ) SnrLookUP =   23.3    ;
573        else if(SnrRead <       51      ) SnrLookUP =   23.2    ;
574        else if(SnrRead <       52      ) SnrLookUP =   23.1    ;
575        else if(SnrRead <       53      ) SnrLookUP =   23      ;
576        else if(SnrRead <       55      ) SnrLookUP =   22.9    ;
577        else if(SnrRead <       56      ) SnrLookUP =   22.8    ;
578        else if(SnrRead <       57      ) SnrLookUP =   22.7    ;
579        else if(SnrRead <       58      ) SnrLookUP =   22.6    ;
580        else if(SnrRead <       59      ) SnrLookUP =   22.5    ;
581        else if(SnrRead <       60      ) SnrLookUP =   22.4    ;
582        else if(SnrRead <       62      ) SnrLookUP =   22.3    ;
583        else if(SnrRead <       63      ) SnrLookUP =   22.2    ;
584        else if(SnrRead <       65      ) SnrLookUP =   22.1    ;
585        else if(SnrRead <       66      ) SnrLookUP =   22      ;
586        else if(SnrRead <       68      ) SnrLookUP =   21.9    ;
587        else if(SnrRead <       69      ) SnrLookUP =   21.8    ;
588        else if(SnrRead <       70      ) SnrLookUP =   21.7    ;
589        else if(SnrRead <       72      ) SnrLookUP =   21.6    ;
590        else if(SnrRead <       73      ) SnrLookUP =   21.5    ;
591        else if(SnrRead <       75      ) SnrLookUP =   21.4    ;
592        else if(SnrRead <       76      ) SnrLookUP =   21.3    ;
593        else if(SnrRead <       78      ) SnrLookUP =   21.2    ;
594        else if(SnrRead <       80      ) SnrLookUP =   21.1    ;
595        else if(SnrRead <       81      ) SnrLookUP =   21      ;
596        else if(SnrRead <       83      ) SnrLookUP =   20.9    ;
597        else if(SnrRead <       84      ) SnrLookUP =   20.8    ;
598        else if(SnrRead <       85      ) SnrLookUP =   20.7    ;
599        else if(SnrRead <       87      ) SnrLookUP =   20.6    ;
600        else if(SnrRead <       89      ) SnrLookUP =   20.5    ;
601        else if(SnrRead <       91      ) SnrLookUP =   20.4    ;
602        else if(SnrRead <       93      ) SnrLookUP =   20.3    ;
603        else if(SnrRead <       95      ) SnrLookUP =   20.2    ;
604        else if(SnrRead <       96      ) SnrLookUP =   20.1    ;
605        else if(SnrRead <       104     ) SnrLookUP =   20      ;
606        else SnrLookUP = 0; 
607        return SnrLookUP;
608
609}
610
611double Sdm_1409xQam256SnrLookUpTable(int SnrRead)
612{
613        double SnrLookUP=0;
614        if(!SnrRead)SnrLookUP = 0;
615        else if(SnrRead<        12      ) SnrLookUP =   40      ;
616        else if(SnrRead <       13      ) SnrLookUP =   39      ;
617        else if(SnrRead <       15      ) SnrLookUP =   38      ;
618        else if(SnrRead <       17      ) SnrLookUP =   37      ;
619        else if(SnrRead <       19      ) SnrLookUP =   36      ;
620        else if(SnrRead <       22      ) SnrLookUP =   35      ;
621        else if(SnrRead <       22      ) SnrLookUP =   34.8    ;
622        else if(SnrRead <       23      ) SnrLookUP =   34.6    ;
623        else if(SnrRead <       24      ) SnrLookUP =   34.4    ;
624        else if(SnrRead <       25      ) SnrLookUP =   34.2    ;
625        else if(SnrRead <       26      ) SnrLookUP =   34      ;
626        else if(SnrRead <       27      ) SnrLookUP =   33.8    ;
627        else if(SnrRead <       27      ) SnrLookUP =   33.6    ;
628        else if(SnrRead <       28      ) SnrLookUP =   33.4    ;
629        else if(SnrRead <       29      ) SnrLookUP =   33.2    ;
630        else if(SnrRead <       30      ) SnrLookUP =   33      ;
631        else if(SnrRead <       31      ) SnrLookUP =   32.8    ;
632        else if(SnrRead <       32      ) SnrLookUP =   32.6    ;
633        else if(SnrRead <       33      ) SnrLookUP =   32.4    ;
634        else if(SnrRead <       34      ) SnrLookUP =   32.2    ;
635        else if(SnrRead <       35      ) SnrLookUP =   32      ;
636        else if(SnrRead <       37      ) SnrLookUP =   31.8    ;
637        else if(SnrRead <       39      ) SnrLookUP =   31.6    ;
638        else if(SnrRead <       40      ) SnrLookUP =   31.4    ;
639        else if(SnrRead <       41      ) SnrLookUP =   31.2    ;
640        else if(SnrRead <       42      ) SnrLookUP =   31      ;
641        else if(SnrRead <       43      ) SnrLookUP =   30.8    ;
642        else if(SnrRead <       46      ) SnrLookUP =   30.6    ;
643        else if(SnrRead <       47      ) SnrLookUP =   30.4    ;
644        else if(SnrRead <       49      ) SnrLookUP =   30.2    ;
645        else if(SnrRead <       51      ) SnrLookUP =   30      ;
646        else if(SnrRead <       53      ) SnrLookUP =   29.8    ;
647        else if(SnrRead <       54      ) SnrLookUP =   29.7    ;
648        else if(SnrRead <       55      ) SnrLookUP =   29.6    ;
649        else if(SnrRead <       56      ) SnrLookUP =   29.5    ;
650        else if(SnrRead <       57      ) SnrLookUP =   29.4    ;
651        else if(SnrRead <       59      ) SnrLookUP =   29.3    ;
652        else if(SnrRead <       60      ) SnrLookUP =   29.2    ;
653        else if(SnrRead <       61      ) SnrLookUP =   29.1    ;
654        else if(SnrRead <       63      ) SnrLookUP =   29      ;
655        else if(SnrRead <       64      ) SnrLookUP =   28.9    ;
656        else if(SnrRead <       65      ) SnrLookUP =   28.8    ;
657        else if(SnrRead <       66      ) SnrLookUP =   28.7    ;
658        else if(SnrRead <       68      ) SnrLookUP =   28.6    ;
659        else if(SnrRead <       69      ) SnrLookUP =   28.5    ;
660        else if(SnrRead <       71      ) SnrLookUP =   28.4    ;
661        else if(SnrRead <       72      ) SnrLookUP =   28.3    ;
662        else if(SnrRead <       74      ) SnrLookUP =   28.2    ;
663        else if(SnrRead <       75      ) SnrLookUP =   28.1    ;
664        else if(SnrRead <       76      ) SnrLookUP =   28      ;
665        else if(SnrRead <       77      ) SnrLookUP =   27.9    ;
666        else if(SnrRead <       78      ) SnrLookUP =   27.8    ;
667        else if(SnrRead <       81      ) SnrLookUP =   27.7    ;
668        else if(SnrRead <       83      ) SnrLookUP =   27.6    ;
669        else if(SnrRead <       84      ) SnrLookUP =   27.5    ;
670        else if(SnrRead <       86      ) SnrLookUP =   27.4    ;
671        else if(SnrRead <       87      ) SnrLookUP =   27.3    ;
672        else if(SnrRead <       89      ) SnrLookUP =   27.2    ;
673        else if(SnrRead <       90      ) SnrLookUP =   27.1    ;
674        else if(SnrRead <       92      ) SnrLookUP =   27      ;
675        else if(SnrRead <       93      ) SnrLookUP =   26.9    ;
676        else if(SnrRead <       95      ) SnrLookUP =   26.8    ;
677        else if(SnrRead <       96      ) SnrLookUP =   26.7    ;
678        else if(SnrRead <       98      ) SnrLookUP =   26.6    ;
679        else if(SnrRead <       100     ) SnrLookUP =   26.5    ;
680        else if(SnrRead <       102     ) SnrLookUP =   26.4    ;
681        else if(SnrRead <       104     ) SnrLookUP =   26.3    ;
682        else if(SnrRead <       105     ) SnrLookUP =   26.2    ;
683        else if(SnrRead <       106     ) SnrLookUP =   26.1    ;
684        else if(SnrRead <       110     ) SnrLookUP =   26      ;
685        else SnrLookUP = 0;
686
687//      printf("SnrRead=%d,SnrLookUP=%f\n",SnrRead,SnrLookUP);
688        return SnrLookUP;
689
690}
691
692 /**************************************************************************
693 * Name:
694 *              Sdm_1409xQamSnrValue
695 * Description:
696 *              Check the SNR value, The signal in 0x00-0x48 is good, and in 0x48-0xff is bad.
697 * Author:
698 *              Alex
699 ********************************************************************/
700DS_U8 Sdm_1409xQamSnrValue(void)
701{
702        DS_U16 value;
703        DS_U8 lock,ret=0;
704        value = S5H_IicReadOneRegister(IIC_1409x_RegId,0xf0);
705        lock =  (value>>12 & 0x01) && (value>>13 & 0x01);
706
707        if(!lock)
708                ret = 0xff;
709        else
710                ret = (value & 0xff);
711        return ret;
712}
713
714 /**************************************************************************
715 * Name:
716 *              Sdm_1409xVsbSnrValue
717 * Description:
718 *              Check the  VSB SNR value.
719 * Author:
720 *              Alex
721 ********************************************************************/
722DS_U16 Sdm_1409xVsbSnrValue(void)
723{       
724        DS_U16 value;
725
726        value = S5H_IicReadOneRegister(IIC_1409x_RegId,0xf1);
727        //printf("Sdm_1409xVsbSnrResultCheck: 0xf1 = 0x%hx\n",value);
728        value = (value & 0x3ff);
729       
730        return value;
731}
732
733double Sdm_1409xQamSnrResultCheck(void)
734{       
735        DS_U16 lvalue;
736        DS_U16 value;
737        DS_U16 value1;
738        DS_U16 value2;
739        DS_U16 result;
740        double SnrValue=0;
741        int lock=0;
742
743        value1 = S5H_IicReadOneRegister(IIC_1409x_RegId,0x85);
744        value2 = S5H_IicReadOneRegister(IIC_1409x_RegId,0xf0);
745        result = ((unsigned int)value2>>8 & 0x01);      //Qam64 or Qam256
746
747        value  = S5H_IicReadOneRegister(IIC_1409x_RegId,0xf0);
748        lock =  (value2>>12 & 0x01) && (value2>>13 & 0x01);     //Alex added,2006-7-31
749        if (lock)
750                lvalue  = (value & 0xff);
751        else
752                lvalue=0;
753
754        if (lock && lvalue == 0) {
755                lvalue=10;
756        }
757
758        //printf("lvalue= 0x%x;        value1 = 0x%x,result = 0x%x\n",lvalue,value1,result);
759       
760        if(value1==0x110 && result==1)         
761                {SnrValue = Sdm_1409xQam256SnrLookUpTable(lvalue);}
762        else if(value1==0x110 && result==0)     
763                {SnrValue = Sdm_1409xQam64SnrLookUpTable(lvalue);}
764        else if(value1==0x100 )                 
765                {SnrValue = Sdm_1409xQam64SnrLookUpTable(lvalue);}
766        else if(value1==0x101 )                 
767                {SnrValue = Sdm_1409xQam256SnrLookUpTable(lvalue);}
768
769        return (SnrValue);
770}
771
772 /**************************************************************************
773 * Name:
774 *              Sdm_1409SetScanMode
775 * Description:
776 *              bScanMode must be set true before doing the channel scan and set FALSE
777 *                 after finishing the scanning
778 * Author:
779 *              Alex
780 ********************************************************************/
781DS_U8 Sdm_1409SetScanMode(DS_BOOL bScanMode)
782{
783        DS_U8 result=0;
784        if(bScanMode)
785        {
786                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0x3b, 0x1000);//enable auto lock check of sync detector
787                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0x44, 0x500);        //disable auto reset of chip
788        }
789        else
790        {
791                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0x3b, 0x1010);//disable auto lock check of sync detector
792                result |= S5H_IicWriteOneRegister(IIC_1409x_RegId, 0x44, 0x510);        //enable auto reset of chip
793        }
794        return result;
795}
796
797
798 /*********************************************************************************************************
799* S5H1409 QAM Interleave mode set driver
800* Conditions: Only in qam mode
801* Description: In the TOV state at low SNR, this driver could be improve the perfomance.
802*    Call this function in a timer when in QAM mode( maybe 0.5-1 second / loop)
803* Addr: 0xab
804* Value: 0x1000 -> manually write the interleaver mode.
805* 2006-8-4   Alex
806**********************************************************************************************************/
807void Sdm_1409xQamInterleave_ModeSet(void)
808{
809        static int temp,temp1,temp2 = 0;
810        static int qam_up = 0;
811       
812        if(!Sdm_1409xIsQamMode())
813                return;
814       
815        temp = S5H_IicReadOneRegister(IIC_1409x_RegId,0xf1);
816        temp1= S5H_IicReadOneRegister(IIC_1409x_RegId, 0xb2);
817        temp2= S5H_IicReadOneRegister(IIC_1409x_RegId, 0xad);
818        if(Sdm_1409xVsbQAMMasterLock()) // if (master lock)
819        {
820                if(qam_up!=2) // VSB mode: m_IsVsb=1, Qam mode: m_IsVsb=0.
821                {
822                        qam_up = 2;
823                        S5H_IicWriteOneRegister(IIC_1409x_RegId,0x96,0x20);
824                        S5H_IicWriteOneRegister(IIC_1409x_RegId,0xad,( (( temp1&0xf000)>>4)|( temp2&0xf0ff )) );
825                        S5H_IicWriteOneRegister(IIC_1409x_RegId,0xab,0x1000);
826                }
827        }
828        else
829        {
830                if(qam_up!=1)
831                {
832                        qam_up = 1;
833                        S5H_IicWriteOneRegister (IIC_1409x_RegId, 0x96 , 0x0c );
834                        S5H_IicWriteOneRegister (IIC_1409x_RegId, 0xab , 0x1001 );
835                }
836        }
837        return;
838}
839
840 /**************************************************************************
841 * Name:
842 *              Sdm_1409xSetQamInterleave
843 * Description:
844 *             
845 * Author:
846 *              Alex
847 ********************************************************************/
848void Sdm_1409xSetQamInterleave(DS_BOOL bSet)
849{
850        s_bSetQamInterleaver = bSet;
851}
852
853DS_U16 Sdm_1409xGetRSErrCnt(void)
854{
855        DS_U16 value;
856
857        value = S5H_IicReadOneRegister(IIC_1409x_RegId,0xB5);
858       
859        return value;
860}
861
862DS_U16 Sdm_1409xGetTrellisErrCnt(void)
863{
864        DS_U16 value;
865
866        value = S5H_IicReadOneRegister(IIC_1409x_RegId,0xB7);
867       
868        return value;
869}
870
871 /**************************************************************************
872 * Name:
873 *              Dm_1490xIsQamMode
874 * Description:
875 *              Whether is it in QAM(Digital) Mode
876 * Author:
877 *              Alex
878 ********************************************************************/
879DS_BOOL Sdm_1409xIsQamMode(void)
880{
881        return s_bSetQamInterleaver;
882}
883
884void get_sdm(DS_U8 addr)
885{
886        DS_U16 value;
887       
888        value = S5H_IicReadOneRegister(IIC_1409x_RegId, addr);
889        printf("[S5H1409 Reg: 0x%02X] << Value=0x%04X\n", addr, value);
890}
891
892void set_sdm(DS_U8 addr, DS_U16 value)
893{
894        DS_U16 regValue;
895       
896        printf("B4 [S5H1409 Reg: 0x%02X] >> Value=0x%04X\n", addr, value);
897        S5H_IicWriteOneRegister(IIC_1409x_RegId, addr, value);
898        regValue = S5H_IicReadOneRegister(IIC_1409x_RegId, addr);
899        printf("A4 [S5H1409 Reg: 0x%02X] >> Value=0x%04X\n", addr, regValue);
900}
901
902/*****************************************************************************
903*                       End Of File
904*****************************************************************************/
905
Note: See TracBrowser for help on using the repository browser.