/****************************************************************************
* AnalyzeEDSPSubChunk
*
* Description:
* E-DSP Sub chunk analysis
* Arguments:
* pbPrm AEC data pointer
* pdPos AEC sub chunk start pos
* pdSubChunkSize AEC sub chunk byte size
* psAECInfo MCDRV_AEC_INFO structure pointer
* Return:
* MCDRV_SUCCESS
* MCDRV_ERROR_ARGUMENT
*
****************************************************************************/
static SINT32 AnalyzeEDSPSubChunk
(
const UINT8 *pbPrm,
UINT32 *pdPos,
UINT32 *pdSubChunkSize,
struct MCDRV_AEC_INFO *psAECInfo
)
{
SINT32 sdRet = MCDRV_SUCCESS;
UINT32 dChunkId;
UINT32 dChunkSize;
#if (MCDRV_DEBUG_LEVEL >= 4)
McDebugLog_FuncIn("AnalyzeEDSPSubChunk");
#endif
while (*pdSubChunkSize > 0 && sdRet == MCDRV_SUCCESS) {
if (*pdSubChunkSize < 8) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
dChunkId = CreateUINT32(pbPrm[*pdPos],
pbPrm[*pdPos+1],
pbPrm[*pdPos+2],
pbPrm[*pdPos+3]);
dChunkSize = CreateUINT32(pbPrm[*pdPos+4],
pbPrm[*pdPos+5],
pbPrm[*pdPos+6],
pbPrm[*pdPos+7]);
*pdSubChunkSize -= 8;
if (*pdSubChunkSize < dChunkSize) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
switch (dChunkId) {
case AEC_D7_CHUNK_E2_CONFIG:
if (psAECInfo->sE2.sE2Config.pbChunkData
!= NULL) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sE2.sE2Config.pbChunkData
= (UINT8 *)&pbPrm[*pdPos];
psAECInfo->sE2.sE2Config.dwSize
= dChunkSize;
*pdPos += (dChunkSize+8);
*pdSubChunkSize -= dChunkSize;
break;
default:
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
}
#if (MCDRV_DEBUG_LEVEL >= 4)
McDebugLog_FuncOut("AnalyzeEDSPSubChunk", &sdRet);
#endif
return sdRet;
}
/****************************************************************************
* machdep_ClockStop
*
* Description:
* Stop clock.
* Arguments:
* none
* Return:
* none
*
****************************************************************************/
void machdep_ClockStop
(
void
)
{
#if (MCDRV_DEBUG_LEVEL>=4)
McDebugLog_FuncIn("machdep_ClockStop");
#endif
/* Please implement clock stop procedure if need */
#if (MCDRV_DEBUG_LEVEL>=4)
McDebugLog_FuncOut("machdep_ClockStop", 0);
#endif
}
/****************************************************************************
* machdep_SystemTerm
*
* Description:
* Terminate the system.
* Arguments:
* none
* Return:
* none
*
****************************************************************************/
void machdep_SystemTerm
(
void
)
{
#if (MCDRV_DEBUG_LEVEL>=4)
McDebugLog_FuncIn("machdep_SystemTerm");
#endif
/* Please implement system termination procedure if need */
mutex_destroy(&McDrv_Mutex);
#if (MCDRV_DEBUG_LEVEL>=4)
McDebugLog_FuncOut("machdep_SystemTerm", 0);
#endif
}
/****************************************************************************
* machdep_SystemInit
*
* Description:
* Initialize the system.
* Arguments:
* none
* Return:
* none
*
****************************************************************************/
void machdep_SystemInit
(
void
)
{
#if (MCDRV_DEBUG_LEVEL>=4)
McDebugLog_FuncIn("machdep_SystemInit");
#endif
/* Please implement system initialization procedure if need */
mutex_init(&McDrv_Mutex);
#if (MCDRV_DEBUG_LEVEL>=4)
McDebugLog_FuncOut("machdep_SystemInit", 0);
#endif
}
/***************************************************************************
* machdep_Unlock
*
* Function:
* Unlock a call of the driver.
* Arguments:
* none
* Return:
* none
*
****************************************************************************/
void machdep_Unlock
(
void
)
{
#if (MCDRV_DEBUG_LEVEL>=4)
McDebugLog_FuncIn("machdep_Unlock");
#endif
/* Please implement unlock procedure */
mutex_unlock(&McDrv_Mutex);
#if (MCDRV_DEBUG_LEVEL>=4)
McDebugLog_FuncOut("machdep_Unlock", 0);
#endif
}
/***************************************************************************
* machdep_WriteSPI
*
* Function:
* Write data to the register.
* Arguments:
* pbData byte data for write
* dSize byte data length
* Return:
* None
*
****************************************************************************/
void machdep_WriteSPI
(
const UINT8* pbData,
UINT32 dSize
)
{
#if (MCDRV_DEBUG_LEVEL>=4)
McDebugLog_FuncIn("machdep_WriteSPI");
#endif
/* Please implement register write procedure */
#if (MCDRV_DEBUG_LEVEL>=4)
McDebugLog_FuncOut("machdep_WriteSPI", 0);
#endif
}
/****************************************************************************
* machdep_Sleep
*
* Function:
* Sleep for a specified interval.
* Arguments:
* dSleepTime sleep time [us]
* Return:
* None
*
****************************************************************************/
void machdep_Sleep
(
UINT32 dSleepTime
)
{
unsigned long ms = dSleepTime / 1000;
unsigned long us = dSleepTime % 1000;
#if (MCDRV_DEBUG_LEVEL>=4)
McDebugLog_FuncIn("machdep_Sleep");
#endif
/* Please implement sleep procedure */
if (us)
udelay(us);
if (ms)
msleep(ms);
#if (MCDRV_DEBUG_LEVEL>=4)
McDebugLog_FuncOut("machdep_Sleep", 0);
#endif
}
/***************************************************************************
* machdep_ReadSPI
*
* Function:
* Read a byte data from the register.
* Arguments:
* dAddress address of register
* Return:
* read data
*
****************************************************************************/
UINT8 machdep_ReadSPI
(
UINT32 dAddress
)
{
UINT8 bData = 0x00;
#if (MCDRV_DEBUG_LEVEL>=4)
SINT32 sdRet;
McDebugLog_FuncIn("machdep_ReadSPI");
#endif
/* Please implement register read procedure */
bData = 0xff;
#if (MCDRV_DEBUG_LEVEL>=4)
sdRet = (SINT32)bData;
McDebugLog_FuncOut("machdep_ReadSPI", &sdRet);
#endif
return bData;
}
/***************************************************************************
* machdep_ReadI2C
*
* Function:
* Read a byte data from the register.
* Arguments:
* bSlaveAdr slave address
* dAddress address of register
* Return:
* read data
*
****************************************************************************/
UINT8 machdep_ReadI2C
(
UINT8 bSlaveAdr,
UINT32 dAddress
)
{
UINT8 bData = 0x00;
#if (MCDRV_DEBUG_LEVEL>=4)
SINT32 sdRet;
McDebugLog_FuncIn("machdep_ReadI2C");
#endif
/* Please implement register read procedure */
McDrv_I2C_Client = mc_asoc_get_i2c_client(bSlaveAdr);
bData = mc_asoc_i2c_read_byte(McDrv_I2C_Client, dAddress);
#if (MCDRV_DEBUG_LEVEL>=4)
sdRet = (SINT32)bData;
McDebugLog_FuncOut("machdep_ReadI2C", &sdRet);
#endif
return bData;
}
/***************************************************************************
* machdep_WriteI2C
*
* Function:
* Write data to the register.
* Arguments:
* bSlaveAdr slave address
* pbData byte data for write
* dSize byte data length
* Return:
* None
*
****************************************************************************/
void machdep_WriteI2C
(
UINT8 bSlaveAdr,
const UINT8* pbData,
UINT32 dSize
)
{
int count;
#if (MCDRV_DEBUG_LEVEL>=4)
McDebugLog_FuncIn("machdep_WriteI2C");
#endif
/* Please implement register write procedure */
McDrv_I2C_Client = mc_asoc_get_i2c_client(bSlaveAdr);
count = i2c_master_send(McDrv_I2C_Client, pbData, dSize);
if (count != dSize) {
dev_err(&McDrv_I2C_Client->dev, "I2C write error\n");
}
#if (MCDRV_DEBUG_LEVEL>=4)
McDebugLog_FuncOut("machdep_WriteI2C", 0);
#endif
}
/****************************************************************************
* McParser_AnalyzeD7Chunk
*
* Description:
* D7 chunk analysis
* Arguments:
* psD7Info MCDRV_AEC_D7_INFO structure pointer
* psAECInfo MCDRV_AEC_INFO structure pointer
* Return:
* MCDRV_SUCCESS
* MCDRV_ERROR_ARGUMENT
*
****************************************************************************/
SINT32 McParser_AnalyzeD7Chunk(
struct MCDRV_AEC_D7_INFO *psD7Info,
struct MCDRV_AEC_INFO *psAECInfo
)
{
const UINT8 *pbPrm;
UINT32 dChunkEnd;
UINT32 dPos;
UINT32 dChunkId;
UINT32 dSubChunkSize;
SINT32 sdRet = MCDRV_SUCCESS;
int n;
#if (MCDRV_DEBUG_LEVEL >= 4)
McDebugLog_FuncIn("McParser_AnalyzeD7Chunk");
#endif
pbPrm = psD7Info->pbChunkTop;
dChunkEnd = psD7Info->dChunkSize-1;
psAECInfo->sAecConfig.bFDspLocate = 0xFF;
psAECInfo->sAecAudioengine.bEnable = 0;
psAECInfo->sAecAudioengine.sAecBDsp.pbChunkData = NULL;
psAECInfo->sAecAudioengine.sAecBDsp.dwSize = 0;
psAECInfo->sAecAudioengine.sAecFDsp.pbChunkData = NULL;
psAECInfo->sAecAudioengine.sAecFDsp.dwSize = 0;
psAECInfo->sAecVBox.bEnable = 0;
psAECInfo->sAecVBox.sAecCDspA.pbChunkData = NULL;
psAECInfo->sAecVBox.sAecCDspA.dwSize = 0;
psAECInfo->sAecVBox.sAecCDspB.pbChunkData = NULL;
psAECInfo->sAecVBox.sAecCDspB.dwSize = 0;
psAECInfo->sAecVBox.sAecFDsp.pbChunkData = NULL;
psAECInfo->sAecVBox.sAecFDsp.dwSize = 0;
psAECInfo->sAecVBox.sAecCDspDbg.bJtagOn = 0xFF;
psAECInfo->sOutput.bLpf_Pre_Thru[0] = 0xFF;
psAECInfo->sOutput.bLpf_Pre_Thru[1] = 0xFF;
psAECInfo->sInput.bDsf32_L_Type[0] = 0xFF;
psAECInfo->sInput.bDsf32_L_Type[1] = 0xFF;
psAECInfo->sInput.bDsf32_L_Type[2] = 0xFF;
psAECInfo->sPdm.bMode = 0xFF;
psAECInfo->sE2.bEnable = 0;
psAECInfo->sE2.sE2Config.pbChunkData = NULL;
psAECInfo->sE2.sE2Config.dwSize = 0;
psAECInfo->sAdj.bHold = 0xFF;
psAECInfo->sEDspMisc.bI2SOut_Enb = 0xFF;
psAECInfo->sControl.bCommand = 0xFF;
dPos = 0UL;
while (dPos <= dChunkEnd && sdRet == MCDRV_SUCCESS) {
if ((dPos + 8-1) > dChunkEnd) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
dChunkId = CreateUINT32(pbPrm[dPos],
pbPrm[dPos+1],
pbPrm[dPos+2],
pbPrm[dPos+3]);
dSubChunkSize = CreateUINT32(pbPrm[dPos+4],
pbPrm[dPos+5],
pbPrm[dPos+6],
pbPrm[dPos+7]);
dPos += 8;
if ((dPos + dSubChunkSize-1) > dChunkEnd) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
switch (dChunkId) {
case AEC_D7_CHUNK_CONFIG:
if (dSubChunkSize != 1) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
if (psAECInfo->sAecConfig.bFDspLocate != 0xFF) {
/* already done */
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
if (pbPrm[dPos] > 1) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sAecConfig.bFDspLocate = pbPrm[dPos++];
dSubChunkSize = 0;
break;
case AEC_D7_CHUNK_AE:
if (dSubChunkSize < 8) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
if (psAECInfo->sAecAudioengine.bEnable != 0) {
/* already done */
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sAecAudioengine.bEnable = 1;
if (pbPrm[dPos] > 2) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sAecAudioengine.bAEOnOff = pbPrm[dPos++];
dSubChunkSize--;
if (pbPrm[dPos] > 2) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sAecAudioengine.bFDspOnOff = pbPrm[dPos++];
dSubChunkSize--;
if (pbPrm[dPos] > 2) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sAecAudioengine.bBDspAE0Src = pbPrm[dPos++];
dSubChunkSize--;
if (pbPrm[dPos] > 2) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sAecAudioengine.bBDspAE1Src = pbPrm[dPos++];
dSubChunkSize--;
if (pbPrm[dPos] > 2) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sAecAudioengine.bMixerIn0Src = pbPrm[dPos++];
dSubChunkSize--;
if (pbPrm[dPos] > 2) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sAecAudioengine.bMixerIn1Src = pbPrm[dPos++];
dSubChunkSize--;
if (pbPrm[dPos] > 2) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sAecAudioengine.bMixerIn2Src = pbPrm[dPos++];
dSubChunkSize--;
if (pbPrm[dPos] > 2) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sAecAudioengine.bMixerIn3Src = pbPrm[dPos++];
dSubChunkSize--;
if (dSubChunkSize > 0) {
sdRet = AnalyzeAESubChunk(pbPrm,
&dPos,
&dSubChunkSize,
psAECInfo);
}
break;
case AEC_D7_CHUNK_VBOX:
if (dSubChunkSize < 15) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
if (psAECInfo->sAecVBox.bEnable != 0) {
/* already done */
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sAecVBox.bEnable = 1;
if (pbPrm[dPos] > 2) {
if (pbPrm[dPos] != 0x11) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
}
psAECInfo->sAecVBox.bCDspFuncAOnOff = pbPrm[dPos++];
dSubChunkSize--;
if (pbPrm[dPos] > 2) {
if (pbPrm[dPos] != 0x11) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
}
psAECInfo->sAecVBox.bCDspFuncBOnOff = pbPrm[dPos++];
dSubChunkSize--;
if (pbPrm[dPos] > 2) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sAecVBox.bFDspOnOff = pbPrm[dPos++];
dSubChunkSize--;
if ((pbPrm[dPos] > 0x3F)
&& (pbPrm[dPos] < 0xFF)) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sAecVBox.bFdsp_Po_Source = pbPrm[dPos++];
dSubChunkSize--;
if ((pbPrm[dPos] > 1)
&& (pbPrm[dPos] < 0xFF)) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sAecVBox.bISrc2_VSource = pbPrm[dPos++];
dSubChunkSize--;
if ((pbPrm[dPos] > 1)
&& (pbPrm[dPos] < 0xFF)) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sAecVBox.bISrc2_Ch1_VSource = pbPrm[dPos++];
dSubChunkSize--;
if ((pbPrm[dPos] > 1)
&& (pbPrm[dPos] < 0xFF)) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sAecVBox.bISrc3_VSource = pbPrm[dPos++];
dSubChunkSize--;
if ((pbPrm[dPos] > 1)
&& (pbPrm[dPos] < 0xFF)) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sAecVBox.bLPt2_VSource = pbPrm[dPos++];
dSubChunkSize--;
if ((pbPrm[dPos] > 3)
&& (pbPrm[dPos] < 0xFF)) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sAecVBox.bLPt2_Mix_VolO = pbPrm[dPos++];
dSubChunkSize--;
if ((pbPrm[dPos] > 3)
&& (pbPrm[dPos] < 0xFF)) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sAecVBox.bLPt2_Mix_VolI = pbPrm[dPos++];
dSubChunkSize--;
if ((pbPrm[dPos] > 3)
&& (pbPrm[dPos] < 0xFF)) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sAecVBox.bSrc3_Ctrl = pbPrm[dPos++];
dSubChunkSize--;
if ((pbPrm[dPos] == 3)
|| (pbPrm[dPos] == 7)
|| (pbPrm[dPos] == 11)
|| ((pbPrm[dPos] > 13) && (pbPrm[dPos] < 0xFF))) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sAecVBox.bSrc2_Fs = pbPrm[dPos++];
dSubChunkSize--;
if (McDevProf_GetDevId() == eMCDRV_DEV_ID_80_90H) {
if ((pbPrm[dPos] > 1)
&& (pbPrm[dPos] < 0xFF)) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sAecVBox.bSrc2_Thru = pbPrm[dPos++];
} else {
dPos++;
}
dSubChunkSize--;
if ((pbPrm[dPos] == 3)
|| (pbPrm[dPos] == 7)
|| (pbPrm[dPos] == 11)
|| ((pbPrm[dPos] > 13) && (pbPrm[dPos] < 0xFF))) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sAecVBox.bSrc3_Fs = pbPrm[dPos++];
dSubChunkSize--;
if ((pbPrm[dPos] > 1)
&& (pbPrm[dPos] < 0xFF)) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sAecVBox.bSrc3_Thru = pbPrm[dPos++];
dSubChunkSize--;
if (dSubChunkSize > 0) {
sdRet = AnalyzeVBoxSubChunk(pbPrm,
&dPos,
&dSubChunkSize,
psAECInfo);
}
break;
case AEC_D7_CHUNK_OUTPUT0_ES1:
case AEC_D7_CHUNK_OUTPUT1_ES1:
case AEC_D7_CHUNK_OUTPUT0:
case AEC_D7_CHUNK_OUTPUT1:
if (McDevProf_GetDevId() == eMCDRV_DEV_ID_80_90H) {
if ((dChunkId != AEC_D7_CHUNK_OUTPUT0_ES1)
&& (dChunkId != AEC_D7_CHUNK_OUTPUT1_ES1)) {
;
break;
}
n = dChunkId - AEC_D7_CHUNK_OUTPUT0_ES1;
} else {
if ((dChunkId != AEC_D7_CHUNK_OUTPUT0)
&& (dChunkId != AEC_D7_CHUNK_OUTPUT1)) {
;
break;
}
n = dChunkId - AEC_D7_CHUNK_OUTPUT0;
}
if (dSubChunkSize < 47) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
if (psAECInfo->sOutput.bLpf_Pre_Thru[n] != 0xFF) {
/* already done */
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
if (pbPrm[dPos] > 1) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sOutput.bLpf_Pre_Thru[n] = pbPrm[dPos++];
if (pbPrm[dPos] > 1) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sOutput.bLpf_Post_Thru[n] = pbPrm[dPos++];
if (pbPrm[dPos] > 3) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sOutput.bDcc_Sel[n] = pbPrm[dPos++];
if (pbPrm[dPos] > 5) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sOutput.bSig_Det_Lvl = pbPrm[dPos++];
if (pbPrm[dPos] > 3) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sOutput.bPow_Det_Lvl[n] = pbPrm[dPos++];
if (pbPrm[dPos] > 3) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sOutput.bOsf_Sel[n] = pbPrm[dPos++];
if (McDevProf_GetDevId() == eMCDRV_DEV_ID_80_90H) {
if (pbPrm[dPos] > 1) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
} else {
if (pbPrm[dPos] > 7) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
}
psAECInfo->sOutput.bSys_Eq_Enb[n] = pbPrm[dPos++];
psAECInfo->sOutput.bSys_Eq_Coef_A0[n][0]
= pbPrm[dPos++];
psAECInfo->sOutput.bSys_Eq_Coef_A0[n][1]
= pbPrm[dPos++];
psAECInfo->sOutput.bSys_Eq_Coef_A0[n][2]
= pbPrm[dPos++];
psAECInfo->sOutput.bSys_Eq_Coef_A1[n][0]
= pbPrm[dPos++];
psAECInfo->sOutput.bSys_Eq_Coef_A1[n][1]
= pbPrm[dPos++];
psAECInfo->sOutput.bSys_Eq_Coef_A1[n][2]
= pbPrm[dPos++];
psAECInfo->sOutput.bSys_Eq_Coef_A2[n][0]
= pbPrm[dPos++];
psAECInfo->sOutput.bSys_Eq_Coef_A2[n][1]
= pbPrm[dPos++];
psAECInfo->sOutput.bSys_Eq_Coef_A2[n][2]
= pbPrm[dPos++];
psAECInfo->sOutput.bSys_Eq_Coef_B1[n][0]
= pbPrm[dPos++];
psAECInfo->sOutput.bSys_Eq_Coef_B1[n][1]
= pbPrm[dPos++];
psAECInfo->sOutput.bSys_Eq_Coef_B1[n][2]
= pbPrm[dPos++];
psAECInfo->sOutput.bSys_Eq_Coef_B2[n][0]
= pbPrm[dPos++];
psAECInfo->sOutput.bSys_Eq_Coef_B2[n][1]
= pbPrm[dPos++];
psAECInfo->sOutput.bSys_Eq_Coef_B2[n][2]
= pbPrm[dPos++];
if (pbPrm[dPos] > 7) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sOutput.bClip_Md[n] = pbPrm[dPos++];
psAECInfo->sOutput.bClip_Att[n] = pbPrm[dPos++];
psAECInfo->sOutput.bClip_Rel[n] = pbPrm[dPos++];
psAECInfo->sOutput.bClip_G[n] = pbPrm[dPos++];
psAECInfo->sOutput.bOsf_Gain[n][0] = pbPrm[dPos++];
psAECInfo->sOutput.bOsf_Gain[n][1] = pbPrm[dPos++];
if (pbPrm[dPos] > 1) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sOutput.bDcl_OnOff[n] = pbPrm[dPos++];
if (pbPrm[dPos] > 3) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sOutput.bDcl_Gain[n] = pbPrm[dPos++];
if (pbPrm[dPos] > 0x7F) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sOutput.bDcl_Limit[n][0] = pbPrm[dPos++];
psAECInfo->sOutput.bDcl_Limit[n][1] = pbPrm[dPos++];
if (McDevProf_GetDevId() == eMCDRV_DEV_ID_80_90H) {
if (pbPrm[dPos] > 1) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sOutput.bRandom_Dither_OnOff[n]
= pbPrm[dPos++];
} else {
dPos++;
}
if (McDevProf_GetDevId() == eMCDRV_DEV_ID_80_90H) {
if (pbPrm[dPos] > 3) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sOutput.bRandom_Dither_Level[n]
= pbPrm[dPos++];
} else {
dPos++;
}
if (McDevProf_GetDevId() == eMCDRV_DEV_ID_80_90H) {
if (pbPrm[dPos] > 1) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sOutput.bRandom_Dither_POS[n]
= pbPrm[dPos++];
} else {
dPos++;
}
if (pbPrm[dPos] > 1) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sOutput.bDc_Dither_OnOff[n] = pbPrm[dPos++];
if (McDevProf_GetDevId() == eMCDRV_DEV_ID_80_90H) {
if (pbPrm[dPos] > 15) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sOutput.bDc_Dither_Level[n]
= pbPrm[dPos++];
} else {
dPos++;
}
if (pbPrm[dPos] > 1) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sOutput.bDither_Type[n] = pbPrm[dPos++];
if (pbPrm[dPos] > 1) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sOutput.bDng_On[n] = pbPrm[dPos++];
if (pbPrm[dPos] > 31) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sOutput.bDng_Zero[n] = pbPrm[dPos++];
if (pbPrm[dPos] > 2) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sOutput.bDng_Time[n] = pbPrm[dPos++];
if (pbPrm[dPos] > 1) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sOutput.bDng_Fw[n] = pbPrm[dPos++];
psAECInfo->sOutput.bDng_Attack = pbPrm[dPos++];
psAECInfo->sOutput.bDng_Release = pbPrm[dPos++];
psAECInfo->sOutput.bDng_Target[n] = pbPrm[dPos++];
psAECInfo->sOutput.bDng_Target_LineOut[n]
= pbPrm[dPos++];
if (n == 0)
psAECInfo->sOutput.bDng_Target_Rc
= pbPrm[dPos++];
else
dPos++;
dSubChunkSize -= 47;
if (dSubChunkSize > 0) {
sdRet = AnalyzeSysEqExSubChunk(pbPrm,
&dPos,
&dSubChunkSize,
&psAECInfo->sOutput.sSysEqEx[n]);
}
break;
case AEC_D7_CHUNK_INPUT0:
case AEC_D7_CHUNK_INPUT1:
case AEC_D7_CHUNK_INPUT2:
n = dChunkId - AEC_D7_CHUNK_INPUT0;
if (dSubChunkSize < 16) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
if (psAECInfo->sInput.bDsf32_L_Type[n] != 0xFF) {
/* already done */
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
if (n == 0) {
if (pbPrm[dPos] > 2) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
} else {
if (pbPrm[dPos] > 1) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
}
psAECInfo->sInput.bDsf32_L_Type[n] = pbPrm[dPos++];
if (n == 0) {
if (pbPrm[dPos] > 2) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
} else {
if (pbPrm[dPos] > 1) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
}
psAECInfo->sInput.bDsf32_R_Type[n] = pbPrm[dPos++];
if (pbPrm[dPos] > 1) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sInput.bDsf4_Sel[n] = pbPrm[dPos++];
if (pbPrm[dPos] > 3) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sInput.bDcc_Sel[n] = pbPrm[dPos++];
if (pbPrm[dPos] > 1) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sInput.bDng_On[n] = pbPrm[dPos++];
if (pbPrm[dPos] > 3) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sInput.bDng_Att[n] = pbPrm[dPos++];
if (pbPrm[dPos] > 3) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sInput.bDng_Rel[n] = pbPrm[dPos++];
if (pbPrm[dPos] > 1) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sInput.bDng_Fw[n] = pbPrm[dPos++];
if (pbPrm[dPos] > 0x3F) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sInput.bDng_Tim[n] = pbPrm[dPos++];
psAECInfo->sInput.bDng_Zero[n][0] = pbPrm[dPos++];
psAECInfo->sInput.bDng_Zero[n][1] = pbPrm[dPos++];
psAECInfo->sInput.bDng_Tgt[n][0] = pbPrm[dPos++];
psAECInfo->sInput.bDng_Tgt[n][1] = pbPrm[dPos++];
if (pbPrm[dPos] > 3) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sInput.bDepop_Att[n] = pbPrm[dPos++];
if (pbPrm[dPos] > 3) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sInput.bDepop_Wait[n] = pbPrm[dPos++];
if (n == 2) {
if (pbPrm[dPos] > 1) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sInput.bRef_Sel = pbPrm[dPos++];
} else {
dPos++;
}
dSubChunkSize = 0;
break;
case AEC_D7_CHUNK_PDM:
if (dSubChunkSize != 10) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
if (psAECInfo->sPdm.bMode != 0xFF) {
/* already done */
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
if (pbPrm[dPos] > 3) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sPdm.bMode = pbPrm[dPos++];
if (pbPrm[dPos] > 3) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sPdm.bStWait = pbPrm[dPos++];
if (pbPrm[dPos] > 7) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sPdm.bPdm0_LoadTim = pbPrm[dPos++];
if (pbPrm[dPos] > 63) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sPdm.bPdm0_LFineDly = pbPrm[dPos++];
if (pbPrm[dPos] > 63) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sPdm.bPdm0_RFineDly = pbPrm[dPos++];
if (pbPrm[dPos] > 7) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sPdm.bPdm1_LoadTim = pbPrm[dPos++];
if (pbPrm[dPos] > 63) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sPdm.bPdm1_LFineDly = pbPrm[dPos++];
if (pbPrm[dPos] > 63) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sPdm.bPdm1_RFineDly = pbPrm[dPos++];
if (pbPrm[dPos] > 1) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sPdm.bPdm0_Data_Delay = pbPrm[dPos++];
if (pbPrm[dPos] > 1) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sPdm.bPdm1_Data_Delay = pbPrm[dPos++];
dSubChunkSize = 0;
break;
case AEC_D7_CHUNK_E2:
if (dSubChunkSize < 3) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
if (psAECInfo->sE2.bEnable != 0) {
/* already done */
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sE2.bEnable = 1;
if (pbPrm[dPos] > 4) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sE2.bE2_Da_Sel = pbPrm[dPos++];
dSubChunkSize--;
if (pbPrm[dPos] > 8) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sE2.bE2_Ad_Sel = pbPrm[dPos++];
dSubChunkSize--;
if (pbPrm[dPos] > 2) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sE2.bE2OnOff = pbPrm[dPos++];
dSubChunkSize--;
if (dSubChunkSize > 0) {
sdRet = AnalyzeEDSPSubChunk(pbPrm,
&dPos,
&dSubChunkSize,
psAECInfo);
}
break;
case AEC_D7_CHUNK_ADJ:
if (dSubChunkSize != 4) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
if (psAECInfo->sAdj.bHold != 0xFF) {
/* already done */
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
if (pbPrm[dPos] > 0x3F) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sAdj.bHold = pbPrm[dPos++];
if (pbPrm[dPos] > 0x0F) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sAdj.bCnt = pbPrm[dPos++];
psAECInfo->sAdj.bMax[0] = pbPrm[dPos++];
psAECInfo->sAdj.bMax[1] = pbPrm[dPos++];
dSubChunkSize = 0;
break;
case AEC_D7_CHUNK_EDSP_MISC:
if (dSubChunkSize != 3) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
if (psAECInfo->sEDspMisc.bI2SOut_Enb != 0xFF) {
/* already done */
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
if (pbPrm[dPos] > 1) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sEDspMisc.bI2SOut_Enb = pbPrm[dPos++];
if (pbPrm[dPos] > 1) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sEDspMisc.bChSel = pbPrm[dPos++];
if (pbPrm[dPos] > 3) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sEDspMisc.bLoopBack = pbPrm[dPos++];
dSubChunkSize = 0;
break;
case AEC_D7_CHUNK_CONTROL:
if (dSubChunkSize != 5) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
if (psAECInfo->sControl.bCommand != 0xFF) {
/* already done */
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
if (McDevProf_GetDevId() == eMCDRV_DEV_ID_80_90H) {
if ((pbPrm[dPos] < 1)
|| (pbPrm[dPos] > 2)) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
} else {
if ((pbPrm[dPos] < 1)
|| (pbPrm[dPos] > 5)) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
}
psAECInfo->sControl.bCommand = pbPrm[dPos++];
psAECInfo->sControl.bParam[0] = pbPrm[dPos++];
psAECInfo->sControl.bParam[1] = pbPrm[dPos++];
psAECInfo->sControl.bParam[2] = pbPrm[dPos++];
psAECInfo->sControl.bParam[3] = pbPrm[dPos++];
dSubChunkSize = 0;
break;
default:
/* unknown */
break;
}
dPos += dSubChunkSize;
}
#if (MCDRV_DEBUG_LEVEL >= 4)
McDebugLog_FuncOut("McParser_AnalyzeD7Chunk", &sdRet);
#endif
return sdRet;
}
/****************************************************************************
* McParser_GetD7Chunk
*
* Description:
* D7 chunk acquisition
* Arguments:
* pbPrm AEC data pointer
* dSize data size
* psD7Info MCDRV_AEC_D7_INFO structure pointer
* Return:
* MCDRV_SUCCESS
* MCDRV_ERROR_ARGUMENT
*
****************************************************************************/
SINT32 McParser_GetD7Chunk(
const UINT8 *pbPrm,
UINT32 dSize,
struct MCDRV_AEC_D7_INFO *psD7Info
)
{
SINT32 sdRet = MCDRV_SUCCESS;
UINT32 dDataSize;
UINT32 dChunkSize;
UINT32 dPos;
#if (MCDRV_DEBUG_LEVEL >= 4)
McDebugLog_FuncIn("");
#endif
if (dSize < (UINT32)AEC_MIN_BYTES) {
sdRet = MCDRV_ERROR_ARGUMENT;
goto exit;
}
/* header */
if ((pbPrm[0] != 0x41)
|| (pbPrm[1] != 0x45)
|| (pbPrm[2] != 0x43)) {
sdRet = MCDRV_ERROR_ARGUMENT;
goto exit;
}
/* revision */
if (pbPrm[3] != AEC_REVISION) {
sdRet = MCDRV_ERROR_ARGUMENT;
goto exit;
}
/* size */
dDataSize = CreateUINT32(pbPrm[4], pbPrm[5], pbPrm[6], pbPrm[7]);
if (dSize != (dDataSize + 8)) {
sdRet = MCDRV_ERROR_ARGUMENT;
goto exit;
}
/* target */
if (pbPrm[9] != AEC_TARGET) {
sdRet = MCDRV_ERROR_ARGUMENT;
goto exit;
}
/* Reserved */
if (pbPrm[11] != 0x00) {
sdRet = MCDRV_ERROR_ARGUMENT;
goto exit;
}
/* D7 Chunk Search */
psD7Info->pbChunkTop = NULL;
psD7Info->dChunkSize = 0;
dPos = AEC_MIN_BYTES;
while ((dPos + AEC_D7_MIN_BYTES) < dSize) {
if ((pbPrm[dPos + 0] == 0x44)
&& (pbPrm[dPos + 1] == 0x37)) {
if (psD7Info->pbChunkTop != NULL) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
dChunkSize = CreateUINT32(pbPrm[dPos + 2],
pbPrm[dPos + 3],
pbPrm[dPos + 4],
pbPrm[dPos + 5]);
if ((dPos + AEC_D7_MIN_BYTES + dChunkSize) > dSize) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psD7Info->pbChunkTop
= &pbPrm[dPos + AEC_D7_MIN_BYTES];
psD7Info->dChunkSize = dChunkSize;
} else {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
/* Next Chunk */
dPos += AEC_D7_MIN_BYTES;
dPos += dChunkSize;
}
if (psD7Info->pbChunkTop == NULL)
sdRet = MCDRV_ERROR_ARGUMENT;
exit:
#if (MCDRV_DEBUG_LEVEL >= 4)
McDebugLog_FuncOut("McParser_GetD7Chunk", &sdRet);
#endif
return sdRet;
}
/****************************************************************************
* AnalyzeSysEqExSubChunk
*
* Description:
* SYS EQ EX Sub chunk analysis
* Arguments:
* pbPrm AEC data pointer
* pdPos AEC sub chunk start pos
* pdSubChunkSize AEC sub chunk byte size
* psSysEqEx MCDRV_AEC_SYSEQ_EX structure pointer
* Return:
* MCDRV_SUCCESS
* MCDRV_ERROR_ARGUMENT
*
****************************************************************************/
static SINT32 AnalyzeSysEqExSubChunk
(
const UINT8 *pbPrm,
UINT32 *pdPos,
UINT32 *pdSubChunkSize,
struct MCDRV_AEC_SYSEQ_EX *psSysEqEx
)
{
SINT32 sdRet = MCDRV_SUCCESS;
UINT32 dChunkId;
UINT32 dChunkSize;
#if (MCDRV_DEBUG_LEVEL >= 4)
McDebugLog_FuncIn("AnalyzeSysEqExSubChunk");
#endif
while (*pdSubChunkSize > 0) {
if (*pdSubChunkSize < 8) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
dChunkId = CreateUINT32(pbPrm[*pdPos],
pbPrm[*pdPos+1],
pbPrm[*pdPos+2],
pbPrm[*pdPos+3]);
dChunkSize = CreateUINT32(pbPrm[*pdPos+4],
pbPrm[*pdPos+5],
pbPrm[*pdPos+6],
pbPrm[*pdPos+7]);
*pdPos += 8;
*pdSubChunkSize -= 8;
if (*pdSubChunkSize < dChunkSize) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
switch (dChunkId) {
case AEC_D7_CHUNK_SYSEQ_EX:
if (dChunkSize != 30) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
if (psSysEqEx->bEnable != 0) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psSysEqEx->bEnable = 1;
psSysEqEx->sBand[0].bCoef_A0[0] = pbPrm[*pdPos+0];
psSysEqEx->sBand[0].bCoef_A0[1] = pbPrm[*pdPos+1];
psSysEqEx->sBand[0].bCoef_A0[2] = pbPrm[*pdPos+2];
psSysEqEx->sBand[0].bCoef_A1[0] = pbPrm[*pdPos+3];
psSysEqEx->sBand[0].bCoef_A1[1] = pbPrm[*pdPos+4];
psSysEqEx->sBand[0].bCoef_A1[2] = pbPrm[*pdPos+5];
psSysEqEx->sBand[0].bCoef_A2[0] = pbPrm[*pdPos+6];
psSysEqEx->sBand[0].bCoef_A2[1] = pbPrm[*pdPos+7];
psSysEqEx->sBand[0].bCoef_A2[2] = pbPrm[*pdPos+8];
psSysEqEx->sBand[0].bCoef_B1[0] = pbPrm[*pdPos+9];
psSysEqEx->sBand[0].bCoef_B1[1] = pbPrm[*pdPos+10];
psSysEqEx->sBand[0].bCoef_B1[2] = pbPrm[*pdPos+11];
psSysEqEx->sBand[0].bCoef_B2[0] = pbPrm[*pdPos+12];
psSysEqEx->sBand[0].bCoef_B2[1] = pbPrm[*pdPos+13];
psSysEqEx->sBand[0].bCoef_B2[2] = pbPrm[*pdPos+14];
psSysEqEx->sBand[1].bCoef_A0[0] = pbPrm[*pdPos+15];
psSysEqEx->sBand[1].bCoef_A0[1] = pbPrm[*pdPos+16];
psSysEqEx->sBand[1].bCoef_A0[2] = pbPrm[*pdPos+17];
psSysEqEx->sBand[1].bCoef_A1[0] = pbPrm[*pdPos+18];
psSysEqEx->sBand[1].bCoef_A1[1] = pbPrm[*pdPos+19];
psSysEqEx->sBand[1].bCoef_A1[2] = pbPrm[*pdPos+20];
psSysEqEx->sBand[1].bCoef_A2[0] = pbPrm[*pdPos+21];
psSysEqEx->sBand[1].bCoef_A2[1] = pbPrm[*pdPos+22];
psSysEqEx->sBand[1].bCoef_A2[2] = pbPrm[*pdPos+23];
psSysEqEx->sBand[1].bCoef_B1[0] = pbPrm[*pdPos+24];
psSysEqEx->sBand[1].bCoef_B1[1] = pbPrm[*pdPos+25];
psSysEqEx->sBand[1].bCoef_B1[2] = pbPrm[*pdPos+26];
psSysEqEx->sBand[1].bCoef_B2[0] = pbPrm[*pdPos+27];
psSysEqEx->sBand[1].bCoef_B2[1] = pbPrm[*pdPos+28];
psSysEqEx->sBand[1].bCoef_B2[2] = pbPrm[*pdPos+29];
*pdPos += 30;
*pdSubChunkSize -= dChunkSize;
break;
default:
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
}
#if (MCDRV_DEBUG_LEVEL >= 4)
McDebugLog_FuncOut("AnalyzeSysEqExSubChunk", &sdRet);
#endif
return sdRet;
}
/****************************************************************************
* AnalyzeVBoxSubChunk
*
* Description:
* V-Box Sub chunk analysis
* Arguments:
* pbPrm AEC data pointer
* pdPos AEC sub chunk start pos
* pdSubChunkSize AEC sub chunk byte size
* psAECInfo MCDRV_AEC_INFO structure pointer
* Return:
* MCDRV_SUCCESS
* MCDRV_ERROR_ARGUMENT
*
****************************************************************************/
static SINT32 AnalyzeVBoxSubChunk(
const UINT8 *pbPrm,
UINT32 *pdPos,
UINT32 *pdSubChunkSize,
struct MCDRV_AEC_INFO *psAECInfo
)
{
SINT32 sdRet = MCDRV_SUCCESS;
UINT32 dChunkId;
UINT32 dChunkSize;
#if (MCDRV_DEBUG_LEVEL >= 4)
McDebugLog_FuncIn("AnalyzeVBoxSubChunk");
#endif
while (*pdSubChunkSize > 0) {
if (*pdSubChunkSize < 8) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
dChunkId = CreateUINT32(pbPrm[*pdPos],
pbPrm[*pdPos+1],
pbPrm[*pdPos+2],
pbPrm[*pdPos+3]);
dChunkSize = CreateUINT32(pbPrm[*pdPos+4],
pbPrm[*pdPos+5],
pbPrm[*pdPos+6],
pbPrm[*pdPos+7]);
*pdSubChunkSize -= 8;
if (*pdSubChunkSize < dChunkSize) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
if (dChunkId == AEC_D7_CHUNK_CDSPA) {
if (psAECInfo->sAecVBox.sAecCDspA.pbChunkData
!= NULL) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sAecVBox.sAecCDspA.pbChunkData
= (UINT8 *)&pbPrm[*pdPos];
psAECInfo->sAecVBox.sAecCDspA.dwSize
= dChunkSize;
} else if (dChunkId == AEC_D7_CHUNK_CDSPB) {
if (psAECInfo->sAecVBox.sAecCDspB.pbChunkData
!= NULL) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sAecVBox.sAecCDspB.pbChunkData
= (UINT8 *)&pbPrm[*pdPos];
psAECInfo->sAecVBox.sAecCDspB.dwSize
= dChunkSize;
} else if ((dChunkId == AEC_D7_CHUNK_FDSP_ES1)
|| (dChunkId == AEC_D7_CHUNK_FDSP)) {
if (((dChunkId == AEC_D7_CHUNK_FDSP_ES1)
&& (McDevProf_GetDevId() == eMCDRV_DEV_ID_80_90H))
|| ((dChunkId == AEC_D7_CHUNK_FDSP)
&& (McDevProf_GetDevId() != eMCDRV_DEV_ID_80_90H))) {
if (psAECInfo->sAecVBox.sAecFDsp.pbChunkData
!= NULL) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sAecVBox.sAecFDsp.pbChunkData
= (UINT8 *)&pbPrm[*pdPos];
psAECInfo->sAecVBox.sAecFDsp.dwSize
= dChunkSize;
}
} else if (dChunkId == AEC_D7_CHUNK_CDSP_DEBUG) {
if (dChunkSize != 1) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
if (psAECInfo->sAecVBox.sAecCDspDbg.bJtagOn
!= 0xFF) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
if (pbPrm[*pdPos+8] > 1) {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
psAECInfo->sAecVBox.sAecCDspDbg.bJtagOn
= pbPrm[*pdPos+8];
} else {
sdRet = MCDRV_ERROR_ARGUMENT;
break;
}
*pdPos += (dChunkSize+8);
*pdSubChunkSize -= dChunkSize;
}
#if (MCDRV_DEBUG_LEVEL >= 4)
McDebugLog_FuncOut("AnalyzeVBoxSubChunk", &sdRet);
#endif
return sdRet;
}
