📄 ddx8000_binary.c
字号:
/***********************************
Creater: xiongyuyue
Date : 2003/8/14
Description: Amplifier function using
Reference:DDX8000 Datasheet(APOGEE CO.)
***********************************/
#include "user_init.h"
//#include "config.h"
//#include "regmap.h"
#include "global.h"
#include "ircode.h"
#include "osd.h"
//#include "gpio.h"
//#include "iop.h"
#include "audctrl.h"
#include "ddx8000.h"
#include "cchar.h"
#define NOP delay_1us(10000)
#define AMP_I2CADDR_START 512
#define BASS_GAIN_ADDR AMP_I2CADDR_START+sizeof(amp_userSet)+1
#define TREBLE_GAIN_ADDR BASS_GAIN_ADDR+1
#define DDX_EQ_TYPE_ADDR TREBLE_GAIN_ADDR+1
#define DDX_REVB_TYPE_ADDR DDX_EQ_TYPE_ADDR+1
int ddx_amp_mode = 0;
extern BYTE * lev_list[7];
BYTE channel_addr[6] =
{
0x0f,//front left
0x0d,//front right
0x0c,//surround left
0x0a,//surround right
0x09,//center
0x0e//subwoofer
};
//Reset DDX8000
void ddx_reset_all(void)
{
BYTE data;
//Reset Configuration Register A
data = 0x83;
WriteToI2c(DDX8K_ADDR,CONFIGREG_A,&data,1);
//Reset Configuration Register B
data = 0x42;
WriteToI2c(DDX8K_ADDR,CONFIGREG_B,&data,1);
//Reset Configuration Register C
data = 0x7c;
WriteToI2c(DDX8K_ADDR,CONFIGREG_C,&data,1);
//Reset Configuration Register D
data=0x2f; //xulf
WriteToI2c(DDX8K_ADDR,CONFIGREG_D,&data,1);
//Reset Configuration Register E
data = 0x02;
WriteToI2c(DDX8K_ADDR,CONFIGREG_E,&data,1);
//Reset Configuration Register F
data = 0x00;
WriteToI2c(DDX8K_ADDR,CONFIGREG_F,&data,1);
//Master Mute
data = 0x00;
WriteToI2c(DDX8K_ADDR,MASTER_MUTE_REG,&data,1);
//Master Volume
data = 0xff;
WriteToI2c(DDX8K_ADDR,MASTER_VOL_REG,&data,1);
//Channel 1,2,3,4,5,6,7,8 mute
data = 0x00;
WriteToI2c(DDX8K_ADDR,CHANEL_MUTE_REG,&data,1);
//Channel 1,2,3,4,5,6,7,8 Volume
data = 0x30;
WriteToI2c(DDX8K_ADDR,C1V_REG,&data,8);
//Channel Input Mapping
data = 0x10;
WriteToI2c(DDX8K_ADDR,C12MAP_REG,&data,1);
data = 0x32;
WriteToI2c(DDX8K_ADDR,C34MAP_REG,&data,1);
data = 0x54;
WriteToI2c(DDX8K_ADDR,C56MAP_REG,&data,1);
data = 0x76;
WriteToI2c(DDX8K_ADDR,C78MAP_REG,&data,1);
//Limiter Selection
data = 0x00;
WriteToI2c(DDX8K_ADDR,CLIMITER_SEL0,&data,2);
//Limiter 1 & 2 Rates and Thresholds
data = 0xa6;
WriteToI2c(DDX8K_ADDR,L1RATE_REG,&data,1);
data = 0x67;
WriteToI2c(DDX8K_ADDR,L1THRESHOLDS_REG,&data,1);
data = 0xa6;
WriteToI2c(DDX8K_ADDR,L2RATE_REG,&data,1);
data = 0x67;
WriteToI2c(DDX8K_ADDR,L2THRESHOLDS_REG,&data,1);
//Tone control
data = 0x77;
WriteToI2c(DDX8K_ADDR,TONE_CTRL_REG,&data,1);
}
void write_reg_bit(int addr,BYTE bit,BYTE val)
{
BYTE tmp = 0;
int res;
res = ReadFromI2c(DDX8K_ADDR,addr,&tmp,1);
NOP;
// printf("11-----------------tmp = :%x,res :%d**********\n",tmp,res);
if(val)
tmp |= 0x01<<bit;
else
tmp &= ~(0x01<<bit);
NOP;
res = WriteToI2c(DDX8K_ADDR,addr,&tmp,1);
printf("1addr :%x,tmp = :%x,res :%d\n",addr,tmp,res);
NOP;
res = ReadFromI2c(DDX8K_ADDR,addr,&tmp,1);
printf("2addr :%x,tmp = :%x,res :%d\n",addr,tmp,res);
}
//Enable or Disable External Amplifier Power Down
void ddx_enableEPAD(void)
{
write_reg_bit(CONFIGREG_F,7,1);
}
void ddx_disableEPAD(void)
{
write_reg_bit(CONFIGREG_F,7,0);
}
/*///////////////////////////////////////////////////////////////
sample_rate ctrl input data format
32fs ×010 MSB First Right/Left-Justified 16-bit data
48fs 0001 MSB First Left-Justified Data
1001 LSB First Left-Justified Data
×010 Right-Justified 16-bit Data
×011 Right-Justified 18-bit Data
×100 Right-Justified 20-bit Data
×101 Right-Justified 24-bit Data
64fs 0000 I2S 16 to 24-bit Data default input data format
0001 MSB First Left-Justified Data
1001 LSB First Left-Justified Data
×010 Right-Justified 16-bit Data
×011 Right-Justified 18-bit Data
×100 Right-Justified 20-bit Data
×101 Right-Justified 24-bit Data
*////////////////////////////////////////////////////////////////
void set_inputData_format(BYTE ctrl)
{
UINT16 romSum=0;
BYTE *p = (BYTE *)(&romSum);
ReadFromI2c(DDX8K_ADDR,CONFIGREG_B,p,1);
*p = (ctrl<<2) | (*p & 0xc3);
WriteToI2c(DDX8K_ADDR,CONFIGREG_B,p,1);
}
//channel mapping
//par: pch---processing channel number; ich---input channel number
void ddx_channel_map(BYTE pch,BYTE ich)
{
UINT16 romSum=0;
BYTE *p = (BYTE *)(&romSum);
switch(pch)
{
case 1:
*p = (*p & 0xf8) | (ich-1);
WriteToI2c(DDX8K_ADDR,C12MAP_REG,p,1);
break;
case 2:
*p = (*p & 0x8f) | ((ich-1)<<4);
WriteToI2c(DDX8K_ADDR,C12MAP_REG,p,1);
break;
case 3:
*p = (*p & 0xf8) | (ich-1);
WriteToI2c(DDX8K_ADDR,C34MAP_REG,p,1);
break;
case 4:
*p = (*p & 0x8f) | ((ich-1)<<4);
WriteToI2c(DDX8K_ADDR,C34MAP_REG,p,1);
break;
case 5:
*p = (*p & 0xf8) | (ich-1);
WriteToI2c(DDX8K_ADDR,C56MAP_REG,p,1);
break;
case 6:
*p = (*p & 0x8f) | ((ich-1)<<4);
WriteToI2c(DDX8K_ADDR,C56MAP_REG,p,1);
break;
case 7:
*p = (*p & 0xf8) | (ich-1);
WriteToI2c(DDX8K_ADDR,C78MAP_REG,p,1);
break;
case 8:
*p = (*p & 0x8f) | ((ich-1)<<4);
WriteToI2c(DDX8K_ADDR,C78MAP_REG,p,1);
break;
}
}
//////////////////////////////////////////////////////////////////
//Configuration Register A
/*
sample rate(kHz) | IR(D4~D3) | MCS(D2~D0)
-----------------------------------------------------------------------
| | 1×× | 011 | 010 | 001 | 000
-----------------------------------------------------------------------
32, 44.1, 48 | 00 | 128fs | 256fs | 384fs | 512fs | 768fs
88.2, 96 | 01 | 64fs | 128fs | 192fs | 256fs | 384fs
176.4, 192 | 10 | 64fs | 128fs | 192fs | 256fs | 384fs
Reserved | NA | NA | NA | NA | NA | NA
-----------------------------------------------------------------------
*/
///////////////////////////////////////////////////////////////////
void set_inputClock(BYTE IR,BYTE MCS)
{
UINT16 romSum=0;
BYTE *p = (BYTE *)(&romSum);
*p = (*p & 0xe0) | ((IR<<3) | MCS);
WriteToI2c(DDX8K_ADDR,CONFIGREG_A,p,1);
}
//Bass Management
//set Configuration Register A bit 5 will enable or disable bass management
void ddx_enable_BassManagement(void)
{
write_reg_bit(CONFIGREG_A,5,1);
}
void ddx_disable_BassManagement(void)
{
write_reg_bit(CONFIGREG_A,5,0);
}
//Reading a Coefficient Value From RAM
UINT32 ddx_readCoefVal(BYTE regAddr)
{
UINT32 tmp;
UINT16 romSum=0;
BYTE *p = (BYTE *)(&romSum);
// printf("**********************************************\n");
//write 8-bit address to I2C register 1Ch
*p = regAddr;
WriteToI2c(DDX8K_ADDR,0x1c,p,1);
*p = 0;
ReadFromI2c(DDX8K_ADDR,0x1c,p,1);
// printf("the val of register 0x1c is:%x\n",*p);
//read top 8-bits of coefficient in I2C address 1Dh
*p = 0;
ReadFromI2c(DDX8K_ADDR,0x1d,p,1);
// printf("the val of register 0x1d is:%x\n",*p);
tmp = (*p << 16) & 0xff0000;
//read middle 8-bits of coefficient in I2C address 1Fh
*p = 0;
ReadFromI2c(DDX8K_ADDR,0x1e,p,1);
// printf("the val of register 0x1e is:%x\n",*p);
tmp = tmp | ((*p << 8) & 0xff00);
//read bottom 8-bits of coefficient in I2C address 1Fh
*p=0;
ReadFromI2c(DDX8K_ADDR,0x1f,p,1);
// printf("the val of register 0x1f is:%x\n",*p);
tmp = tmp | *p;
return tmp;
}
//Writing a single Coefficient Value to RAM
void ddx_writeCoefVal(BYTE regAddr,UINT32 coefVal)
{
UINT16 romSum=0;
BYTE *p = (BYTE *)(&romSum);
//write 8-bit address to I2C register 1Ch
*p = regAddr;
WriteToI2c(DDX8K_ADDR,0x1c,p,1);
//write top 8-bits of coefficient in I2C address 1Dh
*p = (coefVal & 0xff0000) >> 16;
WriteToI2c(DDX8K_ADDR,0x1d,p,1);
//write middle 8-bits of coefficient in I2C address 1Eh
*p = (coefVal & 0x00ff00) >> 8;
WriteToI2c(DDX8K_ADDR,0x1e,p,1);
//write bottom 8-bits of coefficient in I2C address 1Fh
*p = (coefVal & 0x0000ff);
WriteToI2c(DDX8K_ADDR,0x1f,p,1);
//write control
write_reg_bit(0x2c,0,1);
}
//Writing a set of Coefficient Values to RAM
void ddx_writeCoefValSets(BYTE startAddr,coef_factor factor)
{
UINT16 romSum=0;
BYTE *p = (BYTE *)(&romSum);
//write 8-bit address to I2C register 1Ch
*p = startAddr;
WriteToI2c(DDX8K_ADDR,0x1c,p,1);
//write factor b2
*p = (factor.b2 & 0xff0000) >> 16;
WriteToI2c(DDX8K_ADDR,0x1d,p,1);
*p = (factor.b2 & 0x00ff00) >> 8;
WriteToI2c(DDX8K_ADDR,0x1e,p,1);
*p = (factor.b2 & 0x0000ff);
WriteToI2c(DDX8K_ADDR,0x1f,p,1);
//write factor b0
*p = (factor.b0 & 0xff0000) >> 16;
WriteToI2c(DDX8K_ADDR,0x20,p,1);
*p = (factor.b0 & 0x00ff00) >> 8;
WriteToI2c(DDX8K_ADDR,0x21,p,1);
*p = (factor.b0 & 0x0000ff);
WriteToI2c(DDX8K_ADDR,0x22,p,1);
//write factor a2
*p = (factor.a2 & 0xff0000) >> 16;
WriteToI2c(DDX8K_ADDR,0x23,p,1);
*p = (factor.a2 & 0x00ff00) >> 8;
WriteToI2c(DDX8K_ADDR,0x24,p,1);
*p = (factor.a2 & 0x0000ff);
WriteToI2c(DDX8K_ADDR,0x25,p,1);
//write factor a1
*p = (factor.a1 & 0xff0000) >> 16;
WriteToI2c(DDX8K_ADDR,0x26,p,1);
*p = (factor.a1 & 0x00ff00) >> 8;
WriteToI2c(DDX8K_ADDR,0x27,p,1);
*p = (factor.a1 & 0x0000ff);
WriteToI2c(DDX8K_ADDR,0x28,p,1);
//write factor b1
*p = (factor.b1 & 0xff0000) >> 16;
WriteToI2c(DDX8K_ADDR,0x29,p,1);
*p = (factor.b1 & 0x00ff00) >> 8;
WriteToI2c(DDX8K_ADDR,0x2a,p,1);
*p = (factor.b1 & 0x0000ff);
WriteToI2c(DDX8K_ADDR,0x2b,p,1);
//write control
write_reg_bit(0x2c,1,1);
}
//HPB register i.e. Configuation Register C-02h,Bit 7
//1: disable this feature
//0: enable this feature
//input:1---disable,0---enable
//enable High Pass Filter
void enable_hpf(void)
{
write_reg_bit(CONFIGREG_C,7,0);
}
void disable_hpf(void)
{
write_reg_bit(CONFIGREG_C,7,1);
}
//tone control: include treble control and bass control
//input:
//updown: 1---boost tone -1---cut tone
BYTE ddx_trebleCtrl(int updown) //xulf modified 2004-01-13
{
BYTE romSum=0;
BYTE *p = (BYTE *)(&romSum);
ReadFromI2c(DDX8K_ADDR,TONE_CTRL_REG,p,1);
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -