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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > mpeg/mp3 > 查看源码
SwapCode1.c
资源名称：SwapCode1fromsmi339edopencodeSM339BDFFISPA6ADCDACN　[点击查看]
上传用户：hualongjx
上传日期：2022-01-17
资源大小：4k
文件大小：14k
源码类别：

mpeg/mp3

开发平台：

Objective-C

SwapCode1.c：源码内容
  1. #include <option.h>
  2. #include <SMI51.h>
  3. #include <struct.h>
  4. #include <local.h>
  5. #include <local1.h>
  6. #include <protyp.h>
  7. #include <fusb.h>
  8. #include <UI.h>
  9. #include <fat.H>  
  10. #include <sd.h>
  11. #include <sdcmd.h>
  12. #include <isp_def.h>
  14. #if 1//S_SupportFM //yu5
  15. void FMdelay()
  16. {
  17.     delayclk(0x02);   
  18. }
  19. //code BYTE BATMAPISP[]={0,0,1,2,2,3,3,3};
  20. code BYTE BATMAPISP[]={0,0,0,0,0,1,2,3};
  21. void GUI_FM_ShowChanISP()
  22. {
  23.     for (gxTemp0=0;gxTemp0<16;gxTemp0++)
  24.         XB_FM_TempString[gxTemp0]=' ';
  26.     XB_FM_TempString[0]='F';
  27.     XB_FM_TempString[1]='M';
  29.     //JM=>PLL=(XW_FM_Freq*8.192-225)/100;
  30.     //gxibTempIntegerByte.INTEGER=(XW_FM_Freq&0x01)+(XW_FM_Freq/2);
  31.     gxibTempIntegerByte.INTEGER=(XW_FM_Freq/2); //(GM8)
  32.     gxibTempIntegerByte.INTEGER=hex2dec(gxibTempIntegerByte.INTEGER);
  33.     gxTemp0=2;
  34.     XB_FM_TempString[2]=((gxibTempIntegerByte.SBYTE.B1>>4) & 0x0f) | '0';
  36.     if (XB_FM_TempString[2] != '0') gxTemp0=3;
  38.     XB_FM_TempString[gxTemp0++]=((gxibTempIntegerByte.SBYTE.B1>>0) & 0x0f) | '0';
  39.     XB_FM_TempString[gxTemp0++]=((gxibTempIntegerByte.SBYTE.B0>>4) & 0x0f) | '0';
  40.     XB_FM_TempString[gxTemp0++]='.';
  41.     XB_FM_TempString[gxTemp0++]=((gxibTempIntegerByte.SBYTE.B0>>0) & 0x0f) | '0';
  42.    
  43.     if(XW_FM_Freq&0x01)
  44.      XB_FM_TempString[gxTemp0++]='5';
  45.     else
  46.      XB_FM_TempString[gxTemp0++]='0';
  50.     XB_FM_TempString[9]='C';
  51.     XB_FM_TempString[10]='H';
  53.     gxibTempIntegerByte.SBYTE.B0=hex2dec(XB_FM_MEM);
  55.     XB_FM_TempString[11]=((gxibTempIntegerByte.SBYTE.B0>>4) & 0x0f) | '0';
  56.     XB_FM_TempString[12]=((gxibTempIntegerByte.SBYTE.B0>>0) & 0x0f) | '0';
  57.     XB_FM_TempString[13]=0;
  59.     LCM_xp=0;
  60.     LCM_yp=1;
  62.     GUI_ShowString((XBYTE*)(XB_FM_TempString) ,0);
  63.     if(!(PB_HOST[0x04]&SET_BIT1)) //(GM7)
  64.     {
  65.      uiUpdateMainDisplay(bit0);
  66. lcmSetPageAddress(0,80); //(G) for FM mode
  67. MOVERAM_LCM(&XB_BUF0xE000[BATMAPISP[PB_HOST[ADC3BIT_CTRL]]*128],18);
  68. if(PB_HOST[ADC3BIT_CTRL]<=3)
  69. {
  70. M_SetLowBattery;
  71. GUI_ShowMenu1(C_LowBatteryPictureOffset);
  72. }   
  73.     }
  74. }
  76. void I2C_Stop_ISP()
  77. {
  78.     PB_HOST[FMI2C]=0xF8;
  79.     PB_HOST[I2CSEL]=0x7F;//Set input mode
  80.     FMdelay();
  81.     PB_HOST[FMI2C]=0xFA;
  82.     FMdelay();
  83.     PB_HOST[FMI2C]=0xFB;
  84. }
  86. #define k gxTempR
  87. #define i gxTemp0
  88. #define temp gxTemp1
  89. #define tempreg gxTemp2
  91. void FM_I2C_ADDR_ISP(BYTE addr)
  92. {
  93.     temp=addr;
  94.     
  95.     PB_HOST[FMI2C]=0xFB;//Start condition,CLK=0
  96.     FMdelay();
  97.     tempreg=0xFA;
  98.     PB_HOST[FMI2C]=0xFA;//Start condition,CLK=0
  99.     
  100.     FMdelay();
  101.     
  102.     for (i=0;i<8;i++)
  103.     {
  104.         tempreg&=0xFD;//Clr clk
  105.         PB_HOST[FMI2C]=tempreg; 
  106.         if (temp&0x80)
  107.         {
  108.             tempreg|=0x01;
  109.         }
  110.         else
  111.         {
  112.             tempreg&=0xFE;
  113.         }
  114.         PB_HOST[FMI2C]=tempreg;
  115.         tempreg|=0x02;//Set clk
  116.         PB_HOST[FMI2C]=tempreg;
  117.         temp=temp<<1;
  118.     }
  119.     
  120.     FMdelay();
  121.     
  122.     tempreg&=0xFD;//clr clk
  123.     PB_HOST[FMI2C]=tempreg;
  124.     PB_HOST[I2CSEL]=0x7E;//Set input mode
  125.     FMdelay();
  126.     tempreg|=0x02;//Set clk
  127.     PB_HOST[FMI2C]=tempreg;
  128.     FMdelay();
  129.     
  130. }
  132. void FM_I2C_IN_ISP(BYTE addr)
  133. {
  134.     FM_I2C_ADDR_ISP(addr);
  135.     for (k=0;k<5;k++)
  136.     {
  137.         temp=XB_FM_Data[k];
  138.         for (i=0;i<8;i++)
  139.         {
  140.             tempreg&=0xFD;
  141.             PB_HOST[FMI2C]=tempreg;
  142.             PB_HOST[I2CSEL]=0x7F;
  143.             if (temp&0x80)
  144.             {
  145.                 tempreg|=0x01;
  146.             }
  147.             else
  148.             {
  149.                 tempreg&=0xFE;
  150.             }
  151.             PB_HOST[FMI2C]=tempreg;
  152.             tempreg|=0x02;//Set clk
  153.             PB_HOST[FMI2C]=tempreg;
  154.             temp=temp<<1;
  155.         }
  156.         FMdelay();        
  157.         tempreg&=0xFD;//clr clk
  158.         PB_HOST[FMI2C]=tempreg;
  159.         PB_HOST[I2CSEL]=0x7E;//Set input mode
  160.         FMdelay();        
  161.         tempreg|=0x02;//Set clk
  162.         PB_HOST[FMI2C]=tempreg;
  163.         FMdelay();
  164.     }
  165.     I2C_Stop_ISP();
  166. }
  168. void FM_I2C_OUT_ISP(BYTE addr)
  169. {
  170.     FM_I2C_ADDR_ISP(addr);
  171.     for (k=0;k<5;k++)
  172.     {
  173.         temp=0;
  174.         for (i=0;i<8;i++)
  175.         {
  176.             temp=(temp<<1);
  177.             tempreg&=0xFD;//Clr clk
  178.             PB_HOST[FMI2C]=tempreg;
  179.             PB_HOST[I2CSEL]=0x7E;
  180.             FMdelay();
  181.             tempreg|=0x02;//set clk
  182.             PB_HOST[FMI2C]=tempreg;
  183.             FMdelay();
  184.             if (PB_HOST[FMI2C]&0x01)
  185.             {
  186.                 temp|=0x01;
  187.             }
  188.             else
  189.             {
  190.                 temp&=0xFE;
  191.             }
  192.         }
  193.         XB_FM_Data[k]=temp;
  194.         tempreg&=0xFD;//clr clk
  195.         PB_HOST[FMI2C]=tempreg;
  196.         FMdelay();
  197.         tempreg&=0xFE;
  198.         PB_HOST[I2CSEL]=0x7F;
  199.         PB_HOST[FMI2C]=tempreg;
  200.         tempreg|=0x02;//Set clk
  201.         PB_HOST[FMI2C]=tempreg;
  202.         FMdelay();
  203.     }
  204.     I2C_Stop_ISP();
  205. }
  206. #undef k
  207. #undef i
  208. #undef temp
  209. #undef tempreg
  211. void SetFMDataISP()
  212. {
  213.     //JM=>XB_FM_Data[1]=XW_FM_Freq&0xFF;
  214.     //JM=>XB_FM_Data[0]=XB_FM_Data[0]|((XW_FM_Freq>>8)&0x3F);
  215.     XB_FM_Data[0]=gxlbTempLongByte.SBYTE.B1;
  216.     XB_FM_Data[1]=gxlbTempLongByte.SBYTE.B0;
  217.     XB_FM_Data[2]=(XB_FM_Data[2]&0xA0)|0x30;
  218.     XB_FM_Data[3]=0x10;
  219.     XB_FM_Data[4]=0;
  220.     FM_I2C_IN_ISP(0xC0);
  221. }
  223. void FM_initISP()
  224. {
  225.     PB_HOST[I2CSEL] |= SET_BIT0;
  226.     if((XW_FM_Freq>FMMax)||(XW_FM_Freq<FMMin))
  227.      XW_FM_Freq=FMMin;
  228.     XB_FM_Data[0]=0;
  229.     XB_FM_Data[2]=0;
  230.     SetFMDataISP();
  231. }
  233. #define buf gxTemp4
  234. #define PTR XB_BUF0xE000
  235. void LoadSettingISP(void)
  236. {
  237.     //XBYTE *PTR;
  238.     
  239.     LoadWPROPage(buf,1);
  240.     //PTR=BUFADR[buf];
  241.     if (
  242.        (PTR[0]=='S')&&
  243.        (PTR[1]=='M')&&
  244.        (PTR[2]=='I')
  245.        )
  246.     {
  247.         gxRepeatMode=PTR[0x10];
  248.         XB_ADJ_Language=PTR[0x11];
  249.         XB_ADJ_CurrentV=PTR[0x12];
  250.         if(XB_ADJ_CurrentV>24)
  251.          XB_ADJ_CurrentV=24;
  252.         
  253.         XB_ADJ_EQMode=PTR[0x13];
  254.         XB_ADJ_AutoOff=PTR[0x14];
  255.         XB_ADJ_Contrast=PTR[0x15];
  257. SelectFolderCount=XB_ADJ_Contrast&0x0f;
  258. FolderStudeLevel=((XB_ADJ_Contrast>>4)&0x0f)*10;
  260. if( (SelectFolderCount>36)||(!SelectFolderCount)  )
  261. SelectFolderCount=1;
  262. if( (FolderStudeLevel>100)||(!FolderStudeLevel)  )
  263. FolderStudeLevel=40;
  265. XB_ADJ_Contrast=4;
  269.         XB_ADJ_BLTimer=PTR[0x16];
  270.         gxUseEngMenu=PTR[0x17];
  272.         gx16TempReg=((UINT16)PTR[0x18]<<8)+PTR[0x19];
  273.         if(gx16TempReg>=XW_TotalFile[XB_FileType])
  274. gx16PlayIndex=0;
  275. else
  276. gx16PlayIndex=gx16TempReg;
  277.         
  278.     
  279.         XW_FM_Freq=PTR[0x20+XB_FM_MEM*2+1];
  280. XW_FM_Freq=(XW_FM_Freq<<8)+PTR[0x20+XB_FM_MEM*2];
  281. if((XW_FM_Freq>FMMax)||(XW_FM_Freq<FMMin)) XW_FM_Freq=FMMin;
  283.         XB_FM_MEM=PTR[0x20+21*2];
  284.     }
  285.     else
  286.     {
  287.         gxRepeatMode=0x00;
  288.         XB_ADJ_Language=0x02;
  289.         XB_ADJ_CurrentV=18;
  290.         XB_ADJ_EQMode=0x00;
  291.         XB_ADJ_AutoOff=0x00;
  292. //        XB_ADJ_Contrast=0x51;
  293.         XB_ADJ_Contrast=4;
  294. SelectFolderCount=1;
  295. FolderStudeLevel=60;
  297.         XB_ADJ_BLTimer=0x00;
  298.         gxUseEngMenu=0;
  299.         gx16PlayIndex=0;
  300.         XW_FM_Freq=FMMin;
  301.         XB_FM_MEM=0;
  302.     }    
  303. }
  305. #undef buf 
  306. #undef PTR
  309. void fmGetMemChannelISP()
  310. {
  311.     if(XB_FM_MEM>20) XB_FM_MEM=0;
  312. gxTempR=XB_FM_MEM;
  313. gxTemp4=BUF0xE000;
  314. LoadSettingISP();
  315. //LoadSetting(BUF0xE000);
  316. XB_FM_MEM=gxTempR;
  317.     XB_FM_Data[0]=0;
  318.     XB_FM_Data[2]=0;
  319.     
  320.     gxlbTempLongByte.ULONG=(UINT32)XW_FM_Freq*(12500/2)+28125;  //(GM8)
  321. gxlbTempLongByte.ULONG=gxlbTempLongByte.ULONG>>10; //(J)/1024    
  323.     SetFMDataISP();
  324.     gxMemChannel=1;
  325. GUI_FM_ShowChanISP();
  327. }
  329. void InitFMISP()
  330. {
  331.     while (ReadDSP_DMA_CTRbit());
  332. //    WRITE_DSPREG(DMA_CTR,0);
  333.     Disable_DSP();
  335.     XB_FM_RunSeek=0;
  336.     XB_FM_SeekDir=0;
  338.     i2cInitialCS42L51(2);
  340. uiUpdateMainDisplay(bit7);
  341. XSFR2&=~bit2;//enable FM data bus pull high 
  342.     FM_initISP();
  343.     fmGetMemChannelISP();
  344. M_SetRampUpToVolume;
  345. gxRampVolume=0;
  346.     GUI_FM_ShowChanISP();
  347. }
  349. void FMStandbyISP()
  350. {
  351.     XB_FM_Data[1]=XW_FM_Freq&0xFF;
  352.     XB_FM_Data[0]=XB_FM_Data[0]|((XW_FM_Freq>>8)&0x3F);
  353.     XB_FM_Data[2]=(XB_FM_Data[2]&0xA0)|0x30;
  354.     XB_FM_Data[3]=0x53;
  355.     XB_FM_Data[4]=0x00;
  356.     FM_I2C_IN_ISP(0xC0);
  357.     XSFR2|=bit2;//disable FM data bus pull high 
  358.     
  359. #if(S_SupportAudioADC)
  360. WRITE_DSPIO(0x44,C_ADCDefultSetting);
  361.     M_AudioADCPowerDown;
  362. #endif    
  363. }
  365. #if(S_CS42L51)
  366. void I2CMixOff()
  367. {
  368. CodecI2COut(0x0e,0x80);
  369. CodecI2COut(0x0f,0x80);
  370. }
  371. void I2CMixOn()
  372. {
  373. CodecI2COut(0x0e,0x00);
  374. CodecI2COut(0x0f,0x00);
  375. }
  376. #endif
  378. void FM_SeekISP(void)
  379. {  
  380. //XBYTE u8IFCnt; //20060117_Jash use gxTemp0
  381. gxTempFMLevel=0; //20060411_Jash
  383. if (gxFMSeekDir>1) 
  384.      gxFMSeekDir=XB_FM_SeekDir;
  385.     else      
  386.     {
  387.      XB_FM_SeekDir=gxFMSeekDir;
  388.     }
  389.     
  390. if(XB_FM_RunSeek)
  391. {
  392. #if(S_CS42L51)
  393.         I2CMixOff();
  394. #endif 
  395. #if(S_SupportAudioADC)
  396. CodeI2C_CS_HIGH;
  397. #endif        
  398. }
  400. XB_FM_Data[0]=0x00; //(J)Step 
  401.     
  402.     if (gxFMSeekDir)
  403.     {
  404.      XW_FM_Freq++;
  405.     if (XW_FM_Freq > FMMax)   XW_FM_Freq = FMMin;
  406.     }
  407.     else
  408.     {
  409.      XW_FM_Freq--;  
  410.     if (XW_FM_Freq < FMMin)    XW_FM_Freq = FMMax;
  411.     }
  412.     XB_FM_Data[2]=0x60;
  413.     gxlbTempLongByte.ULONG=(UINT32)XW_FM_Freq*(12500/2)+28125;
  414. gxlbTempLongByte.ULONG=gxlbTempLongByte.ULONG>>10; //(J)/1024
  416.     SetFMDataISP();
  418.     gx5P5mSCnt=0;
  419.     T1Flag=0;
  420.     XSFR1 |= bit2; //20060719_Jash //(J)active key pad internal pull high
  421. delayclk(50); //20060719_Jash
  422.     while(gx5P5mSCnt<3)
  423.     {
  424.      if(T1Flag)
  425.      {
  426.      T1Flag=0;
  427.      gx5P5mSCnt++;
  428.      }
  429.     
  430.      //20060719_Jash
  431.      if((gxKeyMinderBuf==0)&&(~PB_HOST[Key_Pad])) //must be release all key then press any key
  432.      {
  433.      XB_FM_RunSeek=3; //XB_FM_RunSeek=3 means in prepare to leave FM seek mode.
  434.      XB_MENULayer[0]=10; //clear auto scan mode
  435. #if(S_CS42L51)    
  436.      I2CMixOn(); //(GM8)after manually stop FM seek, enable I2CMixOn
  437. #endif
  438.      break;
  439.      }
  440.     }
  441.     XSFR1 &= ~bit2; //20060719_Jash
  443.     FM_I2C_OUT_ISP(0xC1);
  445. gxTemp0=XB_FM_Data[2]&0x7f;  
  446. //u8ADCLevel=XB_FM_Data[3];
  448. if(XB_FM_Data[0]&0x40)
  449. {
  450. if(XB_FM_RunSeek!=2) //20060411_Jash
  451. {
  452. XB_FM_RunSeek=0; //original
  453.          //I2CMixOn(); //original
  454.         
  455.         }
  456.         else
  457.         {
  458. gxTempFMLevel=0xF1;
  459.         }
  460. }
  461. else if(((XB_FM_Data[3]&0xf0)>=0xA0)&&(gxTemp0>=49)&&(gxTemp0<=63)) //(J)33,41/49,62
  462. {
  463. if(XB_FM_RunSeek!=2) //20060411_Jash
  464. {
  465.     XB_FM_RunSeek=0; //original
  466. #if(S_CS42L51)    
  467.      I2CMixOn();
  468. #endif
  469. #if(S_SupportAudioADC)
  470. CodeI2C_CS_LOW;
  471. #endif
  472.     }
  473.     else
  474.     {
  475.      gxTempFMLevel=(XB_FM_Data[3]&0xf0);
  476.         }
  477. }
  479. #if(S_SupportAudioADC)
  480. if(XB_FM_RunSeek==3 || XB_FM_RunSeek==0)
  481. CodeI2C_CS_LOW;
  482. #endif
  484. //20060411_Jash
  485. if(XB_FM_RunSeek==2)
  486. {
  487. if(gxTempFMLevel&&(XW_FM_Freq!=(960*2)))
  488.         {
  489.          if(XB_FM_MEM<21)
  490.          {
  491.          gx16FMFreq[XB_FM_MEM]=XW_FM_Freq;
  492.          gxFMLevel[XB_FM_MEM]=gxTempFMLevel;
  493.          if(gxTempFMLevel<gxFMMinLevel)
  494.          {
  495.          gxFMMinLevel=gxTempFMLevel;
  496.          gxMinFreqIndex=XB_FM_MEM;
  497.          }
  498.          XB_FM_MEM++;
  499.          }
  500.          else
  501.          {
  502.          if(gxTempFMLevel>=gxFMMinLevel)
  503.          {        
  504.          gx16FMFreq[gxMinFreqIndex]=XW_FM_Freq;
  505.          gxFMLevel[gxMinFreqIndex]=gxTempFMLevel;
  506.         
  507.          gxFMMinLevel=0xFF;
  508.          for(gxTemp1=0;gxTemp1<XB_FM_MEM;gxTemp1++)
  509.          {
  510.          if(gxFMLevel[gxTemp1]<gxFMMinLevel)
  511.          {
  512.          //we give 0xFF for gxFMMinLeve initial value, but the max level is 0xF0.
  513.          //So, the fist time will enter here.
  514.          gxFMMinLevel=gxFMLevel[gxTemp1];
  515.          gxMinFreqIndex=gxTemp1;
  516.          }
  517.          else
  518.          {
  519.          if((gxFMLevel[gxTemp1]==gxFMMinLevel)&&(gx16FMFreq[gxTemp1]<gx16FMFreq[gxMinFreqIndex]))
  520.          {
  521.          gxMinFreqIndex=gxTemp1;
  522.          }
  523.          }
  524.          }
  525.          }
  526.          }        
  527.         }
  528. if(XW_FM_Freq==FMMax)
  529. {
  530.   for(gxTemp1=0;gxTemp1<XB_FM_MEM;gxTemp1++)
  531.   {
  532.   gxibTempIntegerByte.INTEGER=gx16FMFreq[gxTemp1];
  533.   for(gxTemp2=gxTemp1+1;gxTemp2<XB_FM_MEM;gxTemp2++)
  534.   {
  535.   if(gx16FMFreq[gxTemp2]<gxibTempIntegerByte.INTEGER)
  536.   {
  537.   gxibTempIntegerByte.INTEGER=gx16FMFreq[gxTemp2];
  538.   gx16FMFreq[gxTemp2]=gx16FMFreq[gxTemp1];
  539.   gx16FMFreq[gxTemp1]=gxibTempIntegerByte.INTEGER;
  540.   }
  541.   }
  542.   }
  544. LoadWPROPage(BUF0xE000,1);
  545.      gxTempPtr=BUFADR[BUF0xE000];
  546.      for(gxTemp1=0;gxTemp1<XB_FM_MEM;gxTemp1++)
  547.      {
  548.      gxTempPtr[0x20+gxTemp1*2]=gx16FMFreq[gxTemp1];
  549.      gxTempPtr[0x20+gxTemp1*2+1]=(gx16FMFreq[gxTemp1]>>8);
  550.     
  551.      }
  552.     
  553. SaveWPROPage(BUF0xE000,1);
  555. XB_FM_RunSeek=0;
  556. XB_MENULayer[0]=10;
  557. XB_FM_MEM=0;
  558. fmGetMemChannelISP();
  559. #if(S_CS42L51)
  560.      I2CMixOn();
  561. #endif
  562. #if(S_SupportAudioADC)
  563. CodeI2C_CS_LOW;
  564. #endif
  565. }
  566. }
  567. }
  568. CBYTE T_FMAutoScan1[]=
  569. {
  570. 'A','u','t','o',' ','S','c','a','n','?',0
  571. };
  572. CBYTE T_FMAutoScan2[]=
  573. {
  574. 'Y','E','S','=','M','E','N','U',0
  575. };
  577. void EnableFMAutoScan(void)
  578. {
  579. lcmClearLCM();
  580. LCM_xp=0;
  581.     LCM_yp=0;
  582.     GUI_ShowSmallString((XBYTE*)(T_FMAutoScan1));
  583. LCM_xp=0;
  584.     LCM_yp=1;
  585.     GUI_ShowSmallString((XBYTE*)(T_FMAutoScan2));
  587. XB_MENULayer[0]=10;
  588. gxLevelHoldCnt=0;
  589. M_SetFMAutoScan;
  590. M_SetStopKeyFunction;
  591. }
  593. void FMProcedure(void)
  594. {
  595. if(!gbFMMode)
  596. {
  597. #if(S_SupportAudioADC)
  598. CodeI2C_CS_HIGH;
  599. delayclk(250);
  600. delayclk(250);
  601. delayclk(250);
  602. delayclk(250);
  603. delayclk(250);
  604. PB_DAC[DAC_PowerCtrl]=0x0c;
  605. #endif
  606.         Process_STOP();
  608.         XB_MENULayer[0]=10;  //GOTO FM MODE
  609.         SET_PLAYMODE(C_FMMode);
  610.         XB_NoFile=0;
  611.         //i2cInitialCS42L51ISP(2);
  612.         
  613.         InitFMISP();
  614. #if(S_SupportAudioADC)
  616. WRITE_DSPIO(0x44,C_ADCDefultSetting); //(G)defult setting, loop back always enable for DSP code "RECFILE" in audio ADC case
  618. gxibTempIntegerByte.INTEGER=0x8000; //(G)use 24.576MHz, sampling rate 32k for DSP code "RECFILE"
  619. SwitchPLL();
  620.     InitDSPType(RECFILE);
  621. SWITCH_CLK(PLLCLK+DIV2+WAITS);
  622.     Enable_DSP();
  623.         
  624.         PB_DAC[DAC_SamplingRate]=SR_32K;
  625.         PB_DAC[DAC_PowerCtrl]=0x0d;
  626.     
  627. M_ClrEnableRampUpVolume;
  628. gx10P10mSCnt1=0;        
  629. M_AudioADCPowerOn;
  630.         
  631. #endif
  632.     }
  633.     else
  634.      GotoMainPorg();
  635. }
  638. #endif //yu5