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

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

DVD

开发平台：

C/C++

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