/*
Description:
AT command handler, handle command AT commands at*maudvol=P1,P2,P3
Parameters:
pChip -- Pointer to chip data structure
ParamCount -- Count of parameter array
Params --- P1,P2,...,P6
*/
int AtMaudVol(brcm_alsa_chip_t *pChip, Int32 ParamCount, Int32 *Params)
{
int *pVolume;
int mode, vol;
aTrace(LOG_AUDIO_DRIVER, "%s P1-P6=%ld %ld %ld %ld %ld %ld cnt=%ld\n",
__func__, Params[0], Params[1], Params[2],
Params[3], Params[4], Params[5], ParamCount);
csl_caph_ControlHWClock(TRUE);
switch (Params[0]) {
case 6: /*at*maudvol=6 */
mode = AUDCTRL_GetAudioMode();
/*Get volume. Range -36 ~ 0 dB in Driver and DSP: */
Params[0] =
AUDCTRL_GetTelephonySpkrVolume(AUDIO_GAIN_FORMAT_mB);
Params[0] = Params[0] / 100; /* dB */
Params[0] += AudParmP()[mode].voice_volume_max;
/* Range 0~36 dB shown in PCG */
/*
pVolume = pChip->streamCtl[
CTL_STREAM_PANEL_VOICECALL -1].ctlLine[mode].iVolume;
Params[0] = pVolume[0];
*/
aTrace(LOG_AUDIO_DRIVER,
"%s pVolume[0] %ld\n", __func__, Params[0]);
return 0;
case 7: /* at*maudvol=7,x Range 0~36 dB in PCG */
mode = AUDCTRL_GetAudioMode();
/*
mode = pChip->streamCtl[
CTL_STREAM_PANEL_VOICECALL-1].iLineSelect[1];
*/
pVolume =
pChip->streamCtl[CTL_STREAM_PANEL_VOICECALL -
1].ctlLine[mode].iVolume;
pVolume[0] = Params[1];
pVolume[1] = Params[1];
vol = Params[1];
vol -= AudParmP()[mode].voice_volume_max;
/* Range -36 ~ 0 dB in DSP */
AUDCTRL_SetTelephonySpkrVolume(AUDIO_SINK_UNDEFINED,
(vol * 100),
AUDIO_GAIN_FORMAT_mB);
aTrace(LOG_AUDIO_DRIVER, "%s pVolume[0] %d mode=%d vol %d\n",
__func__, pVolume[0], mode, vol);
return 0;
default:
aWarn("%s Unsupported cmd %ld\n", __func__,
Params[0]);
break;
}
return -1;
}
/*****************************************************************************
*
* Function Name: hawaii_hw_free
*
* Description: Dissable clocks, if both playback and capture is finished
*
*****************************************************************************/
static int hawaii_hw_free(struct snd_pcm_substream *substream)
{
struct snd_soc_pcm_runtime *rtd = substream->private_data;
struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
struct caph_i2s *i2s = snd_soc_dai_get_drvdata(cpu_dai);
if (i2s->fmTxRunning == 0 && i2s->fmRxRunning == 0 && useclk) {
ssp_ControlHWClock(FALSE);
csl_caph_ControlHWClock(FALSE);
useclk = FALSE;
}
return 0;
}
/*****************************************************************************
*
* Function Name: hawaii_hw_params
*
* Description: Enable clocks
*
*****************************************************************************/
static int hawaii_hw_params(struct snd_pcm_substream *substream,
struct snd_pcm_hw_params *params)
{
struct snd_soc_pcm_runtime *rtd = substream->private_data;
struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
struct caph_i2s *i2s = snd_soc_dai_get_drvdata(cpu_dai);
if (i2s->fmTxRunning == 0 && i2s->fmRxRunning == 0 && !useclk) {
csl_caph_ControlHWClock(TRUE);
ssp_ControlHWClock(TRUE);
useclk = TRUE;
}
return 0;
}
void HandleAudioEventrespCb(RPC_Msg_t *pMsg,
ResultDataBufHandle_t dataBufHandle,
UInt32 userContextData)
{
if (MSG_AUDIO_CALL_STATUS_IND == pMsg->msgId) {
UInt32 *codecID = NULL;
codecID = (UInt32 *) pMsg->dataBuf;
aTrace(LOG_AUDIO_DRIVER,
"HandleAudioEventrespCb : codecid=0x%lx \r\n",
(*codecID));
if ((*codecID) != 0) /* Make sure codeid is not 0 */
AUDDRV_Telephone_RequestRateChange((UInt8) (*codecID));
}
if (MSG_AUDIO_START_TUNING_IND == pMsg->msgId) {
unsigned int addr = *((int *) pMsg->dataBuf);
aTrace(LOG_AUDIO_DRIVER,
"HandleAudioEventrespCb : start tuning addr=0x%x\r\n",
addr);
AUDDRV_SetTuningFlag(1);
csl_caph_ControlHWClock(TRUE);
csl_ControlHWClock_156m(TRUE);
csl_ControlHWClock_2p4m(TRUE);
}
if (MSG_AUDIO_STOP_TUNING_IND == pMsg->msgId) {
unsigned int addr = *((int *) pMsg->dataBuf);
aTrace(LOG_AUDIO_DRIVER,
"HandleAudioEventrespCb : stop tuning addr=0x%x\r\n",
addr);
AUDDRV_SetTuningFlag(0);
if (csl_caph_hwctrl_allPathsDisabled() == TRUE) {
csl_caph_ControlHWClock(FALSE);
csl_ControlHWClock_156m(FALSE);
csl_ControlHWClock_2p4m(FALSE);
}
}
if (MSG_AUDIO_TUNING_SETPARM_IND == pMsg->msgId) {
struct AudioTuningParamInd_st paramInd =
*((struct AudioTuningParamInd_st *) pMsg->dataBuf);
aTrace(LOG_AUDIO_DRIVER,
"HandleAudioEventrespCb : mode %d, tune param=%d value=%d\r\n",
(int)paramInd.audioModeApp,
(int)paramInd.audioParamType,
*((UInt16 *)¶mInd.param[0]));
}
if ((MSG_AUDIO_CTRL_GENERIC_RSP == pMsg->msgId) ||
(MSG_AUDIO_CTRL_DSP_RSP == pMsg->msgId) ||
(MSG_AUDIO_COMP_FILTER_RSP == pMsg->msgId)) {
aTrace(LOG_AUDIO_DRIVER,
"HandleAudioEventrespCb GENERIC_DSP_RSP: tid=%ld\n",
pMsg->tid);
}
if (dataBufHandle)
RPC_SYSFreeResultDataBuffer(dataBufHandle);
else
aTrace(LOG_AUDIO_DRIVER,
"HandleAudioEventrespCb : dataBufHandle is NULL \r\n");
}
int AtMaudMode(brcm_alsa_chip_t *pChip, Int32 ParamCount, Int32 *Params)
{
AUDIO_SOURCE_Enum_t mic = AUDIO_SOURCE_ANALOG_MAIN;
AUDIO_SINK_Enum_t spk = AUDIO_SINK_HANDSET;
AudioMode_t mode = AUDIO_SINK_HANDSET;
AudioApp_t app = AUDIO_APP_VOICE_CALL, currapp;
int rtn = 0; /* 0 means Ok */
static UInt8 loopback_status = 0, loopback_input = 0, loopback_output =
0, sidetone_mode = 0;
static UInt8 loopback_api_input, loopback_api_output;
Int32 pCurSel[2];
aTrace(LOG_AUDIO_DRIVER, "%s P1-P6=%ld %ld %ld %ld %ld %ld cnt=%ld\n",
__func__, Params[0], Params[1], Params[2],
Params[3], Params[4], Params[5], ParamCount);
csl_caph_ControlHWClock(TRUE);
switch (Params[0]) {
case 0: /* at*maudmode 0 */
break;
case 1: /* at*maudmode 1 mode */
break;
case 8: /* at*maudmode=8 */
Params[0] = loopback_status;
aTrace(LOG_AUDIO_DRIVER,
" %s loopback status is %d\n", __func__,
loopback_status);
DEBUG(" %s loopback status is %d\n", __func__, loopback_status);
break;
case 9: /* at*maudmode=9,x. x = 0 --> disable; x =1 enable */
loopback_status = Params[1];
if (loopback_status > 1)
loopback_status = 1;
aTrace(LOG_AUDIO_DRIVER,
" %s set loopback status %d (1:ena 0:dis)\n",
__func__, loopback_status);
break;
case 10: /* at*maudmode=10 --> get loopback path */
/* Per PCG request
if (loopback_output > 2) loopback_output = 2; */
Params[0] = loopback_input;
Params[1] = loopback_output;
aTrace(LOG_AUDIO_DRIVER,
"%s loopback path is from src %d to sink %d\n",
__func__, loopback_input, loopback_output);
break;
/* at*maudmode=11,x,y --> set loopback path. */
/* mic: 0 = default mic, 1 = main mic */
/* spk: 0 = handset, 1 = headset, 2 = loud speaker */
case 11:
loopback_input = loopback_api_input = Params[1];
loopback_output = loopback_api_output = Params[2];
sidetone_mode = Params[3];
if (((loopback_input > 6) && (loopback_input != 11)) ||
((loopback_output > 2) && (loopback_output != 9) &&
(loopback_output != 4))) {
aError(
"%s srr/sink exceeds its range.\n",
__func__);
rtn = -1;
break;
}
if (loopback_output == 2) /* use IHF */
loopback_api_output = 4;
if (loopback_input == 0) /* default mic: use main mic */
loopback_api_input = 1;
loopback_status = 1;
/* enable the HW loopback without DSP. */
AUDCTRL_SetAudioLoopback(TRUE, loopback_api_input,
loopback_api_output, sidetone_mode);
aTrace(LOG_AUDIO_DRIVER,
"%s ena lpback: src %d sink %d sidetone %d\n",
__func__, loopback_api_input,
loopback_api_output, sidetone_mode);
break;
case 12: /* at*maudmode=12 --> disable loopback path */
loopback_status = 0;
AUDCTRL_SetAudioLoopback(FALSE, loopback_api_input,
loopback_api_output, sidetone_mode);
aTrace(LOG_AUDIO_DRIVER,
"%s dis lpback: src %d sink %d sidetone %d\n",
__func__, loopback_api_input,
loopback_api_output, sidetone_mode);
break;
case 13: /* at*maudmode=13 --> Get call ID */
aError(
"%s get call ID is not supported\n", __func__);
rtn = -1;
break;
/* at*maudmode=14 --> read current mode and app */
case 14:
Params[0] = AUDCTRL_GetAudioApp();
Params[1] = AUDCTRL_GetAudioMode();
aTrace(LOG_AUDIO_DRIVER, "%s app %ld mode %ld\n",
__func__, Params[0], Params[1]);
break;
/* at*maudmode=15 --> set current mode and app */
case 15:
app = Params[1];
mode = Params[2];
AUDCTRL_GetSrcSinkByMode(mode, &mic, &spk);
pCurSel[0] =
pChip->streamCtl[CTL_STREAM_PANEL_VOICECALL -
1].iLineSelect[0];
/* save current setting */
pCurSel[1] = pChip->
streamCtl[CTL_STREAM_PANEL_VOICECALL - 1].iLineSelect[1];
/* Update 'VC-SEL' -- */
pChip->streamCtl[CTL_STREAM_PANEL_VOICECALL - 1].
iLineSelect[0] = mic;
pChip->streamCtl[CTL_STREAM_PANEL_VOICECALL - 1].
iLineSelect[1] = spk;
#ifdef CONFIG_BCM_MODEM
RPC_SetProperty(RPC_PROP_AUDIO_MODE,
(UInt32)(app * AUDIO_MODE_NUMBER + mode));
#endif
/* for PCG to set new app */
currapp = AUDCTRL_GetAudioApp();
if (currapp != app) {
/* Remove the current app
before setting the new app */
AUDCTRL_RemoveAudioApp(currapp);
AUDCTRL_SaveAudioApp(app);
}
if (app == AUDIO_APP_VOICE_CALL
|| app == AUDIO_APP_VOICE_CALL_WB
|| app == AUDIO_APP_VT_CALL
|| app == AUDIO_APP_VT_CALL_WB) {
AUDCTRL_SetTelephonyMicSpkr(mic, spk, false);
AUDCTRL_SetAudioMode(mode, app);
} else if (app == AUDIO_APP_MUSIC) {
if (AUDCTRL_InVoiceCall() == FALSE) {
AUDCTRL_SwitchPlaySpk_forTuning(mode);
AUDCTRL_SaveAudioMode(mode);
AUDCTRL_SaveAudioApp(app);
}
} else {
/* Handling all other apps cases */
/* For PCG to set new Mode */
AUDCTRL_SetAudioMode(mode, app);
}
aTrace(LOG_AUDIO_DRIVER, "%s mic %d spk %d mode %ld app %ld\n",
__func__, mic, spk, Params[2],
Params[1]);
break;
/* read back AUDIO_APP_NUMBER and AUDIO_APP_MM_NUMBER */
/* needs to match to enum AudioTuneCommand_t in at_audtune.c */
case 16:
Params[0] = AUDIO_APP_NUMBER;
Params[1] = AUDIO_APP_MM_NUMBER;
break;
case 99: /* at*maudmode=99 --> stop tuning */
break;
/* at*maudmode=100 --> set external audio
amplifer gain in PMU */
/* PCG and loadcal currently use Q13p2 gain format */
case 100:
{
short gain;
gain = (short)Params[3];
if (Params[1] == 3) {
aTrace(LOG_AUDIO_DRIVER, "Params[2] = %d, "
"Params[3] %d, audio mode %d\n",
(int)Params[2], (int)Params[3],
AUDCTRL_GetAudioMode());
if ((Params[2] == PARAM_PMU_SPEAKER_PGA_LEFT_CHANNEL)
|| (Params[2] == PARAM_PMU_SPEAKER_PGA_RIGHT_CHANNEL)) {
if (AUDCTRL_GetAudioMode() == AUDIO_MODE_HEADSET
|| AUDCTRL_GetAudioMode() ==
AUDIO_MODE_TTY) {
aTrace(LOG_AUDIO_DRIVER,
"%s ext headset "
"speaker gain = %d\n",
__func__, gain);
if (Params[2] ==
PARAM_PMU_SPEAKER_PGA_LEFT_CHANNEL)
extern_hs_set_gain(gain*25,
AUDIO_HS_LEFT);
else if (Params[2] ==
PARAM_PMU_SPEAKER_PGA_RIGHT_CHANNEL)
extern_hs_set_gain(gain*25,
AUDIO_HS_RIGHT);
} else if (AUDCTRL_GetAudioMode() ==
AUDIO_MODE_SPEAKERPHONE) {
aTrace(LOG_AUDIO_DRIVER, "%s ext IHF "
"speaker gain = %d\n",
__func__, gain);
extern_ihf_set_gain(gain*25);
}
}
/* Params[2] checking */
aTrace(LOG_AUDIO_DRIVER,
"Params[2] = %d, Params[3] %d,"
" audio mode %d\n",
(int)Params[2], (int)Params[3],
AUDCTRL_GetAudioMode());
if (Params[2] == PARAM_PMU_HIGH_GAIN_MODE_FLAG) {
if (AUDCTRL_GetAudioMode() ==
AUDIO_MODE_SPEAKERPHONE) {
aTrace(LOG_AUDIO_DRIVER,
"ext IHF high gain "
"mode = %d\n",
(int)Params[3]);
extern_ihf_en_hi_gain_mode(
(int)Params[3]);
} else if (AUDCTRL_GetAudioMode() ==
AUDIO_MODE_HEADSET ||
AUDCTRL_GetAudioMode() ==
AUDIO_MODE_TTY) {
aTrace(LOG_AUDIO_DRIVER,
"ext HS high gain "
"mode = %d\n",
(int)Params[3]);
extern_hs_en_hi_gain_mode(
(int)Params[3]);
}
}
} /* if (Params[1] == 3) */
} /* case 100 */
break;
default:
aWarn("%s Unsupported cmd %ld\n", __func__,
Params[0]);
rtn = -1;
break;
}
return rtn;
}
int AtMaudTst(brcm_alsa_chip_t *pChip, Int32 ParamCount, Int32 *Params)
{
aTrace(LOG_AUDIO_DRIVER, "%s P1-P6=%ld %ld %ld %ld %ld %ld cnt=%ld.\n",
__func__, Params[0], Params[1], Params[2],
Params[3], Params[4], Params[5], ParamCount);
/* test command 110/101 is to control the HW clock.
In this case, dont enable the clock */
if (Params[0] != 110 && Params[0] != 101)
csl_caph_ControlHWClock(TRUE);
switch (Params[0]) {
case 50: /* set audio debug level */
gAudioDebugLevel = Params[1];
break;
case 51: /* print audio debug level */
pr_info("audio debug level is 0x%x\n", gAudioDebugLevel);
break;
case 98:
#ifdef CONFIG_BCM_MODEM
DJB_GetStatistics();
#endif
break;
case 99:
if (voip_running) {
AUDTST_VoIP_Stop();
voip_running = FALSE;
}
break;
case 100:
if (!voip_running) {
/* Params[1] - Mic
Params[2] - speaker
Params[3] - Delay (msec)
Params[4] - Codectype:
Params[5] - Codec bit rate: */
AUDTST_VoIP(Params[1],
Params[2], Params[3], Params[4], Params[5]);
voip_running = TRUE;
}
break;
case 110:
if (Params[1] == 1) {
aTrace(LOG_AUDIO_DRIVER, "Enable CAPH clock\n");
csl_caph_ControlHWClock(TRUE);
} else if (Params[1] == 0) {
aTrace(LOG_AUDIO_DRIVER, "Disable CAPH clock\n");
csl_caph_ControlHWClock(FALSE);
}
break;
case 500: /*at*maudtst=500, */
{
char *address;
unsigned int value = 0, gain1 = 0, gain2 = 0,
gain3 = 0, gain4 = 0;
unsigned int index;
#define CHAL_CAPH_SRCM_MAX_FIFOS 15
#define SRCMIXER_A SRCMIXER_SRC_M1D1_CH1M_GAIN_CTRL_OFFSET
#define SRCMIXER_B SRCMIXER_SRC_M1D0_CH1M_GAIN_CTRL_OFFSET
/* 4 bytes */
#define SRCMIXER_MIX_CH_GAIN_CTRL_OFFSET ((SRCMIXER_A - SRCMIXER_B)/4)
address = (char *)ioremap_nocache((UInt32)
(AUDIOH_BASE_ADDR +
AUDIOH_AUDIORX_VRX1_OFFSET),
sizeof(UInt32));
if (!address) {
pr_err(" address ioremap failed\n");
return 0;
}
value = ioread32(address);
iounmap(address);
gain1 = value;
gain1 &=
(AUDIOH_AUDIORX_VRX1_AUDIORX_VRX_GAINCTRL_MASK);
gain1 >>=
(AUDIOH_AUDIORX_VRX1_AUDIORX_VRX_GAINCTRL_SHIFT);
pr_err("AUDIOH_AUDIORX_VRX1=0x%x, AMIC_PGA=0x%x\n",
value, gain1);
address = (char *)ioremap_nocache((UInt32)
(AUDIOH_BASE_ADDR +
AUDIOH_VIN_FILTER_CTRL_OFFSET),
sizeof(UInt32));
if (!address) {
pr_err(" address ioremap failed\n");
return 0;
}
value = ioread32(address);
iounmap(address);
gain1 = value;
gain1 &=
(AUDIOH_VIN_FILTER_CTRL_DMIC1_CIC_BIT_SEL_MASK);
gain1 >>=
(AUDIOH_VIN_FILTER_CTRL_DMIC1_CIC_BIT_SEL_SHIFT);
gain2 = value;
gain2 &=
(AUDIOH_VIN_FILTER_CTRL_DMIC1_CIC_FINE_SCL_MASK);
gain2 >>=
(AUDIOH_VIN_FILTER_CTRL_DMIC1_CIC_FINE_SCL_SHIFT);
gain3 = value;
gain3 &=
(AUDIOH_VIN_FILTER_CTRL_DMIC2_CIC_BIT_SEL_MASK);
gain3 >>=
(AUDIOH_VIN_FILTER_CTRL_DMIC2_CIC_BIT_SEL_SHIFT);
gain4 = value;
gain4 &=
(AUDIOH_VIN_FILTER_CTRL_DMIC2_CIC_FINE_SCL_MASK);
gain4 >>=
(AUDIOH_VIN_FILTER_CTRL_DMIC2_CIC_FINE_SCL_SHIFT);
pr_err(" AUDIOH_VIN_FILTER_CTRL=0x%x\n", value);
pr_err("DMIC1_CIC_BIT_SEL=0x%x, DMIC1_CIC_FINE=0x%x\n",
gain1, gain2);
pr_err("DMIC2_CIC_BIT_SEL=0x%x, "
"DMIC2_CIC_FINE_SCL=0x%x\n", gain3, gain4);
address = (char *)ioremap_nocache((UInt32)
(AUDIOH_BASE_ADDR +
AUDIOH_NVIN_FILTER_CTRL_OFFSET),
sizeof(UInt32));
if (!address) {
pr_err(" address ioremap failed\n");
return 0;
}
value = ioread32(address);
iounmap(address);
gain1 = value;
gain1 &=
(AUDIOH_NVIN_FILTER_CTRL_DMIC3_CIC_BIT_SEL_MASK);
gain1 >>=
(AUDIOH_NVIN_FILTER_CTRL_DMIC3_CIC_BIT_SEL_SHIFT);
gain2 = value;
gain2 &=
(AUDIOH_NVIN_FILTER_CTRL_DMIC3_CIC_FINE_SCL_MASK);
gain2 >>=
(AUDIOH_NVIN_FILTER_CTRL_DMIC3_CIC_FINE_SCL_SHIFT);
gain3 = value;
gain3 &=
(AUDIOH_NVIN_FILTER_CTRL_DMIC4_CIC_BIT_SEL_MASK);
gain3 >>=
(AUDIOH_NVIN_FILTER_CTRL_DMIC4_CIC_BIT_SEL_SHIFT);
gain4 = value;
gain4 &=
(AUDIOH_NVIN_FILTER_CTRL_DMIC4_CIC_FINE_SCL_MASK);
gain4 >>=
(AUDIOH_NVIN_FILTER_CTRL_DMIC4_CIC_FINE_SCL_SHIFT);
pr_err(" AUDIOH_VIN_FILTER_CTRL=0x%x\n", value);
pr_err("DMIC3_CIC_BIT_SEL=0x%x, DMIC3_CIC_FINE=0x%x\n",
gain1, gain2);
pr_err("DMIC4_CIC_BIT_SEL=0x%x, "
"DMIC4_CIC_FINE_SCL=0x%x\n", gain3, gain4);
address = (char *)
ioremap_nocache((UInt32)
(SRCMIXER_BASE_ADDR +
SRCMIXER_SRC_M1D0_CH1M_GAIN_CTRL_OFFSET),
sizeof(UInt32));
if (!address) {
pr_err(" address ioremap failed\n");
return 0;
}
value = ioread32(address);
iounmap(address);
gain1 = value;
gain1 &=
(SRCMIXER_SRC_M1D0_CH1M_GAIN_CTRL_SRC_M1D0_CH1M_GAIN_RAMPSTEP_MASK);
gain1 >>=
(SRCMIXER_SRC_M1D0_CH1M_GAIN_CTRL_SRC_M1D0_CH1M_GAIN_RAMPSTEP_SHIFT);
gain2 = value;
gain2 &=
(SRCMIXER_SRC_M1D0_CH1M_GAIN_CTRL_SRC_M1D0_CH1M_TARGET_GAIN_MASK);
gain2 >>=
(SRCMIXER_SRC_M1D0_CH1M_GAIN_CTRL_SRC_M1D0_CH1M_TARGET_GAIN_SHIFT);
pr_err("MIXER 1 D0, channel 1, Target_Gain"
"=0x%x, Gain_RampStep=0x%x\n", gain2, gain1);
address = (char *)ioremap_nocache((UInt32)
(SRCMIXER_BASE_ADDR +
SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_OFFSET),
sizeof(UInt32));
value = ioread32(address);
iounmap(address);
gain1 = value;
gain1 &=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_GAIN_RAMPSTEP_MASK);
gain1 >>=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_GAIN_RAMPSTEP_SHIFT);
gain2 = value;
gain2 &=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_TARGET_GAIN_MASK);
gain2 >>=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_TARGET_GAIN_SHIFT);
pr_err("MIXER 1 D0, channel 2, Target_Gain"
"=0x%x, Gain_RampStep=0x%x\n", gain2, gain1);
address = (char *)ioremap_nocache((UInt32)
(SRCMIXER_BASE_ADDR +
SRCMIXER_SRC_M1D0_CH3M_GAIN_CTRL_OFFSET),
sizeof(UInt32));
value = ioread32(address);
iounmap(address);
gain1 = value;
gain1 &=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_GAIN_RAMPSTEP_MASK);
gain1 >>=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_GAIN_RAMPSTEP_SHIFT);
gain2 = value;
gain2 &=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_TARGET_GAIN_MASK);
gain2 >>=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_TARGET_GAIN_SHIFT);
pr_err("MIXER 1 D0, channel 3, Target_Gain"
"=0x%x, Gain_RampStep=0x%x\n", gain2, gain1);
address = (char *)ioremap_nocache((UInt32)
(SRCMIXER_BASE_ADDR +
SRCMIXER_SRC_M1D0_CH4M_GAIN_CTRL_OFFSET),
sizeof(UInt32));
value = ioread32(address);
iounmap(address);
gain1 = value;
gain1 &=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_GAIN_RAMPSTEP_MASK);
gain1 >>=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_GAIN_RAMPSTEP_SHIFT);
gain2 = value;
gain2 &=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_TARGET_GAIN_MASK);
gain2 >>=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_TARGET_GAIN_SHIFT);
pr_err("MIXER 1 D0, channel 4, Target_Gain"
"=0x%x, Gain_RampStep=0x%x\n", gain2, gain1);
address = (char *)ioremap_nocache((UInt32)
(SRCMIXER_BASE_ADDR +
SRCMIXER_SRC_M1D0_CH5L_GAIN_CTRL_OFFSET),
sizeof(UInt32));
value = ioread32(address);
iounmap(address);
gain1 = value;
gain1 &=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_GAIN_RAMPSTEP_MASK);
gain1 >>=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_GAIN_RAMPSTEP_SHIFT);
gain2 = value;
gain2 &=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_TARGET_GAIN_MASK);
gain2 >>=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_TARGET_GAIN_SHIFT);
pr_err("MIXER 1 D0, channel 5 left, "
"Target_Gain=0x%x, Gain_RampStep=0x%x\n",
gain2, gain1);
address = (char *)ioremap_nocache((UInt32)
(SRCMIXER_BASE_ADDR +
SRCMIXER_SRC_M1D0_CH5R_GAIN_CTRL_OFFSET),
sizeof(UInt32));
value = ioread32(address);
iounmap(address);
gain1 = value;
gain1 &=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_GAIN_RAMPSTEP_MASK);
gain1 >>=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_GAIN_RAMPSTEP_SHIFT);
gain2 = value;
gain2 &=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_TARGET_GAIN_MASK);
gain2 >>=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_TARGET_GAIN_SHIFT);
pr_err("MIXER 1 D0, channel 5 right, "
"Target_Gain=0x%x, Gain_RampStep=0x%x\n",
gain2, gain1);
address = (char *)ioremap_nocache((UInt32)
(SRCMIXER_BASE_ADDR +
SRCMIXER_SRC_M1D0_CH6L_GAIN_CTRL_OFFSET),
sizeof(UInt32));
value = ioread32(address);
iounmap(address);
gain1 = value;
gain1 &=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_GAIN_RAMPSTEP_MASK);
gain1 >>=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_GAIN_RAMPSTEP_SHIFT);
gain2 = value;
gain2 &=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_TARGET_GAIN_MASK);
gain2 >>=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_TARGET_GAIN_SHIFT);
pr_err("MIXER 1 D0, channel 6 left, "
"Target_Gain=0x%x, Gain_RampStep=0x%x\n",
gain2, gain1);
address = (char *)ioremap_nocache((UInt32)
(SRCMIXER_BASE_ADDR +
SRCMIXER_SRC_M1D0_CH6R_GAIN_CTRL_OFFSET),
sizeof(UInt32));
value = ioread32(address);
iounmap(address);
gain1 = value;
gain1 &=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_GAIN_RAMPSTEP_MASK);
gain1 >>=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_GAIN_RAMPSTEP_SHIFT);
gain2 = value;
gain2 &=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_TARGET_GAIN_MASK);
gain2 >>=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_TARGET_GAIN_SHIFT);
pr_err("MIXER 1 D0, channel 6 right, "
"Target_Gain=0x%x, Gain_RampStep=0x%x\n",
gain2, gain1);
address = (char *)ioremap_nocache((UInt32)
(SRCMIXER_BASE_ADDR +
SRCMIXER_SRC_M1D0_CH7L_GAIN_CTRL_OFFSET),
sizeof(UInt32));
value = ioread32(address);
iounmap(address);
gain1 = value;
gain1 &=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_GAIN_RAMPSTEP_MASK);
gain1 >>=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_GAIN_RAMPSTEP_SHIFT);
gain2 = value;
gain2 &=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_TARGET_GAIN_MASK);
gain2 >>=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_TARGET_GAIN_SHIFT);
pr_err("MIXER 1 D0, channel 7 left, "
"Target_Gain=0x%x, Gain_RampStep=0x%x\n",
gain2, gain1);
address = (char *)ioremap_nocache((UInt32)
(SRCMIXER_BASE_ADDR +
SRCMIXER_SRC_M1D0_CH7R_GAIN_CTRL_OFFSET),
sizeof(UInt32));
value = ioread32(address);
iounmap(address);
gain1 = value;
gain1 &=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_GAIN_RAMPSTEP_MASK);
gain1 >>=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_GAIN_RAMPSTEP_SHIFT);
gain2 = value;
gain2 &=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_TARGET_GAIN_MASK);
gain2 >>=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_TARGET_GAIN_SHIFT);
pr_err("MIXER 1 D0, channel 7 right, "
"Target_Gain=0x%x, Gain_RampStep=0x%x\n",
gain2, gain1);
/********/
address = (char *)ioremap_nocache((UInt32)
(SRCMIXER_BASE_ADDR +
SRCMIXER_SRC_M1D1_CH1M_GAIN_CTRL_OFFSET),
sizeof(UInt32));
value = ioread32(address);
iounmap(address);
gain1 = value;
gain1 &=
(SRCMIXER_SRC_M1D0_CH1M_GAIN_CTRL_SRC_M1D0_CH1M_GAIN_RAMPSTEP_MASK);
gain1 >>=
(SRCMIXER_SRC_M1D0_CH1M_GAIN_CTRL_SRC_M1D0_CH1M_GAIN_RAMPSTEP_SHIFT);
gain2 = value;
gain2 &=
(SRCMIXER_SRC_M1D0_CH1M_GAIN_CTRL_SRC_M1D0_CH1M_TARGET_GAIN_MASK);
gain2 >>=
(SRCMIXER_SRC_M1D0_CH1M_GAIN_CTRL_SRC_M1D0_CH1M_TARGET_GAIN_SHIFT);
pr_err("MIXER 1 D1, channel 1, Target_Gain"
"=0x%x, Gain_RampStep=0x%x\n", gain2, gain1);
address = (char *)ioremap_nocache((UInt32)
(SRCMIXER_BASE_ADDR +
SRCMIXER_SRC_M1D1_CH2M_GAIN_CTRL_OFFSET),
sizeof(UInt32));
value = ioread32(address);
iounmap(address);
gain1 = value;
gain1 &=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_GAIN_RAMPSTEP_MASK);
gain1 >>=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_GAIN_RAMPSTEP_SHIFT);
gain2 = value;
gain2 &=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_TARGET_GAIN_MASK);
gain2 >>=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_TARGET_GAIN_SHIFT);
pr_err("MIXER 1 D1, channel 2, Target_Gain"
"=0x%x, Gain_RampStep=0x%x\n", gain2, gain1);
address = (char *)ioremap_nocache((UInt32)
(SRCMIXER_BASE_ADDR +
SRCMIXER_SRC_M1D1_CH3M_GAIN_CTRL_OFFSET),
sizeof(UInt32));
value = ioread32(address);
iounmap(address);
gain1 = value;
gain1 &=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_GAIN_RAMPSTEP_MASK);
gain1 >>=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_GAIN_RAMPSTEP_SHIFT);
gain2 = value;
gain2 &=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_TARGET_GAIN_MASK);
gain2 >>=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_TARGET_GAIN_SHIFT);
pr_err("MIXER 1 D1, channel 3, Target_Gain"
"=0x%x, Gain_RampStep=0x%x\n", gain2, gain1);
address = (char *)ioremap_nocache((UInt32)
(SRCMIXER_BASE_ADDR +
SRCMIXER_SRC_M1D1_CH4M_GAIN_CTRL_OFFSET),
sizeof(UInt32));
value = ioread32(address);
iounmap(address);
gain1 = value;
gain1 &=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_GAIN_RAMPSTEP_MASK);
gain1 >>=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_GAIN_RAMPSTEP_SHIFT);
gain2 = value;
gain2 &=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_TARGET_GAIN_MASK);
gain2 >>=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_TARGET_GAIN_SHIFT);
pr_err("MIXER 1 D1, channel 4, "
"Target_Gain=0x%x, Gain_RampStep=0x%x\n",
gain2, gain1);
address = (char *)ioremap_nocache((UInt32)
(SRCMIXER_BASE_ADDR +
SRCMIXER_SRC_M1D1_CH5L_GAIN_CTRL_OFFSET),
sizeof(UInt32));
value = ioread32(address);
iounmap(address);
gain1 = value;
gain1 &=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_GAIN_RAMPSTEP_MASK);
gain1 >>=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_GAIN_RAMPSTEP_SHIFT);
gain2 = value;
gain2 &=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_TARGET_GAIN_MASK);
gain2 >>=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_TARGET_GAIN_SHIFT);
pr_err("MIXER 1 D1, channel 5 left, "
"Target_Gain=0x%x, Gain_RampStep=0x%x\n",
gain2, gain1);
address = (char *)ioremap_nocache((UInt32)
(SRCMIXER_BASE_ADDR +
SRCMIXER_SRC_M1D1_CH5R_GAIN_CTRL_OFFSET),
sizeof(UInt32));
value = ioread32(address);
iounmap(address);
gain1 = value;
gain1 &=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_GAIN_RAMPSTEP_MASK);
gain1 >>=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_GAIN_RAMPSTEP_SHIFT);
gain2 = value;
gain2 &=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_TARGET_GAIN_MASK);
gain2 >>=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_TARGET_GAIN_SHIFT);
pr_err("MIXER 1 D1, channel 5 right, "
"Target_Gain=0x%x, Gain_RampStep=0x%x\n",
gain2, gain1);
address = (char *)ioremap_nocache((UInt32)
(SRCMIXER_BASE_ADDR +
SRCMIXER_SRC_M1D1_CH6L_GAIN_CTRL_OFFSET),
sizeof(UInt32));
value = ioread32(address);
iounmap(address);
gain1 = value;
gain1 &=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_GAIN_RAMPSTEP_MASK);
gain1 >>=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_GAIN_RAMPSTEP_SHIFT);
gain2 = value;
gain2 &=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_TARGET_GAIN_MASK);
gain2 >>=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_TARGET_GAIN_SHIFT);
pr_err("MIXER 1 D1, channel 6 left, "
"Target_Gain=0x%x, Gain_RampStep=0x%x\n",
gain2, gain1);
address = (char *)ioremap_nocache((UInt32)
(SRCMIXER_BASE_ADDR +
SRCMIXER_SRC_M1D1_CH6R_GAIN_CTRL_OFFSET),
sizeof(UInt32));
value = ioread32(address);
iounmap(address);
gain1 = value;
gain1 &=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_GAIN_RAMPSTEP_MASK);
gain1 >>=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_GAIN_RAMPSTEP_SHIFT);
gain2 = value;
gain2 &=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_TARGET_GAIN_MASK);
gain2 >>=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_TARGET_GAIN_SHIFT);
pr_err("MIXER 1 D1, channel 6 right, "
"Target_Gain=0x%x, Gain_RampStep=0x%x\n",
gain2, gain1);
address = (char *)ioremap_nocache((UInt32)
(SRCMIXER_BASE_ADDR +
SRCMIXER_SRC_M1D1_CH7L_GAIN_CTRL_OFFSET),
sizeof(UInt32));
value = ioread32(address);
iounmap(address);
gain1 = value;
gain1 &=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_GAIN_RAMPSTEP_MASK);
gain1 >>=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_GAIN_RAMPSTEP_SHIFT);
gain2 = value;
gain2 &=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_TARGET_GAIN_MASK);
gain2 >>=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_TARGET_GAIN_SHIFT);
pr_err("MIXER 1 D1, channel 7 left, "
"Target_Gain=0x%x, Gain_RampStep=0x%x\n",
gain2, gain1);
address = (char *)ioremap_nocache((UInt32)
(SRCMIXER_BASE_ADDR +
SRCMIXER_SRC_M1D1_CH7R_GAIN_CTRL_OFFSET),
sizeof(UInt32));
value = ioread32(address);
iounmap(address);
gain1 = value;
gain1 &=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_GAIN_RAMPSTEP_MASK);
gain1 >>=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_GAIN_RAMPSTEP_SHIFT);
gain2 = value;
gain2 &=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_TARGET_GAIN_MASK);
gain2 >>=
(SRCMIXER_SRC_M1D0_CH2M_GAIN_CTRL_SRC_M1D0_CH2M_TARGET_GAIN_SHIFT);
pr_err("MIXER 1 D1, channel 7 right, "
"Target_Gain=0x%x, Gain_RampStep=0x%x\n",
gain2, gain1);
/**********/
for (index = 0x00000160; index <= 0x00000270;
index = index + 4) {
address = (char *)
ioremap_nocache((UInt32)
(SRCMIXER_BASE_ADDR +
index), sizeof(UInt32));
value = ioread32(address);
iounmap(address);
pr_err("SRCMIXER_BASE_ADDR + offset 0x%x, "
"value = 0x%x\n", index, value);
}
} /* 500 cmd */
break;
case 1000: /*at*maudtst=1000,addr,len */
{
u32 value, index, phy_addr, size;
char *addr;
if (Params[2] == 0)
size = 1;
else
size = Params[2] >> 2;
phy_addr = Params[1];
if (!phy_addr) {
pr_err("invalid addr 0\n");
return 0;
}
addr = ioremap_nocache(phy_addr, sizeof(u32));
if (!addr) {
pr_err(" addr ioremap failed\n");
return 0;
}
pr_err("Read phy_addr 0x%08x (virtual %p), "
"size = 0x%08x bytes\n",
phy_addr, addr, size << 2);
iounmap(addr);
for (index = 0; index < size; index++) {
addr = ioremap_nocache(phy_addr, sizeof(u32));
if (addr) {
value = ioread32(addr);
iounmap(addr);
pr_err("[%08x] = %08x\n", phy_addr,
value);
}
phy_addr += 4;
}
}
break;
default:
aTrace(LOG_AUDIO_DRIVER,
"%s Not supported command\n", __func__);
return -1;
}
return 0;
}
