开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 压缩解压 > 查看源码
FmTEA5767.c
资源名称：SDK_M5661.rar　[点击查看]
上传用户：hjhsjcl
上传日期：2020-09-25
资源大小：11378k
文件大小：19k
源码类别：

压缩解压

开发平台：

C++ Builder

FmTEA5767.c：源码内容
  1. /*==========================================================================
  2. Copyright (c) 2004 ALi Corporation. All Rights Reserved
  4. File: Fm.c
  6. content: 
  8. History: Created by David Chiu 2004/4/27
  9. ==========================================================================*/
  10. #define _FM_TEA5767_H_
  13. #include "TypeDef.h"
  14. #include "Const.h"
  15. #include "Reg5661.h"
  17. #if(FM_MODULE==0) //Walace060126#2
  19. #include "Common.h"
  20. #include "UiFm.h"  //just for UiDisplayCtrl
  22. #include "I2C.h"
  23. #include "FmTEA5767.h" 
  25. //Ren050312#1
  26. #include "ExtCodec.h"
  27. #include "IntCodec.h"
  29. //Walace060126#2 start
  30. #define FM_GET_ADC_LEVEL 0xF0
  31. #define FM_GET_IF 0x7F
  32. #define FM_SEARCH_FINISH 0x80
  33. #define FM_SEARCH_BAND 0x40
  35. #define FM_CMD_MUTE_EN 0x80
  36. #define FM_CMD_MUTE_DIS 0x7F
  37. #define FM_CMD_SEARCH_EN 0x40
  38. #define FM_CMD_SEARCH_DIS 0xBF
  39. #define FM_CMD_STANDBY_EN 0x40
  40. #define FM_CMD_STANDBY_DIS 0xBF
  41. #define FM_CMD_STOP_HIGH 0x60
  42. #define FM_CMD_STOP_MID 0x40
  43. #define FM_CMD_STOP_LOW 0x20
  44. #define FM_HI_INJECTION_EN 0x10
  45. #define FM_LO_INJECTION_ENJ 0xEF
  47. #define FM_FORCE_MONO 0x08 //Walace060217#1
  49. #define FM_NEXT_STOP_LEVEL 0x20
  51. #define FM_STERO_EN 0x80
  52. //Walace060126#2 end
  54. BOOL gfHILOInjection;
  55. XBYTE gxbFmWriteData[5];
  56. XBYTE gxbFmReadData[5];
  57. //Walace060126#2 end
  58.  
  59. BOOL TEA5767Write(void);
  60. BOOL TEA5767Read(void);
  61. WORD CalculatePLL(WORD wfrequency);
  62. WORD ConvertPLL(WORD wPll);
  63. BOOL IsValidStop(void)large;
  65. //Dennis Shih 20060309
  66. //Dino050812
  67. void FMHiLoCheck(void) large;
  69. /*
  70. EXTERN API BOOL gfStereoSet; //Walace060217#1
  71. EXTERN API BOOL gfRealStereo;
  72. */
  73. /*
  74. *--------------------------------------------------------------------------
  75. Desciption:
  76. Initial setting of FM Module
  77. Arguments:
  78. void
  79. Global arguments:
  80. gxwFmFreq=Default FM Freq
  81. Returns:
  82. void
  83. --------------------------------------------------------------------------*/
  84. #if (_PM_FM_|_PM_MPTEST_)
  85. API bit TEA5767_FmInit(void)
  86. {
  87. //David 041106#2
  88. /*
  89. obDCVARRD=0x0A; //DCV Addr 0x0A
  90. obDCVWRDATA=0x72; //Set 0x72
  92. obDCVARRD=0x09; //DCV Addr 0x09
  93. obDCVWRDATA=0x74; //Set 0x74
  94. */
  96. obGPIOEDAT &=0xBF; //Power on FM //David 041106#1
  97. // Data Init...
  98. //FmDataInit(); //Vicky050311#3 //Walace060126#2
  99. TEA5767_FmDataInit(); //Vicky050311#3 //Walace060126#2
  101. I2cInit();
  102. obI2CCLKDIV = 7; // Set I2C Serial Port Clock for FM
  104. I2cWaitBusy();
  107. //return FmSetFreq(); //Walace060126#2
  108. return TEA5767_FmSetFreq();
  110. }
  112. //Vicky050311#3
  113. API void TEA5767_FmDataInit(void)
  114. {
  115. BYTE bI;
  117. for(bI=0;bI<5;bI++)
  118. {
  119. gxbFmReadData[bI]=0;
  120. gxbFmWriteData[bI]=0;
  121. }
  123. gfHILOInjection=FM_LO_INJEC;
  124. gxbFmWriteData[2]=0x00;//low injection ,stereo on,left not muted,right not muted,SW port1 low
  125. gxbFmWriteData[3]=0x1e;//SW port2 low,standby off,US/Europe FM band limit,xtal=32.768kHz,Soft-mute on,HCC on,SNC on,pin 14 is SW port1;
  126. gxbFmWriteData[4]=0x80;//6.5kHz reference for PLL  enable,Deemphasis time const is 50us
  129. }
  130. #endif
  132. #if (_PM_FM_|_PM_MPTEST_)
  133. /*--------------------------------------------------------------------------
  134. Desciption:
  135. Write 5 bytes to TEA5767HN chip ,no subaddress byte is needed
  136. Arguments:
  137. void
  138. Global arguments:
  139. xbFmWriteData[]: Data write to TEA5767 chip
  140. Returns:
  141. TRUE or FALSE
  142. --------------------------------------------------------------------------*/
  143. BOOL TEA5767Write(void)
  144. {
  145. BYTE bI;
  147. obCLKI2CMCTRL |= 0x80; //clock Enable //Renshuo050322#A
  148. obMODSEL2 |= 0x08; //I2CM Enable
  150. obI2CMAADDR = FM_TEA5767;
  151. obI2CSLADDR = gxbFmWriteData[0];
  152. for(bI=1;bI<5;bI++)
  153. obI2CFIFO = gxbFmWriteData[bI];
  155. obI2CMACMD = (I2C_CMD_SINGLE | I2C_CMD_CURRENT | I2C_CMD_WRITE_MODE | I2C_CMD_DATA_LEN(4));
  157. //Renshuo050322#A      
  158. bI = I2cWaitBusy();  
  159. obMODSEL2 &= 0xF7; //I2CM Disable
  160. obCLKI2CMCTRL &= 0x7F; //clock Disable
  161. return bI;
  163. }
  164. #endif // (_PM_FM_|_PM_MPTEST_)
  166. #if (_PM_FM_|_PM_MPTEST_)
  167. /*--------------------------------------------------------------------------
  168. Desciption:
  169. Read 5 bytes from TEA5767HN chip ,no subaddress byte is needed
  170. Arguments:
  171. void
  172. Global arguments:
  173. void
  174. Returns:
  175. TRUE or FALSE
  176. --------------------------------------------------------------------------*/
  177. BOOL TEA5767Read(void)
  178. {
  179. BYTE bI;
  181. //Renshuo050322#A    
  182. obCLKI2CMCTRL |= 0x80; //clock Enable
  183. obMODSEL2 |= 0x08; //I2CM Enable
  185. obI2CMAADDR = FM_TEA5767;
  186. obI2CMACMD = ( I2C_CMD_SINGLE | I2C_CMD_CURRENT | I2C_CMD_READ_MODE | I2C_CMD_DATA_LEN(5));
  188. if(I2cWaitBusy())
  189. {
  190. for(bI=0;bI<5;bI++)
  191. gxbFmReadData[bI]=obI2CFIFO;
  192. //Renshuo050322#A    
  193. obCLKI2CMCTRL |= 0x80; //clock Enable
  194. obMODSEL2 |= 0x08; //I2CM Enable
  195. return TRUE;
  196. }
  197. else
  198. {
  199. obCLKI2CMCTRL |= 0x80; //clock Enable
  200. obMODSEL2 |= 0x08; //I2CM Enable
  201. return FALSE;
  202. }
  203. }
  204. #endif // (_PM_FM_|_PM_MPTEST_)
  207. #if (_PM_FM_|_PM_MPTEST_)
  208. /*--------------------------------------------------------------------------
  209. Desciption:
  210. Converts frequency to PLL value in condition of "HILO injection" = 1 
  211. Arguments:
  212. xwfrequency: the frequency based on 100KHz (ex: 963 = 96.3 MHz)
  213. Global arguments:
  214. void
  215. Returns:
  216. The value of PLL 
  217. --------------------------------------------------------------------------*/
  218. WORD CalculatePLL(WORD wfrequency)
  219. {
  220. #if(FM_STEP_100K) //Dennis060517#1 start
  221. if (gfHILOInjection)
  222. return (WORD)( (( (DWORD)wfrequency*100000)+225000)>>13);//HILO injection=1
  223. else
  224. return (WORD)( (( (DWORD)wfrequency*100000)-225000)>>13);//HILO injection=0
  225. #else
  226. if (gfHILOInjection)
  227. return (WORD)( (( (DWORD)wfrequency*10000)+225000)>>13);//HILO injection=1
  228. else
  229. return (WORD)( (( (DWORD)wfrequency*10000)-225000)>>13);//HILO injection=0
  230. #endif //Dennis060517#1 end
  231. }
  232. #endif
  234. #if (_PM_FM_)
  235. /*--------------------------------------------------------------------------
  236. Desciption:
  237. Converts PLL value to frequency in condition of "HILO injection" = 1
  238. Arguments:
  239. wPll: The PLL value
  240. Global arguments:
  241. void
  242. Returns:
  243. The frequency 
  244. --------------------------------------------------------------------------*/
  245. WORD ConvertPLL(WORD wPll)
  246. {
  247. #if(FM_STEP_100K) //Dennis060517#1 start
  248. if(gfHILOInjection)
  249. return (((((DWORD)wPll<<13)-225000)/100000)+1); // HILo injection=1;
  250. else
  251. return (((((DWORD)wPll<<13)+225000)/100000)+1);// HILo injection=0;
  252. #else 
  253. if(gfHILOInjection)
  254. return (((((DWORD)wPll<<13)-225000)/10000)+10); // HILo injection=1;
  255. else
  256. return (((((DWORD)wPll<<13)+225000)/10000)+10);// HILo injection=0;
  257. #endif //Dennis060517#1 end
  258. }
  259. #endif // (_PM_FM_)
  262. #if (_PM_FM_|_PM_MPTEST_)
  263. /*--------------------------------------------------------------------------
  264. Desciption:
  265. Set FM IC's PLL by "gxwFmFreq"
  266. Arguments:
  267. void
  268. Global arguments:
  269. gxwFmFreq : FM frequency based on 100KHz
  270. Returns:
  271. TRUE: Set Freq successful
  272. FALSE: Busy time out or Nack error
  273. --------------------------------------------------------------------------*/
  274. API bit TEA5767_FmSetFreq(void)
  275. {
  276. XWORD xwPLL;
  278. xwPLL=CalculatePLL(gxwFmFreq);
  279. if (gfHILOInjection)
  280. gxbFmWriteData[2] |= FM_HI_INJECTION_EN;
  281. else
  282. gxbFmWriteData[2] &= FM_LO_INJECTION_ENJ;
  284. gxbFmWriteData[0]=((xwPLL>>8) & FM_CMD_MUTE_DIS) & FM_CMD_SEARCH_DIS; //not mute and not in search mode
  285.        gxbFmWriteData[1]=xwPLL ;    
  286. TEA5767Write();
  288. return TRUE;
  290. }
  291. #endif //_PM_FM_|_PM_MPTEST_
  293. #if (_PM_FM_)
  294. /*--------------------------------------------------------------------------
  295. Desciption:
  296. Set FM in mute mode, this function will set frequ, too.
  297. If You want to unmute, just call FmSetFreq
  298. Arguments:
  299. void
  300. Global arguments:
  301. gxwFmFreq : FM frequency based on 100KHz
  302. Returns:
  303. void
  304. --------------------------------------------------------------------------*/
  305. API void TEA5767_FmSetMute(void)
  306. {
  307. XWORD xwPLL;
  309. xwPLL=CalculatePLL(gxwFmFreq);
  310. if (gfHILOInjection)
  311. gxbFmWriteData[2] |= FM_HI_INJECTION_EN;
  312. else
  313. gxbFmWriteData[2] &= FM_LO_INJECTION_ENJ;
  315. gxbFmWriteData[0]=((xwPLL>>8) | FM_CMD_MUTE_EN) & FM_CMD_SEARCH_DIS; //mute and not in search mode
  316. gxbFmWriteData[1]=xwPLL ;
  317.    
  318. TEA5767Write();
  319. }
  320. #endif  // (_PM_FM_)
  322. #if (_PM_FM_)
  323. /*--------------------------------------------------------------------------
  324. Desciption:
  325. Stop FM Module, set IC mute and standby
  326. Arguments:
  327. void
  328. Global arguments:
  329. void
  330. Returns:
  331. void
  332. --------------------------------------------------------------------------*/
  333. API void TEA5767_FmEnd(void)
  334. {
  335. gxbFmWriteData[0] |= FM_CMD_MUTE_EN;
  336. gxbFmWriteData[3] |= FM_CMD_STANDBY_EN;
  337. TEA5767Write();
  338. ClkI2CmDis();
  339. ClkCdcEn(); //2004.11.16 Renshuo
  341. //obALGPAREG |= 0x04; //power down PDY
  342. //obALGPAREG |= 0x01; //power down PD
  343. //obALGPAREG |= 0x02; //power down PDX
  344. #if(!EXT_ADC | !EXT_DAC | !EXT_PA)
  345. //Renshuo050322#A    
  346. IntCdcPowerDownPa(); //Renshuo041207#A //Ren050312#1
  347. #endif
  348. ClkCdcDis();
  349. gfCdcAlreadyInit = FALSE; /*2004.11.17 Renshuo add*/
  351. obGPIOEDAT |=0x40; //Power down FM //David 041106#1
  353. //David 041106#2
  354. /*
  355. // restore dvc value
  356. obDCVARRD=0x0A; //DCV Addr 0x0A
  357. obDCVWRDATA=0x42; //Set 0x42
  359. obDCVARRD=0x09; //DCV Addr 0x09
  360. obDCVWRDATA=0x07; //Set 0x07
  361. */
  362. }
  363. #endif // (_PM_FM_)
  366. API void  TEA5767_FmSetStereo(BOOL fStereo) //Walace060217#1
  367. {
  368. if(fStereo) //Dennis060309#1
  369. gxbFmWriteData[2] &=(~FM_FORCE_MONO); //Dennis Shih 2006/03/10
  370. else
  371. gxbFmWriteData[2] |=FM_FORCE_MONO; //Dennis Shih 2006/03/10
  372. TEA5767Write();
  373. }
  375. #if (_PM_FM_)
  376. /*--------------------------------------------------------------------------
  377. Desciption:
  378. check Fm is stereo or mono
  379. Arguments:
  380. void
  381. Global arguments:
  382. void
  383. Returns:
  384. TRUE:Stereo
  385. FALSE:MONO
  386. --------------------------------------------------------------------------*/
  387. API bit TEA5767_FmCheckStereo(void)
  388. {
  389. TEA5767Read();
  391. if(gxbFmReadData[2]&FM_STERO_EN)
  392. return TRUE;
  393. else
  394. return FALSE;
  395. }
  396. #endif //(_PM_FM_)
  400. #if (_PM_FM_)
  401. /*--------------------------------------------------------------------------
  402. Desciption:
  403. Search Up/Down from currently frequency
  404. Arguments:
  405. fSearchUp 1: Up 0: Down
  406. bStopLevel
  407. Global arguments:
  408. void
  409. Returns:
  410. TRUE: A station is found
  411. FALSE:Reach the band limit
  412. --------------------------------------------------------------------------*/
  413. //BOOL TEA5767_FmSearch(BOOL fSearchUp) 
  414. #if(USE_CHIP_AUTO_SEARCH) //Walace060829#4
  415. BOOL TEA5767_FmSearch(BYTE fSearchUp) reentrant //Tne051228#reentrant
  416. {
  417. //-----------------------For TEA5767--------------------------
  419. BYTE xbLevelHigh,xbLevelLow;
  420. WORD xwPLL,xwPreFreq,xwTimeOut2;
  421. DWORD xdwTimeOut1;
  423. WORD xwDifFreq;
  424. BYTE xbNowStopLevel;
  425. BYTE xbRetry=0;
  427. xbNowStopLevel=FM_CMD_STOP_LOW; // Use Low Level for search default
  429. xdwTimeOut1=0x7FFFFFFF;
  430. while(1)
  431. {
  432. xwPreFreq = gxwFmFreq;
  433. xwPLL = CalculatePLL(gxwFmFreq);
  435. gxbFmWriteData[0] = ((BYTE)(xwPLL>>8) | FM_CMD_SEARCH_EN | FM_CMD_MUTE_EN);
  436. gxbFmWriteData[1] = (BYTE)xwPLL;
  437. gxbFmWriteData[2] = (((BYTE)fSearchUp)<<7) | xbNowStopLevel;
  439. TEA5767Write(); //Start Search
  440. xdwTimeOut1--;
  441. if(xdwTimeOut1==0) 
  442. return FALSE; // TimeOut
  443. xwTimeOut2=0xFFFF;
  444. do
  445. {
  446. UiDispCtrl(UI_FM_SEARCHING); //show searching message
  447. if(!TEA5767Read()) return FALSE;
  448. xwTimeOut2--;
  449. if(xwTimeOut2==0) return FALSE; //Time Out
  450. }
  451. while((gxbFmReadData[0]&FM_SEARCH_FINISH)==FALSE); //wait search finish
  454. if(gxbFmReadData[0]&FM_SEARCH_BAND) //Reach the band limit
  455. return (FALSE);
  457. //applying searching algorithm here
  458. xwPLL=((WORD)(gxbFmReadData[0] & 0x3f))<<8;
  459. xwPLL|=gxbFmReadData[1];
  460. gxwFmFreq=ConvertPLL(xwPLL);
  462. if( (xwPreFreq==gxwFmFreq ) )
  463. {
  465. if(fSearchUp)
  466. gxwFmFreq++;
  467. else
  468. gxwFmFreq--;
  470. }
  471. else
  472. {
  473. if(xbNowStopLevel==FM_CMD_STOP_HIGH) // STOP Level High...No more high
  474. {
  475. if (IsValidStop())
  476. break;
  477. }
  478. else
  479. {
  480. if(fSearchUp)
  481. xwDifFreq=(gxwFmFreq-xwPreFreq);
  482. else
  483. xwDifFreq=(xwPreFreq-gxwFmFreq);
  485. if(xwDifFreq==1)
  486. {
  487. xbRetry++;
  488. if(xbRetry>=3)
  489. {
  490. xbNowStopLevel += FM_NEXT_STOP_LEVEL; // Try Next stop Level
  491. xbRetry=0;
  492. }
  493. }
  494. else
  495. {
  496. if (IsValidStop())
  497. break;
  498. }
  499. }
  500. }
  501. }//while loop
  503. if(gfHILOInjection)
  504. xwPLL+=0x3d;
  505. else
  506. xwPLL+=0x30;
  508. //starting to set HILO to optimal level
  509. gxbFmWriteData[0]=(xwPLL>>8) & FM_CMD_SEARCH_DIS; //stop search mode
  510. gxbFmWriteData[1]=xwPLL ;
  511. TEA5767Write();
  512. TEA5767Read();
  513. xbLevelHigh=(gxbFmReadData[3] & FM_GET_ADC_LEVEL);
  514. if(gfHILOInjection)
  515. xwPLL-=0x7a;
  516. else
  517. xwPLL-=0x60;
  519. gxbFmWriteData[0]=(xwPLL>>8) & FM_CMD_SEARCH_DIS;
  520.     gxbFmWriteData[1]=xwPLL ;
  521. TEA5767Write();
  522. TEA5767Read();
  523. xbLevelLow=(gxbFmReadData[3] & FM_GET_ADC_LEVEL);
  525. if (xbLevelHigh<xbLevelLow)
  526. gfHILOInjection=TRUE; //high injection
  527. else
  528. gfHILOInjection=FALSE; //low injection
  530. //FmSetFreq();
  532. return TRUE;
  533. }
  535. #else //Walace060829#4 start
  537. API BYTE FmCheckLevel(void)
  538. {
  540. TEA5767Read();
  541. return (gxbFmReadData[3] & FM_GET_ADC_LEVEL)>>4;
  543. }
  545. BOOL TEA5767_FmSearch(BYTE fSearchUp) reentrant //Tne051228#reentrant
  546. {
  547. WORD wDelay,xwPLL;
  548. BYTE xbIFCounter;
  549. BYTE xbStreo;
  550. BYTE bI;
  551. BYTE bKey;
  552. BYTE bTemp,bLevel;
  554. while(1)
  555. {
  556.      bTemp=0;
  557. //KeyGet(bKey); //Walace060829#4
  558. //if((bKey == KEY_LEFT_BREAK)||(bKey == KEY_RIGHT_BREAK))
  559. // return FALSE;
  560. if(fSearchUp)
  561. {
  562. gxwFmFreq++;
  563. if(gxwFmFreq>FM_FREQ_MAX)
  564. {
  565. gxwFmFreq=FM_FREQ_MAX;
  566. return FALSE;
  567. }
  568. }
  569. else
  570. {
  571. gxwFmFreq--;
  572. if(gxwFmFreq<FM_FREQ_MIN)
  573. {
  574. gxwFmFreq=FM_FREQ_MIN;
  575. return FALSE;
  576. }
  577. }
  578. //UiShowFreq();    
  579. //UiShowScrollPreset();    
  580. UiDispCtrl(UI_FM_SEARCHING); //Walace060829#4
  582. xwPLL=CalculatePLL(gxwFmFreq);
  583. if (gfHILOInjection)
  584. gxbFmWriteData[2] |= FM_HI_INJECTION_EN;
  585. else
  586. gxbFmWriteData[2] &= FM_LO_INJECTION_ENJ;
  589. gxbFmWriteData[0]=((xwPLL>>8) & FM_CMD_MUTE_DIS) & FM_CMD_SEARCH_DIS; //not mute and not in search mode
  590.     gxbFmWriteData[1]=xwPLL ;
  591. TEA5767Write();
  594. wDelay=0;
  595. while(++wDelay<30000);
  596. wDelay=0;
  597. while(++wDelay<30000);
  599. bLevel = FmCheckLevel();
  600.  
  601. for(bI=0;bI<15;bI++)
  602. {
  603. TEA5767Read();
  605. xbIFCounter = gxbFmReadData[2] & FM_GET_IF;
  606. xbStreo=gxbFmReadData[2]&FM_STERO_EN;
  608. if(xbStreo)
  609. {
  610.     bTemp++;
  611. if((xbIFCounter>=0x35)&(xbIFCounter<0x3e)&(bTemp>10)&(bLevel>=2))
  612. //if((xbIFCounter>=0x37)&(xbIFCounter<0x3e)&(bTemp>12)&(bLevel>=4))
  613. {
  614.       bTemp=0;
  615. TEA5767Write();
  616. return TRUE;
  617. }
  618. }
  619. wDelay=0;
  620. while(++wDelay<800);
  621. }
  622. }
  623. }
  624. #endif //#if(USE_CHIP_AUTO_SEARCH)
  625. //Walace060829#4 end
  627. #endif // (_PM_FM_)
  629. #if (_PM_FM_|_PM_MPTEST_)
  630. /*--------------------------------------------------------------------------
  631. Desciption:
  632. Checking frequency searching stopped value is valid or not 
  633. Arguments:
  634. void
  635. Global arguments:
  636. void
  637. Returns:
  638. TRUE: Valid
  639. FALSE:Invalid
  640. --------------------------------------------------------------------------*/
  641. BOOL IsValidStop(void) large
  642. {
  643. //Dennis Shih 20060309 start
  644. XBYTE xbLevel1,xbIFCounter;
  646. TEA5767Read();
  647. xbLevel1 = (gxbFmReadData[3] & FM_GET_ADC_LEVEL)>>4;
  648. xbIFCounter = gxbFmReadData[2] & FM_GET_IF;
  651. //if (!(  (xbLevel1>5) & (0x30<xbIFCounter)  & (xbIFCounter<0x5f)))
  652. if (!(  (xbLevel1>3) & (0x32<xbIFCounter)  & (xbIFCounter<0x3b)))
  653. return (FALSE);
  654. else 
  655. return TRUE;
  659. /*
  660. XBYTE xbLevel1,xbLevel2,xbIFCounter;
  661. #define xbLevelDiff xbLevel2
  664. if (!(  (xbLevel1>5) & (0x31<xbIFCounter)  & (xbIFCounter<0x3a) ))
  665. return (FALSE);
  666. else 
  667. return TRUE;
  669. if (gfHILOInjection)
  670. gxbFmWriteData[2] &= FM_LO_INJECTION_ENJ; //hi toggle to lo
  671. else
  672. gxbFmWriteData[2] |= FM_HI_INJECTION_EN; //lo toggle to high
  674. TEA5767Write();
  675. TEA5767Read();
  676. xbLevel2 = (gxbFmReadData[3] & FM_GET_ADC_LEVEL)>>4; //measure level2
  677. xbIFCounter = gxbFmReadData[2] & FM_GET_IF;
  679. if (gfHILOInjection)
  680. gxbFmWriteData[2] |= FM_HI_INJECTION_EN; //high injection
  681. else
  682. gxbFmWriteData[2] &= FM_LO_INJECTION_ENJ; //low injection
  684. TEA5767Write();
  687. if(xbLevel1>=xbLevel2)
  688. xbLevelDiff=xbLevel1-xbLevel2;
  689. else
  690. xbLevelDiff=xbLevel2-xbLevel1;
  692. if (xbLevel1>10)
  693. {
  694. if (!(  (xbLevelDiff<3) & (0x31<xbIFCounter)  & (xbIFCounter<0x3e) ))
  695. return (FALSE);
  696. }
  697. else
  698. {
  699. if (!(  (xbLevelDiff<2) & (0x31<xbIFCounter)  & (xbIFCounter<0x3e)))
  700. return (FALSE);
  701. }
  702.     
  703. return (TRUE);
  704. #undef xbLevelDiff 
  705. */
  706. //Dennis Shih 20060309 end
  707. }
  708. #endif // (_PM_FM_)         
  711. /*--------------------------------------------------------------------------
  712. Desciption:
  713. Search Up/Down from currently frequency and select stop level
  714. Arguments:
  715. 1: Up
  716. 0: Down
  717. Global arguments:
  718. void
  719. Returns:
  720. TRUE: A station is found
  721. FALSE:Reach the band limit
  722. --------------------------------------------------------------------------*/
  723. /*
  724. API BOOL FmSearchFreq(BOOL fSearchUp)
  725. {
  727. XWORD xwPreFreq,xwDifFreq;
  728. XBYTE xbNowStopLevel,xbRetry=0;
  730. xbNowStopLevel=FM_CMD_STOP_LOW; // Use Low Level for search default
  731. //xbNowStopLevel=FM_CMD_STOP_HIGH;
  732. while(1)
  733. {
  734. xwPreFreq=gxwFmFreq;
  735. if(FmSearch(fSearchUp,xbNowStopLevel)==FALSE)
  736. return FALSE;
  738. if(xbNowStopLevel==FM_CMD_STOP_HIGH)
  739.  return TRUE; // STOP Level High...No more high
  741. if(fSearchUp)
  742. xwDifFreq=(gxwFmFreq-xwPreFreq);
  743. else
  744. xwDifFreq=(xwPreFreq-gxwFmFreq);
  746. if(xwDifFreq==1)
  747. {
  748. xbRetry++;
  749. if(xbRetry>3)
  750. {
  751. xbNowStopLevel += FM_NEXT_STOP_LEVEL; // Try Next stop Level
  752. xbRetry=0;
  753. }
  754. }
  755. else
  756. return TRUE;
  757. }
  758. }
  759. */
  762. //Dennis Shih 20060309
  763. //Dino050812
  764. //check the whether the FM freq level ADC and IF counter
  765. #if (_PM_FM_|_PM_MPTEST_)
  766. API bit TEA5767_FmFreqCheck(void)
  767. {
  768. XWORD xwPLL;
  769. XWORD Temp;
  771. //gfHILOInjection=0;
  772. FMHiLoCheck();
  773. xwPLL=CalculatePLL(gxwFmFreq);
  775.      gxbFmWriteData[1]=xwPLL ;
  776. if(!TEA5767Write())
  777. return FALSE;
  781. Temp=0x100;
  782. do
  783.    {
  784.     Temp--;
  785.     TEA5767Read();
  786.     if(gxbFmReadData[0] &0x80)
  787. goto CHECKFREQ;
  789.     }while(Temp>0);
  790.     return FALSE;
  792. CHECKFREQ:
  794. if(IsValidStop())
  795. return TRUE;
  796. else
  797. return FALSE;
  802. }
  804. //Dennis Shih 20060309
  805. //Dino050812
  806. //Check the HILO inject value
  807. void FMHiLoCheck(void) large
  808. {
  809. XBYTE xbLevelHigh,xbLevelLow;
  810. XWORD xwPLL;
  812. xwPLL = CalculatePLL(gxwFmFreq);
  813. if(gfHILOInjection)
  814. xwPLL+=0x3d;
  815. else
  816. xwPLL+=0x30;
  818. //starting to set HILO to optimal level
  819. gxbFmWriteData[0]=(xwPLL>>8) & FM_CMD_SEARCH_DIS; //stop search mode
  820.     gxbFmWriteData[1]=xwPLL ;
  821. TEA5767Write();
  822. TEA5767Read();
  823. xbLevelHigh=(gxbFmReadData[3] & FM_GET_ADC_LEVEL);
  824. if(gfHILOInjection)
  825. xwPLL-=0x7a;
  826. else
  827. xwPLL-=0x60;
  829. gxbFmWriteData[0]=(xwPLL>>8) & FM_CMD_SEARCH_DIS;
  830.     gxbFmWriteData[1]=xwPLL ;
  831. TEA5767Write();
  832. TEA5767Read();
  833. xbLevelLow=(gxbFmReadData[3] & FM_GET_ADC_LEVEL);
  835. if (xbLevelHigh<xbLevelLow)
  836. gfHILOInjection=TRUE; //high injection
  837. else
  838. gfHILOInjection=FALSE; //low injection
  839. }
  840. #endif
  842. #endif //#if(FM_MODULE==1) //Walace060126#2