/**************************************************************************** *_Copyright (c) 2004 Digital Stream Technologies Inc. All Rights Reserved. * * Module: dsthalfe.cpp * Author: Jun-ku Park, hwatk@dstreamtech.com * Description: DST HAL [Front End] Platform/Project Indepedent Sources * * notes: hwatk20050708 * * TO DO LIST * - Implement BERT Functions. * ***************************************************************************/ #include #include #include #include #include "dsthalcommon.h" #include "dstdddtv.h" #include "dstddaud.h" #include "dstddfe.h" #include "dstddsys.h" #ifdef DMALLOC #include #endif /****************************************************************************** * Global variable declaration ******************************************************************************/ DST_FE sDSTFE_Tuner[TUNER_MAX-1] = { {0}, {0} }; int gdhlFeDbgLvl = 2; int g_AnalogSearchDelay = 1000; int g_PreAudioModeDelay = 200; int g_AftAudioModeDelay = 200; /****************************************************************************** * Imported variable declaration ******************************************************************************/ extern DHL_DTV_CONFIG g_dhlav; extern DHL_CAP_CONFIG g_dhlcap; extern DHL_CAP_VideoTiming_t PrevVideoTiming, PrevVideoTimingPIP; /****************************************************************************** * Imported function declaration ******************************************************************************/ /****************************************************************************** * Local definitions and typedefs ******************************************************************************/ #define USE_NTSCCALLBACK 1 // NTSC Call Back 사용 여부 #define USE_DIGITAL_CALLBACK 0 // Digital Callback 사용 여부 #define USE_ANALOGLOCKSTATUS 0 #define MDELAY(x) OS_mDelay((x)) #define USE_IN_KHZ 0 // Frequency Table을 KHz 단위로 사용할 것인지 // MHz 단위로 사용할 것인지 여부 /****************************************************************************** * Local variables declaration ******************************************************************************/ int g_fe_debug = 0; int g_force_ss = 0; int g_test_weak_interval = 0; /****************************************************************************** * Local function prototypes ******************************************************************************/ #if USE_NTSCCALLBACK static DHL_RESULT DHL_FE_NTSCCallbackInit(void); #endif void set_lock(int l); #if 0 ___Frequency_Table__________() {} #endif /* Frequency Conversion Table from HDMB - Tuner.c */ #if USE_IN_KHZ /* 2005.05.30 - Frequency Table 수정 */ DS_U16 Air_Freq[69+2] = { 0, 0, 57, 63, 69, 79, 85,177,183,189, 195,201,207,213,473,479,485,491,497,503, 509,515,521,527,533,539,545,551,557,563, 569,575,581,587,593,599,605,611,617,623, 629,635,641,647,653,659,665,671,677,683, 689,695,701,707,713,719,725,731,737,743, 749,755,761,767,773,779,785,791,797,803, }; DS_U16 Cable_Freq[160] = { 0, 75, 57, 63, 69, 79, 85,177,183,189, 195,201,207,213,123,129,135,141,147,153, 159,165,171,219,225,231,237,243,249,255, 261,267,273,279,285,291,297,303,309,315, 321,327,333,339,345,351,357,363,369,375, 381,387,393,399,405,411,417,423,429,435, 441,447,453,459,465,471,477,483,489,495, 501,507,513,519,525,531,537,543,549,555, 561,567,573,579,585,591,597,603,609,615, 621,627,633,639,645, 93, 99,105,111,117, 651,657,663,669,675,681,687,693,699,705, 711,717,723,729,735,741,747,753,759,765, 771,777,783,789,795,801,807,813,819,825, 831,837,843,849,855,861,867,873,879,885, 891,897,903,909,915,921,927,933,939,945, 951,957,963,969,975,981,987,993,999, }; DS_U16 Cable_Freq_IRC[160] = { 0, 75, 57, 63, 69, 81, 87,177,183,189, 195,201,207,213,123,129,135,141,147,153, 159,165,171,219,225,231,237,243,249,255, 261,267,273,279,285,291,297,303,309,315, 321,327,333,339,345,351,357,363,369,375, 381,387,393,399,405,411,417,423,429,435, 441,447,453,459,465,471,477,483,489,495, 501,507,513,519,525,531,537,543,549,555, 561,567,573,579,585,591,597,603,609,615, 621,627,633,639,645, 93, 99,105,111,117, 651,657,663,669,675,681,687,693,699,705, 711,717,723,729,735,741,747,753,759,765, 771,777,783,789,795,801,807,813,819,825, 831,837,843,849,855,861,867,873,879,885, 891,897,903,909,915,921,927,933,939,945, 951,957,963,969,975,981,987,993,999, }; DS_U16 Cable_Freq_HRC[160] = { 0, 74, 56, 62, 68, 80, 86,176,182,188, 194,200,206,212,122,128,134,140,146,152, 158,164,170,218,224,230,236,242,248,254, 260,266,272,278,284,290,296,302,308,314, 320,326,332,338,344,350,356,362,368,374, 380,386,392,398,404,410,416,422,428,434, 440,446,452,458,464,470,476,482,488,494, 500,506,512,518,524,530,536,542,548,554, 560,566,572,578,584,590,596,602,608,614, 620,626,632,638,644, 92, 98,104,110,116, 650,656,662,668,674,680,686,692,698,704, 710,716,722,728,734,740,746,752,758,764, 770,776,782,788,794,800,806,812,818,824, 830,836,842,848,854,860,866,872,878,884, 890,896,902,908,914,920,926,932,938,944, 950,956,962,968,974,980,986,992,998, }; #else DS_U32 Air_Freq[83+2] = { 0, 0, 57000, 63000, 69000, 79000, 85000,177000,183000,189000, 195000,201000,207000,213000,473000,479000,485000,491000,497000,503000, 509000,515000,521000,527000,533000,539000,545000,551000,557000,563000, 569000,575000,581000,587000,593000,599000,605000,611000,617000,623000, 629000,635000,641000,647000,653000,659000,665000,671000,677000,683000, 689000,695000,701000,707000,713000,719000,725000,731000,737000,743000, 749000,755000,761000,767000,773000,779000,785000,791000,797000,803000, 809000,815000,821000,827000,833000,839000,845000,851000,857000,863000, 869000,875000,881000,887000 }; DS_U32 Cable_Freq[160] = { 0, 75000, 57000, 63000, 69000, 79000, 85000,177000,183000,189000, 195000,201000,207000,213000,123000,129000,135000,141000,147000,153000, 159000,165000,171000,219000,225000,231000,237000,243000,249000,255000, 261000,267000,273000,279000,285000,291000,297000,303000,309000,315000, 321000,327000,333000,339000,345000,351000,357000,363000,369000,375000, 381000,387000,393000,399000,405000,411000,417000,423000,429000,435000, 441000,447000,453000,459000,465000,471000,477000,483000,489000,495000, 501000,507000,513000,519000,525000,531000,537000,543000,549000,555000, 561000,567000,573000,579000,585000,591000,597000,603000,609000,615000, 621000,627000,633000,639000,645000, 93000, 99000,105000,111000,117000, 651000,657000,663000,669000,675000,681000,687000,693000,699000,705000, 711000,717000,723000,729000,735000,741000,747000,753000,759000,765000, 771000,777000,783000,789000,795000,801000,807000,813000,819000,825000, 831000,837000,843000,849000,855000,861000,867000,873000,879000,885000, 891000,897000,903000,909000,915000,921000,927000,933000,939000,945000, 951000,957000,963000,969000,975000,981000,987000,993000,999000, }; DS_U32 Cable_Freq_IRC[160] = { 0, 75000, 57000, 63000, 69000, 81000, 87000,177000,183000,189000, 195000,201000,207000,213000,123000,129000,135000,141000,147000,153000, 159000,165000,171000,219000,225000,231000,237000,243000,249000,255000, 261000,267000,273000,279000,285000,291000,297000,303000,309000,315000, 321000,327000,333000,339000,345000,351000,357000,363000,369000,375000, 381000,387000,393000,399000,405000,411000,417000,423000,429000,435000, 441000,447000,453000,459000,465000,471000,477000,483000,489000,495000, 501000,507000,513000,519000,525000,531000,537000,543000,549000,555000, 561000,567000,573000,579000,585000,591000,597000,603000,609000,615000, 621000,627000,633000,639000,645000, 93000, 99000,105000,111000,117000, 651000,657000,663000,669000,675000,681000,687000,693000,699000,705000, 711000,717000,723000,729000,735000,741000,747000,753000,759000,765000, 771000,777000,783000,789000,795000,801000,807000,813000,819000,825000, 831000,837000,843000,849000,855000,861000,867000,873000,879000,885000, 891000,897000,903000,909000,915000,921000,927000,933000,939000,945000, 951000,957000,963000,969000,975000,981000,987000,993000,999000 }; DS_U32 Cable_Freq_HRC[160] = { // 0 1 2 3 4 5 6 7 8 9 0, 73750, 55750, 61750, 67750, 79750, 85750,175750,181750,187750, // 0~ 9 193750,199750,205750,211750,121750,127750,133750,139750,145750,151750, // 10~ 19 157750,163750,169750,217750,223750,229750,235750,241750,247750,253750, // 20~ 29 259750,265750,271750,277750,283750,289750,295750,301750,307750,313750, // 30~ 39 319750,325750,331750,337750,343750,349750,355750,361750,367750,373750, // 40~ 49 379750,385750,391750,397750,403750,409750,415750,421750,427750,433750, // 50~ 59 439750,445750,451750,457750,463750,469750,475750,481750,487750,493750, // 60~ 69 499750,505750,511750,517750,523750,529750,535750,541750,547750,553750, // 70~ 79 559750,565750,571750,577750,583750,589750,595750,601750,607750,613750, // 80~ 89 619750,625750,631750,637750,643750, 91750, 97750,103750,109750,115750, // 90~ 99 649750,655750,661750,667750,673750,679750,685750,691750,697750,703750, // 100~109 709750,715750,721750,727750,733750,739750,745750,751750,757750,763750, // 110~119 769750,775750,781750,787750,793750,799750,805750,811750,817750,823750, // 120~129 829750,835750,841750,847750,853750,859750,865750,871750,877750,884750, 890750,896750,902750,908750,914750,920750,926750,932750,938750,944750, 950750,956750,962750,968750,974750,980750,986750,992750,998750, // 130~135 }; #endif #if USE_IN_KHZ static DS_U32 ConvertChannelToFrequency( DS_U32 Channel, FreqStandardType FreqStd ) { DS_U32 Frequency; switch ( FreqStd ) { case FREQ_AIR: Frequency = Air_Freq[Channel] * 1000; break; case FREQ_STD: Frequency = Cable_Freq[Channel] * 1000; break; case FREQ_IRC: Frequency = Cable_Freq_IRC[Channel] * 1000; break; case FREQ_HRC: Frequency = Cable_Freq_HRC[Channel] * 1000; break; default: DHL_DbgPrintf( 0, DHLDBG_FE, "Error with Channel = %lu, FreqStd = %d\n", Channel, FreqStd ); return 0; } return Frequency; } #else static DS_U32 ConvertChannelToFrequency( DS_U32 Channel, FreqStandardType FreqStd ) { DS_U32 Frequency; switch ( FreqStd ) { case FREQ_AIR: Frequency = Air_Freq[Channel]; break; case FREQ_STD: Frequency = Cable_Freq[Channel]; break; case FREQ_IRC: Frequency = Cable_Freq_IRC[Channel]; break; case FREQ_HRC: Frequency = Cable_Freq_HRC[Channel]; break; default: DHL_DbgPrintf( 0, DHLDBG_FE, "Error with Channel = %lu, FreqStd = %d\n", Channel, FreqStd ); return 0; } return Frequency; } #endif #if 0 ___Main_FE_Functions_________() #endif /**************************************************************************** DHL_RESULT DHL_FE_Init - Summary : Initialize Front End, including Tuner/Demodulator. - Argument : Tuner to use, TunerType { TUNER_FAT, TUNER_FDC } - Returns : DHL_OK on success, DHL_FAIL on failure. ***************************************************************************/ DHL_RESULT DHL_FE_Init( TunerType Tuner ) { P_DST_FE pDSTFETuner; int RetVal; int i; if ( Tuner >= TUNER_MAX || Tuner <= TUNER_UNKNOWN ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error : Tuner is unknown!\n" ); return DHL_FAIL; } pDSTFETuner = &sDSTFE_Tuner[Tuner-1]; if ( pDSTFETuner->bCurState != TUNERSTATE_UNKNOWN ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error : Tuner State is unknown!\n" ); return DHL_FAIL; } pDSTFETuner->bFreqStd = FREQ_AIR; /* Default AIR */ pDSTFETuner->bCurDemod = DEMOD_UNKNOWN; /* Default 8VSB */ pDSTFETuner->bChannel = 0; pDSTFETuner->uFrequency = 0; pDSTFETuner->bCarrierMute = 0; for (i=0; i<(FECALLBACK_MAX-1); i++) { pDSTFETuner->fnFECallback[i] = (P_DHL_FE_CALLBACK)0; pDSTFETuner->FECallbackUserArg[i] = 0; } RetVal = DD_FE_Init( Tuner, pDSTFETuner ); if ( RetVal != DHL_OK ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error : DD_FE_Init()\n" ); return DHL_FAIL; } #if USE_NTSCCALLBACK if ( Tuner == TUNER_FAT ) DHL_FE_NTSCCallbackInit(); #endif pDSTFETuner->bTuner = Tuner; pDSTFETuner->bCurState = TUNERSTATE_INIT; pDSTFETuner->bBERTStarted = _FALSE_; /* FALSE means NOT-STARTED. */ /* Initialize MUTEX */ return DHL_OK; } /**************************************************************************** DHL_RESULT DHL_FE_SetChannelStandard - Summary : Set Channel Standard for Tuner. - Argument TunerType { TUNER_FAT, TUNER_FDC } FreqStandardType { FREQ_AIR, FREQ_STD, FREQ_IRC, FREQ_IRC } - Returns : DHL_OK on success, DHL_FAIL on failure - Note . Don't use MUTEX. ***************************************************************************/ DHL_RESULT DHL_FE_SetChannelStandard( TunerType Tuner, FreqStandardType FreqStd ) { P_DST_FE pDSTFETuner; if ( (Tuner >= TUNER_MAX) || (Tuner <= TUNER_UNKNOWN) ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Selected Tuner is %d\n", Tuner ); return DHL_FAIL; } pDSTFETuner = &sDSTFE_Tuner[Tuner-1]; if ( (pDSTFETuner->bCurState != TUNERSTATE_INIT) && (pDSTFETuner->bCurState != TUNERSTATE_STOP) ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error: This function should be called in TUNER_INIT, TUNER_STOP\n" ); return DHL_FAIL; } if ( (FreqStd <= FREQ_UNKNOWN) || FreqStd >= (FREQ_MAX) ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Frequency Standard is invalid, %d\n", FreqStd ); return DHL_FAIL; } pDSTFETuner->bFreqStd = FreqStd; return DHL_OK; } /**************************************************************************** DHL_RESULT DHL_FE_Start - Summary : Set Channel / Frequency on Tuner. - Argument TunerType { TUNER_FAT, TUNER_FDC } ChannelFreq if ( Tuner == TUNER_FAT ) ChannelFreq = Channel else if ( Tuner == TUNER_FDC ) ChannelFreq = Frequency, 1 unit = 1000 Hz Demod { DEMOD_8VSB, DEMOD_64QAM, DEMOD_256QAM, DEMOD_NTSC, DEMOD_ISDBT, DEMOD_ISDBT_MANUAL } bFreq { CHANNEL, FREQ } - Returns : DHL_OK on success, DHL_FAIL on failure ***************************************************************************/ DHL_RESULT DHL_FE_Start( TunerType Tuner, DS_U32 ChannelFreq, TunerDemod Demod, TuneType bFreq ) { P_DST_FE pDSTFETuner; DHL_RESULT dhlResult = DHL_OK; DS_U32 Frequency = 0; if ( Tuner >= TUNER_MAX || Tuner <= TUNER_UNKNOWN ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Selected Tuner is %d\n", Tuner ); return DHL_FAIL; } //JFET20050513 | ADD LOG - for the tuner IF select //FE_SelectTunerIF(Demod); if ( Tuner == TUNER_FAT ) { if ( (Demod <= DEMOD_UNKNOWN) || (Demod > DEMOD_OFF) ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Demodulation Type is invalid, %d\n", Demod ); return DHL_FAIL_INVALID_PARAM; } if ( bFreq == CHANNEL ) { if ( (ChannelFreq < MIN_FAT_CH) || (ChannelFreq > MAX_FAT_CH) ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Channel is over limited area, %lu\n", ChannelFreq ); return DHL_FAIL; } } else { /* Frequency Check is done at lower Tuner Driver */ } } else { /* FDC Check is not implemented yet */ if ( (Demod != DEMOD_MODEA) && (Demod != DEMOD_MODEB) ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Demodulation Type is invalid, 0x%x\n", Demod ); return DHL_FAIL_INVALID_PARAM; } } pDSTFETuner = &sDSTFE_Tuner[Tuner-1]; /* Take the MUTEX */ if ( pDSTFETuner->bCurState == TUNERSTATE_UNKNOWN ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Tuner State is %d\n", pDSTFETuner->bCurState ); dhlResult = DHL_FAIL; goto done; } if ( (pDSTFETuner->bFreqStd <= FREQ_UNKNOWN) || (pDSTFETuner->bFreqStd >= FREQ_MAX) ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Frequency Standard is invalid, %d\n", pDSTFETuner->bFreqStd ); dhlResult = DHL_FAIL; goto done; } #if 0 if ( (Demod == DEMOD_8VSB) && (pDSTFETuner->bFreqStd != FREQ_AIR) ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Demodulation is 8VSB, but Frequency Standard is not FREQ_AIR!\n" ); dhlResult = DHL_FAIL; goto done; } #endif /* * Convert Channel to Frequency if bFreq = CHANNEL. */ if ( bFreq == CHANNEL ) { Frequency = ConvertChannelToFrequency( ChannelFreq, pDSTFETuner->bFreqStd ); } else { Frequency = ChannelFreq; } if ( (Tuner == TUNER_FDC) && (bFreq != FREQ) ) { dhlResult = DHL_FAIL; goto done; } if ( Tuner == TUNER_FAT ) dhlResult = DD_FE_SetChannelFAT( pDSTFETuner, Frequency * 1000, &Demod ); else dhlResult = DD_FE_SetChannelFDC( pDSTFETuner, Frequency * 1000, &Demod ); if ( dhlResult != DHL_OK ) goto done; pDSTFETuner->bCurState = TUNERSTATE_START; pDSTFETuner->bCurDemod = Demod; pDSTFETuner->uFrequency = Frequency; if ( bFreq == CHANNEL ) pDSTFETuner->bChannel = ChannelFreq; // // Digital Callback을 사용하지 않는 경우, (하위 FE Driver가 지원하는 경우) // NTSC Callback Function만을 사용하도록 함. // #if USE_NTSCCALLBACK if ( pDSTFETuner->bCurDemod == DEMOD_NTSC ) { if ( pDSTFETuner->fnFECallbackNTSC[FECALLBACK_ACQSTART-1] ) { (pDSTFETuner->fnFECallbackNTSC[FECALLBACK_ACQSTART-1])(pDSTFETuner->bTuner, FECALLBACK_ACQSTART, pDSTFETuner->FECallbackNTSCUserArg[FECALLBACK_ACQSTART-1]); } if ( g_fe_debug ) { DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "[FAT] %s Acqusition start.\n", Demod == DEMOD_8VSB ? "8VSB" : Demod == DEMOD_64QAM ? "64QAM" : Demod == DEMOD_256QAM ? "256QAM" : Demod == DEMOD_QAM ? "QAM" : Demod == DEMOD_NTSC ? "NTSC" : Demod == DEMOD_ISDBT ? "ISDB-T" : Demod == DEMOD_ISDBT_MANUAL ? "ISDB-T Manual" : Demod == DEMOD_MODEA ? "MODEA" : Demod == DEMOD_MODEB ? "MODEB" : "Unknown"); } } #endif #if USE_DIGITAL_CALLBACK if ( pDSTFETuner->bCurDemod != DEMOD_NTSC ) { if ( pDSTFETuner->fnFECallback[FECALLBACK_ACQSTART-1] ) { (pDSTFETuner->fnFECallback[FECALLBACK_ACQSTART-1])(pDSTFETuner->bTuner, FECALLBACK_ACQSTART, pDSTFETuner->FECallbackUserArg[FECALLBACK_ACQSTART-1]); } if ( g_fe_debug ) { DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "[FAT] %s Acqusition start.\n", Demod == DEMOD_8VSB ? "8VSB" : Demod == DEMOD_64QAM ? "64QAM" : Demod == DEMOD_256QAM ? "256QAM" : Demod == DEMOD_QAM ? "QAM" : Demod == DEMOD_NTSC ? "NTSC" : Demod == DEMOD_ISDBT ? "ISDB-T" : Demod == DEMOD_ISDBT_MANUAL ? "ISDB-T Manual" : Demod == DEMOD_MODEA ? "MODEA" : Demod == DEMOD_MODEB ? "MODEB" : "Unknown"); } } #endif // // Monitor Thread Activate는 Callback Function 호출 이후에... // if ( Tuner == TUNER_FAT ) { pDSTFETuner->NotifyState = FE_WAIT_FOR_LOCK; pDSTFETuner->bThreadActive = _TRUE_; } done: /* Give the MUTEX */ return dhlResult; } /**************************************************************************** DHL_RESULT DHL_FE_Stop - Summary : Stop the Tuner. - Argument TunerType { TUNER_FAT, TUNER_FDC } - Returns : DHL_OK on success, DHL_FAIL on failure ***************************************************************************/ DHL_RESULT DHL_FE_Stop( TunerType Tuner ) { P_DST_FE pDSTFETuner; DHL_RESULT dhlResult; if ( Tuner >= TUNER_MAX || Tuner <= TUNER_UNKNOWN ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Selected Tuner is %d\n", Tuner ); return DHL_FAIL; } pDSTFETuner = &sDSTFE_Tuner[Tuner-1]; /* Take the MUTEX */ /* State Checking */ if ( pDSTFETuner->bCurState != TUNERSTATE_START ) { //DHL_DbgPrintf( 0, DHLDBG_FE, " WARNING: Tuner State is NOT TUNERSTATE_START, %d\n", pDSTFETuner->bCurState ); dhlResult = DHL_OK; goto done; } /* Call the lower device driver */ dhlResult = DD_FE_Stop( pDSTFETuner ); if ( dhlResult != DHL_OK ) goto done; pDSTFETuner->bCurState = TUNERSTATE_STOP; if ( Tuner == TUNER_FAT ) { pDSTFETuner->NotifyState = FE_WAIT_FOR_LOCK; pDSTFETuner->bThreadActive = _FALSE_; } done: /* Give the MUTEX */ return dhlResult; } /**************************************************************************** DHL_RESULT DHL_FE_Close - Summary Close Front End. (Used to re-initialize FE.) - Argument TunerType { TUNER_FAT, TUNER_FDC } - Returns DHL_OK on success, DHL_FAIL on failure. - Note ***************************************************************************/ DHL_RESULT DHL_FE_Close( TunerType Tuner ) { P_DST_FE pDSTFETuner; DHL_RESULT dhlResult = DHL_OK; if ( Tuner >= TUNER_MAX || Tuner <= TUNER_UNKNOWN ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Selected Tuner is %d\n", Tuner ); return DHL_FAIL; } pDSTFETuner = &sDSTFE_Tuner[Tuner-1]; /* Take the MUTEX */ /* State Checking */ if ( pDSTFETuner->bCurState == TUNERSTATE_UNKNOWN ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error: This tuner is not initialized or closed already.\n" ); dhlResult = DHL_FAIL; goto done; } if ( (pDSTFETuner->bCurState == TUNERSTATE_START) || (pDSTFETuner->bCurState == TUNERSTATE_INIT) ) { dhlResult = DD_FE_Stop( pDSTFETuner ); if ( dhlResult != DHL_OK ) goto done; pDSTFETuner->bCurState = TUNERSTATE_STOP; } /* Call the lower device driver */ dhlResult = DD_FE_Close( pDSTFETuner ); if ( dhlResult != DHL_OK ) goto done; pDSTFETuner->bTuner = TUNER_UNKNOWN; pDSTFETuner->bCurState = TUNERSTATE_UNKNOWN; pDSTFETuner->bFreqStd = FREQ_UNKNOWN; /* Default AIR */ pDSTFETuner->bCurDemod = DEMOD_UNKNOWN; /* Default 8VSB */ pDSTFETuner->bChannel = 0; pDSTFETuner->uFrequency = 0; done: /* Give the MUTEX */ return dhlResult; } /**************************************************************************** DHL_RESULT DHL_FE_SetCallback - Summary Register/Unregister FE Callback Function. - Argument TunerType { TUNER_FAT, TUNER_FDC } FECallbackSource { FECALLBACK_ACQSTART, FECALLBACK_LOCK, FECALLBACK_UNLOCK } P_DHL_FE_CALLBACK fn, if fn is NULL, then unregister FE callback function. DS_U32 userArg, passed to fn. - Returns : DHL_OK on success, DHL_FAIL on failure - Note typedef void (*P_DHL_FE_CALLBACK)(TunerType Tuner, FECallbackSource eventSource, DS_U32 userArg); ***************************************************************************/ DHL_RESULT DHL_FE_SetCallback( TunerType Tuner, FECallbackSource eventSource, P_DHL_FE_CALLBACK fn, DS_U32 userArg ) { DHL_RESULT dhlResult = DHL_OK; P_DST_FE pDSTFETuner; if ( (Tuner >= TUNER_MAX) || (Tuner <= TUNER_UNKNOWN) ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Selected Tuner is %d\n", Tuner ); return DHL_FAIL; } if ( (eventSource >= FECALLBACK_MAX) || (eventSource <= FECALLBACK_UNKNOWN) ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Callback Event Source is invalid, %d\n", eventSource ); return DHL_FAIL; } pDSTFETuner = &sDSTFE_Tuner[Tuner-1]; /* Take the MUTEX */ /* State Checking */ if ( (pDSTFETuner->bCurState != TUNERSTATE_INIT) && (pDSTFETuner->bCurState != TUNERSTATE_STOP) ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Should be called TUNERSTATE_INIT or TUNERSTATE_STOP, bCurState= %d\n", pDSTFETuner->bCurState ); dhlResult = DHL_FAIL; goto done; } pDSTFETuner->fnFECallback[eventSource-1] = fn; pDSTFETuner->FECallbackUserArg[eventSource-1] = userArg; done: /* Give the MUTEX */ return dhlResult; } DHL_RESULT DHL_FE_SetCallbackNTSC( TunerType Tuner, FECallbackSource eventSource, P_DHL_FE_CALLBACK fn, DS_U32 userArg ) { DHL_RESULT dhlResult = DHL_OK; P_DST_FE pDSTFETuner; if ( Tuner != TUNER_FAT ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Selected Tuner is %d\n", Tuner ); return DHL_FAIL; } if ( (eventSource >= FECALLBACK_MAX) || (eventSource <= FECALLBACK_UNKNOWN) ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Callback Event Source is invalid, %d\n", eventSource ); return DHL_FAIL; } pDSTFETuner = &sDSTFE_Tuner[Tuner-1]; /* Take the MUTEX */ pDSTFETuner->fnFECallbackNTSC[eventSource-1] = fn; pDSTFETuner->FECallbackNTSCUserArg[eventSource-1] = userArg; /* Give the MUTEX */ return dhlResult; } /**************************************************************************** DHL_RESULT DHL_FE_GetLockStatus - Summary : Get the lock status from tuner. - Argument TunerType { TUNER_FAT, TUNER_FDC } pLockStatus : Lock State loaded into. - Returns : DHL_OK on success, DHL_FAIL on failure ***************************************************************************/ DHL_RESULT DHL_FE_GetLockStatus( TunerType Tuner, DS_U8 *pLockStatus ) { P_DST_FE pDSTFETuner = (P_DST_FE)0; DS_U8 LockStatus; DHL_RESULT dhlResult = DHL_OK; if ( (Tuner >= TUNER_MAX) || (Tuner <= TUNER_UNKNOWN) ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Selected Tuner is %d\n", Tuner ); return DHL_FAIL; } /* Argument Checking */ if ( pLockStatus == (DS_U8 *)0 ) { return DHL_FAIL; } /* Take the MUTEX */ /* Tuner State Checking */ pDSTFETuner = &sDSTFE_Tuner[Tuner-1]; if ( (pDSTFETuner->bCurState <= TUNERSTATE_UNKNOWN) || (pDSTFETuner->bCurState >= TUNERSTATE_MAX) ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Tuner State is Invalid, %d\n", pDSTFETuner->bCurState ); dhlResult = DHL_FAIL; goto done; } /* Put invalid on DST_FE information */ pDSTFETuner->bLockStatus = -1; dhlResult = DD_FE_GetLockStatus( pDSTFETuner, &LockStatus ); if ( dhlResult != DHL_OK ) { *pLockStatus = 0; DHL_DbgPrintf( 0, DHLDBG_FE, "Error: DD_FE_GetLockStatus()\n" ); goto done; } pDSTFETuner->bLockStatus = LockStatus; *pLockStatus = LockStatus; if ( g_force_ss == 1 ) { *pLockStatus= 1; } else if ( g_force_ss == 2 ) { *pLockStatus= 0; } done: /* Give the MUTEX */ return dhlResult; } /**************************************************************************** DHL_RESULT DHL_FE_GetModFormat - Summary : Get the modulation format from tuner. - Argument TunerType { TUNER_FAT, TUNER_FDC } pModFormat : Modulation Format - Returns : DHL_OK on success, DHL_FAIL on failure ***************************************************************************/ DHL_RESULT DHL_FE_GetModFormat( TunerType Tuner, TunerDemod *pModFormat ) { P_DST_FE pDSTFETuner = (P_DST_FE)0; DHL_RESULT dhlResult = DHL_OK; TunerDemod ModFormat; if ( (Tuner >= TUNER_MAX) || (Tuner <= TUNER_UNKNOWN) ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Selected Tuner is %d\n", Tuner ); return DHL_FAIL; } /* Argument Checking */ if ( pModFormat == (TunerDemod *)0 ) { return DHL_FAIL; } /* Take the MUTEX */ /* Tuner State Checking */ pDSTFETuner = &sDSTFE_Tuner[Tuner-1]; if ( (pDSTFETuner->bCurState <= TUNERSTATE_UNKNOWN) || (pDSTFETuner->bCurState >= TUNERSTATE_MAX) ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Tuner State is Invalid, %d\n", pDSTFETuner->bCurState ); dhlResult = DHL_FAIL; goto done; } /* Put invalid on DST_FE information */ //pDSTFETuner->bCurDemod = DEMOD_UNKNOWN; *pModFormat = pDSTFETuner->bCurDemod; dhlResult = DD_FE_GetModFormat( pDSTFETuner, &ModFormat ); if ( dhlResult != DHL_OK ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error: DD_FE_GetLockStatus()\n" ); goto done; } pDSTFETuner->bCurDemod = ModFormat; *pModFormat = ModFormat; done: /* Give the MUTEX */ return dhlResult; } /**************************************************************************** DHL_RESULT DHL_FE_GetSNR - Summary : Calculate the demodulator (Equalizer) SNR from SQI. - Arguments TunerType { TUNER_FAT, TUNER_FDC } pSNR : SNR loaded into. - Returns : DHL_OK on success, DHL_FAIL on failure - Note . Valid only if the tuner is locked. ***************************************************************************/ DHL_RESULT DHL_FE_GetSNR( TunerType Tuner, float *pSNR ) { P_DST_FE pDSTFETuner = (P_DST_FE)0; DS_U8 LockStatus; DHL_RESULT dhlResult = DHL_OK; float SNR; if ( (Tuner >= TUNER_MAX) || (Tuner <= TUNER_UNKNOWN) ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Selected Tuner is %d\n", Tuner ); return DHL_FAIL; } /* Argument Checking */ if ( pSNR == (float *)0 ) { return DHL_FAIL; } /* Take the MUTEX */ /* Tuner State Checking */ pDSTFETuner = &sDSTFE_Tuner[Tuner-1]; if ( (pDSTFETuner->bCurState <= TUNERSTATE_UNKNOWN) || (pDSTFETuner->bCurState >= TUNERSTATE_MAX) ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Tuner State is Invalid, %d\n", pDSTFETuner->bCurState ); dhlResult = DHL_FAIL; goto done; } dhlResult = DD_FE_GetLockStatus( pDSTFETuner, &LockStatus ); if ( dhlResult != DHL_OK ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error: DD_FE_GetLockStatus()\n" ); dhlResult = DHL_FAIL; goto done; } #if 0 /* hwatk/041109, lock이 안되어도 snr 검사를 할 수 있어야 함.. */ if ( LockStatus == 0 ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Tuner is not locked!\n" ); dhlResult = DHL_FAIL; goto done; } #endif /* Call the lower device driver */ dhlResult = DD_FE_GetSNR( pDSTFETuner, &SNR ); if ( dhlResult != DHL_OK ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error: DD_FE_GetSNR()\n" ); dhlResult = DHL_FAIL; goto done; } *pSNR = SNR; done: /* Give the MUTEX */ return dhlResult; } /**************************************************************************** DHL_RESULT DHL_FE_GetTrellisSNR - Summary : Get the Trellis Decoder Output SNR. - Arguments TunerType { TUNER_FAT, TUNER_FDC } pTrellisSNR : Trellis SNR loaded into. - Returns : DHL_OK on success, DHL_FAIL on failure. - Note . Valid only if the tuner is FAT. ??? . Valid only if the tuner is locked. ***************************************************************************/ DHL_RESULT DHL_FE_GetTrellisSNR( TunerType Tuner, double *pTrellisSNR ) { P_DST_FE pDSTFETuner = (P_DST_FE)0; DS_U8 LockStatus; DHL_RESULT dhlResult = DHL_OK; double TrellisSNR; if ( Tuner != TUNER_FAT ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error: This function is excuted only if TUNER_FAT, Tuner = %d\n", Tuner ); return DHL_FAIL; } /* Argument Checking */ if ( pTrellisSNR == (double *)0 ) { return DHL_FAIL; } /* Take the MUTEX */ /* Tuner State Checking */ pDSTFETuner = &sDSTFE_Tuner[Tuner-1]; if ( (pDSTFETuner->bCurState <= TUNERSTATE_UNKNOWN) || (pDSTFETuner->bCurState >= TUNERSTATE_MAX) ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Tuner State is Invalid, %d\n", pDSTFETuner->bCurState ); dhlResult = DHL_FAIL; goto done; } dhlResult = DD_FE_GetLockStatus( pDSTFETuner, &LockStatus ); if ( dhlResult != DHL_OK ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error: DD_FE_GetLockStatus()\n" ); dhlResult = DHL_FAIL; goto done; } if ( LockStatus == 0 ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Tuner is not locked!\n" ); dhlResult = DHL_FAIL; goto done; } dhlResult = DD_FE_GetTrellisSNR( pDSTFETuner, &TrellisSNR ); if ( dhlResult != DHL_OK ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error: DD_FE_GetTrellisSNR()\n" ); dhlResult = DHL_FAIL; goto done; } pDSTFETuner->dTrellisSNR = TrellisSNR; *pTrellisSNR = TrellisSNR; done: /* Give the MUTEX */ return dhlResult; } /**************************************************************************** DHL_RESULT DHL_FE_GetSignalStrength - Summary : Get the SQI (Signal Quality Indicator) from the Tuner. - Arguments TunerType { TUNER_FAT, TUNER_FDC } pSQI : SQI loaded into - Returns : DHL_OK on success, DHL_FAIL on failure - Note . Can be get the signal strength on both locked and unlocked. - Locked : From Equalizer SNR. - Unlocked : From Current AGC Value. ***************************************************************************/ DHL_RESULT DHL_FE_GetSignalStrength( TunerType Tuner, DS_U32 *pSQI ) { P_DST_FE pDSTFETuner = (P_DST_FE)0; DHL_RESULT dhlResult = DHL_OK; DS_U32 SQI; /* Argument checking */ if ( pSQI == (DS_U32 *)0 ) { return DHL_FAIL; } /* Take the MUTEX */ /* Tuner State Checking */ pDSTFETuner = &sDSTFE_Tuner[Tuner-1]; if ( (pDSTFETuner->bCurState <= TUNERSTATE_UNKNOWN) || (pDSTFETuner->bCurState >= TUNERSTATE_MAX) ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Tuner State is Invalid, %d\n", pDSTFETuner->bCurState ); dhlResult = DHL_FAIL; goto done; } dhlResult = DD_FE_GetSignalStrength( pDSTFETuner, &SQI ); if ( dhlResult != DHL_OK ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error: DD_FE_GetSignalStrength()\n" ); goto done; } pDSTFETuner->uSQI = SQI; *pSQI = SQI; if ( g_force_ss == 1 ) { *pSQI = 100; } done: /* Give the MUTEX */ return dhlResult; } DHL_RESULT DHL_FE_GetSignalPower( TunerType Tuner, DS_U32 *pSQI ) { P_DST_FE pDSTFETuner = (P_DST_FE)0; DHL_RESULT dhlResult = DHL_OK; DS_U32 SQI; /* Argument checking */ if ( pSQI == (DS_U32 *)0 ) { return DHL_FAIL; } /* Take the MUTEX */ /* Tuner State Checking */ pDSTFETuner = &sDSTFE_Tuner[Tuner-1]; if ( (pDSTFETuner->bCurState <= TUNERSTATE_UNKNOWN) || (pDSTFETuner->bCurState >= TUNERSTATE_MAX) ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Tuner State is Invalid, %d\n", pDSTFETuner->bCurState ); dhlResult = DHL_FAIL; goto done; } dhlResult = DD_FE_GetSignalPower( pDSTFETuner, &SQI ); if ( dhlResult != DHL_OK ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error: DD_FE_GetSignalStrength()\n" ); goto done; } *pSQI = SQI; if ( g_force_ss == 1 ) { *pSQI= 100; } done: /* Give the MUTEX */ return dhlResult; } /**************************************************************************** DHL_RESULT DHL_FE_GetEqSNR - Summary : Calculate the demodulator (Equalizer) SNR from SQI. - Arguments TunerType { TUNER_FAT, TUNER_FDC } pSNR : SNR loaded into. - Returns : DHL_OK on success, DHL_FAIL on failure - Note . Valid only if the tuner is locked. ***************************************************************************/ DHL_RESULT DHL_FE_GetEqSNR( TunerType Tuner, float *pSNR ) { return DHL_FE_GetSNR( Tuner, pSNR ); } DS_U32 DHL_FE_GetFrequency( TunerType Tuner ) { P_DST_FE pDSTFETuner = (P_DST_FE)0; pDSTFETuner = &sDSTFE_Tuner[Tuner-1]; return DD_FE_GetFrequency(pDSTFETuner); } /**************************************************************************** DHL_RESULT DHL_FE_GetRSError - Summary Get the Reed-Solomon Decoder Error Count and calculate error count per unit second. - Arguments TunerType { TUNER_FAT, TUNER_FDC } pRSErrorCnt : RS Decoder Error Count loaded into. pRSErrorRate : RS Decoder Error Rate loaded into. - Returns : DHL_OK on success, DHL_FAIL on failure. - Note . Valid only if the tuner is FAT. ***************************************************************************/ DHL_RESULT DHL_FE_GetRSError( TunerType Tuner, DS_U32 *pRSErrorCnt, float *pRSErrorRate ) { P_DST_FE pDSTFETuner = (P_DST_FE)0; DS_U8 LockStatus; DHL_RESULT dhlResult; DS_U32 RSErrorCnt; float RSErrorRate; if ( Tuner != TUNER_FAT ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error: This function is valid only if TUNER_FAT, Tuner = %d\n", Tuner ); return DHL_FAIL; } if ( (pRSErrorCnt == (DS_U32 *)0) || (pRSErrorRate == (float *)0) ) { return DHL_FAIL; } /* Take the MUTEX */ /* Tuner State Checking */ pDSTFETuner = &sDSTFE_Tuner[Tuner-1]; if ( (pDSTFETuner->bCurState <= TUNERSTATE_UNKNOWN) || (pDSTFETuner->bCurState >= TUNERSTATE_MAX) ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Tuner State is Invalid, %d\n", pDSTFETuner->bCurState ); dhlResult = DHL_FAIL; goto done; } /* Put invalid on DST_FE information */ pDSTFETuner->uRSErrorCnt = -1; pDSTFETuner->fRSErrorRate = -1.0f; /* Call the lower device driver */ dhlResult = DD_FE_GetLockStatus( pDSTFETuner, &LockStatus ); if ( dhlResult != DHL_OK ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error: DD_FE_GetLockStatus()\n" ); goto done; } if ( LockStatus == 0 ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Tuner is not locked!\n" ); dhlResult = DHL_FAIL; goto done; } /* Call the lower device driver */ dhlResult = DD_FE_GetRSError( pDSTFETuner, &RSErrorCnt, &RSErrorRate ); if ( dhlResult != DHL_OK ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error: DD_FE_GetRSError()\n" ); dhlResult = DHL_FAIL; goto done; } pDSTFETuner->uRSErrorCnt = RSErrorCnt; *pRSErrorCnt = RSErrorCnt; pDSTFETuner->fRSErrorRate = RSErrorRate; *pRSErrorRate = RSErrorRate; done: /* Give the MUTEX */ return dhlResult; } /**************************************************************************** DHL_RESULT DHL_FE_BERTStart - Summary : - Arguments TunerType { TUNER_FAT, TUNER_FDC } HdrRm - Header Remove Bytes { FEBERT_RM_0, FEBERT_RM_1, FEBERT_RM_3, FEBERT_RM_4 } Source - Source Selection { FEBERT_INPUT_FAT, FEBERT_INPUT_DI, FEBERT_INPUT_FDC, FEBERT_INPUT_TRELLIS } PNInv - PN Inversion { FEBERT_INVERTED, FEBERT_NON_INVERTED } PNSeq - PN Sequence { FEBERT_PN_15, FEBERT_PN_23 } - Returns : DHL_OK on success, DHL_FAIL on failure - Note ***************************************************************************/ DHL_RESULT DHL_FE_BERTStart( TunerType Tuner, FEBertRm HdrRm, FEBertSource Source, FEBertPNInv PNInv, FEBertPNSeq PNSeq) { DHL_RESULT dhlResult; P_DST_FE pDSTFETuner; /* Tuner Id. Checking */ if ( Tuner >= TUNER_MAX || Tuner <= TUNER_UNKNOWN ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error : Tuner is unknown!\n" ); return DHL_FAIL; } pDSTFETuner = &sDSTFE_Tuner[Tuner-1]; /* Is BERT started ? */ if ( pDSTFETuner->bBERTStarted == _TRUE_ ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error: BERT is already started.\n" ); return DHL_FAIL; } /* Take the MUTEX */ /* Tuner State Checking */ if ( pDSTFETuner->bCurState != TUNERSTATE_START ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Tuner State is NOT TUNERSTATE_START, %d\n", pDSTFETuner->bCurState ); dhlResult = DHL_FAIL; goto done; } /* Call the lower device driver */ dhlResult = DD_FE_BERTStart( pDSTFETuner, HdrRm, Source, PNInv, PNSeq ); if ( dhlResult != DHL_OK ) goto done; pDSTFETuner->bBERTStarted = _TRUE_; done: /* Give the MUTEX */ return dhlResult; } /**************************************************************************** DHL_RESULT DHL_FE_BERTStop - Summary : - Arguments TunerType { TUNER_FAT, TUNER_FDC } - Returns : DHL_OK on success, DHL_FAIL on failure - Note ***************************************************************************/ DHL_RESULT DHL_FE_BERTStop( TunerType Tuner ) { DHL_RESULT dhlResult; P_DST_FE pDSTFETuner; /* Tuner Id. Checking */ if ( Tuner >= TUNER_MAX || Tuner <= TUNER_UNKNOWN ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error : Tuner is unknown!\n" ); return DHL_FAIL; } pDSTFETuner = &sDSTFE_Tuner[Tuner-1]; /* Is BERT started ? */ if ( pDSTFETuner->bBERTStarted == _FALSE_ ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error: BERT is already started.\n" ); return DHL_FAIL; } /* Take the MUTEX */ /* Tuner State Checking */ if ( pDSTFETuner->bCurState != TUNERSTATE_START ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Tuner State is NOT TUNERSTATE_START, %d\n", pDSTFETuner->bCurState ); dhlResult = DHL_FAIL; goto done; } /* Call the lower device driver */ dhlResult = DD_FE_BERTStop( pDSTFETuner ); if ( dhlResult != DHL_OK ) goto done; pDSTFETuner->bBERTStarted = _TRUE_; done: /* Give the MUTEX */ return dhlResult; } /**************************************************************************** DHL_RESULT DHL_FE_GetBERT - Summary : - Arguments TunerType { TUNER_FAT, TUNER_FDC } - Returns : DHL_OK on success, DHL_FAIL on failure - Note ***************************************************************************/ DHL_RESULT DHL_FE_GetBERT( TunerType Tuner, DS_U32 *pErrorCnt, float *pErrorRate ) { DHL_RESULT dhlResult = DHL_OK; P_DST_FE pDSTFETuner; /* Tuner Id. Checking */ if ( Tuner >= TUNER_MAX || Tuner <= TUNER_UNKNOWN ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error : Tuner is unknown!\n" ); return DHL_FAIL; } /* Argument Checking */ if ( (pErrorCnt == (DS_U32 *)0) || (pErrorRate == (float *)0) ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error : Arguments are invalid!,\ pErrorCnt = %lx, pErrorRate = %lx", pErrorCnt, pErrorRate ); return DHL_FAIL_NULL_POINTER; } pDSTFETuner = &sDSTFE_Tuner[Tuner-1]; /* Take the MUTEX */ /* Tuner State Checking */ if ( pDSTFETuner->bCurState != TUNERSTATE_START ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Tuner State is NOT TUNERSTATE_START, %d\n", pDSTFETuner->bCurState ); dhlResult = DHL_FAIL; goto done; } /* Put invalid on DST_FE information */ pDSTFETuner->ulBERTErrorCnt = -1; pDSTFETuner->dBERTErrorRate = -1.0f; *pErrorCnt = -1; *pErrorRate = -1.0f; /* Call the lower device driver */ dhlResult = DD_FE_GetBERT( pDSTFETuner, pErrorCnt, pErrorRate ); if ( dhlResult != DHL_OK ) goto done; pDSTFETuner->ulBERTErrorCnt = *pErrorCnt; pDSTFETuner->dBERTErrorRate = *pErrorRate; done: /* Give the MUTEX */ return dhlResult; } /**************************************************************************** DHL_RESULT DHL_FE_SetFDCConfig - Summary : FDC 관련 Data Mode 설정 - Arguments TunerType { TUNER_FAT, TUNER_FDC } RFFreq FDC Frequency SymbolRate { FDC_SYMBOL_RATE_772, FDC_SYMBOL_RATE_1024, FDC_SYMBOL_RATE_1544 } ClockPol { FDC_INVERT_SIGNAL, FDC_NO_INVERT_SIGNAL } DataPol { FDC_INVERT_SIGNAL, FDC_NO_INVERT_SIGNAL } DecoderMode { FDC_INVERT_SIGNAL, FDC_NO_INVERT_SIGNAL } - Returns : DHL_OK on success, DHL_FAIL on failure - Note ***************************************************************************/ DHL_RESULT DHL_FE_SetFDCConfig( TunerType Tuner, DS_U32 RFFreq, FdcSymbolRate_t SymbolRate, FdcSignalPolarity_t ClockPol, FdcSignalPolarity_t DataPol, FdcSignalPolarity_t DecoderMode, DS_U32 RefDivider ) { P_DST_FE pDSTFETuner; DHL_RESULT dhlResult = DHL_OK; if ( Tuner >= TUNER_MAX || Tuner <= TUNER_UNKNOWN ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Selected Tuner is %d\n", Tuner ); return DHL_FAIL; } pDSTFETuner = &sDSTFE_Tuner[Tuner-1]; /* Take the MUTEX */ /* State Checking */ if ( (pDSTFETuner->bCurState != TUNERSTATE_INIT) && (pDSTFETuner->bCurState != TUNERSTATE_STOP) ) { DHL_DbgPrintf( 0, DHLDBG_FE, " Error: Should be INIT or STOP, %d\n", pDSTFETuner->bCurState ); dhlResult = DHL_FAIL; goto done; } #if 0 /* 이 함수에서는 설정만 하고, 실제 적용은 DD_FE_SetChannelFDC()에서 하도록 함. hwatk - 2004.07.28 */ /* Call the lower device driver */ dhlResult = DD_FE_SetFDCConfig( pDSTFETuner, RFFreq, SymbolRate, ClockPol, DataPol, DecoderMode, RefDivider ); if ( dhlResult != DHL_OK ) goto done; #endif pDSTFETuner->uFrequency = RFFreq; pDSTFETuner->FdcSymbolRate = SymbolRate; pDSTFETuner->FdcClockPolarity = ClockPol; pDSTFETuner->FdcDataPolarity = DataPol; pDSTFETuner->FdcDecoderMode = DecoderMode; pDSTFETuner->RefDivider = RefDivider; done: /* Give the MUTEX */ return dhlResult; } DHL_RESULT DHL_FE_CheckAlive( TunerType Tuner ) { DHL_RESULT dhlResult = DHL_OK; P_DST_FE pDSTFETuner; pDSTFETuner = &sDSTFE_Tuner[Tuner-1]; //JFET_20050125 //Remove the Av drop at qam64 channels //Tempopary return DHL_OK; /* Take the MUTEX */ dhlResult = DD_FE_CheckAlive(pDSTFETuner); if ( dhlResult != DHL_OK ) { DHL_DbgPrintf( 0, DHLDBG_FE, " Error: line = %d, dhlResult = 0x%x\n", __LINE__, dhlResult ); } return dhlResult; } DHL_RESULT DHL_FE_SetInput( TunerType Tuner, int Cable ) { DHL_RESULT dhlResult = DHL_OK; P_DST_FE pDSTFETuner; pDSTFETuner = &sDSTFE_Tuner[Tuner-1]; dhlResult = DD_FE_SetInput( pDSTFETuner, Cable ); return dhlResult; } DHL_RESULT DHL_FE_SetGPIOC( TunerType Tuner, int mask, int value ) { DHL_RESULT dhlResult = DHL_OK; P_DST_FE pDSTFETuner; pDSTFETuner = &sDSTFE_Tuner[Tuner-1]; dhlResult = DD_FE_SetGPIOC( pDSTFETuner, mask, value ); return dhlResult; } DHL_RESULT DHL_FE_GetGPIOC( TunerType Tuner, int mask, int *value ) { DHL_RESULT dhlResult = DHL_OK; P_DST_FE pDSTFETuner; pDSTFETuner = &sDSTFE_Tuner[Tuner-1]; dhlResult = DD_FE_GetGPIOC( pDSTFETuner, mask, value ); return dhlResult; } DHL_RESULT DHL_FE_GetAudioMode( TunerType Tuner, FEAudioMode_t *audioMode, FEAudioStandard_t *audioStandard ) { DHL_RESULT dhlResult = DHL_OK; P_DST_FE pDSTFETuner; pDSTFETuner = &sDSTFE_Tuner[Tuner-1]; dhlResult = DD_FE_GetAudioMode( audioMode, audioStandard ); return dhlResult; } DHL_RESULT DHL_FE_SetAudioMode( TunerType Tuner, FEAudioMode_t audioMode, FEAudioStandard_t audioStandard ) { DHL_RESULT dhlResult = DHL_OK; P_DST_FE pDSTFETuner; pDSTFETuner = &sDSTFE_Tuner[Tuner-1]; /* * Just before Audio Mode Change, have to do audio mute. * (or equivalent function such as Fade Out). */ if ( DHL_AUD_IsMainMuted() == _FALSE_ ) { DD_AUD_VolumeFadeInOut_I2S(0); if (g_PreAudioModeDelay) OS_mDelay(g_PreAudioModeDelay); } if ( DHL_IsVideoSourceATV(DHL_CAP_GetVideoSrc(0)) == 0 ) { DHL_DbgPrintf( 0, DHLDBG_FE, " Error: line = %d, Current Mode is Not ATV mode", __LINE__); dhlResult = DHL_FAIL; goto done; } dhlResult = DD_FE_SetAudioMode( audioMode, audioStandard ); SysASSERT( dhlResult == DHL_OK ); /* * Just after Audio Mode Change, have to release audio mute. * (or equivalent function such as Fade In). */ if ( DHL_AUD_IsMainMuted() == _FALSE_ ) { if (g_AftAudioModeDelay) OS_mDelay(g_AftAudioModeDelay); DD_AUD_VolumeFadeInOut_I2S(1); } done: return dhlResult; } DHL_RESULT DHL_FE_SetCarrierMute( TunerType Tuner, DS_BOOL bEn ) { DHL_RESULT dhlResult = DHL_OK; P_DST_FE pDSTFETuner; pDSTFETuner = &sDSTFE_Tuner[Tuner-1]; pDSTFETuner->bCarrierMute = bEn; return dhlResult; } DHL_RESULT DHL_FE_SetFrequency( TunerType Tuner, DS_U32 Frequency, TunerDemod Demod ) { DHL_RESULT dhlResult = DHL_OK; P_DST_FE pDSTFETuner; pDSTFETuner = &sDSTFE_Tuner[Tuner-1]; dhlResult = DD_FE_SetFrequency( pDSTFETuner, Frequency, Demod, 1 ); pDSTFETuner->bCurDemod = Demod; // // Digital Callback을 사용하지 않는 경우, (하위 FE Driver가 지원하는 경우) // NTSC Callback Function만을 사용하도록 함. // #if USE_NTSCCALLBACK if ( pDSTFETuner->bCurDemod == DEMOD_NTSC ) { if ( pDSTFETuner->fnFECallbackNTSC[FECALLBACK_ACQSTART-1] ) (pDSTFETuner->fnFECallbackNTSC[FECALLBACK_ACQSTART-1])(pDSTFETuner->bTuner, FECALLBACK_ACQSTART, pDSTFETuner->FECallbackNTSCUserArg[FECALLBACK_ACQSTART-1]); if ( g_fe_debug ) { DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "[FAT] %s Acqusition start.\n", Demod == DEMOD_8VSB ? "8VSB" : Demod == DEMOD_64QAM ? "64QAM" : Demod == DEMOD_256QAM ? "256QAM" : Demod == DEMOD_QAM ? "QAM" : Demod == DEMOD_NTSC ? "NTSC" : Demod == DEMOD_ISDBT ? "ISDB-T" : Demod == DEMOD_ISDBT_MANUAL ? "ISDB-T Manual" : Demod == DEMOD_MODEA ? "MODEA" : Demod == DEMOD_MODEB ? "MODEB" : "Unknown"); } } #endif #if USE_DIGITAL_CALLBACK if ( pDSTFETuner->bCurDemod != DEMOD_NTSC ) { if ( pDSTFETuner->fnFECallback[FECALLBACK_ACQSTART-1] ) (pDSTFETuner->fnFECallback[FECALLBACK_ACQSTART-1])(pDSTFETuner->bTuner, FECALLBACK_ACQSTART, pDSTFETuner->FECallbackUserArg[FECALLBACK_ACQSTART-1]); if ( g_fe_debug ) { DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "[FAT] %s Acqusition start.\n", Demod == DEMOD_8VSB ? "8VSB" : Demod == DEMOD_64QAM ? "64QAM" : Demod == DEMOD_256QAM ? "256QAM" : Demod == DEMOD_QAM ? "QAM" : Demod == DEMOD_NTSC ? "NTSC" : Demod == DEMOD_ISDBT ? "ISDB-T" : Demod == DEMOD_ISDBT_MANUAL ? "ISDB-T Manual" : Demod == DEMOD_MODEA ? "MODEA" : Demod == DEMOD_MODEB ? "MODEB" : "Unknown"); } } #endif // // Monitor Thread Activate는 Callback Function 호출 이후에... // if ( Tuner == TUNER_FAT ) { pDSTFETuner->NotifyState = FE_WAIT_FOR_LOCK; pDSTFETuner->bThreadActive = _TRUE_; } return dhlResult; } #if 0 ___Analog_Tune_Functions___() #endif /**************************************************************************** Analog (NTSC) Search/Tune Function DHL_FE_AnalogFullSearch() Full Search 함수 / TDA9885 기반 DHL_FE_AnalogShortSearch() Short Search 함수 / TDA9885 기반 DHL_FE_FullSearchEx() Full Search 함수 / ORION 기반 Sanyo Tuner 알고리즘. 1. 450 kHz 단위로, 0인 지점을 검색. 2. 100 kHz 단위로 감소시키며, Edge 지점을 찾음. 3. 50 khz 단위로 증가시키며, 최적 주파수를 찾음. ****************************************************************************/ typedef union{ struct{ #if 0 unsigned PONR :1; signed AFC :4; // AFC4, AFC3, AFC2, AFC1 unsigned FMIFL :1; unsigned VIFL :1; unsigned AFCWIN :1; #else unsigned AFCWIN :1; unsigned VIFL :1; unsigned FMIFL :1; signed AFC :4; // AFC4, AFC3, AFC2, AFC1 unsigned PONR :1; #endif } Part; // 구조체 맴버 접근 DS_U8 Byte; // 바이트 접근 }UTda9885ReadReg; #define SEARCH_FREQ_STEP_SANYO 125 // 500 kHz #define SEARCH_FREQ_FINE_STEP1 125 // 125 kHz #define SEARCH_FREQ_FINE_STEP2 62.50 // 62.50 kHz /***************************************************************************** AnalogCheckChannelStart() AnalogCheckChannel() AnalogOneChannelSearch() AnalogSearchEnd() - Summary: TDA9885 기반의 NTSC Signal 여부 검사 함수. ****************************************************************************/ int AnalogIsSignal(DS_U8 afc_status) { #if NIMTN_TYPE==NIMTN_U7A06 || NIMTN_TYPE==NIMTN_U7A26 #if 0 DS_U8 lockStatus = 0; OS_mDelay(100); DHL_FE_AnalogGetLockStatus( TUNER_FAT, &lockStatus ); if (lockStatus) return afc_status <= 2; else return 0; #else return afc_status <= 2; #endif #else return afc_status != 7 && afc_status != 8; #endif } static char AnalogCheckChannelStart( TunerType Tuner, float freq, DS_BOOL (*fnCancelCk1)(), DS_BOOL (*fnCancelCk2)() ) { P_DST_FE pDSTFETuner; DHL_RESULT dhlResult = DHL_OK; DS_U8 afc_status = 0xFF; #if NIMTN_TYPE==NIMTN_TDQU || NIMTN_TYPE==NIMTN_U7A06 || NIMTN_TYPE==NIMTN_U7A26 DS_U8 tdaData; #elif NIMTN_TYPE==NIMTN_TDQU UTda9885ReadReg tdaData; #endif // int retry = 0; pDSTFETuner = &sDSTFE_Tuner[Tuner-1]; dhlResult = DD_FE_SetFrequency( pDSTFETuner, (DS_U32)(freq * 1000), DEMOD_NTSC, 1 ); if ( dhlResult != DHL_OK ) { DHL_DbgPrintf( 0, DHLDBG_FE, "ERROR: line = %d\n", __LINE__); goto done; } MDELAY(200); // // 처음 튜닝 후 200 mSec 기다림. (100msec --> 200msec / 2007.04.06 hwatk) // --> 채널이 BAND간에 변경된 경우, TDA9885 Status 변경에 시간이 걸림. // #if NIMTN_TYPE==NIMTN_TDQU dhlResult = DD_FE_GetTdquReg( pDSTFETuner, (DS_U8 *)&tdaData ); if ( dhlResult != DHL_OK ) DHL_DbgPrintf( 0, DHLDBG_FE, "ERROR: line = %d\n", __LINE__); afc_status=tdaData; #elif NIMTN_TYPE==NIMTN_DTT7611 dhlResult = DD_FE_GetTDA9885Reg( pDSTFETuner, (DS_U8 *)&tdaData ); if ( dhlResult != DHL_OK ) DHL_DbgPrintf( 0, DHLDBG_FE, "ERROR: line = %d\n", __LINE__); afc_status = tdaData.Part.AFC; #elif NIMTN_TYPE==NIMTN_U7A06 do { OS_mDelay(10); dhlResult = DD_FE_GetAFCReg( pDSTFETuner, (DS_U8 *)&tdaData ); if ( dhlResult != DHL_OK ) DHL_DbgPrintf( 0, DHLDBG_FE, "ERROR: line = %d\n", __LINE__); afc_status = tdaData & 0x7; // If cancel is raised, then just return with afc_status = unlock (-8). if ( fnCancelCk1 ) { if ( fnCancelCk1() ) { afc_status = 8; goto done; } } if ( fnCancelCk2 ) { if ( fnCancelCk2() ) { afc_status = 8; goto done; } } } while( !(tdaData & 0x40) ); #elif NIMTN_TYPE==NIMTN_U7A26 do { OS_mDelay(10); dhlResult = DD_FE_GetAFCReg( pDSTFETuner, (DS_U8 *)&tdaData ); if ( dhlResult != DHL_OK ) DHL_DbgPrintf( 0, DHLDBG_FE, "ERROR: line = %d\n", __LINE__); afc_status = tdaData & 0x7; // If cancel is raised, then just return with afc_status = unlock (-8). if ( fnCancelCk1 ) { if ( fnCancelCk1() ) { afc_status = 8; goto done; } } if ( fnCancelCk2 ) { if ( fnCancelCk2() ) { afc_status = 8; goto done; } } } while( !(tdaData & 0x40) ); #endif done: return afc_status; } static char AnalogCheckChannel( TunerType Tuner, float freq, DS_BOOL (*fnCancelCk1)(), DS_BOOL (*fnCancelCk2)() ) { P_DST_FE pDSTFETuner; DHL_RESULT dhlResult = DHL_OK; char afc_status; #if NIMTN_TYPE==NIMTN_TDQU || NIMTN_TYPE==NIMTN_U7A06 || NIMTN_TYPE==NIMTN_U7A26 char tdaData; #elif NIMTN_TYPE==NIMTN_DTT7611 UTda9885ReadReg tdaData; #endif int retry = 0; pDSTFETuner = &sDSTFE_Tuner[Tuner-1]; dhlResult = DD_FE_SetFrequency( pDSTFETuner, (DS_U32)(freq * 1000), DEMOD_NTSC, 0 ); if ( dhlResult != DHL_OK ) DHL_DbgPrintf( 0, DHLDBG_FE, "ERROR: line = %d\n", __LINE__); #if NIMTN_TYPE==NIMTN_TDQU dhlResult = DD_FE_GetTdquReg( pDSTFETuner, (DS_U8*)&tdaData ); if ( dhlResult != DHL_OK ) DHL_DbgPrintf( 0, DHLDBG_FE, "ERROR: line = %d\n", __LINE__); afc_status =(char) tdaData; DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "++++Tdqu AFT==0x%x\n",afc_status); #elif NIMTN_TYPE==NIMTN_DTT7611 dhlResult = DD_FE_GetTDA9885Reg( pDSTFETuner, (DS_U8 *)&tdaData ); if ( dhlResult != DHL_OK ) DHL_DbgPrintf( 0, DHLDBG_FE, "ERROR: line = %d\n", __LINE__); afc_status = tdaData.Part.AFC; #elif NIMTN_TYPE==NIMTN_U7A06 retry = 0; do { OS_mDelay(10); dhlResult = DD_FE_GetAFCReg( pDSTFETuner, (DS_U8 *)&tdaData ); if ( dhlResult != DHL_OK ) DHL_DbgPrintf( 0, DHLDBG_FE, "ERROR: line = %d\n", __LINE__); afc_status = tdaData & 0x7; // If cancel is raised, then just return with afc_status = unlock (-8). if ( fnCancelCk1 ) { if ( fnCancelCk1() ) { afc_status = 8; goto done; } } if ( fnCancelCk2 ) { if ( fnCancelCk2() ) { afc_status = 8; goto done; } } } while( !(tdaData & 0x40) && retry++ < 10 ); #elif NIMTN_TYPE==NIMTN_U7A26 retry = 0; do { OS_mDelay(10); dhlResult = DD_FE_GetAFCReg( pDSTFETuner, (DS_U8 *)&tdaData ); if ( dhlResult != DHL_OK ) DHL_DbgPrintf( 0, DHLDBG_FE, "ERROR: line = %d\n", __LINE__); afc_status = tdaData & 0x7; // If cancel is raised, then just return with afc_status = unlock (-8). if ( fnCancelCk1 ) { if ( fnCancelCk1() ) { afc_status = 8; goto done; } } if ( fnCancelCk2 ) { if ( fnCancelCk2() ) { afc_status = 8; goto done; } } } while( !(tdaData & 0x40) && retry++ < 10 ); #else afc_status = 0xFF; #endif done: return afc_status; } static int AnalogOneChannelSearchConfirm( TunerType Tuner, float *try_freq, float start_freq, float end_freq, DS_U8 afc_status, DS_BOOL (*fnCancelCk1)(), DS_BOOL (*fnCancelCk2)() ) { int bFound = 0; if (afc_status <=2 ) { for(*try_freq=*try_freq-SEARCH_FREQ_FINE_STEP1; *try_freq>=start_freq; *try_freq-=SEARCH_FREQ_FINE_STEP1) { afc_status=AnalogCheckChannel(Tuner, *try_freq, fnCancelCk1, fnCancelCk2); fprintf(stderr,"|%s|%d %d\n",__FUNCTION__,__LINE__,(int)*try_freq); if (afc_status > 3) { bFound = 1; break; } } if (bFound) { for(*try_freq=*try_freq+SEARCH_FREQ_FINE_STEP2; *try_freq<=end_freq; *try_freq+=SEARCH_FREQ_FINE_STEP2) { afc_status=AnalogCheckChannel(Tuner, *try_freq, fnCancelCk1, fnCancelCk2); if (afc_status < 3) { // *try_freq -= SEARCH_FREQ_FINE_STEP2*3; // AnalogCheckChannel(Tuner,*try_freq); bFound = 1; break; } } } } return bFound; } static char AnalogOneChannelSearch_Sanyo( TunerType Tuner, float start_freq, float end_freq, float step_freq, float *tune_freq, DS_BOOL (*fnCancelCk1)(), DS_BOOL (*fnCancelCk2)() ) { P_DST_FE pDSTFETuner; char afc_status; float freq; DS_U8 lockStatus; volatile DS_U32 startTick; int bFound = 0; pDSTFETuner = &sDSTFE_Tuner[Tuner-1]; /* 우선 Center Frequency + 250 kHz로 찾음. */ freq = (start_freq+end_freq)/2; freq += SEARCH_FREQ_FINE_STEP1*3; afc_status = AnalogCheckChannelStart(TUNER_FAT, freq, fnCancelCk1, fnCancelCk2); if( afc_status==0 ) { // MDELAY 200 startTick = OS_GetTickCount(); do { MDELAY(10); // If cancel is raised, then just return with afc_status = unlock (-8). if ( fnCancelCk1 ) { if ( fnCancelCk1() ) { afc_status = 8; goto done; } } if ( fnCancelCk2 ) { if ( fnCancelCk2() ) { afc_status = 8; goto done; } } } while ( (OS_GetTickCount()-startTick) < 20 ); startTick = OS_GetTickCount(); do { lockStatus = 0; // Cortez에서 에러를 반환하는 경우, 재시도하도록 0으로 설정. DHL_FE_AnalogGetLockStatus( Tuner, &lockStatus ); if ( lockStatus ) goto done; // If cancel is raised, then just return with afc_status = unlock (-8). if ( fnCancelCk1 ) { if ( fnCancelCk1() ) { afc_status = 8; goto done; } } if ( fnCancelCk2 ) { if ( fnCancelCk2() ) { afc_status = 8; goto done; } } MDELAY(50); } while( (OS_GetTickCount()-startTick) < (g_AnalogSearchDelay/10) ); printf("|%s:%d| UNLOCK!\n", __FUNCTION__, __LINE__); } #if 0 else{ goto done; } #endif /* 못 찾았으면, start_freq ~ end_freq로 찾기 시작하자. */ for(freq=start_freq; freq<=end_freq; freq+=step_freq) { afc_status=AnalogCheckChannel(Tuner, freq, fnCancelCk1, fnCancelCk2); if(afc_status<=0)//&& H_Sync_Status==1) { // MDELAY 200 startTick = OS_GetTickCount(); do { MDELAY(10); // If cancel is raised, then just return with afc_status = unlock (-8). if ( fnCancelCk1 ) { if ( fnCancelCk1() ) { afc_status = 8; goto done; } } if ( fnCancelCk2 ) { if ( fnCancelCk2() ) { afc_status = 8; goto done; } } } while ( (OS_GetTickCount()-startTick) < 20 ); startTick = OS_GetTickCount(); do { lockStatus = 0; // Cortez에서 에러를 반환하는 경우, 재시도하도록 0으로 설정. DHL_FE_AnalogGetLockStatus( Tuner, &lockStatus ); if ( lockStatus ) goto done; // If cancel is raised, then just return with afc_status = unlock (-8). if ( fnCancelCk1 ) { if ( fnCancelCk1() ) { afc_status = 8; goto done; } } if ( fnCancelCk2 ) { if ( fnCancelCk2() ) { afc_status = 8; goto done; } } MDELAY(50); } while( (OS_GetTickCount()-startTick) < (g_AnalogSearchDelay/10) ); printf("|%s:%d| UNLOCK!\n", __FUNCTION__, __LINE__); } } done: //static int AnalogOneChannelSearchConfirm( TunerType Tuner, float try_freq, float start_freq, float end_freq, DS_U8 afc_status ) if (lockStatus && afc_status <=0){ bFound = AnalogOneChannelSearchConfirm( Tuner, &freq, start_freq, end_freq, afc_status, fnCancelCk1, fnCancelCk2 ); } if (bFound) *tune_freq = freq; else *tune_freq = -1; return afc_status; } #if NIMTN_TYPE==NIMTN_TDQU static char AnalogOneCenterSearch( TunerType Tuner, float start_freq, float end_freq, float step_freq, float *tune_freq, DS_BOOL (*fnCancelCk1)(), DS_BOOL (*fnCancelCk2)()) { P_DST_FE pDSTFETuner; char afc_status = 0; DS_U8 lockStatus = 0; float saved_freq = 0; int state_cnt = 0; char status = 0; float freq; pDSTFETuner = &sDSTFE_Tuner[Tuner-1]; /* 우선 Center Frequency로 찾음. */ freq = (start_freq+end_freq)/2 + 400; // afc_status = AnalogCheckChannelStart( TUNER_FAT, freq, fnCancelCk1, fnCancelCk2); if(afc_status == 0){ // if correct frequency exist near center frequency for(freq=(start_freq+end_freq)/2 + 400;freq>=start_freq;freq-=step_freq){ afc_status=AnalogCheckChannel(Tuner, freq, fnCancelCk1, fnCancelCk2); if(status == 0){ if(afc_status >= 2){ state_cnt++; saved_freq = freq; status = 1; } }else if(status == 1){ if(afc_status == 3){ state_cnt++; saved_freq = freq; }else { status = 2; DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "***check the frequency****\n"); afc_status=AnalogCheckChannelStart(Tuner, saved_freq, fnCancelCk1, fnCancelCk2); DHL_FE_AnalogGetLockStatus( Tuner, &lockStatus ); if ( lockStatus ) { DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "****Analog Locked ****\n"); status = 2; afc_status = 3; *tune_freq = saved_freq; return afc_status; }else{ DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "****Faked Lock Status****\n"); status = 0; state_cnt = 0; saved_freq = 0; afc_status = 0; *tune_freq = saved_freq; return afc_status; } } } } }else { afc_status = 0; saved_freq = 0; } if(saved_freq){ *tune_freq = saved_freq; }else{ *tune_freq = freq; } return afc_status; } static char AnalogOneChannelSearchX( TunerType Tuner, float start_freq, float end_freq, float step_freq, float *tune_freq, DS_BOOL (*fnCancelCk1)(), DS_BOOL (*fnCancelCk2)()) { P_DST_FE pDSTFETuner; char afc_status = 0; float saved_freq = 0; int state_cnt = 0; DS_U8 lockStatus = 0; char status = 0; char bottom = 0; float freq; char first = 0; pDSTFETuner = &sDSTFE_Tuner[Tuner-1]; /* 우선 Center Frequency로 찾음. */ for(freq=start_freq; freq<=end_freq; freq+=step_freq) { if(!first){ afc_status=AnalogCheckChannelStart(Tuner, freq, fnCancelCk1, fnCancelCk2); first = 1; }else{ afc_status=AnalogCheckChannel(Tuner,freq, fnCancelCk1, fnCancelCk2); } if(status == 0){ if(afc_status <= 3){ state_cnt++; saved_freq = freq; DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "1"); status = 1; } }else if(status == 1){ if(afc_status == 2 || afc_status == 1){ bottom = 1; } if(afc_status == 0){ afc_status=AnalogCheckChannelStart(Tuner, saved_freq, fnCancelCk1, fnCancelCk2); MDELAY(200); DHL_FE_AnalogGetLockStatus( Tuner, &lockStatus ); if ( lockStatus ) { DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "****Analog Locked ****\n"); status = 2; DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "2"); afc_status = 3; goto finish; // if(afc_status == 3 || afc_status == 4) // goto done; }else{ DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "****Faked Lock Status****\n"); status = 0; state_cnt = 0; bottom = 0; saved_freq = 0; bottom = 0; } }else if(afc_status == 4){ DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "0"); if(bottom){ DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "wrong region\n"); bottom = 0; } status = 0; state_cnt = 0; bottom = 0; saved_freq = 0; }else if(afc_status == 3){ if(bottom){ DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "wrong region\n"); saved_freq = freq; bottom = 0; } state_cnt = 1; } } } afc_status = 0; finish: DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "status count is %d\n",state_cnt); if(saved_freq){ *tune_freq = saved_freq; }else{ *tune_freq = freq; } return afc_status; } #endif static char AnalogOneChannelSearch( TunerType Tuner, float start_freq, float end_freq, float step_freq, float *tune_freq, DS_BOOL (*fnCancelCk1)(), DS_BOOL (*fnCancelCk2)() ) { P_DST_FE pDSTFETuner; char afc_status; float freq; DS_U8 lockStatus; volatile DS_U32 startTick; pDSTFETuner = &sDSTFE_Tuner[Tuner-1]; /* 우선 Center Frequency로 찾음. */ freq = (start_freq+end_freq)/2; afc_status = AnalogCheckChannelStart(TUNER_FAT, freq, fnCancelCk1, fnCancelCk2); printf("|%s:%d| afc_status=%d\n", __FUNCTION__, __LINE__, afc_status); /* 찾았으면 나가자. */ #if NIMTN_TYPE==NIMTN_TDQU DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "*****AnalogOneChannelSearch******afc_status=%d\n",afc_status); //if(afc_status != 0 && afc_status != 4 )//&& H_Sync_Status==1) if(afc_status !=5)//afc_status: error { lockStatus = 1; DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "****Analog Locked Directly****\n"); lockStatus = 1; MDELAY(300); DHL_FE_AnalogGetLockStatus( Tuner, &lockStatus ); if ( lockStatus ) { DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "****Analog Locked by Directly****\n"); // if(afc_status == 3 || afc_status == 4) // goto done; } } #elif (NIMTN_TYPE==NIMTN_DTT7611) if(AnalogIsSignal(afc_status)) { // MDELAY 200 startTick = OS_GetTickCount(); do { MDELAY(10); // If cancel is raised, then just return with afc_status = unlock (-8). if ( fnCancelCk1 ) { if ( fnCancelCk1() ) { afc_status = -8; goto done; } } if ( fnCancelCk2 ) { if ( fnCancelCk2() ) { afc_status = -8; goto done; } } } while ( (OS_GetTickCount()-startTick) < 20 ); startTick = OS_GetTickCount(); do { lockStatus = 0; // Cortez에서 에러를 반환하는 경우, 재시도하도록 0으로 설정. DHL_FE_AnalogGetLockStatus( Tuner, &lockStatus ); if ( lockStatus ) goto done; // If cancel is raised, then just return with afc_status = unlock (-8). if ( fnCancelCk1 ) { if ( fnCancelCk1() ) { afc_status = -8; goto done; } } if ( fnCancelCk2 ) { if ( fnCancelCk2() ) { afc_status = -8; goto done; } } MDELAY(50); } while( (OS_GetTickCount()-startTick) < (g_AnalogSearchDelay/10) ); printf("|%s:%d| UNLOCK!\n", __FUNCTION__, __LINE__); } #else if(afc_status==0) { // MDELAY 200 startTick = OS_GetTickCount(); do { MDELAY(10); // If cancel is raised, then just return with afc_status = unlock (-8). if ( fnCancelCk1 ) { if ( fnCancelCk1() ) { afc_status = -8; goto done; } } if ( fnCancelCk2 ) { if ( fnCancelCk2() ) { afc_status = -8; goto done; } } } while ( (OS_GetTickCount()-startTick) < 20 ); startTick = OS_GetTickCount(); do { lockStatus = 0; // Cortez에서 에러를 반환하는 경우, 재시도하도록 0으로 설정. DHL_FE_AnalogGetLockStatus( Tuner, &lockStatus ); if ( lockStatus ) goto done; // If cancel is raised, then just return with afc_status = unlock (-8). if ( fnCancelCk1 ) { if ( fnCancelCk1() ) { afc_status = -8; goto done; } } if ( fnCancelCk2 ) { if ( fnCancelCk2() ) { afc_status = -8; goto done; } } MDELAY(50); } while( (OS_GetTickCount()-startTick) < (g_AnalogSearchDelay/10) ); printf("|%s:%d| UNLOCK!\n", __FUNCTION__, __LINE__); } #endif /* 못 찾았으면, start_freq ~ end_freq로 찾기 시작하자. */ for(freq=start_freq; freq<=end_freq; freq+=step_freq) { afc_status=AnalogCheckChannel(Tuner, freq, fnCancelCk1, fnCancelCk2); #if NIMTN_TYPE==NIMTN_TDQU DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "**********Frequency Checking**********\n"); DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "*****AnalogOneChannelSearch******afc_status=%d\n",afc_status); //if(afc_status !=0 && afc_status != 4)//&& H_Sync_Status==1) if(afc_status !=5) { lockStatus = 1; DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "****Analog Locked by AFT****\n"); MDELAY(300); DHL_FE_AnalogGetLockStatus( Tuner, &lockStatus ); if ( lockStatus ) { DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "****Analog Locked by AFT****\n"); // if(afc_status == 3 || afc_status == 4) // goto done; } } #elif (NIMTN_TYPE==NIMTN_DTT7611) if(AnalogIsSignal(afc_status))//&& H_Sync_Status==1) { // MDELAY 200 startTick = OS_GetTickCount(); do { MDELAY(10); // If cancel is raised, then just return with afc_status = unlock (-8). if ( fnCancelCk1 ) { if ( fnCancelCk1() ) { afc_status = -8; goto done; } } if ( fnCancelCk2 ) { if ( fnCancelCk2() ) { afc_status = -8; goto done; } } } while ( (OS_GetTickCount()-startTick) < 20 ); startTick = OS_GetTickCount(); do { lockStatus = 0; // Cortez에서 에러를 반환하는 경우, 재시도하도록 0으로 설정. DHL_FE_AnalogGetLockStatus( Tuner, &lockStatus ); if ( lockStatus ) goto done; // If cancel is raised, then just return with afc_status = unlock (-8). if ( fnCancelCk1 ) { if ( fnCancelCk1() ) { afc_status = -8; goto done; } } if ( fnCancelCk2 ) { if ( fnCancelCk2() ) { afc_status = -8; goto done; } } MDELAY(50); } while( (OS_GetTickCount()-startTick) < (g_AnalogSearchDelay/10) ); printf("|%s:%d| UNLOCK!\n", __FUNCTION__, __LINE__); } #else if(afc_status==0)//&& H_Sync_Status==1) { // MDELAY 200 startTick = OS_GetTickCount(); do { MDELAY(10); // If cancel is raised, then just return with afc_status = unlock (-8). if ( fnCancelCk1 ) { if ( fnCancelCk1() ) { afc_status = -8; goto done; } } if ( fnCancelCk2 ) { if ( fnCancelCk2() ) { afc_status = -8; goto done; } } } while ( (OS_GetTickCount()-startTick) < 20 ); startTick = OS_GetTickCount(); do { lockStatus = 0; // Cortez에서 에러를 반환하는 경우, 재시도하도록 0으로 설정. DHL_FE_AnalogGetLockStatus( Tuner, &lockStatus ); if ( lockStatus ) goto done; // If cancel is raised, then just return with afc_status = unlock (-8). if ( fnCancelCk1 ) { if ( fnCancelCk1() ) { afc_status = -8; goto done; } } if ( fnCancelCk2 ) { if ( fnCancelCk2() ) { afc_status = -8; goto done; } } MDELAY(50); } while( (OS_GetTickCount()-startTick) < (g_AnalogSearchDelay/10) ); printf("|%s:%d| UNLOCK!\n", __FUNCTION__, __LINE__); } #endif } #if NIMTN_TYPE!=NIMTN_TDQU done: #endif *tune_freq = freq; return afc_status; } static char AnalogSearchEnd(TunerType Tuner, float freq, char afc_status, float *tune_freq) { #if NIMTN_TYPE==NIMTN_TDQU char afc = afc_status; DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "*******AnalogSearchEnd*****Afc_Freq=%d\n",afc_status); #if 0 switch(afc_status) { case 0: freq+=162.5; break; case 1: freq+=112.5; break; case 2: freq+=62.5; break; case 4: freq-=62.5; break; case 3: return afc_status; break; default : DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "Invalid afc_status = %d\n", afc_status ); return afc_status; } #endif afc_status=AnalogCheckChannel(Tuner, freq, fnCancelCk1, fnCancelCk2); *tune_freq = freq; return afc; #elif NIMTN_TYPE==NIMTN_DTT7611 switch(afc_status) { // TDA9885 - AFC Status 참조 case 6 : freq+=162.5; break; case 5 : freq+=137.5; break; case 4 : freq+=112.5; break; case 3 : freq+= 87.5; break; case 2 : freq+= 62.5; break; case -3 : freq-= 62.5; break; case -4 : freq-= 87.5; break; case -5 : freq-=112.5; break; case -6 : freq-=137.5; break; case -7 : freq-=162.5; break; case -1 : case 0 : case 1 : case -2: return afc_status; break; default : DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "Invalid afc_status = %d\n", afc_status ); return afc_status; } afc_status=AnalogCheckChannel(Tuner, freq, fnCancelCk1, fnCancelCk2); *tune_freq = freq; return afc_status; #else return afc_status; #endif } #if 0 static char AnalogSearchEnd_Sanyo(TunerType Tuner, float freq, char afc_status, float *tune_freq) { if (afc_status <= 2) { afc_status=AnalogCheckChannel(Tuner, freq, fnCancelCk1, fnCancelCk2); *tune_freq = freq; } return afc_status; } #endif // // DHL_FE_AnalogFullSearch() // // search_range = 0인 경우, 다음 Range로 설정하여 찾음. // // if AIR // +/- 2.25MHz // // if STD // Ch 5/6 +/- 3.00MHz // Others -2.25MHz ~ +2.25MHz // if HRC // Ch 5/6 - 3.00MHz ~ + 2.25MHz // Others -2.25MHz ~ +2.25MHz // if IRC // Ch 5/6 - 3.00MHz ~ + 1.75MHz // Others -2.25MHz ~ +2.25MHz // // ** Autoscan 등에서는 꼭(!) CVBS Decoder를 Active 시킨 상태에서 사용해야 함. // DHL_RESULT DHL_FE_AnalogFullSearch(TunerType Tuner, DS_U32 channel, DS_S32 *offset, TuneType bFreq, float search_range, DS_BOOL (*fnCancelCk1)(), DS_BOOL (*fnCancelCk2)() ) { DHL_RESULT dhlResult = DHL_OK; P_DST_FE pDSTFETuner; float try_freq, tune_freq, old_freq; char afc_status; float range_low, range_high; //////// analog full search 시 signal이 NTSC에서 변하지 않는 경우 SIGNAL CALLBACK을 안올려줘 노 시그날이 되는 문제때문에 추가. ///////// pDSTFETuner = &sDSTFE_Tuner[Tuner-1]; /* * Convert Channel to Frequency if bFreq == CHANNEL. */ if ( bFreq == CHANNEL ) { try_freq = ConvertChannelToFrequency( channel, pDSTFETuner->bFreqStd ); } else { try_freq = channel; } if ( search_range == 0 ) { switch( pDSTFETuner->bFreqStd ) { case FREQ_AIR: range_low = 2250; range_high = 2250; break; case FREQ_STD: if ( bFreq == CHANNEL && (channel == 5 || channel == 6) ) { range_low = 3000; range_high = 3000; } else { range_low = 2250; range_high = 2250; } break; case FREQ_IRC: if ( bFreq == CHANNEL && (channel == 5 || channel == 6) ) { range_low = 3000; range_high = 1750; } else { range_low = 2250; range_high = 2250; } break; case FREQ_HRC: if ( bFreq == CHANNEL && (channel == 5 || channel == 6) ) { range_low = 3000; range_high = 2250; } else { range_low = 2250; range_high = 2250; } break; default: DHL_DbgPrintf( 0, DHLDBG_FE, "*** Frequency standards is not initialized!\n"); return DHL_FAIL; } } else { range_low = search_range; range_high = search_range; } old_freq = try_freq; #if NIMTN_TYPE==NIMTN_TDQU afc_status=AnalogOneCenterSearch(Tuner, try_freq-range_low, try_freq+range_high, XOCECO_STEP_FREQ, &tune_freq); if(afc_status == 0){ DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "aft search start\n"); afc_status=AnalogOneChannelSearchX(Tuner, try_freq-range_low, try_freq+range_high, XOCECO_STEP_FREQ, &tune_freq); afc_status=AnalogSearchEnd(Tuner, tune_freq, afc_status, &tune_freq); } DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "tune : %lf\n old : %lf",tune_freq,old_freq); if(afc_status == 3){ *offset = (DS_S32)((tune_freq-old_freq)*1000); }else{ *offset = -1; } #elif NIMTN_TYPE==NIMTN_DTT7611 afc_status=AnalogOneChannelSearch(Tuner, try_freq-range_low, try_freq+range_high, SEARCH_STEP_FREQ, &tune_freq, fnCancelCk1, fnCancelCk2 ); afc_status=AnalogSearchEnd(Tuner, tune_freq, afc_status, &tune_freq); if( afc_status >= -3 && afc_status <= 2 )/*BK(12.15출장merge) <- afc_status < 2*/ { // 튜닝 성공 DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "tune_freq = %f, old_freq = %f\n", tune_freq, old_freq ); *offset = (DS_S32)((tune_freq-old_freq)*1000); // offset => xxxxx Hz } else { afc_status=AnalogCheckChannel(Tuner,try_freq, fnCancelCk1, fnCancelCk2); *offset = -1; } #else // +200 kHz 지점부터 찾기 시작. #if 1 tune_freq += SEARCH_FREQ_FINE_STEP1*2; afc_status=AnalogOneChannelSearch_Sanyo(Tuner, try_freq-range_low, try_freq+range_high, SEARCH_FREQ_STEP_SANYO, &tune_freq, fnCancelCk1, fnCancelCk2 ); //printf("|%s| afc_status=%d\n", __FUNCTION__, afc_status); //afc_status=AnalogSearchEnd_Sanyo(Tuner, tune_freq, afc_status, &tune_freq); if( afc_status <= 2 && tune_freq != -1 )/*BK(12.15출장merge) <- afc_status < 2*/ { // 튜닝 성공 DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "tune_freq = %f, old_freq = %f\n", tune_freq, old_freq ); *offset = (DS_S32)((tune_freq-old_freq)*1000); // offset => xxxxx Hz } else { afc_status=AnalogCheckChannel(Tuner,try_freq, fnCancelCk1, fnCancelCk2); *offset = -1; } #else DHL_FE_SetFrequency( TUNER_FAT, try_freq*1000, DEMOD_NTSC ); afc_status = 1; if(afc_status != 1){ AnalogOneChannelSearch_Sanyo(Tuner, try_freq-range_low, try_freq+range_high, SEARCH_FREQ_STEP_SANYO, &tune_freq, fnCancelCk1, fnCancelCk2 ); } tune_freq = old_freq; #endif #endif pDSTFETuner->bCurDemod = DEMOD_NTSC; pDSTFETuner->NotifyState = FE_WAIT_FOR_LOCK; pDSTFETuner->bThreadActive = _TRUE_; return dhlResult; } #if NIMTN_TYPE==NIMTN_TDQU DHL_RESULT DHL_FE_AnalogFullSearchXO(TunerType Tuner, DS_U32 channel, DS_S32 *offset, TuneType bFreq, float search_range ) { DHL_RESULT dhlResult = DHL_OK; P_DST_FE pDSTFETuner; float try_freq, tune_freq, old_freq; char afc_status; float range_low, range_high; pDSTFETuner = &sDSTFE_Tuner[Tuner-1]; /* * Convert Channel to Frequency if bFreq == CHANNEL. */ if ( bFreq == CHANNEL ) { try_freq = ConvertChannelToFrequency( channel, pDSTFETuner->bFreqStd ); } else { try_freq = channel; } if ( search_range == 0 ) { switch( pDSTFETuner->bFreqStd ) { case FREQ_AIR: range_low = 2250; range_high = 2250; break; case FREQ_STD: if ( bFreq == CHANNEL && (channel == 5 || channel == 6) ) { range_low = 3000; range_high = 3000; } else { range_low = 2250; range_high = 2250; } break; case FREQ_IRC: if ( bFreq == CHANNEL && (channel == 5 || channel == 6) ) { range_low = 3000; range_high = 1750; } else { range_low = 2250; range_high = 2250; } break; case FREQ_HRC: if ( bFreq == CHANNEL && (channel == 5 || channel == 6) ) { range_low = 3000; range_high = 2250; } else { range_low = 2250; range_high = 2250; } break; default: DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "*** Frequency standards is not initialized!\n"); return DHL_FAIL; } } else { range_low = search_range; range_high = search_range; } old_freq = try_freq; afc_status=AnalogOneChannelSearchX(Tuner, try_freq-range_low, try_freq+range_high, SEARCH_STEP_FREQ, &tune_freq); // afc_status=AnalogSearchEnd(Tuner, tune_freq, afc_status, &tune_freq); DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "tune : %lf\n old : %lf",tune_freq,old_freq); if(afc_status == 3){ *offset = (DS_S32)((tune_freq-old_freq)*1000); }else{ *offset = 0; } pDSTFETuner->bCurDemod = DEMOD_NTSC; pDSTFETuner->NotifyState = FE_WAIT_FOR_LOCK; pDSTFETuner->bThreadActive = _TRUE_; return dhlResult; } #endif DHL_RESULT DHL_FE_AnalogShortSearch(TunerType Tuner, DS_U32 channel, DS_S32 *offset, TuneType bFreq ) { DHL_RESULT dhlResult = DHL_OK; P_DST_FE pDSTFETuner; float try_freq, tune_freq, old_freq; char afc_status; pDSTFETuner = &sDSTFE_Tuner[Tuner-1]; /* * Convert Channel to Frequency if bFreq == CHANNEL. */ if ( bFreq == CHANNEL ) { try_freq = ConvertChannelToFrequency( channel, pDSTFETuner->bFreqStd ); } else { try_freq = channel; } old_freq = try_freq; afc_status=AnalogOneChannelSearch(Tuner, try_freq-SHORT_SEARCH_HALF_BOUND, try_freq+SHORT_SEARCH_HALF_BOUND, SEARCH_STEP_FREQ, &tune_freq, 0, 0); afc_status=AnalogSearchEnd(Tuner, tune_freq, afc_status, &tune_freq); if( afc_status >= -3 && afc_status <= 2 )/*BK(12.15출장merge) <- afc_status < 2*/ { // 튜닝 성공 DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "tune_freq = %f, old_freq = %f\n", tune_freq, old_freq ); *offset = (DS_S32)((tune_freq-old_freq)*1000); // offset => xxxxx Hz } else *offset = -1; pDSTFETuner->bCurDemod = DEMOD_NTSC; pDSTFETuner->NotifyState = FE_WAIT_FOR_LOCK; pDSTFETuner->bThreadActive = _TRUE_; return dhlResult; } /**************************************************************************** DHL_RESULT DHL_FE_AnalogFullSearchEx - Summary : Full search for NTSC channel. - Argument Tuner to use, TunerType { TUNER_FAT, TUNER_FDC } channel returns offset in pOffset. - Returns : DHL_OK on success, DHL_FAIL on failure. AFT Range (OMEGA Requirements) Air Channel All channel +/- 2.25MHz Cable Channel if HRC Ch 5/6 +/- 3.00MHz Others -2.25MHz ~ +3.00MHz else Ch 5/6 +/- 3.00MHz Others -3.00MHz ~ +2.25MHz AFT Sequences ORION AFT 문서 참조. E.g. PHASE1: Center에서 Low Limit까지 Lock 여부 검사. PHASE2: AFT High 검색 (검색되면 PHASE3으로) PHASE3: AFT Low 검색 (검색되면 PHASE9으로) PHASE9: AFT High 검색 (검색되면 PHASE8으로) PHASE8: AFT Low 검색 (검색되면 END) ***************************************************************************/ // // AFT Range // #define AFT_RANGE_AIR 2250000 #define AFT_RANGE_STD_LOW 3000000 #define AFT_RANGE_STD_HIGH 2250000 #define AFT_RANGE_HRC_LOW 2250000 #define AFT_RANGE_HRC_HIGH 3000000 #define AFT_RANGE_CH5_6 3000000 DHL_RESULT DHL_FE_AnalogFullSearchEx( TunerType Tuner, DS_U32 channel, DS_S32 *pOffset, TuneType bFreq, DS_S32 RangeLow, DS_S32 RangeHigh ) { DHL_RESULT dhlResult = DHL_OK; return dhlResult; } static int m_ALockMethod = 1; DHL_RESULT DHL_FE_AnalogGetLockStatus(TunerType Tuner, DS_U8 *lockStatus) { DHL_RESULT dhlResult = DHL_OK; P_DST_FE pDSTFETuner=&sDSTFE_Tuner[Tuner-1]; #if USE_ANALOGLOCKSTATUS if (m_ALockMethod) dhlResult = DD_FE_AnalogGetLockStatusEx( pDSTFETuner, lockStatus); else dhlResult = DD_FE_AnalogGetLockStatus( pDSTFETuner, lockStatus); #else pDSTFETuner = pDSTFETuner; *lockStatus = 1; //dhlResult = DHL_FAIL_NOT_IMPLEMENTED; #endif return dhlResult; } void DHL_FE_SetAnalogLockMethod(int Method) { m_ALockMethod = Method; } // // NTSC Callback을 위한 Monitor Thread // #define FE_THREAD_DELAY 40 void DHL_FE_MonitorThread(DS_U32 arg) { DHL_CAP_VIDEO_INPUT mainSrc, subSrc; P_DST_FE pDSTFETuner; DS_U8 isLocked; #if NIMTN_TYPE!=NIMTN_TDQU int w_count=0, flag=0; #endif pDSTFETuner = (P_DST_FE)arg; while( 1 ) { #if NIMTN_TYPE!=NIMTN_TDQU // // 다음은 Weak Signal 테스트 용도로 사용됨. // if ( g_test_weak_interval ) { if ( w_count++ > g_test_weak_interval ) { flag = flag == 0 ? 2 : 0; set_lock( flag ); w_count = 0; } } #endif if ( pDSTFETuner->bThreadActive == _FALSE_ ) { MDELAY(FE_THREAD_DELAY); continue; } #if !USE_DIGITAL_CALLBACK if ( pDSTFETuner->bCurDemod != DEMOD_NTSC ) { pDSTFETuner->bThreadActive = _FALSE_; pDSTFETuner->NotifyState = FE_WAIT_FOR_LOCK; MDELAY(FE_THREAD_DELAY); continue; } #endif mainSrc = DHL_CAP_GetVideoSrc(0); subSrc = DHL_CAP_GetVideoSrc(1); if ( mainSrc != DHL_CAP_ATV0_VIDEO && subSrc != DHL_CAP_ATV0_VIDEO ) { MDELAY(FE_THREAD_DELAY); continue; } // // ATV가 Main에 있을때만, NTSC Adaptive NR 실행. // if ( mainSrc == DHL_CAP_ATV0_VIDEO ) DHL_CAP_SetAdaptiveNR(); /* Get NTSC lock status. */ if ( pDSTFETuner->bCurDemod == DEMOD_NTSC ) DD_FE_AnalogGetLockStatus(pDSTFETuner, &isLocked); else DD_FE_GetLockStatus(pDSTFETuner, &isLocked); //isLocked = 0; /* Send callback to upper layer. */ if ( isLocked && (pDSTFETuner->NotifyState != FE_SENT_LOCK) ) { pDSTFETuner->NotifyState = FE_SENT_LOCK; if ( g_fe_debug ) { DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "[FAT] %s Locked.\n", pDSTFETuner->bCurDemod == DEMOD_8VSB ? "8VSB" : pDSTFETuner->bCurDemod == DEMOD_64QAM ? "64QAM" : pDSTFETuner->bCurDemod == DEMOD_256QAM ? "256QAM" : pDSTFETuner->bCurDemod == DEMOD_QAM ? "QAM" : pDSTFETuner->bCurDemod == DEMOD_NTSC ? "NTSC" : pDSTFETuner->bCurDemod == DEMOD_ISDBT ? "ISDB-T" : pDSTFETuner->bCurDemod == DEMOD_ISDBT_MANUAL ? "ISDB-T Manual" : pDSTFETuner->bCurDemod == DEMOD_MODEA ? "MODEA" : pDSTFETuner->bCurDemod == DEMOD_MODEB ? "MODEB" : "Unknown"); } if ( pDSTFETuner->bCurDemod == DEMOD_NTSC ) { if ( pDSTFETuner->fnFECallbackNTSC[FECALLBACK_LOCK-1] ) { (pDSTFETuner->fnFECallbackNTSC[FECALLBACK_LOCK-1])(pDSTFETuner->bTuner, FECALLBACK_LOCK, pDSTFETuner->FECallbackUserArg[FECALLBACK_LOCK-1]); } } else { if ( pDSTFETuner->fnFECallback[FECALLBACK_LOCK-1] ) { (pDSTFETuner->fnFECallback[FECALLBACK_LOCK-1])(pDSTFETuner->bTuner, FECALLBACK_LOCK, pDSTFETuner->FECallbackUserArg[FECALLBACK_LOCK-1]); } } } else if ( !isLocked && (pDSTFETuner->NotifyState == FE_SENT_LOCK) ) { pDSTFETuner->NotifyState = FE_SENT_UNLOCK; if ( g_fe_debug ) { DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "[FAT] %s Unlocked.\n", pDSTFETuner->bCurDemod == DEMOD_8VSB ? "8VSB" : pDSTFETuner->bCurDemod == DEMOD_64QAM ? "64QAM" : pDSTFETuner->bCurDemod == DEMOD_256QAM ? "256QAM" : pDSTFETuner->bCurDemod == DEMOD_QAM ? "QAM" : pDSTFETuner->bCurDemod == DEMOD_NTSC ? "NTSC" : pDSTFETuner->bCurDemod == DEMOD_ISDBT ? "ISDB-T" : pDSTFETuner->bCurDemod == DEMOD_ISDBT_MANUAL ? "ISDB-T Manual" : pDSTFETuner->bCurDemod == DEMOD_MODEA ? "MODEA" : pDSTFETuner->bCurDemod == DEMOD_MODEB ? "MODEB" : "Unknown"); } if ( pDSTFETuner->bCurDemod == DEMOD_NTSC ) { if ( pDSTFETuner->fnFECallbackNTSC[FECALLBACK_UNLOCK-1] ) { (pDSTFETuner->fnFECallbackNTSC[FECALLBACK_UNLOCK-1])(pDSTFETuner->bTuner, FECALLBACK_UNLOCK, pDSTFETuner->FECallbackNTSCUserArg[FECALLBACK_UNLOCK-1]); } } else { if ( pDSTFETuner->fnFECallback[FECALLBACK_UNLOCK-1] ) { (pDSTFETuner->fnFECallback[FECALLBACK_UNLOCK-1])(pDSTFETuner->bTuner, FECALLBACK_UNLOCK, pDSTFETuner->FECallbackUserArg[FECALLBACK_UNLOCK-1]); } } } /* else { DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "NTSC = %s, NotifyState = %d\n", isLocked ? "Locked" : "Unlocked", pDSTFETuner->NotifyState ); } */ MDELAY(FE_THREAD_DELAY); } } #if USE_NTSCCALLBACK static DHL_RESULT DHL_FE_NTSCCallbackInit(void) { DHL_RESULT dhlResult = DHL_OK; int i; P_DST_FE pDSTFETuner=&sDSTFE_Tuner[TUNER_FAT-1]; for (i=0; i<(FECALLBACK_MAX-1); i++) { pDSTFETuner->fnFECallbackNTSC[i] = (P_DHL_FE_CALLBACK)0; pDSTFETuner->FECallbackNTSCUserArg[i] = 0; } pDSTFETuner->NotifyState = FE_WAIT_FOR_LOCK; pDSTFETuner->bThreadActive = _FALSE_; pDSTFETuner->feThreadId = OS_SpawnTask( DHL_FE_MonitorThread, "tFEMonitor", 60, 4096, (DS_U32)pDSTFETuner); if ( pDSTFETuner->feThreadId == 0 ) DHL_DbgPrintf( 0, DHLDBG_FE, "ERROR: Cannot create FE thread!\n"); else DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "FE Thread ID = 0x%lx\n", pDSTFETuner->feThreadId ); return dhlResult; } #endif void dhl_fe_t_btsc( int Enable ) { P_DST_FE pDSTFETuner; pDSTFETuner = &sDSTFE_Tuner[TUNER_FAT-1]; //DD_FE_I2SEnable( pDSTFETuner, Enable ); } #if 0 ___Debugging_Functions___() #endif /************************************************************************* Debugging Functions *************************************************************************/ void set_am(int am, int as) { DHL_RESULT dhlResult = DHL_OK; DHL_DbgPrintf( 0, DHLDBG_FE, "*** Set NTSC Audio Mode ***\n"); DHL_DbgPrintf( 0, DHLDBG_FE, " AudioMode = %s (%d)\n", am == FE_AUDIO_MONO ? "MONO" : am == FE_AUDIO_STEREO ? "STEREO" : am == FE_AUDIO_MONO_SAP ? "MONO_SAP" : am == FE_AUDIO_SAP ? "SAP" : "Unknown", am ); DHL_DbgPrintf( 0, DHLDBG_FE, " AudioStandard = %s (%d)\n", as == FE_AUDIO_OFF ? "OFF" : as == FE_AUDIO_BTSC ? "BTSC" : as == FE_DUALFM ? "DUALFM" : as == FE_AUTODETECT ? "AUTODETECT" : "Unknown", as ); dhlResult = DHL_FE_SetAudioMode( TUNER_FAT, am, as ); if ( dhlResult == DHL_OK ) DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "success.\n"); else DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "failure.\n"); } void get_am(void) { DHL_RESULT dhlResult = DHL_OK; FEAudioMode_t am; FEAudioStandard_t as; dhlResult = DHL_FE_GetAudioMode( TUNER_FAT, &am, &as ); if ( dhlResult == DHL_OK ) DHL_DbgPrintf( 0, DHLDBG_FE, "success.\n"); else DHL_DbgPrintf( 0, DHLDBG_FE, "failure.\n"); DHL_DbgPrintf( 0, DHLDBG_FE, "*** Get NTSC Audio Mode ***\n"); DHL_DbgPrintf( 0, DHLDBG_FE, " AudioMode = %s (%d)\n", am == FE_AUDIO_MONO ? "MONO" : am == FE_AUDIO_STEREO ? "STEREO" : am == FE_AUDIO_MONO_SAP ? "MONO_SAP" : am == FE_AUDIO_SAP ? "SAP" : "Unknown", am ); DHL_DbgPrintf( 0, DHLDBG_FE, " AudioStandard = %s (%d)\n", as == FE_AUDIO_OFF ? "OFF" : as == FE_AUDIO_BTSC ? "BTSC" : as == FE_DUALFM ? "DUALFM" : as == FE_AUTODETECT ? "AUTODETECT" : "Unknown", as ); } void tune( DS_U32 Frequency, int Demod ) { Frequency *= 1000; #if NIMTN_TYPE==NIMTN_TDQU DS_U8 lockStatus = 0; char aft = 0; #endif DHL_DbgPrintf( 0, DHLDBG_FE, "tune to %ld\n", Frequency ); switch ( Demod ) { case DEMOD_8VSB: DHL_DbgPrintf( 0, DHLDBG_FE, "Demod to 8VSB\n"); break; case DEMOD_64QAM: DHL_DbgPrintf( 0, DHLDBG_FE, "Demod to QAM64\n"); break; case DEMOD_256QAM: DHL_DbgPrintf( 0, DHLDBG_FE, "Demod to QAM256\n"); break; case DEMOD_QAM: DHL_DbgPrintf( 0, DHLDBG_FE, "Demod to QAM\n"); break; case DEMOD_NTSC: DHL_DbgPrintf( 0, DHLDBG_FE, "Demod to NTSC/BTSC\n"); break; case DEMOD_ISDBT: DHL_DbgPrintf( 0, DHLDBG_FE, "Demod to ISDB-T\n"); break; case DEMOD_ISDBT_MANUAL: DHL_DbgPrintf( 0, DHLDBG_FE, "Demod to ISDB-T Manual\n"); break; case DEMOD_OFF: DHL_DbgPrintf( 0, DHLDBG_FE, "Demod to OFF\n"); break; default: DHL_DbgPrintf( 0, DHLDBG_FE, "Usage: tune [frenInKHz] [demod]\n"); DHL_DbgPrintf( 0, DHLDBG_FE, " [demod] = %d for %s\n", DEMOD_8VSB, "8VSB"); DHL_DbgPrintf( 0, DHLDBG_FE, " [demod] = %d for %s\n", DEMOD_64QAM, "64QAM"); DHL_DbgPrintf( 0, DHLDBG_FE, " [demod] = %d for %s\n", DEMOD_256QAM, "256QAM"); DHL_DbgPrintf( 0, DHLDBG_FE, " [demod] = %d for %s\n", DEMOD_QAM, "QAM"); DHL_DbgPrintf( 0, DHLDBG_FE, " [demod] = %d for %s\n", DEMOD_NTSC, "NTSC"); DHL_DbgPrintf( 0, DHLDBG_FE, " [demod] = %d for %s\n", DEMOD_ISDBT, "ISDB-T"); DHL_DbgPrintf( 0, DHLDBG_FE, " [demod] = %d for %s\n", DEMOD_ISDBT_MANUAL, "ISDB-T Manual"); DHL_DbgPrintf( 0, DHLDBG_FE, " [demod] = %d for %s\n", DEMOD_OFF, "OFF"); return; } DHL_FE_SetFrequency( TUNER_FAT, Frequency, Demod ); #if NIMTN_TYPE==NIMTN_TDQU DHL_FE_AnalogGetLockStatus( TUNER_FAT, &lockStatus); aft = AnalogCheckChannelStart( TUNER_FAT, Frequency, fnCancelCk1, fnCancelCk2); DHL_DbgPrintf( 0, DHLDBG_FE, "H lock status is %d\n",lockStatus); DHL_DbgPrintf( 0, DHLDBG_FE, "AFT lock status is %d\n",aft); #endif } void isLocked(void) { DHL_RESULT dhlResult = DHL_OK; DS_U8 isLocked; dhlResult = DHL_FE_GetLockStatus( TUNER_FAT, &isLocked ); if ( dhlResult != DHL_OK ) { DHL_DbgPrintf( 0, DHLDBG_FE, "ERROR: line = %d\n", __LINE__); return; } DHL_DbgPrintf( 0, DHLDBG_FE, "FAT is %s\n", isLocked == 1 ? "locked" : isLocked == 0 ? "unlocked" : "unknown" ); } void gettda() { P_DST_FE pDSTFETuner; UTda9885ReadReg tdaData; pDSTFETuner = &sDSTFE_Tuner[TUNER_FAT-1]; DD_FE_GetTDA9885Reg( pDSTFETuner, (DS_U8 *)&tdaData ); DHL_DbgPrintf( 0, DHLDBG_FE, "tdaData = 0x%x\n", tdaData.Byte ); DHL_DbgPrintf( 0, DHLDBG_FE, "afc_status = %d\n", tdaData.Part.AFC ); } int get_analoglock() { DS_U8 isLocked; isLocked = 0; if ( DHL_FE_AnalogGetLockStatus( TUNER_FAT, &isLocked ) != DHL_OK ) isLocked = 0; DHL_DbgPrintf( 0, DHLDBG_FE, "analog lock = %d (%s)\n", isLocked, isLocked ? "Locked" : "Unlocked" ); return (int)isLocked; } void TestAFT( DS_U32 channel, DS_U32 isCable ) { DHL_RESULT dhlResult = DHL_OK; DS_S32 Offset; P_DST_FE pDSTFETuner = &sDSTFE_Tuner[TUNER_FAT-1]; DS_U32 ori_freq; DS_U8 lockStatus; volatile DS_U32 startTick, endTick; DHL_FE_Stop( TUNER_FAT ); if (!channel && !isCable) { printf("Usage: %s [channel] [isCable]\n", __FUNCTION__); printf(" channel: ch #\n"); printf(" isCable: %d: AIR %d:STD %d:HRC %d: IRC\n", FREQ_AIR, FREQ_STD, FREQ_HRC, FREQ_IRC); return; } if ( isCable <= FREQ_UNKNOWN || isCable >= FREQ_MAX ) isCable = FREQ_AIR; DHL_FE_SetChannelStandard( TUNER_FAT, isCable ); ori_freq = ConvertChannelToFrequency( channel, pDSTFETuner->bFreqStd ); ori_freq *= 1000; DHL_DbgPrintf( 0, DHLDBG_FE, "Frequency Standard: %s, Freq: %d\n", isCable == FREQ_AIR ? "AIR" : \ isCable == FREQ_STD ? "STD" : \ isCable == FREQ_HRC ? "HRC" : \ isCable == FREQ_IRC ? "IRC" : "Unknown", ori_freq ); startTick = OS_GetTickCount(); dhlResult = DHL_FE_AnalogFullSearch( TUNER_FAT, channel, &Offset, CHANNEL, 0, 0, 0 ); if ( dhlResult != DHL_OK ) { DHL_DbgPrintf( 0, DHLDBG_FE, "ERROR: line = %d\n", __LINE__); return; } endTick = OS_GetTickCount(); printf("Elapsed Time: %ld.%ld sec\n", (endTick-startTick)/100, (endTick-startTick)%100); DHL_FE_GetLockStatus( TUNER_FAT, &lockStatus ); DHL_DbgPrintf( 0, DHLDBG_FE, "Lock Status: %d\n", lockStatus ); DHL_DbgPrintf( 0, DHLDBG_FE, "Original Frequency: %ld\n", ori_freq); DHL_DbgPrintf( 0, DHLDBG_FE, "New Frequency: %ld (%ld diff)\n", ori_freq + Offset, Offset); } DHL_RESULT PrintTunerStatus(void) { DHL_RESULT dhlResult = DHL_OK; DS_U8 LockStatus; DS_U8 ana_LockStat = 0; static float SNR; static float eqSNR; DS_U32 PWR; DS_U32 SQI; DS_U32 RSErr; float RSErrRate; TunerDemod Demod; DHL_FE_GetLockStatus( TUNER_FAT, &LockStatus ); DHL_FE_AnalogGetLockStatus( TUNER_FAT, &ana_LockStat ); DHL_FE_GetSignalStrength( TUNER_FAT, &SQI ); dhlResult = DHL_FE_GetSignalPower( TUNER_FAT, &PWR ); if ( dhlResult != DHL_OK ) PWR = -1; if ( LockStatus == 1 ) { dhlResult = DHL_FE_GetSNR( TUNER_FAT, &SNR ); dhlResult = DHL_FE_GetEqSNR( TUNER_FAT, &eqSNR ); dhlResult = DHL_FE_GetRSError( TUNER_FAT, &RSErr, &RSErrRate ); dhlResult = DHL_FE_GetModFormat( TUNER_FAT, &Demod ); } else { SNR = -1.0f; eqSNR = SNR; RSErr = (DS_U32)-1; RSErrRate = -1.0f; Demod = DEMOD_UNKNOWN; } DHL_DbgPrintf( 0, DHLDBG_FE, " <<< FAT Tuner Status >>>\n" ); DHL_DbgPrintf( 0, DHLDBG_FE, " SQI : %lu\n", SQI ); DHL_DbgPrintf( 0, DHLDBG_FE, " Power : %lu\n", PWR ); DHL_DbgPrintf( 0, DHLDBG_FE, " LockStatus : %u (%s)\n", LockStatus, LockStatus == 1 ? "Locked" : "Unlocked" ); DHL_DbgPrintf( 0, DHLDBG_FE, " Analog Lock: %u (%s)\n", ana_LockStat, ana_LockStat == 1 ? "Locked" : "Unlocked" ); DHL_DbgPrintf( 0, DHLDBG_FE, " SNR : %f (%s)\n", SNR, SNR == -1.0f ? "Invalid" : "Valid" ); DHL_DbgPrintf( 0, DHLDBG_FE, " EQ-SNR : %f (%s)\n", eqSNR, eqSNR == -1.0f ? "Invalid" : "Valid" ); DHL_DbgPrintf( 0, DHLDBG_FE, " RS Err Cnt : %lu(%s)\n", RSErr, RSErr ==(DS_U32) -1 ? "Invalid" : "Valid" ); DHL_DbgPrintf( 0, DHLDBG_FE, " RS Err Cnt : %f(%s)\n", RSErrRate, RSErrRate== -1.0f ? "Invalid" : "Valid" ); DHL_DbgPrintf( 0, DHLDBG_FE, " Modulation : %d(%s)\n", Demod, (Demod==DEMOD_8VSB) ? "8VSB" : (Demod==DEMOD_64QAM) ? "64QAM" : (Demod==DEMOD_256QAM) ? "256QAM" : (Demod==DEMOD_NTSC) ? "NTSC" : (Demod==DEMOD_ISDBT) ? "ISDB-T" : (Demod==DEMOD_ISDBT_MANUAL) ? "ISDB-T Manual" : "UNKNOWN"); #if 0 LockStatus = 0; dhlResult = DHL_FE_GetLockStatus( TUNER_FDC, &LockStatus ); dhlResult = DHL_FE_GetSignalStrength( TUNER_FDC, &SQI ); if ( LockStatus == 1 ) { dhlResult = DHL_FE_GetSNR( TUNER_FDC, &SNR ); dhlResult = DHL_FE_GetEqSNR( TUNER_FDC, &eqSNR ); dhlResult = DHL_FE_GetModFormat( TUNER_FDC, &Demod ); // dhlResult = DHL_FE_GetBERT( TUNER_FDC, &bertErrCnt, &bertErrRate ); } else { SNR = -1.0f; eqSNR = SNR; Demod = DEMOD_UNKNOWN; bertErrCnt = (DS_U32)-1; bertErrRate = -1.0f; } DHL_DbgPrintf( 0, DHLDBG_FE, " <<< FDC Tuner Status >>> \n" ); DHL_DbgPrintf( 0, DHLDBG_FE, " SQI : %lu\n", SQI ); DHL_DbgPrintf( 0, DHLDBG_FE, " LockStatus : %u (%s)\n", LockStatus, LockStatus == 1 ? "Locked" : "Unlocked" ); DHL_DbgPrintf( 0, DHLDBG_FE, " SNR : %f (%s)\n", SNR, SNR == -1.0f ? "Invalid" : "Valid" ); DHL_DbgPrintf( 0, DHLDBG_FE, " Modulation : %d(%s)\n", Demod, (Demod==DEMOD_MODEA) ? "MODEA" : ((Demod==DEMOD_MODEB) ? "MODEB" : "UNKNOWN") ); // DHL_DbgPrintf( 0, DHLDBG_FE, " BERT : %ld (%s)\n", bertErrCnt, bertErrCnt == -1 ? "Invalid" : "Valid" ); #endif return DHL_OK; } void FE_AgingTest(int mod, int count, int cable) { TunerDemod demod; DHL_RESULT dhlResult = DHL_OK; int curChannel, startChannel, stopChannel; if ( mod == 0 || mod > 3 ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Usage: %s [modulationType]\n", __FUNCTION__); DHL_DbgPrintf( 0, DHLDBG_FE, " modulationType\n"); DHL_DbgPrintf( 0, DHLDBG_FE, " 0:8VSB / 1:64QAM / 2:256QAM / 3:NTSC\n"); return; } switch(mod) { case 1: demod = DEMOD_8VSB; break; case 2: demod = DEMOD_64QAM; break; case 3: demod = DEMOD_256QAM; break; case 4: demod = DEMOD_NTSC; break; case 5: demod = DEMOD_ISDBT; break; case 6: demod = DEMOD_ISDBT_MANUAL; break; default: demod = DEMOD_8VSB; } if ( count <= 0 ) count = 1; DHL_FE_Stop( TUNER_FAT ); if ( cable == 1 ) { startChannel = 1; stopChannel = 135; DHL_FE_SetChannelStandard( TUNER_FAT, FREQ_STD ); DHL_FE_SetInput(TUNER_FAT, 0); } else { startChannel = 2; stopChannel = 69; DHL_FE_SetChannelStandard( TUNER_FAT, FREQ_AIR ); DHL_FE_SetInput(TUNER_FAT, 1); } while ( count-- ) { for (curChannel=startChannel; curChannel<=stopChannel; curChannel++) { dhlResult = DHL_FE_Start( TUNER_FAT, curChannel, demod, CHANNEL ); if ( dhlResult != DHL_OK ) DHL_DbgPrintf( 0, DHLDBG_FE, "ERROR, LINE=%d\n", __LINE__); dhlResult = DHL_FE_Stop( TUNER_FAT ); if ( dhlResult != DHL_OK ) DHL_DbgPrintf( 0, DHLDBG_FE, "ERROR, LINE=%d\n", __LINE__); MDELAY(1000); } } } static void TestNTSCFunc( TunerType Tuner, FECallbackSource eventSource, DS_U32 userArg ) { switch(eventSource) { case FECALLBACK_LOCK: DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "[NTSC] Locked. userArg = 0x%lx\n", userArg); break; case FECALLBACK_UNLOCK: DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "[NTSC] Unlocked. userArg = 0x%lx\n", userArg); break; default: DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "Spurious Signal. eventSource = %d\n", eventSource); } } void installTestNTSCCb(void) { DHL_RESULT dhlResult; DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "Install Test NTSC Callback Function.\n"); dhlResult = DHL_FE_SetCallbackNTSC(TUNER_FAT, FECALLBACK_ACQSTART, TestNTSCFunc, 0x1234 ); if ( dhlResult != DHL_OK ) DHL_DbgPrintf( 0, DHLDBG_FE, "ERROR: LINE=%d\n", __LINE__); dhlResult = DHL_FE_SetCallbackNTSC(TUNER_FAT, FECALLBACK_LOCK, TestNTSCFunc, 0x1234 ); if ( dhlResult != DHL_OK ) DHL_DbgPrintf( 0, DHLDBG_FE, "ERROR: LINE=%d\n", __LINE__); dhlResult = DHL_FE_SetCallbackNTSC(TUNER_FAT, FECALLBACK_UNLOCK, TestNTSCFunc, 0x4321 ); if ( dhlResult != DHL_OK ) DHL_DbgPrintf( 0, DHLDBG_FE, "ERROR: LINE=%d\n", __LINE__); } void check_freq_table(void) { DS_U32 freqHRC, freqSTD; int i, err; DHL_DbgPrintf( 0, DHLDBG_FE, "Check Frequency Table\n"); err = 0; for (i=1; i<=135; i++ ) { freqHRC = Cable_Freq_HRC[i]; freqSTD = Cable_Freq[i]; if ( (freqSTD - freqHRC) != 1250 ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Ch[%d] HRC = %ld, IRC = %ld\n", i, freqHRC, freqSTD ); err ++; } } if ( !err ) DHL_DbgPrintf( 0, DHLDBG_FE, "Frequency Table is OK\n"); else DHL_DbgPrintf( 0, DHLDBG_FE, "Frequency Table is INVALID, err cnt = %d\n", err); } void set_lock(int l) { if ( l == 1 ) DHL_DbgPrintf( 0, DHLDBG_FE, "Force to locked status.\n"); else if ( l == 0 ) DHL_DbgPrintf( 0, DHLDBG_FE, "Reset to normal status.\n"); else DHL_DbgPrintf( 0, DHLDBG_FE, "Force to unlocked status.\n"); g_force_ss = l; } void test_weaksignal(int interval) { if (interval) DHL_DbgPrintf( 0, DHLDBG_FE, "Set weak signal status with %d msec interval.\n", interval); else DHL_DbgPrintf( 0, DHLDBG_FE, "Clear weak signal status.\n"); g_test_weak_interval = interval; } void test_lockstatus(int n) { int i; DS_U32 SQI; for (i=0; i timeOut ) break; if ( lockStat ) break; } while ( 1 ); if (elapsedTime>timeOut) DHL_DbgPrintf( 0, DHLDBG_FE, "FAILURE: Timeout\n"); if (lockStat) DHL_DbgPrintf( 0, DHLDBG_FE, "ElapsedTime = %d msec\n", (int)elapsedTime*10); } } void test_locktime1(int freq1, int mod1, int freq2, int mod2, int n) { int i; volatile DS_U32 startTime, elapsedTime, timeOut = 300; DS_U8 lockStat; int flag = 0; if ( !freq1 || !freq2 || !mod1 || !mod2 || !n ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Usage: test_locktime [freqInKHz_1] [demod_1] [freqInKHz_2] [demod_2] [n]\n"); DHL_DbgPrintf( 0, DHLDBG_FE, " [demod] = %d for %s\n", DEMOD_8VSB, "8VSB"); DHL_DbgPrintf( 0, DHLDBG_FE, " [demod] = %d for %s\n", DEMOD_64QAM, "64QAM"); DHL_DbgPrintf( 0, DHLDBG_FE, " [demod] = %d for %s\n", DEMOD_256QAM, "256QAM"); DHL_DbgPrintf( 0, DHLDBG_FE, " [demod] = %d for %s\n", DEMOD_QAM, "QAM"); DHL_DbgPrintf( 0, DHLDBG_FE, " [demod] = %d for %s\n", DEMOD_NTSC, "NTSC"); DHL_DbgPrintf( 0, DHLDBG_FE, " [demod] = %d for %s\n", DEMOD_ISDBT, "ISDB-T"); DHL_DbgPrintf( 0, DHLDBG_FE, " [demod] = %d for %s\n", DEMOD_ISDBT_MANUAL, "ISDB-T Manual"); } for (i=0; i timeOut ) break; if ( lockStat ) break; } while ( 1 ); if (elapsedTime>timeOut) DHL_DbgPrintf( 0, DHLDBG_FE, "FAILURE: Timeout\n"); if (lockStat) DHL_DbgPrintf( 0, DHLDBG_FE, "ElapsedTime = %d msec\n", (int)elapsedTime*10); } } void set_air_freq( int n, int freq ) { DS_U32 old_freq; if ( !n || !freq ) { DHL_DbgPrintf( 0, DHLDBG_FE, "Usage: %s [ch #] [freqInKHz]\n", __FUNCTION__ ); return; } old_freq = Air_Freq[n]; Air_Freq[n] = (DS_U32)freq; DHL_DbgPrintf( 0, DHLDBG_FE, "Old: Air_Freq[%d] = %ld\n", n, old_freq); DHL_DbgPrintf( 0, DHLDBG_FE, "New: Air_Freq[%d] = %ld\n", n, Air_Freq[n]); } void set_am_delay(int b, int a) { DHL_DbgPrintf( 0, DHLDBG_FE, "g_PreAudioModeDelay: %d --> %d\n", g_PreAudioModeDelay, b); DHL_DbgPrintf( 0, DHLDBG_FE, "g_AftAudioModeDelay: %d --> %d\n", g_AftAudioModeDelay, a); g_PreAudioModeDelay = b; g_AftAudioModeDelay = a; } void set_analog_delay(int d) { printf("Analog Full Search delay: %d --> %d\n", g_AnalogSearchDelay, d); g_AnalogSearchDelay = d; } void test_tuner_ch(int std) { int i=0; if (std==0) { printf("Usage: %s [std] [ch]\n", __FUNCTION__); printf(" where 1: AIR\n"); printf(" where 2: STD\n"); printf(" where 3: IRC\n"); printf(" where 4: HRC\n"); return; } switch(std) { case 1: printf("Standard: AIR (2-69)\n"); for (i=2; i<=69; i++) { tune(Air_Freq[i], 1); } break; case 2: printf("Standard: STD (1-135)\n"); for (i=1; i<=135; i++) { tune(Cable_Freq[i], 3); } break; case 3: printf("Standard: HRC (1-135)\n"); for (i=1; i<=135; i++) { tune(Cable_Freq_IRC[i], 3); } break; case 4: printf("Standard: IRC (1-135)\n"); for (i=1; i<=135; i++) { tune(Cable_Freq_HRC[i], 3); } break; } } void test_aft_value(int ch) { DS_U32 startFreq, endFreq, stepFreq, curFreq; DS_U8 tdaData; if (!ch) { printf("Usage: %s [ch]\n", __FUNCTION__); return; } startFreq = Cable_Freq[ch] - 2250; endFreq = Cable_Freq[ch] + 2250; stepFreq = 50; for (curFreq=startFreq; curFreq