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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > DVD > 查看源码
ddx8000.c
资源名称：8202s_8281s_050405_dvd_622.rar　[点击查看]
上传用户：caisangzi8
上传日期：2013-10-25
资源大小：15756k
文件大小：37k
源码类别：

DVD

开发平台：

C/C++

ddx8000.c：源码内容
  1. /***********************************
  2. Creater: xiongyuyue
  3. Date   : 2003/8/14 
  4. Description: Amplifier function using
  5. Reference:DDX8000 Datasheet(APOGEE CO.)
  6. ***********************************/
  7. #include "user_init.h"
  8. //#include "config.h"
  9. //#include "regmap.h"
  10. #include "global.h"
  11. #include "ircode.h"
  12. #include "osd.h"
  13. //#include "gpio.h"
  14. //#include "iop.h"
  15. #include "audctrl.h"
  16. #include "ddx8000.h"
  17. #include "cchar.h"
  18. #include "util.h"
  20. #define NOP delay_1us(10000)
  22. #ifdef SUPPORT_SAVE_AMPLIFIER_STATUS
  23. extern void save_amplifier_status_to_e2prom();
  24. extern void load_amplifier_status_from_e2prom();
  25. #endif
  27. int ddx_amp_mode = 0;
  28. extern BYTE amp_lev[9];
  29. extern BYTE vol_gain[9];
  31. #if defined(AMPVOL_ADJUST_TYPE1)
  32. extern BYTE channelNm;//xyy 2004-5-25 10:44
  33. #endif
  35. #if defined(DDX8000_BINARY_MODE)
  36. BYTE channel_addr[6] = 
  37. {
  38. 0x0f,//front left
  39. 0x0d,//front right
  40. 0x0c,//surround left
  41. 0x0a,//surround right
  42. 0x09,//center
  43. 0x0e//subwoofer
  44. };
  45. #elif defined(XINGQIU_BINARY_MODE)
  46. BYTE channel_addr[6] = 
  47. {
  48. 0x0a,//front left
  49. 0x0c,//front right
  50. 0x0f,//surround left
  51. 0x0d,//surround right
  52. 0x09,//center
  53. 0x0e//subwoofer
  54. };
  55. #else
  56. BYTE channel_addr[6] = 
  57. {
  58. 0x09,//front left
  59. 0x0a,//front right
  60. 0x0b,//surround left
  61. 0x0c,//surround right
  62. 0x0d,//center
  63. 0x0e//subwoofer
  64. };
  65. #endif
  67. //Reset DDX8000
  68. void ddx_reset_all(void)
  69. {
  70. BYTE data;
  71. //Reset Configuration Register A
  72. data = 0x83;
  73. WriteToI2c(DDX8K_ADDR,CONFIGREG_A,&data,1);
  74. //Reset Configuration Register B
  75. data = 0x42;
  76. WriteToI2c(DDX8K_ADDR,CONFIGREG_B,&data,1);
  77. //Reset Configuration Register C
  78. data = 0x7c;
  79. WriteToI2c(DDX8K_ADDR,CONFIGREG_C,&data,1);
  80. //Reset Configuration Register D
  81. data = 0x20;
  82. WriteToI2c(DDX8K_ADDR,CONFIGREG_D,&data,1);
  83. //Reset Configuration Register E
  84. data = 0x02;
  85. WriteToI2c(DDX8K_ADDR,CONFIGREG_E,&data,1);
  86. //Reset Configuration Register F
  87. data = 0x00;
  88. WriteToI2c(DDX8K_ADDR,CONFIGREG_F,&data,1);
  89. //Master Mute
  90. data = 0x00;
  91. WriteToI2c(DDX8K_ADDR,MASTER_MUTE_REG,&data,1);
  92. //Master Volume
  93. data = 0xff;
  94. WriteToI2c(DDX8K_ADDR,MASTER_VOL_REG,&data,1);
  95. //Channel 1,2,3,4,5,6,7,8 mute
  96. data = 0x00;
  97. WriteToI2c(DDX8K_ADDR,CHANEL_MUTE_REG,&data,1);
  98. //Channel 1,2,3,4,5,6,7,8 Volume
  99. data = 0x30;
  100. WriteToI2c(DDX8K_ADDR,C1V_REG,&data,8);
  101. //Channel Input Mapping
  102. data = 0x10;
  103. WriteToI2c(DDX8K_ADDR,C12MAP_REG,&data,1);
  104. data = 0x32;
  105. WriteToI2c(DDX8K_ADDR,C34MAP_REG,&data,1);
  106. data = 0x54;
  107. WriteToI2c(DDX8K_ADDR,C56MAP_REG,&data,1);
  108. data = 0x76;
  109. WriteToI2c(DDX8K_ADDR,C78MAP_REG,&data,1);
  110. //Limiter Selection
  111. data = 0x00;
  112. WriteToI2c(DDX8K_ADDR,CLIMITER_SEL0,&data,2);
  113. //Limiter 1 & 2 Rates and Thresholds
  114. data = 0xa6;
  115. WriteToI2c(DDX8K_ADDR,L1RATE_REG,&data,1);
  116. data = 0x67;
  117. WriteToI2c(DDX8K_ADDR,L1THRESHOLDS_REG,&data,1);
  118. data = 0xa6;
  119. WriteToI2c(DDX8K_ADDR,L2RATE_REG,&data,1);
  120. data = 0x67;
  121. WriteToI2c(DDX8K_ADDR,L2THRESHOLDS_REG,&data,1);
  122. //Tone control
  123. data = 0x77;
  124. WriteToI2c(DDX8K_ADDR,TONE_CTRL_REG,&data,1);
  125. }
  127. void write_reg_bit(int addr,BYTE bit,BYTE val)
  128. {
  129. BYTE tmp = 0;
  130. int res;
  131. res = ReadFromI2c(DDX8K_ADDR,addr,&tmp,1);
  132. NOP;
  133. // printf("11-----------------tmp = :%x,res :%d**********n",tmp,res);
  134. if(val)
  135. tmp |= 0x01<<bit;
  136. else
  137. tmp &= ~(0x01<<bit);
  138. NOP;
  139. res = WriteToI2c(DDX8K_ADDR,addr,&tmp,1);
  140. printf("1addr :%x,tmp = :%x,res :%dn",addr,tmp,res);
  141. NOP;
  143. res = ReadFromI2c(DDX8K_ADDR,addr,&tmp,1);
  144. printf("2addr :%x,tmp = :%x,res :%dn",addr,tmp,res);
  145. }
  147. //Enable or Disable External Amplifier Power Down
  148. void ddx_enableEPAD(void)
  149. {
  150. write_reg_bit(CONFIGREG_F,7,1);
  151. }
  153. void ddx_disableEPAD(void)
  154. {
  155. write_reg_bit(CONFIGREG_F,7,0);
  156. }
  158. /*///////////////////////////////////////////////////////////////
  159. sample_rate     ctrl        input data format
  160.    32fs         ×010        MSB First Right/Left-Justified 16-bit data
  161.    48fs         0001        MSB First Left-Justified Data
  162.                 1001        LSB First Left-Justified Data
  163.                 ×010        Right-Justified 16-bit Data
  164.                 ×011        Right-Justified 18-bit Data
  165.                 ×100        Right-Justified 20-bit Data
  166.                 ×101        Right-Justified 24-bit Data
  167.    64fs         0000        I2S 16 to 24-bit Data          default input data format
  168.     0001        MSB First Left-Justified Data
  169.                 1001        LSB First Left-Justified Data
  170.                 ×010        Right-Justified 16-bit Data
  171.                 ×011        Right-Justified 18-bit Data
  172.                 ×100        Right-Justified 20-bit Data
  173.                 ×101        Right-Justified 24-bit Data
  174. *////////////////////////////////////////////////////////////////
  175. void set_inputData_format(BYTE ctrl)
  176. {
  177.     UINT16      romSum=0;
  178.     BYTE *p = (BYTE *)(&romSum);
  179. ReadFromI2c(DDX8K_ADDR,CONFIGREG_B,p,1);
  180. *p = (ctrl<<2) | (*p & 0xc3);
  181. WriteToI2c(DDX8K_ADDR,CONFIGREG_B,p,1);
  182. }
  184. //channel mapping
  185. //par:  pch---processing channel number; ich---input channel number
  186. void ddx_channel_map(BYTE pch,BYTE ich)
  187. {
  188.     UINT16      romSum=0;
  189.     BYTE *p = (BYTE *)(&romSum);
  190. switch(pch)
  191. {
  192. case 1:
  193. *p = (*p & 0xf8) | (ich-1);
  194. WriteToI2c(DDX8K_ADDR,C12MAP_REG,p,1);
  195. break;
  196. case 2:
  197. *p = (*p & 0x8f) | ((ich-1)<<4);
  198. WriteToI2c(DDX8K_ADDR,C12MAP_REG,p,1);
  199. break;
  200. case 3:
  201. *p = (*p & 0xf8) | (ich-1);
  202. WriteToI2c(DDX8K_ADDR,C34MAP_REG,p,1);
  203. break;
  204. case 4:
  205. *p = (*p & 0x8f) | ((ich-1)<<4);
  206. WriteToI2c(DDX8K_ADDR,C34MAP_REG,p,1);
  207. break;
  208. case 5:
  209. *p = (*p & 0xf8) | (ich-1);
  210. WriteToI2c(DDX8K_ADDR,C56MAP_REG,p,1);
  211. break;
  212. case 6:
  213. *p = (*p & 0x8f) | ((ich-1)<<4);
  214. WriteToI2c(DDX8K_ADDR,C56MAP_REG,p,1);
  215. break;
  216. case 7:
  217. *p = (*p & 0xf8) | (ich-1);
  218. WriteToI2c(DDX8K_ADDR,C78MAP_REG,p,1);
  219. break;
  220. case 8:
  221. *p = (*p & 0x8f) | ((ich-1)<<4);
  222. WriteToI2c(DDX8K_ADDR,C78MAP_REG,p,1);
  223. break;
  224. }
  225. }
  227. //////////////////////////////////////////////////////////////////
  228. //Configuration Register A
  229. /*
  230. sample rate(kHz)  |  IR(D4~D3)  |            MCS(D2~D0)
  231. -----------------------------------------------------------------------
  232.                   |             |  1××   | 011   | 010   | 001   | 000
  233. -----------------------------------------------------------------------
  234. 32, 44.1, 48      |     00      |  128fs | 256fs | 384fs | 512fs | 768fs
  235. 88.2, 96          |     01      |  64fs  | 128fs | 192fs | 256fs | 384fs
  236. 176.4, 192        |     10      |  64fs  | 128fs | 192fs | 256fs | 384fs
  237. Reserved          |     NA      |    NA  |   NA  |   NA  |   NA  |   NA
  238. -----------------------------------------------------------------------
  239. */
  240. ///////////////////////////////////////////////////////////////////
  241. void set_inputClock(BYTE IR,BYTE MCS)
  242. {
  243.     UINT16      romSum=0;
  244.     BYTE *p = (BYTE *)(&romSum);
  245. *p = (*p & 0xe0) | ((IR<<3) | MCS);
  246. WriteToI2c(DDX8K_ADDR,CONFIGREG_A,p,1);
  247. }
  249. //Bass Management
  250. //set Configuration Register A bit 5 will enable or disable bass management
  251. void ddx_enable_BassManagement(void)
  252. {
  253. write_reg_bit(CONFIGREG_A,5,1);
  254. }
  256. void ddx_disable_BassManagement(void)
  257. {
  258. write_reg_bit(CONFIGREG_A,5,0);
  259. }
  261. //Reading a Coefficient Value From RAM
  262. UINT32 ddx_readCoefVal(BYTE regAddr)
  263. {
  264. UINT32 tmp;
  265.     UINT16      romSum=0;
  266.     BYTE *p = (BYTE *)(&romSum);
  267.     
  268. //    printf("**********************************************n");
  269.     //write 8-bit address to I2C register 1Ch
  270.     *p = regAddr;
  271. WriteToI2c(DDX8K_ADDR,0x1c,p,1);
  273. *p = 0;
  274. ReadFromI2c(DDX8K_ADDR,0x1c,p,1);
  275. // printf("the val of register 0x1c is:%xn",*p);
  277. //read top 8-bits of coefficient in I2C address 1Dh
  278. *p = 0;
  279. ReadFromI2c(DDX8K_ADDR,0x1d,p,1);
  281. // printf("the val of register 0x1d is:%xn",*p);
  283. tmp = (*p << 16) & 0xff0000;
  285. //read middle 8-bits of coefficient in I2C address 1Fh
  286. *p = 0;
  287. ReadFromI2c(DDX8K_ADDR,0x1e,p,1);
  289. // printf("the val of register 0x1e is:%xn",*p);
  291. tmp = tmp | ((*p << 8) & 0xff00);
  293. //read bottom 8-bits of coefficient in I2C address 1Fh
  294. *p=0;
  295. ReadFromI2c(DDX8K_ADDR,0x1f,p,1);
  297. // printf("the val of register 0x1f is:%xn",*p);
  299. tmp = tmp | *p;
  300. return tmp;
  301. }
  302. //Writing a single Coefficient Value to RAM
  303. void ddx_writeCoefVal(BYTE regAddr,UINT32 coefVal)
  304. {
  306.     UINT16      romSum=0;
  307.     BYTE *p = (BYTE *)(&romSum);
  308.     
  309.     //write 8-bit address to I2C register 1Ch
  310.     *p = regAddr;
  311. WriteToI2c(DDX8K_ADDR,0x1c,p,1);
  313. //write top 8-bits of coefficient in I2C address 1Dh
  314. *p = (coefVal & 0xff0000) >> 16;
  315. WriteToI2c(DDX8K_ADDR,0x1d,p,1);
  317. //write middle 8-bits of coefficient in I2C address 1Eh
  318. *p = (coefVal & 0x00ff00) >> 8;
  319. WriteToI2c(DDX8K_ADDR,0x1e,p,1);
  321. //write bottom 8-bits of coefficient in I2C address 1Fh
  322. *p = (coefVal & 0x0000ff);
  323. WriteToI2c(DDX8K_ADDR,0x1f,p,1);
  325. //write control
  326. write_reg_bit(0x2c,0,1);
  327. }
  330. //Writing a set of Coefficient Values to RAM
  331. void ddx_writeCoefValSets(BYTE startAddr,coef_factor factor)
  332. {
  333.     UINT16      romSum=0;
  334.     BYTE *p = (BYTE *)(&romSum);
  335.     //write 8-bit address to I2C register 1Ch
  336.     *p = startAddr;
  337. WriteToI2c(DDX8K_ADDR,0x1c,p,1);
  338. //write factor b2
  339. *p = (factor.b2 & 0xff0000) >> 16;
  340. WriteToI2c(DDX8K_ADDR,0x1d,p,1);
  342. *p = (factor.b2 & 0x00ff00) >> 8;
  343. WriteToI2c(DDX8K_ADDR,0x1e,p,1);
  345. *p = (factor.b2 & 0x0000ff);
  346. WriteToI2c(DDX8K_ADDR,0x1f,p,1);
  347. //write factor b0
  348. *p = (factor.b0 & 0xff0000) >> 16;
  349. WriteToI2c(DDX8K_ADDR,0x20,p,1);
  351. *p = (factor.b0 & 0x00ff00) >> 8;
  352. WriteToI2c(DDX8K_ADDR,0x21,p,1);
  354. *p = (factor.b0 & 0x0000ff);
  355. WriteToI2c(DDX8K_ADDR,0x22,p,1);
  356. //write factor a2
  357. *p = (factor.a2 & 0xff0000) >> 16;
  358. WriteToI2c(DDX8K_ADDR,0x23,p,1);
  360. *p = (factor.a2 & 0x00ff00) >> 8;
  361. WriteToI2c(DDX8K_ADDR,0x24,p,1);
  363. *p = (factor.a2 & 0x0000ff);
  364. WriteToI2c(DDX8K_ADDR,0x25,p,1);
  365. //write factor a1
  366. *p = (factor.a1 & 0xff0000) >> 16;
  367. WriteToI2c(DDX8K_ADDR,0x26,p,1);
  369. *p = (factor.a1 & 0x00ff00) >> 8;
  370. WriteToI2c(DDX8K_ADDR,0x27,p,1);
  372. *p = (factor.a1 & 0x0000ff);
  373. WriteToI2c(DDX8K_ADDR,0x28,p,1);
  374. //write factor b1
  375. *p = (factor.b1 & 0xff0000) >> 16;
  376. WriteToI2c(DDX8K_ADDR,0x29,p,1);
  378. *p = (factor.b1 & 0x00ff00) >> 8;
  379. WriteToI2c(DDX8K_ADDR,0x2a,p,1);
  381. *p = (factor.b1 & 0x0000ff);
  382. WriteToI2c(DDX8K_ADDR,0x2b,p,1);
  384. //write control
  385. write_reg_bit(0x2c,1,1);
  386. }
  387. //HPB register i.e. Configuation Register C-02h,Bit 7
  388. //1: disable this feature
  389. //0: enable this feature
  390. //input:1---disable,0---enable
  391. //enable High Pass Filter
  392. void enable_hpf(void)
  393. {
  394. write_reg_bit(CONFIGREG_C,7,0);
  395. }
  397. void disable_hpf(void)
  398. {
  399.   write_reg_bit(CONFIGREG_C,7,1);
  400. }
  403. #ifdef SUPPORT_BASS_TREBLE
  404. //tone control:  include treble control and bass control
  405. //input:
  406. //updown: 1---boost tone -1---cut tone
  407. BYTE ddx_trebleCtrl(int updown)   //xulf modified 2004-01-13
  408. {
  409.     BYTE romSum=0;
  410.     BYTE *p = (BYTE *)(&romSum);
  411.     
  412. ReadFromI2c(DDX8K_ADDR,TONE_CTRL_REG,p,1);
  413. if(updown==1)
  414. {
  415. if(ddx_Treble_lev < 0x0d)
  416. ddx_Treble_lev++;
  417. }
  418. else if(updown==-1)
  419. {
  420. if(ddx_Treble_lev > 0x1)
  421. ddx_Treble_lev--;
  422. }
  423. *p = (ddx_Treble_lev<<4) | (*p & 0x0f);
  424. WriteToI2c(DDX8K_ADDR,TONE_CTRL_REG,p,1);
  425. #ifdef SUPPORT_SAVE_AMPLIFIER_STATUS
  426. WriteToI2c(0xa0, TREBLE_GAIN_ADDR, &ddx_Treble_lev, 1);
  427. #endif
  428. }
  430. BYTE  ddx_bassCtrl(int updown) //xulf modified 2004-01-13
  431. {
  432.     BYTE romSum=0;
  433.     BYTE *p = (BYTE *)(&romSum);
  434.     
  435. ReadFromI2c(DDX8K_ADDR,TONE_CTRL_REG,p,1);
  436. if(updown==1)
  437. {
  438. if(ddx_Bass_lev < 0x0d)      
  439. ddx_Bass_lev++;
  440. }
  441. else if(updown==-1)
  442. {
  443. if(ddx_Bass_lev > 0x1)
  444. ddx_Bass_lev--;
  445. }
  446. *p = ddx_Bass_lev | (*p & 0xf0);
  447. WriteToI2c(DDX8K_ADDR,TONE_CTRL_REG,p,1);
  448. #ifdef SUPPORT_SAVE_AMPLIFIER_STATUS
  449. WriteToI2c(0xa0, BASS_GAIN_ADDR, &ddx_Bass_lev, 1);
  450. #endif
  451. }
  452. #endif
  454. //volume control:  include master volume control and channel volume control
  455. //input:
  456. /*
  457. updown:  1---boost,  -1---cut
  458. mute:    1---Hard Master Mute,  0---not mute,adjust volume
  459. */
  460. void ddx_master_volume_adjust(int updown,BYTE mute)
  461. {
  462.     BYTE tmp_var;
  463.     int iRts;
  464.     
  465.     if(mute)
  466.     {
  467. tmp_var = 0xff;
  468. vol_gain[0] = tmp_var;
  469. WriteToI2c(DDX8K_ADDR,MASTER_VOL_REG,&tmp_var,1);
  470. return;
  471.     }
  472.     else
  473.     {
  474. //     ddx_masterMute(1);
  475. iRts = ReadFromI2c(DDX8K_ADDR,MASTER_VOL_REG,&tmp_var,1);
  476.      if(updown==1)
  477.      {
  478.      if(tmp_var>0x00 && tmp_var<=0x13)//0x00:0dB,0x13:-9.5dB
  479.      tmp_var--;
  480.      else if(tmp_var>=0x14 && tmp_var<=0x31)//0x14:-10dB,0x31:-24.5dB
  481.          tmp_var = tmp_var - 2;
  482.      else if(tmp_var>=0x32 && tmp_var<=0x6b)//0x32:-25dB,0x6b:-53dB
  483.      tmp_var = tmp_var - 4;
  484.      }
  485.      else if(updown==-1)
  486.      {
  487.      if(tmp_var>=0x00 && tmp_var<=0x13)//0x00:0dB,0x13:-9.5dB
  488.      tmp_var++;
  489.      else if(tmp_var>=0x14 && tmp_var<=0x31)//0x14:-10dB,0x31:-24.5dB
  490.          tmp_var += 2;
  491.      else if(tmp_var>=0x32 && tmp_var<=0x6b)//0x32:-25dB,0x6b:-53dB
  492.      tmp_var += 4;
  493.      }
  494.      if(amp_lev[0]==1)
  495.      tmp_var = 0x6b;//-53dB
  496.      else if(amp_lev[0]==0)
  497.      tmp_var = 0xff;
  498. vol_gain[0] = tmp_var;
  499.      WriteToI2c(DDX8K_ADDR,MASTER_VOL_REG,&tmp_var,1);
  500. #ifdef SUPPORT_SAVE_AMPLIFIER_STATUS
  501. iRts = WriteToI2c(0xa0,AMPLIFIER_START,&amp_lev[0],1);    
  502. iRts = WriteToI2c(0xa0,AMPLIFIER_START+9,&tmp_var,1);
  503. #endif
  504. //     ddx_masterMute(0);
  505.     }
  506. }
  508. //Set Master Volume Gain
  509. void ddx_setMVG(BYTE chAddr,BYTE ctrl)
  510. {
  511. WriteToI2c(DDX8K_ADDR,chAddr,&ctrl,1);
  512. }
  513. //input:
  514. /*
  515. chAddr:  channel volume regsiter address
  516. updown:  1---boost,  -1---cut
  517. */
  518. #ifdef AMPVOL_ADJUST_TYPE1//xyy 2004-5-25
  519. void ddx_channel_volume_adjust(BYTE chAddr,int updown)
  520. {
  521. //    UINT16      romSum=0;
  522.     BYTE tmp_var;
  524. // ddx_masterMute(1);
  525. ReadFromI2c(DDX8K_ADDR,chAddr,&tmp_var,1);
  526. if(updown==1)
  527. {
  528. if(tmp_var>0x00)
  529.     tmp_var -= 2;
  530. }
  531. else if(updown==-1)
  532. {
  533. if(tmp_var<0x28)
  534.     tmp_var += 2;
  535. }
  536. vol_gain[channelNm] = tmp_var;
  537. WriteToI2c(DDX8K_ADDR,chAddr,&tmp_var,1);
  538. #ifdef SUPPORT_SAVE_AMPLIFIER_STATUS //xyy 2004-3-6 10:16
  539. WriteToI2c(0xa0,AMPLIFIER_START+channelNm,&amp_lev[channelNm],1);    
  540. WriteToI2c(0xa0,AMPLIFIER_START+(9+channelNm),&tmp_var,1);
  541. #endif
  542. // ddx_masterMute(0);
  543. }
  545. #else
  546. void ddx_channel_volume_adjust(BYTE chAddr,int updown)
  547. {
  548. //    UINT16      romSum=0;
  549.     BYTE tmp_var;
  551. // ddx_masterMute(1);
  552. ReadFromI2c(DDX8K_ADDR,chAddr,&tmp_var,1);
  553. if(updown==1)
  554. {
  555.      if(tmp_var>0x00 && tmp_var<=0x13)//0x00:24dB,0x13:14.5dB
  556.      tmp_var--;
  557.      else if(tmp_var>=0x14 && tmp_var<=0x31)//0x14:14dB,0x31:-0.5dB
  558.          tmp_var -= 2;
  559.      else if(tmp_var>=0x32 && tmp_var<=0x6e)//0x32:-1dB,0x6b:-30.5dB
  560.      tmp_var -= 4;
  561. }
  562. else if(updown==-1)
  563. {
  564.      if(tmp_var>=0x00 && tmp_var<=0x13)//0x00:24dB,0x13:14.5dB
  565.      tmp_var++;
  566.      else if(tmp_var>=0x14 && tmp_var<=0x31)//0x14:14dB,0x31:-0.5dB
  567.          tmp_var += 2;
  568.      else if(tmp_var>=0x32 && tmp_var<=0x6e)//0x32:-1dB,0x6b:-30.5dB
  569.      tmp_var += 4;
  570. }
  571. vol_gain[y_index] = tmp_var;
  572. WriteToI2c(DDX8K_ADDR,chAddr,&tmp_var,1);
  573. #ifdef SUPPORT_SAVE_AMPLIFIER_STATUS //xyy 2004-3-6 10:16
  574. WriteToI2c(0xa0,AMPLIFIER_START+y_index,&amp_lev[y_index],1);    
  575. WriteToI2c(0xa0,AMPLIFIER_START+(9+y_index),&tmp_var,1);
  576. #endif
  577. // ddx_masterMute(0);
  578. }
  579. #endif
  582. //Set Channel Volume Gain
  583. void ddx_setCVG(BYTE chAddr,BYTE ctrl)
  584. {
  585. WriteToI2c(DDX8K_ADDR,chAddr,&ctrl,1);
  586. }
  588. //all changes in volume take place at digital zero-crossing
  589. //will create the smoothest possible volume transition
  590. void ddx_enZeroCross(void)
  591. {
  592. write_reg_bit(CONFIGREG_B,6,1);
  593. }
  594. void ddx_disZeroCross(void)
  595. {//volume updates immediately
  596. write_reg_bit(CONFIGREG_B,6,0);
  597. }
  599. //Master Volume Mute
  600. //mute all channels simultaneously
  601. //mute   1: mute       0: demute
  602. void ddx_masterMute(BYTE mute)
  603. {
  604. if(mute)
  605. write_reg_bit(MASTER_MUTE_REG,0,1);
  606. else
  607. write_reg_bit(MASTER_MUTE_REG,0,0);
  608. }
  610. //channel mute individually
  611. //mute   1: mute       0: demute
  612. void ddx_channelMute(BYTE chNum,BYTE mute)
  613. {
  614. if(mute)
  615. write_reg_bit(CHANEL_MUTE_REG,chNum,1);
  616. else
  617. write_reg_bit(CHANEL_MUTE_REG,chNum,0);
  618. }
  620. //Channel Limiter Selection
  621. /*
  622. CxLS(1,0)   Channel Limiter Mapping
  623. -------------------------------------------
  624.    00       Channel has limiting disabled
  625.    01       Channel is mapped to limiter #1
  626.    10       Channel is mapped to limiter #2
  627.    11       Reserved.Don't use this setting
  628. --------------------------------------------
  629. */
  630. void ddx_ch1_limiterSel(BYTE selCtrl)
  631. {
  632. BYTE data;
  633. ReadFromI2c(DDX8K_ADDR,CLIMITER_SEL0,&data,1);
  634. data = selCtrl | (data & 0xfc); 
  635. if(selCtrl<0x03)
  636. WriteToI2c(DDX8K_ADDR,CLIMITER_SEL0,&data,1);
  637. }
  639. void ddx_ch2_limiterSel(BYTE selCtrl)
  640. {
  641. BYTE data;
  642. ReadFromI2c(DDX8K_ADDR,CLIMITER_SEL0,&data,1);
  643. data = (selCtrl << 2) | (data & 0xf3); 
  644. if(selCtrl<0x03)
  645. WriteToI2c(DDX8K_ADDR,CLIMITER_SEL0,&data,1);
  646. }
  648. void ddx_ch3_limiterSel(BYTE selCtrl)
  649. {
  650. BYTE data;
  651. ReadFromI2c(DDX8K_ADDR,CLIMITER_SEL0,&data,1);
  652. data = (selCtrl << 4) | (data & 0xcf); 
  653. if(selCtrl<0x03)
  654. WriteToI2c(DDX8K_ADDR,CLIMITER_SEL0,&data,1);
  655. }
  656. void ddx_ch4_limiterSel(BYTE selCtrl)
  657. {
  658. BYTE data;
  659. ReadFromI2c(DDX8K_ADDR,CLIMITER_SEL0,&data,1);
  660. data = (selCtrl << 6) | (data & 0x3f); 
  661. if(selCtrl<0x03)
  662. WriteToI2c(DDX8K_ADDR,CLIMITER_SEL0,&data,1);
  663. }
  664. void ddx_ch5_limiterSel(BYTE selCtrl)
  665. {
  666. BYTE data;
  667. ReadFromI2c(DDX8K_ADDR,CLIMITER_SEL1,&data,1);
  668. data = selCtrl | (data & 0xfc); 
  669. if(selCtrl<0x03)
  670. WriteToI2c(DDX8K_ADDR,CLIMITER_SEL1,&data,1);
  671. }
  673. void ddx_ch6_limiterSel(BYTE selCtrl)
  674. {
  675. BYTE data;
  676. ReadFromI2c(DDX8K_ADDR,CLIMITER_SEL1,&data,1);
  677. data = (selCtrl << 2) | (data & 0xf3); 
  678. if(selCtrl<0x03)
  679. WriteToI2c(DDX8K_ADDR,CLIMITER_SEL1,&data,1);
  680. }
  682. void ddx_ch7_limiterSel(BYTE selCtrl)
  683. {
  684. BYTE data;
  685. ReadFromI2c(DDX8K_ADDR,CLIMITER_SEL1,&data,1);
  686. data = (selCtrl << 4) | (data & 0xcf); 
  687. if(selCtrl<0x03)
  688. WriteToI2c(DDX8K_ADDR,CLIMITER_SEL1,&data,1);
  689. }
  690. void ddx_ch8_limiterSel(BYTE selCtrl)
  691. {
  692. BYTE data;
  693. ReadFromI2c(DDX8K_ADDR,CLIMITER_SEL1,&data,1);
  694. data = (selCtrl << 6) | (data & 0x3f); 
  695. if(selCtrl<0x03)
  696. WriteToI2c(DDX8K_ADDR,CLIMITER_SEL1,&data,1);
  697. }
  699. //Set Compression and Release Rates of Limiter
  700. void ddx_setL1CRrates(BYTE ctrl)
  701. {
  702. WriteToI2c(DDX8K_ADDR,L1RATE_REG,&ctrl,1);
  703. }
  705. void ddx_setL2CRrates(BYTE ctrl)
  706. {
  707. WriteToI2c(DDX8K_ADDR,L2RATE_REG,&ctrl,1);
  708. }
  710. //Set Compression and Release Threshold of Limiter
  711. void ddx_setL1CRthreshold(BYTE ctrl)
  712. {
  713. WriteToI2c(DDX8K_ADDR,L1THRESHOLDS_REG,&ctrl,1);
  714. }
  716. void ddx_setL2CRthreshold(BYTE ctrl)
  717. {
  718. WriteToI2c(DDX8K_ADDR,L2THRESHOLDS_REG,&ctrl,1);
  719. }
  721. //Set Dynamic Range Compression mode
  722. //drc: 1----Dynamic Range Compression mode
  723. //     0----Anti-Clipping Mode(default)
  724. void ddx_setDRCmode(BYTE drc)
  725. {
  726. write_reg_bit(CONFIGREG_B,7,drc);
  727. }
  729. //Set Max Power Correction
  730. void ddx_setMPC(void)
  731. {
  732. write_reg_bit(CONFIGREG_A,7,1);
  733. }
  734. //Head Phone Enable or Disable
  735. void ddx_enHeadPhone(void)
  736. {
  737. write_reg_bit(CONFIGREG_A,6,1);
  738. }
  739. void ddx_disHeadPhone(void)
  740. {
  741. write_reg_bit(CONFIGREG_A,6,0);
  742. }
  744. //AM Mode Enable or Disable
  745. void ddx_enableAM_mode(void)
  746. {
  747. write_reg_bit(CONFIGREG_F,3,1);
  748. }
  749. void ddx_disableAM_mode(void)
  750. {
  751. write_reg_bit(CONFIGREG_F,3,0);
  752. }
  754. //Initialize volume gain
  755. #if defined(DDX8000_BINARY_MODE) || defined(XINGQIU_BINARY_MODE)
  756. void ddx_set_BassManagement(void)
  757. {
  758. coef_factor bass_coef;
  759. //set channel 7,5,4,2,1 pre-scale factor
  760. //set channel 2,4,7,5,1 pre-scale factor
  761.     ddx_writeCoefVal(0xd6,FL_SCALE_FACTOR); 
  762.     ddx_writeCoefVal(0xd4,FR_SCALE_FACTOR);
  763.     ddx_writeCoefVal(0xd3,SL_SCALE_FACTOR);
  764.     ddx_writeCoefVal(0xd1,SR_SCALE_FACTOR);
  765.     ddx_writeCoefVal(0xd0,CE_SCALE_FACTOR);
  766.     ddx_writeCoefVal(0xd5,LFE_SCALE_FACTOR);
  767.     
  768. //set channel 7,5,4,2,1 filter coefficient
  769. bass_coef.b2 = HPF_COEF_B2;
  770. bass_coef.b0 = HPF_COEF_B0;
  771. bass_coef.a2 = HPF_COEF_A2;
  772. bass_coef.a1 = HPF_COEF_A1;
  773. bass_coef.b1 = HPF_COEF_B1;
  774. ddx_writeCoefValSets(0x96,bass_coef);  //channel 7    
  775. ddx_writeCoefValSets(0x64,bass_coef);  //channel 5
  776. ddx_writeCoefValSets(0x4b,bass_coef);  //channel 4
  777. ddx_writeCoefValSets(0x19,bass_coef);  //channel 2
  778. ddx_writeCoefValSets(0x00,bass_coef);  //channel 1
  780. //set channel 6 filter coefficient
  781. bass_coef.b2 = LPF_COEF_B2;
  782. bass_coef.b0 = LPF_COEF_B0;
  783. bass_coef.a2 = LPF_COEF_A2;
  784. bass_coef.a1 = LPF_COEF_A1;
  785. bass_coef.b1 = LPF_COEF_B1;
  786. ddx_writeCoefValSets(0x7d,bass_coef);
  787. }
  789. void ddx_init_volumeGain(void)
  790. {
  791. #if defined(DDX8000_BINARY_MODE)
  792. ddx_setMVG(MASTER_VOL_REG,vol_gain[0]);
  793. ddx_setCVG(C7V_REG,vol_gain[1]);
  794. ddx_setCVG(C5V_REG,vol_gain[2]);
  795. ddx_setCVG(C4V_REG,vol_gain[3]);
  796. ddx_setCVG(C2V_REG,vol_gain[4]);
  797. ddx_setCVG(C1V_REG,vol_gain[5]);
  798. ddx_setCVG(C6V_REG,vol_gain[6]);
  799. ddx_setCVG(C3V_REG,0xff);
  800. ddx_setCVG(C8V_REG,0xff);
  801. #elif defined(XINGQIU_BINARY_MODE)
  802. ddx_setMVG(MASTER_VOL_REG,vol_gain[0]);
  803. ddx_setCVG(C2V_REG,vol_gain[1]);
  804. ddx_setCVG(C4V_REG,vol_gain[2]);
  805. ddx_setCVG(C7V_REG,vol_gain[3]);
  806. ddx_setCVG(C5V_REG,vol_gain[4]);
  807. ddx_setCVG(C1V_REG,vol_gain[5]);
  808. ddx_setCVG(C6V_REG,vol_gain[6]);
  809. ddx_setCVG(C3V_REG,0xff);
  810. ddx_setCVG(C8V_REG,0xff);
  811. #endif
  812. }
  813. #else
  814. void ddx_set_BassManagement(void)
  815. {
  816. coef_factor bass_coef;
  817. //set pre-scale factor
  818.     ddx_writeCoefVal(0xd0,FL_SCALE_FACTOR);
  820.     ddx_writeCoefVal(0xd1,FR_SCALE_FACTOR);
  822.     ddx_writeCoefVal(0xd2,SL_SCALE_FACTOR);
  824.     ddx_writeCoefVal(0xd3,SL_SCALE_FACTOR);
  826.     ddx_writeCoefVal(0xd4,CE_SCALE_FACTOR);
  828.     ddx_writeCoefVal(0xd5,LFE_SCALE_FACTOR);
  829.     
  830. //set channel 1,2,3,4,5 filter coefficient
  831. bass_coef.b2 = HPF_COEF_B2;
  832. bass_coef.b0 = HPF_COEF_B0;
  833. bass_coef.a2 = HPF_COEF_A2;
  834. bass_coef.a1 = HPF_COEF_A1;
  835. bass_coef.b1 = HPF_COEF_B1;
  836. ddx_writeCoefValSets(0x00,bass_coef);
  837. ddx_writeCoefValSets(0x19,bass_coef);
  838. ddx_writeCoefValSets(0x32,bass_coef);
  839. ddx_writeCoefValSets(0x4b,bass_coef);
  840. ddx_writeCoefValSets(0x64,bass_coef);
  842. //set channel 6 filter coefficient
  843. bass_coef.b2 = LPF_COEF_B2;
  844. bass_coef.b0 = LPF_COEF_B0;
  845. bass_coef.a2 = LPF_COEF_A2;
  846. bass_coef.a1 = LPF_COEF_A1;
  847. bass_coef.b1 = LPF_COEF_B1;
  848. ddx_writeCoefValSets(0x7d,bass_coef);
  849. }
  851. void ddx_init_volumeGain(void)
  852. {
  853. //set volume gain 
  854. // ddx_setMVG(MASTER_VOL_REG,0x2c/*-20dB*/);
  855. // ddx_setMVG(MASTER_VOL_REG,0x3c/*-30dB*/);
  856. ddx_setMVG(MASTER_VOL_REG,vol_gain[0]);
  857. ddx_setCVG(C1V_REG,vol_gain[1]);
  858. ddx_setCVG(C2V_REG,vol_gain[2]);
  859. ddx_setCVG(C3V_REG,vol_gain[3]);
  860. ddx_setCVG(C4V_REG,vol_gain[4]);
  861. ddx_setCVG(C5V_REG,vol_gain[5]);
  862. ddx_setCVG(C6V_REG,vol_gain[6]);
  863. ddx_setCVG(C7V_REG,0xff);
  864. ddx_setCVG(C8V_REG,0xff);
  866. }
  867. #endif
  869. void ddx_set_biquad_iir_filter_coef(BYTE addr,BYTE top,BYTE mid,BYTE bot)
  870. {
  871. #if 1
  872. BYTE data;
  874. NOP;
  875. data = addr;
  876. WriteToI2c(DDX8K_ADDR,0x1c,&data,1);
  877. data = top;
  878. WriteToI2c(DDX8K_ADDR,0x1d,&data,1);
  879. data = mid;
  880. WriteToI2c(DDX8K_ADDR,0x1e,&data,1);
  881. data = bot;
  882. WriteToI2c(DDX8K_ADDR,0x1f,&data,1);
  883. data = 0x01;
  884. WriteToI2c(DDX8K_ADDR,0x2c,&data,1);
  885. #endif
  887. }
  889. void ddx_set_biquad_iir_filter()
  890. {
  891. int index = 0;
  892. do{
  893. ddx_set_biquad_iir_filter_coef(index,0x7f,0x8e,0x71);
  894. ddx_set_biquad_iir_filter_coef((index+1),0x3f,0xc7,0x38);
  895. ddx_set_biquad_iir_filter_coef((index+2),0x80,0xe2,0xb9);
  896. ddx_set_biquad_iir_filter_coef((index+3),0x7f,0x8e,0x3e);
  897. ddx_set_biquad_iir_filter_coef((index+4),0x80,0x71,0x8f);
  898. index += 5;
  899. }while (index <= 125);
  902. ddx_set_biquad_iir_filter_coef(126,0x00,0x00,0x8c);
  903. ddx_set_biquad_iir_filter_coef(127,0x00,0x00,0x46);
  904. ddx_set_biquad_iir_filter_coef(128,0x81,0x7a,0x80);
  905. ddx_set_biquad_iir_filter_coef(129,0x7f,0x41,0xa7);
  906. ddx_set_biquad_iir_filter_coef(130,0x00,0x00,0x8c);
  907. }
  910. //Initialization
  911. void ddx_initialization(void)
  912. {
  913. int res;
  914. BYTE data;
  915. //printf("ddx_initialization()n");
  917. /*
  918. before write cmd to initiate the amplifier,we should confirm its existence first!
  919. huziqin 2004-1-14
  920. */
  921. res = ReadFromI2c(DDX8K_ADDR,0,&data,1);
  922. if(res<0)
  923. {
  924. printf("fail to init ddx or there is no ddx!! ret n");
  925. return;
  926. }
  928. enable_hpf();
  929.        //NOP;
  930. set_inputClock(0x00,0x03);//256Fs
  931. //NOP;
  932. //set input data format
  933. //set input data format   :DVD,VCD,MP3,CD,
  934. #if defined(WM8746)//Right-Justified 24-bit Data
  935. set_inputData_format(0x05);
  936. #elif defined(WM8746I2S24) || defined(USE_DAC_I2S24)//I2S 24-bit Data
  937. set_inputData_format(0x00);
  938. #endif
  939. // BYTE data = 0x27;
  940. // WriteToI2c(DDX8K_ADDR,0x03,&data,1);
  942. //enable bass management
  943. //ddx_enable_BassManagement();
  944. //Enable Zero Crossing
  945. //ddx_enZeroCross();
  946. //set Anti-clipping Mode for 5.1 Channels
  947. //ddx_setDRCmode(0);
  948. #ifdef SUPPORT_SAVE_AMPLIFIER_STATUS
  949. load_amplifier_status_from_e2prom();
  950. #endif
  953. //initialize volume gain
  954. ddx_init_volumeGain();
  956. //This function cause crash when the amplifier is not connected.
  957. // ddx_set_biquad_iir_filter();
  959. #if defined(DDX8000_BINARY_MODE)
  960. data=0x2f;              
  961. WriteToI2c(DDX8K_ADDR,CONFIGREG_D,&data,1);  
  962.     //channel mapping via I2C
  963.     //output: 7 5 4 2 1 6=====input: 1 2 3 4 5 6
  964. data = 0x34;        
  965. WriteToI2c(DDX8K_ADDR,C12MAP_REG,&data,1);
  966. data = 0x20;
  967. WriteToI2c(DDX8K_ADDR,C34MAP_REG,&data,1);
  968. data = 0x51;
  969. WriteToI2c(DDX8K_ADDR,C56MAP_REG,&data,1);
  970. data = 0x00;
  971. WriteToI2c(DDX8K_ADDR,C78MAP_REG,&data,1);
  973. #elif defined(XINGQIU_BINARY_MODE)//xyy 2004-3-31
  974. data=0x2f;              
  975. WriteToI2c(DDX8K_ADDR,CONFIGREG_D,&data,1);  
  976.     //channel mapping via I2C
  977.     //input: 1 2 3 4 5 6=====output: 2 4 7 5 1 6
  978. data = 0x04;        
  979. WriteToI2c(DDX8K_ADDR,C12MAP_REG,&data,1);
  980. data = 0x10;
  981. WriteToI2c(DDX8K_ADDR,C34MAP_REG,&data,1);
  982. data = 0x53;
  983. WriteToI2c(DDX8K_ADDR,C56MAP_REG,&data,1);
  984. data = 0x02;
  985. WriteToI2c(DDX8K_ADDR,C78MAP_REG,&data,1);
  987. #endif
  989. //set bass management
  990. //ddx_set_BassManagement();
  991. //limiter selection: channel 1,2,3,4,5 select limiter 1
  992. //channel 6 select limiter 2
  993. ddx_ch7_limiterSel(0x01);//unmark by xyy 2004-4-29 
  994. ddx_ch4_limiterSel(0x01);
  995. ddx_ch5_limiterSel(0x01);
  996. ddx_ch2_limiterSel(0x01);
  997. ddx_ch1_limiterSel(0x01);
  998. ddx_ch6_limiterSel(0x02);
  999. //set limiter 1,2 Attack Rate and Release Rate
  1000. ddx_setL1CRrates(0xa4);
  1001. ddx_setL2CRrates(0xf7);
  1002. //set limiter 1,2 Attack Threshold and Release Threshold
  1003. ddx_setL1CRthreshold(0x76);
  1004. ddx_setL2CRthreshold(0x76);
  1006. // write_reg_bit(0x30,
  1007. // BYTE data = 0x00;
  1008. // WriteToI2c(DDX8K_ADDR,0x03,&data,1);
  1009. //unmute all channels
  1010. // ddx_enableAM_mode();
  1011. /* NOP;
  1012. ddx_masterMute(0);
  1013. NOP;
  1014. ddx_enableEPAD();
  1015. */
  1016. }
  1018. void ddx_ampvol_func_left(void);
  1019. void ddx_ampvol_func_right(void);
  1020. void ddx_ampvol_func_up(void);
  1021. void ddx_ampvol_func_down(void);
  1023. void ddx_volume_adjust(UINT32 key)
  1024. {
  1025. switch(key)
  1026. {
  1027. case IRC_UP:
  1028. ddx_ampvol_func_up();
  1029. break;
  1030. case IRC_DOWN:
  1031. ddx_ampvol_func_down();
  1032. break;
  1033. case IRC_LEFT:
  1034. ddx_ampvol_func_left();
  1035. break;
  1036. case IRC_RIGHT:
  1037. ddx_ampvol_func_right();
  1038. break;
  1039. }
  1040. }
  1043. /*****************************************
  1044. /Function: ddx_Set_EQ()
  1045. /Description: Set coefficient values of biquads for preset EQ settings. 
  1046. /Creator: xulf
  1047. /Date: 2003-12-27
  1048. ****************************************/
  1049. #ifdef AMP_SUPPORT_EQ
  1050. void ddx_Set_EQ(BYTE EQtype)
  1051. {
  1052.     coef_factor biquad_coef;
  1053. //    ddx_disableEPAD();   //EAPD
  1054.     ddx_masterMute(1);  //mute all channels
  1055.     switch(EQtype)
  1056.     {
  1057. case NONE:
  1058.     //set the channel pre-scale. 
  1059.     ddx_writeCoefVal(0xc8,0xe36809);  //channel 1 
  1060.      biquad_coef.b2 = 0x000000;
  1061.     biquad_coef.b0 = 0x3fffff;
  1062.     biquad_coef.a2 = 0x000000;
  1063.     biquad_coef.a1 = 0x000000;
  1064.     biquad_coef.b1 = 0x000000;
  1065.     ddx_writeCoefValSets(0x05,biquad_coef);  //channel 1 biquad2
  1066.     ddx_writeCoefValSets(0x0a,biquad_coef);  //channel 1 biquad3     
  1067.     ddx_writeCoefValSets(0x0f,biquad_coef);  //channel 1 biquad4     
  1068.     ddx_writeCoefValSets(0x14,biquad_coef);  //channel 1 biquad5
  1069.     //each channel uses channel 1 coefficient values.
  1070.      write_reg_bit(CONFIGREG_D,7,1); 
  1071.     break;
  1072. case ROCK:
  1073.     ddx_writeCoefVal(0xc8,0xaf3cc5);  //channel 1 
  1074.     biquad_coef.b2 = 0x7fcf05;
  1075.     biquad_coef.b0 = 0x40058a;
  1076.     biquad_coef.a2 = 0x8025e6;
  1077.     biquad_coef.a1 = 0x7fed02;
  1078.     biquad_coef.b1 = 0x8012fe;
  1079.     ddx_writeCoefValSets(0x05,biquad_coef);  //channel 1 biquad2
  1080.      biquad_coef.b2 = 0x7fd80a;
  1081.     biquad_coef.b0 = 0x4006a3;
  1082.     biquad_coef.a2 = 0x801aaf;
  1083.     biquad_coef.a1 = 0x7ff28c;
  1084.     biquad_coef.b1 = 0x800d74;
  1085.     ddx_writeCoefValSets(0x0a,biquad_coef);  //channel 1 biquad3     
  1086.      biquad_coef.b2 = 0x7ead9f;
  1087.     biquad_coef.b0 = 0x3fc7c8;
  1088.     biquad_coef.a2 = 0x81c2d0;
  1089.     biquad_coef.a1 = 0x7f1d06;
  1090.     biquad_coef.b1 = 0x80e2fa;
  1091.     ddx_writeCoefValSets(0x0f,biquad_coef);  //channel 1 biquad4     
  1092.      biquad_coef.b2 = 0x5d3dab;
  1093.     biquad_coef.b0 = 0x46a5ae;
  1094.     biquad_coef.a2 = 0x9576f8;
  1095.     biquad_coef.a1 = 0x714597;
  1096.     biquad_coef.b1 = 0x8eba69;
  1097.     ddx_writeCoefValSets(0x14,biquad_coef);  //channel 1 biquad5
  1098.     //each channel uses channel 1 coefficient values.
  1099.      write_reg_bit(CONFIGREG_D,7,1); 
  1100.     break;
  1101. case POP:
  1102.     ddx_writeCoefVal(0xc8,0xdb759b);  //channel 1 
  1103.      biquad_coef.b2 = 0x7fe781;
  1104.     biquad_coef.b0 = 0x3ffd3a;
  1105.     biquad_coef.a2 = 0x801e09;
  1106.     biquad_coef.a1 = 0x7ff0f8;
  1107.     biquad_coef.b1 = 0x800f08;
  1108.     ddx_writeCoefValSets(0x05,biquad_coef);  //channel 1 biquad2
  1109.      biquad_coef.b2 = 0x7cc19b;
  1110.     biquad_coef.b0 = 0x40e89e;
  1111.     biquad_coef.a2 = 0x816d29;
  1112.     biquad_coef.a1 = 0x7f40df;
  1113.     biquad_coef.b1 = 0x80bf21;
  1114.     ddx_writeCoefValSets(0x0a,biquad_coef);  //channel 1 biquad3     
  1115.      biquad_coef.b2 = 0x640c0d;
  1116.     biquad_coef.b0 = 0x3cd666;
  1117.     biquad_coef.a2 = 0xa24727;
  1118.     biquad_coef.a1 = 0x6cbb1a;
  1119.     biquad_coef.b1 = 0x9344e6;
  1120.     ddx_writeCoefValSets(0x0f,biquad_coef);  //channel 1 biquad4     
  1121.      biquad_coef.b2 = 0x4274ad;
  1122.     biquad_coef.b0 = 0x37613b;
  1123.     biquad_coef.a2 = 0xcec8dd;
  1124.     biquad_coef.a1 = 0x4cbc8c;
  1125.     biquad_coef.b1 = 0xb34374;
  1126.     ddx_writeCoefValSets(0x14,biquad_coef);  //channel 1 biquad5
  1127.     //each channel uses channel 1 coefficient values.
  1128.      write_reg_bit(CONFIGREG_D,7,1); 
  1129.     break;
  1130. case PARTY:
  1131.     ddx_writeCoefVal(0xc8,0xe4a917);  //channel 1 
  1132.      biquad_coef.b2 = 0x7fc83b;
  1133.     biquad_coef.b0 = 0x400e7c;
  1134.     biquad_coef.a2 = 0x801acd;
  1135.     biquad_coef.a1 = 0x7ff297;
  1136.     biquad_coef.b1 = 0x800d69;
  1137.     ddx_writeCoefValSets(0x05,biquad_coef);  //channel 1 biquad2
  1138.      biquad_coef.b2 = 0x7f4db3;
  1139.     biquad_coef.b0 = 0x402e50;
  1140.     biquad_coef.a2 = 0x8055ad;
  1141.     biquad_coef.a1 = 0x7fd50c;
  1142.     biquad_coef.b1 = 0x802af4;
  1143.     ddx_writeCoefValSets(0x0a,biquad_coef);  //channel 1 biquad3     
  1144.      biquad_coef.b2 = 0x7908a0;
  1145.     biquad_coef.b0 = 0x412849;
  1146.     biquad_coef.a2 = 0x84a6cc;
  1147.     biquad_coef.a1 = 0x7d8082;
  1148.     biquad_coef.b1 = 0x827f7e;
  1149.     ddx_writeCoefValSets(0x0f,biquad_coef);  //channel 1 biquad4     
  1150.      biquad_coef.b2 = 0x2688b9;
  1151.     biquad_coef.b0 = 0x4edd22;
  1152.     biquad_coef.a2 = 0xbbbd01;
  1153.     biquad_coef.a1 = 0x4dda39;
  1154.     biquad_coef.b1 = 0xb225c7;
  1155.     ddx_writeCoefValSets(0x14,biquad_coef);  //channel 1 biquad5
  1156.     //each channel uses channel 1 coefficient values.
  1157.      write_reg_bit(CONFIGREG_D,7,1); 
  1158.     break;
  1159.     case DANCE:
  1160.     ddx_writeCoefVal(0xc8,0xddef46);  //channel 1 
  1161.      biquad_coef.b2 = 0x7fd0f2;
  1162.     biquad_coef.b0 = 0x400a20;
  1163.     biquad_coef.a2 = 0x801acd;
  1164.     biquad_coef.a1 = 0x7ff297;
  1165.     biquad_coef.b1 = 0x800d69;
  1166.     ddx_writeCoefValSets(0x05,biquad_coef);  //channel 1 biquad2
  1167.      biquad_coef.b2 = 0x7f2132;
  1168.     biquad_coef.b0 = 0x4039df;
  1169.     biquad_coef.a2 = 0x806b0f;
  1170.     biquad_coef.a1 = 0x7fca4b;
  1171.     biquad_coef.b1 = 0x8035b5;
  1172.     ddx_writeCoefValSets(0x0a,biquad_coef);  //channel 1 biquad3     
  1173.      biquad_coef.b2 = 0x7a469f;
  1174.     biquad_coef.b0 = 0x40cd3f;
  1175.     biquad_coef.a2 = 0x841ee2;
  1176.     biquad_coef.a1 = 0x7ddf4c;
  1177.     biquad_coef.b1 = 0x8220b4;
  1178.     ddx_writeCoefValSets(0x0f,biquad_coef);  //channel 1 biquad4     
  1179.      biquad_coef.b2 = 0x2ca6df;
  1180.     biquad_coef.b0 = 0x4dd8f0;
  1181.     biquad_coef.a2 = 0xb7a741;
  1182.     biquad_coef.a1 = 0x534a84;
  1183.     biquad_coef.b1 = 0xacb57c;
  1184.     ddx_writeCoefValSets(0x14,biquad_coef);  //channel 1 biquad5
  1185.     //each channel uses channel 1 coefficient values.
  1186.      write_reg_bit(CONFIGREG_D,7,1); 
  1187.     break;
  1188. case HARD:
  1189.     ddx_writeCoefVal(0xc8,0xdfd91e);  //channel 1 
  1190.      biquad_coef.b2 = 0x7fdeb7;
  1191.     biquad_coef.b0 = 0x400729;
  1192.     biquad_coef.a2 = 0x8012f5;
  1193.     biquad_coef.a1 = 0x7ff683;
  1194.     biquad_coef.b1 = 0x80097d;
  1195.     ddx_writeCoefValSets(0x05,biquad_coef);  //channel 1 biquad2
  1196.      biquad_coef.b2 = 0x7fbd74;
  1197.     biquad_coef.b0 = 0x400e52;
  1198.     biquad_coef.a2 = 0x8025e6;
  1199.     biquad_coef.a1 = 0x7fed02;
  1200.     biquad_coef.b1 = 0x8012fe;
  1201.     ddx_writeCoefValSets(0x0a,biquad_coef);  //channel 1 biquad3     
  1202.      biquad_coef.b2 = 0x007c0c;
  1203.     biquad_coef.b0 = 0x662860;
  1204.     biquad_coef.a2 = 0xb33334;
  1205.     biquad_coef.a1 = 0x58ae56;
  1206.     biquad_coef.b1 = 0xa751aa;
  1207.     ddx_writeCoefValSets(0x0f,biquad_coef);  //channel 1 biquad4     
  1208.      biquad_coef.b2 = 0x000000;
  1209.     biquad_coef.b0 = 0x3fffff;
  1210.     biquad_coef.a2 = 0x000000;
  1211.     biquad_coef.a1 = 0x000000;
  1212.     biquad_coef.b1 = 0x000000;
  1213.     ddx_writeCoefValSets(0x14,biquad_coef);  //channel 1 biquad5
  1214.     //each channel uses channel 1 coefficient values.
  1215.      write_reg_bit(CONFIGREG_D,7,1);      
  1216.     break;
  1217. case CLASSIC:
  1218.     ddx_writeCoefVal(0xc8,0xaf3cc5);  //channel 1 
  1219.      biquad_coef.b2 = 0x7f4977;
  1220.     biquad_coef.b0 = 0x400f9b;
  1221.     biquad_coef.a2 = 0x809753;
  1222.     biquad_coef.a1 = 0x7fb3a3;
  1223.     biquad_coef.b1 = 0x804c5d;
  1224.     ddx_writeCoefValSets(0x05,biquad_coef);  //channel 1 biquad2
  1225.      biquad_coef.b2 = 0x7b9d6f;
  1226.     biquad_coef.b0 = 0x40ba80;
  1227.     biquad_coef.a2 = 0x82ed90;
  1228.     biquad_coef.a1 = 0x7e77e0;
  1229.     biquad_coef.b1 = 0x818820;
  1230.     ddx_writeCoefValSets(0x0a,biquad_coef);  //channel 1 biquad3     
  1231.      biquad_coef.b2 = 0x4e4a5f;
  1232.     biquad_coef.b0 = 0x459fbc;
  1233.     biquad_coef.a2 = 0xa67628;
  1234.     biquad_coef.a1 = 0x5e3269;
  1235.     biquad_coef.b1 = 0xa1cd97;
  1236.     ddx_writeCoefValSets(0x0f,biquad_coef);  //channel 1 biquad4     
  1237.      biquad_coef.b2 = 0x000000;
  1238.     biquad_coef.b0 = 0x3fffff;
  1239.     biquad_coef.a2 = 0x000000;
  1240.     biquad_coef.a1 = 0x000000;
  1241.     biquad_coef.b1 = 0x000000;
  1242.     ddx_writeCoefValSets(0x14,biquad_coef);  //channel 1 biquad5
  1243.     //each channel uses channel 1 coefficient values.
  1244.      write_reg_bit(CONFIGREG_D,7,1); 
  1245.     break;
  1246. case SOFT:
  1247.     ddx_writeCoefVal(0xc8,0xd77b6);  //channel 1 
  1248.      biquad_coef.b2 = 0x7fdd5d;
  1249.     biquad_coef.b0 = 0x4003eb;
  1250.     biquad_coef.a2 = 0x801acd;
  1251.     biquad_coef.a1 = 0x7ff297;
  1252.     biquad_coef.b1 = 0x800d69;
  1253.     ddx_writeCoefValSets(0x05,biquad_coef);  //channel 1 biquad2
  1254.      biquad_coef.b2 = 0x7fa8c6;
  1255.     biquad_coef.b0 = 0x4009de;
  1256.     biquad_coef.a2 = 0x80437d;
  1257.     biquad_coef.a1 = 0x7fde2f;
  1258.     biquad_coef.b1 = 0x8021d1;
  1259.     ddx_writeCoefValSets(0x0a,biquad_coef);  //channel 1 biquad3     
  1260.      biquad_coef.b2 = 0x7d21e7;
  1261.     biquad_coef.b0 = 0x3f992d;
  1262.     biquad_coef.a2 = 0x83abbd;
  1263.     biquad_coef.a1 = 0x7e25ce;
  1264.     biquad_coef.b1 = 0x81da32;
  1265.     ddx_writeCoefValSets(0x0f,biquad_coef);  //channel 1 biquad4     
  1266.      biquad_coef.b2 = 0x157218;
  1267.     biquad_coef.b0 = 0x5bad59;
  1268.     biquad_coef.a2 = 0xb33334;
  1269.     biquad_coef.a1 = 0x58ae56;
  1270.     biquad_coef.b1 = 0xa751aa;
  1271.     ddx_writeCoefValSets(0x14,biquad_coef);  //channel 1 biquad5
  1272.     //each channel uses channel 1 coefficient values.
  1273.      write_reg_bit(CONFIGREG_D,7,1); 
  1274.     break;
  1275. default:
  1276.     }
  1277. //    ddx_enableEPAD();   //unEAPD
  1278.     ddx_masterMute(0);  //demute all channels
  1279. }
  1280. #endif
  1283. /******************************************
  1284. /Function: ddx_TunerOutput_VSS()
  1285. /description: Specific stereo to "virtual 5.1 effect" 
  1286. setting for tuner input mode 
  1287. /creator: xulf 
  1288. /date: 2003-12-24
  1289. *****************************************/
  1290. void ddx_TunerOutput_VSS(void)
  1291. {
  1292.     BYTE data;
  1293.     coef_factor bass_coef;
  1294.     
  1295.     ddx_disableEPAD();   //EAPD
  1296.     ddx_masterMute(1);  //mute all channels
  1297.     //disable bass management mode
  1298.     ddx_disable_BassManagement();
  1299.     //enable adjacent channel-mixing mode
  1300.     write_reg_bit(CONFIGREG_E,0,1);
  1302.     //SDI_12-->LT/RT; SDI_34-->0; SDI_56-->0; SDI_78-->0
  1303.     //7 5 4 2 1 6-->FL FR VirtualCE  VirtualSL VirtualSR VirtualSW
  1304. data = 0x01;
  1305. WriteToI2c(DDX8K_ADDR,C12MAP_REG,&data,1);
  1306. data = 0x01;
  1307. WriteToI2c(DDX8K_ADDR,C34MAP_REG,&data,1);
  1308. data = 0x01;
  1309. WriteToI2c(DDX8K_ADDR,C56MAP_REG,&data,1);
  1310. data = 0x00;
  1311. WriteToI2c(DDX8K_ADDR,C78MAP_REG,&data,1);
  1312.     
  1313.     //set pre-scale factor
  1314.     ddx_writeCoefVal(0xd0,0x000000);  //X-Full attenuation
  1315.     ddx_writeCoefVal(0xd1,0x7FFFFF);  //0dB
  1316.     ddx_writeCoefVal(0xd2,0x400000);  //-6dB
  1317.     ddx_writeCoefVal(0xd3,0x400000);
  1318.     ddx_writeCoefVal(0xd4,0x400000);
  1319.     ddx_writeCoefVal(0xd5,0x400000);
  1320.     ddx_writeCoefVal(0xd6,0x000000);
  1321.     
  1322.     //set channel 7,5,4,2,1 filter coefficient
  1323.     bass_coef.b2 = HPF_COEF_B2;
  1324.     bass_coef.b0 = HPF_COEF_B0;
  1325.     bass_coef.a2 = HPF_COEF_A2;
  1326.     bass_coef.a1 = HPF_COEF_A1;
  1327.     bass_coef.b1 = HPF_COEF_B1;
  1328.     ddx_writeCoefValSets(0x96,bass_coef);  //channel 7    xulf 2003-12-15
  1329.     ddx_writeCoefValSets(0x64,bass_coef);  //channel 5
  1330.     ddx_writeCoefValSets(0x4b,bass_coef);  //channel 4
  1331.     ddx_writeCoefValSets(0x19,bass_coef);  //channel 2
  1332.     ddx_writeCoefValSets(0x00,bass_coef);  //channel 1
  1334.     //set channel 6 filter coefficient
  1335.     bass_coef.b2 = LPF_COEF_B2;
  1336.     bass_coef.b0 = LPF_COEF_B0;
  1337.     bass_coef.a2 = LPF_COEF_A2;
  1338.     bass_coef.a1 = LPF_COEF_A1;
  1339.     bass_coef.b1 = LPF_COEF_B1;
  1340.     ddx_writeCoefValSets(0x7d,bass_coef);    
  1342.     ddx_enableEPAD();   //unEAPD
  1343.     ddx_masterMute(0);  //demute all channels
  1344.     
  1345. }