source: svn/trunk/zas_dstar/devices/Tuner/S5H1409/S5H1409.c @ 2

Last change on this file since 2 was 2, checked in by phkim, 11 years ago

1.phkim

  1. revision copy newcon3sk r27
File size: 17.1 KB
Line 
1/****************************************************************************
2 * Module:      S5H1409
3 *
4 * Description: Tuner Driver for DTF8640 Main Routines
5 *
6 * Notes: 20041019/hwatk
7 *
8 * TO DO
9 *
10 *              ChannelChange() ¿¡ ´ëÇÑ ÀÎÀÚ¸¦ ´Ù½ÃÈ®ÀÎÇÏÀÚ.
11 *
12 ************************************************************************^^*/
13
14
15#include "dsthalcommon.h"
16
17#include "S5H1409.h"
18#include "S5H1409Core.h"
19
20extern DS_U32 gdhlExtDbgLvl;
21
22typedef struct tag_S5H2C_info {
23        OS_SEMAPHORE_ID Mutex; 
24        DS_U32          OrenI2cAddr;
25/*      DS_U16          Tda9885Addr;    */
26/*      DS_U16          TunerAddr;      TunerAddrÀº »ç¿ëµÇÁö ¾ÊÀ½. -- OREN DemodulatorÀÇ I2C¿¡ ¹°·ÁÀÖÀ½. */
27        /* Current FAT channel information. */
28        DS_U32                  FATFreq;
29        TunerDemod              CurFATDemod;
30        DS_U8                   *pMicroCode;
31        DS_U16                  microCodeLen;
32        DS_U32                  bInitialized;
33        DS_U8                   isNtsc;
34} *P_S5H_INFO, S5H_INFO;
35
36S5H_INFO g_S5H_info;
37P_S5H_INFO pS5H = &g_S5H_info;
38
39int S5H_SetFrequencyDTV( DS_U32 dMHz );
40
41int S5H_GetVersion( DS_U32 *pVersion )
42{
43    DS_U32 version;
44   
45    version = 0x00000001;
46   
47        *pVersion = version;
48       
49        return 0;
50}
51
52int S5H_Initialize(void)
53{
54        int retVal = 0;
55        static int sem_initialized = 0;
56
57        if ( sem_initialized == 0 ) {
58                pS5H->Mutex = OS_CreateBinarySemaphore( "S5H_Sema4", 0, 1 );
59                if ( pS5H->Mutex == (OS_SEMAPHORE_ID)0 ) {
60                        DHL_DbgPrintf(gdhlExtDbgLvl,DHLDBG_EXT, "ERROR: OS_CreateMutexSemaphore\n");
61                        retVal = -1;
62                        goto done;
63                }
64                pS5H->OrenI2cAddr = 0;
65                sem_initialized = 1;
66        }
67       
68        DHL_SYS_SetGPIO(GPIO_DEMOD_RESETN, 0);
69        OS_mDelay(200);
70        DHL_SYS_SetGPIO(GPIO_DEMOD_RESETN, 1);
71        OS_mDelay(200);
72       
73        retVal = Sdm_1409xInitialize(1/*1:Parallel*/);
74        if (retVal) {
75                DHL_DbgPrintf(0,DHLDBG_EXT, "ERROR: Cannot Initialize S5H1409.\n");
76                retVal = -1;
77        }
78
79done:   
80        return retVal;
81
82}
83
84/****************************************************************************
85       
86        S5H_Start()
87
88                Summary : Start Oren demodulator.
89                Returns : 0 on success, others on failure.
90               
91 ************************************************************************^^*/
92int S5H_Start( TunerDemod Demod, int Ntsc, int Cable )
93{
94        int retVal = 0;
95        DS_U8 sdmRet;
96        DS_U32 semErr;
97
98        /* Take Mutex. */
99        semErr = OS_TakeSemaphore( pS5H->Mutex );
100        if ( semErr != 0 )
101                return -1;
102       
103        if (Ntsc) {
104                //
105                // ´Ü¼øÈ÷ Tuner¸¸ Æ©´×ÇÏÀÚ.
106                //
107                sdmRet = Sdm_1409xSleepOn();
108                if (sdmRet) {
109                        printf("|%s| ERROR, LINE=%d\n", __FUNCTION__, __LINE__);
110                        retVal = -1;
111                        goto done;
112                }
113
114#if NIMTN_TYPE==NIMTN_DTT7611
115                retVal = Tuner_DTT7611SendFreq( pS5H->FATFreq, TUNERDTT7611_REF_DIVIDER_RATIO_62_5, TUNERDTT7611_AGC_WIDE_BAND_OFF, 2, TUNERDTT7611_CHARGE_PUMP_60, TUNERDTT7611_AGC_TIME_CONSTANT_2_SEC );
116                if ( retVal != DTT7611_SUCCESS ) {
117                        DHL_DbgPrintf(0,DHLDBG_EXT,"ERROR: line=%d, Result = %d\n", __LINE__, retVal );
118                        retVal = -1;
119                }
120#elif NIMTN_TYPE==NIMTN_U7A06
121                retVal = Tuner_U7A06_SendFreq( pS5H->FATFreq, Demod );
122                if ( retVal < 0 ) {
123                        DHL_DbgPrintf(0,DHLDBG_EXT,"ERROR: line=%d, Result = %d\n", __LINE__, retVal );
124                        retVal = -1;
125                }
126#elif NIMTN_TYPE==NIMTN_DTVS205
127                retVal = TunerDTVS205FH201ASendFreq(
128                                pS5H->FATFreq, TUNERDTVS205FH201A_REF_DIVIDER_RATIO_62_5,
129                                TUNERDTVS205FH201A_AGC_WIDE_BAND_OFF,0,TUNERDTVS205FH201A_CHARGE_PUMP_100,
130                                TUNERDTVS205FH201A_AGC_TIME_CONSTANT_2_SEC );
131//              retVal = Tuner_DTT7611SendFreq( pS5H->FATFreq, TUNERDTT7611_REF_DIVIDER_RATIO_62_5, TUNERDTT7611_AGC_WIDE_BAND_OFF, 2, TUNERDTT7611_CHARGE_PUMP_60, TUNERDTT7611_AGC_TIME_CONSTANT_2_SEC );
132                if ( retVal != DTVS205FH201A_SUCCESS ) {
133                        DHL_DbgPrintf(0,DHLDBG_EXT,"ERROR: line=%d, Result = %d\n", __LINE__, retVal );
134                        retVal = -1;
135                }
136
137#else
138        #error NIMTN_TYPE shall be defined first.
139#endif
140                sdmRet = Sdm_1409xRepeaterDisable();
141                if (sdmRet) {
142                        printf("|%s| ERROR, LINE=%d\n", __FUNCTION__, __LINE__);
143                        retVal = -1;
144                        goto done;
145                }
146                sdmRet = Sdm_1409xSoftReset();
147                if (sdmRet) {
148                        printf("|%s| ERROR, LINE=%d\n", __FUNCTION__, __LINE__);
149                        retVal = -1;
150                        goto done;
151                }
152                Sdm_1409xSetQamInterleave(FALSE);
153        } else {
154                sdmRet = Sdm_1409xSleepOff();
155                if (sdmRet) {
156                        printf("|%s| ERROR, LINE=%d\n", __FUNCTION__, __LINE__);
157                        retVal = -1;
158                        goto done;
159                }
160
161                if ( Demod == DEMOD_8VSB ) {
162                        sdmRet = Sdm_1409SetScanMode(TRUE);
163                        if (sdmRet) {
164                                printf("|%s| ERROR, LINE=%d\n", __FUNCTION__, __LINE__);
165                                retVal = -1;
166                                goto done;
167                        }
168                }
169
170#if NIMTN_TYPE==NIMTN_DTT7611
171                retVal = Tuner_DTT7611SendFreq( pS5H->FATFreq, TUNERDTT7611_REF_DIVIDER_RATIO_62_5, TUNERDTT7611_AGC_93, 1, TUNERDTT7611_CHARGE_PUMP_60, TUNERDTT7611_AGC_TIME_CONSTANT_2_SEC );
172                if ( retVal != DTT7611_SUCCESS ) {
173                        DHL_DbgPrintf(0,DHLDBG_EXT,"ERROR: line=%d, Result = %d\n", __LINE__, retVal );
174                        retVal = -1;
175                        goto done;
176                }
177#elif NIMTN_TYPE==NIMTN_U7A06
178                retVal = Tuner_U7A06_SendFreq( pS5H->FATFreq, Demod );
179                if ( retVal < 0 ) {
180                        DHL_DbgPrintf(0,DHLDBG_EXT,"ERROR: line=%d, Result = %d\n", __LINE__, retVal );
181                        retVal = -1;
182                        goto done;
183                }
184#elif NIMTN_TYPE==NIMTN_DTVS205
185                retVal = TunerDTVS205FH201ASendFreq(
186                                pS5H->FATFreq, TUNERDTVS205FH201A_REF_DIVIDER_RATIO_62_5,
187                                TUNERDTVS205FH201A_AGC_WIDE_BAND_OFF,0,TUNERDTVS205FH201A_CHARGE_PUMP_100,
188                                TUNERDTVS205FH201A_AGC_TIME_CONSTANT_2_SEC );
189//              retVal = Tuner_DTT7611SendFreq( pS5H->FATFreq, TUNERDTT7611_REF_DIVIDER_RATIO_62_5, TUNERDTT7611_AGC_WIDE_BAND_OFF, 2, TUNERDTT7611_CHARGE_PUMP_60, TUNERDTT7611_AGC_TIME_CONSTANT_2_SEC );
190                if ( retVal != DTVS205FH201A_SUCCESS ) {
191                        DHL_DbgPrintf(0,DHLDBG_EXT,"ERROR: line=%d, Result = %d\n", __LINE__, retVal );
192                        retVal = -1;
193                        goto done;
194                }
195#else
196        #error NIMTN_TYPE shall be defined first.
197#endif
198               
199                switch(Demod) {
200                        case DEMOD_8VSB: sdmRet = Sdm_1409xVsbMode(); break;
201                        case DEMOD_QAM: sdmRet = Sdm_1409xQamMode(); break;
202                        case DEMOD_64QAM: sdmRet = Sdm_1409x64QamMode(); break;
203                        case DEMOD_256QAM: sdmRet = Sdm_1409x256QamMode(); break;
204                        default:
205                                printf("|%s| ERROR, LINE=%d\n", __FUNCTION__, __LINE__);
206                                goto done;
207                }
208                if (sdmRet) {
209                        printf("|%s| ERROR, LINE=%d\n", __FUNCTION__, __LINE__);
210                        goto done;
211                }
212                               
213                if ( Demod == DEMOD_8VSB ) {
214                        sdmRet = Sdm_1409SetScanMode(FALSE);
215                        if (sdmRet) {
216                                printf("|%s| ERROR, LINE=%d\n", __FUNCTION__, __LINE__);
217                                retVal = -1;
218                                goto done;
219                        }
220                }
221        }
222       
223        pS5H->CurFATDemod = Demod;
224       
225        DHL_DbgPrintf(gdhlExtDbgLvl,DHLDBG_EXT,"dMHz = %ld Mode=%s(%d)\n", pS5H->FATFreq, 
226                Demod == DEMOD_8VSB ? "8VSB" : 
227                Demod == DEMOD_QAM ? "QAM" :           
228                Demod == DEMOD_64QAM ? "64QAM" :               
229                Demod == DEMOD_256QAM ? "256QAM" :             
230                Demod == DEMOD_NTSC ? "NTSC" : "Unknown", Demod);
231       
232done:
233        /* Give Mutex. */
234        semErr = OS_GiveSemaphore( pS5H->Mutex );
235        if ( semErr != 0 )
236                retVal = -1;
237
238        if (!retVal)
239                DHL_DbgPrintf(gdhlExtDbgLvl,DHLDBG_EXT,"success.\n");
240        else
241                DHL_DbgPrintf(gdhlExtDbgLvl,DHLDBG_EXT,"failure.\n");
242
243        return retVal;
244}
245
246/****************************************************************************
247       
248        S5H_Stop()
249
250                Summary : Stop the Oren demodulator.
251                Returns : 0 on success, others on failure.
252               
253 ************************************************************************^^*/
254int S5H_Stop(void)
255{
256        int retVal = 0;
257        DS_U32 semErr;
258
259        /* Take Mutex. */
260        semErr = OS_TakeSemaphore( pS5H->Mutex );
261        if ( semErr != 0 )
262                return -1;
263       
264        /* DO NOTHING. */       
265       
266        /* Give Mutex. */
267        semErr = OS_GiveSemaphore( pS5H->Mutex );
268        if ( semErr != 0 )
269                retVal = -1;
270
271        return retVal;
272}
273
274
275/****************************************************************************
276       
277        S5H_Close()
278
279                Summary : Close the Oren demodulator.
280                Returns : 0 on success, others on failure.
281               
282 ************************************************************************^^*/
283int S5H_Close(void)
284{
285        int retVal = 0;
286        DS_U32 semErr;
287
288        /* Take Mutex. */
289        semErr = OS_TakeSemaphore( pS5H->Mutex );
290        if ( semErr != 0 )
291                return -1;
292       
293
294        /* DO NOTHING */
295        goto done;
296       
297done:
298        /* Give Mutex. */
299        semErr = OS_GiveSemaphore( pS5H->Mutex );
300        if ( semErr != 0 )
301                retVal = -1;
302
303        return retVal;
304}
305
306/****************************************************************************
307       
308        S5H_Reset()
309
310                Summary : Reset the Oren demodulator.
311                Returns : 0 on success, others on failure.
312               
313 ************************************************************************^^*/
314int S5H_Reset(void)
315{
316        int retVal = 0;
317        DS_U32 semErr;
318
319        /* Take Mutex. */
320        semErr = OS_TakeSemaphore( pS5H->Mutex );
321        if ( semErr != 0 )
322                return -1;
323       
324        /* Give Mutex. */
325        semErr = OS_GiveSemaphore( pS5H->Mutex );
326        if ( semErr != 0 )
327                retVal = -1;
328
329        return retVal;
330}
331
332/****************************************************************************
333       
334        S5H_SetFrequency()
335
336                Summary : Set Frequency
337                Returns : 0 on success, others on failure.
338               
339 ************************************************************************^^*/
340int S5H_SetFrequencyNTSC( DS_U32 dMHz )
341{
342        int retVal = 0;
343        DS_U32 semErr;
344       
345        /* Take Mutex. */
346        semErr = OS_TakeSemaphore( pS5H->Mutex );
347        if ( semErr != 0 )
348                return -1;
349       
350        Sdm_1409xSleepOn();
351       
352#if NIMTN_TYPE==NIMTN_DTT7611
353        retVal = Tuner_DTT7611SendFreq( dMHz, TUNERDTT7611_REF_DIVIDER_RATIO_62_5, TUNERDTT7611_AGC_WIDE_BAND_OFF, 2, TUNERDTT7611_CHARGE_PUMP_60, TUNERDTT7611_AGC_TIME_CONSTANT_2_SEC );
354        if ( retVal != DTT7611_SUCCESS ) {
355                DHL_DbgPrintf(0,DHLDBG_EXT,"ERROR: line=%d, Result = %d\n", __LINE__, retVal );
356                retVal = -1;
357        }
358#elif NIMTN_TYPE==NIMTN_U7A06
359        retVal = Tuner_U7A06_SendFreq( dMHz, DEMOD_NTSC );
360        if ( retVal < 0 ) {
361                DHL_DbgPrintf(0,DHLDBG_EXT,"ERROR: line=%d, Result = %d\n", __LINE__, retVal );
362                retVal = -1;
363        }
364#elif NIMTN_TYPE==NIMTN_DTVS205
365                retVal = TunerDTVS205FH201ASendFreq(
366                                dMHz, TUNERDTVS205FH201A_REF_DIVIDER_RATIO_62_5,
367                                TUNERDTVS205FH201A_AGC_WIDE_BAND_OFF,0,TUNERDTVS205FH201A_CHARGE_PUMP_100,
368                                TUNERDTVS205FH201A_AGC_TIME_CONSTANT_2_SEC );
369//              retVal = Tuner_DTT7611SendFreq( pS5H->FATFreq, TUNERDTT7611_REF_DIVIDER_RATIO_62_5, TUNERDTT7611_AGC_WIDE_BAND_OFF, 2, TUNERDTT7611_CHARGE_PUMP_60, TUNERDTT7611_AGC_TIME_CONSTANT_2_SEC );
370                if ( retVal != DTVS205FH201A_SUCCESS ) {
371                        DHL_DbgPrintf(0,DHLDBG_EXT,"ERROR: line=%d, Result = %d\n", __LINE__, retVal );
372                        retVal = -1;
373                }
374#else
375
376        #error NIMTN_TYPE shall be defined first.
377#endif
378
379        Sdm_1409xRepeaterDisable();
380
381        /* Give Mutex. */
382        semErr = OS_GiveSemaphore( pS5H->Mutex );
383        if ( semErr != 0 )
384                retVal = -1;
385
386        return retVal;
387}
388
389//
390// Tuner Á¦¾îÇÏÁö ¾Ê°í, ³»ºÎÀûÀ¸·Î TuningÇÒ ÁÖÆļö¸¦ ¸í½ÃÇÏ´Â ÇÔ¼ö.
391// ¼³Á¤µÈ ÁÖÆļö´Â ´ÙÀ½ S5H_Start() È£Ã⠽ÿ¡ Àû¿ëµÊ.
392//
393int S5H_SetFrequency( DS_U32 dMHz )
394{
395        int retVal = 0;
396        DS_U32 semErr;
397        DS_U32 freq;
398       
399        /* Take Mutex. */
400        semErr = OS_TakeSemaphore( pS5H->Mutex );
401        if ( semErr != 0 )
402                return -1;
403       
404        freq = (DS_U32)dMHz;
405        pS5H->FATFreq = freq;
406        DHL_DbgPrintf(gdhlExtDbgLvl,DHLDBG_EXT,"dMHz = %d\n", (int)freq );
407
408        /* Give Mutex. */
409        semErr = OS_GiveSemaphore( pS5H->Mutex );
410        if ( semErr != 0 )
411                retVal = -1;
412
413        return retVal;
414}
415
416DS_U32 S5H_GetFrequency(void)
417{
418        return pS5H->FATFreq;
419}
420
421/****************************************************************************
422       
423        S5H_GetLockStatus()
424
425                Summary : Set Frequency
426                Returns : 0 on success, others on failure.
427               
428 ************************************************************************^^*/
429int S5H_GetLockStatus( int *pLockStatus )
430{
431        int retVal = 0;
432        DS_U32 semErr;
433        DS_U16 lock;
434       
435        /* Take Mutex. */
436        semErr = OS_TakeSemaphore( pS5H->Mutex );
437        if ( semErr != 0 )
438                return -1;
439       
440        if (pS5H->CurFATDemod != DEMOD_NTSC) {
441                lock = Sdm_1409xVsbQAMMasterLock();
442                *pLockStatus = lock ? 1 : 0;
443       
444                switch(pS5H->CurFATDemod) {
445                        case DEMOD_8VSB: lock = Sdm_1409xVsbSyncLock(); break;
446                        case DEMOD_QAM:
447                        case DEMOD_256QAM:
448                        case DEMOD_64QAM: lock = Sdm_1409xQAMEQLock(); break;
449                        default:
450                                printf("|%s| ERROR: Invalid demodulation mode=%d\n", __FUNCTION__, pS5H->CurFATDemod);
451                }
452        } else {
453                /* shall be implemented. */
454                *pLockStatus = 0;
455        }
456       
457        /* Give Mutex. */
458        semErr = OS_GiveSemaphore( pS5H->Mutex );
459        if ( semErr != 0 )
460                retVal = -1;
461
462        return retVal;
463}
464
465int S5H_GetLockStatusNTSC( int *pLockStatus )
466{
467        int retVal = 0;
468        DS_U32 semErr;
469       
470        /* Take Mutex. */
471        semErr = OS_TakeSemaphore( pS5H->Mutex );
472        if ( semErr != 0 )
473                return -1;
474       
475        /* Give Mutex. */
476        semErr = OS_GiveSemaphore( pS5H->Mutex );
477        if ( semErr != 0 )
478                retVal = -1;
479
480        return retVal;
481}
482
483/****************************************************************************
484       
485        S5H_GetSignalStrength()
486
487                Summary : Get signal strength from demodulator.
488                Returns : 0 on success, others on failure.
489               
490 ************************************************************************^^*/
491int S5H_GetSignalStrength( int *pSQI )
492{
493        int retVal = 0;
494        DS_U32 semErr;
495        float SNR = 0;
496        int maxSNR = 30;
497        TunerDemod mode;
498        int SQI;
499
500        if ( pS5H->CurFATDemod == DEMOD_NTSC ) {
501                *pSQI = 0;
502                return 0;
503        }
504       
505        /* Take Mutex. */
506        semErr = OS_TakeSemaphore( pS5H->Mutex );
507        if ( semErr != 0 )
508                return -1;
509       
510        if (pS5H->CurFATDemod == DEMOD_QAM)
511                Sdm_1409xGetQAMMode(&mode);
512        else
513                mode = pS5H->CurFATDemod;
514       
515        switch(mode) {
516                case DEMOD_8VSB:
517                {
518                        maxSNR=30;     
519                        SNR = Sdm_1409xVsbSnrResultCheck(); 
520                        break;
521                }
522                       
523                case DEMOD_64QAM:
524                {
525                        SNR = Sdm_1409xQamSnrResultCheck(); 
526                        maxSNR=30; 
527                        break; 
528                }
529               
530                case DEMOD_256QAM:
531                {
532                        SNR = Sdm_1409xQamSnrResultCheck(); 
533                        if (SNR == 77)
534                                SNR = 25.0;
535                        maxSNR=40; 
536                        break; 
537                }
538
539                case DEMOD_QAM:
540                {
541                        SNR = Sdm_1409xQamSnrResultCheck(); 
542                        maxSNR=30; 
543                        break; 
544                }
545
546                default:
547                        printf("|%s| ERROR, LINE=%d\n", __FUNCTION__, __LINE__);
548                        goto done;
549        }
550        //printf("SNR is %l\n",SNR);
551        SQI = SNR * 100;
552        if (maxSNR)
553                SQI /= maxSNR;
554        else
555                SQI /= 30;
556        //printf("SQI is %l\n",SQI);
557        *pSQI = SQI;
558
559done:   
560        /* Give Mutex. */
561        semErr = OS_GiveSemaphore( pS5H->Mutex );
562        if ( semErr != 0 )
563                retVal = -1;
564       
565        return retVal;
566}
567
568
569int S5H_GetSignalPower( int *pPower )
570{
571        int retVal = 0;
572        DS_U32 semErr;
573
574        /* Take Mutex. */
575        semErr = OS_TakeSemaphore( pS5H->Mutex );
576        if ( semErr != 0 )
577                return -1;
578       
579        /* Give Mutex. */
580        semErr = OS_GiveSemaphore( pS5H->Mutex );
581        if ( semErr != 0 )
582                retVal = -1;
583
584        return retVal;
585}
586       
587/****************************************************************************
588       
589        S5H_GetSNR
590
591                Summary : Get signal strength from demodulator.
592                Returns : 0 on success, others on failure.
593               
594 ************************************************************************^^*/
595int S5H_GetSNR( float *pSNR )
596{
597        int retVal = 0;
598        DS_U32 semErr;
599        double SNR = 0.0;
600       
601        /* Take Mutex. */
602        semErr = OS_TakeSemaphore( pS5H->Mutex );
603        if ( semErr != 0 )
604                return -1;
605       
606        if (pS5H->CurFATDemod == DEMOD_NTSC) {
607                *pSNR = 6;
608        } else {
609                switch(pS5H->CurFATDemod) {
610                        case DEMOD_8VSB: SNR = Sdm_1409xVsbSnrResultCheck(); break;
611                        case DEMOD_QAM:
612                        case DEMOD_256QAM:
613                        case DEMOD_64QAM: SNR = Sdm_1409xQamSnrResultCheck(); break;
614                        default:
615                                printf("|%s| ERROR: Invalid demodulation mode=%d\n", __FUNCTION__, pS5H->CurFATDemod);
616                }
617        }
618       
619        if ( SNR == 77 )
620                *pSNR = 0.0;
621        else
622                *pSNR = SNR;
623       
624        /* Give Mutex. */
625        semErr = OS_GiveSemaphore( pS5H->Mutex );
626        if ( semErr != 0 )
627                retVal = -1;
628
629        return retVal;
630}
631
632
633/****************************************************************************
634       
635        S5H_GetModFormat
636
637                Summary : Get signal strength from demodulator.
638                Returns : 0 on success, others on failure.
639               
640 ************************************************************************^^*/
641int S5H_GetModFormat( TunerDemod *mode )
642{
643        int retVal = 0;
644        DS_U32 semErr;
645        TunerDemod qam_mode;
646        DS_U8 sdmRet;
647       
648        semErr = OS_TakeSemaphore( pS5H->Mutex );
649        if ( semErr != 0 )
650                return -1;
651       
652        if (pS5H->CurFATDemod == DEMOD_QAM) {
653                sdmRet = Sdm_1409xGetQAMMode(&qam_mode);
654                if ( sdmRet ) {
655                        printf("|%s| ERROR, LINE=%d\n", __FUNCTION__, __LINE__);
656                        *mode = DEMOD_256QAM;
657                        goto done;
658                }
659                *mode = qam_mode;
660        } else
661                *mode = pS5H->CurFATDemod;
662
663done:
664        /* Give Mutex. */
665        semErr = OS_GiveSemaphore( pS5H->Mutex );
666        if ( semErr != 0 )
667                retVal = -1;
668
669        return retVal;
670}
671
672
673/****************************************************************************
674       
675        S5H_GetErrCount
676
677                Summary : Get signal strength from demodulator.
678                Returns : 0 on success, others on failure.
679               
680 ************************************************************************^^*/
681int S5H_GetErrCount( DS_U32 *pRSErrCnt )
682{
683        int retVal = 0;
684        DS_U32 semErr;
685       
686        /* Take Mutex. */
687        semErr = OS_TakeSemaphore( pS5H->Mutex );
688        if ( semErr != 0 )
689                return -1;
690               
691        *pRSErrCnt = Sdm_1409xGetRSErrCnt();
692       
693        /* Give Mutex. */
694        semErr = OS_GiveSemaphore( pS5H->Mutex );
695        if ( semErr != 0 )
696                retVal = -1;
697
698        return retVal;
699}
700
701
702/****************************************************************************
703       
704        S5H_GetTDA9885Reg
705
706                Summary :
707                Returns : 0 on success, others on failure.
708               
709 ************************************************************************^^*/
710int S5H_GetTDA9885Reg( DS_U8 *pStatus )
711{
712        int retVal = 0;
713        DS_U32 semErr;
714#if ((NIMTN_TYPE==NIMTN_DTT7611) || (NIMTN_TYPE==NIMTN_U7A06))
715        DS_U8 data;
716#endif
717        /* Take Mutex. */
718        semErr = OS_TakeSemaphore( pS5H->Mutex );
719        if ( semErr != 0 )
720                return -1;
721
722#if NIMTN_TYPE==NIMTN_DTT7611
723        data = Tuner_GetTDA9885();
724        *pStatus = data;
725#elif NIMTN_TYPE==NIMTN_U7A06
726        data = Tuner_U7A06GetADC();
727        *pStatus = data;
728#endif
729        /* Give Mutex. */
730        semErr = OS_GiveSemaphore( pS5H->Mutex );
731        if ( semErr != 0 )
732                retVal = -1;
733
734        return retVal;
735}
736
737//
738// Notes: Standard ÁöÁ¤Çϸé, ´ÙÀ½ Æ©´× ¶§¿¡ Àû¿ëµÊ.
739//
740int S5H_SetAudioStandard( DS_U32 AudioStandard)
741{
742        int err = 0;
743
744        return err;
745}
746
747int S5H_SetAudioMode( DS_U32 AudioMode )
748{
749        int err = 0;
750       
751        return err;
752}
753
754int S5H_GetAudioMode( DS_U32 *pAudioMode )
755{
756        int err = 0;
757
758        return err;
759}
760
761int S5H_GetAudioStandard( DS_U32 *pAudioStandard )
762{
763        return 0;
764}
Note: See TracBrowser for help on using the repository browser.