static HI_S32 AI_ProcessCmd(struct file *file, HI_U32 cmd, HI_VOID *arg)
{
HI_S32 Ret = HI_SUCCESS;
HI_HANDLE hHandle = HI_INVALID_HANDLE;
switch(cmd)
{
case CMD_AI_GEtDEFAULTATTR:
{
AI_GetDfAttr_Param_S_PTR pstAiDfAttr = (AI_GetDfAttr_Param_S_PTR)arg;
Ret = AI_GetDefaultAttr(pstAiDfAttr->enAiPort, &pstAiDfAttr->stAttr);
break;
}
case CMD_AI_CREATE:
{
AI_Create_Param_S_PTR pstAi = (AI_Create_Param_S_PTR)arg;
if (HI_SUCCESS == AI_AllocHandle(&hHandle))
{
Ret = AI_Create(pstAi, hHandle, file);
if (HI_SUCCESS != Ret)
{
AI_FreeHandle(hHandle);
break;
}
pstAi->hAi = hHandle;
}
else
{
Ret = HI_FAILURE;
}
break;
}
case CMD_AI_DESTROY:
{
HI_HANDLE hAi = *(HI_HANDLE *)arg;
CHECK_AI_CHN_OPEN(hAi);
Ret = AI_Destory(hAi);
if (HI_SUCCESS != Ret)
{
break;
}
AI_FreeHandle(hAi);
break;
}
case CMD_AI_SETENABLE:
{
AI_Enable_Param_S_PTR pstAiEnable = (AI_Enable_Param_S_PTR)arg;
CHECK_AI_CHN_OPEN(pstAiEnable->hAi);
Ret = AI_SetEnable(pstAiEnable->hAi, pstAiEnable->bAiEnable);
break;
}
case CMD_AI_ACQUIREFRAME:
{
AI_Frame_Param_S_PTR pstAiFrame = (AI_Frame_Param_S_PTR)arg;
CHECK_AI_CHN_OPEN(pstAiFrame->hAi);
Ret = AI_AcquireFrame(pstAiFrame->hAi, &pstAiFrame->stAiFrame);
break;
}
case CMD_AI_RELEASEFRAME:
{
AI_Frame_Param_S_PTR pstAiFrame = (AI_Frame_Param_S_PTR)arg;
CHECK_AI_CHN_OPEN(pstAiFrame->hAi);
Ret = AI_ReleaseFrame(pstAiFrame->hAi, &pstAiFrame->stAiFrame);
break;
}
case CMD_AI_SETATTR:
{
AI_Attr_Param_S_PTR pstAiAttr = (AI_Attr_Param_S_PTR)arg;
CHECK_AI_CHN_OPEN(pstAiAttr->hAi);
Ret = AI_SetAttr(pstAiAttr->hAi, &pstAiAttr->stAttr);
break;
}
case CMD_AI_GETATTR:
{
AI_Attr_Param_S_PTR pstAiAttr = (AI_Attr_Param_S_PTR)arg;
CHECK_AI_CHN_OPEN(pstAiAttr->hAi);
Ret = AI_GetAttr(pstAiAttr->hAi, &pstAiAttr->stAttr);
break;
}
case CMD_AI_GETBUFINFO:
{
AI_Buf_Param_S_PTR pstAiBufInfo = (AI_Buf_Param_S_PTR)arg;
CHECK_AI_CHN_OPEN(pstAiBufInfo->hAi);
Ret = AI_GetAiBufInfo(pstAiBufInfo->hAi, &pstAiBufInfo->stAiBuf);
break;
}
case CMD_AI_SETBUFINFO:
{
AI_Buf_Param_S_PTR pstAiBufInfo = (AI_Buf_Param_S_PTR)arg;
CHECK_AI_CHN_OPEN(pstAiBufInfo->hAi);
Ret = AI_SetAiBufInfo(pstAiBufInfo->hAi, &pstAiBufInfo->stAiBuf);
break;
}
default:
{
Ret = HI_ERR_AI_INVALID_PARA;;
HI_WARN_AI("unknown cmd: 0x%x\n", cmd);
break;
}
}
return Ret;
}
//--------------------------------------------------------------------------
// Module:
// BurnInInitAnalogs
//
/// This function is responsible for initializing the analog
/// outputs and the analog inputs for Burn In testing. The analog
/// outputs are fed back into the analog inputs.
///
//--------------------------------------------------------------------------
static void BurnInInitAnalogs (void)
{
AO_Init();
/* Set the chart recording scaling */
AO_SetScaling (ALOG_OUT0, HI_DAC_VOLTAGE_MV, LO_DAC_VOLTAGE_MV);
AO_SetScaling (ALOG_OUT1, HI_DAC_VOLTAGE_MV, LO_DAC_VOLTAGE_MV);
AO_SetScaling (ALOG_OUT2, HI_DAC_VOLTAGE_MV, LO_DAC_VOLTAGE_MV);
AO_SetScaling (ALOG_OUT3, HI_DAC_VOLTAGE_MV, LO_DAC_VOLTAGE_MV);
AO_SetScaling (ALOG_OUT4, HI_DAC_VOLTAGE_MV, LO_DAC_VOLTAGE_MV);
AO_SetScaling (ALOG_OUT5, HI_DAC_VOLTAGE_MV, LO_DAC_VOLTAGE_MV);
AO_SetScaling (ALOG_OUT6, HI_DAC_VOLTAGE_MV, LO_DAC_VOLTAGE_MV);
AO_SetScaling (ALOG_OUT7, HI_DAC_VOLTAGE_MV, LO_DAC_VOLTAGE_MV);
/* Set the variables for the chart recorder driver software to monitor */
AO_SetVariable (ALOG_OUT0, &burninDAC[0], INT_16_TYPE);
AO_SetVariable (ALOG_OUT1, &burninDAC[1], INT_16_TYPE);
AO_SetVariable (ALOG_OUT2, &burninDAC[2], INT_16_TYPE);
AO_SetVariable (ALOG_OUT3, &burninDAC[3], INT_16_TYPE);
AO_SetVariable (ALOG_OUT4, &burninDAC[4], INT_16_TYPE);
AO_SetVariable (ALOG_OUT5, &burninDAC[5], INT_16_TYPE);
AO_SetVariable (ALOG_OUT6, &burninDAC[6], INT_16_TYPE);
AO_SetVariable (ALOG_OUT7, &burninDAC[7], INT_16_TYPE);
/* Enable the channels of the chart recorder */
AO_SetEnable (ALOG_OUT0, TRUE);
AO_SetEnable (ALOG_OUT1, TRUE);
AO_SetEnable (ALOG_OUT2, TRUE);
AO_SetEnable (ALOG_OUT3, TRUE);
AO_SetEnable (ALOG_OUT4, TRUE);
AO_SetEnable (ALOG_OUT5, TRUE);
AO_SetEnable (ALOG_OUT6, TRUE);
AO_SetEnable (ALOG_OUT7, TRUE);
/* Initialize the analog inputs */
AI_Init();
/* Only used to test VDrive, not used in application */
AI_SetScaleFactors (ANALOGIN_10, MAX_ADC_QUANTA, MIN_ADC_QUANTA,
5000, 0);
AI_SetEnable (ANALOGIN_10, TRUE);
AI_SetScaleFactors (ANALOGIN_00, MAX_ADC_QUANTA, MIN_ADC_QUANTA,
1, -1);
AI_SetEnable (ANALOGIN_00, TRUE);
AI_SetScaleFactors (ANALOGIN_01, MAX_ADC_QUANTA, MIN_ADC_QUANTA,
1, -1);
AI_SetEnable (ANALOGIN_01, TRUE);
AI_SetScaleFactors (ANALOGIN_02, MAX_ADC_QUANTA, MIN_ADC_QUANTA,
1, -1);
AI_SetEnable (ANALOGIN_02, TRUE);
AI_SetScaleFactors (ANALOGIN_03, MAX_ADC_QUANTA, MIN_ADC_QUANTA,
1, -1);
AI_SetEnable (ANALOGIN_03, TRUE);
AI_SetScaleFactors (ANALOGIN_04, MAX_ADC_QUANTA, MIN_ADC_QUANTA,
1, -1);
AI_SetEnable (ANALOGIN_04, TRUE);
AI_SetScaleFactors (ANALOGIN_05, MAX_ADC_QUANTA, MIN_ADC_QUANTA,
1, -1);
AI_SetEnable (ANALOGIN_05, TRUE);
AI_SetScaleFactors (ANALOGIN_06, MAX_ADC_QUANTA, MIN_ADC_QUANTA,
1, -1);
AI_SetEnable (ANALOGIN_06, TRUE);
AI_SetScaleFactors (ANALOGIN_07, MAX_ADC_QUANTA, MIN_ADC_QUANTA,
1, -1);
AI_SetEnable (ANALOGIN_07, TRUE);
AI_SetScaleFactors (ANALOGIN_08, MAX_ADC_QUANTA, MIN_ADC_QUANTA,
1, -1);
AI_SetEnable (ANALOGIN_08, TRUE);
AI_SetScaleFactors (ANALOGIN_09, MAX_ADC_QUANTA, MIN_ADC_QUANTA,
1, -1);
AI_SetEnable (ANALOGIN_09, TRUE);
AI_SetScaleFactors (ANALOGIN_11, MAX_ADC_QUANTA, MIN_ADC_QUANTA,
1, -1);
AI_SetEnable (ANALOGIN_11, TRUE);
AI_SetScaleFactors (ANALOGIN_12, MAX_ADC_QUANTA, MIN_ADC_QUANTA,
1, -1);
AI_SetEnable (ANALOGIN_12, TRUE);
AI_SetScaleFactors (ANALOGIN_13, MAX_ADC_QUANTA, MIN_ADC_QUANTA,
1, -1);
AI_SetEnable (ANALOGIN_13, TRUE);
AI_SetScaleFactors (BATTERY_VOLTAGE, MAX_ADC_QUANTA, MIN_ADC_QUANTA,
1, -1);
AI_SetEnable (BATTERY_VOLTAGE, TRUE);
}
HI_S32 AI_DRV_Resume(PM_BASEDEV_S * pdev)
{
#if defined (HI_AI_DRV_SUSPEND_SUPPORT)
HI_S32 s32Ret;
HI_U32 i;
HI_UNF_AI_E enAiPort;
HI_UNF_AI_ATTR_S stAiAttr;
HI_BOOL bAlsa;
HI_VOID *pAlsaPara;
AI_CHANNEL_STATE_S *state = HI_NULL;
AI_CHANNEL_STATUS_E enAiStatus;
HI_FATAL_AI("entering\n");
s32Ret = down_interruptible(&g_AIMutex);
if(0 != atomic_read(&g_AIOpenCnt))
{
s32Ret = HAL_AIAO_Resume();
if(HI_SUCCESS != s32Ret)
{
HI_FATAL_AI("AIAO Resume fail\n");
up(&g_AIMutex);
return HI_FAILURE;
}
for(i=0; i<AI_MAX_TOTAL_NUM; i++)
{
if (g_pstGlobalAIRS.pstAI_ATTR_S[i])
{
state = g_pstGlobalAIRS.pstAI_ATTR_S[i];
enAiPort = g_pstGlobalAIRS.pstAI_ATTR_S[i]->enAiPort;
stAiAttr = g_pstGlobalAIRS.pstAI_ATTR_S[i]->stSndPortAttr;
bAlsa = g_pstGlobalAIRS.pstAI_ATTR_S[i]->bAlsa;
pAlsaPara = g_pstGlobalAIRS.pstAI_ATTR_S[i]->pAlsaPara;
enAiStatus= state->enCurnStatus;
#ifdef HI_ALSA_AI_SUPPORT
if(bAlsa ==HI_TRUE)
{
pAlsaPara= (void*)&g_stAlsaAttr;
}
#endif
s32Ret = AI_Resume_CreateChn(enAiPort, &stAiAttr, bAlsa, pAlsaPara, state);
if(HI_SUCCESS != s32Ret)
{
HI_FATAL_AI("AICreateChn failed\n");
up(&g_AIMutex);
return HI_FAILURE;
}
if(AI_CHANNEL_STATUS_START == enAiStatus)
{
s32Ret = AI_SetEnable(i, HI_TRUE);
if(HI_SUCCESS != s32Ret)
{
HI_ERR_AI("Set AI Enable failed\n");
up(&g_AIMutex);
return HI_FAILURE;
}
}
}
}
}
up(&g_AIMutex);
HI_FATAL_AI("ok\n");
#endif
return HI_SUCCESS;
}
