void codec_config()
{
int i;
codec_reg_set(CODEC_AIC23_POWERDOWN, aic23_config.regs[CODEC_AIC23_POWERDOWN]);
for(i = 0; i < CODEC_AIC23_NUMREGS; i++)
{
if(i != CODEC_AIC23_POWERDOWN)
{
codec_reg_set(i, aic23_config.regs[i]);
}
}
}
////////////////////////////////////////////////////
// 功能: 打开或者关闭声音
// 输入:
// 输出:
// 返回:
// 说明:
////////////////////////////////////////////////////
void SetMuteMode(char mode)
{
if( mode )
codec_reg_clear(A_CODEC_CR1, DAC_MUTE);
else
codec_reg_set(A_CODEC_CR1, DAC_MUTE);
}
////////////////////////////////////////////////////
// 功能: 利用DMA播放数据
// 输入:
// 输出:
// 返回:
// 说明:
////////////////////////////////////////////////////
static void set_volume_reg(unsigned long arg)
{
if (arg == 0)
{
codec_reg_write(A_CODEC_CGR8, GOL(31));
codec_reg_write(A_CODEC_CGR9, GOR(31));
codec_reg_write(A_CODEC_CGR1, GODR(15) | GODL(15));
codec_reg_set(A_CODEC_CR1, DAC_MUTE);
return;
}
codec_reg_clear(A_CODEC_CR1, DAC_MUTE);
if (arg >= 8)
{
codec_reg_write(A_CODEC_CGR1, GODR(0) | GODL(0));
codec_reg_write(A_CODEC_CGR8, GOL(31 - (arg - 8)));
codec_reg_write(A_CODEC_CGR9, GOR(31 - (arg - 8)));
}
else
{
codec_reg_write(A_CODEC_CGR1, GODR(15 - arg * 2) | GODL(15 - arg * 2));
codec_reg_write(A_CODEC_CGR8, GOL(31));
codec_reg_write(A_CODEC_CGR9, GOR(31));
}
}
////////////////////////////////////////////////////
// 功能: 打开codec设备
// 输入:
// 输出:
// 返回:
// 说明:
////////////////////////////////////////////////////
void OpenMediaCodecDevice()
{
unsigned char pmr1;
pmr1 = codec_reg_read(A_CODEC_PMR1);
kdebug(mod_media, PRINT_INFO, "pmr1 = %x\n",pmr1);
#ifdef CODEC_ALWAYS_OPEN
if( codec_reg_read(A_CODEC_PMR1) & 0x90)
{ //CODEC处于开的状态，不需要重新打开
if( fDeviceStatus == DEVICE_OPEN_STATUS )
{
fDeviceStatus = DEVICE_OPEN_STATUS;
kdebug(mod_media, PRINT_INFO, "codec is already open\n");
return;
}
goto OPEN_MEDIA_CODEC_DEVICE;
}
else //CODEC处于关闭状态，必须重新打开CODEC
{
kdebug(mod_media, PRINT_ERROR, "codec is close, need to open codec\n");
goto OPEN_MEDIA_CODEC_DEVICE;
}
#endif
if( fDeviceStatus == DEVICE_OPEN_STATUS )
{
kdebug(mod_media, PRINT_INFO, "codec is already open\n");
return;
}
#ifdef CODEC_ALWAYS_OPEN
OPEN_MEDIA_CODEC_DEVICE:
SetMoseCe(1);//0 //修改复位开机声音小的问题。
#endif
kdebug(mod_media, PRINT_INFO, "open media device\n");
fDeviceStatus = DEVICE_OPEN_STATUS;
//codec寄存器设置
codec_reg_write(A_CODEC_AICR, 0x0F);
codec_reg_write(A_CODEC_TR1,0x00); // 0x02);
codec_reg_write(A_CODEC_IFR, 0xFF); //Write 1 to Update of the flag
codec_reg_write(A_CODEC_ICR, 0x3F);
codec_reg_write(A_CODEC_CR2, 0x60);
codec_reg_write(A_CODEC_CR3, 0xC0); //??
codec_reg_write(A_CODEC_CGR8, 0x1f); //??
codec_reg_write(A_CODEC_CGR9, 0x1f); //??
codec_reg_write(A_CODEC_CGR1, 0xff);
codec_reg_write(A_CODEC_CGR10, 0);
codec_reg_clear(A_CODEC_PMR2, SB);
MillinsecoundDelay(10);
codec_reg_clear(A_CODEC_PMR2, SB_SLEEP);
codec_reg_clear(A_CODEC_PMR1, SB_DAC);
codec_reg_clear(A_CODEC_PMR1, SB_ADC);
codec_reg_clear(A_CODEC_PMR2, SB_MC);
codec_reg_clear(A_CODEC_PMR1, SB_MIX);
codec_reg_clear(A_CODEC_PMR1, SB_OUT);
MillinsecoundDelay(20);
// 关闭音量开关
codec_reg_set(A_CODEC_CR1, DAC_MUTE);
}
////////////////////////////////////////////////////
// 功能: 关闭codec设备
// 输入:
// 输出:
// 返回:
// 说明:
////////////////////////////////////////////////////
void CloseMediaCodecDevice()
{
#ifdef CODEC_ALWAYS_OPEN
SetMoseCe(0);
#endif
kdebug(mod_media, PRINT_INFO, "close meida device\n");
fDeviceStatus = DEVICE_CLOSE_STATUS;
//close codec
codec_reg_write(A_CODEC_CGR8, 0x1f);
codec_reg_write(A_CODEC_CGR9, 0x1f);
codec_reg_write(A_CODEC_CGR1, 0xff);
codec_reg_write(A_CODEC_CGR10, 0);
codec_reg_set(A_CODEC_PMR1, SB_OUT);
codec_reg_set(A_CODEC_PMR2, SB_SLEEP);
codec_reg_set(A_CODEC_PMR2, SB);
codec_reg_set(A_CODEC_PMR1, SB_MIX | SB_DAC | SB_ADC);
}
////////////////////////////////////////////////////
// 功能: 音频初始化
// 输入:
// 输出:
// 返回:
// 说明:
////////////////////////////////////////////////////
int pcm_ioctl(unsigned int cmd, unsigned long arg)
{
unsigned int data, temp, aicfr, aiccr;
switch (cmd)
{
case PCM_SET_SAMPLE_RATE:
#ifdef KPRINTF_DEF
kprintf("pcm_ioctl, PCM_SET_SAMPLE_RATE,arg = %d\n", arg);
#endif
set_sample_rate(arg);
break;
case PCM_SET_CHANNEL:
#ifdef KPRINTF_DEF
kprintf("pcm_ioctl, PCM_SET_CHANNEL,arg = %d.\n", arg);
#endif
if (arg == 2)
__aic_disable_mono2stereo(); //CLRREG32(AIC_CR, AICCR_M2S);
else if (arg == 1)
__aic_enable_mono2stereo(); //SETREG32(AIC_CR, AICCR_M2S);
break;
case PCM_SET_FORMAT:
#ifdef KPRINTF_DEF
kprintf("pcm_ioctl, PCM_SET_FORMAT, arg = %d.\n",arg);
#endif
// Config for Playback
aicfr = INREG32(AIC_FR) & (~AIC_FR_TFTH_MASK);
aiccr = INREG32(AIC_CR) & (~AIC_CR_OSS_MASK);
temp = INREG32(A_DMA_DCM(PLAYBACK_CHANNEL)) & (~DCM_DP_MASK);
if (arg == 16)
{
aicfr |= AICFR_TFTH(16);
temp |= DCM_DP_16BIT;
aiccr &= ~AIC_CR_AVSTSU;
aiccr |= AIC_CR_OSS_16BIT;
}
else if (arg == 8)
{
aicfr |= AICFR_TFTH(16);
temp |= DCM_DP_08BIT;
aiccr |= AIC_CR_AVSTSU;
aiccr |= AIC_CR_OSS_8BIT;
}
OUTREG32(AIC_FR, aicfr);
OUTREG32(AIC_CR, aiccr);
OUTREG32(A_DMA_DCM(PLAYBACK_CHANNEL), temp);
// Config for Recorder
temp = INREG32(A_DMA_DCM(RECORD_CHANNEL)) & (~DCM_DP_MASK);
if (arg == 16)
temp |= DCM_DP_16BIT;
else if (arg == 8)
temp |= DCM_DP_08BIT;
OUTREG32(A_DMA_DCM(RECORD_CHANNEL), temp);
break;
case PCM_SET_MUTE:
#ifdef KPRINTF_DEF
kprintf("pcm_ioctl, PCM_SET_MUTE, arg = %d.\n", arg);
#endif
if ((g_volume == 0) || arg == 1)
{
codec_reg_set(A_CODEC_CR1, DAC_MUTE);
}
else
{
codec_reg_clear(A_CODEC_CR1, DAC_MUTE);
}
break;
case PCM_SET_VOL:
case PCM_SET_HP_VOL:
#ifdef KPRINTF_DEF
kprintf("pcm_ioctl, PCM_SET_HP_VOL, val = %d.\n", arg);
#endif
{
int RegVolume = 0, VolDif = 0, JumpCoun = 0;
data = arg > 31 ? 31 : arg;
g_volume = data;
RegVolume = get_volume_reg();
VolDif = RegVolume > data ? (RegVolume - data) : (data - RegVolume);
#ifdef KPRINTF_DEF
kprintf("set volume: voldif = %d,data = %d\n",VolDif,data);
#endif
if (VolDif > 7)
{
for (JumpCoun = 0; JumpCoun <= data; JumpCoun++)
{
set_volume_reg(JumpCoun);
//MillinsecoundDelay(10);
}
}
else
{
set_volume_reg(data);
}
}
break;
case PCM_SET_PAUSE:
#ifdef KPRINTF_DEF
kprintf("pcm_ioctl, PCM_SET_PAUSE\n");
#endif
MillinsecoundDelay(10);
CLRREG32(AIC_CR, AIC_CR_ERPL);
CLRREG32(A_DMA_DCS(PLAYBACK_CHANNEL), DCS_AR | DCS_HLT | DCS_CTE | DCS_CT);
SETREG32(AIC_CR, AIC_CR_FLUSH_FIFO);
OUTREG32(AIC_SR, 0x00000000);
break;
case PCM_SET_PLAY:
#ifdef KPRINTF_DEF
kprintf("pcm_ioctl, PCM_SET_PLAY\n");
#endif
codec_reg_clear(A_CODEC_PMR1, SB_ADC);
jz_audio_reset();
MillinsecoundDelay(10);
codec_reg_clear(A_CODEC_CR1, HP_DIS);
codec_reg_set(A_CODEC_PMR1, SB_LIN);
codec_reg_clear(A_CODEC_PMR1, SB_DAC);
codec_reg_set(A_CODEC_PMR1, SB_ADC);
SETREG32(AIC_CR, AIC_CR_ERPL);
break;
case PCM_SET_REPLAY:
#ifdef KPRINTF_DEF
kprintf("pcm_ioctl, PCM_SET_REPLAY\n");
#endif
CLRREG32(AIC_CR, AIC_CR_EREC);
CLRREG32(A_DMA_DCS(RECORD_CHANNEL), DCS_AR | DCS_HLT | DCS_CTE | DCS_CT);
codec_reg_clear(A_CODEC_CR2, ADC_HPF);
codec_reg_set(A_CODEC_CR1, SB_MICBIAS);
codec_reg_clear(A_CODEC_CR1, BYPASS);
codec_reg_set(A_CODEC_CR1, DACSEL);
codec_reg_write(A_CODEC_CR3, 0xC0);
codec_reg_clear(A_CODEC_PMR2, GIM);
pcm_ioctl(PCM_SET_PLAY, 0);
break;
case PCM_SET_RECORD:
#ifdef KPRINTF_DEF
kprintf("pcm_ioctl, PCM_SET_RECORD\n");
#endif
jz_audio_reset();
codec_reg_clear(A_CODEC_CR1, SB_MICBIAS);
codec_reg_write(A_CODEC_CR3, 0x40);
codec_reg_set(A_CODEC_PMR2, GIM);
codec_reg_set(A_CODEC_PMR1, SB_LIN);
codec_reg_set(A_CODEC_CR2, ADC_HPF);
codec_reg_clear(A_CODEC_PMR1, SB_ADC);
codec_reg_write(A_CODEC_CGR10, 0x88);
break;
case PCM_SET_RECORD_FM:
#ifdef KPRINTF_DEF
kprintf("pcm_ioctl, PCM_SET_RECORD_FM\n");
#endif
jz_audio_reset();
codec_reg_clear(A_CODEC_CR1, DACSEL);
codec_reg_set(A_CODEC_CR2, ADC_HPF);
codec_reg_write(A_CODEC_CGR10, 0xff);
break;
case PCM_RESET:
#ifdef KPRINTF_DEF
kprintf("pcm_ioctl, PCM_RESET\n");
#endif
CLRREG32(A_DMA_DCS(PLAYBACK_CHANNEL), DCS_AR | DCS_HLT | DCS_CTE | DCS_CT);
break;
case PCM_GET_HP_VOL:
return get_volume_reg();
case PCM_GET_VOL:
return get_volume_reg();
case PCM_POWER_OFF:
#ifdef KPRINTF_DEF
kprintf("pcm_ioctl, PCM_POWER_OFF\n");
#endif
codec_reg_set(A_CODEC_CR1, DAC_MUTE);
return 1;
case PCM_POWER_ON:
#ifdef KPRINTF_DEF
kprintf("pcm_ioctl, PCM_POWER_ON\n");
#endif
codec_reg_clear(A_CODEC_CR1, DAC_MUTE);
return 1;
default:
#ifdef KPRINTF_DEF
kprintf("pcm_ioctl:Unsupported I/O command: %08x\n", cmd);
#endif
return -1;
}
return 0;
}
