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

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

DVD

开发平台：

C/C++

ddx8000_binary.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"
  19. #define NOP delay_1us(10000)
  20. #define AMP_I2CADDR_START 512
  21. #define BASS_GAIN_ADDR AMP_I2CADDR_START+sizeof(amp_userSet)+1
  22. #define TREBLE_GAIN_ADDR BASS_GAIN_ADDR+1
  23. #define DDX_EQ_TYPE_ADDR TREBLE_GAIN_ADDR+1
  24. #define DDX_REVB_TYPE_ADDR DDX_EQ_TYPE_ADDR+1
  26. int ddx_amp_mode = 0;
  28. extern BYTE * lev_list[7];
  30. BYTE channel_addr[6] = 
  31. {
  32. 0x0f,//front left
  33. 0x0d,//front right
  34. 0x0c,//surround left
  35. 0x0a,//surround right
  36. 0x09,//center
  37. 0x0e//subwoofer
  38. };
  41. //Reset DDX8000
  42. void ddx_reset_all(void)
  43. {
  44. BYTE data;
  45. //Reset Configuration Register A
  46. data = 0x83;
  47. WriteToI2c(DDX8K_ADDR,CONFIGREG_A,&data,1);
  48. //Reset Configuration Register B
  49. data = 0x42;
  50. WriteToI2c(DDX8K_ADDR,CONFIGREG_B,&data,1);
  51. //Reset Configuration Register C
  52. data = 0x7c;
  53. WriteToI2c(DDX8K_ADDR,CONFIGREG_C,&data,1);
  54. //Reset Configuration Register D
  55.        data=0x2f;                //xulf
  56. WriteToI2c(DDX8K_ADDR,CONFIGREG_D,&data,1);
  57. //Reset Configuration Register E
  58. data = 0x02;
  59. WriteToI2c(DDX8K_ADDR,CONFIGREG_E,&data,1);
  60. //Reset Configuration Register F
  61. data = 0x00;
  62. WriteToI2c(DDX8K_ADDR,CONFIGREG_F,&data,1);
  63. //Master Mute
  64. data = 0x00;
  65. WriteToI2c(DDX8K_ADDR,MASTER_MUTE_REG,&data,1);
  66. //Master Volume
  67. data = 0xff;
  68. WriteToI2c(DDX8K_ADDR,MASTER_VOL_REG,&data,1);
  69. //Channel 1,2,3,4,5,6,7,8 mute
  70. data = 0x00;
  71. WriteToI2c(DDX8K_ADDR,CHANEL_MUTE_REG,&data,1);
  72. //Channel 1,2,3,4,5,6,7,8 Volume
  73. data = 0x30;
  74. WriteToI2c(DDX8K_ADDR,C1V_REG,&data,8);
  75. //Channel Input Mapping
  76. data = 0x10;
  77. WriteToI2c(DDX8K_ADDR,C12MAP_REG,&data,1);
  78. data = 0x32;
  79. WriteToI2c(DDX8K_ADDR,C34MAP_REG,&data,1);
  80. data = 0x54;
  81. WriteToI2c(DDX8K_ADDR,C56MAP_REG,&data,1);
  82. data = 0x76;
  83. WriteToI2c(DDX8K_ADDR,C78MAP_REG,&data,1);
  84. //Limiter Selection
  85. data = 0x00;
  86. WriteToI2c(DDX8K_ADDR,CLIMITER_SEL0,&data,2);
  87. //Limiter 1 & 2 Rates and Thresholds
  88. data = 0xa6;
  89. WriteToI2c(DDX8K_ADDR,L1RATE_REG,&data,1);
  90. data = 0x67;
  91. WriteToI2c(DDX8K_ADDR,L1THRESHOLDS_REG,&data,1);
  92. data = 0xa6;
  93. WriteToI2c(DDX8K_ADDR,L2RATE_REG,&data,1);
  94. data = 0x67;
  95. WriteToI2c(DDX8K_ADDR,L2THRESHOLDS_REG,&data,1);
  96. //Tone control
  97. data = 0x77;
  98. WriteToI2c(DDX8K_ADDR,TONE_CTRL_REG,&data,1);
  99. }
  101. void write_reg_bit(int addr,BYTE bit,BYTE val)
  102. {
  103. BYTE tmp = 0;
  104. int res;
  105. res = ReadFromI2c(DDX8K_ADDR,addr,&tmp,1);
  106. NOP;
  107. // printf("11-----------------tmp = :%x,res :%d**********n",tmp,res);
  108. if(val)
  109. tmp |= 0x01<<bit;
  110. else
  111. tmp &= ~(0x01<<bit);
  112. NOP;
  113. res = WriteToI2c(DDX8K_ADDR,addr,&tmp,1);
  114. printf("1addr :%x,tmp = :%x,res :%dn",addr,tmp,res);
  115. NOP;
  117. res = ReadFromI2c(DDX8K_ADDR,addr,&tmp,1);
  118. printf("2addr :%x,tmp = :%x,res :%dn",addr,tmp,res);
  119. }
  121. //Enable or Disable External Amplifier Power Down
  122. void ddx_enableEPAD(void)
  123. {
  124. write_reg_bit(CONFIGREG_F,7,1);
  125. }
  127. void ddx_disableEPAD(void)
  128. {
  129. write_reg_bit(CONFIGREG_F,7,0);
  130. }
  132. /*///////////////////////////////////////////////////////////////
  133. sample_rate     ctrl        input data format
  134.    32fs         ×010        MSB First Right/Left-Justified 16-bit data
  135.    48fs         0001        MSB First Left-Justified Data
  136.                 1001        LSB First Left-Justified Data
  137.                 ×010        Right-Justified 16-bit Data
  138.                 ×011        Right-Justified 18-bit Data
  139.                 ×100        Right-Justified 20-bit Data
  140.                 ×101        Right-Justified 24-bit Data
  141.    64fs         0000        I2S 16 to 24-bit Data          default input data format
  142.     0001        MSB First Left-Justified Data
  143.                 1001        LSB First Left-Justified Data
  144.                 ×010        Right-Justified 16-bit Data
  145.                 ×011        Right-Justified 18-bit Data
  146.                 ×100        Right-Justified 20-bit Data
  147.                 ×101        Right-Justified 24-bit Data
  148. *////////////////////////////////////////////////////////////////
  149. void set_inputData_format(BYTE ctrl)
  150. {
  151.     UINT16      romSum=0;
  152.     BYTE *p = (BYTE *)(&romSum);
  153. ReadFromI2c(DDX8K_ADDR,CONFIGREG_B,p,1);
  154. *p = (ctrl<<2) | (*p & 0xc3);
  155. WriteToI2c(DDX8K_ADDR,CONFIGREG_B,p,1);
  156. }
  158. //channel mapping
  159. //par:  pch---processing channel number; ich---input channel number
  160. void ddx_channel_map(BYTE pch,BYTE ich)
  161. {
  162.     UINT16      romSum=0;
  163.     BYTE *p = (BYTE *)(&romSum);
  164. switch(pch)
  165. {
  166. case 1:
  167. *p = (*p & 0xf8) | (ich-1);
  168. WriteToI2c(DDX8K_ADDR,C12MAP_REG,p,1);
  169. break;
  170. case 2:
  171. *p = (*p & 0x8f) | ((ich-1)<<4);
  172. WriteToI2c(DDX8K_ADDR,C12MAP_REG,p,1);
  173. break;
  174. case 3:
  175. *p = (*p & 0xf8) | (ich-1);
  176. WriteToI2c(DDX8K_ADDR,C34MAP_REG,p,1);
  177. break;
  178. case 4:
  179. *p = (*p & 0x8f) | ((ich-1)<<4);
  180. WriteToI2c(DDX8K_ADDR,C34MAP_REG,p,1);
  181. break;
  182. case 5:
  183. *p = (*p & 0xf8) | (ich-1);
  184. WriteToI2c(DDX8K_ADDR,C56MAP_REG,p,1);
  185. break;
  186. case 6:
  187. *p = (*p & 0x8f) | ((ich-1)<<4);
  188. WriteToI2c(DDX8K_ADDR,C56MAP_REG,p,1);
  189. break;
  190. case 7:
  191. *p = (*p & 0xf8) | (ich-1);
  192. WriteToI2c(DDX8K_ADDR,C78MAP_REG,p,1);
  193. break;
  194. case 8:
  195. *p = (*p & 0x8f) | ((ich-1)<<4);
  196. WriteToI2c(DDX8K_ADDR,C78MAP_REG,p,1);
  197. break;
  198. }
  199. }
  201. //////////////////////////////////////////////////////////////////
  202. //Configuration Register A
  203. /*
  204. sample rate(kHz)  |  IR(D4~D3)  |            MCS(D2~D0)
  205. -----------------------------------------------------------------------
  206.                   |             |  1××   | 011   | 010   | 001   | 000
  207. -----------------------------------------------------------------------
  208. 32, 44.1, 48      |     00      |  128fs | 256fs | 384fs | 512fs | 768fs
  209. 88.2, 96          |     01      |  64fs  | 128fs | 192fs | 256fs | 384fs
  210. 176.4, 192        |     10      |  64fs  | 128fs | 192fs | 256fs | 384fs
  211. Reserved          |     NA      |    NA  |   NA  |   NA  |   NA  |   NA
  212. -----------------------------------------------------------------------
  213. */
  214. ///////////////////////////////////////////////////////////////////
  215. void set_inputClock(BYTE IR,BYTE MCS)
  216. {
  217.     UINT16      romSum=0;
  218.     BYTE *p = (BYTE *)(&romSum);
  219. *p = (*p & 0xe0) | ((IR<<3) | MCS);
  220. WriteToI2c(DDX8K_ADDR,CONFIGREG_A,p,1);
  221. }
  223. //Bass Management
  224. //set Configuration Register A bit 5 will enable or disable bass management
  225. void ddx_enable_BassManagement(void)
  226. {
  227. write_reg_bit(CONFIGREG_A,5,1);
  228. }
  230. void ddx_disable_BassManagement(void)
  231. {
  232. write_reg_bit(CONFIGREG_A,5,0);
  233. }
  235. //Reading a Coefficient Value From RAM
  236. UINT32 ddx_readCoefVal(BYTE regAddr)
  237. {
  238. UINT32 tmp;
  239.     UINT16      romSum=0;
  240.     BYTE *p = (BYTE *)(&romSum);
  241.     
  242. //    printf("**********************************************n");
  243.     //write 8-bit address to I2C register 1Ch
  244.     *p = regAddr;
  245. WriteToI2c(DDX8K_ADDR,0x1c,p,1);
  247. *p = 0;
  248. ReadFromI2c(DDX8K_ADDR,0x1c,p,1);
  249. // printf("the val of register 0x1c is:%xn",*p);
  251. //read top 8-bits of coefficient in I2C address 1Dh
  252. *p = 0;
  253. ReadFromI2c(DDX8K_ADDR,0x1d,p,1);
  255. // printf("the val of register 0x1d is:%xn",*p);
  257. tmp = (*p << 16) & 0xff0000;
  259. //read middle 8-bits of coefficient in I2C address 1Fh
  260. *p = 0;
  261. ReadFromI2c(DDX8K_ADDR,0x1e,p,1);
  263. // printf("the val of register 0x1e is:%xn",*p);
  265. tmp = tmp | ((*p << 8) & 0xff00);
  267. //read bottom 8-bits of coefficient in I2C address 1Fh
  268. *p=0;
  269. ReadFromI2c(DDX8K_ADDR,0x1f,p,1);
  271. // printf("the val of register 0x1f is:%xn",*p);
  273. tmp = tmp | *p;
  274. return tmp;
  275. }
  276. //Writing a single Coefficient Value to RAM
  277. void ddx_writeCoefVal(BYTE regAddr,UINT32 coefVal)
  278. {
  280.     UINT16      romSum=0;
  281.     BYTE *p = (BYTE *)(&romSum);
  282.     
  283.     //write 8-bit address to I2C register 1Ch
  284.     *p = regAddr;
  285. WriteToI2c(DDX8K_ADDR,0x1c,p,1);
  287. //write top 8-bits of coefficient in I2C address 1Dh
  288. *p = (coefVal & 0xff0000) >> 16;
  289. WriteToI2c(DDX8K_ADDR,0x1d,p,1);
  291. //write middle 8-bits of coefficient in I2C address 1Eh
  292. *p = (coefVal & 0x00ff00) >> 8;
  293. WriteToI2c(DDX8K_ADDR,0x1e,p,1);
  295. //write bottom 8-bits of coefficient in I2C address 1Fh
  296. *p = (coefVal & 0x0000ff);
  297. WriteToI2c(DDX8K_ADDR,0x1f,p,1);
  299. //write control
  300. write_reg_bit(0x2c,0,1);
  301. }
  304. //Writing a set of Coefficient Values to RAM
  305. void ddx_writeCoefValSets(BYTE startAddr,coef_factor factor)
  306. {
  307.     UINT16      romSum=0;
  308.     BYTE *p = (BYTE *)(&romSum);
  309.     //write 8-bit address to I2C register 1Ch
  310.     *p = startAddr;
  311. WriteToI2c(DDX8K_ADDR,0x1c,p,1);
  312. //write factor b2
  313. *p = (factor.b2 & 0xff0000) >> 16;
  314. WriteToI2c(DDX8K_ADDR,0x1d,p,1);
  316. *p = (factor.b2 & 0x00ff00) >> 8;
  317. WriteToI2c(DDX8K_ADDR,0x1e,p,1);
  319. *p = (factor.b2 & 0x0000ff);
  320. WriteToI2c(DDX8K_ADDR,0x1f,p,1);
  321. //write factor b0
  322. *p = (factor.b0 & 0xff0000) >> 16;
  323. WriteToI2c(DDX8K_ADDR,0x20,p,1);
  325. *p = (factor.b0 & 0x00ff00) >> 8;
  326. WriteToI2c(DDX8K_ADDR,0x21,p,1);
  328. *p = (factor.b0 & 0x0000ff);
  329. WriteToI2c(DDX8K_ADDR,0x22,p,1);
  330. //write factor a2
  331. *p = (factor.a2 & 0xff0000) >> 16;
  332. WriteToI2c(DDX8K_ADDR,0x23,p,1);
  334. *p = (factor.a2 & 0x00ff00) >> 8;
  335. WriteToI2c(DDX8K_ADDR,0x24,p,1);
  337. *p = (factor.a2 & 0x0000ff);
  338. WriteToI2c(DDX8K_ADDR,0x25,p,1);
  339. //write factor a1
  340. *p = (factor.a1 & 0xff0000) >> 16;
  341. WriteToI2c(DDX8K_ADDR,0x26,p,1);
  343. *p = (factor.a1 & 0x00ff00) >> 8;
  344. WriteToI2c(DDX8K_ADDR,0x27,p,1);
  346. *p = (factor.a1 & 0x0000ff);
  347. WriteToI2c(DDX8K_ADDR,0x28,p,1);
  348. //write factor b1
  349. *p = (factor.b1 & 0xff0000) >> 16;
  350. WriteToI2c(DDX8K_ADDR,0x29,p,1);
  352. *p = (factor.b1 & 0x00ff00) >> 8;
  353. WriteToI2c(DDX8K_ADDR,0x2a,p,1);
  355. *p = (factor.b1 & 0x0000ff);
  356. WriteToI2c(DDX8K_ADDR,0x2b,p,1);
  358. //write control
  359. write_reg_bit(0x2c,1,1);
  360. }
  361. //HPB register i.e. Configuation Register C-02h,Bit 7
  362. //1: disable this feature
  363. //0: enable this feature
  364. //input:1---disable,0---enable
  365. //enable High Pass Filter
  366. void enable_hpf(void)
  367. {
  368. write_reg_bit(CONFIGREG_C,7,0);
  369. }
  371. void disable_hpf(void)
  372. {
  373.   write_reg_bit(CONFIGREG_C,7,1);
  374. }
  376. //tone control:  include treble control and bass control
  377. //input:
  378. //updown: 1---boost tone -1---cut tone
  379. BYTE ddx_trebleCtrl(int updown)   //xulf modified 2004-01-13
  380. {
  381.     BYTE romSum=0;
  382.     BYTE *p = (BYTE *)(&romSum);
  383.     
  384. ReadFromI2c(DDX8K_ADDR,TONE_CTRL_REG,p,1);
  385. if(updown==1)
  386. {
  387. if(amp_userSet.ddx_Treble_lev < 0x0d)
  388. amp_userSet.ddx_Treble_lev++;
  389. }
  390. else if(updown==-1)
  391. {
  392. if(amp_userSet.ddx_Treble_lev > 0x1)
  393. amp_userSet.ddx_Treble_lev--;
  394. }
  395. *p = (amp_userSet.ddx_Treble_lev<<4) | (*p & 0x0f);
  396. WriteToI2c(DDX8K_ADDR,TONE_CTRL_REG,p,1);
  397. WriteToI2c(0xa0, TREBLE_GAIN_ADDR, &amp_userSet.ddx_Treble_lev, 1);
  398. }
  400. BYTE  ddx_bassCtrl(int updown) //xulf modified 2004-01-13
  401. {
  402.     BYTE romSum=0;
  403.     BYTE *p = (BYTE *)(&romSum);
  404.     
  405. ReadFromI2c(DDX8K_ADDR,TONE_CTRL_REG,p,1);
  406. if(updown==1)
  407. {
  408. if(amp_userSet.ddx_Bass_lev < 0x0d)      
  409. amp_userSet.ddx_Bass_lev++;
  410. }
  411. else if(updown==-1)
  412. {
  413. if(amp_userSet.ddx_Bass_lev > 0x1)
  414. amp_userSet.ddx_Bass_lev--;
  415. }
  416. *p = amp_userSet.ddx_Bass_lev | (*p & 0xf0);
  417. WriteToI2c(DDX8K_ADDR,TONE_CTRL_REG,p,1);
  418. WriteToI2c(0xa0, BASS_GAIN_ADDR, &amp_userSet.ddx_Bass_lev, 1);
  419. }
  421. //volume control:  include master volume control and channel volume control
  422. //input:
  423. /*
  424. updown:  1---boost,  -1---cut
  425. mute:    1---Hard Master Mute,  0---not mute,adjust volume
  426. */
  427. void ddx_master_volume_adjust(int updown,BYTE mute)
  428. {
  429.     BYTE tmp_var;
  430.     
  431.     if(mute)
  432.     {
  433. amp_userSet.mainvol = 0xff;
  434. WriteToI2c(DDX8K_ADDR,MASTER_VOL_REG,&amp_userSet.mainvol,1);
  435. return;
  436.     }
  437.     else
  438.     {
  439. //     ddx_masterMute(1);
  440. ReadFromI2c(DDX8K_ADDR,MASTER_VOL_REG,&amp_userSet.mainvol,1);
  441. tmp_var = amp_userSet.mainvol;
  442.      if(updown==1)
  443.      {
  444.      if(tmp_var>0x00)
  445.      tmp_var--;
  446.      }
  447.      else if(updown==-1)
  448.      tmp_var++;
  449.      if(*lev_list[0]==1)
  450.      tmp_var = 0x31;
  451.      else if(*lev_list[0]==0)
  452.      tmp_var = 0xff;
  453.      amp_userSet.mainvol = tmp_var;
  454.      WriteToI2c(DDX8K_ADDR,MASTER_VOL_REG,&amp_userSet.mainvol,1);
  455. WriteToI2c(0xa0,AMP_I2CADDR_START+(2*y_index),lev_list[y_index],1);
  456. WriteToI2c(0xa0,AMP_I2CADDR_START+(2*y_index + 1),&amp_userSet.mainvol,1);
  457. //     ddx_masterMute(0);
  458.     }
  459. }
  461. //Set Master Volume Gain
  462. void ddx_setMVG(BYTE chAddr,BYTE ctrl)
  463. {
  464. WriteToI2c(DDX8K_ADDR,chAddr,&ctrl,1);
  465. }
  466. //input:
  467. /*
  468. chAddr:  channel volume regsiter address
  469. updown:  1---boost,  -1---cut
  470. */
  472. void ddx_channel_volume_adjust(BYTE chAddr,int updown)
  473. {
  474. //    UINT16      romSum=0;
  475.     BYTE *p = (BYTE *)(&amp_userSet);
  476.     BYTE tmp_var;
  478. // ddx_masterMute(1);
  479. ReadFromI2c(DDX8K_ADDR,chAddr,p,1);
  480. tmp_var = *(p+(2*y_index+1));
  481. if(updown==1)
  482. {
  483. if(tmp_var>0x00)
  484. tmp_var -=1;
  485. }
  486. else if(updown==-1)
  487. {
  488. if(tmp_var<0xfe)
  489. tmp_var +=1;
  490. }
  491. *(p+(2*y_index+1)) = tmp_var;
  492. WriteToI2c(DDX8K_ADDR,chAddr,(p+(2*y_index+1)),1);
  493. WriteToI2c(0xa0,AMP_I2CADDR_START+(2*y_index),lev_list[y_index],1);
  494. WriteToI2c(0xa0,AMP_I2CADDR_START+(2*y_index + 1),(p+(2*y_index+1)),1);
  495. // ddx_masterMute(0);
  496. }
  498. //Set Channel Volume Gain
  499. void ddx_setCVG(BYTE chAddr,BYTE ctrl)
  500. {
  501. WriteToI2c(DDX8K_ADDR,chAddr,&ctrl,1);
  502. }
  504. //all changes in volume take place at digital zero-crossing
  505. //will create the smoothest possible volume transition
  506. void ddx_enZeroCross(void)
  507. {
  508. write_reg_bit(CONFIGREG_B,6,1);
  509. }
  510. void ddx_disZeroCross(void)
  511. {//volume updates immediately
  512. write_reg_bit(CONFIGREG_B,6,0);
  513. }
  515. //Master Volume Mute
  516. //mute all channels simultaneously
  517. //mute   1: mute       0: demute
  518. void ddx_masterMute(BYTE mute)
  519. {
  520. if(mute)
  521. write_reg_bit(MASTER_MUTE_REG,0,1);
  522. else
  523. write_reg_bit(MASTER_MUTE_REG,0,0);
  524. }
  526. //channel mute individually
  527. //mute   1: mute       0: demute
  528. void ddx_channelMute(BYTE chNum,BYTE mute)
  529. {
  530. if(mute)
  531. write_reg_bit(CHANEL_MUTE_REG,chNum,1);
  532. else
  533. write_reg_bit(CHANEL_MUTE_REG,chNum,0);
  534. }
  536. //Channel Limiter Selection
  537. /*
  538. CxLS(1,0)   Channel Limiter Mapping
  539. -------------------------------------------
  540.    00       Channel has limiting disabled
  541.    01       Channel is mapped to limiter #1
  542.    10       Channel is mapped to limiter #2
  543.    11       Reserved.Don't use this setting
  544. --------------------------------------------
  545. */
  546. void ddx_ch1_limiterSel(BYTE selCtrl)
  547. {
  548. BYTE data;
  549. ReadFromI2c(DDX8K_ADDR,CLIMITER_SEL0,&data,1);
  550. data = selCtrl | (data & 0xfc); 
  551. if(selCtrl<0x03)
  552. WriteToI2c(DDX8K_ADDR,CLIMITER_SEL0,&data,1);
  553. }
  555. void ddx_ch2_limiterSel(BYTE selCtrl)
  556. {
  557. BYTE data;
  558. ReadFromI2c(DDX8K_ADDR,CLIMITER_SEL0,&data,1);
  559. data = (selCtrl << 2) | (data & 0xf3); 
  560. if(selCtrl<0x03)
  561. WriteToI2c(DDX8K_ADDR,CLIMITER_SEL0,&data,1);
  562. }
  564. void ddx_ch3_limiterSel(BYTE selCtrl)
  565. {
  566. BYTE data;
  567. ReadFromI2c(DDX8K_ADDR,CLIMITER_SEL0,&data,1);
  568. data = (selCtrl << 4) | (data & 0xcf); 
  569. if(selCtrl<0x03)
  570. WriteToI2c(DDX8K_ADDR,CLIMITER_SEL0,&data,1);
  571. }
  572. void ddx_ch4_limiterSel(BYTE selCtrl)
  573. {
  574. BYTE data;
  575. ReadFromI2c(DDX8K_ADDR,CLIMITER_SEL0,&data,1);
  576. data = (selCtrl << 6) | (data & 0x3f); 
  577. if(selCtrl<0x03)
  578. WriteToI2c(DDX8K_ADDR,CLIMITER_SEL0,&data,1);
  579. }
  580. void ddx_ch5_limiterSel(BYTE selCtrl)
  581. {
  582. BYTE data;
  583. ReadFromI2c(DDX8K_ADDR,CLIMITER_SEL1,&data,1);
  584. data = selCtrl | (data & 0xfc); 
  585. if(selCtrl<0x03)
  586. WriteToI2c(DDX8K_ADDR,CLIMITER_SEL1,&data,1);
  587. }
  589. void ddx_ch6_limiterSel(BYTE selCtrl)
  590. {
  591. BYTE data;
  592. ReadFromI2c(DDX8K_ADDR,CLIMITER_SEL1,&data,1);
  593. data = (selCtrl << 2) | (data & 0xf3); 
  594. if(selCtrl<0x03)
  595. WriteToI2c(DDX8K_ADDR,CLIMITER_SEL1,&data,1);
  596. }
  598. void ddx_ch7_limiterSel(BYTE selCtrl)
  599. {
  600. BYTE data;
  601. ReadFromI2c(DDX8K_ADDR,CLIMITER_SEL1,&data,1);
  602. data = (selCtrl << 4) | (data & 0xcf); 
  603. if(selCtrl<0x03)
  604. WriteToI2c(DDX8K_ADDR,CLIMITER_SEL1,&data,1);
  605. }
  606. void ddx_ch8_limiterSel(BYTE selCtrl)
  607. {
  608. BYTE data;
  609. ReadFromI2c(DDX8K_ADDR,CLIMITER_SEL1,&data,1);
  610. data = (selCtrl << 6) | (data & 0x3f); 
  611. if(selCtrl<0x03)
  612. WriteToI2c(DDX8K_ADDR,CLIMITER_SEL1,&data,1);
  613. }
  615. //Set Compression and Release Rates of Limiter
  616. void ddx_setL1CRrates(BYTE ctrl)
  617. {
  618. WriteToI2c(DDX8K_ADDR,L1RATE_REG,&ctrl,1);
  619. }
  621. void ddx_setL2CRrates(BYTE ctrl)
  622. {
  623. WriteToI2c(DDX8K_ADDR,L2RATE_REG,&ctrl,1);
  624. }
  626. //Set Compression and Release Threshold of Limiter
  627. void ddx_setL1CRthreshold(BYTE ctrl)
  628. {
  629. WriteToI2c(DDX8K_ADDR,L1THRESHOLDS_REG,&ctrl,1);
  630. }
  632. void ddx_setL2CRthreshold(BYTE ctrl)
  633. {
  634. WriteToI2c(DDX8K_ADDR,L2THRESHOLDS_REG,&ctrl,1);
  635. }
  637. //Set Dynamic Range Compression mode
  638. //drc: 1----Dynamic Range Compression mode
  639. //     0----Anti-Clipping Mode(default)
  640. void ddx_setDRCmode(BYTE drc)
  641. {
  642. write_reg_bit(CONFIGREG_B,7,drc);
  643. }
  645. //Set Max Power Correction
  646. void ddx_setMPC(void)
  647. {
  648. write_reg_bit(CONFIGREG_A,7,1);
  649. }
  650. //Head Phone Enable or Disable
  651. void ddx_enHeadPhone(void)
  652. {
  653. write_reg_bit(CONFIGREG_A,6,1);
  654. }
  655. void ddx_disHeadPhone(void)
  656. {
  657. write_reg_bit(CONFIGREG_A,6,0);
  658. }
  660. //AM Mode Enable or Disable
  661. void ddx_enableAM_mode(void)
  662. {
  663. write_reg_bit(CONFIGREG_F,3,1);
  664. }
  665. void ddx_disableAM_mode(void)
  666. {
  667. write_reg_bit(CONFIGREG_F,3,0);
  668. }
  670. void ddx_set_BassManagement(void)
  671. {
  672. coef_factor bass_coef;
  673. //set channel 7,5,4,2,1 pre-scale factor
  674.     ddx_writeCoefVal(0xd6,FL_SCALE_FACTOR);  //xulf 2003-12-15
  675.     ddx_writeCoefVal(0xd4,FR_SCALE_FACTOR);
  676.     ddx_writeCoefVal(0xd3,SL_SCALE_FACTOR);
  677.     ddx_writeCoefVal(0xd1,SR_SCALE_FACTOR);
  678.     ddx_writeCoefVal(0xd0,CE_SCALE_FACTOR);
  679.     ddx_writeCoefVal(0xd5,LFE_SCALE_FACTOR);
  680.     
  681. //set channel 7,5,4,2,1 filter coefficient
  682. bass_coef.b2 = HPF_COEF_B2;
  683. bass_coef.b0 = HPF_COEF_B0;
  684. bass_coef.a2 = HPF_COEF_A2;
  685. bass_coef.a1 = HPF_COEF_A1;
  686. bass_coef.b1 = HPF_COEF_B1;
  687. ddx_writeCoefValSets(0x96,bass_coef);  //channel 7    xulf 2003-12-15
  688. ddx_writeCoefValSets(0x64,bass_coef);  //channel 5
  689. ddx_writeCoefValSets(0x4b,bass_coef);  //channel 4
  690. ddx_writeCoefValSets(0x19,bass_coef);  //channel 2
  691. ddx_writeCoefValSets(0x00,bass_coef);  //channel 1
  693. //set channel 6 filter coefficient
  694. bass_coef.b2 = LPF_COEF_B2;
  695. bass_coef.b0 = LPF_COEF_B0;
  696. bass_coef.a2 = LPF_COEF_A2;
  697. bass_coef.a1 = LPF_COEF_A1;
  698. bass_coef.b1 = LPF_COEF_B1;
  699. ddx_writeCoefValSets(0x7d,bass_coef);
  700. }
  702. //Initialize volume gain
  703. void ddx_init_volumeGain(void)
  704. {
  705. //set volume gain 
  706. ddx_setMVG(MASTER_VOL_REG,0x6c/*-54dB*/);
  707. ddx_setCVG(C7V_REG,0x18);//12dB
  708. ddx_setCVG(C5V_REG,0x18);//12dB
  709. ddx_setCVG(C4V_REG,0x18);//12dB
  710. ddx_setCVG(C2V_REG,0x18);//12dB
  711. ddx_setCVG(C1V_REG,0x18);//12dB
  712. ddx_setCVG(C6V_REG,0x10);//16dB
  713. ddx_setCVG(C3V_REG,0xff);           //xulf 2003-12-15
  714. ddx_setCVG(C8V_REG,0xff);
  715. }
  716. //Initialization
  717. void ddx_initialization(void)
  718. {
  719. BYTE data;
  720. /* //disable external amplifier
  721. ddx_disableEPAD();
  722. //mute all channels
  723. ddx_masterMute(1);
  724. */
  725. enable_hpf();
  726. NOP;
  727. set_inputClock(0x00,0x03);//256Fs
  728. NOP;
  729. //set input data format
  730. //set input data format   :DVD,VCD,MP3,CD,
  731. #if defined(WM8746)//Right-Justified 24-bit Data
  732. set_inputData_format(0x05);
  733. #elif defined(WM8746I2S24)//I2S 24-bit Data
  734. set_inputData_format(0x00);
  735. #endif
  736. // BYTE data = 0x27;
  737. // WriteToI2c(DDX8K_ADDR,0x03,&data,1);
  739. //enable bass management
  740. //ddx_enable_BassManagement();
  741. //Enable Zero Crossing
  742. //ddx_enZeroCross();
  743. //set Anti-clipping Mode for 5.1 Channels
  744. //ddx_setDRCmode(0);
  745. //initialize volume gain
  746. //ddx_init_volumeGain();
  747. //set bass management
  748. //ddx_set_BassManagement();
  749. //limiter selection: channel 7,5,4,2,1 select limiter 1
  750. //channel 6 select limiter 2
  751. /*ddx_ch7_limiterSel(0x01);
  752. ddx_ch5_limiterSel(0x01);
  753. ddx_ch4_limiterSel(0x01);
  754. ddx_ch2_limiterSel(0x01);
  755. ddx_ch1_limiterSel(0x01);
  756. ddx_ch6_limiterSel(0x02);*/
  757. //set limiter 1,2 Attack Rate and Release Rate
  758. //ddx_setL1CRrates(0xa4);
  759. //ddx_setL2CRrates(0xf7);
  760. //set limiter 1,2 Attack Threshold and Release Threshold
  761. //ddx_setL1CRthreshold(0x65);
  762. //ddx_setL1CRthreshold(0x75);
  764. data=0x2f;              //xulf 2003-12-17
  765. WriteToI2c(DDX8K_ADDR,CONFIGREG_D,&data,1);  
  766.     //channel mapping via I2C
  767.     //output: 7 5 4 2 1 6=====input: 1 2 3 4 5 6
  768. data = 0x34;        
  769. WriteToI2c(DDX8K_ADDR,C12MAP_REG,&data,1);
  770. data = 0x20;
  771. WriteToI2c(DDX8K_ADDR,C34MAP_REG,&data,1);
  772. data = 0x51;
  773. WriteToI2c(DDX8K_ADDR,C56MAP_REG,&data,1);
  774. data = 0x00;
  775. WriteToI2c(DDX8K_ADDR,C78MAP_REG,&data,1);
  777. // write_reg_bit(0x30,
  778. // BYTE data = 0x00;
  779. // WriteToI2c(DDX8K_ADDR,0x03,&data,1);
  780. //unmute all channels
  781. // ddx_enableAM_mode();
  782. /* NOP;
  783. ddx_masterMute(0);
  784. NOP;
  785. ddx_enableEPAD();
  786. */
  787. }
  789. void ddx_ampvol_func_left(void);
  790. void ddx_ampvol_func_right(void);
  791. void ddx_ampvol_func_up(void);
  792. void ddx_ampvol_func_down(void);
  794. void ddx_volume_adjust(UINT32 key)
  795. {
  796. switch(key)
  797. {
  798. case IRC_UP:
  799. ddx_ampvol_func_up();
  800. break;
  801. case IRC_DOWN:
  802. ddx_ampvol_func_down();
  803. break;
  804. case IRC_LEFT:
  805. ddx_ampvol_func_left();
  806. break;
  807. case IRC_RIGHT:
  808. ddx_ampvol_func_right();
  809. break;
  810. }
  811. }
  813. void load_amp_setup(void)//xyy 2004-1-13 10:20
  814. {
  815.     int iRts,i;
  816.     BYTE tmp = 0;
  817.     BYTE *p = (BYTE *)(&tmp);
  818.     printf("-----*********------load_amp_setup()-----***********-------n");
  819.     iRts=ReadFromI2c(0xa0, AMP_I2CADDR_START, &amp_userSet, sizeof(amp_userSet));   
  820.     ReadFromI2c(0xa0, BASS_GAIN_ADDR, &amp_userSet.ddx_Bass_lev, 1);   
  821.     ReadFromI2c(0xa0, TREBLE_GAIN_ADDR, &amp_userSet.ddx_Treble_lev, 1);   
  822.     ReadFromI2c(0xa0, DDX_EQ_TYPE_ADDR, &amp_userSet.ddx_EQ_sel, 1);   
  823.     ReadFromI2c(0xa0, DDX_REVB_TYPE_ADDR, &amp_userSet.ddx_Revb_sel, 1);   
  824.     printf("===iRts : %d====n",iRts);
  825.     if(iRts<0)
  826.     {
  827.      set_ampsetup_default();
  828. WriteToI2c(0xa0,AMP_I2CADDR_START,&amp_userSet,sizeof(amp_userSet));
  829.     }
  830. /* printf("1=========channel mv volume is: %x========n",amp_userSet.mainvol);
  831. printf("1=========channel 1 volume is: %x========n",amp_userSet.lfrontvol);
  832. printf("1=========channel 2 volume is: %x========n",amp_userSet.rfrontvol);
  833. printf("1=========channel 3 volume is: %x========n",amp_userSet.lrearvol);
  834. printf("1=========channel 4 volume is: %x========n",amp_userSet.rrearvol);
  835. printf("1=========channel 5 volume is: %x========n",amp_userSet.centervol);
  836. printf("1=========channel 6 volume is: %x========n",amp_userSet.woofervol);
  837. */
  838. WriteToI2c(DDX8K_ADDR,MASTER_VOL_REG,&amp_userSet.mainvol,1);
  839. WriteToI2c(DDX8K_ADDR,C1V_REG,&amp_userSet.lfrontvol,1);
  840. WriteToI2c(DDX8K_ADDR,C2V_REG,&amp_userSet.rfrontvol,1);
  841. WriteToI2c(DDX8K_ADDR,C3V_REG,&amp_userSet.lrearvol,1);
  842. WriteToI2c(DDX8K_ADDR,C4V_REG,&amp_userSet.rrearvol,1);
  843. WriteToI2c(DDX8K_ADDR,C5V_REG,&amp_userSet.centervol,1);
  844. WriteToI2c(DDX8K_ADDR,C6V_REG,&amp_userSet.woofervol,1);
  845. ddx_Set_EQ(amp_userSet.ddx_EQ_sel);
  846.  *p = (amp_userSet.ddx_Treble_lev<<4)|amp_userSet.ddx_Bass_lev;
  847. WriteToI2c(DDX8K_ADDR,TONE_CTRL_REG,p,1);
  848. }
  850. /*****************************************
  851. /Function: ddx_Set_EQ()
  852. /Description: Set coefficient values of biquads for preset EQ settings. 
  853. /Creator: xulf
  854. /Date: 2003-12-27
  855. /*****************************************/
  856. void ddx_Set_EQ(BYTE EQtype)
  857. {
  858.     coef_factor biquad_coef;
  859.     ddx_disableEPAD();   //EAPD
  860.     ddx_masterMute(1);  //mute all channels
  861.     switch(EQtype)
  862.     {
  863. case NONE:
  864.     //set the channel pre-scale. 
  865.     ddx_writeCoefVal(0xc8,0xe36809);  //channel 1 
  866.          biquad_coef.b2 = 0x000000;
  867.     biquad_coef.b0 = 0x3fffff;
  868.     biquad_coef.a2 = 0x000000;
  869.     biquad_coef.a1 = 0x000000;
  870.     biquad_coef.b1 = 0x000000;
  871.     ddx_writeCoefValSets(0x05,biquad_coef);  //channel 1 biquad2
  872.     ddx_writeCoefValSets(0x0a,biquad_coef);  //channel 1 biquad3     
  873.     ddx_writeCoefValSets(0x0f,biquad_coef);  //channel 1 biquad4     
  874.     ddx_writeCoefValSets(0x14,biquad_coef);  //channel 1 biquad5
  875.     //each channel uses channel 1 coefficient values.
  876.          write_reg_bit(CONFIGREG_D,7,1); 
  877.     break;
  878. case ROCK:
  879.     ddx_writeCoefVal(0xc8,0xaf3cc5);  //channel 1 
  880.     biquad_coef.b2 = 0x7fcf05;
  881.     biquad_coef.b0 = 0x40058a;
  882.     biquad_coef.a2 = 0x8025e6;
  883.     biquad_coef.a1 = 0x7fed02;
  884.     biquad_coef.b1 = 0x8012fe;
  885.     ddx_writeCoefValSets(0x05,biquad_coef);  //channel 1 biquad2
  886.          biquad_coef.b2 = 0x7fd80a;
  887.     biquad_coef.b0 = 0x4006a3;
  888.     biquad_coef.a2 = 0x801aaf;
  889.     biquad_coef.a1 = 0x7ff28c;
  890.     biquad_coef.b1 = 0x800d74;
  891.     ddx_writeCoefValSets(0x0a,biquad_coef);  //channel 1 biquad3     
  892.          biquad_coef.b2 = 0x7ead9f;
  893.     biquad_coef.b0 = 0x3fc7c8;
  894.     biquad_coef.a2 = 0x81c2d0;
  895.     biquad_coef.a1 = 0x7f1d06;
  896.     biquad_coef.b1 = 0x80e2fa;
  897.     ddx_writeCoefValSets(0x0f,biquad_coef);  //channel 1 biquad4     
  898.          biquad_coef.b2 = 0x5d3dab;
  899.     biquad_coef.b0 = 0x46a5ae;
  900.     biquad_coef.a2 = 0x9576f8;
  901.     biquad_coef.a1 = 0x714597;
  902.     biquad_coef.b1 = 0x8eba69;
  903.     ddx_writeCoefValSets(0x14,biquad_coef);  //channel 1 biquad5
  904.     //each channel uses channel 1 coefficient values.
  905.          write_reg_bit(CONFIGREG_D,7,1); 
  906.     break;
  907. case POP:
  908.     ddx_writeCoefVal(0xc8,0xdb759b);  //channel 1 
  909.          biquad_coef.b2 = 0x7fe781;
  910.     biquad_coef.b0 = 0x3ffd3a;
  911.     biquad_coef.a2 = 0x801e09;
  912.     biquad_coef.a1 = 0x7ff0f8;
  913.     biquad_coef.b1 = 0x800f08;
  914.     ddx_writeCoefValSets(0x05,biquad_coef);  //channel 1 biquad2
  915.          biquad_coef.b2 = 0x7cc19b;
  916.     biquad_coef.b0 = 0x40e89e;
  917.     biquad_coef.a2 = 0x816d29;
  918.     biquad_coef.a1 = 0x7f40df;
  919.     biquad_coef.b1 = 0x80bf21;
  920.     ddx_writeCoefValSets(0x0a,biquad_coef);  //channel 1 biquad3     
  921.          biquad_coef.b2 = 0x640c0d;
  922.     biquad_coef.b0 = 0x3cd666;
  923.     biquad_coef.a2 = 0xa24727;
  924.     biquad_coef.a1 = 0x6cbb1a;
  925.     biquad_coef.b1 = 0x9344e6;
  926.     ddx_writeCoefValSets(0x0f,biquad_coef);  //channel 1 biquad4     
  927.          biquad_coef.b2 = 0x4274ad;
  928.     biquad_coef.b0 = 0x37613b;
  929.     biquad_coef.a2 = 0xcec8dd;
  930.     biquad_coef.a1 = 0x4cbc8c;
  931.     biquad_coef.b1 = 0xb34374;
  932.     ddx_writeCoefValSets(0x14,biquad_coef);  //channel 1 biquad5
  933.     //each channel uses channel 1 coefficient values.
  934.          write_reg_bit(CONFIGREG_D,7,1); 
  935.     break;
  936. case PARTY:
  937.     ddx_writeCoefVal(0xc8,0xe4a917);  //channel 1 
  938.          biquad_coef.b2 = 0x7fc83b;
  939.     biquad_coef.b0 = 0x400e7c;
  940.     biquad_coef.a2 = 0x801acd;
  941.     biquad_coef.a1 = 0x7ff297;
  942.     biquad_coef.b1 = 0x800d69;
  943.     ddx_writeCoefValSets(0x05,biquad_coef);  //channel 1 biquad2
  944.          biquad_coef.b2 = 0x7f4db3;
  945.     biquad_coef.b0 = 0x402e50;
  946.     biquad_coef.a2 = 0x8055ad;
  947.     biquad_coef.a1 = 0x7fd50c;
  948.     biquad_coef.b1 = 0x802af4;
  949.     ddx_writeCoefValSets(0x0a,biquad_coef);  //channel 1 biquad3     
  950.          biquad_coef.b2 = 0x7908a0;
  951.     biquad_coef.b0 = 0x412849;
  952.     biquad_coef.a2 = 0x84a6cc;
  953.     biquad_coef.a1 = 0x7d8082;
  954.     biquad_coef.b1 = 0x827f7e;
  955.     ddx_writeCoefValSets(0x0f,biquad_coef);  //channel 1 biquad4     
  956.          biquad_coef.b2 = 0x2688b9;
  957.     biquad_coef.b0 = 0x4edd22;
  958.     biquad_coef.a2 = 0xbbbd01;
  959.     biquad_coef.a1 = 0x4dda39;
  960.     biquad_coef.b1 = 0xb225c7;
  961.     ddx_writeCoefValSets(0x14,biquad_coef);  //channel 1 biquad5
  962.     //each channel uses channel 1 coefficient values.
  963.          write_reg_bit(CONFIGREG_D,7,1); 
  964.     break;
  965.     case DANCE:
  966.     ddx_writeCoefVal(0xc8,0xddef46);  //channel 1 
  967.          biquad_coef.b2 = 0x7fd0f2;
  968.     biquad_coef.b0 = 0x400a20;
  969.     biquad_coef.a2 = 0x801acd;
  970.     biquad_coef.a1 = 0x7ff297;
  971.     biquad_coef.b1 = 0x800d69;
  972.     ddx_writeCoefValSets(0x05,biquad_coef);  //channel 1 biquad2
  973.          biquad_coef.b2 = 0x7f2132;
  974.     biquad_coef.b0 = 0x4039df;
  975.     biquad_coef.a2 = 0x806b0f;
  976.     biquad_coef.a1 = 0x7fca4b;
  977.     biquad_coef.b1 = 0x8035b5;
  978.     ddx_writeCoefValSets(0x0a,biquad_coef);  //channel 1 biquad3     
  979.          biquad_coef.b2 = 0x7a469f;
  980.     biquad_coef.b0 = 0x40cd3f;
  981.     biquad_coef.a2 = 0x841ee2;
  982.     biquad_coef.a1 = 0x7ddf4c;
  983.     biquad_coef.b1 = 0x8220b4;
  984.     ddx_writeCoefValSets(0x0f,biquad_coef);  //channel 1 biquad4     
  985.          biquad_coef.b2 = 0x2ca6df;
  986.     biquad_coef.b0 = 0x4dd8f0;
  987.     biquad_coef.a2 = 0xb7a741;
  988.     biquad_coef.a1 = 0x534a84;
  989.     biquad_coef.b1 = 0xacb57c;
  990.     ddx_writeCoefValSets(0x14,biquad_coef);  //channel 1 biquad5
  991.     //each channel uses channel 1 coefficient values.
  992.          write_reg_bit(CONFIGREG_D,7,1); 
  993.     break;
  994. case HARD:
  995.     ddx_writeCoefVal(0xc8,0xdfd91e);  //channel 1 
  996.          biquad_coef.b2 = 0x7fdeb7;
  997.     biquad_coef.b0 = 0x400729;
  998.     biquad_coef.a2 = 0x8012f5;
  999.     biquad_coef.a1 = 0x7ff683;
  1000.     biquad_coef.b1 = 0x80097d;
  1001.     ddx_writeCoefValSets(0x05,biquad_coef);  //channel 1 biquad2
  1002.          biquad_coef.b2 = 0x7fbd74;
  1003.     biquad_coef.b0 = 0x400e52;
  1004.     biquad_coef.a2 = 0x8025e6;
  1005.     biquad_coef.a1 = 0x7fed02;
  1006.     biquad_coef.b1 = 0x8012fe;
  1007.     ddx_writeCoefValSets(0x0a,biquad_coef);  //channel 1 biquad3     
  1008.          biquad_coef.b2 = 0x007c0c;
  1009.     biquad_coef.b0 = 0x662860;
  1010.     biquad_coef.a2 = 0xb33334;
  1011.     biquad_coef.a1 = 0x58ae56;
  1012.     biquad_coef.b1 = 0xa751aa;
  1013.     ddx_writeCoefValSets(0x0f,biquad_coef);  //channel 1 biquad4     
  1014.          biquad_coef.b2 = 0x000000;
  1015.     biquad_coef.b0 = 0x3fffff;
  1016.     biquad_coef.a2 = 0x000000;
  1017.     biquad_coef.a1 = 0x000000;
  1018.     biquad_coef.b1 = 0x000000;
  1019.     ddx_writeCoefValSets(0x14,biquad_coef);  //channel 1 biquad5
  1020.     //each channel uses channel 1 coefficient values.
  1021.          write_reg_bit(CONFIGREG_D,7,1);      
  1022.     break;
  1023. case CLASSIC:
  1024.     ddx_writeCoefVal(0xc8,0xaf3cc5);  //channel 1 
  1025.          biquad_coef.b2 = 0x7f4977;
  1026.     biquad_coef.b0 = 0x400f9b;
  1027.     biquad_coef.a2 = 0x809753;
  1028.     biquad_coef.a1 = 0x7fb3a3;
  1029.     biquad_coef.b1 = 0x804c5d;
  1030.     ddx_writeCoefValSets(0x05,biquad_coef);  //channel 1 biquad2
  1031.          biquad_coef.b2 = 0x7b9d6f;
  1032.     biquad_coef.b0 = 0x40ba80;
  1033.     biquad_coef.a2 = 0x82ed90;
  1034.     biquad_coef.a1 = 0x7e77e0;
  1035.     biquad_coef.b1 = 0x818820;
  1036.     ddx_writeCoefValSets(0x0a,biquad_coef);  //channel 1 biquad3     
  1037.          biquad_coef.b2 = 0x4e4a5f;
  1038.     biquad_coef.b0 = 0x459fbc;
  1039.     biquad_coef.a2 = 0xa67628;
  1040.     biquad_coef.a1 = 0x5e3269;
  1041.     biquad_coef.b1 = 0xa1cd97;
  1042.     ddx_writeCoefValSets(0x0f,biquad_coef);  //channel 1 biquad4     
  1043.          biquad_coef.b2 = 0x000000;
  1044.     biquad_coef.b0 = 0x3fffff;
  1045.     biquad_coef.a2 = 0x000000;
  1046.     biquad_coef.a1 = 0x000000;
  1047.     biquad_coef.b1 = 0x000000;
  1048.     ddx_writeCoefValSets(0x14,biquad_coef);  //channel 1 biquad5
  1049.     //each channel uses channel 1 coefficient values.
  1050.          write_reg_bit(CONFIGREG_D,7,1); 
  1051.     break;
  1052. case SOFT:
  1053.     ddx_writeCoefVal(0xc8,0xd77b6);  //channel 1 
  1054.          biquad_coef.b2 = 0x7fdd5d;
  1055.     biquad_coef.b0 = 0x4003eb;
  1056.     biquad_coef.a2 = 0x801acd;
  1057.     biquad_coef.a1 = 0x7ff297;
  1058.     biquad_coef.b1 = 0x800d69;
  1059.     ddx_writeCoefValSets(0x05,biquad_coef);  //channel 1 biquad2
  1060.          biquad_coef.b2 = 0x7fa8c6;
  1061.     biquad_coef.b0 = 0x4009de;
  1062.     biquad_coef.a2 = 0x80437d;
  1063.     biquad_coef.a1 = 0x7fde2f;
  1064.     biquad_coef.b1 = 0x8021d1;
  1065.     ddx_writeCoefValSets(0x0a,biquad_coef);  //channel 1 biquad3     
  1066.          biquad_coef.b2 = 0x7d21e7;
  1067.     biquad_coef.b0 = 0x3f992d;
  1068.     biquad_coef.a2 = 0x83abbd;
  1069.     biquad_coef.a1 = 0x7e25ce;
  1070.     biquad_coef.b1 = 0x81da32;
  1071.     ddx_writeCoefValSets(0x0f,biquad_coef);  //channel 1 biquad4     
  1072.          biquad_coef.b2 = 0x157218;
  1073.     biquad_coef.b0 = 0x5bad59;
  1074.     biquad_coef.a2 = 0xb33334;
  1075.     biquad_coef.a1 = 0x58ae56;
  1076.     biquad_coef.b1 = 0xa751aa;
  1077.     ddx_writeCoefValSets(0x14,biquad_coef);  //channel 1 biquad5
  1078.     //each channel uses channel 1 coefficient values.
  1079.          write_reg_bit(CONFIGREG_D,7,1); 
  1080.     break;
  1081. default:
  1082.     }
  1083.     ddx_enableEPAD();   //unEAPD
  1084.     ddx_masterMute(0);  //demute all channels
  1085. }
  1087. /******************************************
  1088. /Function: ddx_TunerOutput_VSS()
  1089. /description: Specific stereo to "virtual 5.1 effect" 
  1090. setting for tuner input mode 
  1091. /creator: xulf 
  1092. /date: 2003-12-24
  1093. /******************************************/
  1094. void ddx_TunerOutput_VSS(void)
  1095. {
  1096.     BYTE data;
  1097.     coef_factor bass_coef;
  1098.     
  1099.     ddx_disableEPAD();   //EAPD
  1100.     ddx_masterMute(1);  //mute all channels
  1101.     
  1102.     //disable bass management mode
  1103.     ddx_disable_BassManagement();
  1104.     //enable adjacent channel-mixing mode
  1105.     write_reg_bit(CONFIGREG_E,0,1);
  1107.     //SDI_12-->LT/RT; SDI_34-->0; SDI_56-->0; SDI_78-->0
  1108.     //7 5 4 2 1 6-->FL FR VirtualCE  VirtualSL VirtualSR VirtualSW
  1109. data = 0x01;
  1110. WriteToI2c(DDX8K_ADDR,C12MAP_REG,&data,1);
  1111. data = 0x01;
  1112. WriteToI2c(DDX8K_ADDR,C34MAP_REG,&data,1);
  1113. data = 0x01;
  1114. WriteToI2c(DDX8K_ADDR,C56MAP_REG,&data,1);
  1115. data = 0x00;
  1116. WriteToI2c(DDX8K_ADDR,C78MAP_REG,&data,1);
  1117.    
  1118.     //set pre-scale factor
  1119.     ddx_writeCoefVal(0xd0,0x000000);  //X-Full attenuation
  1120.     ddx_writeCoefVal(0xd1,0x7FFFFF);  //0dB
  1121.     ddx_writeCoefVal(0xd2,0x400000);  //-6dB
  1122.     ddx_writeCoefVal(0xd3,0x400000);
  1123.     ddx_writeCoefVal(0xd4,0x400000);
  1124.     ddx_writeCoefVal(0xd5,0x400000);
  1125.     ddx_writeCoefVal(0xd6,0x000000);
  1126.     
  1127.     //set channel 7,5,4,2,1 filter coefficient
  1128.     bass_coef.b2 = HPF_COEF_B2;
  1129.     bass_coef.b0 = HPF_COEF_B0;
  1130.     bass_coef.a2 = HPF_COEF_A2;
  1131.     bass_coef.a1 = HPF_COEF_A1;
  1132.     bass_coef.b1 = HPF_COEF_B1;
  1133.     ddx_writeCoefValSets(0x96,bass_coef);  //channel 7    xulf 2003-12-15
  1134.     ddx_writeCoefValSets(0x64,bass_coef);  //channel 5
  1135.     ddx_writeCoefValSets(0x4b,bass_coef);  //channel 4
  1136.     ddx_writeCoefValSets(0x19,bass_coef);  //channel 2
  1137.     ddx_writeCoefValSets(0x00,bass_coef);  //channel 1
  1139.     //set channel 6 filter coefficient
  1140.     bass_coef.b2 = LPF_COEF_B2;
  1141.     bass_coef.b0 = LPF_COEF_B0;
  1142.     bass_coef.a2 = LPF_COEF_A2;
  1143.     bass_coef.a1 = LPF_COEF_A1;
  1144.     bass_coef.b1 = LPF_COEF_B1;
  1145.     ddx_writeCoefValSets(0x7d,bass_coef);    
  1147.     ddx_enableEPAD();   //unEAPD
  1148.     ddx_masterMute(0);  //demute all channels    
  1149. }