diff options
Diffstat (limited to 'sound/soc/codecs/ymu831/mcdriver.c')
| -rw-r--r-- | sound/soc/codecs/ymu831/mcdriver.c | 6309 |
1 files changed, 6309 insertions, 0 deletions
diff --git a/sound/soc/codecs/ymu831/mcdriver.c b/sound/soc/codecs/ymu831/mcdriver.c new file mode 100644 index 0000000..47ddddb --- /dev/null +++ b/sound/soc/codecs/ymu831/mcdriver.c @@ -0,0 +1,6309 @@ +/**************************************************************************** + * + * Copyright(c) 2012-2013 Yamaha Corporation. All rights reserved. + * + * Module : mcdriver.c + * + * Description : MC Driver + * + * Version : 1.0.6 2013.02.04 + * + * This software is provided 'as-is', without any express or implied + * warranty. In no event will the authors be held liable for any damages + * arising from the use of this software. + * + * Permission is granted to anyone to use this software for any purpose, + * including commercial applications, and to alter it and redistribute it + * freely, subject to the following restrictions: + * + * 1. The origin of this software must not be misrepresented; you must not + * claim that you wrote the original software. If you use this software + * in a product, an acknowledgment in the product documentation would be + * appreciated but is not required. + * 2. Altered source versions must be plainly marked as such, and must not be + * misrepresented as being the original software. + * 3. This notice may not be removed or altered from any source distribution. + * + ****************************************************************************/ + + +#include "mcdriver.h" +#include "mcservice.h" +#include "mcdevif.h" +#include "mcresctrl.h" +#include "mcparser.h" +#include "mcdefs.h" +#include "mcdevprof.h" +#include "mcmachdep.h" +#include "mcbdspdrv.h" +#include "mccdspdrv.h" +#include "mcedspdrv.h" +#include "mcfdspdrv.h" +#if MCDRV_DEBUG_LEVEL +#include "mcdebuglog.h" +#endif + + + + +#define MCDRV_MAX_WAIT_TIME (268435455UL) +#define MCDRV_LDO_WAIT_TIME (1000UL) +#define MCDRV_DAC_MUTE_WAIT_TIME (20000UL) +#define MCDRV_VREF_WAIT_TIME_ES1 (2000UL) +#define MCDRV_VREF_WAIT_TIME (30000UL) +#define MCDRV_MB4_WAIT_TIME (8000UL) +#define MCDRV_SP_WAIT_TIME (200UL) + +#define T_CPMODE_IMPSENSE_BEFORE (0) +#define T_CPMODE_IMPSENSE_AFTER (2) + +static const struct MCDRV_PATH_INFO gsPathInfoAllOff = { + {{0x00AAAAAA}, {0x00AAAAAA} }, /* asMusicOut */ + {{0x00AAAAAA}, {0x00AAAAAA} }, /* asExtOut */ + {{0x00AAAAAA} }, /* asHifiOut */ + {{0x00AAAAAA}, {0x00AAAAAA}, + {0x00AAAAAA}, {0x00AAAAAA} }, /* asVboxMixIn */ + {{0x00AAAAAA}, {0x00AAAAAA} }, /* asAe0 */ + {{0x00AAAAAA}, {0x00AAAAAA} }, /* asAe1 */ + {{0x00AAAAAA}, {0x00AAAAAA} }, /* asAe2 */ + {{0x00AAAAAA}, {0x00AAAAAA} }, /* asAe3 */ + {{0x00AAAAAA}, {0x00AAAAAA} }, /* asDac0 */ + {{0x00AAAAAA}, {0x00AAAAAA} }, /* asDac1 */ + {{0x00AAAAAA} }, /* asVoiceOut */ + {{0x00AAAAAA} }, /* asVboxIoIn */ + {{0x00AAAAAA} }, /* asVboxHostIn */ + {{0x00AAAAAA} }, /* asHostOut */ + {{0x00AAAAAA}, {0x00AAAAAA} }, /* asAdif0 */ + {{0x00AAAAAA}, {0x00AAAAAA} }, /* asAdif1 */ + {{0x00AAAAAA}, {0x00AAAAAA} }, /* asAdif2 */ + {{0x002AAAAA}, {0x002AAAAA} }, /* asAdc0 */ + {{0x002AAAAA} }, /* asAdc1 */ + {{0x002AAAAA}, {0x002AAAAA} }, /* asSp */ + {{0x002AAAAA}, {0x002AAAAA} }, /* asHp */ + {{0x002AAAAA} }, /* asRc */ + {{0x002AAAAA}, {0x002AAAAA} }, /* asLout1 */ + {{0x002AAAAA}, {0x002AAAAA} }, /* asLout2 */ + {{0x002AAAAA}, {0x002AAAAA}, + {0x002AAAAA}, {0x002AAAAA} } /* asBias */ +}; + +static const struct MCDRV_PATH_INFO gsPathInfoAllZero = { + {{0x00000000}, {0x00000000} }, /* asMusicOut */ + {{0x00000000}, {0x00000000} }, /* asExtOut */ + {{0x00000000} }, /* asHifiOut */ + {{0x00000000}, {0x00000000}, + {0x00000000}, {0x00000000} }, /* asVboxMixIn */ + {{0x00000000}, {0x00000000} }, /* asAe0 */ + {{0x00000000}, {0x00000000} }, /* asAe1 */ + {{0x00000000}, {0x00000000} }, /* asAe2 */ + {{0x00000000}, {0x00000000} }, /* asAe3 */ + {{0x00000000}, {0x00000000} }, /* asDac0 */ + {{0x00000000}, {0x00000000} }, /* asDac1 */ + {{0x00000000} }, /* asVoiceOut */ + {{0x00000000} }, /* asVboxIoIn */ + {{0x00000000} }, /* asVboxHostIn */ + {{0x00000000} }, /* asHostOut */ + {{0x00000000}, {0x00000000} }, /* asAdif0 */ + {{0x00000000}, {0x00000000} }, /* asAdif1 */ + {{0x00000000}, {0x00000000} }, /* asAdif2 */ + {{0x00000000}, {0x00000000} }, /* asAdc0 */ + {{0x00000000} }, /* asAdc1 */ + {{0x00000000}, {0x00000000} }, /* asSp */ + {{0x00000000}, {0x00000000} }, /* asHp */ + {{0x00000000} }, /* asRc */ + {{0x00000000}, {0x00000000} }, /* asLout1 */ + {{0x00000000}, {0x00000000} }, /* asLout2 */ + {{0x00000000}, {0x00000000}, + {0x00000000}, {0x00000000} } /* asBias */ +}; + +static SINT32 init(const struct MCDRV_INIT_INFO *psInitInfo, + const struct MCDRV_INIT2_INFO *psInit2Info); +static SINT32 term(void); + +static SINT32 read_reg(struct MCDRV_REG_INFO *psRegInfo); +static SINT32 write_reg(const struct MCDRV_REG_INFO *psRegInfo); + +static SINT32 get_clocksw(struct MCDRV_CLOCKSW_INFO *psClockSwInfo); +static SINT32 set_clocksw(const struct MCDRV_CLOCKSW_INFO *psClockSwInfo); + +static SINT32 get_path(struct MCDRV_PATH_INFO *psPathInfo); +static SINT32 set_path(const struct MCDRV_PATH_INFO *psPathInfo); + +static SINT32 get_volume(struct MCDRV_VOL_INFO *psVolInfo); +static SINT32 set_volume(const struct MCDRV_VOL_INFO *psVolInfo); + +static SINT32 get_digitalio(struct MCDRV_DIO_INFO *psDioInfo); +static SINT32 set_digitalio(const struct MCDRV_DIO_INFO *psDioInfo, + UINT32 dUpdateInfo); + +static SINT32 get_digitalio_path(struct MCDRV_DIOPATH_INFO *psDioPathInfo); +static SINT32 set_digitalio_path( + const struct MCDRV_DIOPATH_INFO *psDioPathInfo, + UINT32 dUpdateInfo); + +static SINT32 get_swap(struct MCDRV_SWAP_INFO *psSwapInfo); +static SINT32 set_swap(const struct MCDRV_SWAP_INFO *psSwapInfo, + UINT32 dUpdateInfo); + +static UINT8 IsPathAllOff(void); +static SINT32 set_dsp(const UINT8 *pbPrm, UINT32 dSize); +static SINT32 get_dsp(struct MCDRV_DSP_PARAM *psDspParam, + void *pvData, + UINT32 dSize); +static SINT32 get_dsp_data(UINT8 *pbData, UINT32 dSize); +static SINT32 set_dsp_data(const UINT8 *pbData, UINT32 dSize); +static SINT32 register_dsp_cb(SINT32 (*pcbfunc)(SINT32, UINT32, UINT32)); +static SINT32 get_dsp_transition(UINT32 dDspType); + +static SINT32 get_hsdet(struct MCDRV_HSDET_INFO *psHSDet, + struct MCDRV_HSDET2_INFO *psHSDet2); +static SINT32 set_hsdet(const struct MCDRV_HSDET_INFO *psHSDet, + const struct MCDRV_HSDET2_INFO *psHSDet2, + UINT32 dUpdateInfo); +static SINT32 config_gp(const struct MCDRV_GP_MODE *psGpMode); +static SINT32 mask_gp(UINT8 *pbMask, UINT32 dPadNo); +static SINT32 getset_gp(UINT8 *pbGpio, UINT32 dPadNo); + +static SINT32 irq_proc(void); +static SINT32 BeginImpSense(UINT8 *bOP_DAC); + +static UINT8 IsLDOAOn(void); +static UINT8 IsValidInitParam(const struct MCDRV_INIT_INFO *psInitInfo, + const struct MCDRV_INIT2_INFO *psInit2Info); +static UINT8 IsValidClockSwParam( + const struct MCDRV_CLOCKSW_INFO *psClockSwInfo); +static UINT8 IsValidReadRegParam(const struct MCDRV_REG_INFO *psRegInfo); +static UINT8 IsValidWriteRegParam(const struct MCDRV_REG_INFO *psRegInfo); +static void MaskIrregularPath(struct MCDRV_PATH_INFO *psPathInfo); +static UINT8 IsValidDioParam(const struct MCDRV_DIO_INFO *psDioInfo, + UINT32 dUpdateInfo); +static UINT8 IsValidDioPathParam( + const struct MCDRV_DIOPATH_INFO *psDioPathInfo, + UINT32 dUpdateInfo); +static UINT8 IsValidSwapParam(const struct MCDRV_SWAP_INFO *psSwapInfo, + UINT32 dUpdateInfo); +static UINT8 IsValidDspParam(const struct MCDRV_AEC_INFO *psAECInfo); +static UINT8 IsValidHSDetParam(const struct MCDRV_HSDET_INFO *psHSDetInfo, + const struct MCDRV_HSDET2_INFO *psHSDet2Info, + UINT32 dUpdateInfo); +static UINT8 IsValidGpParam(const struct MCDRV_GP_MODE *psGpMode); +static UINT8 IsValidMaskGp(UINT8 bMask, UINT32 dPadNo); + +static UINT8 CheckDIOCommon(const struct MCDRV_DIO_INFO *psDioInfo, + UINT8 bPort); +static UINT8 CheckDaFormat(const struct MCDRV_DA_FORMAT *psDaFormat); +static UINT8 CheckPcmFormat(const struct MCDRV_PCM_FORMAT *psPcmFormat); +static UINT8 CheckDIODIR(const struct MCDRV_DIO_INFO *psDioInfo, + UINT8 bPort); +static UINT8 CheckDIODIT(const struct MCDRV_DIO_INFO *psDioInfo, + UINT8 bPort); + +static SINT32 SetVol(UINT32 dUpdate, + enum MCDRV_VOLUPDATE_MODE eMode, + UINT32 *pdSVolDoneParam); +static void GetMuteParam(UINT8 *pbDIRMuteParam, + UINT8 *pbADCMuteParam, + UINT8 *pbDITMuteParam, + UINT8 *pbDACMuteParam); +static SINT32 SavePower(void); + +/**************************************************************************** + * init + * + * Description: + * Initialize. + * Arguments: + * psInitInfo initialize information + * psInit2Info initialize information + * Return: + * MCDRV_SUCCESS + * MCDRV_ERROR_ARGUMENT + * MCDRV_ERROR_STATE + * + ****************************************************************************/ +static SINT32 init +( + const struct MCDRV_INIT_INFO *psInitInfo, + const struct MCDRV_INIT2_INFO *psInit2Info +) +{ + SINT32 sdRet; + UINT8 abData[4]; + UINT8 bHwId_dig, + bHwId_ana = 0; + UINT8 bAP = MCI_AP_DEF; + enum MCDRV_STATE eState = McResCtrl_GetState(); + struct MCDRV_POWER_INFO sPowerInfo; + struct MCDRV_POWER_UPDATE sPowerUpdate; + + if (NULL == psInitInfo) + return MCDRV_ERROR_ARGUMENT; + + if (eMCDRV_STATE_READY == eState) + return MCDRV_ERROR_STATE; + + McSrv_SystemInit(); + McSrv_Lock(); + McResCtrl_Init(); + + machdep_PreLDODStart(); + + if (bHwId_ana == 0) { + abData[0] = MCI_ANA_REG_A<<1; + abData[1] = MCI_ANA_ID; + McSrv_WriteReg(MCDRV_SLAVEADDR_ANA, abData, 2); + bHwId_ana = McSrv_ReadReg(MCDRV_SLAVEADDR_ANA, + (UINT32)MCI_ANA_REG_D); + if ((bHwId_ana&MCDRV_DEVID_MASK) == MCDRV_DEVID_ANA) { + abData[0] = MCI_ANA_REG_A<<1; + abData[1] = MCI_ANA_RST; + abData[2] = MCI_ANA_REG_D<<1; + abData[3] = MCI_ANA_RST_DEF; + McSrv_WriteReg(MCDRV_SLAVEADDR_ANA, abData, 4); + abData[3] = 0; + McSrv_WriteReg(MCDRV_SLAVEADDR_ANA, abData, 4); + + if ((bHwId_ana&MCDRV_VERID_MASK) == 0) { + abData[1] = MCI_AP; + abData[3] = MCI_AP_DEF; + abData[3] &= + (UINT8)~MCB_AP_VR; + McSrv_WriteReg(MCDRV_SLAVEADDR_ANA, abData, 4); + McSrv_Sleep(MCDRV_VREF_WAIT_TIME_ES1); + abData[3] &= + (UINT8)~(MCB_AP_LDOA|MCB_AP_BGR); + McSrv_WriteReg(MCDRV_SLAVEADDR_ANA, abData, 4); + McSrv_Sleep(MCDRV_LDO_WAIT_TIME); + bAP = abData[3]; + } else { + abData[1] = MCI_HIZ; + abData[3] = 0; + McSrv_WriteReg(MCDRV_SLAVEADDR_ANA, abData, 4); + abData[1] = MCI_LO_HIZ; + abData[3] = 0; + McSrv_WriteReg(MCDRV_SLAVEADDR_ANA, abData, 4); + abData[1] = MCI_AP; + bAP &= (UINT8)~(MCB_AP_LDOA|MCB_AP_BGR); + abData[3] = bAP; + McSrv_WriteReg(MCDRV_SLAVEADDR_ANA, abData, 4); + McSrv_Sleep(MCDRV_LDO_WAIT_TIME); + abData[1] = 62; + abData[3] = 0x20; + McSrv_WriteReg(MCDRV_SLAVEADDR_ANA, abData, 4); + abData[1] = MCI_AP; + bAP &= (UINT8)~MCB_AP_VR; + abData[3] = bAP; + McSrv_WriteReg(MCDRV_SLAVEADDR_ANA, abData, 4); + McSrv_Sleep(MCDRV_VREF_WAIT_TIME); + abData[1] = 62; + abData[3] = 0; + McSrv_WriteReg(MCDRV_SLAVEADDR_ANA, abData, 4); + } + } + } + if ((bHwId_ana&MCDRV_DEVID_MASK) == MCDRV_DEVID_ANA) { + if ((bHwId_ana&MCDRV_VERID_MASK) == 0) + bHwId_dig = 0x80; + else + bHwId_dig = 0x81; + sdRet = McResCtrl_SetHwId(bHwId_dig, bHwId_ana); + if (sdRet == MCDRV_SUCCESS) { + if (IsValidInitParam(psInitInfo, psInit2Info) == 0) + sdRet = MCDRV_ERROR_ARGUMENT; + McResCtrl_SetRegVal(MCDRV_PACKET_REGTYPE_ANA, MCI_AP, + bAP); + } + if (sdRet == MCDRV_SUCCESS) { + McResCtrl_SetInitInfo(psInitInfo, psInit2Info); + sdRet = McDevIf_AllocPacketBuf(); + } + if (sdRet == MCDRV_SUCCESS) + sdRet = McPacket_AddInit(); + + if (sdRet == MCDRV_SUCCESS) + sdRet = McDevIf_ExecutePacket(); + + if (sdRet == MCDRV_SUCCESS) { + if (psInitInfo->bPowerMode == MCDRV_POWMODE_CDSPDEBUG) { + McResCtrl_GetPowerInfo(&sPowerInfo); + /* used path power up */ + sPowerUpdate.bDigital = MCDRV_POWUPDATE_D_ALL; + sPowerUpdate.abAnalog[0] = MCB_AP_LDOD; + sPowerUpdate.abAnalog[1] = + sPowerUpdate.abAnalog[2] = + sPowerUpdate.abAnalog[3] = + sPowerUpdate.abAnalog[4] = 0; + sdRet = + McPacket_AddPowerUp(&sPowerInfo, &sPowerUpdate); + } else { + if ((psInit2Info != NULL) + && (psInit2Info->bOption[19] == 1)) { + /* LDOD always on */ + McResCtrl_GetPowerInfo(&sPowerInfo); + sPowerInfo.bDigital &= + (UINT8)~MCDRV_POWINFO_D_PLL_PD; + sPowerInfo.abAnalog[0] &= + (UINT8)~MCB_AP_LDOD; + /* used path power up */ + sPowerUpdate.bDigital = + MCDRV_POWUPDATE_D_ALL; + sPowerUpdate.abAnalog[0] = + MCB_AP_LDOD; + sPowerUpdate.abAnalog[1] = + sPowerUpdate.abAnalog[2] = + sPowerUpdate.abAnalog[3] = + sPowerUpdate.abAnalog[4] = 0; + sdRet = + McPacket_AddPowerUp(&sPowerInfo, + &sPowerUpdate); + } else { + abData[0] = MCI_ANA_REG_A<<1; + abData[1] = MCI_AP; + abData[2] = MCI_ANA_REG_D<<1; + bAP &= (UINT8)~MCB_AP_LDOD; + abData[3] = bAP; + McSrv_WriteReg(MCDRV_SLAVEADDR_ANA, + abData, 4); + McResCtrl_SetRegVal( + MCDRV_PACKET_REGTYPE_ANA, + MCI_AP, bAP); + abData[0] = MCI_RST_A<<1; + abData[1] = MCI_RST_A_DEF; + McSrv_WriteReg(MCDRV_SLAVEADDR_DIG, + abData, 2); + abData[1] = + MCI_RST_A_DEF&~MCB_RST_A; + McSrv_WriteReg(MCDRV_SLAVEADDR_DIG, + abData, 2); + } + } + } + + if (sdRet == MCDRV_SUCCESS) + sdRet = McDevIf_ExecutePacket(); + + if (sdRet == MCDRV_SUCCESS) { + abData[0] = MCI_A_REG_A<<1; + abData[1] = MCI_A_DEV_ID; + McSrv_WriteReg(MCDRV_SLAVEADDR_DIG, abData, 2); + abData[3] = McSrv_ReadReg(MCDRV_SLAVEADDR_DIG, + (UINT32)MCI_A_REG_D); + if (abData[3] != bHwId_dig) + sdRet = MCDRV_ERROR_INIT; + } + + if (sdRet == MCDRV_SUCCESS) { + McResCtrl_UpdateState(eMCDRV_STATE_READY); + SavePower(); + } else + McDevIf_ReleasePacketBuf(); + } else + sdRet = MCDRV_ERROR_INIT; + + bAP = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_ANA, MCI_AP); + if ((bAP&MCB_AP_LDOD) != 0) { + ; + machdep_PostLDODStart(); + } + + McSrv_Unlock(); + + if (sdRet != MCDRV_SUCCESS) + McSrv_SystemTerm(); + + return sdRet; +} + +/**************************************************************************** + * term + * + * Description: + * Terminate. + * Arguments: + * none + * Return: + * MCDRV_SUCCESS + * MCDRV_ERROR_STATE + * + ****************************************************************************/ +static SINT32 term +( + void +) +{ + SINT32 sdRet = MCDRV_SUCCESS; + struct MCDRV_INIT_INFO sInitInfo; + struct MCDRV_POWER_INFO sPowerInfo; + struct MCDRV_POWER_UPDATE sPowerUpdate; + UINT32 dUpdateFlg; + struct MCDRV_HSDET_INFO sHSDet; + UINT8 bAP; + + if (eMCDRV_STATE_READY != McResCtrl_GetState()) + return MCDRV_ERROR_STATE; + + McSrv_Lock(); + + bAP = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_ANA, MCI_AP); + if ((bAP&MCB_AP_LDOD) != 0) { + ; + machdep_PreLDODStart(); + } + + McResCtrl_GetInitInfo(&sInitInfo, NULL); + sInitInfo.bPowerMode = MCDRV_POWMODE_FULL; + McResCtrl_SetInitInfo(&sInitInfo, NULL); + + sdRet = set_path(&gsPathInfoAllOff); + if (sdRet == MCDRV_SUCCESS) { + sPowerInfo.bDigital = 0xFF; + sPowerInfo.abAnalog[0] = + sPowerInfo.abAnalog[1] = + sPowerInfo.abAnalog[2] = + sPowerInfo.abAnalog[3] = + sPowerInfo.abAnalog[4] = (UINT8)0xFF; + sPowerUpdate.bDigital = MCDRV_POWUPDATE_D_ALL; + sPowerUpdate.abAnalog[0] = + (UINT8)MCDRV_POWUPDATE_AP; + sPowerUpdate.abAnalog[1] = + (UINT8)MCDRV_POWUPDATE_AP_OUT0; + sPowerUpdate.abAnalog[2] = + (UINT8)MCDRV_POWUPDATE_AP_OUT1; + sPowerUpdate.abAnalog[3] = + (UINT8)MCDRV_POWUPDATE_AP_MC; + sPowerUpdate.abAnalog[4] = + (UINT8)MCDRV_POWUPDATE_AP_IN; + sdRet = McPacket_AddPowerDown(&sPowerInfo, &sPowerUpdate); + if (sdRet == MCDRV_SUCCESS) + sdRet = McDevIf_ExecutePacket(); + } + + sHSDet.bEnPlugDet = MCDRV_PLUGDET_DISABLE; + sHSDet.bEnPlugDetDb = MCDRV_PLUGDETDB_DISABLE; + sHSDet.bEnDlyKeyOff = MCDRV_KEYEN_D_D_D; + sHSDet.bEnDlyKeyOn = MCDRV_KEYEN_D_D_D; + sHSDet.bEnMicDet = MCDRV_MICDET_DISABLE; + sHSDet.bEnKeyOff = MCDRV_KEYEN_D_D_D; + sHSDet.bEnKeyOn = MCDRV_KEYEN_D_D_D; + dUpdateFlg = MCDRV_ENPLUGDET_UPDATE_FLAG + |MCDRV_ENPLUGDETDB_UPDATE_FLAG + |MCDRV_ENDLYKEYOFF_UPDATE_FLAG + |MCDRV_ENDLYKEYON_UPDATE_FLAG + |MCDRV_ENMICDET_UPDATE_FLAG + |MCDRV_ENKEYOFF_UPDATE_FLAG + |MCDRV_ENKEYON_UPDATE_FLAG; + sdRet = set_hsdet(&sHSDet, NULL, dUpdateFlg); + + McDevIf_ReleasePacketBuf(); + + McResCtrl_UpdateState(eMCDRV_STATE_NOTINIT); + + if ((bAP&MCB_AP_LDOD) != 0) { + ; + machdep_PostLDODStart(); + } + McSrv_Unlock(); + + McSrv_SystemTerm(); + + return sdRet; +} + +/**************************************************************************** + * read_reg + * + * Description: + * read register. + * Arguments: + * psRegInfo register information + * Return: + * MCDRV_SUCCESS + * MCDRV_ERROR_STATE + * MCDRV_ERROR_ARGUMENT + * + ****************************************************************************/ +static SINT32 read_reg +( + struct MCDRV_REG_INFO *psRegInfo +) +{ + SINT32 sdRet = MCDRV_SUCCESS; + UINT8 bSlaveAddr; + UINT8 bAddr; + UINT8 abData[2]; + struct MCDRV_POWER_INFO sPowerInfo; + struct MCDRV_POWER_INFO sCurPowerInfo; + struct MCDRV_POWER_UPDATE sPowerUpdate; + + if (NULL == psRegInfo) + return MCDRV_ERROR_ARGUMENT; + + if (eMCDRV_STATE_READY != McResCtrl_GetState()) + return MCDRV_ERROR_STATE; + + if (IsValidReadRegParam(psRegInfo) == 0) + return MCDRV_ERROR_ARGUMENT; + + /* get current power info */ + McResCtrl_GetCurPowerInfo(&sCurPowerInfo); + + /* power up */ + McResCtrl_GetPowerInfoRegAccess(psRegInfo, &sPowerInfo); + sPowerUpdate.bDigital = MCDRV_POWUPDATE_D_ALL; + sPowerUpdate.abAnalog[0] = (UINT8)MCDRV_POWUPDATE_AP; + sPowerUpdate.abAnalog[1] = (UINT8)MCDRV_POWUPDATE_AP_OUT0; + sPowerUpdate.abAnalog[2] = (UINT8)MCDRV_POWUPDATE_AP_OUT1; + sPowerUpdate.abAnalog[3] = (UINT8)MCDRV_POWUPDATE_AP_MC; + sPowerUpdate.abAnalog[4] = (UINT8)MCDRV_POWUPDATE_AP_IN; + sdRet = McPacket_AddPowerUp(&sPowerInfo, &sPowerUpdate); + if (MCDRV_SUCCESS != sdRet) + return sdRet; + sdRet = McDevIf_ExecutePacket(); + if (MCDRV_SUCCESS != sdRet) + return sdRet; + + bAddr = psRegInfo->bAddress; + + if (psRegInfo->bRegType == MCDRV_REGTYPE_IF) { + if ((psRegInfo->bAddress == MCI_ANA_REG_A) + || (psRegInfo->bAddress == MCI_ANA_REG_D)) + bSlaveAddr = + McDevProf_GetSlaveAddr(eMCDRV_SLAVE_ADDR_ANA); + else + bSlaveAddr = + McDevProf_GetSlaveAddr(eMCDRV_SLAVE_ADDR_DIG); + } else { + switch (psRegInfo->bRegType) { + case MCDRV_REGTYPE_A: + bSlaveAddr = + McDevProf_GetSlaveAddr(eMCDRV_SLAVE_ADDR_DIG); + abData[0] = MCI_A_REG_A<<1; + abData[1] = bAddr; + McSrv_WriteReg(bSlaveAddr, abData, 2); + bAddr = MCI_A_REG_D; + break; + + case MCDRV_REGTYPE_MA: + bSlaveAddr = + McDevProf_GetSlaveAddr(eMCDRV_SLAVE_ADDR_DIG); + abData[0] = MCI_MA_REG_A<<1; + abData[1] = bAddr; + McSrv_WriteReg(bSlaveAddr, abData, 2); + bAddr = MCI_MA_REG_D; + break; + + case MCDRV_REGTYPE_MB: + bSlaveAddr = + McDevProf_GetSlaveAddr(eMCDRV_SLAVE_ADDR_DIG); + abData[0] = MCI_MB_REG_A<<1; + abData[1] = bAddr; + McSrv_WriteReg(bSlaveAddr, abData, 2); + bAddr = MCI_MB_REG_D; + break; + + case MCDRV_REGTYPE_B: + bSlaveAddr = + McDevProf_GetSlaveAddr(eMCDRV_SLAVE_ADDR_DIG); + abData[0] = MCI_B_REG_A<<1; + abData[1] = bAddr; + McSrv_WriteReg(bSlaveAddr, abData, 2); + bAddr = MCI_B_REG_D; + break; + + case MCDRV_REGTYPE_E: + bSlaveAddr = + McDevProf_GetSlaveAddr(eMCDRV_SLAVE_ADDR_DIG); + abData[0] = MCI_E_REG_A<<1; + abData[1] = bAddr; + McSrv_WriteReg(bSlaveAddr, abData, 2); + bAddr = MCI_E_REG_D; + break; + + case MCDRV_REGTYPE_C: + bSlaveAddr = + McDevProf_GetSlaveAddr(eMCDRV_SLAVE_ADDR_DIG); + abData[0] = MCI_C_REG_A<<1; + abData[1] = bAddr; + McSrv_WriteReg(bSlaveAddr, abData, 2); + bAddr = MCI_C_REG_D; + break; + + case MCDRV_REGTYPE_F: + bSlaveAddr = + McDevProf_GetSlaveAddr(eMCDRV_SLAVE_ADDR_DIG); + abData[0] = MCI_F_REG_A<<1; + abData[1] = bAddr; + McSrv_WriteReg(bSlaveAddr, abData, 2); + bAddr = MCI_F_REG_D; + break; + + case MCDRV_REGTYPE_ANA: + bSlaveAddr = + McDevProf_GetSlaveAddr(eMCDRV_SLAVE_ADDR_ANA); + abData[0] = MCI_ANA_REG_A<<1; + abData[1] = bAddr; + McSrv_WriteReg(bSlaveAddr, abData, 2); + bAddr = MCI_ANA_REG_D; + break; + + case MCDRV_REGTYPE_CD: + bSlaveAddr = + McDevProf_GetSlaveAddr(eMCDRV_SLAVE_ADDR_ANA); + abData[0] = MCI_CD_REG_A<<1; + abData[1] = bAddr; + McSrv_WriteReg(bSlaveAddr, abData, 2); + bAddr = MCI_CD_REG_D; + break; + + default: + return MCDRV_ERROR_ARGUMENT; + } + } + + /* read register */ + psRegInfo->bData = McSrv_ReadReg(bSlaveAddr, bAddr); + + /* restore power */ + sdRet = McPacket_AddPowerDown(&sCurPowerInfo, &sPowerUpdate); + if (MCDRV_SUCCESS != sdRet) + return sdRet; + return McDevIf_ExecutePacket(); +} + +/**************************************************************************** + * write_reg + * + * Description: + * Write register. + * Arguments: + * psWR register information + * Return: + * MCDRV_SUCCESS + * MCDRV_ERROR_STATE + * MCDRV_ERROR_ARGUMENT + * MCDRV_ERROR_RESOURCEOVER + * + ****************************************************************************/ +static SINT32 write_reg +( + const struct MCDRV_REG_INFO *psRegInfo +) +{ + SINT32 sdRet = MCDRV_SUCCESS; + struct MCDRV_POWER_INFO sPowerInfo; + struct MCDRV_POWER_INFO sCurPowerInfo; + struct MCDRV_POWER_UPDATE sPowerUpdate; + UINT8 abData[2]; + + if (NULL == psRegInfo) + return MCDRV_ERROR_ARGUMENT; + + if (eMCDRV_STATE_READY != McResCtrl_GetState()) + return MCDRV_ERROR_STATE; + + if (IsValidWriteRegParam(psRegInfo) == 0) + return MCDRV_ERROR_ARGUMENT; + + /* get current power info */ + McResCtrl_GetCurPowerInfo(&sCurPowerInfo); + + /* power up */ + McResCtrl_GetPowerInfoRegAccess(psRegInfo, &sPowerInfo); + sPowerUpdate.bDigital = MCDRV_POWUPDATE_D_ALL; + sPowerUpdate.abAnalog[0] = (UINT8)MCDRV_POWUPDATE_AP; + sPowerUpdate.abAnalog[1] = (UINT8)MCDRV_POWUPDATE_AP_OUT0; + sPowerUpdate.abAnalog[2] = (UINT8)MCDRV_POWUPDATE_AP_OUT1; + sPowerUpdate.abAnalog[3] = (UINT8)MCDRV_POWUPDATE_AP_MC; + sPowerUpdate.abAnalog[4] = (UINT8)MCDRV_POWUPDATE_AP_IN; + sdRet = McPacket_AddPowerUp(&sPowerInfo, &sPowerUpdate); + if (sdRet != MCDRV_SUCCESS) + return sdRet; + + switch (psRegInfo->bRegType) { + case MCDRV_REGTYPE_IF: + if ((psRegInfo->bAddress == MCI_ANA_REG_A) + || (psRegInfo->bAddress == MCI_ANA_REG_D) + || (psRegInfo->bAddress == MCI_CD_REG_A) + || (psRegInfo->bAddress == MCI_CD_REG_D)) { + abData[0] = psRegInfo->bAddress<<1; + abData[1] = psRegInfo->bData; + McSrv_WriteReg( + McDevProf_GetSlaveAddr(eMCDRV_SLAVE_ADDR_ANA), + abData, 2); + } else { + ; + McDevIf_AddPacket( + (MCDRV_PACKET_TYPE_FORCE_WRITE + | MCDRV_PACKET_REGTYPE_IF + | psRegInfo->bAddress), + psRegInfo->bData); + } + break; + + case MCDRV_REGTYPE_A: + McDevIf_AddPacket( + (MCDRV_PACKET_TYPE_FORCE_WRITE + | MCDRV_PACKET_REGTYPE_A + | psRegInfo->bAddress), + psRegInfo->bData); + break; + + case MCDRV_REGTYPE_MA: + McDevIf_AddPacket( + (MCDRV_PACKET_TYPE_FORCE_WRITE + | MCDRV_PACKET_REGTYPE_MA + | psRegInfo->bAddress), + psRegInfo->bData); + break; + + case MCDRV_REGTYPE_MB: + McDevIf_AddPacket( + (MCDRV_PACKET_TYPE_FORCE_WRITE + | MCDRV_PACKET_REGTYPE_MB + | psRegInfo->bAddress), + psRegInfo->bData); + break; + + case MCDRV_REGTYPE_B: + McDevIf_AddPacket( + (MCDRV_PACKET_TYPE_FORCE_WRITE + | MCDRV_PACKET_REGTYPE_B + | psRegInfo->bAddress), + psRegInfo->bData); + break; + + case MCDRV_REGTYPE_E: + McDevIf_AddPacket( + (MCDRV_PACKET_TYPE_FORCE_WRITE + | MCDRV_PACKET_REGTYPE_E + | psRegInfo->bAddress), + psRegInfo->bData); + break; + + case MCDRV_REGTYPE_C: + McDevIf_AddPacket( + (MCDRV_PACKET_TYPE_FORCE_WRITE + | MCDRV_PACKET_REGTYPE_C + | psRegInfo->bAddress), + psRegInfo->bData); + break; + + case MCDRV_REGTYPE_F: + McDevIf_AddPacket( + (MCDRV_PACKET_TYPE_FORCE_WRITE + | MCDRV_PACKET_REGTYPE_F + | psRegInfo->bAddress), + psRegInfo->bData); + break; + + case MCDRV_REGTYPE_ANA: + McDevIf_AddPacket( + (MCDRV_PACKET_TYPE_FORCE_WRITE + | MCDRV_PACKET_REGTYPE_ANA + | psRegInfo->bAddress), + psRegInfo->bData); + break; + + case MCDRV_REGTYPE_CD: + McDevIf_AddPacket( + (MCDRV_PACKET_TYPE_FORCE_WRITE + | MCDRV_PACKET_REGTYPE_CD + | psRegInfo->bAddress), + psRegInfo->bData); + break; + + default: + return MCDRV_ERROR_ARGUMENT; + } + + sdRet = McDevIf_ExecutePacket(); + if (sdRet != MCDRV_SUCCESS) + return sdRet; + + /* restore power */ + switch (psRegInfo->bRegType) { + case MCDRV_REGTYPE_A: + sCurPowerInfo.bDigital &= ~MCDRV_POWINFO_D_PLL_PD; + if (psRegInfo->bAddress == MCI_PD) { + if (((psRegInfo->bData&MCB_PE_CLK_PD) == 0) + && (sCurPowerInfo.bDigital&MCDRV_POWINFO_D_PM_CLK_PD) + == 0) + sCurPowerInfo.bDigital + &= ~MCDRV_POWINFO_D_PE_CLK_PD; + if (((psRegInfo->bData&MCB_PB_CLK_PD) == 0) + && (sCurPowerInfo.bDigital&MCDRV_POWINFO_D_PM_CLK_PD) + == 0) + sCurPowerInfo.bDigital + &= ~MCDRV_POWINFO_D_PB_CLK_PD; + } + break; + case MCDRV_REGTYPE_IF: + if (psRegInfo->bAddress == MCI_RST) { + if ((psRegInfo->bData&MCB_PSW_M) == 0) + sCurPowerInfo.bDigital + &= ~MCDRV_POWINFO_D_PM_CLK_PD; + if ((psRegInfo->bData&MCB_PSW_F) == 0) + sCurPowerInfo.bDigital + &= ~MCDRV_POWINFO_D_PF_CLK_PD; + if ((psRegInfo->bData&MCB_PSW_C) == 0) + sCurPowerInfo.bDigital + &= ~MCDRV_POWINFO_D_PC_CLK_PD; + } + break; + + case MCDRV_REGTYPE_ANA: + if (psRegInfo->bAddress == MCI_AP) + sCurPowerInfo.abAnalog[0] = psRegInfo->bData; + else if (psRegInfo->bAddress == MCI_AP_DA0) + sCurPowerInfo.abAnalog[1] = psRegInfo->bData; + else if (psRegInfo->bAddress == MCI_AP_DA1) + sCurPowerInfo.abAnalog[2] = psRegInfo->bData; + else if (psRegInfo->bAddress == MCI_AP_MIC) + sCurPowerInfo.abAnalog[3] = psRegInfo->bData; + else if (psRegInfo->bAddress == MCI_AP_AD) + sCurPowerInfo.abAnalog[4] = psRegInfo->bData; + break; + + default: + break; + } + sdRet = McPacket_AddPowerDown(&sCurPowerInfo, &sPowerUpdate); + if (MCDRV_SUCCESS == sdRet) + return sdRet; + return McDevIf_ExecutePacket(); +} + +/**************************************************************************** + * get_clocksw + * + * Description: + * Get clock switch setting. + * Arguments: + * psClockSwInfo clock switch information + * Return: + * MCDRV_SUCCESS + * MCDRV_ERROR_STATE + * + ****************************************************************************/ +static SINT32 get_clocksw +( + struct MCDRV_CLOCKSW_INFO *psClockSwInfo +) +{ + if (NULL == psClockSwInfo) + return MCDRV_ERROR_ARGUMENT; + + if (eMCDRV_STATE_READY != McResCtrl_GetState()) + return MCDRV_ERROR_STATE; + + McResCtrl_GetClockSwInfo(psClockSwInfo); + + return MCDRV_SUCCESS; +} + +/**************************************************************************** + * set_clocksw + * + * Description: + * Set clock switch. + * Arguments: + * psClockSwInfo clock switch information + * Return: + * MCDRV_SUCCESS + * MCDRV_ERROR_ARGUMENT + * MCDRV_ERROR_STATE + * + ****************************************************************************/ +static SINT32 set_clocksw +( + const struct MCDRV_CLOCKSW_INFO *psClockSwInfo +) +{ + struct MCDRV_CLOCKSW_INFO sCurClockSwInfo; + + if (NULL == psClockSwInfo) + return MCDRV_ERROR_ARGUMENT; + + if (eMCDRV_STATE_READY != McResCtrl_GetState()) + return MCDRV_ERROR_STATE; + + if (IsValidClockSwParam(psClockSwInfo) == 0) + return MCDRV_ERROR_ARGUMENT; + + McResCtrl_GetClockSwInfo(&sCurClockSwInfo); + if (sCurClockSwInfo.bClkSrc == psClockSwInfo->bClkSrc) + return MCDRV_SUCCESS; + + McResCtrl_SetClockSwInfo(psClockSwInfo); + McPacket_AddClockSw(); + return McDevIf_ExecutePacket(); +} + +/**************************************************************************** + * get_path + * + * Description: + * Get current path setting. + * Arguments: + * psPathInfo path information + * Return: + * MCDRV_SUCCESS + * MCDRV_ERROR_STATE + * + ****************************************************************************/ +static SINT32 get_path +( + struct MCDRV_PATH_INFO *psPathInfo +) +{ + if (NULL == psPathInfo) + return MCDRV_ERROR_ARGUMENT; + + if (eMCDRV_STATE_READY != McResCtrl_GetState()) + return MCDRV_ERROR_STATE; + + McResCtrl_GetPathInfoVirtual(psPathInfo); + + return MCDRV_SUCCESS; +} + +/**************************************************************************** + * set_path + * + * Description: + * Set path. + * Arguments: + * psPathInfo path information + * Return: + * MCDRV_SUCCESS + * MCDRV_ERROR_ARGUMENT + * MCDRV_ERROR_STATE + * + ****************************************************************************/ +static SINT32 set_path +( + const struct MCDRV_PATH_INFO *psPathInfo +) +{ + SINT32 sdRet = MCDRV_SUCCESS; + UINT32 dSVolDoneParam = 0; + UINT8 bDIRMuteParam = 0; + UINT8 bADCMuteParam = 0; + UINT8 bDITMuteParam = 0; + UINT8 bDACMuteParam = 0; + enum MCDRV_STATE eState = McResCtrl_GetState(); + struct MCDRV_PATH_INFO sPathInfo; + struct MCDRV_POWER_INFO sPowerInfo; + struct MCDRV_POWER_UPDATE sPowerUpdate; + UINT8 bDSPStarted = McResCtrl_GetDspStart(); + UINT8 bHPVolL, bHPVolR; + UINT8 bSPVolL, bSPVolR; + UINT8 bReg; + + if (NULL == psPathInfo) + return MCDRV_ERROR_ARGUMENT; + + if (eMCDRV_STATE_READY != eState) + return MCDRV_ERROR_STATE; + + sPathInfo = *psPathInfo; + MaskIrregularPath(&sPathInfo); + + sdRet = McResCtrl_SetPathInfo(&sPathInfo); + if (sdRet != MCDRV_SUCCESS) + return sdRet; + + bHPVolL = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_ANA, MCI_HPVOL_L); + bHPVolL &= (UINT8)~MCB_ALAT_HP; + bHPVolR = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_ANA, MCI_HPVOL_R); + bSPVolL = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_ANA, MCI_SPVOL_L); + bSPVolL &= (UINT8)~MCB_ALAT_SP; + bSPVolR = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_ANA, MCI_SPVOL_R); + + /* unused analog out volume mute */ + sdRet = SetVol(MCDRV_VOLUPDATE_ANA_OUT, + eMCDRV_VOLUPDATE_MUTE, + &dSVolDoneParam); + if (sdRet != MCDRV_SUCCESS) + return sdRet; + + if (dSVolDoneParam != 0UL) + McDevIf_AddPacket( + MCDRV_PACKET_TYPE_EVTWAIT + | MCDRV_EVT_SVOL_DONE + | dSVolDoneParam, + 0); + sdRet = McDevIf_ExecutePacket(); + if (sdRet != MCDRV_SUCCESS) + return sdRet; + + if ((bSPVolL != 0) + || (bSPVolR != 0)) { + bSPVolL = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_ANA, + MCI_SPVOL_L); + bSPVolL &= (UINT8)~MCB_ALAT_SP; + bSPVolR = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_ANA, + MCI_SPVOL_R); + if ((bSPVolL == 0) + && (bSPVolR == 0)) { + ; + McDevIf_AddPacket(MCDRV_PACKET_TYPE_TIMWAIT + | MCDRV_SP_WAIT_TIME, 0); + } + } + + GetMuteParam(&bDIRMuteParam, + &bADCMuteParam, + &bDITMuteParam, + &bDACMuteParam); + + /* unused volume mute */ + sdRet = SetVol(MCDRV_VOLUPDATE_DIG, + eMCDRV_VOLUPDATE_MUTE, + NULL); + if (sdRet != MCDRV_SUCCESS) + return sdRet; + + /* set volume */ + sdRet = SetVol(MCDRV_VOLUPDATE_ANA_IN, + eMCDRV_VOLUPDATE_ALL, + NULL); + if (sdRet != MCDRV_SUCCESS) + return sdRet; + + /* wait VFLAG */ + if (bDIRMuteParam != 0) + McDevIf_AddPacket( + MCDRV_PACKET_TYPE_EVTWAIT + | MCDRV_EVT_DIRMUTE + | bDIRMuteParam, + 0); + + if (bADCMuteParam != 0) + McDevIf_AddPacket( + MCDRV_PACKET_TYPE_EVTWAIT + | MCDRV_EVT_ADCMUTE + | bADCMuteParam, + 0); + + if (bDITMuteParam != 0) + McDevIf_AddPacket( + MCDRV_PACKET_TYPE_EVTWAIT + | MCDRV_EVT_DITMUTE + | bDITMuteParam, + 0); + + if (bDACMuteParam != 0) + McDevIf_AddPacket( + MCDRV_PACKET_TYPE_EVTWAIT + | MCDRV_EVT_DACMUTE + | bDACMuteParam, + 0); + + /* F-DSP stop */ + McPacket_AddFDSPStop(bDSPStarted); + sdRet = McDevIf_ExecutePacket(); + if (sdRet != MCDRV_SUCCESS) + return sdRet; + + /* stop unused path */ + McPacket_AddStop(); + sdRet = McDevIf_ExecutePacket(); + if (sdRet != MCDRV_SUCCESS) + return sdRet; + + McResCtrl_GetPowerInfo(&sPowerInfo); + + /* unused analog out path power down */ + sPowerUpdate.bDigital = 0; + sPowerUpdate.abAnalog[0] = (UINT8)0; + sPowerUpdate.abAnalog[1] = (UINT8)MCDRV_POWUPDATE_AP_OUT0; + sPowerUpdate.abAnalog[2] = (UINT8)MCDRV_POWUPDATE_AP_OUT1; + sPowerUpdate.abAnalog[3] = (UINT8)0; + sPowerUpdate.abAnalog[4] = (UINT8)0; + sdRet = McPacket_AddPowerDown(&sPowerInfo, &sPowerUpdate); + if (sdRet != MCDRV_SUCCESS) + return sdRet; + sdRet = McDevIf_ExecutePacket(); + if (sdRet != MCDRV_SUCCESS) + return sdRet; + + /* used path power up */ + sPowerUpdate.bDigital = MCDRV_POWUPDATE_D_ALL; + sPowerUpdate.abAnalog[0] = (UINT8)MCDRV_POWUPDATE_AP; + sPowerUpdate.abAnalog[1] = (UINT8)MCDRV_POWUPDATE_AP_OUT0; + sPowerUpdate.abAnalog[2] = (UINT8)MCDRV_POWUPDATE_AP_OUT1; + sPowerUpdate.abAnalog[3] = (UINT8)MCDRV_POWUPDATE_AP_MC; + sPowerUpdate.abAnalog[4] = (UINT8)MCDRV_POWUPDATE_AP_IN; + sdRet = McPacket_AddPowerUp(&sPowerInfo, &sPowerUpdate); + if (sdRet != MCDRV_SUCCESS) + return sdRet; + sdRet = McDevIf_ExecutePacket(); + if (sdRet != MCDRV_SUCCESS) + return sdRet; + + /* set mixer */ + McPacket_AddPathSet(); + sdRet = McDevIf_ExecutePacket(); + if (sdRet != MCDRV_SUCCESS) + return sdRet; + + /* DSP start */ + McPacket_AddDSPStartStop(bDSPStarted); + sdRet = McDevIf_ExecutePacket(); + if (sdRet != MCDRV_SUCCESS) + return sdRet; + + if ((bHPVolL != 0) + || (bHPVolR != 0)) { + if ((bHPVolL == 0) + || ((dSVolDoneParam&(MCB_HPL_BUSY<<8)) != 0)) { + if ((bHPVolR == 0) + || ((dSVolDoneParam&(MCB_HPR_BUSY<<8)) != 0)) { + if ((sPowerInfo.abAnalog[3] & MCB_MB4) != 0) { + bReg = McResCtrl_GetRegVal( + MCDRV_PACKET_REGTYPE_ANA, + MCI_AP_MIC); + if ((bReg&MCB_MB4) == 0) { + ; + McDevIf_AddPacket( + MCDRV_PACKET_TYPE_TIMWAIT + | MCDRV_MB4_WAIT_TIME, + 0); + } + } + } + } + } + + /* unused path power down */ + sPowerUpdate.bDigital = MCDRV_POWUPDATE_D_ALL; + sPowerUpdate.abAnalog[0] = (UINT8)MCDRV_POWUPDATE_AP; + sPowerUpdate.abAnalog[1] = (UINT8)MCDRV_POWUPDATE_AP_OUT0; + sPowerUpdate.abAnalog[2] = (UINT8)MCDRV_POWUPDATE_AP_OUT1; + sPowerUpdate.abAnalog[3] = (UINT8)MCDRV_POWUPDATE_AP_MC; + sPowerUpdate.abAnalog[4] = (UINT8)MCDRV_POWUPDATE_AP_IN; + sdRet = McPacket_AddPowerDown(&sPowerInfo, &sPowerUpdate); + if (sdRet != MCDRV_SUCCESS) + return sdRet; + sdRet = McDevIf_ExecutePacket(); + if (sdRet != MCDRV_SUCCESS) + return sdRet; + + /* start */ + McPacket_AddStart(); + sdRet = McDevIf_ExecutePacket(); + if (sdRet != MCDRV_SUCCESS) + return sdRet; + + /* set volume */ + sdRet = SetVol(MCDRV_VOLUPDATE_DIG, + eMCDRV_VOLUPDATE_ALL, + NULL); + if (sdRet != MCDRV_SUCCESS) + return sdRet; + sdRet = SetVol(MCDRV_VOLUPDATE_ANA_OUT, + eMCDRV_VOLUPDATE_ALL, + &dSVolDoneParam); + if (sdRet != MCDRV_SUCCESS) + return sdRet; + + return sdRet; +} + +/**************************************************************************** + * get_volume + * + * Description: + * Get current volume setting. + * Arguments: + * psVolInfo volume information + * Return: + * MCDRV_SUCCESS + * MCDRV_ERROR_ARGUMENT + * + ****************************************************************************/ +static SINT32 get_volume +( + struct MCDRV_VOL_INFO *psVolInfo +) +{ + if (NULL == psVolInfo) + return MCDRV_ERROR_ARGUMENT; + + if (eMCDRV_STATE_READY != McResCtrl_GetState()) + return MCDRV_ERROR_STATE; + + McResCtrl_GetVolInfo(psVolInfo); + + return MCDRV_SUCCESS; +} + +/**************************************************************************** + * set_volume + * + * Description: + * Set volume. + * Arguments: + * psVolInfo volume update information + * Return: + * MCDRV_SUCCESS + * MCDRV_ERROR_ARGUMENT + * + ****************************************************************************/ +static SINT32 set_volume +( + const struct MCDRV_VOL_INFO *psVolInfo +) +{ + enum MCDRV_STATE eState = McResCtrl_GetState(); + struct MCDRV_PATH_INFO sPathInfo; + + if (NULL == psVolInfo) + return MCDRV_ERROR_ARGUMENT; + + if (eMCDRV_STATE_READY != eState) + return MCDRV_ERROR_STATE; + + McResCtrl_SetVolInfo(psVolInfo); + + McResCtrl_GetPathInfoVirtual(&sPathInfo); + return set_path(&sPathInfo); +} + +/**************************************************************************** + * get_digitalio + * + * Description: + * Get current digital IO setting. + * Arguments: + * psDioInfo digital IO information + * Return: + * MCDRV_SUCCESS + * MCDRV_ERROR_STATE + * + ****************************************************************************/ +static SINT32 get_digitalio +( + struct MCDRV_DIO_INFO *psDioInfo +) +{ + if (NULL == psDioInfo) + return MCDRV_ERROR_ARGUMENT; + + if (eMCDRV_STATE_READY != McResCtrl_GetState()) + return MCDRV_ERROR_STATE; + + McResCtrl_GetDioInfo(psDioInfo); + + return MCDRV_SUCCESS; +} + +/**************************************************************************** + * set_digitalio + * + * Description: + * Update digital IO configuration. + * Arguments: + * psDioInfo digital IO configuration + * dUpdateInfo update information + * Return: + * MCDRV_SUCCESS + * MCDRV_ERROR_ARGUMENT + * MCDRV_ERROR_STATE + * + ****************************************************************************/ +static SINT32 set_digitalio +( + const struct MCDRV_DIO_INFO *psDioInfo, + UINT32 dUpdateInfo +) +{ + enum MCDRV_STATE eState = McResCtrl_GetState(); + + if (NULL == psDioInfo) + return MCDRV_ERROR_ARGUMENT; + + if (eMCDRV_STATE_READY != eState) + return MCDRV_ERROR_STATE; + + if (IsValidDioParam(psDioInfo, dUpdateInfo) == 0) + return MCDRV_ERROR_ARGUMENT; + + McResCtrl_SetDioInfo(psDioInfo, dUpdateInfo); + + McPacket_AddDigitalIO(dUpdateInfo); + return McDevIf_ExecutePacket(); +} + +/**************************************************************************** + * get_digitalio_path + * + * Description: + * Get current digital IO path setting. + * Arguments: + * psDioInfoPath digital IO path information + * Return: + * MCDRV_SUCCESS + * MCDRV_ERROR_STATE + * + ****************************************************************************/ +static SINT32 get_digitalio_path +( + struct MCDRV_DIOPATH_INFO *psDioPathInfo +) +{ + if (NULL == psDioPathInfo) + return MCDRV_ERROR_ARGUMENT; + + if (eMCDRV_STATE_READY != McResCtrl_GetState()) + return MCDRV_ERROR_STATE; + + McResCtrl_GetDioPathInfo(psDioPathInfo); + + return MCDRV_SUCCESS; +} + +/**************************************************************************** + * set_digitalio_path + * + * Description: + * Update digital IO path configuration. + * Arguments: + * psDioInfoPath digital IO path configuration + * dUpdateInfo update information + * Return: + * MCDRV_SUCCESS + * MCDRV_ERROR_ARGUMENT + * MCDRV_ERROR_STATE + * + ****************************************************************************/ +static SINT32 set_digitalio_path +( + const struct MCDRV_DIOPATH_INFO *psDioPathInfo, + UINT32 dUpdateInfo +) +{ + enum MCDRV_STATE eState = McResCtrl_GetState(); + + if (NULL == psDioPathInfo) + return MCDRV_ERROR_ARGUMENT; + + if (eMCDRV_STATE_READY != eState) + return MCDRV_ERROR_STATE; + + if (IsValidDioPathParam(psDioPathInfo, dUpdateInfo) == 0) + return MCDRV_ERROR_ARGUMENT; + + McResCtrl_SetDioPathInfo(psDioPathInfo, dUpdateInfo); + + McPacket_AddDigitalIOPath(); + return McDevIf_ExecutePacket(); +} + +/**************************************************************************** + * get_swap + * + * Description: + * Get Swap setting. + * Arguments: + * psSwapInfo pointer to MCDRV_SWAP_INFO struct + * Return: + * MCDRV_SUCCESS + * MCDRV_ERROR_STATE + * MCDRV_ERROR_ARGUMENT +* + ****************************************************************************/ +static SINT32 get_swap +( + struct MCDRV_SWAP_INFO *psSwapInfo +) +{ + enum MCDRV_STATE eState = McResCtrl_GetState(); + + if (eMCDRV_STATE_READY != eState) + return MCDRV_ERROR_STATE; + + if (NULL == psSwapInfo) + return MCDRV_ERROR_ARGUMENT; + + McResCtrl_GetSwap(psSwapInfo); + + return MCDRV_SUCCESS; +} + +/**************************************************************************** + * set_swap + * + * Description: + * Set Swap setting. + * Arguments: + * psSwapInfo pointer to MCDRV_SWAP_INFO struct + * dUpdateInfo update information + * Return: + * MCDRV_SUCCESS + * MCDRV_ERROR_STATE + * MCDRV_ERROR_ARGUMENT +* + ****************************************************************************/ +static SINT32 set_swap +( + const struct MCDRV_SWAP_INFO *psSwapInfo, + UINT32 dUpdateInfo +) +{ + enum MCDRV_STATE eState = McResCtrl_GetState(); + + if (eMCDRV_STATE_READY != eState) + return MCDRV_ERROR_STATE; + + if (NULL == psSwapInfo) + return MCDRV_ERROR_ARGUMENT; + + if (IsValidSwapParam(psSwapInfo, dUpdateInfo) == 0) + return MCDRV_ERROR_ARGUMENT; + + McResCtrl_SetSwap(psSwapInfo, dUpdateInfo); + McPacket_AddSwap(dUpdateInfo); + return McDevIf_ExecutePacket(); +} + + +/**************************************************************************** + * IsPathAllOff + * + * Description: + * Is Path All Off. + * Arguments: + * none + * Return: + * 0:not All Off, 1:All Off + * + ****************************************************************************/ +static UINT8 IsPathAllOff +( + void +) +{ + UINT8 bRet = 1; + struct MCDRV_PATH_INFO sCurPathInfo; + +#if (MCDRV_DEBUG_LEVEL >= 4) + SINT32 sdRet; + McDebugLog_FuncIn("IsPathAllOff"); +#endif + McResCtrl_GetPathInfoVirtual(&sCurPathInfo); + if ((sCurPathInfo.asMusicOut[0].dSrcOnOff + != gsPathInfoAllOff.asMusicOut[0].dSrcOnOff) + || (sCurPathInfo.asMusicOut[1].dSrcOnOff + != gsPathInfoAllOff.asMusicOut[1].dSrcOnOff) + || (sCurPathInfo.asExtOut[0].dSrcOnOff + != gsPathInfoAllOff.asExtOut[0].dSrcOnOff) + || (sCurPathInfo.asExtOut[1].dSrcOnOff + != gsPathInfoAllOff.asExtOut[1].dSrcOnOff) + || (sCurPathInfo.asHifiOut[0].dSrcOnOff + != gsPathInfoAllOff.asHifiOut[0].dSrcOnOff) + || (sCurPathInfo.asVboxMixIn[0].dSrcOnOff + != gsPathInfoAllOff.asVboxMixIn[0].dSrcOnOff) + || (sCurPathInfo.asVboxMixIn[1].dSrcOnOff + != gsPathInfoAllOff.asVboxMixIn[1].dSrcOnOff) + || (sCurPathInfo.asVboxMixIn[2].dSrcOnOff + != gsPathInfoAllOff.asVboxMixIn[2].dSrcOnOff) + || (sCurPathInfo.asVboxMixIn[3].dSrcOnOff + != gsPathInfoAllOff.asVboxMixIn[3].dSrcOnOff) + || (sCurPathInfo.asAe0[0].dSrcOnOff + != gsPathInfoAllOff.asAe0[0].dSrcOnOff) + || (sCurPathInfo.asAe0[1].dSrcOnOff + != gsPathInfoAllOff.asAe0[1].dSrcOnOff) + || (sCurPathInfo.asAe1[0].dSrcOnOff + != gsPathInfoAllOff.asAe1[0].dSrcOnOff) + || (sCurPathInfo.asAe1[1].dSrcOnOff + != gsPathInfoAllOff.asAe1[1].dSrcOnOff) + || (sCurPathInfo.asAe2[0].dSrcOnOff + != gsPathInfoAllOff.asAe2[0].dSrcOnOff) + || (sCurPathInfo.asAe2[1].dSrcOnOff + != gsPathInfoAllOff.asAe2[1].dSrcOnOff) + || (sCurPathInfo.asAe3[0].dSrcOnOff + != gsPathInfoAllOff.asAe3[0].dSrcOnOff) + || (sCurPathInfo.asAe3[1].dSrcOnOff + != gsPathInfoAllOff.asAe3[1].dSrcOnOff) + || (sCurPathInfo.asDac0[0].dSrcOnOff + != gsPathInfoAllOff.asDac0[0].dSrcOnOff) + || (sCurPathInfo.asDac0[1].dSrcOnOff + != gsPathInfoAllOff.asDac0[1].dSrcOnOff) + || (sCurPathInfo.asDac1[0].dSrcOnOff + != gsPathInfoAllOff.asDac1[0].dSrcOnOff) + || (sCurPathInfo.asDac1[1].dSrcOnOff + != gsPathInfoAllOff.asDac1[1].dSrcOnOff) + || (sCurPathInfo.asVoiceOut[0].dSrcOnOff + != gsPathInfoAllOff.asVoiceOut[0].dSrcOnOff) + || (sCurPathInfo.asVboxIoIn[0].dSrcOnOff + != gsPathInfoAllOff.asVboxIoIn[0].dSrcOnOff) + || (sCurPathInfo.asVboxHostIn[0].dSrcOnOff + != gsPathInfoAllOff.asVboxHostIn[0].dSrcOnOff) + || (sCurPathInfo.asHostOut[0].dSrcOnOff + != gsPathInfoAllOff.asHostOut[0].dSrcOnOff) + || (sCurPathInfo.asAdif0[0].dSrcOnOff + != gsPathInfoAllOff.asAdif0[0].dSrcOnOff) + || (sCurPathInfo.asAdif0[1].dSrcOnOff + != gsPathInfoAllOff.asAdif0[1].dSrcOnOff) + || (sCurPathInfo.asAdif1[0].dSrcOnOff + != gsPathInfoAllOff.asAdif1[0].dSrcOnOff) + || (sCurPathInfo.asAdif1[1].dSrcOnOff + != gsPathInfoAllOff.asAdif1[1].dSrcOnOff) + || (sCurPathInfo.asAdif2[0].dSrcOnOff + != gsPathInfoAllOff.asAdif2[0].dSrcOnOff) + || (sCurPathInfo.asAdif2[1].dSrcOnOff + != gsPathInfoAllOff.asAdif2[1].dSrcOnOff) + || (sCurPathInfo.asAdc0[0].dSrcOnOff + != gsPathInfoAllOff.asAdc0[0].dSrcOnOff) + || (sCurPathInfo.asAdc0[1].dSrcOnOff + != gsPathInfoAllOff.asAdc0[1].dSrcOnOff) + || (sCurPathInfo.asAdc1[0].dSrcOnOff + != gsPathInfoAllOff.asAdc1[0].dSrcOnOff) + || (sCurPathInfo.asSp[0].dSrcOnOff + != gsPathInfoAllOff.asSp[0].dSrcOnOff) + || (sCurPathInfo.asSp[1].dSrcOnOff + != gsPathInfoAllOff.asSp[1].dSrcOnOff) + || (sCurPathInfo.asHp[0].dSrcOnOff + != gsPathInfoAllOff.asHp[0].dSrcOnOff) + || (sCurPathInfo.asHp[1].dSrcOnOff + != gsPathInfoAllOff.asHp[1].dSrcOnOff) + || (sCurPathInfo.asRc[0].dSrcOnOff + != gsPathInfoAllOff.asRc[0].dSrcOnOff) + || (sCurPathInfo.asLout1[0].dSrcOnOff + != gsPathInfoAllOff.asLout1[0].dSrcOnOff) + || (sCurPathInfo.asLout1[1].dSrcOnOff + != gsPathInfoAllOff.asLout1[1].dSrcOnOff) + || (sCurPathInfo.asLout2[0].dSrcOnOff + != gsPathInfoAllOff.asLout2[0].dSrcOnOff) + || (sCurPathInfo.asLout2[1].dSrcOnOff + != gsPathInfoAllOff.asLout2[1].dSrcOnOff) + || (sCurPathInfo.asBias[0].dSrcOnOff + != gsPathInfoAllOff.asBias[0].dSrcOnOff) + || (sCurPathInfo.asBias[1].dSrcOnOff + != gsPathInfoAllOff.asBias[1].dSrcOnOff) + || (sCurPathInfo.asBias[2].dSrcOnOff + != gsPathInfoAllOff.asBias[2].dSrcOnOff) + || (sCurPathInfo.asBias[3].dSrcOnOff + != gsPathInfoAllOff.asBias[3].dSrcOnOff) + ) + bRet = 0; + +#if (MCDRV_DEBUG_LEVEL >= 4) + sdRet = bRet; + McDebugLog_FuncOut("IsPathAllOff", &sdRet); +#endif + return bRet; +} + +/**************************************************************************** + * set_dsp + * + * Description: + * Set DSP parameter. + * Arguments: + * pbPrm pointer to AEC parameter + * dSize data byte size. + * Return: + * MCDRV_SUCCESS + * MCDRV_ERROR_STATE + * MCDRV_ERROR_ARGUMENT +* + ****************************************************************************/ +static SINT32 set_dsp +( + const UINT8 *pbPrm, + UINT32 dSize +) +{ + SINT32 sdRet = MCDRV_SUCCESS; + enum MCDRV_STATE eState = McResCtrl_GetState(); + struct MCDRV_AEC_D7_INFO sD7Info; + struct MCDRV_AEC_INFO sAECInfo, sCurAECInfo; + struct MCDRV_POWER_INFO sPowerInfo; + struct MCDRV_POWER_UPDATE sPowerUpdate; + static struct MCDRV_PATH_INFO sPathInfo; + static UINT8 bLP2_START, bSRC3_START; + UINT32 dSVolDoneParam = 0; + UINT32 dMuteFlg; + UINT8 bReg; + + if (eMCDRV_STATE_READY != eState) + return MCDRV_ERROR_STATE; + + if (NULL == pbPrm) + return MCDRV_ERROR_ARGUMENT; + + if (dSize == 0) + return MCDRV_SUCCESS; + + McResCtrl_GetAecInfo(&sAECInfo); + sCurAECInfo = sAECInfo; + + sdRet = McParser_GetD7Chunk(pbPrm, dSize, &sD7Info); + if (sdRet < MCDRV_SUCCESS) + return sdRet; + + sdRet = McParser_AnalyzeD7Chunk(&sD7Info, &sAECInfo); + if (sdRet < MCDRV_SUCCESS) + return sdRet; + + if (IsValidDspParam(&sAECInfo) == 0) { + sdRet = MCDRV_ERROR_ARGUMENT; + return sdRet; + } + + McResCtrl_SetAecInfo(&sAECInfo); + McResCtrl_GetAecInfo(&sAECInfo); + + sAECInfo.sAecVBox.bCDspFuncAOnOff &= 0x01; + sAECInfo.sAecVBox.bCDspFuncBOnOff &= 0x01; + if (sAECInfo.sControl.bCommand == 1) { + if (sAECInfo.sControl.bParam[0] == 0) { + if (IsPathAllOff() == 0) { + McResCtrl_GetPathInfoVirtual(&sPathInfo); + sdRet = set_path(&gsPathInfoAllOff); + if (sdRet != MCDRV_SUCCESS) { + ; + goto exit; + } + } + } + } else if (sAECInfo.sControl.bCommand == 2) { + if (sAECInfo.sControl.bParam[0] == 0) { + bLP2_START = + McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_MB, + MCI_LP2_START); + McDevIf_AddPacket(MCDRV_PACKET_TYPE_WRITE + | MCDRV_PACKET_REGTYPE_MB + | (UINT32)MCI_LP2_START, + 0); + bSRC3_START = + McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_MB, + MCI_SRC3_START); + McDevIf_AddPacket(MCDRV_PACKET_TYPE_WRITE + | MCDRV_PACKET_REGTYPE_MB + | (UINT32)MCI_SRC3_START, + 0); + sdRet = McDevIf_ExecutePacket(); + if (sdRet != MCDRV_SUCCESS) + goto exit; + } + } else if (sAECInfo.sControl.bCommand == 3) { + if (McDevProf_GetDevId() != eMCDRV_DEV_ID_80_90H) { + McPacket_AddDOutMute(); + dMuteFlg = MCB_DIFO3_VFLAG1 + | MCB_DIFO3_VFLAG0 + | MCB_DIFO2_VFLAG1 + | MCB_DIFO2_VFLAG0 + | MCB_DIFO1_VFLAG1 + | MCB_DIFO1_VFLAG0 + | MCB_DIFO0_VFLAG1 + | MCB_DIFO0_VFLAG0; + McDevIf_AddPacket( + MCDRV_PACKET_TYPE_EVTWAIT + | MCDRV_EVT_DITMUTE + | dMuteFlg, + 0); + dMuteFlg = MCB_DAO1_VFLAG1 + | MCB_DAO1_VFLAG0 + | MCB_DAO0_VFLAG1 + | MCB_DAO0_VFLAG0; + McDevIf_AddPacket( + MCDRV_PACKET_TYPE_EVTWAIT + | MCDRV_EVT_DACMUTE + | dMuteFlg, + 0); + McDevIf_AddPacket(MCDRV_PACKET_TYPE_WRITE + | MCDRV_PACKET_REGTYPE_MA + | (UINT32)MCI_CLK_SEL, + sAECInfo.sControl.bParam[0]); + McResCtrl_SetClkSel(sAECInfo.sControl.bParam[0]); + sdRet = McDevIf_ExecutePacket(); + if (sdRet != MCDRV_SUCCESS) + goto exit; + sdRet = SetVol(MCDRV_VOLUPDATE_DOUT, + eMCDRV_VOLUPDATE_ALL, + NULL); + if (sdRet != MCDRV_SUCCESS) + goto exit; + } + } else if (sAECInfo.sControl.bCommand == 4) { + if (McDevProf_GetDevId() != eMCDRV_DEV_ID_80_90H) { + McPacket_AddDac0Mute(); + McPacket_AddDac1Mute(); + McPacket_AddAdifMute(); + McPacket_AddDPathDAMute(); + dMuteFlg = MCB_ADI2_VFLAG1 + | MCB_ADI2_VFLAG0 + | MCB_ADI1_VFLAG1 + | MCB_ADI1_VFLAG0 + | MCB_ADI0_VFLAG1 + | MCB_ADI0_VFLAG0; + McDevIf_AddPacket( + MCDRV_PACKET_TYPE_EVTWAIT + | MCDRV_EVT_ADCMUTE + | dMuteFlg, + 0); + dMuteFlg = MCB_SPR_BUSY<<8 + | MCB_SPL_BUSY<<8 + | MCB_HPR_BUSY<<8 + | MCB_HPL_BUSY<<8 + | MCB_LO2R_BUSY + | MCB_LO2L_BUSY + | MCB_LO1R_BUSY + | MCB_LO1L_BUSY + | MCB_RC_BUSY; + McDevIf_AddPacket( + MCDRV_PACKET_TYPE_EVTWAIT + | MCDRV_EVT_SVOL_DONE + | dMuteFlg, + 0); + McDevIf_AddPacket(MCDRV_PACKET_TYPE_WRITE + | MCDRV_PACKET_REGTYPE_E + | (UINT32)MCI_ECLK_SEL, + sAECInfo.sControl.bParam[0]); + McResCtrl_SetEClkSel(sAECInfo.sControl.bParam[0]); + sdRet = McDevIf_ExecutePacket(); + if (sdRet != MCDRV_SUCCESS) + goto exit; + sdRet = SetVol(MCDRV_VOLUPDATE_ANA_OUT + | MCDRV_VOLUPDATE_ADIF0 + | MCDRV_VOLUPDATE_ADIF1 + | MCDRV_VOLUPDATE_ADIF2 + | MCDRV_VOLUPDATE_DPATHDA, + eMCDRV_VOLUPDATE_ALL, + &dSVolDoneParam); + if (sdRet != MCDRV_SUCCESS) + goto exit; + } + } else if (sAECInfo.sControl.bCommand == 5) { + bReg = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_A, + MCI_FREQ73M); + if ((sAECInfo.sControl.bParam[0] != 0xFF)) { + bReg &= 0xF8; + bReg |= sAECInfo.sControl.bParam[0]; + McResCtrl_SetCClkSel(sAECInfo.sControl.bParam[0]); + } + if ((sAECInfo.sControl.bParam[1] != 0xFF)) { + bReg &= 0x3F; + bReg |= (sAECInfo.sControl.bParam[1]<<6); + McResCtrl_SetFClkSel(sAECInfo.sControl.bParam[1]); + } + McDevIf_AddPacket(MCDRV_PACKET_TYPE_WRITE + | MCDRV_PACKET_REGTYPE_A + | (UINT32)MCI_FREQ73M, + bReg); + sdRet = McDevIf_ExecutePacket(); + if (sdRet != MCDRV_SUCCESS) + goto exit; + } + + sdRet = McBdsp_SetDSPCheck(&sAECInfo); + if (sdRet < MCDRV_SUCCESS) + goto exit; + sdRet = McCdsp_SetDSPCheck(&sAECInfo); + if (sdRet < MCDRV_SUCCESS) + goto exit; + sdRet = McEdsp_SetDSPCheck(&sAECInfo); + if (sdRet < MCDRV_SUCCESS) + goto exit; + sdRet = McFdsp_SetDSPCheck(&sAECInfo); + if (sdRet < MCDRV_SUCCESS) + goto exit; + + McResCtrl_GetPowerInfo(&sPowerInfo); + sPowerUpdate.bDigital = MCDRV_POWUPDATE_D_ALL; + sPowerUpdate.abAnalog[0] = (UINT8)MCDRV_POWUPDATE_AP; + sPowerUpdate.abAnalog[1] = (UINT8)MCDRV_POWUPDATE_AP_OUT0; + sPowerUpdate.abAnalog[2] = (UINT8)MCDRV_POWUPDATE_AP_OUT1; + sPowerUpdate.abAnalog[3] = (UINT8)MCDRV_POWUPDATE_AP_MC; + sPowerUpdate.abAnalog[4] = (UINT8)MCDRV_POWUPDATE_AP_IN; + sdRet = McPacket_AddPowerUp(&sPowerInfo, &sPowerUpdate); + if (sdRet != MCDRV_SUCCESS) + goto exit; + sdRet = McDevIf_ExecutePacket(); + if (sdRet != MCDRV_SUCCESS) + goto exit; + + McPacket_AddAEC(); + sdRet = McDevIf_ExecutePacket(); + if (sdRet != MCDRV_SUCCESS) + goto exit; + + sdRet = McBdsp_SetDSP(&sAECInfo); + if (sdRet < MCDRV_SUCCESS) + goto exit; + sdRet = McCdsp_SetDSP(&sAECInfo); + if (sdRet < MCDRV_SUCCESS) + goto exit; + sdRet = McEdsp_SetDSP(&sAECInfo); + if (sdRet < MCDRV_SUCCESS) + goto exit; + sdRet = McFdsp_SetDSP(&sAECInfo); + if (sdRet < MCDRV_SUCCESS) + goto exit; + + if (sAECInfo.sControl.bCommand == 1) { + if (sAECInfo.sControl.bParam[0] == 1) { + sdRet = set_path(&sPathInfo); + sPathInfo = gsPathInfoAllZero; + if (sdRet != MCDRV_SUCCESS) + goto exit; + } + } else if (sAECInfo.sControl.bCommand == 2) { + if (sAECInfo.sControl.bParam[0] == 1) { + McDevIf_AddPacket(MCDRV_PACKET_TYPE_WRITE + | MCDRV_PACKET_REGTYPE_MB + | (UINT32)MCI_LP2_START, + bLP2_START); + McDevIf_AddPacket(MCDRV_PACKET_TYPE_WRITE + | MCDRV_PACKET_REGTYPE_MB + | (UINT32)MCI_SRC3_START, + bSRC3_START); + } + } + + McResCtrl_GetPowerInfo(&sPowerInfo); + sdRet = McPacket_AddPowerDown(&sPowerInfo, &sPowerUpdate); + if (sdRet != MCDRV_SUCCESS) + goto exit; + sdRet = McDevIf_ExecutePacket(); + if (sdRet == MCDRV_SUCCESS) + return sdRet; + +exit: + McResCtrl_ReplaceAecInfo(&sCurAECInfo); + SavePower(); + return sdRet; +} + +/**************************************************************************** + * get_dsp + * + * Description: + * Get DSP parameter. + * Arguments: + * psDspParam pointer to parameter + * pvData pointer to read data buffer + * dSize data buffer size + * Return: + * 0<= Get data size + * MCDRV_ERROR_STATE + * MCDRV_ERROR_ARGUMENT +* + ****************************************************************************/ +static SINT32 get_dsp +( + struct MCDRV_DSP_PARAM *psDspParam, + void *pvData, + UINT32 dSize +) +{ + enum MCDRV_STATE eState = McResCtrl_GetState(); + + if (eMCDRV_STATE_READY != eState) + return MCDRV_ERROR_STATE; + + if (NULL == psDspParam) + return MCDRV_ERROR_ARGUMENT; + + if (NULL == pvData) + return MCDRV_ERROR_ARGUMENT; + + switch (psDspParam->dType) { + case MCDRV_DSP_PARAM_CDSP_INPOS: + return McCdsp_GetDSP(CDSP_INPOS, pvData, dSize); + case MCDRV_DSP_PARAM_CDSP_OUTPOS: + return McCdsp_GetDSP(CDSP_OUTPOS, pvData, dSize); + case MCDRV_DSP_PARAM_CDSP_DFIFO_REMAIN: + return McCdsp_GetDSP(CDSP_DFIFO_REMAIN, pvData, dSize); + case MCDRV_DSP_PARAM_CDSP_RFIFO_REMAIN: + return McCdsp_GetDSP(CDSP_RFIFO_REMAIN, pvData, dSize); + case MCDRV_DSP_PARAM_FDSP_DXRAM: + return McFdsp_GetDSP(FDSP_AE_FW_DXRAM, psDspParam->dInfo, + (UINT8 *)pvData, dSize); + case MCDRV_DSP_PARAM_FDSP_DYRAM: + return McFdsp_GetDSP(FDSP_AE_FW_DYRAM, psDspParam->dInfo, + (UINT8 *)pvData, dSize); + case MCDRV_DSP_PARAM_FDSP_IRAM: + return McFdsp_GetDSP(FDSP_AE_FW_IRAM, psDspParam->dInfo, + (UINT8 *)pvData, dSize); + case MCDRV_DSP_PARAM_EDSP_E2RES: + return McEdsp_GetDSP((UINT8 *)pvData); + default: + return MCDRV_ERROR_ARGUMENT; + } +} + +/**************************************************************************** + * get_dsp_data + * + * Description: + * Get DSP data. + * Arguments: + * pbData pointer to data + * dSize data byte size + * Return: + * 0<= size of got data + * MCDRV_ERROR_STATE + * MCDRV_ERROR_ARGUMENT +* + ****************************************************************************/ +static SINT32 get_dsp_data +( + UINT8 *pbData, + UINT32 dSize +) +{ + enum MCDRV_STATE eState = McResCtrl_GetState(); + + if (eMCDRV_STATE_READY != eState) + return MCDRV_ERROR_STATE; + + if (NULL == pbData) + return MCDRV_ERROR_ARGUMENT; + + return McCdsp_ReadData(pbData, dSize); +} + +/**************************************************************************** + * set_dsp_data + * + * Description: + * Write data to DSP. + * Arguments: + * pbData pointer to data + * dSize data byte size + * Return: + * 0<= size of write data + * MCDRV_ERROR_STATE + * MCDRV_ERROR_ARGUMENT +* + ****************************************************************************/ +static SINT32 set_dsp_data +( + const UINT8 *pbData, + UINT32 dSize +) +{ + enum MCDRV_STATE eState = McResCtrl_GetState(); + + if (eMCDRV_STATE_READY != eState) + return MCDRV_ERROR_STATE; + + if (NULL == pbData) + return MCDRV_ERROR_ARGUMENT; + + return McCdsp_WriteData(pbData, dSize); +} + +/**************************************************************************** + * register_dsp_cb + * + * Description: + * Callback function setting + * Arguments: + * pcbfunc Pointer to Callback function + * Return: + * MCDRV_SUCCESS + * MCDRV_ERROR_STATE + * + ****************************************************************************/ +static SINT32 register_dsp_cb +( + SINT32 (*pcbfunc)(SINT32, UINT32, UINT32) +) +{ + enum MCDRV_STATE eState = McResCtrl_GetState(); + + if (eMCDRV_STATE_READY != eState) + return MCDRV_ERROR_STATE; + + McResCtrl_SetDSPCBFunc(pcbfunc); + return MCDRV_SUCCESS; +} + +/**************************************************************************** + * get_dsp_transition + * + * Description: + * It judges while processing the DSP control + * Arguments: + * dDspType DSP type + * Return: + * 0 has processed + * 1<= processing + * MCDRV_ERROR_STATE + * + ****************************************************************************/ +static SINT32 get_dsp_transition +( + UINT32 dDspType +) +{ + enum MCDRV_STATE eState = McResCtrl_GetState(); + + if (eMCDRV_STATE_READY != eState) + return MCDRV_ERROR_STATE; + + if (dDspType == MCDRV_DSPTYPE_FDSP) { + ; + return McFdsp_GetTransition(); + } else if (dDspType == MCDRV_DSPTYPE_BDSP) { + return McBdsp_GetTransition(); + } + + return MCDRV_ERROR_ARGUMENT; +} + +/**************************************************************************** + * get_hsdet + * + * Description: + * Get Headset Det. + * Arguments: + * psHSDet pointer to MCDRV_HSDET_INFO struct + * psHSDet pointer to MCDRV_HSDET2_INFO struct + * Return: + * MCDRV_SUCCESS + * MCDRV_ERROR_STATE + * MCDRV_ERROR_ARGUMENT +* + ****************************************************************************/ +static SINT32 get_hsdet +( + struct MCDRV_HSDET_INFO *psHSDet, + struct MCDRV_HSDET2_INFO *psHSDet2 +) +{ + enum MCDRV_STATE eState = McResCtrl_GetState(); + + if (eMCDRV_STATE_READY != eState) + return MCDRV_ERROR_STATE; + + if (NULL == psHSDet) + return MCDRV_ERROR_ARGUMENT; + + McResCtrl_GetHSDet(psHSDet, psHSDet2); + psHSDet->bDlyIrqStop = 0; + + return MCDRV_SUCCESS; +} + +/**************************************************************************** + * set_hsdet + * + * Description: + * Set Headset Det. + * Arguments: + * psHSDet pointer to MCDRV_HSDET_INFO struct + * psHSDet pointer to MCDRV_HSDET2_INFO struct + * dUpdateInfo update information + * Return: + * MCDRV_SUCCESS + * MCDRV_ERROR_STATE + * MCDRV_ERROR_ARGUMENT +* + ****************************************************************************/ +static SINT32 set_hsdet +( + const struct MCDRV_HSDET_INFO *psHSDet, + const struct MCDRV_HSDET2_INFO *psHSDet2, + UINT32 dUpdateInfo +) +{ + SINT32 sdRet = MCDRV_SUCCESS; + enum MCDRV_STATE eState = McResCtrl_GetState(); + struct MCDRV_HSDET_INFO sHSDetInfo; + UINT8 bReg; + struct MCDRV_PATH_INFO sCurPathInfo, sTmpPathInfo; + struct MCDRV_HSDET_RES sHSDetRes; + UINT8 bSlaveAddrA; + UINT8 abData[2]; + UINT8 bPlugDetDB; + struct MCDRV_HSDET_INFO sHSDet; + + if (eMCDRV_STATE_READY != eState) + return MCDRV_ERROR_STATE; + + if (NULL == psHSDet) + return MCDRV_ERROR_ARGUMENT; + + sHSDet = *psHSDet; + if (IsValidHSDetParam(&sHSDet, psHSDet2, dUpdateInfo) == 0) { + ; + return MCDRV_ERROR_ARGUMENT; + } + if (McDevProf_GetDevId() == eMCDRV_DEV_ID_80_90H) { + ; + sHSDet.bDetInInv &= 1; + } + + McResCtrl_SetHSDet(&sHSDet, psHSDet2, dUpdateInfo); + McPacket_AddHSDet(); + sdRet = McDevIf_ExecutePacket(); + if (sdRet != MCDRV_SUCCESS) + return sdRet; + + McResCtrl_GetHSDet(&sHSDetInfo, NULL); + if ((sHSDetInfo.bEnPlugDetDb != MCDRV_PLUGDETDB_DISABLE) + || (sHSDetInfo.bEnDlyKeyOff != MCDRV_KEYEN_D_D_D) + || (sHSDetInfo.bEnDlyKeyOn != MCDRV_KEYEN_D_D_D) + || (sHSDetInfo.bEnMicDet != MCDRV_MICDET_DISABLE) + || (sHSDetInfo.bEnKeyOff != MCDRV_KEYEN_D_D_D) + || (sHSDetInfo.bEnKeyOn != MCDRV_KEYEN_D_D_D)) { + bPlugDetDB = McResCtrl_GetPlugDetDB(); + bReg = McResCtrl_GetRegVal( + MCDRV_PACKET_REGTYPE_CD, + MCI_HSDETEN); + if ((bReg&MCB_MKDETEN) == 0) { + McDevIf_AddPacket( + MCDRV_PACKET_TYPE_WRITE + | MCDRV_PACKET_REGTYPE_CD + | (UINT32)MCI_HSDETEN, + (UINT8)(MCB_HSDETEN | sHSDetInfo.bHsDetDbnc)); + + if (((bPlugDetDB&MCB_RPLUGDET_DB) != 0) + && ((sHSDetInfo.bEnDlyKeyOff != MCDRV_KEYEN_D_D_D) + || (sHSDetInfo.bEnDlyKeyOn != MCDRV_KEYEN_D_D_D) + || (sHSDetInfo.bEnMicDet != MCDRV_MICDET_DISABLE) + || (sHSDetInfo.bEnKeyOff != MCDRV_KEYEN_D_D_D) + || (sHSDetInfo.bEnKeyOn != MCDRV_KEYEN_D_D_D))) { + if (IsLDOAOn() != 0) { + McResCtrl_GetPathInfoVirtual( + &sCurPathInfo); + sTmpPathInfo = sCurPathInfo; + sTmpPathInfo.asAdc0[0].dSrcOnOff + = 0x00AAAAAA; + sTmpPathInfo.asAdc0[1].dSrcOnOff + = 0x00AAAAAA; + + sTmpPathInfo.asAdc1[0].dSrcOnOff + = 0x00AAAAAA; + + sTmpPathInfo.asSp[0].dSrcOnOff + = 0x002AAAAA; + sTmpPathInfo.asSp[1].dSrcOnOff + = 0x002AAAAA; + sTmpPathInfo.asHp[0].dSrcOnOff + = 0x002AAAAA; + sTmpPathInfo.asHp[1].dSrcOnOff + = 0x002AAAAA; + sTmpPathInfo.asRc[0].dSrcOnOff + = 0x002AAAAA; + sTmpPathInfo.asLout1[0].dSrcOnOff + = 0x002AAAAA; + sTmpPathInfo.asLout1[1].dSrcOnOff + = 0x002AAAAA; + sTmpPathInfo.asLout2[0].dSrcOnOff + = 0x002AAAAA; + sTmpPathInfo.asLout2[1].dSrcOnOff + = 0x002AAAAA; + + sTmpPathInfo.asBias[0].dSrcOnOff + = 0x002AAAAA; + sTmpPathInfo.asBias[1].dSrcOnOff + = 0x002AAAAA; + sTmpPathInfo.asBias[2].dSrcOnOff + = 0x002AAAAA; + sTmpPathInfo.asBias[3].dSrcOnOff + = 0x002AAAAA; + sdRet = set_path(&sTmpPathInfo); + if (sdRet != MCDRV_SUCCESS) + return sdRet; + McPacket_AddMKDetEnable(1); + sdRet = set_path(&sCurPathInfo); + } else { + McPacket_AddMKDetEnable(1); + } + } + } else { + bReg = (UINT8)(MCB_HSDETEN | sHSDetInfo.bHsDetDbnc); + if ((sHSDetInfo.bEnDlyKeyOff != MCDRV_KEYEN_D_D_D) + || (sHSDetInfo.bEnDlyKeyOn != MCDRV_KEYEN_D_D_D) + || (sHSDetInfo.bEnMicDet != MCDRV_MICDET_DISABLE) + || (sHSDetInfo.bEnKeyOff != MCDRV_KEYEN_D_D_D) + || (sHSDetInfo.bEnKeyOn != MCDRV_KEYEN_D_D_D)) { + if ((bPlugDetDB&MCB_RPLUGDET_DB) != 0) { + ; + bReg |= MCB_MKDETEN; + } + } + + McDevIf_AddPacket( + MCDRV_PACKET_TYPE_WRITE + | MCDRV_PACKET_REGTYPE_CD + | (UINT32)MCI_HSDETEN, + bReg); + + if ((bReg&MCB_MKDETEN) == 0) { + bReg = + McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_ANA, + MCI_KDSET); + bReg &= (UINT8)~(MCB_KDSET2|MCB_KDSET1); + McDevIf_AddPacket( + MCDRV_PACKET_TYPE_FORCE_WRITE + | MCDRV_PACKET_REGTYPE_ANA + | (UINT32)MCI_KDSET, + bReg); + } + } + } + if (sdRet == MCDRV_SUCCESS) + sdRet = McDevIf_ExecutePacket(); + if (sdRet == MCDRV_SUCCESS) { + if (((dUpdateInfo & MCDRV_ENPLUGDETDB_UPDATE_FLAG) != 0) + && ((sHSDetInfo.bEnPlugDetDb & MCDRV_PLUGDETDB_UNDET_ENABLE) + != 0) + && (sHSDetInfo.cbfunc != 0)) { + bSlaveAddrA = + McDevProf_GetSlaveAddr(eMCDRV_SLAVE_ADDR_ANA); +#if 0 + McSrv_Sleep(sHSDetInfo.bHsDetDbnc*1000); + abData[0] = MCI_CD_REG_A<<1; + abData[1] = MCI_PLUGDET_DB; + McSrv_WriteReg(bSlaveAddrA, abData, 2); + bReg = McSrv_ReadReg(bSlaveAddrA, MCI_CD_REG_D); + if ((bReg & MCB_PLUGUNDET_DB) != 0) { +#else + abData[0] = MCI_CD_REG_A<<1; + abData[1] = MCI_PLUGDET; + McSrv_WriteReg(bSlaveAddrA, abData, 2); + bReg = McSrv_ReadReg(bSlaveAddrA, MCI_CD_REG_D); + if ((bReg & MCB_PLUGDET) == 0) { +#endif + McSrv_Unlock(); + sHSDetRes.bKeyCnt0 = 0; + sHSDetRes.bKeyCnt1 = 0; + sHSDetRes.bKeyCnt2 = 0; + (*sHSDetInfo.cbfunc)( + MCDRV_HSDET_EVT_PLUGUNDET_DB_FLAG, + &sHSDetRes); + McSrv_Lock(); + } + } + sdRet = SavePower(); + } + return sdRet; +} + +/**************************************************************************** + * config_gp + * + * Description: + * Set GPIO mode. + * Arguments: + * psGpMode GPIO mode information + * Return: + * MCDRV_SUCCESS + * MCDRV_ERROR_ARGUMENT + * MCDRV_ERROR_STATE +* + ****************************************************************************/ +static SINT32 config_gp +( + const struct MCDRV_GP_MODE *psGpMode +) +{ + enum MCDRV_STATE eState = McResCtrl_GetState(); + + if (NULL == psGpMode) + return MCDRV_ERROR_ARGUMENT; + + if (eMCDRV_STATE_READY != eState) + return MCDRV_ERROR_STATE; + + if (IsValidGpParam(psGpMode) == 0) + return MCDRV_ERROR_ARGUMENT; + + McResCtrl_SetGPMode(psGpMode); + + McPacket_AddGPMode(); + return McDevIf_ExecutePacket(); +} + +/**************************************************************************** + * mask_gp + * + * Description: + * Set GPIO input mask. + * Arguments: + * pbMask mask setting + * dPadNo PAD number + * Return: + * MCDRV_SUCCESS + * MCDRV_ERROR_ARGUMENT + * MCDRV_ERROR_STATE + * MCDRV_ERROR +* + ****************************************************************************/ +static SINT32 mask_gp +( + UINT8 *pbMask, + UINT32 dPadNo +) +{ + enum MCDRV_STATE eState = McResCtrl_GetState(); + struct MCDRV_INIT_INFO sInitInfo; + + if (NULL == pbMask) + return MCDRV_ERROR_ARGUMENT; + + if (eMCDRV_STATE_READY != eState) + return MCDRV_ERROR_STATE; + + if (IsValidMaskGp(*pbMask, dPadNo) == 0) + return MCDRV_ERROR_ARGUMENT; + + McResCtrl_GetInitInfo(&sInitInfo, NULL); + if (((dPadNo == 0) && (sInitInfo.bPa0Func != MCDRV_PA_GPIO)) + || ((dPadNo == 1) && (sInitInfo.bPa1Func != MCDRV_PA_GPIO)) + || ((dPadNo == 2) && (sInitInfo.bPa2Func != MCDRV_PA_GPIO))) + return MCDRV_SUCCESS; + + McResCtrl_SetGPMask(*pbMask, dPadNo); + + McPacket_AddGPMask(dPadNo); + return McDevIf_ExecutePacket(); +} + +/**************************************************************************** + * getset_gp + * + * Description: + * Set or get state of GPIO pin. + * Arguments: + * pbGpio pin state + * dPadNo PAD number + * Return: + * MCDRV_SUCCESS + * MCDRV_ERROR_ARGUMENT +* + ****************************************************************************/ +static SINT32 getset_gp +( + UINT8 *pbGpio, + UINT32 dPadNo +) +{ + UINT8 bSlaveAddr; + UINT8 abData[2]; + UINT8 bRegData; + enum MCDRV_STATE eState = McResCtrl_GetState(); + struct MCDRV_INIT_INFO sInitInfo; + struct MCDRV_GP_MODE sGPMode; + + if (NULL == pbGpio) + return MCDRV_ERROR_ARGUMENT; + + if (eMCDRV_STATE_READY != eState) + return MCDRV_ERROR_STATE; + + McResCtrl_GetInitInfo(&sInitInfo, NULL); + McResCtrl_GetGPMode(&sGPMode); + + if ((dPadNo != MCDRV_GP_PAD0) + && (dPadNo != MCDRV_GP_PAD1) + && (dPadNo != MCDRV_GP_PAD2)) + return MCDRV_ERROR_ARGUMENT; + + if (((dPadNo == MCDRV_GP_PAD0) + && (sInitInfo.bPa0Func != MCDRV_PA_GPIO)) + || ((dPadNo == MCDRV_GP_PAD1) + && (sInitInfo.bPa1Func != MCDRV_PA_GPIO)) + || ((dPadNo == MCDRV_GP_PAD2) + && (sInitInfo.bPa2Func != MCDRV_PA_GPIO))) + return MCDRV_ERROR; + + if (sGPMode.abGpDdr[dPadNo] == MCDRV_GPDDR_IN) { + bSlaveAddr = + McDevProf_GetSlaveAddr(eMCDRV_SLAVE_ADDR_DIG); + abData[0] = MCI_A_REG_A<<1; + abData[1] = (UINT8)(MCI_PA0+dPadNo); + McSrv_WriteReg(bSlaveAddr, abData, 2); + bRegData = McSrv_ReadReg(bSlaveAddr, MCI_A_REG_D); + *pbGpio = (UINT8)((bRegData & MCB_PA0_DATA) >> 4); + } else { + if (sGPMode.abGpHost[dPadNo] != MCDRV_GPHOST_CDSP) { + if ((*pbGpio != MCDRV_GP_LOW) + && (*pbGpio != MCDRV_GP_HIGH)) + return MCDRV_ERROR_ARGUMENT; + + McResCtrl_SetGPPad(*pbGpio, dPadNo); + McPacket_AddGPSet(dPadNo); + return McDevIf_ExecutePacket(); + } + } + + return MCDRV_SUCCESS; +} + +/**************************************************************************** + * irq_proc + * + * Description: + * Clear interrupt flag. + * Arguments: + * none + * Return: + * MCDRV_SUCCESS + * MCDRV_ERROR_STATE + * + ****************************************************************************/ +static SINT32 irq_proc +( + void +) +{ + SINT32 sdRet = MCDRV_SUCCESS; + UINT8 bEIRQ = 0; + UINT8 bSlaveAddrD, bSlaveAddrA; + UINT8 bReg, bSPlugDet, bPlugDet; + struct MCDRV_HSDET_INFO sHSDetInfo; + UINT8 abData[4]; + UINT32 dFlg_DET = 0; + UINT8 bFlg_DLYKEY = 0, + bFlg_KEY = 0; + struct MCDRV_HSDET_RES sHSDetRes; + UINT8 bSENSEFIN; + struct MCDRV_AEC_INFO sAecInfo; + struct MCDRV_PATH_INFO sCurPathInfo; + static UINT8 bOP_DAC; + static UINT8 bHpDet; + UINT32 dCycles, dInterval, dTimeOut; + UINT8 bAP; + + bSlaveAddrD = McDevProf_GetSlaveAddr(eMCDRV_SLAVE_ADDR_DIG); + bSlaveAddrA = McDevProf_GetSlaveAddr(eMCDRV_SLAVE_ADDR_ANA); + + McResCtrl_GetHSDet(&sHSDetInfo, NULL); + + bEIRQ = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_IF, MCI_IRQ); + bReg = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_CD, MCI_EIRQSENSE); + if ((bReg & MCB_EIRQSENSE) == 0) { + McSrv_Lock(); + bAP = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_ANA, MCI_AP); + if ((bAP&MCB_AP_LDOD) != 0) { + ; + machdep_PreLDODStart(); + } + } else {/* Sensing */ + /* Disable */ + bAP = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_ANA, MCI_AP); + if ((bAP&MCB_AP_LDOD) != 0) { + ; + machdep_PreLDODStart(); + } + abData[0] = MCI_IRQR<<1; + abData[1] = 0; + McSrv_WriteReg(bSlaveAddrD, abData, 2); + + abData[0] = MCI_CD_REG_A<<1; + abData[1] = MCI_SSENSEFIN; + McSrv_WriteReg(bSlaveAddrA, abData, 2); + bSENSEFIN = McSrv_ReadReg(bSlaveAddrA, MCI_CD_REG_D); + if ((bSENSEFIN&MCB_SSENSEFIN) != 0) { + abData[1] = MCI_EIRQSENSE; + abData[2] = MCI_CD_REG_D<<1; + abData[3] = 0; + McSrv_WriteReg(bSlaveAddrA, abData, 4); + McResCtrl_SetRegVal(MCDRV_PACKET_REGTYPE_CD, + MCI_EIRQSENSE, 0); + abData[1] = MCI_SSENSEFIN; + abData[3] = bReg; + McSrv_WriteReg(bSlaveAddrA, abData, 4); + } else { + /* Enable */ + abData[0] = MCI_IRQR<<1; + abData[1] = MCB_EIRQR; + McSrv_WriteReg(bSlaveAddrD, abData, 2); + if ((bAP&MCB_AP_LDOD) != 0) { + ; + machdep_PostLDODStart(); + } + return MCDRV_SUCCESS; + } + + /* PLUGDET, PLUGUNDETDB, PLUGDETDB */ + abData[0] = MCI_CD_REG_A<<1; + abData[1] = MCI_PLUGDET; + McSrv_WriteReg(bSlaveAddrA, abData, 2); + dFlg_DET = McSrv_ReadReg(bSlaveAddrA, MCI_CD_REG_D); + /* clear */ + abData[2] = MCI_CD_REG_D<<1; + abData[3] = (UINT8)dFlg_DET; + McSrv_WriteReg(bSlaveAddrA, abData, 4); + + /* set reference */ + abData[1] = MCI_PLUGDET_DB; + McSrv_WriteReg(bSlaveAddrA, abData, 2); + bReg = McSrv_ReadReg(bSlaveAddrA, MCI_CD_REG_D); + McResCtrl_SetPlugDetDB(bReg); + abData[1] = MCI_RPLUGDET; + abData[3] = ((UINT8)dFlg_DET&MCB_PLUGDET) | bReg; + McSrv_WriteReg(bSlaveAddrA, abData, 4); + dFlg_DET = abData[3]; + + abData[1] = MCI_MICDET; + McSrv_WriteReg(bSlaveAddrA, abData, 2); + bReg = McSrv_ReadReg(bSlaveAddrA, MCI_CD_REG_D); + bFlg_KEY = bReg & + (sHSDetInfo.bEnMicDet == MCDRV_MICDET_ENABLE ? + MCB_MICDET : 0); + abData[1] = MCI_RMICDET; + abData[3] = bReg; + McSrv_WriteReg(bSlaveAddrA, abData, 4); + + abData[1] = MCI_SMICDET; + McSrv_WriteReg(bSlaveAddrA, abData, 2); + bReg = McSrv_ReadReg(bSlaveAddrA, MCI_CD_REG_D); + abData[3] = bReg; + McSrv_WriteReg(bSlaveAddrA, abData, 4); + + sHSDetRes.bKeyCnt0 = 0; + sHSDetRes.bKeyCnt1 = 0; + sHSDetRes.bKeyCnt2 = 0; + + abData[0] = MCI_E_REG_A<<1; + abData[1] = MCI_PLUG_REV; + McSrv_WriteReg(bSlaveAddrD, abData, 2); + bReg = McSrv_ReadReg(bSlaveAddrD, MCI_E_REG_D); + sHSDetRes.bPlugRev = bReg>>7; + sHSDetRes.bHpImpClass = bReg&0x07; + abData[1] = MCI_HPIMP_15_8; + McSrv_WriteReg(bSlaveAddrD, abData, 2); + bReg = McSrv_ReadReg(bSlaveAddrD, MCI_E_REG_D); + sHSDetRes.wHpImp = bReg<<8; + abData[1] = MCI_HPIMP_7_0; + McSrv_WriteReg(bSlaveAddrD, abData, 2); + bReg = McSrv_ReadReg(bSlaveAddrD, MCI_E_REG_D); + sHSDetRes.wHpImp |= bReg; + + bReg = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_E, + MCI_LPF_THR); + bReg &= (MCB_OSF1_MN|MCB_OSF0_MN|MCB_OSF1_ENB|MCB_OSF0_ENB); + McResCtrl_GetAecInfo(&sAecInfo); + bReg |= (UINT8)(sAecInfo.sOutput.bLpf_Post_Thru[1]<<7); + bReg |= (UINT8)(sAecInfo.sOutput.bLpf_Post_Thru[0]<<6); + bReg |= (UINT8)(sAecInfo.sOutput.bLpf_Pre_Thru[1]<<5); + bReg |= (UINT8)(sAecInfo.sOutput.bLpf_Pre_Thru[0]<<4); + McDevIf_AddPacket(MCDRV_PACKET_TYPE_WRITE + | MCDRV_PACKET_REGTYPE_E + | (UINT32)MCI_LPF_THR, + bReg); + bReg = (UINT8)(sAecInfo.sOutput.bDcl_OnOff[1]<<7) + | (UINT8)(sAecInfo.sOutput.bDcl_Gain[1]<<4) + | (UINT8)(sAecInfo.sOutput.bDcl_OnOff[0]<<3) + | sAecInfo.sOutput.bDcl_Gain[0]; + McDevIf_AddPacket(MCDRV_PACKET_TYPE_WRITE + | MCDRV_PACKET_REGTYPE_E + | (UINT32)MCI_DCL_GAIN,/*18*/ + bReg); + if (McDevProf_GetDevId() == eMCDRV_DEV_ID_80_90H) { + McDevIf_AddPacket(MCDRV_PACKET_TYPE_WRITE + | MCDRV_PACKET_REGTYPE_ANA + | (UINT32)19, + bOP_DAC); + } + McDevIf_AddPacket(MCDRV_PACKET_TYPE_WRITE + | MCDRV_PACKET_REGTYPE_ANA + | (UINT32)MCI_HPDETVOL, + bHpDet); + bReg = (sAecInfo.sE2.bE2_Da_Sel<<3) + | sAecInfo.sE2.bE2_Ad_Sel; + McDevIf_AddPacket(MCDRV_PACKET_TYPE_WRITE + | MCDRV_PACKET_REGTYPE_E + | (UINT32)MCI_E2_SEL, + bReg); + if (McDevProf_GetDevId() == eMCDRV_DEV_ID_80_90H) { + McDevIf_AddPacket(MCDRV_PACKET_TYPE_FORCE_WRITE + | MCDRV_PACKET_REGTYPE_ANA + | (UINT32)78, + T_CPMODE_IMPSENSE_AFTER); + McDevIf_AddPacket(MCDRV_PACKET_TYPE_FORCE_WRITE + | MCDRV_PACKET_REGTYPE_ANA + | (UINT32)87, + 0); + abData[0] = MCI_ANA_REG_A<<1; + abData[1] = 78; + McSrv_WriteReg(bSlaveAddrA, abData, 2); + bReg = McSrv_ReadReg(bSlaveAddrA, MCI_ANA_REG_D); + } else { + McDevIf_AddPacket(MCDRV_PACKET_TYPE_FORCE_WRITE + | MCDRV_PACKET_REGTYPE_ANA + | (UINT32)87, + 0); + McDevIf_AddPacket(MCDRV_PACKET_TYPE_FORCE_WRITE + | MCDRV_PACKET_REGTYPE_IF + | (UINT32)31, + 0); + McDevIf_AddPacket(MCDRV_PACKET_TYPE_FORCE_WRITE + | MCDRV_PACKET_REGTYPE_IF + | (UINT32)30, + 0); + } + + McResCtrl_GetPathInfoVirtual(&sCurPathInfo); + sdRet = set_path(&sCurPathInfo); + if ((bAP&MCB_AP_LDOD) != 0) { + ; + machdep_PostLDODStart(); + } + McSrv_Unlock(); + if (sHSDetInfo.cbfunc != NULL) { + if ((dFlg_DET & MCB_SPLUGUNDET_DB) != 0) { + ; + dFlg_DET = MCB_PLUGUNDET_DB; + } else { + dFlg_DET |= + MCDRV_HSDET_EVT_SENSEFIN_FLAG; + } + (*sHSDetInfo.cbfunc)(dFlg_DET + |((UINT32)bFlg_KEY<<16), + &sHSDetRes); + } + /* Enable IRQ */ + McSrv_Lock(); + bAP = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_ANA, + MCI_AP); + if ((bAP&MCB_AP_LDOD) != 0) { + ; + machdep_PreLDODStart(); + } + abData[0] = MCI_CD_REG_A<<1; + abData[1] = MCI_IRQHS; + abData[2] = MCI_CD_REG_D<<1; + abData[3] = MCB_EIRQHS; + McSrv_WriteReg(bSlaveAddrA, abData, 4); + McResCtrl_SetRegVal(MCDRV_PACKET_REGTYPE_CD, + MCI_IRQHS, MCB_EIRQHS); + abData[0] = MCI_IRQR<<1; + abData[1] = MCB_EIRQR; + McSrv_WriteReg(bSlaveAddrD, abData, 2); + bReg = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_IF, + MCI_RST_A); + if (bReg == 0) { + abData[0] = MCI_IRQ<<1; + abData[1] = MCB_EIRQ; + McSrv_WriteReg(bSlaveAddrD, abData, 2); + McResCtrl_SetRegVal(MCDRV_PACKET_REGTYPE_IF, + MCI_IRQ, MCB_EIRQ); + } + if ((bAP&MCB_AP_LDOD) != 0) { + ; + machdep_PostLDODStart(); + } + McSrv_Unlock(); + return MCDRV_SUCCESS; + } + + if (eMCDRV_STATE_READY != McResCtrl_GetState()) { + sdRet = MCDRV_ERROR_STATE; + goto exit; + } + + if ((bEIRQ&MCB_EIRQ) != 0) { + bReg = McSrv_ReadReg(bSlaveAddrD, MCI_EDSP); + if (bReg != 0) { + /* Disable IRQ */ + McDevIf_AddPacket(MCDRV_PACKET_TYPE_FORCE_WRITE + | MCDRV_PACKET_REGTYPE_IF + | (UINT32)MCI_EEDSP, + 0); + sdRet = McDevIf_ExecutePacket(); + if (sdRet != MCDRV_SUCCESS) + goto exit; + + if ((bReg & MCB_E2DSP_STA) != 0) { + ; + McEdsp_IrqProc(); + } + /* Clear IRQ */ + McDevIf_AddPacket(MCDRV_PACKET_TYPE_FORCE_WRITE + | MCDRV_PACKET_REGTYPE_IF + | (UINT32)MCI_EDSP, + bReg); + /* Enable IRQ */ + McDevIf_AddPacket(MCDRV_PACKET_TYPE_FORCE_WRITE + | MCDRV_PACKET_REGTYPE_IF + | (UINT32)MCI_EEDSP, + MCB_EE2DSP); + } + + bReg = McSrv_ReadReg(bSlaveAddrD, MCI_CDSP); + if (bReg != 0) { + /* Disable IRQ */ + McDevIf_AddPacket(MCDRV_PACKET_TYPE_FORCE_WRITE + | MCDRV_PACKET_REGTYPE_IF + | (UINT32)MCI_ECDSP, + 0); + sdRet = McDevIf_ExecutePacket(); + if (sdRet != MCDRV_SUCCESS) + goto exit; + McCdsp_IrqProc(); + /* Clear IRQ */ + McDevIf_AddPacket(MCDRV_PACKET_TYPE_FORCE_WRITE + | MCDRV_PACKET_REGTYPE_IF + | (UINT32)MCI_CDSP, + bReg); + /* Enable IRQ */ + bReg = MCB_ECDSP + | MCB_EFFIFO + | MCB_ERFIFO + | MCB_EEFIFO + | MCB_EOFIFO + | MCB_EDFIFO + | MCB_EENC + | MCB_EDEC; + McDevIf_AddPacket(MCDRV_PACKET_TYPE_FORCE_WRITE + | MCDRV_PACKET_REGTYPE_IF + | (UINT32)MCI_ECDSP, + bReg); + } + + bReg = McSrv_ReadReg(bSlaveAddrD, MCI_IRSERR); + if (bReg != 0) { + /* Disable IRQ */ + McDevIf_AddPacket(MCDRV_PACKET_TYPE_FORCE_WRITE + | MCDRV_PACKET_REGTYPE_IF + | (UINT32)MCI_IESERR, + 0); + sdRet = McDevIf_ExecutePacket(); + if (sdRet != MCDRV_SUCCESS) + goto exit; + McFdsp_IrqProc(); + /* Clear IRQ */ + McDevIf_AddPacket(MCDRV_PACKET_TYPE_FORCE_WRITE + | MCDRV_PACKET_REGTYPE_IF + | (UINT32)MCI_IRSERR, + bReg); + /* Enable IRQ */ + bReg = MCB_IESERR + | MCB_IEAMTBEG + | MCB_IEAMTEND + | MCB_IEFW; + McDevIf_AddPacket(MCDRV_PACKET_TYPE_FORCE_WRITE + | MCDRV_PACKET_REGTYPE_IF + | (UINT32)MCI_IESERR, + bReg); + } + sdRet = McDevIf_ExecutePacket(); + if (sdRet != MCDRV_SUCCESS) + goto exit; + } + + abData[0] = MCI_CD_REG_A<<1; + abData[1] = MCI_IRQHS; + McSrv_WriteReg(bSlaveAddrA, abData, 2); + bReg = McSrv_ReadReg(bSlaveAddrA, MCI_CD_REG_D); + if (bReg == (MCB_EIRQHS|MCB_IRQHS)) { + /* Disable EIRQHS */ + abData[2] = MCI_CD_REG_D<<1; + abData[3] = 0; + McSrv_WriteReg(bSlaveAddrA, abData, 4); + McResCtrl_SetRegVal(MCDRV_PACKET_REGTYPE_CD, + MCI_IRQHS, 0); + + /* PLUGDET, SPLUGUNDETDB, SPLUGDETDB */ + abData[1] = MCI_PLUGDET;/*10*/ + McSrv_WriteReg(bSlaveAddrA, abData, 2); + bSPlugDet = McSrv_ReadReg(bSlaveAddrA, MCI_CD_REG_D); + dFlg_DET = (bSPlugDet&MCB_PLUGDET); + + abData[1] = MCI_PLUGDET_DB; + McSrv_WriteReg(bSlaveAddrA, abData, 2); + bPlugDet = McSrv_ReadReg(bSlaveAddrA, MCI_CD_REG_D); + dFlg_DET |= bPlugDet; + + if ((dFlg_DET&MCB_PLUGUNDET_DB) != 0) { + ; + McResCtrl_SetPlugDetDB(0); + } + if ((sHSDetInfo.bEnPlugDetDb & MCDRV_PLUGDETDB_DET_ENABLE) != 0 + ) { + if (McDevProf_GetDevId() != eMCDRV_DEV_ID_80_90H) { + abData[1] = MCI_RPLUGDET; + McSrv_WriteReg(bSlaveAddrA, abData, 2); + bReg = (UINT8)~McSrv_ReadReg(bSlaveAddrA, + MCI_CD_REG_D); + bReg &= bPlugDet; + } else { + bReg = bSPlugDet; + } + if ((bReg & MCB_SPLUGDET_DB) != 0) { + McResCtrl_SetPlugDetDB(bReg); + if (McDevProf_GetDevId() != + eMCDRV_DEV_ID_81_92H) { + bReg = McResCtrl_GetRegVal( + MCDRV_PACKET_REGTYPE_ANA, + MCI_AP); + bReg &= (UINT8)~MCB_AP_BGR; + McDevIf_AddPacket( + MCDRV_PACKET_TYPE_WRITE + | MCDRV_PACKET_REGTYPE_ANA + | (UINT32)MCI_AP, + bReg); + } + bReg = McResCtrl_GetRegVal( + MCDRV_PACKET_REGTYPE_ANA, + MCI_HIZ); + bReg |= (MCB_HPR_HIZ|MCB_HPL_HIZ); + McDevIf_AddPacket(MCDRV_PACKET_TYPE_WRITE + | MCDRV_PACKET_REGTYPE_ANA + | (UINT32)MCI_HIZ, + bReg); + McResCtrl_GetPathInfoVirtual(&sCurPathInfo); + sCurPathInfo.asBias[3].dSrcOnOff |= + MCDRV_ASRC_MIC4_ON; + sdRet = set_path(&sCurPathInfo); + if (sdRet != MCDRV_SUCCESS) { + /* Enable IRQ */ + abData[1] = MCI_IRQHS; + abData[3] = MCB_EIRQHS; + McSrv_WriteReg(bSlaveAddrA, abData, 4); + McResCtrl_SetRegVal( + MCDRV_PACKET_REGTYPE_CD, + MCI_IRQHS, MCB_EIRQHS); + goto exit; + } + if ((sHSDetInfo.bEnDlyKeyOff != + MCDRV_KEYEN_D_D_D) + || (sHSDetInfo.bEnDlyKeyOn != + MCDRV_KEYEN_D_D_D) + || (sHSDetInfo.bEnMicDet != + MCDRV_MICDET_DISABLE) + || (sHSDetInfo.bEnKeyOff != + MCDRV_KEYEN_D_D_D) + || (sHSDetInfo.bEnKeyOn != + MCDRV_KEYEN_D_D_D)) { + ; + McPacket_AddMKDetEnable(0); + } + sdRet = McDevIf_ExecutePacket(); + if (sdRet != MCDRV_SUCCESS) { + /* Enable IRQ */ + abData[1] = MCI_IRQHS; + abData[3] = MCB_EIRQHS; + McSrv_WriteReg(bSlaveAddrA, abData, 4); + McResCtrl_SetRegVal( + MCDRV_PACKET_REGTYPE_CD, + MCI_IRQHS, MCB_EIRQHS); + goto exit; + } + if (sHSDetInfo.bSgnlNum != MCDRV_SGNLNUM_NONE + ) { + bHpDet = McResCtrl_GetRegVal( + MCDRV_PACKET_REGTYPE_ANA, + MCI_HPDETVOL); + sdRet = BeginImpSense(&bOP_DAC); + if (sdRet == MCDRV_SUCCESS) { + if ((bAP&MCB_AP_LDOD) != 0) { + ; + machdep_PostLDODStart(); + } + return sdRet; + } else { + /* Enable IRQ */ + abData[1] = MCI_IRQHS; + abData[3] = MCB_EIRQHS; + McSrv_WriteReg(bSlaveAddrA, + abData, 4); + McResCtrl_SetRegVal( + MCDRV_PACKET_REGTYPE_CD, + MCI_IRQHS, MCB_EIRQHS); + goto exit; + } + } + } + } + + /* clear */ + abData[1] = MCI_PLUGDET;/*10*/ + abData[3] = bSPlugDet; + McSrv_WriteReg(bSlaveAddrA, abData, 4); + + /* set reference */ + abData[1] = MCI_RPLUGDET; + abData[3] = (UINT8)dFlg_DET; + McSrv_WriteReg(bSlaveAddrA, abData, 4); + + /* DLYKEYON, DLYKEYOFF */ + abData[1] = MCI_SDLYKEY; + McSrv_WriteReg(bSlaveAddrA, abData, 2); + bReg = McSrv_ReadReg(bSlaveAddrA, MCI_CD_REG_D); + bFlg_DLYKEY = bReg; + /* clear */ + abData[1] = MCI_SDLYKEY; + abData[3] = bReg; + McSrv_WriteReg(bSlaveAddrA, abData, 4); + + /* MICDET, KEYON, KEYOFF */ + abData[1] = MCI_SMICDET; + McSrv_WriteReg(bSlaveAddrA, abData, 2); + bReg = McSrv_ReadReg(bSlaveAddrA, MCI_CD_REG_D); + bFlg_KEY = bReg & (UINT8)~MCB_SMICDET; + /* clear */ + abData[1] = MCI_SMICDET; + abData[3] = bReg; + McSrv_WriteReg(bSlaveAddrA, abData, 4); + + /* set reference */ + abData[1] = MCI_MICDET; + McSrv_WriteReg(bSlaveAddrA, abData, 2); + if (sHSDetInfo.bSgnlNum == MCDRV_SGNLNUM_NONE) { + if ((dFlg_DET & MCB_PLUGDET_DB) != 0) { + dCycles = 0; + switch (sHSDetInfo.bSperiod) { + default: + case MCDRV_SPERIOD_244: + dInterval = 244; + break; + case MCDRV_SPERIOD_488: + dInterval = 488; + break; + case MCDRV_SPERIOD_977: + dInterval = 977; + break; + case MCDRV_SPERIOD_1953: + dInterval = 1953; + break; + case MCDRV_SPERIOD_3906: + dInterval = 3906; + break; + case MCDRV_SPERIOD_7813: + dInterval = 7813; + break; + case MCDRV_SPERIOD_15625: + dInterval = 15625; + break; + case MCDRV_SPERIOD_31250: + dInterval = 31250; + break; + } + switch (sHSDetInfo.bDbncNumMic) { + default: + case MCDRV_DBNC_NUM_2: + dTimeOut = 1; + break; + case MCDRV_DBNC_NUM_3: + dTimeOut = 4; + break; + case MCDRV_DBNC_NUM_4: + dTimeOut = 5; + break; + case MCDRV_DBNC_NUM_7: + dTimeOut = 8; + break; + } + + while (dCycles < dTimeOut) { + bReg = McSrv_ReadReg(bSlaveAddrA, + MCI_CD_REG_D); + if ((bReg & (MCB_MICDET|0x07)) != 0) { + ; + break; + } + McSrv_Sleep(dInterval); + dCycles++; + } + } + } else { + bReg = McSrv_ReadReg(bSlaveAddrA, MCI_CD_REG_D); + } + bFlg_KEY |= bReg & + (sHSDetInfo.bEnMicDet == MCDRV_MICDET_ENABLE ? + MCB_MICDET : 0); + abData[1] = MCI_RMICDET; + abData[3] = bReg; + McSrv_WriteReg(bSlaveAddrA, abData, 4); + + if (sHSDetInfo.cbfunc != NULL) { + /* KeyCnt0 */ + abData[1] = MCI_KEYCNTCLR0; + McSrv_WriteReg(bSlaveAddrA, abData, 2); + sHSDetRes.bKeyCnt0 = McSrv_ReadReg(bSlaveAddrA, + MCI_CD_REG_D); + abData[1] = MCI_KEYCNTCLR0; + abData[3] = MCB_KEYCNTCLR0; + McSrv_WriteReg(bSlaveAddrA, abData, 4); + + /* KeyCnt1 */ + abData[1] = MCI_KEYCNTCLR1; + McSrv_WriteReg(bSlaveAddrA, abData, 2); + sHSDetRes.bKeyCnt1 = McSrv_ReadReg(bSlaveAddrA, + MCI_CD_REG_D); + abData[1] = MCI_KEYCNTCLR1; + abData[3] = MCB_KEYCNTCLR1; + McSrv_WriteReg(bSlaveAddrA, abData, 4); + + /* KeyCnt2 */ + abData[1] = MCI_KEYCNTCLR2; + McSrv_WriteReg(bSlaveAddrA, abData, 2); + sHSDetRes.bKeyCnt2 = McSrv_ReadReg(bSlaveAddrA, + MCI_CD_REG_D); + abData[1] = MCI_KEYCNTCLR2; + abData[3] = MCB_KEYCNTCLR2; + McSrv_WriteReg(bSlaveAddrA, abData, 4); + + abData[0] = MCI_IRQ<<1; + abData[1] = 0; + McSrv_WriteReg(bSlaveAddrD, abData, 2); + McResCtrl_SetRegVal(MCDRV_PACKET_REGTYPE_IF, MCI_IRQ, + 0); + abData[0] = MCI_IRQR<<1; + abData[1] = 0; + McSrv_WriteReg(bSlaveAddrD, abData, 2); + if ((bAP&MCB_AP_LDOD) != 0) { + ; + machdep_PostLDODStart(); + } + McSrv_Unlock(); + (*sHSDetInfo.cbfunc)( + dFlg_DET + |((UINT32)bFlg_DLYKEY<<8) + |((UINT32)bFlg_KEY<<16), + &sHSDetRes); + McSrv_Lock(); + bAP = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_ANA, + MCI_AP); + if ((bAP&MCB_AP_LDOD) != 0) { + ; + machdep_PreLDODStart(); + } + abData[0] = MCI_IRQR<<1; + abData[1] = MCB_EIRQR; + McSrv_WriteReg(bSlaveAddrD, abData, 2); + } + /* Enable IRQ */ + abData[0] = MCI_CD_REG_A<<1; + abData[1] = MCI_IRQHS; + abData[2] = MCI_CD_REG_D<<1; + abData[3] = MCB_EIRQHS; + McSrv_WriteReg(bSlaveAddrA, abData, 4); + McResCtrl_SetRegVal(MCDRV_PACKET_REGTYPE_CD, + MCI_IRQHS, MCB_EIRQHS); + } + +exit: + bReg = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_IF, MCI_RST_A); + if (bReg == 0) { + bReg = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_IF, + MCI_IRQ); + if (bReg != MCB_EIRQ) { + abData[0] = MCI_IRQ<<1; + abData[1] = MCB_EIRQ; + McSrv_WriteReg(bSlaveAddrD, abData, 2); + McResCtrl_SetRegVal(MCDRV_PACKET_REGTYPE_IF, MCI_IRQ, + MCB_EIRQ); + } + } + + if ((bAP&MCB_AP_LDOD) != 0) { + ; + machdep_PostLDODStart(); + } + McSrv_Unlock(); + return sdRet; +} + +#ifndef MCDRV_SKIP_IMPSENSE +/**************************************************************************** + * BeginImpSense + * + * Description: + * Begin Imp Sensing. + * Arguments: + * none + * Return: + * MCDRV_SUCCESS + * MCDRV_ERROR_RESOURCEOVER + * MCDRV_ERROR_TIMEOUT + * + ****************************************************************************/ +static SINT32 BeginImpSense +( + UINT8 *bOP_DAC +) +{ + SINT32 sdRet = MCDRV_SUCCESS; + UINT8 bReg; + struct MCDRV_POWER_INFO sPowerInfo; + struct MCDRV_POWER_UPDATE sPowerUpdate; + struct MCDRV_HSDET_INFO sHSDetInfo; + struct MCDRV_INIT_INFO sInitInfo; + struct MCDRV_INIT2_INFO sInit2Info; + UINT8 bSlaveAddrA; + UINT8 abData[2]; + +#if (MCDRV_DEBUG_LEVEL >= 4) + McDebugLog_FuncIn("BeginImpSense"); +#endif + + bSlaveAddrA = McDevProf_GetSlaveAddr(eMCDRV_SLAVE_ADDR_ANA); + McResCtrl_GetCurPowerInfo(&sPowerInfo); + sPowerInfo.bDigital &= ~(MCDRV_POWINFO_D_PM_CLK_PD + |MCDRV_POWINFO_D_PE_CLK_PD + |MCDRV_POWINFO_D_PLL_PD); + sPowerInfo.abAnalog[0] &= + (UINT8)~(MCB_AP_LDOA|MCB_AP_LDOD|MCB_AP_BGR|MCB_AP_VR); + + /* power up */ + sPowerUpdate.bDigital = MCDRV_POWUPDATE_D_ALL; + sPowerUpdate.abAnalog[0] = (UINT8)MCDRV_POWUPDATE_AP; + sPowerUpdate.abAnalog[1] = 0; + sPowerUpdate.abAnalog[2] = 0; + sPowerUpdate.abAnalog[3] = 0; + sPowerUpdate.abAnalog[4] = 0; + sdRet = McPacket_AddPowerUp(&sPowerInfo, &sPowerUpdate); + if (sdRet != MCDRV_SUCCESS) + goto exit; + sdRet = McDevIf_ExecutePacket(); + if (sdRet != MCDRV_SUCCESS) + goto exit; + + McDevIf_AddPacket(MCDRV_PACKET_TYPE_FORCE_WRITE + | MCDRV_PACKET_REGTYPE_IF + | (UINT32)MCI_IRQ, + 0); + McDevIf_AddPacket(MCDRV_PACKET_TYPE_FORCE_WRITE + | MCDRV_PACKET_REGTYPE_CD + | (UINT32)MCI_IRQHS, + 0); + + McDevIf_AddPacket((MCDRV_PACKET_TYPE_WRITE + | MCDRV_PACKET_REGTYPE_E + | (UINT32)MCI_E1DSP_CTRL), + (UINT8)0x00); + + McPacket_AddDac0Mute(); + McDevIf_AddPacket((MCDRV_PACKET_TYPE_WRITE + | MCDRV_PACKET_REGTYPE_MA + | (UINT32)MCI_DAO0_VOL0), + MCDRV_REG_MUTE); + McDevIf_AddPacket((MCDRV_PACKET_TYPE_WRITE + | MCDRV_PACKET_REGTYPE_MA + | (UINT32)MCI_DAO0_VOL1), + MCDRV_REG_MUTE); + + bReg = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_E, + MCI_LPF_THR); + bReg |= (MCB_OSF0_ENB|MCB_LPF0_PST_THR|MCB_LPF0_PRE_THR); + McDevIf_AddPacket(MCDRV_PACKET_TYPE_WRITE + | MCDRV_PACKET_REGTYPE_E + | (UINT32)MCI_LPF_THR, + bReg); + + bReg = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_CD, MCI_DP); + if (McDevProf_GetDevId() == eMCDRV_DEV_ID_80_90H) { + bReg &= (UINT8)~(MCB_DP_ADC|MCB_DP_DAC0| + MCB_DP_PDMCK|MCB_DP_PDMADC|MCB_DP_PDMDAC); + } else { + bReg &= (UINT8)~(MCB_DP_ADC|MCB_DP_DAC1|MCB_DP_DAC0| + MCB_DP_PDMCK|MCB_DP_PDMADC|MCB_DP_PDMDAC); + } + McDevIf_AddPacket(MCDRV_PACKET_TYPE_WRITE + | MCDRV_PACKET_REGTYPE_CD + | (UINT32)MCI_DP, + bReg); + + bReg = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_E, + MCI_DCL_GAIN); + bReg |= MCB_DCL0_OFF; + McDevIf_AddPacket(MCDRV_PACKET_TYPE_WRITE + | MCDRV_PACKET_REGTYPE_E + | (UINT32)MCI_DCL_GAIN, + bReg); + + if (McDevProf_GetDevId() == eMCDRV_DEV_ID_80_90H) { + bReg = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_E, + MCI_DSF0_FLT_TYPE); + bReg |= MCB_DSF0ENB; + McDevIf_AddPacket(MCDRV_PACKET_TYPE_WRITE + | MCDRV_PACKET_REGTYPE_E + | (UINT32)MCI_DSF0_FLT_TYPE, + bReg); + } else { + bReg = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_E, + MCI_DSF2_FLT_TYPE); + bReg |= MCB_DSF2ENB; + McDevIf_AddPacket(MCDRV_PACKET_TYPE_WRITE + | MCDRV_PACKET_REGTYPE_E + | (UINT32)MCI_DSF2_FLT_TYPE, + bReg); + } + + McResCtrl_GetHSDet(&sHSDetInfo, NULL); + bReg = (sHSDetInfo.bSgnlPeak<<4) + | (sHSDetInfo.bSgnlNum<<2) + | sHSDetInfo.bSgnlPeriod; + McDevIf_AddPacket(MCDRV_PACKET_TYPE_WRITE + | MCDRV_PACKET_REGTYPE_E + | (UINT32)MCI_IMPSEL, + bReg); + + bReg = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_E, MCI_E2_SEL); + bReg &= (UINT8)~0x0C; + McDevIf_AddPacket(MCDRV_PACKET_TYPE_WRITE + | MCDRV_PACKET_REGTYPE_E + | (UINT32)MCI_E2_SEL, + 0); + + McDevIf_AddPacket(MCDRV_PACKET_TYPE_WRITE + | MCDRV_PACKET_REGTYPE_IF + | (UINT32)MCI_IRQR, + MCB_EIRQR); + + McDevIf_AddPacket(MCDRV_PACKET_TYPE_WRITE + | MCDRV_PACKET_REGTYPE_CD + | (UINT32)MCI_EIRQSENSE, + MCB_EIRQSENSE); + + if (McDevProf_GetDevId() == eMCDRV_DEV_ID_80_90H) { + *bOP_DAC = McResCtrl_GetRegVal( + MCDRV_PACKET_REGTYPE_ANA, 19); + McDevIf_AddPacket(MCDRV_PACKET_TYPE_WRITE + | MCDRV_PACKET_REGTYPE_ANA + | (UINT32)19, + 0); + } + + McResCtrl_GetInitInfo(&sInitInfo, &sInit2Info); + if (McDevProf_GetDevId() == eMCDRV_DEV_ID_80_90H) { + ; + McDevIf_AddPacket(MCDRV_PACKET_TYPE_WRITE + | MCDRV_PACKET_REGTYPE_ANA + | (UINT32)MCI_HPDETVOL, + 0x70); + } else if (McDevProf_GetDevId() == eMCDRV_DEV_ID_81_91H) { + McDevIf_AddPacket(MCDRV_PACKET_TYPE_WRITE + | MCDRV_PACKET_REGTYPE_ANA + | (UINT32)MCI_HPDETVOL, + 0x6B); + } else { + McDevIf_AddPacket(MCDRV_PACKET_TYPE_WRITE + | MCDRV_PACKET_REGTYPE_ANA + | (UINT32)MCI_HPDETVOL, + sInit2Info.bOption[9]); + } + + if (McDevProf_GetDevId() == eMCDRV_DEV_ID_80_90H) { + McDevIf_AddPacket(MCDRV_PACKET_TYPE_FORCE_WRITE + | MCDRV_PACKET_REGTYPE_ANA + | (UINT32)78, + T_CPMODE_IMPSENSE_BEFORE); + McDevIf_AddPacket(MCDRV_PACKET_TYPE_FORCE_WRITE + | MCDRV_PACKET_REGTYPE_ANA + | (UINT32)87, + 0x11); + } else { + McDevIf_AddPacket(MCDRV_PACKET_TYPE_FORCE_WRITE + | MCDRV_PACKET_REGTYPE_IF + | (UINT32)31, + 0xB5); + McDevIf_AddPacket(MCDRV_PACKET_TYPE_FORCE_WRITE + | MCDRV_PACKET_REGTYPE_IF + | (UINT32)30, + 0xD6); + + McDevIf_AddPacket(MCDRV_PACKET_TYPE_FORCE_WRITE + | MCDRV_PACKET_REGTYPE_ANA + | (UINT32)87, + sInit2Info.bOption[10]); + } + sdRet = McDevIf_ExecutePacket(); + if (sdRet != MCDRV_SUCCESS) + goto exit; + if (McDevProf_GetDevId() == eMCDRV_DEV_ID_80_90H) { + abData[0] = MCI_ANA_REG_A<<1; + abData[1] = 78; + McSrv_WriteReg(bSlaveAddrA, abData, 2); + bReg = McSrv_ReadReg(bSlaveAddrA, MCI_ANA_REG_D); + if (bReg != T_CPMODE_IMPSENSE_BEFORE) { + sdRet = MCDRV_ERROR; + goto exit; + } + } + + bReg = E1COMMAND_IMP_SENSE; + if (sInitInfo.bGndDet == MCDRV_GNDDET_ON) + bReg |= E1COMMAND_GND_DET; + if ((McResCtrl_IsASrcUsed(MCDRV_ASRC_DAC1_L_ON) != 0) + || (McResCtrl_IsASrcUsed(MCDRV_ASRC_DAC1_R_ON) != 0) + || (McResCtrl_IsD2SrcUsed(MCDRV_D2SRC_ADC0_L_ON) != 0) + || (McResCtrl_IsD2SrcUsed(MCDRV_D2SRC_ADC0_R_ON) != 0) + || (McResCtrl_IsD2SrcUsed(MCDRV_D2SRC_ADC1_ON) != 0) + || (McResCtrl_IsD2SrcUsed(MCDRV_D2SRC_PDM0_L_ON) != 0) + || (McResCtrl_IsD2SrcUsed(MCDRV_D2SRC_PDM0_R_ON) != 0) + || (McResCtrl_IsD2SrcUsed(MCDRV_D2SRC_PDM1_L_ON) != 0) + || (McResCtrl_IsD2SrcUsed(MCDRV_D2SRC_PDM1_R_ON) != 0)) + bReg |= E1COMMAND_ADDITIONAL; + else if ((McResCtrl_IsASrcUsed(MCDRV_ASRC_DAC0_L_ON) != 0) + || (McResCtrl_IsASrcUsed(MCDRV_ASRC_DAC0_R_ON) != 0)) + bReg |= (E1COMMAND_ADDITIONAL|E1COMMAND_PD); + + if (McDevProf_GetDevId() == eMCDRV_DEV_ID_80_90H) { + McDevIf_AddPacket(MCDRV_PACKET_TYPE_TIMWAIT + | MCDRV_DAC_MUTE_WAIT_TIME, + 0); + } else { + bReg |= E1COMMAND_WAIT; + } + McDevIf_AddPacket(MCDRV_PACKET_TYPE_FORCE_WRITE + | MCDRV_PACKET_REGTYPE_E + | (UINT32)MCI_E1COMMAND, + bReg); + + sdRet = McDevIf_ExecutePacket(); + +exit: +#if (MCDRV_DEBUG_LEVEL >= 4) + McDebugLog_FuncOut("BeginImpSense", &sdRet); +#endif + return sdRet; +} +#endif + +/**************************************************************************** + * IsLDOAOn + * + * Description: + * Is LDOA used. + * Arguments: + * none + * Return: + * 0:unused, 1:used + * + ****************************************************************************/ +static UINT8 IsLDOAOn +( + void +) +{ + UINT8 bRet = 0; + +#if (MCDRV_DEBUG_LEVEL >= 4) + SINT32 sdRet; + McDebugLog_FuncIn("IsLDOAOn"); +#endif + if ((McResCtrl_HasSrc(eMCDRV_DST_ADC0, eMCDRV_DST_CH0) != 0) + || (McResCtrl_HasSrc(eMCDRV_DST_ADC0, eMCDRV_DST_CH1) != 0) + || (McResCtrl_HasSrc(eMCDRV_DST_ADC1, eMCDRV_DST_CH0) != 0) + || (McResCtrl_HasSrc(eMCDRV_DST_BIAS, eMCDRV_DST_CH0) != 0) + || (McResCtrl_HasSrc(eMCDRV_DST_BIAS, eMCDRV_DST_CH1) != 0) + || (McResCtrl_HasSrc(eMCDRV_DST_BIAS, eMCDRV_DST_CH2) != 0) + || (McResCtrl_HasSrc(eMCDRV_DST_BIAS, eMCDRV_DST_CH3) != 0) + || (McResCtrl_IsASrcUsed(MCDRV_ASRC_DAC0_L_ON) != 0) + || (McResCtrl_IsASrcUsed(MCDRV_ASRC_DAC0_R_ON) != 0) + || (McResCtrl_IsASrcUsed(MCDRV_ASRC_DAC1_L_ON) != 0) + || (McResCtrl_IsASrcUsed(MCDRV_ASRC_DAC1_R_ON) != 0)) + bRet = 1; + +#if (MCDRV_DEBUG_LEVEL >= 4) + sdRet = bRet; + McDebugLog_FuncOut("IsLDOAOn", &sdRet); +#endif + return bRet; +} + +/**************************************************************************** + * IsValidInitParam + * + * Description: + * check init parameters. + * Arguments: + * psInitInfo initialize information + * psInit2Info initialize information + * Return: + * 0:Invalid + * othre:Valid + * + ****************************************************************************/ +static UINT8 IsValidInitParam +( + const struct MCDRV_INIT_INFO *psInitInfo, + const struct MCDRV_INIT2_INFO *psInit2Info +) +{ + UINT8 bRet = 1; + +#if (MCDRV_DEBUG_LEVEL >= 4) + SINT32 sdRet; + McDebugLog_FuncIn("IsValidInitParam"); +#endif + + + if ((MCDRV_CKSEL_CMOS_CMOS != psInitInfo->bCkSel) + && (MCDRV_CKSEL_TCXO_TCXO != psInitInfo->bCkSel) + && (MCDRV_CKSEL_CMOS_TCXO != psInitInfo->bCkSel) + && (MCDRV_CKSEL_TCXO_CMOS != psInitInfo->bCkSel)) + bRet = 0; + + if ((MCDRV_CKINPUT_CLKI0_CLKI1 != psInitInfo->bCkInput) + && (MCDRV_CKINPUT_CLKI0_RTCK != psInitInfo->bCkInput) + && (MCDRV_CKINPUT_CLKI0_SBCK != psInitInfo->bCkInput) + && (MCDRV_CKINPUT_CLKI1_CLKI0 != psInitInfo->bCkInput) + && (MCDRV_CKINPUT_CLKI1_RTCK != psInitInfo->bCkInput) + && (MCDRV_CKINPUT_CLKI1_SBCK != psInitInfo->bCkInput) + && (MCDRV_CKINPUT_RTC_CLKI0 != psInitInfo->bCkInput) + && (MCDRV_CKINPUT_RTC_CLKI1 != psInitInfo->bCkInput) + && (MCDRV_CKINPUT_RTC_SBCK != psInitInfo->bCkInput) + && (MCDRV_CKINPUT_SBCK_CLKI0 != psInitInfo->bCkInput) + && (MCDRV_CKINPUT_SBCK_CLKI1 != psInitInfo->bCkInput) + && (MCDRV_CKINPUT_SBCK_RTC != psInitInfo->bCkInput) + && (MCDRV_CKINPUT_CLKI0_CLKI0 != psInitInfo->bCkInput) + && (MCDRV_CKINPUT_CLKI1_CLKI1 != psInitInfo->bCkInput) + && (MCDRV_CKINPUT_RTC_RTC != psInitInfo->bCkInput) + && (MCDRV_CKINPUT_SBCK_SBCK != psInitInfo->bCkInput)) + bRet = 0; + + if (psInitInfo->bPllModeA > 7) + bRet = 0; + + if (psInitInfo->bPllPrevDivA > 0x3F) + bRet = 0; + + if (psInitInfo->wPllFbDivA > 0x3FFF) + bRet = 0; + + if ((psInitInfo->bPllFreqA != MCDRV_PLLFREQ_73) + && (psInitInfo->bPllFreqA != MCDRV_PLLFREQ_147)) + bRet = 0; + + if (psInitInfo->bPllModeB > 7) + bRet = 0; + + if (psInitInfo->bPllPrevDivB > 0x3F) + bRet = 0; + + if (psInitInfo->wPllFbDivB > 0x3FFF) + bRet = 0; + + if ((psInitInfo->bPllFreqB != MCDRV_PLLFREQ_73) + && (psInitInfo->bPllFreqB != MCDRV_PLLFREQ_147)) + bRet = 0; + + if ((psInitInfo->bHsdetClk != MCDRV_HSDETCLK_RTC) + && (psInitInfo->bHsdetClk != MCDRV_HSDETCLK_OSC)) + bRet = 0; + + if (((MCDRV_DAHIZ_LOW != psInitInfo->bDio0SdoHiz) + && (MCDRV_DAHIZ_HIZ != psInitInfo->bDio0SdoHiz)) + || ((MCDRV_DAHIZ_LOW != psInitInfo->bDio1SdoHiz) + && (MCDRV_DAHIZ_HIZ != psInitInfo->bDio1SdoHiz)) + || ((MCDRV_DAHIZ_LOW != psInitInfo->bDio2SdoHiz) + && (MCDRV_DAHIZ_HIZ != psInitInfo->bDio2SdoHiz))) + bRet = 0; + + if (((MCDRV_DAHIZ_LOW != psInitInfo->bDio0ClkHiz) + && (MCDRV_DAHIZ_HIZ != psInitInfo->bDio0ClkHiz)) + || ((MCDRV_DAHIZ_LOW != psInitInfo->bDio1ClkHiz) + && (MCDRV_DAHIZ_HIZ != psInitInfo->bDio1ClkHiz)) + || ((MCDRV_DAHIZ_LOW != psInitInfo->bDio2ClkHiz) + && (MCDRV_DAHIZ_HIZ != psInitInfo->bDio2ClkHiz))) + bRet = 0; + + if (((MCDRV_PCMHIZ_LOW != psInitInfo->bDio0PcmHiz) + && (MCDRV_PCMHIZ_HIZ != psInitInfo->bDio0PcmHiz)) + || ((MCDRV_PCMHIZ_LOW != psInitInfo->bDio1PcmHiz) + && (MCDRV_PCMHIZ_HIZ != psInitInfo->bDio1PcmHiz)) + || ((MCDRV_PCMHIZ_LOW != psInitInfo->bDio2PcmHiz) + && (MCDRV_PCMHIZ_HIZ != psInitInfo->bDio2PcmHiz))) + bRet = 0; + + if ((MCDRV_PA_GPIO != psInitInfo->bPa0Func) + && (MCDRV_PA_PDMCK != psInitInfo->bPa0Func)) + bRet = 0; + + if ((MCDRV_PA_GPIO != psInitInfo->bPa1Func) + && (MCDRV_PA_PDMDI != psInitInfo->bPa1Func)) + bRet = 0; + + if ((MCDRV_PA_GPIO != psInitInfo->bPa2Func) + && (MCDRV_PA_PDMDI != psInitInfo->bPa2Func)) + bRet = 0; + + if ((MCDRV_POWMODE_FULL != psInitInfo->bPowerMode) + && (MCDRV_POWMODE_CDSPDEBUG != psInitInfo->bPowerMode)) + bRet = 0; + + if ((psInitInfo->bMbSel1 != MCDRV_MBSEL_20) + && (psInitInfo->bMbSel1 != MCDRV_MBSEL_21) + && (psInitInfo->bMbSel1 != MCDRV_MBSEL_22) + && (psInitInfo->bMbSel1 != MCDRV_MBSEL_23)) + bRet = 0; + if ((psInitInfo->bMbSel2 != MCDRV_MBSEL_20) + && (psInitInfo->bMbSel2 != MCDRV_MBSEL_21) + && (psInitInfo->bMbSel2 != MCDRV_MBSEL_22) + && (psInitInfo->bMbSel2 != MCDRV_MBSEL_23)) + bRet = 0; + if ((psInitInfo->bMbSel3 != MCDRV_MBSEL_20) + && (psInitInfo->bMbSel3 != MCDRV_MBSEL_21) + && (psInitInfo->bMbSel3 != MCDRV_MBSEL_22) + && (psInitInfo->bMbSel3 != MCDRV_MBSEL_23)) + bRet = 0; + if ((psInitInfo->bMbSel4 != MCDRV_MBSEL_20) + && (psInitInfo->bMbSel4 != MCDRV_MBSEL_21) + && (psInitInfo->bMbSel4 != MCDRV_MBSEL_22) + && (psInitInfo->bMbSel4 != MCDRV_MBSEL_23)) + bRet = 0; + + if ((psInitInfo->bMbsDisch != MCDRV_MBSDISCH_0000) + && (psInitInfo->bMbsDisch != MCDRV_MBSDISCH_0001) + && (psInitInfo->bMbsDisch != MCDRV_MBSDISCH_0010) + && (psInitInfo->bMbsDisch != MCDRV_MBSDISCH_0011) + && (psInitInfo->bMbsDisch != MCDRV_MBSDISCH_0100) + && (psInitInfo->bMbsDisch != MCDRV_MBSDISCH_0101) + && (psInitInfo->bMbsDisch != MCDRV_MBSDISCH_0110) + && (psInitInfo->bMbsDisch != MCDRV_MBSDISCH_0111) + && (psInitInfo->bMbsDisch != MCDRV_MBSDISCH_1000) + && (psInitInfo->bMbsDisch != MCDRV_MBSDISCH_1001) + && (psInitInfo->bMbsDisch != MCDRV_MBSDISCH_1010) + && (psInitInfo->bMbsDisch != MCDRV_MBSDISCH_1011) + && (psInitInfo->bMbsDisch != MCDRV_MBSDISCH_1100) + && (psInitInfo->bMbsDisch != MCDRV_MBSDISCH_1101) + && (psInitInfo->bMbsDisch != MCDRV_MBSDISCH_1110) + && (psInitInfo->bMbsDisch != MCDRV_MBSDISCH_1111)) + bRet = 0; + + if ((psInitInfo->bNonClip != MCDRV_NONCLIP_OFF) + && (psInitInfo->bNonClip != MCDRV_NONCLIP_ON)) + bRet = 0; + + if ((psInitInfo->bLineIn1Dif != MCDRV_LINE_STEREO) + && (psInitInfo->bLineIn1Dif != MCDRV_LINE_DIF)) + bRet = 0; + + if ((psInitInfo->bLineOut1Dif != MCDRV_LINE_STEREO) + && (psInitInfo->bLineOut1Dif != MCDRV_LINE_DIF)) + bRet = 0; + + if ((psInitInfo->bLineOut2Dif != MCDRV_LINE_STEREO) + && (psInitInfo->bLineOut2Dif != MCDRV_LINE_DIF)) + bRet = 0; + + if ((psInitInfo->bMic1Sng != MCDRV_MIC_DIF) + && (psInitInfo->bMic1Sng != MCDRV_MIC_SINGLE)) + bRet = 0; + if ((psInitInfo->bMic2Sng != MCDRV_MIC_DIF) + && (psInitInfo->bMic2Sng != MCDRV_MIC_SINGLE)) + bRet = 0; + if ((psInitInfo->bMic3Sng != MCDRV_MIC_DIF) + && (psInitInfo->bMic3Sng != MCDRV_MIC_SINGLE)) + bRet = 0; + if ((psInitInfo->bMic4Sng != MCDRV_MIC_DIF) + && (psInitInfo->bMic4Sng != MCDRV_MIC_SINGLE)) + bRet = 0; + + if ((psInitInfo->bZcLineOut1 != MCDRV_ZC_ON) + && (psInitInfo->bZcLineOut1 != MCDRV_ZC_OFF)) + bRet = 0; + + if ((psInitInfo->bZcLineOut2 != MCDRV_ZC_ON) + && (psInitInfo->bZcLineOut2 != MCDRV_ZC_OFF)) + bRet = 0; + + if ((psInitInfo->bZcRc != MCDRV_ZC_ON) + && (psInitInfo->bZcRc != MCDRV_ZC_OFF)) + bRet = 0; + + if ((psInitInfo->bZcSp != MCDRV_ZC_ON) + && (psInitInfo->bZcSp != MCDRV_ZC_OFF)) + bRet = 0; + + if ((psInitInfo->bZcHp != MCDRV_ZC_ON) + && (psInitInfo->bZcHp != MCDRV_ZC_OFF)) + bRet = 0; + + if ((psInitInfo->bSvolLineOut1 != MCDRV_SVOL_OFF) + && (psInitInfo->bSvolLineOut1 != MCDRV_SVOL_ON)) + bRet = 0; + + if ((psInitInfo->bSvolLineOut2 != MCDRV_SVOL_OFF) + && (psInitInfo->bSvolLineOut2 != MCDRV_SVOL_ON)) + bRet = 0; + + if ((psInitInfo->bSvolRc != MCDRV_SVOL_OFF) + && (psInitInfo->bSvolRc != MCDRV_SVOL_ON)) + bRet = 0; + + if ((psInitInfo->bSvolSp != MCDRV_SVOL_OFF) + && (psInitInfo->bSvolSp != MCDRV_SVOL_ON)) + bRet = 0; + + if ((psInitInfo->bSvolHp != MCDRV_SVOL_OFF) + && (psInitInfo->bSvolHp != MCDRV_SVOL_ON)) + bRet = 0; + + if ((psInitInfo->bRcHiz != MCDRV_RCIMP_FIXLOW) + && (psInitInfo->bRcHiz != MCDRV_RCIMP_WL)) + bRet = 0; + + if ((psInitInfo->bSpHiz != MCDRV_WL_LOFF_ROFF) + && (psInitInfo->bSpHiz != MCDRV_WL_LON_ROFF) + && (psInitInfo->bSpHiz != MCDRV_WL_LOFF_RON) + && (psInitInfo->bSpHiz != MCDRV_WL_LON_RON)) + bRet = 0; + + if ((psInitInfo->bHpHiz != MCDRV_IMP_LFIXLOW_RFIXLOW) + && (psInitInfo->bHpHiz != MCDRV_IMP_LWL_RFIXLOW) + && (psInitInfo->bHpHiz != MCDRV_IMP_LFIXLOW_RWL) + && (psInitInfo->bHpHiz != MCDRV_IMP_LWL_RWL)) + bRet = 0; + + if ((psInitInfo->bLineOut1Hiz != MCDRV_IMP_LFIXLOW_RFIXLOW) + && (psInitInfo->bLineOut1Hiz != MCDRV_IMP_LWL_RFIXLOW) + && (psInitInfo->bLineOut1Hiz != MCDRV_IMP_LFIXLOW_RWL) + && (psInitInfo->bLineOut1Hiz != MCDRV_IMP_LWL_RWL)) + bRet = 0; + + if ((psInitInfo->bLineOut2Hiz != MCDRV_IMP_LFIXLOW_RFIXLOW) + && (psInitInfo->bLineOut2Hiz != MCDRV_IMP_LWL_RFIXLOW) + && (psInitInfo->bLineOut2Hiz != MCDRV_IMP_LFIXLOW_RWL) + && (psInitInfo->bLineOut2Hiz != MCDRV_IMP_LWL_RWL)) + bRet = 0; + + if ((psInitInfo->bCpMod != MCDRV_CPMOD_HI) + && (psInitInfo->bCpMod != MCDRV_CPMOD_MID)) + bRet = 0; + + if (McDevProf_GetDevId() == eMCDRV_DEV_ID_80_90H) { + if ((psInitInfo->bRbSel != MCDRV_RBSEL_2_2K) + && (psInitInfo->bRbSel != MCDRV_RBSEL_50)) + bRet = 0; + } + + if (McDevProf_GetDevId() == eMCDRV_DEV_ID_80_90H) { + if ((psInitInfo->bPlugSel != MCDRV_PLUG_LRGM) + && (psInitInfo->bPlugSel != MCDRV_PLUG_LRMG)) + bRet = 0; + } + + if ((psInitInfo->bGndDet != MCDRV_GNDDET_OFF) + && (psInitInfo->bGndDet != MCDRV_GNDDET_ON)) + bRet = 0; + + if (McDevProf_GetDevId() == eMCDRV_DEV_ID_80_90H) { + if ((psInitInfo->bPpdRc != MCDRV_PPD_OFF) + && (psInitInfo->bPpdRc != MCDRV_PPD_ON)) + bRet = 0; + } + + if ((psInitInfo->bPpdSp != MCDRV_PPD_OFF) + && (psInitInfo->bPpdSp != MCDRV_PPD_ON)) + bRet = 0; + + if (McDevProf_GetDevId() == eMCDRV_DEV_ID_80_90H) { + if ((psInitInfo->bPpdHp != MCDRV_PPD_OFF) + && (psInitInfo->bPpdHp != MCDRV_PPD_ON)) + bRet = 0; + + if ((psInitInfo->bPpdLineOut1 != MCDRV_PPD_OFF) + && (psInitInfo->bPpdLineOut1 != MCDRV_PPD_ON)) + bRet = 0; + + if ((psInitInfo->bPpdLineOut2 != MCDRV_PPD_OFF) + && (psInitInfo->bPpdLineOut2 != MCDRV_PPD_ON)) + bRet = 0; + } + + if ((psInitInfo->sWaitTime.dWaitTime[0] > MCDRV_MAX_WAIT_TIME) + || (psInitInfo->sWaitTime.dWaitTime[1] > MCDRV_MAX_WAIT_TIME) + || (psInitInfo->sWaitTime.dWaitTime[2] > MCDRV_MAX_WAIT_TIME) + || (psInitInfo->sWaitTime.dWaitTime[3] > MCDRV_MAX_WAIT_TIME) + || (psInitInfo->sWaitTime.dWaitTime[4] > MCDRV_MAX_WAIT_TIME)) + bRet = 0; + + if ((McDevProf_GetDevId() != eMCDRV_DEV_ID_80_90H) + && (psInit2Info != NULL)) { + if ((psInit2Info->bOption[0] != MCDRV_DOA_DRV_LOW) + && (psInit2Info->bOption[0] != MCDRV_DOA_DRV_HIGH)) { + bRet = 0; + goto exit; + } + if ((psInit2Info->bOption[1] != MCDRV_SCKMSK_OFF) + && (psInit2Info->bOption[1] != MCDRV_SCKMSK_ON)) { + bRet = 0; + goto exit; + } + if ((psInit2Info->bOption[2] != MCDRV_SPMN_8_9_10) + && (psInit2Info->bOption[2] != MCDRV_SPMN_5_6_7) + && (psInit2Info->bOption[2] != MCDRV_SPMN_4_5_6) + && (psInit2Info->bOption[2] != MCDRV_SPMN_OFF_9) + && (psInit2Info->bOption[2] != MCDRV_SPMN_OFF_6)) { + bRet = 0; + goto exit; + } + if (psInit2Info->bOption[3] > 0x0F) { + bRet = 0; + goto exit; + } + if (psInit2Info->bOption[4] > 0xF8) { + bRet = 0; + goto exit; + } + if (psInit2Info->bOption[5] > 0xF8) { + bRet = 0; + goto exit; + } + if (psInit2Info->bOption[6] > 0x31) { + bRet = 0; + goto exit; + } + if (psInit2Info->bOption[7] > 0x7F) { + bRet = 0; + goto exit; + } + if (psInit2Info->bOption[9] > 0x7F) { + bRet = 0; + goto exit; + } + if (psInit2Info->bOption[10] > 0x11) { + bRet = 0; + goto exit; + } + if (psInit2Info->bOption[11] > 0xF3) { + bRet = 0; + goto exit; + } + if (psInit2Info->bOption[12] > 0x07) { + bRet = 0; + goto exit; + } + } +exit: +#if (MCDRV_DEBUG_LEVEL >= 4) + sdRet = bRet; + McDebugLog_FuncOut("IsValidInitParam", &sdRet); +#endif + return bRet; +} + +/**************************************************************************** + * IsValidReadRegParam + * + * Description: + * check read reg parameter. + * Arguments: + * psRegInfo register information + * Return: + * 0:Invalid + * other:Valid + * + ****************************************************************************/ +static UINT8 IsValidReadRegParam +( + const struct MCDRV_REG_INFO *psRegInfo +) +{ + UINT8 bRet = 1; + +#if (MCDRV_DEBUG_LEVEL >= 4) + SINT32 sdRet; + McDebugLog_FuncIn("IsValidReadRegParam"); +#endif + + + if ((McResCtrl_GetRegAccess(psRegInfo) & eMCDRV_CAN_READ) == + eMCDRV_ACCESS_DENY) { + bRet = 0; + } + +#if (MCDRV_DEBUG_LEVEL >= 4) + sdRet = bRet; + McDebugLog_FuncOut("IsValidReadRegParam", &sdRet); +#endif + return bRet; +} + +/**************************************************************************** + * IsValidWriteRegParam + * + * Description: + * check write reg parameter. + * Arguments: + * psRegInfo register information + * Return: + * 0:Invalid + * other:Valid + * + ****************************************************************************/ +static UINT8 IsValidWriteRegParam +( + const struct MCDRV_REG_INFO *psRegInfo +) +{ + UINT8 bRet = 1; + +#if (MCDRV_DEBUG_LEVEL >= 4) + SINT32 sdRet; + McDebugLog_FuncIn("IsValidWriteRegParam"); +#endif + + + if ((McResCtrl_GetRegAccess(psRegInfo) & eMCDRV_CAN_WRITE) == + eMCDRV_ACCESS_DENY) { + bRet = 0; + } + +#if (MCDRV_DEBUG_LEVEL >= 4) + sdRet = bRet; + McDebugLog_FuncOut("IsValidWriteRegParam", &sdRet); +#endif + return bRet; +} + +/**************************************************************************** + * IsValidClockSwParam + * + * Description: + * check clock parameters. + * Arguments: + * psClockSwInfo clock switch information + * Return: + * 0:Invalid + * other:Valid + * + ****************************************************************************/ +static UINT8 IsValidClockSwParam +( + const struct MCDRV_CLOCKSW_INFO *psClockSwInfo +) +{ + UINT8 bRet = 1; + +#if (MCDRV_DEBUG_LEVEL >= 4) + SINT32 sdRet; + McDebugLog_FuncIn("IsValidClockSwParam"); +#endif + + + if ((MCDRV_CLKSW_CLKA != psClockSwInfo->bClkSrc) + && (MCDRV_CLKSW_CLKB != psClockSwInfo->bClkSrc)) { + bRet = 0; + } + +#if (MCDRV_DEBUG_LEVEL >= 4) + sdRet = bRet; + McDebugLog_FuncOut("IsValidClockSwParam", &sdRet); +#endif + + return bRet; +} + +/**************************************************************************** + * MaskIrregularPath + * + * Description: + * mask irregular path parameters. + * Arguments: + * psPathInfo path information + * Return: + * none + * + ****************************************************************************/ +static void MaskIrregularPath +( + struct MCDRV_PATH_INFO *psPathInfo +) +{ + UINT8 bCh; +#if (MCDRV_DEBUG_LEVEL >= 4) + McDebugLog_FuncIn("MaskIrregularPath"); +#endif + + for (bCh = 0; bCh < MUSICOUT_PATH_CHANNELS; bCh++) + psPathInfo->asMusicOut[bCh].dSrcOnOff &= + ~MCDRV_D1SRC_HIFIIN_ON; + + for (bCh = 0; bCh < EXTOUT_PATH_CHANNELS; bCh++) + psPathInfo->asExtOut[bCh].dSrcOnOff &= + ~MCDRV_D1SRC_HIFIIN_ON; + + for (bCh = 0; bCh < HIFIOUT_PATH_CHANNELS; bCh++) + psPathInfo->asHifiOut[bCh].dSrcOnOff &= + (MCDRV_D1SRC_ADIF0_ON + |MCDRV_D1SRC_ADIF0_OFF); + + for (bCh = 0; bCh < VBOXMIXIN_PATH_CHANNELS; bCh++) + psPathInfo->asVboxMixIn[bCh].dSrcOnOff &= + ~MCDRV_D1SRC_HIFIIN_ON; + + for (bCh = 0; bCh < AE_PATH_CHANNELS; bCh++) { + psPathInfo->asAe0[bCh].dSrcOnOff &= + ~MCDRV_D1SRC_HIFIIN_ON; + psPathInfo->asAe1[bCh].dSrcOnOff &= + ~MCDRV_D1SRC_HIFIIN_ON; + psPathInfo->asAe2[bCh].dSrcOnOff &= + ~MCDRV_D1SRC_HIFIIN_ON; + psPathInfo->asAe3[bCh].dSrcOnOff &= + ~MCDRV_D1SRC_HIFIIN_ON; + } + + for (bCh = 0; bCh < VOICEOUT_PATH_CHANNELS; bCh++) + psPathInfo->asVoiceOut[bCh].dSrcOnOff &= + (MCDRV_D2SRC_VBOXIOOUT_ON|MCDRV_D2SRC_VBOXIOOUT_OFF); + + for (bCh = 0; bCh < VBOXIOIN_PATH_CHANNELS; bCh++) + psPathInfo->asVboxIoIn[bCh].dSrcOnOff &= + (MCDRV_D2SRC_VOICEIN_ON|MCDRV_D2SRC_VOICEIN_OFF); + + for (bCh = 0; bCh < VBOXHOSTIN_PATH_CHANNELS; bCh++) + psPathInfo->asVboxHostIn[bCh].dSrcOnOff &= + (MCDRV_D2SRC_VOICEIN_ON|MCDRV_D2SRC_VOICEIN_OFF); + + for (bCh = 0; bCh < HOSTOUT_PATH_CHANNELS; bCh++) + psPathInfo->asHostOut[bCh].dSrcOnOff &= + (MCDRV_D2SRC_VBOXHOSTOUT_ON + |MCDRV_D2SRC_VBOXHOSTOUT_OFF); + + for (bCh = 0; bCh < ADIF0_PATH_CHANNELS; bCh++) + psPathInfo->asAdif0[bCh].dSrcOnOff &= + (MCDRV_D2SRC_ADC0_L_ON + |MCDRV_D2SRC_ADC0_L_OFF + |MCDRV_D2SRC_ADC0_R_ON + |MCDRV_D2SRC_ADC0_R_OFF + |MCDRV_D2SRC_ADC1_ON + |MCDRV_D2SRC_ADC1_OFF + |MCDRV_D2SRC_PDM0_L_ON + |MCDRV_D2SRC_PDM0_L_OFF + |MCDRV_D2SRC_PDM0_R_ON + |MCDRV_D2SRC_PDM0_R_OFF + |MCDRV_D2SRC_PDM1_L_ON + |MCDRV_D2SRC_PDM1_L_OFF + |MCDRV_D2SRC_PDM1_R_ON + |MCDRV_D2SRC_PDM1_R_OFF); + + for (bCh = 0; bCh < ADIF1_PATH_CHANNELS; bCh++) + psPathInfo->asAdif1[bCh].dSrcOnOff &= + (MCDRV_D2SRC_ADC0_L_ON + |MCDRV_D2SRC_ADC0_L_OFF + |MCDRV_D2SRC_ADC0_R_ON + |MCDRV_D2SRC_ADC0_R_OFF + |MCDRV_D2SRC_ADC1_ON + |MCDRV_D2SRC_ADC1_OFF + |MCDRV_D2SRC_PDM0_L_ON + |MCDRV_D2SRC_PDM0_L_OFF + |MCDRV_D2SRC_PDM0_R_ON + |MCDRV_D2SRC_PDM0_R_OFF + |MCDRV_D2SRC_PDM1_L_ON + |MCDRV_D2SRC_PDM1_L_OFF + |MCDRV_D2SRC_PDM1_R_ON + |MCDRV_D2SRC_PDM1_R_OFF); + + for (bCh = 0; bCh < ADIF2_PATH_CHANNELS; bCh++) + psPathInfo->asAdif2[bCh].dSrcOnOff &= + (MCDRV_D2SRC_ADC0_L_ON + |MCDRV_D2SRC_ADC0_L_OFF + |MCDRV_D2SRC_ADC0_R_ON + |MCDRV_D2SRC_ADC0_R_OFF + |MCDRV_D2SRC_ADC1_ON + |MCDRV_D2SRC_ADC1_OFF + |MCDRV_D2SRC_PDM0_L_ON + |MCDRV_D2SRC_PDM0_L_OFF + |MCDRV_D2SRC_PDM0_R_ON + |MCDRV_D2SRC_PDM0_R_OFF + |MCDRV_D2SRC_PDM1_L_ON + |MCDRV_D2SRC_PDM1_L_OFF + |MCDRV_D2SRC_PDM1_R_ON + |MCDRV_D2SRC_PDM1_R_OFF + |MCDRV_D2SRC_DAC0REF_ON + |MCDRV_D2SRC_DAC0REF_OFF + |MCDRV_D2SRC_DAC1REF_ON + |MCDRV_D2SRC_DAC1REF_OFF); + + psPathInfo->asAdc0[0].dSrcOnOff &= + ~(MCDRV_ASRC_DAC0_L_ON|MCDRV_ASRC_DAC0_R_ON + |MCDRV_ASRC_DAC1_L_ON|MCDRV_ASRC_DAC1_R_ON + |MCDRV_ASRC_LINEIN1_R_ON); + psPathInfo->asAdc0[1].dSrcOnOff &= + ~(MCDRV_ASRC_DAC0_L_ON|MCDRV_ASRC_DAC0_R_ON + |MCDRV_ASRC_DAC1_L_ON|MCDRV_ASRC_DAC1_R_ON + |MCDRV_ASRC_LINEIN1_L_ON); + + for (bCh = 0; bCh < ADC1_PATH_CHANNELS; bCh++) + psPathInfo->asAdc1[bCh].dSrcOnOff &= + ~(MCDRV_ASRC_DAC0_L_ON|MCDRV_ASRC_DAC0_R_ON + |MCDRV_ASRC_DAC1_L_ON|MCDRV_ASRC_DAC1_R_ON + |MCDRV_ASRC_LINEIN1_L_ON|MCDRV_ASRC_LINEIN1_R_ON); + + psPathInfo->asSp[0].dSrcOnOff &= + (MCDRV_ASRC_DAC1_L_ON + |MCDRV_ASRC_DAC1_L_OFF); + psPathInfo->asSp[1].dSrcOnOff &= + (MCDRV_ASRC_DAC1_R_ON + |MCDRV_ASRC_DAC1_R_OFF); + + psPathInfo->asHp[0].dSrcOnOff &= + (MCDRV_ASRC_DAC0_L_ON + |MCDRV_ASRC_DAC0_L_OFF); + psPathInfo->asHp[1].dSrcOnOff &= + (MCDRV_ASRC_DAC0_R_ON + |MCDRV_ASRC_DAC0_R_OFF); + + psPathInfo->asRc[0].dSrcOnOff &= + (MCDRV_ASRC_DAC0_L_ON + |MCDRV_ASRC_DAC0_L_OFF); + + psPathInfo->asLout1[0].dSrcOnOff &= + (MCDRV_ASRC_DAC0_L_ON + |MCDRV_ASRC_DAC0_L_OFF); + psPathInfo->asLout1[1].dSrcOnOff &= + (MCDRV_ASRC_DAC0_R_ON + |MCDRV_ASRC_DAC0_R_OFF); + + psPathInfo->asLout2[0].dSrcOnOff &= + (MCDRV_ASRC_DAC1_L_ON + |MCDRV_ASRC_DAC1_L_OFF); + psPathInfo->asLout2[1].dSrcOnOff &= + (MCDRV_ASRC_DAC1_R_ON + |MCDRV_ASRC_DAC1_R_OFF); + + psPathInfo->asBias[0].dSrcOnOff &= + (MCDRV_ASRC_MIC1_ON + |MCDRV_ASRC_MIC1_OFF); + psPathInfo->asBias[1].dSrcOnOff &= + (MCDRV_ASRC_MIC2_ON + |MCDRV_ASRC_MIC2_OFF); + psPathInfo->asBias[2].dSrcOnOff &= + (MCDRV_ASRC_MIC3_ON + |MCDRV_ASRC_MIC3_OFF); + psPathInfo->asBias[3].dSrcOnOff &= + (MCDRV_ASRC_MIC4_ON + |MCDRV_ASRC_MIC4_OFF); + +#if (MCDRV_DEBUG_LEVEL >= 4) + McDebugLog_FuncOut("MaskIrregularPath", NULL); +#endif +} + +/**************************************************************************** + * IsValidDioParam + * + * Description: + * validate digital IO parameters. + * Arguments: + * psDioInfo digital IO information + * dUpdateInfo update information + * Return: + * 0:Invalid + * other:Valid + * + ****************************************************************************/ +static UINT8 IsValidDioParam +( + const struct MCDRV_DIO_INFO *psDioInfo, + UINT32 dUpdateInfo +) +{ + UINT8 bRet = 1; + struct MCDRV_DIO_INFO sDioInfo; + UINT8 bRegVal; + UINT8 bLPR0_start = 0, + bLPT0_start = 0, + bLPR1_start = 0, + bLPT1_start = 0, + bLPR2_start = 0, + bLPT2_start = 0, + bLPR3_start = 0, + bLPT3_start = 0; + +#if (MCDRV_DEBUG_LEVEL >= 4) + SINT32 sdRet = MCDRV_SUCCESS; + McDebugLog_FuncIn("IsValidDioParam"); +#endif + + + McResCtrl_GetDioInfo(&sDioInfo); + + bRegVal = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_MB, MCI_LP0_START); + if ((bRegVal & MCB_LPR0_START) != 0) { + ; + bLPR0_start = 1; + } + if ((bRegVal & MCB_LPT0_START) != 0) { + ; + bLPT0_start = 1; + } + bRegVal = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_MB, MCI_LP1_START); + if ((bRegVal & MCB_LPR1_START) != 0) { + ; + bLPR1_start = 1; + } + if ((bRegVal & MCB_LPT1_START) != 0) { + ; + bLPT1_start = 1; + } + bRegVal = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_MB, MCI_LP2_START); + if ((bRegVal & MCB_LPR2_START) != 0) { + ; + bLPR2_start = 1; + } + if ((bRegVal & MCB_LPT2_START) != 0) { + ; + bLPT2_start = 1; + } + bRegVal = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_MB, MCI_LP3_START); + if ((bRegVal & MCB_LPR3_START) != 0) { + ; + bLPR3_start = 1; + } + if ((bRegVal & MCB_LPT3_START) != 0) { + ; + bLPT3_start = 1; + } + + if (((dUpdateInfo & MCDRV_MUSIC_COM_UPDATE_FLAG) != 0UL) + || ((dUpdateInfo & MCDRV_MUSIC_DIR_UPDATE_FLAG) != 0UL)) { + if (bLPR0_start != 0) { + ; + bRet = 0; + } + } + if (((dUpdateInfo & MCDRV_MUSIC_COM_UPDATE_FLAG) != 0UL) + || ((dUpdateInfo & MCDRV_MUSIC_DIT_UPDATE_FLAG) != 0UL)) { + if (bLPT0_start != 0) { + ; + bRet = 0; + } + } + if (((dUpdateInfo & MCDRV_EXT_COM_UPDATE_FLAG) != 0UL) + || ((dUpdateInfo & MCDRV_EXT_DIR_UPDATE_FLAG) != 0UL)) { + if (bLPR1_start != 0) { + ; + bRet = 0; + } + } + if (((dUpdateInfo & MCDRV_EXT_COM_UPDATE_FLAG) != 0UL) + || ((dUpdateInfo & MCDRV_EXT_DIT_UPDATE_FLAG) != 0UL)) { + if (bLPT1_start != 0) { + ; + bRet = 0; + } + } + if (((dUpdateInfo & MCDRV_VOICE_COM_UPDATE_FLAG) != 0UL) + || ((dUpdateInfo & MCDRV_VOICE_DIR_UPDATE_FLAG) != 0UL)) { + if (bLPR2_start != 0) { + ; + bRet = 0; + } + } + if (((dUpdateInfo & MCDRV_VOICE_COM_UPDATE_FLAG) != 0UL) + || ((dUpdateInfo & MCDRV_VOICE_DIT_UPDATE_FLAG) != 0UL)) { + if (bLPT2_start != 0) { + ; + bRet = 0; + } + } + if (((dUpdateInfo & MCDRV_HIFI_COM_UPDATE_FLAG) != 0UL) + || ((dUpdateInfo & MCDRV_HIFI_DIR_UPDATE_FLAG) != 0UL)) { + if (bLPR3_start != 0) { + ; + bRet = 0; + } + } + if (((dUpdateInfo & MCDRV_HIFI_COM_UPDATE_FLAG) != 0UL) + || ((dUpdateInfo & MCDRV_HIFI_DIT_UPDATE_FLAG) != 0UL)) { + if (bLPT3_start != 0) { + ; + bRet = 0; + } + } + + + if ((bRet != 0) + && ((dUpdateInfo & MCDRV_MUSIC_COM_UPDATE_FLAG) != 0UL)) { + bRet = CheckDIOCommon(psDioInfo, 0); + if (bRet != 0) { + ; + sDioInfo.asPortInfo[0].sDioCommon.bInterface = + psDioInfo->asPortInfo[0].sDioCommon.bInterface; + } + } + if ((bRet != 0) + && ((dUpdateInfo & MCDRV_EXT_COM_UPDATE_FLAG) != 0UL)) { + bRet = CheckDIOCommon(psDioInfo, 1); + if (bRet != 0) { + ; + sDioInfo.asPortInfo[1].sDioCommon.bInterface = + psDioInfo->asPortInfo[1].sDioCommon.bInterface; + } + } + if ((bRet != 0) + && ((dUpdateInfo & MCDRV_VOICE_COM_UPDATE_FLAG) != 0UL)) { + bRet = CheckDIOCommon(psDioInfo, 2); + if (bRet != 0) { + ; + sDioInfo.asPortInfo[2].sDioCommon.bInterface = + psDioInfo->asPortInfo[2].sDioCommon.bInterface; + } + } + if ((bRet != 0) + && ((dUpdateInfo & MCDRV_HIFI_COM_UPDATE_FLAG) != 0UL)) { + bRet = CheckDIOCommon(psDioInfo, 3); + if (bRet != 0) { + ; + sDioInfo.asPortInfo[3].sDioCommon.bInterface = + psDioInfo->asPortInfo[3].sDioCommon.bInterface; + } + } + + if ((bRet != 0) + && ((dUpdateInfo & MCDRV_MUSIC_DIR_UPDATE_FLAG) != 0UL)) { + ; + bRet = CheckDIODIR(psDioInfo, 0); + } + if ((bRet != 0) + && ((dUpdateInfo & MCDRV_EXT_DIR_UPDATE_FLAG) != 0UL)) { + ; + bRet = CheckDIODIR(psDioInfo, 1); + } + if ((bRet != 0) + && ((dUpdateInfo & MCDRV_VOICE_DIR_UPDATE_FLAG) != 0UL)) { + ; + bRet = CheckDIODIR(psDioInfo, 2); + } + + if ((bRet != 0) + && ((dUpdateInfo & MCDRV_MUSIC_DIT_UPDATE_FLAG) != 0UL)) { + ; + bRet = CheckDIODIT(psDioInfo, 0); + } + if ((bRet != 0) + && ((dUpdateInfo & MCDRV_EXT_DIT_UPDATE_FLAG) != 0UL)) { + ; + bRet = CheckDIODIT(psDioInfo, 1); + } + if ((bRet != 0) + && ((dUpdateInfo & MCDRV_VOICE_DIT_UPDATE_FLAG) != 0UL)) { + ; + bRet = CheckDIODIT(psDioInfo, 2); + } + +#if (MCDRV_DEBUG_LEVEL >= 4) + sdRet = bRet; + McDebugLog_FuncOut("IsValidDioParam", &sdRet); +#endif + return bRet; +} + +/**************************************************************************** + * IsValidDioPathParam + * + * Description: + * validate digital IO path parameters. + * Arguments: + * psDioPathInfo digital IO path information + * dUpdateInfo update information + * Return: + * 0:Invalid + * other:Valid + * + ****************************************************************************/ +static UINT8 IsValidDioPathParam +( + const struct MCDRV_DIOPATH_INFO *psDioPathInfo, + UINT32 dUpdateInfo +) +{ + UINT8 bRet = 1; + UINT8 bRegVal; + struct MCDRV_DIOPATH_INFO sDioPathInfo; + UINT8 bLP0_start = 0, + bLP1_start = 0, + bLP2_start = 0, + bLP3_start = 0; + +#if (MCDRV_DEBUG_LEVEL >= 4) + SINT32 sdRet = MCDRV_SUCCESS; + McDebugLog_FuncIn("IsValidDioPathParam"); +#endif + + + bRegVal = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_MB, MCI_LP0_START); + if ((bRegVal & MCB_LPR0_START) != 0) + bLP0_start = 1; + else if ((bRegVal & MCB_LPT0_START) != 0) + bLP0_start = 1; + + bRegVal = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_MB, MCI_LP1_START); + if ((bRegVal & MCB_LPR1_START) != 0) + bLP1_start = 1; + else if ((bRegVal & MCB_LPT1_START) != 0) + bLP1_start = 1; + + bRegVal = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_MB, MCI_LP2_START); + if ((bRegVal & MCB_LPR2_START) != 0) + bLP2_start = 1; + else if ((bRegVal & MCB_LPT2_START) != 0) + bLP2_start = 1; + + bRegVal = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_MB, MCI_LP3_START); + if ((bRegVal & MCB_LPR3_START) != 0) + bLP3_start = 1; + else if ((bRegVal & MCB_LPT3_START) != 0) + bLP3_start = 1; + + McResCtrl_GetDioPathInfo(&sDioPathInfo); + + if ((dUpdateInfo & MCDRV_MUSICNUM_UPDATE_FLAG) != 0UL) { + if ((psDioPathInfo->bMusicCh != MCDRV_MUSIC_2CH) + && (psDioPathInfo->bMusicCh != MCDRV_MUSIC_4CH) + && (psDioPathInfo->bMusicCh != MCDRV_MUSIC_6CH)) { + bRet = 0; + goto exit; + } else if (psDioPathInfo->bMusicCh != sDioPathInfo.bMusicCh) { + if ((psDioPathInfo->bMusicCh == MCDRV_MUSIC_6CH) + || (sDioPathInfo.bMusicCh == MCDRV_MUSIC_6CH)) { + if (bLP2_start != 0) { + bRet = 0; + goto exit; + } + } else { + if (bLP0_start != 0) { + bRet = 0; + goto exit; + } +#if 0 + if (bLP1_start != 0) { + bRet = 0; + goto exit; + } +#endif + } + } + } + if ((dUpdateInfo & MCDRV_PHYS0_UPDATE_FLAG) != 0UL) { + if ((psDioPathInfo->abPhysPort[0] != MCDRV_PHYSPORT_DIO0) + && (psDioPathInfo->abPhysPort[0] != MCDRV_PHYSPORT_DIO1) + && (psDioPathInfo->abPhysPort[0] != MCDRV_PHYSPORT_DIO2) + && (psDioPathInfo->abPhysPort[0] != MCDRV_PHYSPORT_NONE) + && (psDioPathInfo->abPhysPort[0] != MCDRV_PHYSPORT_SLIM0) + && (psDioPathInfo->abPhysPort[0] != MCDRV_PHYSPORT_SLIM1) + && (psDioPathInfo->abPhysPort[0] != MCDRV_PHYSPORT_SLIM2)) { + bRet = 0; + goto exit; + } else if (psDioPathInfo->abPhysPort[0] != + sDioPathInfo.abPhysPort[0]) { + if (bLP0_start != 0) { + bRet = 0; + goto exit; + } + } + } + if ((dUpdateInfo & MCDRV_PHYS1_UPDATE_FLAG) != 0UL) { + if ((psDioPathInfo->abPhysPort[1] != MCDRV_PHYSPORT_DIO0) + && (psDioPathInfo->abPhysPort[1] != MCDRV_PHYSPORT_DIO1) + && (psDioPathInfo->abPhysPort[1] != MCDRV_PHYSPORT_DIO2) + && (psDioPathInfo->abPhysPort[1] != MCDRV_PHYSPORT_NONE) + && (psDioPathInfo->abPhysPort[1] != MCDRV_PHYSPORT_SLIM0) + && (psDioPathInfo->abPhysPort[1] != MCDRV_PHYSPORT_SLIM1) + && (psDioPathInfo->abPhysPort[1] != MCDRV_PHYSPORT_SLIM2)) { + bRet = 0; + goto exit; + } else if (psDioPathInfo->abPhysPort[1] != + sDioPathInfo.abPhysPort[1]) { + if (bLP1_start != 0) { + bRet = 0; + goto exit; + } + } + } + if ((dUpdateInfo & MCDRV_PHYS2_UPDATE_FLAG) != 0UL) { + if ((psDioPathInfo->abPhysPort[2] != MCDRV_PHYSPORT_DIO0) + && (psDioPathInfo->abPhysPort[2] != MCDRV_PHYSPORT_DIO1) + && (psDioPathInfo->abPhysPort[2] != MCDRV_PHYSPORT_DIO2) + && (psDioPathInfo->abPhysPort[2] != MCDRV_PHYSPORT_NONE) + && (psDioPathInfo->abPhysPort[2] != MCDRV_PHYSPORT_SLIM0) + && (psDioPathInfo->abPhysPort[2] != MCDRV_PHYSPORT_SLIM1) + && (psDioPathInfo->abPhysPort[2] != MCDRV_PHYSPORT_SLIM2)) { + bRet = 0; + goto exit; + } else if (psDioPathInfo->abPhysPort[2] != + sDioPathInfo.abPhysPort[2]) { + if (bLP2_start != 0) { + bRet = 0; + goto exit; + } + } + } + + if ((dUpdateInfo & MCDRV_PHYS3_UPDATE_FLAG) != 0UL) { + if ((psDioPathInfo->abPhysPort[3] != MCDRV_PHYSPORT_DIO0) + && (psDioPathInfo->abPhysPort[3] != MCDRV_PHYSPORT_DIO1) + && (psDioPathInfo->abPhysPort[3] != MCDRV_PHYSPORT_DIO2) + && (psDioPathInfo->abPhysPort[3] != MCDRV_PHYSPORT_NONE) + && (psDioPathInfo->abPhysPort[3] != MCDRV_PHYSPORT_SLIM0) + && (psDioPathInfo->abPhysPort[3] != MCDRV_PHYSPORT_SLIM1) + && (psDioPathInfo->abPhysPort[3] != MCDRV_PHYSPORT_SLIM2)) { + bRet = 0; + goto exit; + } else if (psDioPathInfo->abPhysPort[3] != + sDioPathInfo.abPhysPort[3]) { + if (bLP3_start != 0) { + bRet = 0; + goto exit; + } + } + } + if ((dUpdateInfo & MCDRV_DIR0SLOT_UPDATE_FLAG) != 0UL) { + if ((psDioPathInfo->abMusicRSlot[0] != 0) + && (psDioPathInfo->abMusicRSlot[0] != 1) + && (psDioPathInfo->abMusicRSlot[0] != 2) + && (psDioPathInfo->abMusicRSlot[0] != 3)) { + bRet = 0; + goto exit; + } else if (psDioPathInfo->abMusicRSlot[0] != + sDioPathInfo.abMusicRSlot[0]) { + if (bLP0_start != 0) { + bRet = 0; + goto exit; + } + } + } + if ((dUpdateInfo & MCDRV_DIR1SLOT_UPDATE_FLAG) != 0UL) { + if ((psDioPathInfo->abMusicRSlot[1] != 0) + && (psDioPathInfo->abMusicRSlot[1] != 1) + && (psDioPathInfo->abMusicRSlot[1] != 2) + && (psDioPathInfo->abMusicRSlot[1] != 3)) { + bRet = 0; + } else if (psDioPathInfo->abMusicRSlot[1] != + sDioPathInfo.abMusicRSlot[1]) { + if (bLP0_start != 0) { + bRet = 0; + goto exit; + } + /*if (bLP1_start != 0) { + bRet = 0; + }*/ + } + } + if ((dUpdateInfo & MCDRV_DIR2SLOT_UPDATE_FLAG) != 0UL) { + if ((psDioPathInfo->abMusicRSlot[2] != 0) + && (psDioPathInfo->abMusicRSlot[2] != 1) + && (psDioPathInfo->abMusicRSlot[2] != 2) + && (psDioPathInfo->abMusicRSlot[2] != 3)) { + bRet = 0; + } else if (psDioPathInfo->abMusicRSlot[2] != + sDioPathInfo.abMusicRSlot[2]) { + if (bLP0_start != 0) { + bRet = 0; + goto exit; + } + /*if (bLP2_start != 0) { + bRet = 0; + }*/ + } + } + + if ((dUpdateInfo & MCDRV_DIT0SLOT_UPDATE_FLAG) != 0UL) { + if ((psDioPathInfo->abMusicTSlot[0] != 0) + && (psDioPathInfo->abMusicTSlot[0] != 1) + && (psDioPathInfo->abMusicTSlot[0] != 2) + && (psDioPathInfo->abMusicTSlot[0] != 3)) { + bRet = 0; + } else if (psDioPathInfo->abMusicTSlot[0] != + sDioPathInfo.abMusicTSlot[0]) { + if (bLP0_start != 0) { + bRet = 0; + goto exit; + } + /*if (bLP0_start != 0) { + bRet = 0; + }*/ + } + } + if ((dUpdateInfo & MCDRV_DIT1SLOT_UPDATE_FLAG) != 0UL) { + if ((psDioPathInfo->abMusicTSlot[1] != 0) + && (psDioPathInfo->abMusicTSlot[1] != 1) + && (psDioPathInfo->abMusicTSlot[1] != 2) + && (psDioPathInfo->abMusicTSlot[1] != 3)) { + bRet = 0; + } else if (psDioPathInfo->abMusicTSlot[1] != + sDioPathInfo.abMusicTSlot[1]) { + if (bLP0_start != 0) { + bRet = 0; + goto exit; + } + /*if (bLP1_start != 0) { + bRet = 0; + }*/ + } + } + if ((dUpdateInfo & MCDRV_DIT2SLOT_UPDATE_FLAG) != 0UL) { + if ((psDioPathInfo->abMusicTSlot[2] != 0) + && (psDioPathInfo->abMusicTSlot[2] != 1) + && (psDioPathInfo->abMusicTSlot[2] != 2) + && (psDioPathInfo->abMusicTSlot[2] != 3)) { + bRet = 0; + } else if (psDioPathInfo->abMusicTSlot[2] != + sDioPathInfo.abMusicTSlot[2]) { + if (bLP0_start != 0) { + bRet = 0; + goto exit; + } + /*if (bLP2_start != 0) { + bRet = 0; + }*/ + } + } + +exit: +#if (MCDRV_DEBUG_LEVEL >= 4) + sdRet = bRet; + McDebugLog_FuncOut("IsValidDioPathParam", &sdRet); +#endif + return bRet; +} + +/**************************************************************************** + * IsValidSwapParam + * + * Description: + * check Swap parameters. + * Arguments: + * psSwapInfo Swap information + * dUpdateInfo update information + * Return: + * 0:Invalid + * other:Valid + * + ****************************************************************************/ +static UINT8 IsValidSwapParam +( + const struct MCDRV_SWAP_INFO *psSwapInfo, + UINT32 dUpdateInfo +) +{ + UINT8 bRet = 1; + +#if (MCDRV_DEBUG_LEVEL >= 4) + SINT32 sdRet; + McDebugLog_FuncIn("IsValidSwapParam"); +#endif + + + if ((dUpdateInfo & MCDRV_SWAP_ADIF0_UPDATE_FLAG) != 0UL) { + if ((psSwapInfo->bAdif0 != MCDRV_SWAP_NORMAL) + && (psSwapInfo->bAdif0 != MCDRV_SWAP_SWAP) + && (psSwapInfo->bAdif0 != MCDRV_SWAP_MUTE) + && (psSwapInfo->bAdif0 != MCDRV_SWAP_CENTER) + && (psSwapInfo->bAdif0 != MCDRV_SWAP_MIX) + && (psSwapInfo->bAdif0 != MCDRV_SWAP_MONOMIX) + && (psSwapInfo->bAdif0 != MCDRV_SWAP_BOTHL) + && (psSwapInfo->bAdif0 != MCDRV_SWAP_BOTHR)) + bRet = 0; + } + if ((dUpdateInfo & MCDRV_SWAP_ADIF1_UPDATE_FLAG) != 0UL) { + if ((psSwapInfo->bAdif1 != MCDRV_SWAP_NORMAL) + && (psSwapInfo->bAdif1 != MCDRV_SWAP_SWAP) + && (psSwapInfo->bAdif1 != MCDRV_SWAP_MUTE) + && (psSwapInfo->bAdif1 != MCDRV_SWAP_CENTER) + && (psSwapInfo->bAdif1 != MCDRV_SWAP_MIX) + && (psSwapInfo->bAdif1 != MCDRV_SWAP_MONOMIX) + && (psSwapInfo->bAdif1 != MCDRV_SWAP_BOTHL) + && (psSwapInfo->bAdif1 != MCDRV_SWAP_BOTHR)) + bRet = 0; + } + if ((dUpdateInfo & MCDRV_SWAP_ADIF2_UPDATE_FLAG) != 0UL) { + if ((psSwapInfo->bAdif2 != MCDRV_SWAP_NORMAL) + && (psSwapInfo->bAdif2 != MCDRV_SWAP_SWAP) + && (psSwapInfo->bAdif2 != MCDRV_SWAP_MUTE) + && (psSwapInfo->bAdif2 != MCDRV_SWAP_CENTER) + && (psSwapInfo->bAdif2 != MCDRV_SWAP_MIX) + && (psSwapInfo->bAdif2 != MCDRV_SWAP_MONOMIX) + && (psSwapInfo->bAdif2 != MCDRV_SWAP_BOTHL) + && (psSwapInfo->bAdif2 != MCDRV_SWAP_BOTHR)) + bRet = 0; + } + if ((dUpdateInfo & MCDRV_SWAP_DAC0_UPDATE_FLAG) != 0UL) { + if ((psSwapInfo->bDac0 != MCDRV_SWAP_NORMAL) + && (psSwapInfo->bDac0 != MCDRV_SWAP_SWAP) + && (psSwapInfo->bDac0 != MCDRV_SWAP_MUTE) + && (psSwapInfo->bDac0 != MCDRV_SWAP_CENTER) + && (psSwapInfo->bDac0 != MCDRV_SWAP_MIX) + && (psSwapInfo->bDac0 != MCDRV_SWAP_MONOMIX) + && (psSwapInfo->bDac0 != MCDRV_SWAP_BOTHL) + && (psSwapInfo->bDac0 != MCDRV_SWAP_BOTHR)) + bRet = 0; + } + if ((dUpdateInfo & MCDRV_SWAP_DAC1_UPDATE_FLAG) != 0UL) { + if ((psSwapInfo->bDac1 != MCDRV_SWAP_NORMAL) + && (psSwapInfo->bDac1 != MCDRV_SWAP_SWAP) + && (psSwapInfo->bDac1 != MCDRV_SWAP_MUTE) + && (psSwapInfo->bDac1 != MCDRV_SWAP_CENTER) + && (psSwapInfo->bDac1 != MCDRV_SWAP_MIX) + && (psSwapInfo->bDac1 != MCDRV_SWAP_MONOMIX) + && (psSwapInfo->bDac1 != MCDRV_SWAP_BOTHL) + && (psSwapInfo->bDac1 != MCDRV_SWAP_BOTHR)) + bRet = 0; + } + + if ((dUpdateInfo & MCDRV_SWAP_MUSICIN0_UPDATE_FLAG) != 0UL) { + if ((psSwapInfo->bMusicIn0 != MCDRV_SWSWAP_NORMAL) + && (psSwapInfo->bMusicIn0 != MCDRV_SWSWAP_BOTH1) + && (psSwapInfo->bMusicIn0 != MCDRV_SWSWAP_BOTH0) + && (psSwapInfo->bMusicIn0 != MCDRV_SWSWAP_SWAP)) + bRet = 0; + } + if ((dUpdateInfo & MCDRV_SWAP_MUSICIN1_UPDATE_FLAG) != 0UL) { + if ((psSwapInfo->bMusicIn1 != MCDRV_SWSWAP_NORMAL) + && (psSwapInfo->bMusicIn1 != MCDRV_SWSWAP_BOTH1) + && (psSwapInfo->bMusicIn1 != MCDRV_SWSWAP_BOTH0) + && (psSwapInfo->bMusicIn1 != MCDRV_SWSWAP_SWAP)) + bRet = 0; + } + if ((dUpdateInfo & MCDRV_SWAP_MUSICIN2_UPDATE_FLAG) != 0UL) { + if ((psSwapInfo->bMusicIn2 != MCDRV_SWSWAP_NORMAL) + && (psSwapInfo->bMusicIn2 != MCDRV_SWSWAP_BOTH1) + && (psSwapInfo->bMusicIn2 != MCDRV_SWSWAP_BOTH0) + && (psSwapInfo->bMusicIn2 != MCDRV_SWSWAP_SWAP)) + bRet = 0; + } + if ((dUpdateInfo & MCDRV_SWAP_EXTIN_UPDATE_FLAG) != 0UL) { + if ((psSwapInfo->bExtIn != MCDRV_SWSWAP_NORMAL) + && (psSwapInfo->bExtIn != MCDRV_SWSWAP_BOTH1) + && (psSwapInfo->bExtIn != MCDRV_SWSWAP_BOTH0) + && (psSwapInfo->bExtIn != MCDRV_SWSWAP_SWAP)) + bRet = 0; + } + if ((dUpdateInfo & MCDRV_SWAP_VOICEIN_UPDATE_FLAG) != 0UL) { + if ((psSwapInfo->bVoiceIn != MCDRV_SWSWAP_NORMAL) + && (psSwapInfo->bVoiceIn != MCDRV_SWSWAP_BOTH1) + && (psSwapInfo->bVoiceIn != MCDRV_SWSWAP_BOTH0) + && (psSwapInfo->bVoiceIn != MCDRV_SWSWAP_SWAP)) + bRet = 0; + } + if ((dUpdateInfo & MCDRV_SWAP_HIFIIN_UPDATE_FLAG) != 0UL) { + if ((psSwapInfo->bHifiIn != MCDRV_SWSWAP_NORMAL) + && (psSwapInfo->bHifiIn != MCDRV_SWSWAP_BOTH1) + && (psSwapInfo->bHifiIn != MCDRV_SWSWAP_BOTH0) + && (psSwapInfo->bHifiIn != MCDRV_SWSWAP_SWAP)) + bRet = 0; + } + if ((dUpdateInfo & MCDRV_SWAP_MUSICOUT0_UPDATE_FLAG) != 0UL) { + if ((psSwapInfo->bMusicOut0 != MCDRV_SWAP_NORMAL) + && (psSwapInfo->bMusicOut0 != MCDRV_SWAP_SWAP) + && (psSwapInfo->bMusicOut0 != MCDRV_SWAP_MUTE) + && (psSwapInfo->bMusicOut0 != MCDRV_SWAP_CENTER) + && (psSwapInfo->bMusicOut0 != MCDRV_SWAP_MIX) + && (psSwapInfo->bMusicOut0 != MCDRV_SWAP_MONOMIX) + && (psSwapInfo->bMusicOut0 != MCDRV_SWAP_BOTHL) + && (psSwapInfo->bMusicOut0 != MCDRV_SWAP_BOTHR)) + bRet = 0; + } + if ((dUpdateInfo & MCDRV_SWAP_MUSICOUT1_UPDATE_FLAG) != 0UL) { + if ((psSwapInfo->bMusicOut1 != MCDRV_SWSWAP_NORMAL) + && (psSwapInfo->bMusicOut1 != MCDRV_SWSWAP_BOTH1) + && (psSwapInfo->bMusicOut1 != MCDRV_SWSWAP_BOTH0) + && (psSwapInfo->bMusicOut1 != MCDRV_SWSWAP_SWAP)) + bRet = 0; + } + if ((dUpdateInfo & MCDRV_SWAP_MUSICOUT2_UPDATE_FLAG) != 0UL) { + if ((psSwapInfo->bMusicOut2 != MCDRV_SWSWAP_NORMAL) + && (psSwapInfo->bMusicOut2 != MCDRV_SWSWAP_BOTH1) + && (psSwapInfo->bMusicOut2 != MCDRV_SWSWAP_BOTH0) + && (psSwapInfo->bMusicOut2 != MCDRV_SWSWAP_SWAP)) + bRet = 0; + } + if ((dUpdateInfo & MCDRV_SWAP_EXTOUT_UPDATE_FLAG) != 0UL) { + if ((psSwapInfo->bExtOut != MCDRV_SWSWAP_NORMAL) + && (psSwapInfo->bExtOut != MCDRV_SWSWAP_BOTH1) + && (psSwapInfo->bExtOut != MCDRV_SWSWAP_BOTH0) + && (psSwapInfo->bExtOut != MCDRV_SWSWAP_SWAP)) + bRet = 0; + } + if ((dUpdateInfo & MCDRV_SWAP_VOICEOUT_UPDATE_FLAG) != 0UL) { + if ((psSwapInfo->bVoiceOut != MCDRV_SWSWAP_NORMAL) + && (psSwapInfo->bVoiceOut != MCDRV_SWSWAP_BOTH1) + && (psSwapInfo->bVoiceOut != MCDRV_SWSWAP_BOTH0) + && (psSwapInfo->bVoiceOut != MCDRV_SWSWAP_SWAP)) + bRet = 0; + } + if ((dUpdateInfo & MCDRV_SWAP_HIFIOUT_UPDATE_FLAG) != 0UL) { + if ((psSwapInfo->bHifiOut != MCDRV_SWSWAP_NORMAL) + && (psSwapInfo->bHifiOut != MCDRV_SWSWAP_BOTH1) + && (psSwapInfo->bHifiOut != MCDRV_SWSWAP_BOTH0) + && (psSwapInfo->bHifiOut != MCDRV_SWSWAP_SWAP)) + bRet = 0; + } + +#if (MCDRV_DEBUG_LEVEL >= 4) + sdRet = bRet; + McDebugLog_FuncOut("IsValidSwapParam", &sdRet); +#endif + + return bRet; +} + +/**************************************************************************** + * IsValidDspParam + * + * Description: + * validate DSP parameters. + * Arguments: + * psAECInfo AEC information + * Return: + * 0:Invalid + * other:Valid + * + ****************************************************************************/ +static UINT8 IsValidDspParam +( + const struct MCDRV_AEC_INFO *psAECInfo +) +{ + UINT8 bRet = 1; + UINT8 bBdspUsed = 0, + bCdspUsed = 0, + bFdspUsed = 0; + struct MCDRV_AEC_INFO sCurAECInfo; + +#if (MCDRV_DEBUG_LEVEL >= 4) + SINT32 sdRet; + McDebugLog_FuncIn("IsValidDspParam"); +#endif + + + McResCtrl_GetAecInfo(&sCurAECInfo); + + if (McResCtrl_IsD1SrcUsed(MCDRV_D1SRC_AE0_ON + |MCDRV_D1SRC_AE1_ON + |MCDRV_D1SRC_AE2_ON + |MCDRV_D1SRC_AE3_ON) != 0) { + bBdspUsed = 1; + if (sCurAECInfo.sAecConfig.bFDspLocate == 0) + bFdspUsed = 1; + } + if ((McResCtrl_HasSrc(eMCDRV_DST_VBOXMIXIN, eMCDRV_DST_CH0) != 0) + || (McResCtrl_HasSrc(eMCDRV_DST_VBOXMIXIN, eMCDRV_DST_CH1) != 0) + || (McResCtrl_HasSrc(eMCDRV_DST_VBOXMIXIN, eMCDRV_DST_CH2) != 0) + || (McResCtrl_HasSrc(eMCDRV_DST_VBOXMIXIN, eMCDRV_DST_CH3) != 0) + || (McResCtrl_HasSrc(eMCDRV_DST_VBOXHOSTIN, eMCDRV_DST_CH0) != 0)) { + bCdspUsed = 1; + if (sCurAECInfo.sAecConfig.bFDspLocate == 1) + bFdspUsed = 1; + } + + if ((bBdspUsed != 0) + || (bCdspUsed != 0) + || (bFdspUsed != 0)) + if (psAECInfo->sAecConfig.bFDspLocate != 0xFF) + if (sCurAECInfo.sAecConfig.bFDspLocate != + psAECInfo->sAecConfig.bFDspLocate) { + bRet = 0; + goto exit; + } + + if ((bBdspUsed != 0) + || (bFdspUsed != 0)) + if (psAECInfo->sAecAudioengine.bEnable != 0) { + if ((psAECInfo->sAecAudioengine.bBDspAE0Src != 2) + && (psAECInfo->sAecAudioengine.bBDspAE0Src != + sCurAECInfo.sAecAudioengine.bBDspAE0Src)) { + bRet = 0; + goto exit; + } + if ((psAECInfo->sAecAudioengine.bBDspAE1Src != 2) + && (psAECInfo->sAecAudioengine.bBDspAE1Src != + sCurAECInfo.sAecAudioengine.bBDspAE1Src)) { + bRet = 0; + goto exit; + } + if ((psAECInfo->sAecAudioengine.bMixerIn0Src != 2) + && (psAECInfo->sAecAudioengine.bMixerIn0Src != + sCurAECInfo.sAecAudioengine.bMixerIn0Src)) { + bRet = 0; + goto exit; + } + if ((psAECInfo->sAecAudioengine.bMixerIn1Src != 2) + && (psAECInfo->sAecAudioengine.bMixerIn1Src != + sCurAECInfo.sAecAudioengine.bMixerIn1Src)) { + bRet = 0; + goto exit; + } + if ((psAECInfo->sAecAudioengine.bMixerIn2Src != 2) + && (psAECInfo->sAecAudioengine.bMixerIn2Src != + sCurAECInfo.sAecAudioengine.bMixerIn2Src)) { + bRet = 0; + goto exit; + } + if ((psAECInfo->sAecAudioengine.bMixerIn3Src != 2) + && (psAECInfo->sAecAudioengine.bMixerIn3Src != + sCurAECInfo.sAecAudioengine.bMixerIn3Src)) { + bRet = 0; + goto exit; + } + } + + if ((bCdspUsed != 0) + || (bFdspUsed != 0)) + if (psAECInfo->sAecVBox.bEnable != 0) { + if ((psAECInfo->sAecVBox.bFdsp_Po_Source != 0xFF) + && (psAECInfo->sAecVBox.bFdsp_Po_Source != + sCurAECInfo.sAecVBox.bFdsp_Po_Source)) { + bRet = 0; + goto exit; + } + if ((psAECInfo->sAecVBox.bISrc2_VSource != 0xFF) + && (psAECInfo->sAecVBox.bISrc2_VSource != + sCurAECInfo.sAecVBox.bISrc2_VSource)) { + bRet = 0; + goto exit; + } + if ((psAECInfo->sAecVBox.bISrc2_Ch1_VSource != 0xFF) + && (psAECInfo->sAecVBox.bISrc2_Ch1_VSource != + sCurAECInfo.sAecVBox.bISrc2_Ch1_VSource)) { + bRet = 0; + goto exit; + } + if ((psAECInfo->sAecVBox.bISrc3_VSource != 0xFF) + && (psAECInfo->sAecVBox.bISrc3_VSource != + sCurAECInfo.sAecVBox.bISrc3_VSource)) { + bRet = 0; + goto exit; + } + if ((psAECInfo->sAecVBox.bLPt2_VSource != 0xFF) + && (psAECInfo->sAecVBox.bLPt2_VSource != + sCurAECInfo.sAecVBox.bLPt2_VSource)) { + bRet = 0; + goto exit; + } + } + + if (bCdspUsed != 0) + if (psAECInfo->sAecVBox.bEnable != 0) { + if ((psAECInfo->sAecVBox.bSrc3_Ctrl != 0xFF) + && (psAECInfo->sAecVBox.bSrc3_Ctrl != + sCurAECInfo.sAecVBox.bSrc3_Ctrl)) { + bRet = 0; + goto exit; + } + if ((psAECInfo->sAecVBox.bSrc2_Fs != 0xFF) + && (psAECInfo->sAecVBox.bSrc2_Fs != + sCurAECInfo.sAecVBox.bSrc2_Fs)) { + bRet = 0; + goto exit; + } + if ((psAECInfo->sAecVBox.bSrc2_Thru != 0xFF) + && (psAECInfo->sAecVBox.bSrc2_Thru != + sCurAECInfo.sAecVBox.bSrc2_Thru)) { + bRet = 0; + goto exit; + } + if ((psAECInfo->sAecVBox.bSrc3_Fs != 0xFF) + && (psAECInfo->sAecVBox.bSrc3_Fs != + sCurAECInfo.sAecVBox.bSrc3_Fs)) { + bRet = 0; + goto exit; + } + if ((psAECInfo->sAecVBox.bSrc3_Thru != 0xFF) + && (psAECInfo->sAecVBox.bSrc3_Thru != + sCurAECInfo.sAecVBox.bSrc3_Thru)) { + bRet = 0; + goto exit; + } + } + + if (psAECInfo->sControl.bCommand == 1) { + if ((psAECInfo->sControl.bParam[0] != 0) + && (psAECInfo->sControl.bParam[0] != 1)) { + bRet = 0; + goto exit; + } + } else if (psAECInfo->sControl.bCommand == 2) { + if ((psAECInfo->sControl.bParam[0] != 0) + && (psAECInfo->sControl.bParam[0] != 1)) { + bRet = 0; + goto exit; + } + } else if (psAECInfo->sControl.bCommand == 3) { + if ((psAECInfo->sControl.bParam[0] != 0) + && (psAECInfo->sControl.bParam[0] != 1) + && (psAECInfo->sControl.bParam[0] != 2)) { + bRet = 0; + goto exit; + } + } else if (psAECInfo->sControl.bCommand == 4) { + if ((psAECInfo->sControl.bParam[0] != 0) + && (psAECInfo->sControl.bParam[0] != 1) + && (psAECInfo->sControl.bParam[0] != 3)) { + bRet = 0; + goto exit; + } + } else if (psAECInfo->sControl.bCommand == 5) { + if ((psAECInfo->sControl.bParam[0] > 6) + && (psAECInfo->sControl.bParam[0] < 0xFF)) { + bRet = 0; + goto exit; + } + if ((psAECInfo->sControl.bParam[1] > 3) + && (psAECInfo->sControl.bParam[1] < 0xFF)) { + bRet = 0; + goto exit; + } + } + +exit: +#if (MCDRV_DEBUG_LEVEL >= 4) + sdRet = bRet; + McDebugLog_FuncOut("IsValidDspParam", &sdRet); +#endif + return bRet; +} + +/**************************************************************************** + * IsValidHSDetParam + * + * Description: + * validate HSDet parameters. + * Arguments: + * psHSDetInfo HSDet information + * psHSDet2Info HSDet2 information + * dUpdateInfo update information + * Return: + * 0:Invalid + * other:Valid + * + ****************************************************************************/ +static UINT8 IsValidHSDetParam +( + const struct MCDRV_HSDET_INFO *psHSDetInfo, + const struct MCDRV_HSDET2_INFO *psHSDet2Info, + UINT32 dUpdateInfo +) +{ + UINT8 bRet = 1; + struct MCDRV_HSDET_INFO sHSDetInfo; + +#if (MCDRV_DEBUG_LEVEL >= 4) + SINT32 sdRet; + McDebugLog_FuncIn("IsValidHSDetParam"); +#endif + + + McResCtrl_GetHSDet(&sHSDetInfo, NULL); + + if ((dUpdateInfo & MCDRV_ENPLUGDET_UPDATE_FLAG) != 0UL) { + if ((psHSDetInfo->bEnPlugDet != MCDRV_PLUGDET_DISABLE) + && (psHSDetInfo->bEnPlugDet != MCDRV_PLUGDET_ENABLE)) + bRet = 0; + } + if ((dUpdateInfo & MCDRV_ENPLUGDET_UPDATE_FLAG) != 0UL) { + if ((psHSDetInfo->bEnPlugDetDb != MCDRV_PLUGDETDB_DISABLE) + && (psHSDetInfo->bEnPlugDetDb != MCDRV_PLUGDETDB_DET_ENABLE) + && (psHSDetInfo->bEnPlugDetDb != MCDRV_PLUGDETDB_UNDET_ENABLE) + && (psHSDetInfo->bEnPlugDetDb != MCDRV_PLUGDETDB_BOTH_ENABLE)) + bRet = 0; + } + if ((dUpdateInfo & MCDRV_ENDLYKEYOFF_UPDATE_FLAG) != 0UL) { + if ((psHSDetInfo->bEnDlyKeyOff != MCDRV_KEYEN_D_D_D) + && (psHSDetInfo->bEnDlyKeyOff != MCDRV_KEYEN_D_D_E) + && (psHSDetInfo->bEnDlyKeyOff != MCDRV_KEYEN_D_E_D) + && (psHSDetInfo->bEnDlyKeyOff != MCDRV_KEYEN_D_E_E) + && (psHSDetInfo->bEnDlyKeyOff != MCDRV_KEYEN_E_D_D) + && (psHSDetInfo->bEnDlyKeyOff != MCDRV_KEYEN_E_D_E) + && (psHSDetInfo->bEnDlyKeyOff != MCDRV_KEYEN_E_E_D) + && (psHSDetInfo->bEnDlyKeyOff != MCDRV_KEYEN_E_E_E)) + bRet = 0; + } + if ((dUpdateInfo & MCDRV_ENDLYKEYON_UPDATE_FLAG) != 0UL) { + if ((psHSDetInfo->bEnDlyKeyOn != MCDRV_KEYEN_D_D_D) + && (psHSDetInfo->bEnDlyKeyOn != MCDRV_KEYEN_D_D_E) + && (psHSDetInfo->bEnDlyKeyOn != MCDRV_KEYEN_D_E_D) + && (psHSDetInfo->bEnDlyKeyOn != MCDRV_KEYEN_D_E_E) + && (psHSDetInfo->bEnDlyKeyOn != MCDRV_KEYEN_E_D_D) + && (psHSDetInfo->bEnDlyKeyOn != MCDRV_KEYEN_E_D_E) + && (psHSDetInfo->bEnDlyKeyOn != MCDRV_KEYEN_E_E_D) + && (psHSDetInfo->bEnDlyKeyOn != MCDRV_KEYEN_E_E_E)) + bRet = 0; + } + if ((dUpdateInfo & MCDRV_ENMICDET_UPDATE_FLAG) != 0UL) { + if ((psHSDetInfo->bEnMicDet != MCDRV_MICDET_DISABLE) + && (psHSDetInfo->bEnMicDet != MCDRV_MICDET_ENABLE)) + bRet = 0; + } + if ((dUpdateInfo & MCDRV_ENKEYOFF_UPDATE_FLAG) != 0UL) { + if ((psHSDetInfo->bEnKeyOff != MCDRV_KEYEN_D_D_D) + && (psHSDetInfo->bEnKeyOff != MCDRV_KEYEN_D_D_E) + && (psHSDetInfo->bEnKeyOff != MCDRV_KEYEN_D_E_D) + && (psHSDetInfo->bEnKeyOff != MCDRV_KEYEN_D_E_E) + && (psHSDetInfo->bEnKeyOff != MCDRV_KEYEN_E_D_D) + && (psHSDetInfo->bEnKeyOff != MCDRV_KEYEN_E_D_E) + && (psHSDetInfo->bEnKeyOff != MCDRV_KEYEN_E_E_D) + && (psHSDetInfo->bEnKeyOff != MCDRV_KEYEN_E_E_E)) + bRet = 0; + } + if ((dUpdateInfo & MCDRV_ENKEYON_UPDATE_FLAG) != 0UL) { + if ((psHSDetInfo->bEnKeyOn != MCDRV_KEYEN_D_D_D) + && (psHSDetInfo->bEnKeyOn != MCDRV_KEYEN_D_D_E) + && (psHSDetInfo->bEnKeyOn != MCDRV_KEYEN_D_E_D) + && (psHSDetInfo->bEnKeyOn != MCDRV_KEYEN_D_E_E) + && (psHSDetInfo->bEnKeyOn != MCDRV_KEYEN_E_D_D) + && (psHSDetInfo->bEnKeyOn != MCDRV_KEYEN_E_D_E) + && (psHSDetInfo->bEnKeyOn != MCDRV_KEYEN_E_E_D) + && (psHSDetInfo->bEnKeyOn != MCDRV_KEYEN_E_E_E)) + bRet = 0; + } + if ((dUpdateInfo & MCDRV_HSDETDBNC_UPDATE_FLAG) != 0UL) { + if ((psHSDetInfo->bHsDetDbnc != MCDRV_DETDBNC_27) + && (psHSDetInfo->bHsDetDbnc != MCDRV_DETDBNC_55) + && (psHSDetInfo->bHsDetDbnc != MCDRV_DETDBNC_109) + && (psHSDetInfo->bHsDetDbnc != MCDRV_DETDBNC_219) + && (psHSDetInfo->bHsDetDbnc != MCDRV_DETDBNC_438) + && (psHSDetInfo->bHsDetDbnc != MCDRV_DETDBNC_875) + && (psHSDetInfo->bHsDetDbnc != MCDRV_DETDBNC_1313) + && (psHSDetInfo->bHsDetDbnc != MCDRV_DETDBNC_1750)) + bRet = 0; + } + + if ((dUpdateInfo & MCDRV_KEYOFFMTIM_UPDATE_FLAG) != 0UL) { + if ((psHSDetInfo->bKeyOffMtim == MCDRV_KEYOFF_MTIM_63) + || (psHSDetInfo->bKeyOffMtim == MCDRV_KEYOFF_MTIM_16)) + sHSDetInfo.bKeyOffMtim = psHSDetInfo->bKeyOffMtim; + else + bRet = 0; + } + if ((dUpdateInfo & MCDRV_KEYONMTIM_UPDATE_FLAG) != 0UL) { + if ((psHSDetInfo->bKeyOnMtim == MCDRV_KEYON_MTIM_63) + || (psHSDetInfo->bKeyOnMtim == MCDRV_KEYON_MTIM_250)) + sHSDetInfo.bKeyOnMtim = psHSDetInfo->bKeyOnMtim; + else + bRet = 0; + } + if ((dUpdateInfo & MCDRV_KEY0OFFDLYTIM_UPDATE_FLAG) != 0UL) { + if (psHSDetInfo->bKey0OffDlyTim > MC_DRV_KEYOFFDLYTIM_MAX) + bRet = 0; + else if (sHSDetInfo.bKeyOffMtim == MCDRV_KEYOFF_MTIM_63) { + if (psHSDetInfo->bKey0OffDlyTim == 1) + bRet = 0; + } + } + if ((dUpdateInfo & MCDRV_KEY1OFFDLYTIM_UPDATE_FLAG) != 0UL) { + if (psHSDetInfo->bKey1OffDlyTim > MC_DRV_KEYOFFDLYTIM_MAX) + bRet = 0; + else if (sHSDetInfo.bKeyOffMtim == MCDRV_KEYOFF_MTIM_63) { + if (psHSDetInfo->bKey1OffDlyTim == 1) + bRet = 0; + } + } + if ((dUpdateInfo & MCDRV_KEY2OFFDLYTIM_UPDATE_FLAG) != 0UL) { + if (psHSDetInfo->bKey2OffDlyTim > MC_DRV_KEYOFFDLYTIM_MAX) + bRet = 0; + else if (sHSDetInfo.bKeyOffMtim == MCDRV_KEYOFF_MTIM_63) { + if (psHSDetInfo->bKey2OffDlyTim == 1) + bRet = 0; + } + } + if ((dUpdateInfo & MCDRV_KEY0ONDLYTIM_UPDATE_FLAG) != 0UL) { + if (psHSDetInfo->bKey0OnDlyTim > MC_DRV_KEYONDLYTIM_MAX) + bRet = 0; + else if (sHSDetInfo.bKeyOnMtim == MCDRV_KEYON_MTIM_250) { + if ((psHSDetInfo->bKey0OnDlyTim == 1) + || (psHSDetInfo->bKey0OnDlyTim == 2) + || (psHSDetInfo->bKey0OnDlyTim == 3)) + bRet = 0; + } + } + if ((dUpdateInfo & MCDRV_KEY1ONDLYTIM_UPDATE_FLAG) != 0UL) { + if (psHSDetInfo->bKey1OnDlyTim > MC_DRV_KEYONDLYTIM_MAX) + bRet = 0; + else if (sHSDetInfo.bKeyOnMtim == MCDRV_KEYON_MTIM_250) { + if ((psHSDetInfo->bKey1OnDlyTim == 1) + || (psHSDetInfo->bKey1OnDlyTim == 2) + || (psHSDetInfo->bKey1OnDlyTim == 3)) + bRet = 0; + } + } + if ((dUpdateInfo & MCDRV_KEY2ONDLYTIM_UPDATE_FLAG) != 0UL) { + if (psHSDetInfo->bKey2OnDlyTim > MC_DRV_KEYONDLYTIM_MAX) + bRet = 0; + else if (sHSDetInfo.bKeyOnMtim == MCDRV_KEYON_MTIM_250) { + if ((psHSDetInfo->bKey2OnDlyTim == 1) + || (psHSDetInfo->bKey2OnDlyTim == 2) + || (psHSDetInfo->bKey2OnDlyTim == 3)) + bRet = 0; + } + } + if ((dUpdateInfo & MCDRV_KEY0ONDLYTIM2_UPDATE_FLAG) != 0UL) { + if (psHSDetInfo->bKey0OnDlyTim2 > MC_DRV_KEYONDLYTIM2_MAX) + bRet = 0; + else if (sHSDetInfo.bKeyOnMtim == MCDRV_KEYON_MTIM_250) { + if ((psHSDetInfo->bKey0OnDlyTim2 == 1) + || (psHSDetInfo->bKey0OnDlyTim2 == 2) + || (psHSDetInfo->bKey0OnDlyTim2 == 3)) + bRet = 0; + } + } + if ((dUpdateInfo & MCDRV_KEY1ONDLYTIM2_UPDATE_FLAG) != 0UL) { + if (psHSDetInfo->bKey1OnDlyTim2 > MC_DRV_KEYONDLYTIM2_MAX) + bRet = 0; + else if (sHSDetInfo.bKeyOnMtim == MCDRV_KEYON_MTIM_250) { + if ((psHSDetInfo->bKey1OnDlyTim2 == 1) + || (psHSDetInfo->bKey1OnDlyTim2 == 2) + || (psHSDetInfo->bKey1OnDlyTim2 == 3)) + bRet = 0; + } + } + if ((dUpdateInfo & MCDRV_KEY2ONDLYTIM2_UPDATE_FLAG) != 0UL) { + if (psHSDetInfo->bKey2OnDlyTim2 > MC_DRV_KEYONDLYTIM2_MAX) + bRet = 0; + else if (sHSDetInfo.bKeyOnMtim == MCDRV_KEYON_MTIM_250) { + if ((psHSDetInfo->bKey2OnDlyTim2 == 1) + || (psHSDetInfo->bKey2OnDlyTim2 == 2) + || (psHSDetInfo->bKey2OnDlyTim2 == 3)) + bRet = 0; + } + } + + if ((dUpdateInfo & MCDRV_IRQTYPE_UPDATE_FLAG) != 0UL) { + if ((psHSDetInfo->bIrqType != MCDRV_IRQTYPE_NORMAL) + && (psHSDetInfo->bIrqType != MCDRV_IRQTYPE_REF) + && (psHSDetInfo->bIrqType != MCDRV_IRQTYPE_EX)) { + bRet = 0; + goto exit; + } else if (psHSDetInfo->bIrqType == MCDRV_IRQTYPE_EX) { + if (psHSDet2Info != NULL) { + if ((psHSDet2Info->bPlugDetDbIrqType != + MCDRV_IRQTYPE_NORMAL) + && (psHSDet2Info->bPlugDetDbIrqType != + MCDRV_IRQTYPE_REF)) { + bRet = 0; + goto exit; + } + if ((psHSDet2Info->bPlugUndetDbIrqType != + MCDRV_IRQTYPE_NORMAL) + && (psHSDet2Info->bPlugUndetDbIrqType != + MCDRV_IRQTYPE_REF)) { + bRet = 0; + goto exit; + } + if ((psHSDet2Info->bMicDetIrqType != + MCDRV_IRQTYPE_NORMAL) + && (psHSDet2Info->bMicDetIrqType != + MCDRV_IRQTYPE_REF)) { + bRet = 0; + goto exit; + } + if ((psHSDet2Info->bPlugDetIrqType != + MCDRV_IRQTYPE_NORMAL) + && (psHSDet2Info->bPlugDetIrqType != + MCDRV_IRQTYPE_REF)) { + bRet = 0; + goto exit; + } + if ((psHSDet2Info->bKey0OnIrqType != + MCDRV_IRQTYPE_NORMAL) + && (psHSDet2Info->bKey0OnIrqType != + MCDRV_IRQTYPE_REF)) { + bRet = 0; + goto exit; + } + if ((psHSDet2Info->bKey1OnIrqType != + MCDRV_IRQTYPE_NORMAL) + && (psHSDet2Info->bKey1OnIrqType != + MCDRV_IRQTYPE_REF)) { + bRet = 0; + goto exit; + } + if ((psHSDet2Info->bKey2OnIrqType != + MCDRV_IRQTYPE_NORMAL) + && (psHSDet2Info->bKey2OnIrqType != + MCDRV_IRQTYPE_REF)) { + bRet = 0; + goto exit; + } + if ((psHSDet2Info->bKey0OffIrqType != + MCDRV_IRQTYPE_NORMAL) + && (psHSDet2Info->bKey0OffIrqType != + MCDRV_IRQTYPE_REF)) { + bRet = 0; + goto exit; + } + if ((psHSDet2Info->bKey1OffIrqType != + MCDRV_IRQTYPE_NORMAL) + && (psHSDet2Info->bKey1OffIrqType != + MCDRV_IRQTYPE_REF)) { + bRet = 0; + goto exit; + } + if ((psHSDet2Info->bKey2OffIrqType != + MCDRV_IRQTYPE_NORMAL) + && (psHSDet2Info->bKey2OffIrqType != + MCDRV_IRQTYPE_REF)) { + bRet = 0; + goto exit; + } + } + } + } + if ((dUpdateInfo & MCDRV_DETINV_UPDATE_FLAG) != 0UL) { + if ((psHSDetInfo->bDetInInv != MCDRV_DET_IN_NORMAL) + && (psHSDetInfo->bDetInInv != MCDRV_DET_IN_INV) + && (psHSDetInfo->bDetInInv != + MCDRV_DET_IN_NORMAL_NORMAL) + && (psHSDetInfo->bDetInInv != MCDRV_DET_IN_INV_NORMAL) + && (psHSDetInfo->bDetInInv != MCDRV_DET_IN_NORMAL_INV) + && (psHSDetInfo->bDetInInv != MCDRV_DET_IN_INV_INV)) + bRet = 0; + } + + if ((dUpdateInfo & MCDRV_HSDETMODE_UPDATE_FLAG) != 0UL) { + if ((psHSDetInfo->bHsDetMode != MCDRV_HSDET_MODE_DETIN_A) + && (psHSDetInfo->bHsDetMode != MCDRV_HSDET_MODE_DETIN_B)) + bRet = 0; + } + if ((dUpdateInfo & MCDRV_SPERIOD_UPDATE_FLAG) != 0UL) { + if ((psHSDetInfo->bSperiod != MCDRV_SPERIOD_244) + && (psHSDetInfo->bSperiod != MCDRV_SPERIOD_488) + && (psHSDetInfo->bSperiod != MCDRV_SPERIOD_977) + && (psHSDetInfo->bSperiod != MCDRV_SPERIOD_1953) + && (psHSDetInfo->bSperiod != MCDRV_SPERIOD_3906) + && (psHSDetInfo->bSperiod != MCDRV_SPERIOD_7813) + && (psHSDetInfo->bSperiod != MCDRV_SPERIOD_15625) + && (psHSDetInfo->bSperiod != MCDRV_SPERIOD_31250)) + bRet = 0; + } + if ((dUpdateInfo & MCDRV_LPERIOD_UPDATE_FLAG) != 0UL) { + if ((psHSDetInfo->bLperiod != MCDRV_LPERIOD_3906) + && (psHSDetInfo->bLperiod != MCDRV_LPERIOD_62500) + && (psHSDetInfo->bLperiod != MCDRV_LPERIOD_125000) + && (psHSDetInfo->bLperiod != MCDRV_LPERIOD_250000)) + bRet = 0; + } + if ((dUpdateInfo & MCDRV_DBNCNUMPLUG_UPDATE_FLAG) != 0UL) { + if ((psHSDetInfo->bDbncNumPlug != MCDRV_DBNC_NUM_2) + && (psHSDetInfo->bDbncNumPlug != MCDRV_DBNC_NUM_3) + && (psHSDetInfo->bDbncNumPlug != MCDRV_DBNC_NUM_4) + && (psHSDetInfo->bDbncNumPlug != MCDRV_DBNC_NUM_7)) + bRet = 0; + } + if ((dUpdateInfo & MCDRV_DBNCNUMMIC_UPDATE_FLAG) != 0UL) { + if ((psHSDetInfo->bDbncNumMic != MCDRV_DBNC_NUM_2) + && (psHSDetInfo->bDbncNumMic != MCDRV_DBNC_NUM_3) + && (psHSDetInfo->bDbncNumMic != MCDRV_DBNC_NUM_4) + && (psHSDetInfo->bDbncNumMic != MCDRV_DBNC_NUM_7)) + bRet = 0; + } + if ((dUpdateInfo & MCDRV_DBNCNUMKEY_UPDATE_FLAG) != 0UL) { + if ((psHSDetInfo->bDbncNumKey != MCDRV_DBNC_NUM_2) + && (psHSDetInfo->bDbncNumKey != MCDRV_DBNC_NUM_3) + && (psHSDetInfo->bDbncNumKey != MCDRV_DBNC_NUM_4) + && (psHSDetInfo->bDbncNumKey != MCDRV_DBNC_NUM_7)) + bRet = 0; + } + + if ((dUpdateInfo & MCDRV_SGNL_UPDATE_FLAG) != 0UL) { + if ((psHSDetInfo->bSgnlPeriod != MCDRV_SGNLPERIOD_61) + && (psHSDetInfo->bSgnlPeriod != MCDRV_SGNLPERIOD_79) + && (psHSDetInfo->bSgnlPeriod != MCDRV_SGNLPERIOD_97) + && (psHSDetInfo->bSgnlPeriod != MCDRV_SGNLPERIOD_151)) + bRet = 0; + if ((psHSDetInfo->bSgnlNum != MCDRV_SGNLNUM_1) + && (psHSDetInfo->bSgnlNum != MCDRV_SGNLNUM_4) + && (psHSDetInfo->bSgnlNum != MCDRV_SGNLNUM_6) + && (psHSDetInfo->bSgnlNum != MCDRV_SGNLNUM_8) + && (psHSDetInfo->bSgnlNum != MCDRV_SGNLNUM_NONE)) + bRet = 0; + if ((psHSDetInfo->bSgnlPeak != MCDRV_SGNLPEAK_500) + && (psHSDetInfo->bSgnlPeak != MCDRV_SGNLPEAK_730) + && (psHSDetInfo->bSgnlPeak != MCDRV_SGNLPEAK_960) + && (psHSDetInfo->bSgnlPeak != MCDRV_SGNLPEAK_1182)) + bRet = 0; + } + if ((dUpdateInfo & MCDRV_IMPSEL_UPDATE_FLAG) != 0UL) { + if ((psHSDetInfo->bImpSel != 0) + && (psHSDetInfo->bImpSel != 1)) + bRet = 0; + } + + if ((dUpdateInfo & MCDRV_DLYIRQSTOP_UPDATE_FLAG) != 0UL) { + if ((psHSDetInfo->bDlyIrqStop != MCDRV_DLYIRQ_DONTCARE) + && (psHSDetInfo->bDlyIrqStop != MCDRV_DLYIRQ_STOP)) + bRet = 0; + } + +exit: +#if (MCDRV_DEBUG_LEVEL >= 4) + sdRet = bRet; + McDebugLog_FuncOut("IsValidHSDetParam", &sdRet); +#endif + return bRet; +} + +/**************************************************************************** + * IsValidGpParam + * + * Description: + * validate GP parameters. + * Arguments: + * psGpInfo GP information + * Return: + * 0:Invalid + * other:Valid + * + ****************************************************************************/ +static UINT8 IsValidGpParam +( + const struct MCDRV_GP_MODE *psGpMode +) +{ + UINT8 bRet = 1; + UINT8 bPad; + struct MCDRV_INIT_INFO sInitInfo; + +#if (MCDRV_DEBUG_LEVEL >= 4) + SINT32 sdRet; + McDebugLog_FuncIn("IsValidGpParam"); +#endif + + McResCtrl_GetInitInfo(&sInitInfo, NULL); + + for (bPad = 0; (bPad < 3) && (bRet == 1); bPad++) { + if (((bPad == 0) && (sInitInfo.bPa0Func != MCDRV_PA_GPIO)) + || ((bPad == 1) && (sInitInfo.bPa1Func != MCDRV_PA_GPIO)) + || ((bPad == 2) && (sInitInfo.bPa2Func != MCDRV_PA_GPIO))) + continue; + if ((psGpMode->abGpDdr[bPad] != MCDRV_GPDDR_IN) + && (psGpMode->abGpDdr[bPad] != MCDRV_GPDDR_OUT)) { + bRet = 0; + continue; + } + if ((psGpMode->abGpHost[bPad] != MCDRV_GPHOST_CPU) + && (psGpMode->abGpHost[bPad] != MCDRV_GPHOST_CDSP)) { + bRet = 0; + continue; + } + if ((psGpMode->abGpInvert[bPad] != MCDRV_GPINV_NORMAL) + && (psGpMode->abGpInvert[bPad] != MCDRV_GPINV_INVERT)) + bRet = 0; + } + +#if (MCDRV_DEBUG_LEVEL >= 4) + sdRet = bRet; + McDebugLog_FuncOut("IsValidGpParam", &sdRet); +#endif + return bRet; +} + +/**************************************************************************** + * IsValidMaskGp + * + * Description: + * validate GP parameters. + * Arguments: + * bMask MaskGP information + * dPadNo PAD number + * Return: + * 0:Invalid + * other:Valid + * + ****************************************************************************/ +static UINT8 IsValidMaskGp +( + UINT8 bMask, + UINT32 dPadNo +) +{ + UINT8 bRet = 1; + struct MCDRV_INIT_INFO sInitInfo; + struct MCDRV_GP_MODE sGPMode; + +#if (MCDRV_DEBUG_LEVEL >= 4) + SINT32 sdRet = MCDRV_SUCCESS; + McDebugLog_FuncIn("IsValidMaskGp"); +#endif + + McResCtrl_GetInitInfo(&sInitInfo, NULL); + McResCtrl_GetGPMode(&sGPMode); + + if ((dPadNo != 0) + && (dPadNo != 1) + && (dPadNo != 2)) + bRet = 0; + else if (((dPadNo == 0) && (sInitInfo.bPa0Func != MCDRV_PA_GPIO)) + || ((dPadNo == 1) && (sInitInfo.bPa1Func != MCDRV_PA_GPIO)) + || ((dPadNo == 2) && (sInitInfo.bPa2Func != MCDRV_PA_GPIO))) { + ; + } else { + if (sGPMode.abGpDdr[dPadNo] == MCDRV_GPDDR_OUT) + bRet = 0; + if ((bMask != MCDRV_GPMASK_ON) && (bMask != MCDRV_GPMASK_OFF)) + bRet = 0; + } + +#if (MCDRV_DEBUG_LEVEL >= 4) + sdRet = bRet; + McDebugLog_FuncOut("IsValidMaskGp", &sdRet); +#endif + return bRet; +} + +/**************************************************************************** + * CheckDIOCommon + * + * Description: + * check Digital IO Common parameters. + * Arguments: + * psDioInfo digital IO information + * bPort port number + * Return: + * 0:error + * other:no error + * + ****************************************************************************/ +static UINT8 CheckDIOCommon +( + const struct MCDRV_DIO_INFO *psDioInfo, + UINT8 bPort +) +{ + UINT8 bRet = 1; + +#if (MCDRV_DEBUG_LEVEL >= 4) + SINT32 sdRet = MCDRV_SUCCESS; + McDebugLog_FuncIn("CheckDIOCommon"); +#endif + + + if (bPort == 3) { + if ((psDioInfo->asPortInfo[bPort].sDioCommon.bFs + != MCDRV_FS_48000) + && (psDioInfo->asPortInfo[bPort].sDioCommon.bFs + != MCDRV_FS_192000) + && (psDioInfo->asPortInfo[bPort].sDioCommon.bFs + != MCDRV_FS_96000)) + bRet = 0; + else if ((psDioInfo->asPortInfo[bPort].sDioCommon.bBckFs + != MCDRV_BCKFS_64) + && (psDioInfo->asPortInfo[bPort].sDioCommon.bBckFs + != MCDRV_BCKFS_48) + && (psDioInfo->asPortInfo[bPort].sDioCommon.bBckFs + != MCDRV_BCKFS_32)) + bRet = 0; + else if ((psDioInfo->asPortInfo[bPort].sDioCommon.bBckInvert + != MCDRV_BCLK_NORMAL) + && (psDioInfo->asPortInfo[bPort].sDioCommon.bBckInvert + != MCDRV_BCLK_INVERT)) + bRet = 0; + goto exit; + } + + if ((psDioInfo->asPortInfo[bPort].sDioCommon.bMasterSlave + != MCDRV_DIO_SLAVE) + && (psDioInfo->asPortInfo[bPort].sDioCommon.bMasterSlave + != MCDRV_DIO_MASTER)) + bRet = 0; + else if ((psDioInfo->asPortInfo[bPort].sDioCommon.bAutoFs + != MCDRV_AUTOFS_OFF) + && (psDioInfo->asPortInfo[bPort].sDioCommon.bAutoFs + != MCDRV_AUTOFS_ON)) + bRet = 0; + else if ((psDioInfo->asPortInfo[bPort].sDioCommon.bFs + != MCDRV_FS_48000) + && (psDioInfo->asPortInfo[bPort].sDioCommon.bFs + != MCDRV_FS_44100) + && (psDioInfo->asPortInfo[bPort].sDioCommon.bFs + != MCDRV_FS_32000) + && (psDioInfo->asPortInfo[bPort].sDioCommon.bFs + != MCDRV_FS_24000) + && (psDioInfo->asPortInfo[bPort].sDioCommon.bFs + != MCDRV_FS_22050) + && (psDioInfo->asPortInfo[bPort].sDioCommon.bFs + != MCDRV_FS_16000) + && (psDioInfo->asPortInfo[bPort].sDioCommon.bFs + != MCDRV_FS_12000) + && (psDioInfo->asPortInfo[bPort].sDioCommon.bFs + != MCDRV_FS_11025) + && (psDioInfo->asPortInfo[bPort].sDioCommon.bFs + != MCDRV_FS_8000) + && (psDioInfo->asPortInfo[bPort].sDioCommon.bFs + != MCDRV_FS_192000) + && (psDioInfo->asPortInfo[bPort].sDioCommon.bFs + != MCDRV_FS_96000)) + bRet = 0; + else if ((psDioInfo->asPortInfo[bPort].sDioCommon.bBckFs + != MCDRV_BCKFS_64) + && (psDioInfo->asPortInfo[bPort].sDioCommon.bBckFs + != MCDRV_BCKFS_48) + && (psDioInfo->asPortInfo[bPort].sDioCommon.bBckFs + != MCDRV_BCKFS_32) + && (psDioInfo->asPortInfo[bPort].sDioCommon.bBckFs + != MCDRV_BCKFS_512) + && (psDioInfo->asPortInfo[bPort].sDioCommon.bBckFs + != MCDRV_BCKFS_256) + && (psDioInfo->asPortInfo[bPort].sDioCommon.bBckFs + != MCDRV_BCKFS_192) + && (psDioInfo->asPortInfo[bPort].sDioCommon.bBckFs + != MCDRV_BCKFS_128) + && (psDioInfo->asPortInfo[bPort].sDioCommon.bBckFs + != MCDRV_BCKFS_96) + && (psDioInfo->asPortInfo[bPort].sDioCommon.bBckFs + != MCDRV_BCKFS_24) + && (psDioInfo->asPortInfo[bPort].sDioCommon.bBckFs + != MCDRV_BCKFS_16) + && (psDioInfo->asPortInfo[bPort].sDioCommon.bBckFs + != MCDRV_BCKFS_8) + && (psDioInfo->asPortInfo[bPort].sDioCommon.bBckFs + != MCDRV_BCKFS_SLAVE)) + bRet = 0; + else if ((psDioInfo->asPortInfo[bPort].sDioCommon.bInterface + != MCDRV_DIO_DA) + && (psDioInfo->asPortInfo[bPort].sDioCommon.bInterface + != MCDRV_DIO_PCM)) + bRet = 0; + else if ((psDioInfo->asPortInfo[bPort].sDioCommon.bBckInvert + != MCDRV_BCLK_NORMAL) + && (psDioInfo->asPortInfo[bPort].sDioCommon.bBckInvert + != MCDRV_BCLK_INVERT)) + bRet = 0; + else if ((psDioInfo->asPortInfo[bPort].sDioCommon.bSrcThru + != MCDRV_SRC_NOT_THRU) + && (psDioInfo->asPortInfo[bPort].sDioCommon.bSrcThru + != MCDRV_SRC_THRU)) { + if (McDevProf_GetDevId() == eMCDRV_DEV_ID_80_90H) { + ; + bRet = 0; + } + } else { + if ((psDioInfo->asPortInfo[bPort].sDioCommon.bPcmHizTim + != MCDRV_PCMHIZTIM_FALLING) + && (psDioInfo->asPortInfo[bPort].sDioCommon.bPcmHizTim + != MCDRV_PCMHIZTIM_RISING)) + bRet = 0; + else if ((psDioInfo->asPortInfo[bPort].sDioCommon.bPcmFrame + != MCDRV_PCM_SHORTFRAME) + && (psDioInfo->asPortInfo[bPort].sDioCommon.bPcmFrame + != MCDRV_PCM_LONGFRAME)) + bRet = 0; + else if (psDioInfo->asPortInfo[bPort].sDioCommon.bPcmHighPeriod + > 31) + bRet = 0; + } + + if (psDioInfo->asPortInfo[bPort].sDioCommon.bInterface + == MCDRV_DIO_PCM) { + if ((psDioInfo->asPortInfo[bPort].sDioCommon.bFs + != MCDRV_FS_8000) + && (psDioInfo->asPortInfo[bPort].sDioCommon.bFs + != MCDRV_FS_16000)) + bRet = 0; + + if (psDioInfo->asPortInfo[bPort].sDioCommon.bBckFs + == MCDRV_BCKFS_512) { + if (psDioInfo->asPortInfo[bPort].sDioCommon.bFs + != MCDRV_FS_8000) + bRet = 0; + } + if (psDioInfo->asPortInfo[bPort].sDioCommon.bBckFs + == MCDRV_BCKFS_256) { + if ((psDioInfo->asPortInfo[bPort].sDioCommon.bFs + != MCDRV_FS_8000) + && (psDioInfo->asPortInfo[bPort].sDioCommon.bFs + != MCDRV_FS_16000)) + bRet = 0; + } + if (psDioInfo->asPortInfo[bPort].sDioCommon.bMasterSlave + == MCDRV_DIO_MASTER) { + if (psDioInfo->asPortInfo[bPort].sDioCommon.bBckFs + == MCDRV_BCKFS_SLAVE) + bRet = 0; + } + } else { + if ((bPort == 0) + || (bPort == 1)) { + if ((psDioInfo->asPortInfo[bPort].sDioCommon.bFs + == MCDRV_FS_192000) + || (psDioInfo->asPortInfo[bPort].sDioCommon.bFs + == MCDRV_FS_96000)) + bRet = 0; + } + if ((psDioInfo->asPortInfo[bPort].sDioCommon.bBckFs + != MCDRV_BCKFS_64) + && (psDioInfo->asPortInfo[bPort].sDioCommon.bBckFs + != MCDRV_BCKFS_48) + && (psDioInfo->asPortInfo[bPort].sDioCommon.bBckFs + != MCDRV_BCKFS_32)) { + bRet = 0; + } + } + +exit: +#if (MCDRV_DEBUG_LEVEL >= 4) + sdRet = bRet; + McDebugLog_FuncOut("CheckDIOCommon", &sdRet); +#endif + return bRet; +} + +/**************************************************************************** + * CheckDaFormat + * + * Description: + * check sDaFormat parameters. + * Arguments: + * psDaFormat MCDRV_DA_FORMAT information + * Return: + * 0:error + * other:no error + * + ****************************************************************************/ +static UINT8 CheckDaFormat +( + const struct MCDRV_DA_FORMAT *psDaFormat +) +{ + UINT8 bRet = 1; + +#if (MCDRV_DEBUG_LEVEL >= 4) + SINT32 sdRet; + McDebugLog_FuncIn("CheckDaFormat"); +#endif + + + if ((psDaFormat->bBitSel != MCDRV_BITSEL_16) + && (psDaFormat->bBitSel != MCDRV_BITSEL_20) + && (psDaFormat->bBitSel != MCDRV_BITSEL_24) + && (psDaFormat->bBitSel != MCDRV_BITSEL_32)) { + bRet = 0; + } else if ((psDaFormat->bMode != MCDRV_DAMODE_HEADALIGN) + && (psDaFormat->bMode != MCDRV_DAMODE_I2S) + && (psDaFormat->bMode != MCDRV_DAMODE_TAILALIGN)) { + bRet = 0; + } + +#if (MCDRV_DEBUG_LEVEL >= 4) + sdRet = bRet; + McDebugLog_FuncOut("CheckDaFormat", &sdRet); +#endif + return bRet; +} + +/**************************************************************************** + * CheckPcmFormat + * + * Description: + * check sPcmFormat parameters. + * Arguments: + * psPcmFormat MCDRV_PCM_FORMAT information + * Return: + * 0:error + * other:no error + * + ****************************************************************************/ +static UINT8 CheckPcmFormat +( + const struct MCDRV_PCM_FORMAT *psPcmFormat +) +{ + UINT8 bRet = 1; + +#if (MCDRV_DEBUG_LEVEL >= 4) + SINT32 sdRet; + McDebugLog_FuncIn("CheckPcmFormat"); +#endif + + + if ((psPcmFormat->bMono != MCDRV_PCM_STEREO) + && (psPcmFormat->bMono != MCDRV_PCM_MONO)) { + ; + bRet = 0; + } else if ((psPcmFormat->bOrder != MCDRV_PCM_MSB_FIRST) + && (psPcmFormat->bOrder != MCDRV_PCM_LSB_FIRST)) { + ; + bRet = 0; + } else if ((psPcmFormat->bLaw != MCDRV_PCM_LINEAR) + && (psPcmFormat->bLaw != MCDRV_PCM_ALAW) + && (psPcmFormat->bLaw != MCDRV_PCM_MULAW)) { + ; + bRet = 0; + } else if ((psPcmFormat->bBitSel != MCDRV_PCM_BITSEL_8) + && (psPcmFormat->bBitSel != MCDRV_PCM_BITSEL_16) + && (psPcmFormat->bBitSel != MCDRV_PCM_BITSEL_24)) { + ; + bRet = 0; + } else { + if ((psPcmFormat->bLaw == MCDRV_PCM_ALAW) + || (psPcmFormat->bLaw == MCDRV_PCM_MULAW)) { + if (psPcmFormat->bBitSel != MCDRV_PCM_BITSEL_8) { + ; + bRet = 0; + } + } + } + +#if (MCDRV_DEBUG_LEVEL >= 4) + sdRet = bRet; + McDebugLog_FuncOut("CheckPcmFormat", &sdRet); +#endif + return bRet; +} + +/**************************************************************************** + * CheckDIODIR + * + * Description: + * validate Digital IO DIR parameters. + * Arguments: + * psDioInfo digital IO information + * bPort port number + * Return: + * 0:error + * other:no error + * + ****************************************************************************/ +static UINT8 CheckDIODIR +( + const struct MCDRV_DIO_INFO *psDioInfo, + UINT8 bPort +) +{ + UINT8 bRet = 1; + +#if (MCDRV_DEBUG_LEVEL >= 4) + SINT32 sdRet; + McDebugLog_FuncIn("CheckDIODIR"); +#endif + + + bRet = CheckPcmFormat( + &psDioInfo->asPortInfo[bPort].sDir.sPcmFormat); + if (bRet != 0) { + bRet = CheckDaFormat( + &psDioInfo->asPortInfo[bPort].sDir.sDaFormat); + if (psDioInfo->asPortInfo[bPort].sDir.sDaFormat.bBitSel + == MCDRV_BITSEL_32) + bRet = 0; + } + +#if (MCDRV_DEBUG_LEVEL >= 4) + sdRet = bRet; + McDebugLog_FuncOut("CheckDIODIR", &sdRet); +#endif + return bRet; +} + +/**************************************************************************** + * CheckDIODIT + * + * Description: + * validate Digital IO DIT parameters. + * Arguments: + * psDioInfo digital IO information + * bPort port number + * Return: + * 0:error + * other:no error + * + ****************************************************************************/ +static UINT8 CheckDIODIT +( + const struct MCDRV_DIO_INFO *psDioInfo, + UINT8 bPort +) +{ + UINT8 bRet = 1; + +#if (MCDRV_DEBUG_LEVEL >= 4) + SINT32 sdRet; + McDebugLog_FuncIn("CheckDIODIT"); +#endif + + + if ((psDioInfo->asPortInfo[bPort].sDit.bStMode != MCDRV_STMODE_ZERO) + && (psDioInfo->asPortInfo[bPort].sDit.bStMode != MCDRV_STMODE_HOLD)) + bRet = 0; + else if ((psDioInfo->asPortInfo[bPort].sDit.bEdge != MCDRV_SDOUT_NORMAL) + && (psDioInfo->asPortInfo[bPort].sDit.bEdge != MCDRV_SDOUT_AHEAD)) + bRet = 0; + else { + bRet = CheckPcmFormat( + &psDioInfo->asPortInfo[bPort].sDit.sPcmFormat); + if (bRet != 0) { + bRet = CheckDaFormat( + &psDioInfo->asPortInfo[bPort].sDit.sDaFormat); + if (psDioInfo->asPortInfo[bPort].sDit.sDaFormat.bBitSel + == MCDRV_BITSEL_32) + if (bPort != 2) + bRet = 0; + } + } + +#if (MCDRV_DEBUG_LEVEL >= 4) + sdRet = bRet; + McDebugLog_FuncOut("CheckDIODIT", &sdRet); +#endif + return bRet; +} + +/**************************************************************************** + * SetVol + * + * Description: + * set volume. + * Arguments: + * dUpdate target volume items + * eMode update mode + * pdSVolDoneParam wait soft volume complete flag + * Return: + * MCDRV_SUCCESS + * MCDRV_ERROR_RESOURCEOVER + * + ****************************************************************************/ +static SINT32 SetVol +( + UINT32 dUpdate, + enum MCDRV_VOLUPDATE_MODE eMode, + UINT32 *pdSVolDoneParam +) +{ + SINT32 sdRet = MCDRV_SUCCESS; + +#if (MCDRV_DEBUG_LEVEL >= 4) + McDebugLog_FuncIn("SetVol"); +#endif + + McPacket_AddVol(dUpdate, eMode, pdSVolDoneParam); + sdRet = McDevIf_ExecutePacket(); + +#if (MCDRV_DEBUG_LEVEL >= 4) + McDebugLog_FuncOut("SetVol", &sdRet); +#endif + + return sdRet; +} + +/**************************************************************************** + * GetMuteParam + * + * Description: + * Get mute complete flag. + * Arguments: + * pbDIRMuteParam wait DIR mute complete flag + * pbADCMuteParam wait ADC mute complete flag + * pbDITMuteParam wait DIT mute complete flag + * pbDACMuteParam wait DAC mute complete flag + * Return: + * none + * + ****************************************************************************/ +static void GetMuteParam +( + UINT8 *pbDIRMuteParam, + UINT8 *pbADCMuteParam, + UINT8 *pbDITMuteParam, + UINT8 *pbDACMuteParam +) +{ + UINT8 bVol; + +#if (MCDRV_DEBUG_LEVEL >= 4) + McDebugLog_FuncIn("GetMuteParam"); +#endif + + *pbDIRMuteParam = 0; + *pbADCMuteParam = 0; + *pbDITMuteParam = 0; + *pbDACMuteParam = 0; + + if (McResCtrl_IsD1SrcUsed(MCDRV_D1SRC_MUSICIN_ON) == 0) { + bVol = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_MA, + MCI_DIFI0_VOL0); + if ((bVol & (UINT8)~MCB_DIFI0_VSEP) != 0) + *pbDIRMuteParam |= MCB_DIFI0_VFLAG0; + bVol = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_MA, + MCI_DIFI0_VOL1); + if (bVol != 0) + *pbDIRMuteParam |= MCB_DIFI0_VFLAG1; + } + if (McResCtrl_IsD1SrcUsed(MCDRV_D1SRC_EXTIN_ON) == 0) { + bVol = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_MA, + MCI_DIFI1_VOL0); + if ((bVol & (UINT8)~MCB_DIFI1_VSEP) != 0) + *pbDIRMuteParam |= MCB_DIFI1_VFLAG0; + bVol = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_MA, + MCI_DIFI1_VOL1); + if (bVol != 0) + *pbDIRMuteParam |= MCB_DIFI1_VFLAG1; + } + if (McResCtrl_IsD1SrcUsed(MCDRV_D1SRC_VBOXOUT_ON) == 0) { + bVol = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_MA, + MCI_DIFI2_VOL0); + if ((bVol & (UINT8)~MCB_DIFI2_VSEP) != 0) + *pbDIRMuteParam |= MCB_DIFI2_VFLAG0; + bVol = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_MA, + MCI_DIFI2_VOL1); + if (bVol != 0) + *pbDIRMuteParam |= MCB_DIFI2_VFLAG1; + } + if (McResCtrl_IsD1SrcUsed(MCDRV_D1SRC_VBOXREFOUT_ON) == 0) { + bVol = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_MA, + MCI_DIFI3_VOL0); + if ((bVol & (UINT8)~MCB_DIFI3_VSEP) != 0) + *pbDIRMuteParam |= MCB_DIFI3_VFLAG0; + bVol = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_MA, + MCI_DIFI3_VOL1); + if (bVol != 0) + *pbDIRMuteParam |= MCB_DIFI3_VFLAG1; + } + if (McResCtrl_HasSrc(eMCDRV_DST_DAC0, eMCDRV_DST_CH0) == 0) { + bVol = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_MA, + MCI_DAO0_VOL0); + if ((bVol & (UINT8)~MCB_DAO0_VSEP) != 0) + *pbDACMuteParam |= MCB_DAO0_VFLAG0; + } + if (McResCtrl_HasSrc(eMCDRV_DST_DAC0, eMCDRV_DST_CH1) == 0) { + bVol = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_MA, + MCI_DAO0_VOL1); + if (bVol != 0) + *pbDACMuteParam |= MCB_DAO0_VFLAG1; + } + if (McResCtrl_HasSrc(eMCDRV_DST_DAC1, eMCDRV_DST_CH0) == 0) { + bVol = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_MA, + MCI_DAO1_VOL0); + if ((bVol & (UINT8)~MCB_DAO1_VSEP) != 0) + *pbDACMuteParam |= MCB_DAO1_VFLAG0; + } + if (McResCtrl_HasSrc(eMCDRV_DST_DAC1, eMCDRV_DST_CH1) == 0) { + bVol = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_MA, + MCI_DAO1_VOL1); + if (bVol != 0) + *pbDACMuteParam |= MCB_DAO1_VFLAG1; + } + + if (McResCtrl_HasSrc(eMCDRV_DST_MUSICOUT, eMCDRV_DST_CH0) == 0) { + bVol = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_MA, + MCI_DIFO0_VOL0); + if ((bVol & (UINT8)~MCB_DIFO0_VSEP) != 0) + *pbDITMuteParam |= MCB_DIFO0_VFLAG0; + } + if (McResCtrl_HasSrc(eMCDRV_DST_MUSICOUT, eMCDRV_DST_CH1) == 0) { + bVol = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_MA, + MCI_DIFO0_VOL1); + if (bVol != 0) + *pbDITMuteParam |= MCB_DIFO0_VFLAG1; + + } + if (McResCtrl_HasSrc(eMCDRV_DST_EXTOUT, eMCDRV_DST_CH0) == 0) { + bVol = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_MA, + MCI_DIFO1_VOL0); + if ((bVol & (UINT8)~MCB_DIFO1_VSEP) != 0) + *pbDITMuteParam |= MCB_DIFO1_VFLAG0; + } + if (McResCtrl_HasSrc(eMCDRV_DST_EXTOUT, eMCDRV_DST_CH1) == 0) { + bVol = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_MA, + MCI_DIFO1_VOL1); + if (bVol != 0) + *pbDITMuteParam |= MCB_DIFO1_VFLAG1; + } + + if (McResCtrl_HasSrc(eMCDRV_DST_VBOXMIXIN, eMCDRV_DST_CH0) == 0) { + bVol = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_MA, + MCI_DIFO2_VOL0); + if ((bVol & (UINT8)~MCB_DIFO2_VSEP) != 0) + *pbDITMuteParam |= MCB_DIFO2_VFLAG0; + } + if (McResCtrl_HasSrc(eMCDRV_DST_VBOXMIXIN, eMCDRV_DST_CH1) == 0) { + bVol = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_MA, + MCI_DIFO2_VOL1); + if (bVol != 0) + *pbDITMuteParam |= MCB_DIFO2_VFLAG1; + } + if (McResCtrl_HasSrc(eMCDRV_DST_VBOXMIXIN, eMCDRV_DST_CH2) == 0) { + bVol = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_MA, + MCI_DIFO3_VOL0); + if ((bVol & (UINT8)~MCB_DIFO2_VSEP) != 0) + *pbDITMuteParam |= MCB_DIFO3_VFLAG0; + } + if (McResCtrl_HasSrc(eMCDRV_DST_VBOXMIXIN, eMCDRV_DST_CH3) == 0) { + bVol = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_MA, + MCI_DIFO3_VOL1); + if (bVol != 0) + *pbDITMuteParam |= MCB_DIFO3_VFLAG1; + } + + if (McResCtrl_IsD1SrcUsed(MCDRV_D1SRC_ADIF0_ON) == 0) { + bVol = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_MA, + MCI_ADI0_VOL0); + if ((bVol & (UINT8)~MCB_ADI0_VSEP) != 0) + *pbADCMuteParam |= MCB_ADI0_VFLAG0; + bVol = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_MA, + MCI_ADI0_VOL1); + if (bVol != 0) + *pbADCMuteParam |= MCB_ADI0_VFLAG1; + } + if (McResCtrl_IsD1SrcUsed(MCDRV_D1SRC_ADIF1_ON) == 0) { + bVol = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_MA, + MCI_ADI1_VOL1); + if ((bVol & (UINT8)~MCB_ADI1_VSEP) != 0) + *pbADCMuteParam |= MCB_ADI1_VFLAG0; + bVol = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_MA, + MCI_ADI1_VOL1); + if (bVol != 0) + *pbADCMuteParam |= MCB_ADI1_VFLAG1; + } + if (McResCtrl_IsD1SrcUsed(MCDRV_D1SRC_ADIF2_ON) == 0) { + bVol = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_MA, + MCI_ADI2_VOL1); + if ((bVol & (UINT8)~MCB_ADI2_VSEP) != 0) + *pbADCMuteParam |= MCB_ADI2_VFLAG0; + bVol = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_MA, + MCI_ADI2_VOL1); + if (bVol != 0) + *pbADCMuteParam |= MCB_ADI2_VFLAG1; + } + +#if (MCDRV_DEBUG_LEVEL >= 4) + McDebugLog_FuncOut("GetMuteParam", NULL); +#endif +} + +/**************************************************************************** + * SavePower + * + * Description: + * Save power. + * Arguments: + * none + * Return: + * MCDRV_SUCCESS + * MCDRV_ERROR_RESOURCEOVER + * MCDRV_ERROR_TIMEOUT + * + ****************************************************************************/ +static SINT32 SavePower +( + void +) +{ + SINT32 sdRet = MCDRV_SUCCESS; + struct MCDRV_POWER_INFO sPowerInfo; + struct MCDRV_POWER_UPDATE sPowerUpdate; + +#if (MCDRV_DEBUG_LEVEL >= 4) + McDebugLog_FuncIn("SavePower"); +#endif + + /* unused path power down */ + McResCtrl_GetPowerInfo(&sPowerInfo); + sPowerUpdate.bDigital = MCDRV_POWUPDATE_D_ALL; + sPowerUpdate.abAnalog[0] = (UINT8)MCDRV_POWUPDATE_AP; + sPowerUpdate.abAnalog[1] = (UINT8)MCDRV_POWUPDATE_AP_OUT0; + sPowerUpdate.abAnalog[2] = (UINT8)MCDRV_POWUPDATE_AP_OUT1; + sPowerUpdate.abAnalog[3] = (UINT8)MCDRV_POWUPDATE_AP_MC; + sPowerUpdate.abAnalog[4] = (UINT8)MCDRV_POWUPDATE_AP_IN; + sdRet = McPacket_AddPowerDown(&sPowerInfo, &sPowerUpdate); + if (sdRet == MCDRV_SUCCESS) + sdRet = McDevIf_ExecutePacket(); + +#if (MCDRV_DEBUG_LEVEL >= 4) + McDebugLog_FuncOut("SavePower", &sdRet); +#endif + return sdRet; +} + +/**************************************************************************** + * McDrv_Ctrl + * + * Description: + * MC Driver I/F function. + * Arguments: + * dCmd command # + * pvPrm1 parameter1 + * pvPrm2 parameter2 + * dPrm update info + * Return: + * MCDRV_SUCCESS + * MCDRV_ERROR_ARGUMENT + * MCDRV_ERROR_RESOURCEOVER + * MCDRV_ERROR_STATE + * + ****************************************************************************/ +SINT32 McDrv_Ctrl( + UINT32 dCmd, + void *pvPrm1, + void *pvPrm2, + UINT32 dPrm +) +{ + SINT32 sdRet = MCDRV_ERROR; + UINT8 bAP; + +#if MCDRV_DEBUG_LEVEL + McDebugLog_CmdIn(dCmd, pvPrm1, pvPrm2, dPrm); +#endif + + (void)pvPrm2; + + if ((UINT32)MCDRV_INIT == dCmd) { + sdRet = init((struct MCDRV_INIT_INFO *)pvPrm1, + (struct MCDRV_INIT2_INFO *)pvPrm2); + } else if ((UINT32)MCDRV_TERM == dCmd) { + sdRet = term(); + } else if ((UINT32)MCDRV_IRQ == dCmd) { + sdRet = irq_proc(); + } else { + McSrv_Lock(); + + bAP = McResCtrl_GetRegVal(MCDRV_PACKET_REGTYPE_ANA, MCI_AP); + + switch (dCmd) { + case MCDRV_GET_CLOCKSW: + sdRet = get_clocksw( + (struct MCDRV_CLOCKSW_INFO *)pvPrm1); + break; + case MCDRV_SET_CLOCKSW: + sdRet = set_clocksw( + (struct MCDRV_CLOCKSW_INFO *)pvPrm1); + break; + + case MCDRV_GET_PATH: + sdRet = get_path((struct MCDRV_PATH_INFO *)pvPrm1); + break; + case MCDRV_SET_PATH: + if ((bAP&MCB_AP_LDOD) != 0) { + ; + machdep_PreLDODStart(); + } + sdRet = set_path((struct MCDRV_PATH_INFO *)pvPrm1); + if ((bAP&MCB_AP_LDOD) != 0) { + ; + machdep_PostLDODStart(); + } + break; + + case MCDRV_GET_VOLUME: + sdRet = get_volume((struct MCDRV_VOL_INFO *)pvPrm1); + break; + case MCDRV_SET_VOLUME: + sdRet = set_volume((struct MCDRV_VOL_INFO *)pvPrm1); + break; + + case MCDRV_GET_DIGITALIO: + sdRet = get_digitalio( + (struct MCDRV_DIO_INFO *)pvPrm1); + break; + case MCDRV_SET_DIGITALIO: + sdRet = set_digitalio( + (struct MCDRV_DIO_INFO *)pvPrm1, dPrm); + break; + + case MCDRV_GET_DIGITALIO_PATH: + sdRet = get_digitalio_path( + (struct MCDRV_DIOPATH_INFO *)pvPrm1); + break; + case MCDRV_SET_DIGITALIO_PATH: + sdRet = set_digitalio_path( + (struct MCDRV_DIOPATH_INFO *)pvPrm1, + dPrm); + break; + + case MCDRV_GET_SWAP: + sdRet = get_swap((struct MCDRV_SWAP_INFO *)pvPrm1); + break; + case MCDRV_SET_SWAP: + sdRet = set_swap((struct MCDRV_SWAP_INFO *)pvPrm1, + dPrm); + break; + + case MCDRV_SET_DSP: + if ((bAP&MCB_AP_LDOD) != 0) { + ; + machdep_PreLDODStart(); + } + sdRet = set_dsp((UINT8 *)pvPrm1, dPrm); + if ((bAP&MCB_AP_LDOD) != 0) { + ; + machdep_PostLDODStart(); + } + break; + case MCDRV_GET_DSP: + sdRet = get_dsp((struct MCDRV_DSP_PARAM *)pvPrm1, + pvPrm2, dPrm); + break; + case MCDRV_GET_DSP_DATA: + sdRet = get_dsp_data((UINT8 *)pvPrm1, dPrm); + break; + case MCDRV_SET_DSP_DATA: + sdRet = set_dsp_data((const UINT8 *)pvPrm1, dPrm); + break; + case MCDRV_REGISTER_DSP_CB: + sdRet = register_dsp_cb( + (SINT32 (*)(SINT32, UINT32, UINT32)) + pvPrm1); + break; + case MCDRV_GET_DSP_TRANSITION: + sdRet = get_dsp_transition(dPrm); + break; + + case MCDRV_GET_HSDET: + sdRet = get_hsdet((struct MCDRV_HSDET_INFO *)pvPrm1, + (struct MCDRV_HSDET2_INFO *)pvPrm2); + break; + case MCDRV_SET_HSDET: + if ((bAP&MCB_AP_LDOD) != 0) { + ; + machdep_PreLDODStart(); + } + sdRet = set_hsdet((struct MCDRV_HSDET_INFO *)pvPrm1, + (struct MCDRV_HSDET2_INFO *)pvPrm2, + dPrm); + if ((bAP&MCB_AP_LDOD) != 0) { + ; + machdep_PostLDODStart(); + } + break; + + case MCDRV_CONFIG_GP: + sdRet = config_gp((struct MCDRV_GP_MODE *)pvPrm1); + break; + case MCDRV_MASK_GP: + sdRet = mask_gp((UINT8 *)pvPrm1, dPrm); + break; + case MCDRV_GETSET_GP: + sdRet = getset_gp((UINT8 *)pvPrm1, dPrm); + break; + + case MCDRV_READ_REG: + if ((bAP&MCB_AP_LDOD) != 0) { + ; + machdep_PreLDODStart(); + } + sdRet = read_reg((struct MCDRV_REG_INFO *)pvPrm1); + if ((bAP&MCB_AP_LDOD) != 0) { + ; + machdep_PostLDODStart(); + } + break; + case MCDRV_WRITE_REG: + if ((bAP&MCB_AP_LDOD) != 0) { + ; + machdep_PreLDODStart(); + } + sdRet = write_reg((struct MCDRV_REG_INFO *)pvPrm1); + if ((bAP&MCB_AP_LDOD) != 0) { + ; + machdep_PostLDODStart(); + } + break; + + default: + break; + } + + McSrv_Unlock(); + } + +#if MCDRV_DEBUG_LEVEL + McDebugLog_CmdOut(dCmd, &sdRet, pvPrm1, pvPrm2, dPrm); +#endif +#if !defined(CONFIG_MACH_J_CHN_CTC) && !defined(CONFIG_MACH_J_CHN_CU) + if(sdRet < 0) { + printk("\n!!!McDrv_Ctrl failed\n\n"); + } +#endif + return sdRet; +} + |