Google Git
Sign in
gfiber / barebox / mindspeed / 95b1298aa3b8fb885cc863108126abed342e6a9a / . / diags / legerity / api-II / api_lib / vp880_api / vp880_calibration_common.c
blob: fb915a90d514ab03d6147c88ebaed5cee4e6c274 [file] [log] [blame]
/** \file vp880_calibration_common.c
* vp880_calibration_common.c
*
* This file contains the line and device calibration functions that are common
* within the 880 device family (for ABS and Tracker).
*
* Copyright (c) 2011, Microsemi
*
* $Revision: 1.1.2.1.8.3 $
* $LastChangedDate: 2011-11-07 13:39:50 -0600 (Mon, 07 Nov 2011) $
*/
#include "../includes/vp_api_cfg.h"
#if defined (VP_CC_880_SERIES)
/* INCLUDES */
#include "../../arch/uvb/vp_api_types.h"
#include "../includes/vp_api.h"
#include "../includes/vp_api_int.h"
#include "../includes/vp880_api.h"
#include "../vp880_api/vp880_api_int.h"
#include "../../arch/uvb/vp_hal.h"
#include "../../arch/uvb/sys_service.h"
#if defined (VP_CSLAC_RUNTIME_CAL_ENABLED) && defined (VP880_FXS_SUPPORT)
#define VP880_IMT_SETTLE_MS 100
#define VP880_DCFEED_SETTLE_MS 100
#define VP880_IMT_10MA 5679L
/* Functions for Cal Line = FXS only */
static bool
CalLineNextState(
VpDevCtxType *pDevCtx,
VpLineCtxType *pLineCtx,
Vp880DeviceObjectType *pDevObj,
Vp880LineObjectType *pLineObj,
uint16 *pCalTimerMs);
#ifdef VP880_TRACKER_SUPPORT
static void
ComputeFinalVas(
VpLineCtxType *pLineCtx,
uint16 *vasValue);
#endif
static void
SetAdc(
VpLineCtxType *pLineCtx,
VpDeviceIdType deviceId,
uint8 ecVal,
uint8 adcRoute);
static bool
GetXData(
VpLineCtxType *pLineCtx,
VpDeviceIdType deviceId,
uint8 ecVal,
int16 *pData);
#endif
#if defined (VP_CSLAC_RUNTIME_CAL_ENABLED) && defined (VP880_FXS_SUPPORT)
/**
* Vp880CalCodec() -- Tracker and ABS Function
* This function initiates a calibration operation for analog circuits
* associated with all the lines of a device. See VP-API reference guide for
* more information.
* Preconditions:
* The device and line context must be created and initialized before calling
* this function.
*
* Postconditions:
* This function generates an event upon completing the requested action.
*/
VpStatusType
Vp880CalCodec(
VpLineCtxType *pLineCtx,
VpDeviceCalType mode)
{
Vp880LineObjectType *pLineObj = pLineCtx->pLineObj;
VpDevCtxType *pDevCtx = pLineCtx->pDevCtx;
Vp880DeviceObjectType *pDevObj = pDevCtx->pDevObj;
VpDeviceIdType deviceId = pDevObj->deviceId;
uint8 maxChannels = pDevObj->staticInfo.maxChannels;
uint8 chanNum;
VpLineStateType currentState;
VP_API_FUNC_INT(VpLineCtxType, pLineCtx, ("Vp880CalCodec+"));
VpSysEnterCritical(deviceId, VP_CODE_CRITICAL_SEC);
pDevObj->responseData = VP_CAL_SUCCESS;
if (pDevObj->stateInt & VP880_DEVICE_CAL_COMPLETE) {
pDevObj->deviceEvents.response |= VP_EVID_CAL_CMP;
VP_API_FUNC_INT(VpLineCtxType, pLineCtx, ("Vp880CalCodec-"));
VpSysExitCritical(deviceId, VP_CODE_CRITICAL_SEC);
return VP_STATUS_SUCCESS;
}
if (mode == VP_DEV_CAL_NBUSY) {
for (chanNum = 0; chanNum < maxChannels; chanNum++) {
if (pDevCtx->pLineCtx[chanNum] != VP_NULL) {
pLineObj = pLineCtx->pLineObj;
currentState = pLineObj->lineState.currentState;
if (pLineObj->status & VP880_IS_FXO) {
if ((currentState == VP_LINE_FXO_TALK)
|| (currentState == VP_LINE_FXO_LOOP_CLOSE)) {
pDevObj->deviceEvents.response |= VP_EVID_CAL_BUSY;
pDevObj->deviceEvents.response &= ~VP_EVID_CAL_CMP;
VP_API_FUNC_INT(VpLineCtxType, pLineCtx, ("Vp880CalCodec-"));
VpSysExitCritical(deviceId, VP_CODE_CRITICAL_SEC);
return VP_STATUS_SUCCESS;
}
} else {
if ((currentState != VP_LINE_STANDBY)
&& (currentState != VP_LINE_DISCONNECT)) {
pDevObj->deviceEvents.response |= VP_EVID_CAL_BUSY;
pDevObj->deviceEvents.response &= ~VP_EVID_CAL_CMP;
VP_API_FUNC_INT(VpLineCtxType, pLineCtx, ("Vp880CalCodec-"));
VpSysExitCritical(deviceId, VP_CODE_CRITICAL_SEC);
return VP_STATUS_SUCCESS;
}
}
}
}
}
pDevObj->state |= VP_DEV_IN_CAL;
if (!(pDevObj->stateInt & VP880_IS_ABS)) {
#ifdef VP880_TRACKER_SUPPORT
pDevObj->state |= VP_DEV_ABV_CAL;
Vp880CalCodecInt(pDevCtx);
#endif
} else {
#ifdef VP880_ABS_SUPPORT
if (Vp880SetCalFlags(pDevObj) == TRUE) {
Vp880CalCodecInt(pDevCtx);
}
#endif
}
VP_API_FUNC_INT(VpLineCtxType, pLineCtx, ("Vp880CalCodec-"));
VpSysExitCritical(deviceId, VP_CODE_CRITICAL_SEC);
return VP_STATUS_SUCCESS;
} /* Vp880CalCodec() */
/**
* Vp880CalCodecInt() -- Tracker and ABS Function
* This function initiates a calibration operation for analog circuits
* associated with all the lines of a device. See VP-API reference guide for
* more information.
* Preconditions:
* The device and line context must be created and initialized before calling
* this function.
*
* Postconditions:
* This function generates an event upon completing the requested action.
*/
VpStatusType
Vp880CalCodecInt(
VpDevCtxType *pDevCtx)
{
Vp880DeviceObjectType *pDevObj = pDevCtx->pDevObj;
VP_API_FUNC_INT(VpDevCtxType, pDevCtx, ("Vp880CalCodecInt+"));
#ifdef VP880_TRACKER_SUPPORT
if (pDevObj->state & VP_DEV_ABV_CAL) {
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("Calling ABV Cal inside Vp880CalCodecInt() for Tracker"));
Vp880CalAbv(pDevCtx);
VP_API_FUNC_INT(VpDevCtxType, pDevCtx, ("Vp880CalCodecInt-"));
return VP_STATUS_SUCCESS;
}
#endif
#ifdef VP880_ABS_SUPPORT
if (pDevObj->state & VP_DEV_ABV_CAL_ABS) {
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("Calling ABV Cal inside Vp880CalCodecInt() for ABS"));
Vp880CalAbvAbsDev(pDevCtx);
VP_API_FUNC_INT(VpDevCtxType, pDevCtx, ("Vp880CalCodecInt-"));
return VP_STATUS_SUCCESS;
}
if (pDevObj->state & VP_DEV_ABS_BAT_CAL) {
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("Calling ABS Cal (Vp880AbsCalibration()) inside Vp880CalCodecInt()"));
Vp880AbsCalibration(pDevCtx);
VP_API_FUNC_INT(VpDevCtxType, pDevCtx, ("Vp880CalCodecInt-"));
return VP_STATUS_SUCCESS;
}
#endif
VP_ERROR(VpDevCtxType, pDevCtx, ("Vp880CalCodecInt- Exit to unspecified calibration state!!"));
VP_API_FUNC_INT(VpDevCtxType, pDevCtx, ("Vp880CalCodecInt-"));
return VP_STATUS_SUCCESS;
} /* Vp880CalCodecInt() */
/**
* Vp880CalLine()
* This function initiates a calibration operation for analog circuits
* associated with a given line. See VP-API reference guide for more
* information.
* Preconditions:
* The device and line context must be created and initialized before calling
* this function.
*
* Postconditions:
* This function generates an event upon completing the requested action.
*/
VpStatusType
Vp880CalLine(
VpLineCtxType *pLineCtx)
{
Vp880LineObjectType *pLineObj = pLineCtx->pLineObj;
VpDevCtxType *pDevCtx = pLineCtx->pDevCtx;
Vp880DeviceObjectType *pDevObj = pDevCtx->pDevObj;
VpDeviceIdType deviceId = pDevObj->deviceId;
uint16 tickRate = pDevObj->devProfileData.tickRate;
VpLineStateType currentState = pLineObj->lineState.usrCurrent;
uint8 ecVal = pLineObj->ecVal;
uint8 opCond[VP880_OP_COND_LEN];
VP_API_FUNC_INT(VpLineCtxType, pLineCtx, ("+Vp880CalLine()"));
/* Block if device init is not complete */
if (!(pDevObj->state & VP_DEV_INIT_CMP)) {
return VP_STATUS_DEV_NOT_INITIALIZED;
}
if (pLineObj->status & VP880_IS_FXO) {
return VP_STATUS_INVALID_ARG;
}
/*
* Do not proceed if the device calibration is in progress. This could
* damage the device.
*/
if (pDevObj->state & VP_DEV_IN_CAL) {
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Return NOT_INITIALIZED from Vp880CalLine()"));
VP_API_FUNC_INT(VpLineCtxType, pLineCtx,
("-Vp880CalLine()"));
return VP_STATUS_DEV_NOT_INITIALIZED;
}
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Running Cal Line on Channel %d at time %d target 0x%02X 0x%02X",
pLineObj->channelId, pDevObj->timeStamp,
pLineObj->calLineData.dcFeedRef[0],
pLineObj->calLineData.dcFeedRef[1]));
VpSysEnterCritical(deviceId, VP_CODE_CRITICAL_SEC);
/* Don't run calibration if previously complete on this line */
if ((pLineObj->calLineData.calDone == TRUE) ||
(pDevObj->staticInfo.rcnPcn[VP880_RCN_LOCATION] < VP880_REV_JE)) {
pLineObj->lineEvents.response |= VP_EVID_CAL_CMP;
pLineObj->lineState.calType = VP_CSLAC_CAL_NONE;
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Calibration Previously Done. Cal Line Complete"));
VpSysExitCritical(deviceId, VP_CODE_CRITICAL_SEC);
return VP_STATUS_SUCCESS;
}
pLineObj->status |= VP880_LINE_IN_CAL;
/* Make sure line calibration can be run */
switch(currentState) {
case VP_LINE_OHT:
break;
case VP_LINE_STANDBY:
pLineObj->lineState.calType = VP_CSLAC_CAL_NONE;
Vp880SetLineState(pLineCtx, VP_LINE_OHT);
break;
case VP_LINE_STANDBY_POLREV:
case VP_LINE_OHT_POLREV:
pLineObj->lineState.calType = VP_CSLAC_CAL_NONE;
Vp880SetLineState(pLineCtx, VP_LINE_OHT_POLREV);
break;
default:
VpSysExitCritical(deviceId, VP_CODE_CRITICAL_SEC);
VP_API_FUNC_INT(VpLineCtxType, pLineCtx, ("-Vp880CalLine()"));
return VP_STATUS_INVALID_ARG;
}
/* we need to remember if we started in polrev */
if (pLineObj->slicValueCache & VP880_SS_POLARITY_MASK) {
pLineObj->calLineData.reversePol = TRUE;
} else {
pLineObj->calLineData.reversePol = FALSE;
}
#ifdef VP880_LP_SUPPORT
/*
* Force a LPM Exit update before proceeding with Calibration. If this
* isn't done before setting the device mask, the LPM code to exit LPM will
* not run (because it otherwise does not touch the device while in
* calibration). If it is not a LPM device, this function doesn't do
* anything.
*/
Vp880LowPowerMode(pDevCtx);
#endif
pLineObj->lineTimers.timers.timer[VP_LINE_CAL_LINE_TIMER] =
MS_TO_TICKRATE(VP880_MIN_CAL_WAIT_TIME, tickRate);
pLineObj->lineTimers.timers.timer[VP_LINE_CAL_LINE_TIMER] |=
VP_ACTIVATE_TIMER;
/* Reprogram the Operating Conditions Register, affected by Set Line State */
opCond[0] = (VP880_CUT_TXPATH | VP880_CUT_RXPATH | VP880_HIGH_PASS_DIS);
VpMpiCmdWrapper(deviceId, ecVal, VP880_OP_COND_WRT, VP880_OP_COND_LEN, opCond);
pLineObj->opCond[0] = opCond[0];
pLineObj->calLineData.calLineState = VP880_CAL_SETUP;
/*
* Vp880ServiceFxsInterrupts uses this to decide if ring exit debounce
* or CID need to be handled. Setting it to something other than
* VP_CSLAC_CAL_NONE should be good enough.
*/
pLineObj->lineState.calType = VP_CSLAC_CAL_VOC;
VpSysExitCritical(deviceId, VP_CODE_CRITICAL_SEC);
VP_API_FUNC_INT(VpLineCtxType, pLineCtx, ("-Vp880CalLine()"));
return VP_STATUS_SUCCESS;
}
/**
* Vp880CalLineInt()
* This function is called each time the VP_LINE_CAL_LINE_TIMER expires.
* Its basic purpose is to continue calling CalLineNextState until it
* returns false.
*
* Postconditions:
* This function generates an event upon completing the requested action or
* sets up the cal timer to expire at a later time to run the next state.
*/
VpStatusType
Vp880CalLineInt(
VpLineCtxType *pLineCtx)
{
Vp880LineObjectType *pLineObj = pLineCtx->pLineObj;
VpDevCtxType *pDevCtx = pLineCtx->pDevCtx;
Vp880DeviceObjectType *pDevObj = pDevCtx->pDevObj;
uint16 tickRate = pDevObj->devProfileData.tickRate;
uint16 calTimerMs = 0;
pDevObj->responseData = VP_CAL_SUCCESS;
VP_API_FUNC_INT(VpLineCtxType, pLineCtx, ("+Vp880CalLineInt()"));
/* Continue calling the cal state machine until it indicates FALSE */
while (CalLineNextState(pDevCtx, pLineCtx, pDevObj, pLineObj, &calTimerMs));
if (calTimerMs != 0) {
/* Setup the Cal timer to expire in requested ms */
pLineObj->lineTimers.timers.timer[VP_LINE_CAL_LINE_TIMER] =
MS_TO_TICKRATE(calTimerMs, tickRate);
pLineObj->lineTimers.timers.timer[VP_LINE_CAL_LINE_TIMER] |=
VP_ACTIVATE_TIMER;
} else {
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Generating VP_EVID_CAL_CMP Event for Channel %d EventMask 0x%04X",
pLineObj->channelId, pLineObj->lineEventsMask.response));
/* If no timer was requested, Cal must be done so generate and event */
pLineObj->lineState.calType = VP_CSLAC_CAL_NONE;
pLineObj->lineEvents.response |= VP_EVID_CAL_CMP;
pLineObj->status &= ~VP880_LINE_IN_CAL;
/*
* Set calDone = TRUE only if there wasn't a failure detected. If the
* calDone flag is TRUE, the line can't be recalibrated without the
* hidden setting with APPLY_SYSTEM_CEOFF and NULL profile.
*/
if (pDevObj->responseData == VP_CAL_FAILURE) {
/*
* This should be redundant because calibration won't run unless
* this value was previously set to FALSE. But it's safe just to
* make sure it's set to a know value for a known condition.
*/
pLineObj->calLineData.calDone = FALSE;
} else {
pLineObj->calLineData.calDone = TRUE;
}
/* line calibration is no longer in progress at this point */
pLineObj->status &= ~VP880_LINE_IN_CAL;
}
VP_API_FUNC_INT(VpLineCtxType, pLineCtx, ("-Vp880CalLineInt()"));
return VP_STATUS_SUCCESS;
} /* Vp880CalLineInt */
/**
* CalLineNextState()
* This function implements the steps of the 880 Calibration algorithm.
*
* The state machine will move to the next state when the Cal timer
* expires or if the function returns TRUE.
*
* Postconditions:
* Returns true indicating that another state should be run immediately.
* Returns false indicating that the state machine is done with the current
* state.
*/
static bool
CalLineNextState(
VpDevCtxType *pDevCtx,
VpLineCtxType *pLineCtx,
Vp880DeviceObjectType *pDevObj,
Vp880LineObjectType *pLineObj,
uint16 *pCalTimerMs)
{
uint8 channelId = pLineObj->channelId;
uint8 ecVal = pLineObj->ecVal;
VpDeviceIdType deviceId = pDevObj->deviceId;
Vp880CalLineState nextState = VP880_CAL_ENUM_SIZE;
bool runAnotherState = FALSE;
uint8 mpiIndex = 0;
uint8 mpiBuffer[254];
*pCalTimerMs = 0;
switch(pLineObj->calLineData.calLineState) {
/***********************************************************************
* This state is used to setup the device for the cal sequence
* by clearing out values in registers.
**********************************************************************/
case VP880_CAL_SETUP: {
uint8 disnVal = 0;
uint8 vpGain = 0;
uint8 codec = VP880_LINEAR_CODEC;
uint8 loopSup[VP880_LOOP_SUP_LEN];
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_CAL_SETUP"));
/*
* Start off with the assumption calibration will work. Simpler to
* let the algorithm detect failure and set this accordingly rather
* than have each possible good exit set it for pass.
*/
pDevObj->responseData = VP_CAL_SUCCESS;
/* Store LoopSup, DISN , Voice Path Gain, ICR2, SLIC state, and genA */
VpMemCpy(pLineObj->calLineData.loopSup, pLineObj->loopSup,
VP880_LOOP_SUP_LEN);
VpMpiCmdWrapper(deviceId, ecVal, VP880_SS_CONFIG_RD,
VP880_SS_CONFIG_LEN, &pLineObj->calLineData.asscReg);
VpMemCpy(loopSup, pLineObj->calLineData.loopSup, VP880_LOOP_SUP_LEN);
VpMpiCmdWrapper(deviceId, ecVal, VP880_DISN_RD,
VP880_DISN_LEN, pLineObj->calLineData.disnVal);
VpMpiCmdWrapper(deviceId, ecVal, VP880_VP_GAIN_RD,
VP880_VP_GAIN_LEN,pLineObj->calLineData.vpGain);
VpMemCpy(pLineObj->calLineData.icr2, pLineObj->icr2Values, VP880_ICR2_LEN);
VpMemCpy(pLineObj->calLineData.icr3, pLineObj->icr3Values, VP880_ICR3_LEN);
VpMpiCmdWrapper(deviceId, ecVal, VP880_SIGA_PARAMS_RD,
VP880_SIGA_PARAMS_LEN, pLineObj->calLineData.sigGenA);
VpMpiCmdWrapper(deviceId, ecVal, VP880_OP_FUNC_RD,
VP880_OP_FUNC_LEN, &pLineObj->calLineData.codecReg);
/* Set Hook Debounce to 8 ms */
loopSup[VP880_LOOP_SUP_DEBOUNCE_BYTE] &= ~VP880_SWHOOK_DEBOUNCE_MASK;
loopSup[VP880_LOOP_SUP_DEBOUNCE_BYTE] |= 0x04;
mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer,
VP880_LOOP_SUP_WRT, VP880_LOOP_SUP_LEN, loopSup);
/* Set DISN = 0 and Voice Path Gain = 0dB TX */
mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer,
VP880_DISN_WRT, VP880_DISN_LEN, &disnVal);
mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer,
VP880_VP_GAIN_WRT,VP880_VP_GAIN_LEN, &vpGain);
/* Set the device mode register for single buffer mode */
pDevObj->devMode[0] &= ~(VP880_DEV_MODE_TEST_DATA);
mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer,
VP880_DEV_MODE_WRT, VP880_DEV_MODE_LEN, pDevObj->devMode);
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("\n\rVP880_CAL_SETUP: Writing 0x%02X to Operating Functions", codec));
/* Set for Linear Mode and disable AC Coefficients */
mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer,
VP880_OP_FUNC_WRT, VP880_OP_FUNC_LEN, &codec);
/* Cut TX/RX PCM and disable HPF */
pLineObj->opCond[0] = (VP880_CUT_TXPATH | VP880_CUT_RXPATH | VP880_HIGH_PASS_DIS);
mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer,
VP880_OP_COND_WRT, VP880_OP_COND_LEN, pLineObj->opCond);
/* Copy the reference dcfeed data into the polrev dcfeed array */
VpMemCpy(pLineObj->calLineData.dcFeedPr,
pLineObj->calLineData.dcFeedRef, VP880_DC_FEED_LEN);
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("\n\rVP880_CAL_SETUP: Copied 0x%02X 0x%02X to dcFeedPr",
pLineObj->calLineData.dcFeedPr[0], pLineObj->calLineData.dcFeedPr[1]));
if (!(pDevObj->stateInt & VP880_IS_ABS)) {
#ifdef VP880_TRACKER_SUPPORT
/* set VAS to 3.0V (min) */
pLineObj->calLineData.dcFeedPr[0] &= 0xFC;
pLineObj->calLineData.dcFeedPr[1] &= 0x3F;
/* Start for Tracker Device */
nextState = VP880_CAL_SETUP_RELEASE_CLAMPS;
#endif
} else {
#ifdef VP880_ABS_SUPPORT
/* Start for ABS Device */
nextState = VP880_RAMP_TO_POLREV_SETUP;
#endif
}
/* set ila to 40mA */
pLineObj->calLineData.dcFeedPr[1] &= ~VP880_ILA_MASK;
pLineObj->calLineData.dcFeedPr[1] |= (VP880_ILA_MASK & 0x16);
/* Set DC-Feed to values from dc profile */
mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer,
VP880_DC_FEED_WRT, VP880_DC_FEED_LEN, pLineObj->calLineData.dcFeedPr);
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("\n\rVP880_CAL_SETUP: Modified to 0x%02X 0x%02X to dcFeedPr",
pLineObj->calLineData.dcFeedPr[0], pLineObj->calLineData.dcFeedPr[1]));
/* next state info */
*pCalTimerMs = 10;
break;
}
case VP880_CAL_SETUP_RELEASE_CLAMPS:
if ((pDevObj->stateInt & VP880_IS_HIGH_VOLTAGE) &&
!pDevObj->devProfileData.lowVoltOverride) {
/*
* if this is a high voltage device and designed
* with a high voltage supply then we need to set
* the voltage clamps to 150V to give the slower
* battery designs time to ramp up.
*/
pLineObj->icr2Values[2] |= 0x0C;
pLineObj->icr2Values[3] |= 0x0C;
mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer,
VP880_ICR2_WRT, VP880_ICR2_LEN, pLineObj->icr2Values);
}
/* if we are not already in polrev then we need to go there */
if (!pLineObj->calLineData.reversePol) {
nextState = VP880_RAMP_TO_POLREV_SETUP;
*pCalTimerMs = 10;
} else {
nextState = VP880_IMT_PR_SETUP;
/*
* mimic the time required by ramp pol rev to give
* battery from the slower power supplies time to
* finish moving.
*/
*pCalTimerMs = 100;
}
break;
/***********************************************************************
* These states are used to force the line into polrev using a ramp
*
* Need to ramp to negative polarity so that we dont ding a phone. Due
* to a device issue, we have to split the ramp in two. The first
* ramp will start at -45V and ramp to 0V. Once 0V is acheived, the deivce
* the polarity of the line will be flipped. Then the ramp will
* continue to +45V. Finally the line will be taken out of ringing
* and put into active. Performing the polrev at 0V prevents a tip/ring
* transient at the end when we go from balanced ringing to active polrev.
**********************************************************************/
case VP880_RAMP_TO_POLREV_SETUP: {
uint8 asscReg = (pLineObj->calLineData.asscReg | VP880_ZXR_MASK);
/* setup siggen to mimic a 45V VOC once ringing is enabled */
uint8 sigGenA[VP880_SIGA_PARAMS_LEN] =
{0x00, 0x25, 0x4E, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00 ,0x00, 0x00};
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_RAMP_TO_POLREV_SETUP"));
/* disable auto ring entery / exit */
mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer,
VP880_SS_CONFIG_WRT, VP880_SS_CONFIG_LEN, &asscReg);
/* Prepare the sig gen with ramp info */
mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer,
VP880_SIGA_PARAMS_WRT, VP880_SIGA_PARAMS_LEN, sigGenA);
/*
* go to the balanced ringing state. This should generate a
* longitudinal shift. The direction and size will depend on
* the value of VOC in the DC feed register.
*/
pLineObj->slicValueCache &= ~VP880_SS_STATE_MASK;
pLineObj->slicValueCache |= VP880_SS_BALANCED_RINGING;
mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer,
VP880_SYS_STATE_WRT, VP880_SYS_STATE_LEN, &pLineObj->slicValueCache);
/* enable longitudinal clamp even in ringing for duration of the CalLine */
pLineObj->icr3Values[2] |= 0x40;
pLineObj->icr3Values[3] = (pLineObj->icr3Values[3] & ~0x40);
mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer,
VP880_ICR3_WRT, VP880_ICR3_LEN, pLineObj->icr3Values);
/* next state info */
*pCalTimerMs = 10;
nextState = VP880_RAMP_TO_POLREV_RAMP1;
break;
}
case VP880_RAMP_TO_POLREV_RAMP1: {
/* force the siggen to start a negative ramp of 45V */
uint8 sigGenA[VP880_SIGA_PARAMS_LEN] =
{0x07, 0x25, 0x4E, 0x00, 0x25, 0x25, 0x4E, 0x00, 0x00 ,0x00, 0x00};
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_RAMP_TO_POLREV_RAMP1"));
mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer,
VP880_SIGA_PARAMS_WRT, VP880_SIGA_PARAMS_LEN, sigGenA);
*pCalTimerMs = 100;
nextState = VP880_RAMP_TO_POLREV_SWAP_POLARITY;
break;
}
case VP880_RAMP_TO_POLREV_SWAP_POLARITY: {
/* go to balanced ringing polrev */
pLineObj->slicValueCache &= ~VP880_SS_STATE_MASK;
pLineObj->slicValueCache |= VP880_SS_BALANCED_RINGING_PR;
mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer,
VP880_SYS_STATE_WRT, VP880_SYS_STATE_LEN, &pLineObj->slicValueCache);
runAnotherState = TRUE;
nextState = VP880_RAMP_TO_POLREV_RAMP2;
break;
}
case VP880_RAMP_TO_POLREV_RAMP2: {
/* force the siggen to complete the ramp */
uint8 sigGenA[VP880_SIGA_PARAMS_LEN] =
{0x03, 0x25, 0x4E, 0x00, 0x25, 0x25, 0x4E, 0x00, 0x00 ,0x00, 0x00};
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_RAMP_TO_POLREV_RAMP2"));
mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer,
VP880_SIGA_PARAMS_WRT, VP880_SIGA_PARAMS_LEN, sigGenA);
*pCalTimerMs = 50;
nextState = VP880_RAMP_TO_POLREV_GOACTIVE;
break;
}
case VP880_RAMP_TO_POLREV_GOACTIVE: {
uint8 sigGenA[VP880_SIGA_PARAMS_LEN] =
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00 ,0x00, 0x00};
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_RAMP_TO_POLREV_GOACTIVE"));
/* go to active polrev */
pLineObj->slicValueCache &= ~VP880_SS_STATE_MASK;
pLineObj->slicValueCache |= VP880_SS_ACTIVE_POLREV;
mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer,
VP880_SYS_STATE_WRT, VP880_SYS_STATE_LEN, &pLineObj->slicValueCache);
/* remove the siggen ramp */
mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer,
VP880_SIGA_PARAMS_WRT, VP880_SIGA_PARAMS_LEN, sigGenA);
*pCalTimerMs = 10;
nextState = VP880_RAMP_TO_POLREV_COMPLETE;
break;
}
case VP880_RAMP_TO_POLREV_COMPLETE: {
/* restore the automatic system state control */
mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer,
VP880_SS_CONFIG_WRT, VP880_SS_CONFIG_LEN, &pLineObj->calLineData.asscReg);
*pCalTimerMs = 20;
nextState = VP880_IMT_PR_SETUP;
}
/***********************************************************************
* Settle IMT in PolRev -
*
* These states setup, measure Metallic polrev current until it
* settles. This is done to prevent high REN loads from distorting
* the VAS measurements
**********************************************************************/
case VP880_IMT_PR_SETUP: {
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_IMT_PR_SETUP"));
if (!(pDevObj->stateInt & VP880_IS_ABS)) {
#ifdef VP880_TRACKER_SUPPORT
/* Enable battery and DC Speed up */
pLineObj->icr2Values[2] |= 0xC0;
pLineObj->icr2Values[3] |= 0xC0;
#endif
} else {
#ifdef VP880_ABS_SUPPORT
/* Enable DC Speed up only */
pLineObj->icr2Values[2] |= 0x80;
pLineObj->icr2Values[3] |= 0x80;
#endif
}
mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer,
VP880_ICR2_WRT, VP880_ICR2_LEN, pLineObj->icr2Values);
/* prepare storage data */
pLineObj->calLineData.typeData.loopData.loopNum = 0;
pLineObj->calLineData.typeData.loopData.prevVal = 0;
*pCalTimerMs = 10;
nextState = VP880_IMT_PR_SET_ADC;
break;
}
case VP880_IMT_PR_SET_ADC: {
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_IMT_PR_SET_ADC"));
SetAdc(pLineCtx, deviceId, ecVal, VP880_METALLIC_DC_I);
*pCalTimerMs = 10;
nextState = VP880_IMT_PR_MEASURE;
break;
}
case VP880_IMT_PR_MEASURE: {
int16 imOld = 0;
int16 imNew = 0;
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_IMT_PR_MEASURE"));
if ( !GetXData(pLineCtx, deviceId, ecVal, &imNew)) {
*pCalTimerMs = 10;
nextState = VP880_IMT_PR_MEASURE;
break;
}
/* if this is the first imt measurement then get another */
if (pLineObj->calLineData.typeData.loopData.loopNum++ == 0) {
pLineObj->calLineData.typeData.loopData.prevVal = imNew;
*pCalTimerMs = VP880_IMT_SETTLE_MS;
nextState = VP880_IMT_PR_MEASURE;
break;
}
imOld = pLineObj->calLineData.typeData.loopData.prevVal;
/* have we settled enough or taken to long > 200ms*/
if ( (pLineObj->calLineData.typeData.loopData.loopNum < 20 /*200ms*/) &&
(((imNew + 15 - imOld) & 0xFFE0) != 0) ) {
/* nope run it again */
pLineObj->calLineData.typeData.loopData.prevVal = imNew;
*pCalTimerMs = VP880_IMT_SETTLE_MS;
nextState = VP880_IMT_PR_MEASURE;
break;
}
runAnotherState = TRUE;
if (!(pDevObj->stateInt & VP880_IS_ABS)) {
#ifdef VP880_TRACKER_SUPPORT
nextState = VP880_VAS_PR_SETUP;
#endif
} else {
nextState = VP880_VAB_PR_SETUP;
}
break;
}
#ifdef VP880_TRACKER_SUPPORT
/***********************************************************************
* Measure VAS in PolRev -
*
* These five states step through VAS values and measure IMT.
* This will continue until:
* VAS >= 10.25V ||
* new IMT < 10mA && (new IMT - old IMT are with in +9 to -7mA)
*
* We only loop to 10.25V because we will always add 3.75V to VAS
* and the max value of the VAS register is 14.25V.
**********************************************************************/
case VP880_VAS_PR_SETUP:
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_VAS_PR_SETUP"));
/* prepare storage data */
pLineObj->calLineData.typeData.loopData.loopNum = 0;
pLineObj->calLineData.typeData.loopData.prevVal = 0x7FFF;
pLineObj->calLineData.vasStart = 3000;
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("VP880_VAS_PR_SETUP: Best Actual VAS Start %d",
pLineObj->calLineData.vasStart));
runAnotherState = TRUE;
nextState = VP880_VAS_PR_STEP;
break;
case VP880_VAS_PR_STEP: {
uint8 loopNum = pLineObj->calLineData.typeData.loopData.loopNum;
uint16 vasVal = pLineObj->calLineData.vasStart + (750 * loopNum);
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_VAS_PR_STEP"));
/*
* If the calculated VAS is max, advance to battery adjustment
* steps.
*/
if (vasVal > VP880_VAS_MAX) {
runAnotherState = TRUE;
nextState = VP880_VAS_PR_STORE;
break;
}
/* set VAS to the next value */
VpCSLACSetVas(pLineObj->calLineData.dcFeedPr, vasVal);
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("VP880_VAS_PR_STEP: Setting VAS (%d) with Values 0x%02X 0x%02X at time %d",
vasVal,
pLineObj->calLineData.dcFeedPr[0], pLineObj->calLineData.dcFeedPr[1],
pDevObj->timeStamp));
mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer,
VP880_DC_FEED_WRT, VP880_DC_FEED_LEN, pLineObj->calLineData.dcFeedPr);
/* dcfeed takes 100ms to settle after each step be very carefull adjusting this */
*pCalTimerMs = VP880_DCFEED_SETTLE_MS;
nextState = VP880_VAS_PR_SET_ADC;
break;
}
case VP880_VAS_PR_SET_ADC: {
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_VAS_PR_SET_ADC"));
SetAdc(pLineCtx, deviceId, ecVal, VP880_METALLIC_DC_I);
*pCalTimerMs = 10;
nextState = VP880_VAS_PR_MEASURE;
break;
}
case VP880_VAS_PR_MEASURE: {
int16 imtOld = pLineObj->calLineData.typeData.loopData.prevVal;
int16 imtNew = 0;
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_VAS_PR_MEASURE"));
if ( !GetXData(pLineCtx, deviceId, ecVal, &imtNew)) {
*pCalTimerMs = 10;
nextState = VP880_VAS_PR_MEASURE;
break;
}
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("VP880_VAS_PR_MEASURE: IMT Old %d IMT New %d",
imtOld, imtNew));
runAnotherState = TRUE;
if (pLineObj->calLineData.typeData.loopData.loopNum++ == 0) {
/* if this is the first imt measurement then get another */
nextState = VP880_VAS_PR_STEP;
} else if ((imtNew > VP880_IMT_10MA) ||
(((imtNew + 15 - imtOld) & 0xFFE0) != 0) ) {
/*
* if the measured value is greater than 10 mA or the difference
* between old and new values are greater +9/-7 then get another
*/
nextState = VP880_VAS_PR_STEP;
} else {
/* if there is nothing left then store the data */
nextState = VP880_VAS_PR_STORE;
}
/* replace the old with the new */
pLineObj->calLineData.typeData.loopData.prevVal = imtNew;
break;
}
case VP880_VAS_PR_STORE: {
uint16 vasVal;
uint8 dcFeed[VP880_DC_FEED_LEN];
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_VAS_PR_STORE"));
/* Compute final VAS Values */
VpMpiCmdWrapper(deviceId, ecVal, VP880_DC_FEED_RD, VP880_DC_FEED_LEN, dcFeed);
vasVal = VP880_VAS_CONVERSION(dcFeed[0], dcFeed[1]);
/*
* This function will determine if VAS is at max, and if so then
* increase Battery correction by the overhead amount.
*/
ComputeFinalVas(pLineCtx, &vasVal);
/*
* Set VAS to the final value. Note that this is NOT redundant from
* the previous read because VAS can be actually be reduced. It is
* the case when VAS reaches max and a battery adjustment increases
* such that the total VAS_MAX + battery_adjust_actual is > the
* required VAS + Overhead. This occurs due to differences in step
* sizes betwen battery adjustment and VAS.
*/
VpCSLACSetVas(pLineObj->calLineData.dcFeedPr, vasVal);
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("VP880_VAS_PR_STORE: Setting VAS (%d) with Final Values 0x%02X 0x%02X at time %d",
vasVal,
pLineObj->calLineData.dcFeedPr[0], pLineObj->calLineData.dcFeedPr[1],
pDevObj->timeStamp));
mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer,
VP880_DC_FEED_WRT, VP880_DC_FEED_LEN, pLineObj->calLineData.dcFeedPr);
/* Second byte contains the lower two bits of VAS */
pDevObj->vp880SysCalData.vas[channelId][VP880_REV_POLARITY] =
((pLineObj->calLineData.dcFeedPr[1] >> 6) & 0x3);
/* First byte contains the upper two bits of VAS */
pDevObj->vp880SysCalData.vas[channelId][VP880_REV_POLARITY] |=
((pLineObj->calLineData.dcFeedPr[0] << 2) & 0xC);
runAnotherState = TRUE;
nextState = VP880_VAB_PR_SETUP;
break;
}
#endif
/***********************************************************************
* Measure VAB (VOC) in polrev -
*
* These two states setup and measure the VAB (VOC) value in polrev.
**********************************************************************/
case VP880_VAB_PR_SETUP: {
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_VAB_PR_SETUP"));
SetAdc(pLineCtx, deviceId, ecVal, VP880_METALLIC_DC_V);
*pCalTimerMs = 10; /* wait for data */
nextState = VP880_VAB_PR_MEASURE;
break;
}
case VP880_VAB_PR_MEASURE: {
int16 *pVocRev = &pLineObj->calLineData.typeData.vocData.vocRev;
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_VAB_PR_MEASURE"));
if ( !GetXData(pLineCtx, deviceId, ecVal, pVocRev)) {
*pCalTimerMs = 10;
nextState = VP880_VAB_PR_MEASURE;
} else {
runAnotherState = TRUE;
nextState = VP880_VAB_PR_ADC_OFFSET_SETUP;
}
break;
}
/***********************************************************************
* Measure VAB ADC offset in polrev -
*
* These two states setup and measure the ADC Tip to Ring voltage in
* polrev.
**********************************************************************/
case VP880_VAB_PR_ADC_OFFSET_SETUP: {
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_VAB_PR_ADC_OFFSET_SETUP"));
/* Disconnect tip and ring sense - start feed collapse */
pLineObj->icr6Values[0] = 0x00;
pLineObj->icr6Values[1] = (VP880_C_RING_SNS_CUT | VP880_C_TIP_SNS_CUT);
mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer,
VP880_ICR6_WRT, VP880_ICR6_LEN, pLineObj->icr6Values);
/* set the converter config register to measure Metallic DC Voltage */
SetAdc(pLineCtx, deviceId, ecVal, VP880_METALLIC_DC_V);
*pCalTimerMs = 10; /* wait for data */
nextState = VP880_VAB_PR_ADC_OFFSET_MEASURE;
break;
}
case VP880_VAB_PR_ADC_OFFSET_MEASURE: {
int16 temp = 0;
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_VAB_PR_ADC_OFFSET_MEASURE"));
if ( !GetXData(pLineCtx, deviceId, ecVal, &temp)) {
*pCalTimerMs = 10;
nextState = VP880_VAB_PR_ADC_OFFSET_MEASURE;
} else {
pDevObj->vp880SysCalData.vocOffset[channelId][VP880_REV_POLARITY] = temp;
runAnotherState = TRUE;
nextState = VP880_VA_PR_ADC_OFFSET_SETUP;
}
break;
}
/***********************************************************************
* Measure VA ADC offset in polrev
*
* These two states setup and measure the ADC Tip to Gnd voltage
* offset in normal polarity.
**********************************************************************/
case VP880_VA_PR_ADC_OFFSET_SETUP: {
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_VA_PR_ADC_OFFSET_SETUP"));
/* set the converter config register to measure Tip DC Voltage */
SetAdc(pLineCtx, deviceId, ecVal, VP880_TIP_TO_GND_V);
*pCalTimerMs = 10; /* wait for data */
nextState = VP880_VA_PR_ADC_OFFSET_MEASURE;
break;
}
case VP880_VA_PR_ADC_OFFSET_MEASURE: {
int16 temp = 0;
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_VA_PR_ADC_OFFSET_MEASURE"));
if ( !GetXData(pLineCtx, deviceId, ecVal, &temp)) {
*pCalTimerMs = 10;
nextState = VP880_VA_PR_ADC_OFFSET_MEASURE;
} else {
/* compensate for the static offset of 1.5V on 880*/
pDevObj->vp880SysCalData.vagOffsetRev[channelId] = temp + 205;
runAnotherState = TRUE;
nextState = VP880_VB_PR_ADC_OFFSET_SETUP;
}
break;
}
/***********************************************************************
* Measure VB ADC offset in polrev
*
* These two states setup and measure the ADC RING to Gnd voltage
* offset in normal polarity.
**********************************************************************/
case VP880_VB_PR_ADC_OFFSET_SETUP: {
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_VB_PR_ADC_OFFSET_SETUP"));
/* set the converter config register to measure Ring DC Voltage */
SetAdc(pLineCtx, deviceId, ecVal, VP880_RING_TO_GND_V);
*pCalTimerMs = 10; /* wait for data */
nextState = VP880_VB_PR_ADC_OFFSET_MEASURE;
break;
}
case VP880_VB_PR_ADC_OFFSET_MEASURE: {
int16 temp = 0;
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_VB_PR_ADC_OFFSET_MEASURE"));
if ( !GetXData(pLineCtx, deviceId, ecVal, &temp)) {
*pCalTimerMs = 10;
nextState = VP880_VB_PR_ADC_OFFSET_MEASURE;
} else {
/* compensate for the static offset of 1.5V on 880*/
pDevObj->vp880SysCalData.vbgOffsetRev[channelId] = temp + 205;
runAnotherState = TRUE;
nextState = VP880_COLLAPSE_FEED;
}
break;
}
/***********************************************************************
* Collapse Feed
*
* This state collapses tip and ring and switches to normal polarity.
* This is done with the tip/ring sense cut to prevent a transient.
*
* We are also preparing the siggen A for calibration test.
**********************************************************************/
case VP880_COLLAPSE_FEED: {
/* Sig Gen A cal setup */
uint8 sigGenA[VP880_SIGA_PARAMS_LEN] =
{0x00, 0x00, 0x00, 0x0A, 0xAB, 0x00, 0x02, 0x00, 0x00 ,0x00, 0x00};
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_COLLAPSE_FEED"));
/* Disable VOC DAC */
pLineObj->icr2Values[0] |= 0x20;
pLineObj->icr2Values[1] &= ~0x20;
mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer,
VP880_ICR2_WRT, VP880_ICR2_LEN, pLineObj->icr2Values);
/* Re-Enable tip and ring sense */
pLineObj->icr6Values[0] = 0x00;
pLineObj->icr6Values[1] = 0x00;
mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer,
VP880_ICR6_WRT, VP880_ICR6_LEN, pLineObj->icr6Values);
/* switch to normal polarity */
pLineObj->slicValueCache &= ~VP880_SS_POLARITY_MASK;
VpMpiCmdWrapper(deviceId, ecVal, VP880_SYS_STATE_WRT,
VP880_SYS_STATE_LEN, &pLineObj->slicValueCache);
/*
* set the sig gen with 0 bias, almost no amplitude and
* 1000Hz use for ring offset
*/
mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer,
VP880_SIGA_PARAMS_WRT, VP880_SIGA_PARAMS_LEN, sigGenA);
*pCalTimerMs = 100;
nextState = VP880_GENA_NP_OFFSET_SETUP;
break;
}
/***********************************************************************
* Measure SIGGEN A offset -
*
* These states setup and measure the offset in the signal generator
**********************************************************************/
case VP880_GENA_NP_OFFSET_SETUP: {
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_GENA_NP_OFFSET_SETUP"));
/* store the current slicState */
pLineObj->calLineData.sysState = pLineObj->slicValueCache;
/* go to ringing state */
pLineObj->slicValueCache &= ~VP880_SS_STATE_MASK;
pLineObj->slicValueCache |= VP880_SS_BALANCED_RINGING;
VpMpiCmdWrapper(deviceId, ecVal, VP880_SYS_STATE_WRT,
VP880_SYS_STATE_LEN, &pLineObj->slicValueCache);
*pCalTimerMs = 20; /* wait for ringing */
nextState = VP880_GENA_NP_OFFSET_SET_ADC;
break;
}
case VP880_GENA_NP_OFFSET_SET_ADC: {
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_GENA_NP_OFFSET_SET_ADC"));
/* set the converter config register to measure Metallic DC Voltage */
SetAdc(pLineCtx, deviceId, ecVal, VP880_METALLIC_DC_V);
*pCalTimerMs = 10; /* wait for data */
nextState = VP880_GENA_NP_OFFSET_MEASURE;
break;
}
case VP880_GENA_NP_OFFSET_MEASURE: {
int16 temp = 0;
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_GENA_NP_OFFSET_MEASURE"));
if ( !GetXData(pLineCtx, deviceId, ecVal, &temp)) {
*pCalTimerMs = 10;
nextState = VP880_GENA_NP_OFFSET_MEASURE;
} else {
/* no need to measure offet in rev polrity */
pDevObj->vp880SysCalData.sigGenAError[channelId][VP880_NORM_POLARITY] = temp;
/*
* we must get the slic out of ringing before restoring
* siggen A or risk catching some of the ring cycle
* and pinging a phone.
*/
pLineObj->slicValueCache = pLineObj->calLineData.sysState;
VpMpiCmdWrapper(deviceId, ecVal, VP880_SYS_STATE_WRT,
VP880_SYS_STATE_LEN, &pLineObj->slicValueCache);
*pCalTimerMs = 10;
nextState = VP880_GENA_NP_OFFSET_RESTORE;
}
break;
}
case VP880_GENA_NP_OFFSET_RESTORE: {
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_GENA_NP_OFFSET_RESTORE"));
/* restore the siggen A register */
VpMpiCmdWrapper(deviceId, ecVal, VP880_SIGA_PARAMS_WRT,
VP880_SIGA_PARAMS_LEN, pLineObj->calLineData.sigGenA);
*pCalTimerMs = 30; /* give the device time to get out of ringing */
nextState = VP880_ILG_OFFSET_SETUP;
break;
}
/***********************************************************************
* Measure ILG offset -
*
* These two states setup and measure ILG offset in normal polarity.
* This measurement is take with tip/ring collapsed and sense enabled
**********************************************************************/
case VP880_ILG_OFFSET_SETUP: {
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_ILG_OFFSET_SETUP"));
/* set the converter config register to measure Logitudinal Current */
SetAdc(pLineCtx, deviceId, ecVal, VP880_LONGITUDINAL_DC_I);
*pCalTimerMs = 10; /* wait for data */
nextState = VP880_ILG_OFFSET_MEASURE;
break;
}
case VP880_ILG_OFFSET_MEASURE: {
int16 temp = 0;
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_ILG_OFFSET_MEASURE"));
if ( !GetXData(pLineCtx, deviceId, ecVal, &temp)) {
*pCalTimerMs = 10;
nextState = VP880_ILG_OFFSET_MEASURE;
} else {
pDevObj->vp880SysCalData.ilgOffsetNorm[channelId] = temp;
runAnotherState = TRUE;
nextState = VP880_ILA_OFFSET_SETUP;
}
break;
}
/***********************************************************************
* Measure ILA offset -
*
* These two states setup and measure ILA offset in normal polarity.
* This measurement is take with tip/ring collapsed and sense enabled
**********************************************************************/
case VP880_ILA_OFFSET_SETUP: {
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_ILA_OFFSET_SETUP"));
/* set the converter config register to measure Metallic DC Current */
SetAdc(pLineCtx, deviceId, ecVal, VP880_METALLIC_DC_I);
*pCalTimerMs = 10; /* wait for data */
nextState = VP880_ILA_OFFSET_MEASURE;
break;
}
case VP880_ILA_OFFSET_MEASURE: {
int16 temp = 0;
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_ILA_OFFSET_MEASURE"));
if ( !GetXData(pLineCtx, deviceId, ecVal, &temp)) {
*pCalTimerMs = 10;
nextState = VP880_ILA_OFFSET_MEASURE;
} else {
pDevObj->vp880SysCalData.ilaOffsetNorm[channelId] = temp;
runAnotherState = TRUE;
nextState = VP880_RESTORE_DAC;
}
break;
}
/***********************************************************************
* Restore Feed
*
* This state restores the DC Feed to the reference dc
* profile value and reenables the DAC while in normal polarity.
*
* Additionally, this state will disable tip/ring
* sense for future offset measurements in normal polarity.
**********************************************************************/
case VP880_RESTORE_DAC: {
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_RESTORE_DAC"));
/* Store the ref dcfeed from profile into normal cal dcfeed */
VpMemCpy(pLineObj->calLineData.dcFeed, pLineObj->calLineData.dcFeedRef,
VP880_DC_FEED_LEN);
#ifdef VP880_TRACKER_SUPPORT
if (!(pDevObj->stateInt & VP880_IS_ABS)) {
/* we want to start with a 3.0V VAS for tracker */
pLineObj->calLineData.dcFeed[0] &= 0xFC;
pLineObj->calLineData.dcFeed[1] &= 0x3F;
}
#endif
mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer,
VP880_DC_FEED_WRT, VP880_DC_FEED_LEN, pLineObj->calLineData.dcFeed);
/* Enable VOC DAC */
pLineObj->icr2Values[0] &= ~0x20;
mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer,
VP880_ICR2_WRT, VP880_ICR2_LEN, pLineObj->icr2Values);
/* disable tip and ring sense */
pLineObj->icr6Values[0] = 0x00;
pLineObj->icr6Values[1] = (VP880_C_RING_SNS_CUT | VP880_C_TIP_SNS_CUT);
mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer,
VP880_ICR6_WRT, VP880_ICR6_LEN, pLineObj->icr6Values);
runAnotherState = TRUE;
nextState = VP880_VAB_NP_ADC_OFFSET_SETUP;
break;
}
/***********************************************************************
* Measure VAB ADC offset in normal polarity -
*
* These two states setup and measure ADC Tip to RING voltage offset in
* normal polarity.
**********************************************************************/
case VP880_VAB_NP_ADC_OFFSET_SETUP: {
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_VAB_NP_ADC_OFFSET_SETUP"));
/* set the converter config register to measure Metallic DC Voltage */
SetAdc(pLineCtx, deviceId, ecVal, VP880_METALLIC_DC_V);
*pCalTimerMs = 10; /* wait for data */
nextState = VP880_VAB_NP_ADC_OFFSET_MEASURE;
break;
}
case VP880_VAB_NP_ADC_OFFSET_MEASURE: {
int16 temp = 0;
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_VAB_NP_ADC_OFFSET_MEASURE"));
if ( !GetXData(pLineCtx, deviceId, ecVal, &temp)) {
*pCalTimerMs = 10;
nextState = VP880_VAB_NP_ADC_OFFSET_MEASURE;
} else {
pDevObj->vp880SysCalData.vocOffset[channelId][VP880_NORM_POLARITY] = temp;
runAnotherState = TRUE;
nextState = VP880_VA_NP_ADC_OFFSET_SETUP;
}
break;
}
/***********************************************************************
* Measure VA ADC offset in normal polarity
*
* These two states setup and measure the ADC Tip to Gnd voltage
* offset in normal polarity.
**********************************************************************/
case VP880_VA_NP_ADC_OFFSET_SETUP: {
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_VA_NP_ADC_OFFSET_SETUP"));
/* set the converter config register to measure Tip DC Voltage */
SetAdc(pLineCtx, deviceId, ecVal, VP880_TIP_TO_GND_V);
*pCalTimerMs = 10; /* wait for data */
nextState = VP880_VA_NP_ADC_OFFSET_MEASURE;
break;
}
case VP880_VA_NP_ADC_OFFSET_MEASURE: {
int16 temp = 0;
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_VA_NP_ADC_OFFSET_MEASURE"));
if ( !GetXData(pLineCtx, deviceId, ecVal, &temp)) {
*pCalTimerMs = 10;
nextState = VP880_VA_NP_ADC_OFFSET_MEASURE;
} else {
/* compensate for the static offset of 1.5V on 880*/
pDevObj->vp880SysCalData.vagOffsetNorm[channelId] = temp + 205;
runAnotherState = TRUE;
nextState = VP880_VB_NP_ADC_OFFSET_SETUP;
}
break;
}
/***********************************************************************
* Measure VB ADC offset in normal polarity
*
* These two states setup and measure the ADC RING to Gnd voltage
* offset in normal polarity.
**********************************************************************/
case VP880_VB_NP_ADC_OFFSET_SETUP: {
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_VB_NP_ADC_OFFSET_SETUP"));
/* set the converter config register to measure Ring DC Voltage */
SetAdc(pLineCtx, deviceId, ecVal, VP880_RING_TO_GND_V);
*pCalTimerMs = 10; /* wait for data */
nextState = VP880_VB_NP_ADC_OFFSET_MEASURE;
break;
}
case VP880_VB_NP_ADC_OFFSET_MEASURE: {
int16 temp = 0;
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_VB_NP_ADC_OFFSET_MEASURE"));
if ( !GetXData(pLineCtx, deviceId, ecVal, &temp)) {
*pCalTimerMs = 10;
nextState = VP880_VB_NP_ADC_OFFSET_MEASURE;
} else {
/* compensate for the static offset of 1.5V on 880*/
pDevObj->vp880SysCalData.vbgOffsetNorm[channelId] = temp + 205;
runAnotherState = TRUE;
nextState = VP880_ILA_SETUP;
}
break;
}
/***********************************************************************
* Measure ILA at 4 different values -
*
* These xyz states setup and measure ILA offset in normal polarity
* at 4 different ILA settings (20, 25, 32 and 40mA).
**********************************************************************/
case VP880_ILA_SETUP: {
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_ILA_SETUP"));
/* prepare storage data */
pLineObj->calLineData.typeData.loopData.loopNum = 0;
pLineObj->calLineData.typeData.loopData.prevVal = 0;
pLineObj->calLineData.minVas = 0;
runAnotherState = TRUE;
nextState = VP880_ILA_ADJUST;
break;
}
case VP880_ILA_ADJUST: {
uint8 *pDcFeed = pLineObj->calLineData.dcFeed;
uint8 loopNum = pLineObj->calLineData.typeData.loopData.loopNum;
uint16 vasValue = VP880_VAS_CONVERSION(pDcFeed[0], pDcFeed[1]);
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_ILA_ADJUST"));
/* adjust the ila value and vas */
pDcFeed[1] &= ~VP880_ILA_MASK;
if (loopNum == 0) { /* 20mA */
pDcFeed[1] |= (VP880_ILA_MASK & 0x02);
vasValue = 3000;
} else if (loopNum == 1) { /* 25mA */
pDcFeed[1] |= (VP880_ILA_MASK & 0x07);
vasValue = 3750;
} else if (loopNum == 2) { /* 32mA */
pDcFeed[1] |= (VP880_ILA_MASK & 0x0E);
vasValue = 4500;
} else if (loopNum == 3) { /* 40mA */
pDcFeed[1] |= (VP880_ILA_MASK & 0x16);
vasValue = 5250;
} else {
/*
* If we're here, it's because off-hook has not yet been
* detected with VAS increments, so we have to continue past
* normal ILA calibration.
*/
vasValue += 750;
}
#ifdef VP880_TRACKER_SUPPORT
/* only adjust VAS if device is a tracking supply */
if (!(pDevObj->stateInt & VP880_IS_ABS)) {
if (vasValue < VP880_VAS_MAX) {
VpCSLACSetVas(pDcFeed, vasValue);
} else {
/* ERROR!! Cannot increase VAS. Need to move on */
pLineObj->calLineData.minVas = VP880_VAS_MAX;
runAnotherState = TRUE;
nextState = VP880_RESTORE_FEED;
}
}
#endif
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("VP880_ILA_ADJUST: Writing DC FEED 0x%02X 0x%02X", pDcFeed[0], pDcFeed[1]));
VpMpiCmdWrapper(deviceId, ecVal, VP880_DC_FEED_WRT, VP880_DC_FEED_LEN, pDcFeed);
*pCalTimerMs = 10;
nextState = VP880_ILA_SET_ADC;
break;
}
case VP880_ILA_SET_ADC: {
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_ILA_SET_ADC"));
/* set the converter config register to measure Metallic DC Current */
SetAdc(pLineCtx, deviceId, ecVal, VP880_METALLIC_DC_I);
*pCalTimerMs = 10;
nextState = VP880_ILA_MEASURE;
break;
}
case VP880_ILA_MEASURE: {
int16 temp = 0;
uint8 loopNum = pLineObj->calLineData.typeData.loopData.loopNum;
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_ILA_MEASURE"));
if ( !GetXData(pLineCtx, deviceId, ecVal, &temp)) {
*pCalTimerMs = 10;
nextState = VP880_ILA_MEASURE;
break;
}
/* store the measured ila data */
if (loopNum == 0) { /* 20mA */
pDevObj->vp880SysCalData.ila20[channelId] = temp;
} else if (loopNum == 1) { /* 25mA */
pDevObj->vp880SysCalData.ila25[channelId] = temp;
} else if (loopNum == 2) { /* 32mA */
pDevObj->vp880SysCalData.ila32[channelId] = temp;
} else if (loopNum == 3) { /* 40mA */
pDevObj->vp880SysCalData.ila40[channelId] = temp;
}
runAnotherState = TRUE;
if (!(pDevObj->stateInt & VP880_IS_ABS)) {
#ifdef VP880_TRACKER_SUPPORT
nextState = VP880_ILA_MEASURE_TRACKER;
#endif
} else {
#ifdef VP880_ABS_SUPPORT
nextState = VP880_ILA_MEASURE_ABS;
#endif
}
break;
}
case VP880_ILA_MEASURE_TRACKER: {
uint8 sigReg[VP880_NO_UL_SIGREG_LEN];
uint16 vasValue;
VpMpiCmdWrapper(deviceId, ecVal, VP880_NO_UL_SIGREG_RD,
VP880_NO_UL_SIGREG_LEN, sigReg);
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("VP880_ILA_MEASURE: SIG REG 0x%02X 0x%02X", sigReg[0], sigReg[1]));
if ((sigReg[channelId] & VP880_HOOK1_MASK) && (pLineObj->calLineData.minVas == 0)) {
vasValue = VP880_VAS_CONVERSION(
pLineObj->calLineData.dcFeed[0],
pLineObj->calLineData.dcFeed[1]);
if (vasValue < VP880_VAS_MAX) {
pLineObj->calLineData.minVas = vasValue;
} else {
pLineObj->calLineData.minVas = VP880_VAS_MAX;
}
VP_CALIBRATION(VpLineCtxType, pLineCtx, ("VP880_ILA_MEASURE: Saving Min VAS (%d)",
pLineObj->calLineData.minVas));
}
if ((pLineObj->calLineData.typeData.loopData.loopNum++ < 3)
|| (!(sigReg[channelId] & VP880_HOOK1_MASK))) {
nextState = VP880_ILA_ADJUST;
} else {
nextState = VP880_RESTORE_FEED;
}
runAnotherState = TRUE;
break;
}
case VP880_ILA_MEASURE_ABS:
if (pLineObj->calLineData.typeData.loopData.loopNum++ < 3) {
nextState = VP880_ILA_ADJUST;
} else {
nextState = VP880_RESTORE_FEED;
}
runAnotherState = TRUE;
break;
/***********************************************************************
* Restore Feed
*
* For the most part feed is already restored. All we do here is
* reenable the tip and ring sense and allow the line to settle.
**********************************************************************/
case VP880_RESTORE_FEED: {
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_RESTORE_FEED"));
/* Re-Enable tip and ring sense */
pLineObj->icr6Values[0] = 0x00;
pLineObj->icr6Values[1] = 0x00;
mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer,
VP880_ICR6_WRT, VP880_ICR6_LEN, pLineObj->icr6Values);
*pCalTimerMs = 10;
nextState = VP880_IMT_NP_SETUP;
break;
}
/***********************************************************************
* Settle IMT in PolRev -
*
* These states setup, measure Metallic current until it
* settles. This is done to prevent high REN loads from distorting
* the VAS measurements
**********************************************************************/
case VP880_IMT_NP_SETUP: {
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_IMT_NP_SETUP"));
/* prepare storage data */
pLineObj->calLineData.typeData.loopData.loopNum = 0;
pLineObj->calLineData.typeData.loopData.prevVal = 0;
runAnotherState = TRUE;
nextState = VP880_IMT_NP_SET_ADC;
break;
}
case VP880_IMT_NP_SET_ADC: {
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_IMT_NP_SET_ADC"));
SetAdc(pLineCtx, deviceId, ecVal, VP880_METALLIC_DC_I);
*pCalTimerMs = 10;
nextState = VP880_IMT_NP_MEASURE;
break;
}
case VP880_IMT_NP_MEASURE: {
int16 imOld = 0;
int16 imNew = 0;
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_IMT_NP_MEASURE"));
if ( !GetXData(pLineCtx, deviceId, ecVal, &imNew)) {
*pCalTimerMs = 10;
nextState = VP880_IMT_NP_MEASURE;
break;
}
/* if this is the first imt measurement then get another */
if (pLineObj->calLineData.typeData.loopData.loopNum++ == 0) {
pLineObj->calLineData.typeData.loopData.prevVal = imNew;
*pCalTimerMs = VP880_IMT_SETTLE_MS;
nextState = VP880_IMT_NP_MEASURE;
break;
}
imOld = pLineObj->calLineData.typeData.loopData.prevVal;
/* have we settled enough or taken to long > 200ms*/
if ( (pLineObj->calLineData.typeData.loopData.loopNum < 20 /*200ms*/) &&
(((imNew + 15 - imOld) & 0xFFE0) != 0) ) {
/* nope run it again */
pLineObj->calLineData.typeData.loopData.prevVal = imNew;
*pCalTimerMs = VP880_IMT_SETTLE_MS;
nextState = VP880_IMT_NP_MEASURE;
break;
}
if (!(pDevObj->stateInt & VP880_IS_ABS)) {
#ifdef VP880_TRACKER_SUPPORT
nextState = VP880_VAS_NP_SETUP;
#endif
} else {
#ifdef VP880_ABS_SUPPORT
nextState = VP880_VAB_NP_SETUP;
#endif
}
runAnotherState = TRUE;
break;
}
#ifdef VP880_TRACKER_SUPPORT
/***********************************************************************
* Measure VAS in Normal Polarity -
*
* These five states step through VAS values and measure IMT.
* The VAS adjustment portion of this process will continue until:
* VAS >= 14.25V ||
* new IMT < 10mA && (new IMT - old IMT are with in +9 to -7mA)
*
* If VAS reaches 14.25, proceed to Battery Adjustments.
**********************************************************************/
case VP880_VAS_NP_SETUP: {
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_VAS_NP_SETUP"));
/* prepare storage data */
pLineObj->calLineData.typeData.loopData.loopNum = 0;
pLineObj->calLineData.typeData.loopData.prevVal = 0;
pLineObj->calLineData.vasStart = 3000;
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("VP880_VAS_NP_SETUP: Best Actual VAS Start %d",
pLineObj->calLineData.vasStart));
runAnotherState = TRUE;
nextState = VP880_VAS_NP_STEP;
break;
}
case VP880_VAS_NP_STEP: {
uint8 loopNum = pLineObj->calLineData.typeData.loopData.loopNum;
uint16 vasVal = pLineObj->calLineData.vasStart + (750 * loopNum);
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_VAS_NP_STEP"));
/* If the calculated VAS is max, we need to move to battery steps */
if (vasVal > VP880_VAS_MAX) {
runAnotherState = TRUE;
nextState = VP880_VAS_NP_STORE;
break;
}
/* set VAS to the next value */
VpCSLACSetVas(pLineObj->calLineData.dcFeed, vasVal);
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("VP880_VAS_NP_STEP: Setting VAS (%d) with Values 0x%02X 0x%02X at time %d",
vasVal,
pLineObj->calLineData.dcFeed[0], pLineObj->calLineData.dcFeed[1],
pDevObj->timeStamp));
mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer,
VP880_DC_FEED_WRT, VP880_DC_FEED_LEN, pLineObj->calLineData.dcFeed);
/* dcfeed takes 100ms to settle after each step be very carefull adjusting this */
*pCalTimerMs = VP880_DCFEED_SETTLE_MS;
nextState = VP880_VAS_NP_SET_ADC;
break;
}
case VP880_VAS_NP_SET_ADC: {
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_VAS_NP_SET_ADC"));
/* set the converter config register to measure Metallic DC Current */
SetAdc(pLineCtx, deviceId, ecVal, VP880_METALLIC_DC_I);
*pCalTimerMs = 10;
nextState = VP880_VAS_NP_MEASURE;
break;
}
case VP880_VAS_NP_MEASURE: {
int16 imtOld = pLineObj->calLineData.typeData.loopData.prevVal;
int16 imtNew = 0;
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_VAS_NP_MEASURE"));
if ( !GetXData(pLineCtx, deviceId, ecVal, &imtNew)) {
*pCalTimerMs = 10;
nextState = VP880_VAS_NP_MEASURE;
break;
}
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("VP880_VAS_NP_MEASURE: IMT Old %d IMT New %d",
imtOld, imtNew));
runAnotherState = TRUE;
if (pLineObj->calLineData.typeData.loopData.loopNum++ == 0) {
/* if this is the first imt measurement then get another */
nextState = VP880_VAS_NP_STEP;
} else if ((imtNew > VP880_IMT_10MA) ||
(((imtOld + 15 - imtNew) & 0xFFE0) != 0) ) {
/*
* if the measured value is greater than 10 mA or the difference
* between old and new values are greater +9/-7 then get another
*/
nextState = VP880_VAS_NP_STEP;
} else {
/* if there is nothing left then store the data */
nextState = VP880_VAS_NP_STORE;
}
/* replace the old with the new */
pLineObj->calLineData.typeData.loopData.prevVal = imtNew;
break;
}
case VP880_VAS_NP_STORE: {
uint16 vasVal;
uint8 dcFeed[VP880_DC_FEED_LEN];
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_VAS_NP_STORE"));
/* Compute final VAS Values */
VpMpiCmdWrapper(deviceId, ecVal, VP880_DC_FEED_RD, VP880_DC_FEED_LEN, dcFeed);
vasVal = VP880_VAS_CONVERSION(dcFeed[0], dcFeed[1]);
/*
* This function will determine if VAS is at max, and if so then
* increase Battery correction by the overhead amount.
*/
ComputeFinalVas(pLineCtx, &vasVal);
/*
* Set VAS to the final value. Note that this is NOT redundant from
* the previous read because VAS can actually be reduced. It is
* the case when VAS reaches max and a battery adjustment increases
* such that the total VAS_MAX + battery_adjust_actual is > the
* required VAS + Overhead. This occurs due to differences in step
* sizes betwen battery adjustment and VAS.
*
* Make sure VAS is not set below minimum determined from Battery
* Saturation Detection algorithm.
*/
if (vasVal < pLineObj->calLineData.minVas) {
vasVal = pLineObj->calLineData.minVas;
}
VpCSLACSetVas(pLineObj->calLineData.dcFeed, vasVal);
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("VP880_VAS_NP_STORE: Setting VAS (%d) with Final Values 0x%02X 0x%02X at time %d",
vasVal,
pLineObj->calLineData.dcFeed[0], pLineObj->calLineData.dcFeed[1],
pDevObj->timeStamp));
mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer,
VP880_DC_FEED_WRT, VP880_DC_FEED_LEN, pLineObj->calLineData.dcFeed);
/* Second byte contains the lower two bits of VAS */
pDevObj->vp880SysCalData.vas[channelId][VP880_NORM_POLARITY] =
((pLineObj->calLineData.dcFeed[1] >> 6) & 0x3);
/* First byte contains the upper two bits of VAS */
pDevObj->vp880SysCalData.vas[channelId][VP880_NORM_POLARITY] |=
((pLineObj->calLineData.dcFeed[0] << 2) & 0xC);
/*
* Make sure Reverse Polarity VAS is not set below minimum
* determined from Battery Saturation Detection algorithm.
*/
vasVal = VP880_VAS_CONVERSION(pLineObj->calLineData.dcFeedPr[0],
pLineObj->calLineData.dcFeedPr[1]);
if (vasVal < pLineObj->calLineData.minVas) {
VpCSLACSetVas(pLineObj->calLineData.dcFeedPr,
pLineObj->calLineData.minVas);
/* Second byte contains the lower two bits of VAS */
pDevObj->vp880SysCalData.vas[channelId][VP880_REV_POLARITY] =
((pLineObj->calLineData.dcFeedPr[1] >> 6) & 0x3);
/* First byte contains the upper two bits of VAS */
pDevObj->vp880SysCalData.vas[channelId][VP880_REV_POLARITY] |=
((pLineObj->calLineData.dcFeedPr[0] << 2) & 0xC);
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("VP880_VAS_NP_STORE: PolRev VAS below minVas (%d) - correcting VAS (%d) with Final Values 0x%02X 0x%02X at time %d",
pLineObj->calLineData.minVas, vasVal,
pLineObj->calLineData.dcFeedPr[0], pLineObj->calLineData.dcFeedPr[1],
pDevObj->timeStamp));
}
runAnotherState = TRUE;
nextState = VP880_VAB_NP_SETUP;
break;
}
#endif
/***********************************************************************
* Measure VAB (VOC) in normal polarity -
*
* These two states setup and measure the VAB (VOC) value in normal pol.
**********************************************************************/
case VP880_VAB_NP_SETUP: {
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_VAB_NP_SETUP"));
/* set the converter config register to measure Metallic DC Voltage */
SetAdc(pLineCtx, deviceId, ecVal, VP880_METALLIC_DC_V);
*pCalTimerMs = 10; /* wait for data */
nextState = VP880_VAB_NP_MEASURE;
break;
}
case VP880_VAB_NP_MEASURE: {
int16 temp = 0;
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_VAB_NP_MEASURE"));
if ( !GetXData(pLineCtx, deviceId, ecVal, &temp)) {
*pCalTimerMs = 10;
nextState = VP880_VAB_NP_MEASURE;
} else {
pLineObj->calLineData.typeData.vocData.vocNorm = temp;
runAnotherState = TRUE;
nextState = VP880_CAL_ADJUST;
}
break;
}
/***********************************************************************
* This state is used to perform calcualtions
**********************************************************************/
case VP880_CAL_ADJUST: {
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_CAL_ADJUST"));
/* Set VOC to the device profile value */
Vp880AdjustVoc(pLineCtx, ((pLineObj->calLineData.dcFeedRef[0] >> 2) & 0x7), FALSE);
/* Set ILA to the device profile value */
Vp880AdjustIla(pLineCtx, (pLineObj->calLineData.dcFeedRef[1] & VP880_ILA_MASK));
runAnotherState = TRUE;
nextState = VP880_CAL_RESTORE;
break;
}
/***********************************************************************
* This state is used to restore registers and clean up after cal
**********************************************************************/
case VP880_CAL_RESTORE: {
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Cal State VP880_CAL_RESTORE"));
/* Restore Device Mode */
pDevObj->devMode[0] |= VP880_DEV_MODE_TEST_DATA;
mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer,
VP880_DEV_MODE_WRT, VP880_DEV_MODE_LEN, pDevObj->devMode);
/* Restore Loop Supervision */
mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer,
VP880_LOOP_SUP_WRT, VP880_LOOP_SUP_LEN, pLineObj->calLineData.loopSup);
/* Restore Codec Mode */
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("VP880_CAL_RESTORE: Writing 0x%02X to Operating Functions",
pLineObj->calLineData.codecReg));
mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer,
VP880_OP_FUNC_WRT, VP880_OP_FUNC_LEN, &pLineObj->calLineData.codecReg);
/* Restore TX/RX PCM and enable HPF */
pLineObj->opCond[0] = (VP880_CUT_TXPATH | VP880_CUT_RXPATH);
mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer,
VP880_OP_COND_WRT, VP880_OP_COND_LEN, pLineObj->opCond);
/* Restore disn */
mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer,
VP880_DISN_WRT, VP880_DISN_LEN, pLineObj->calLineData.disnVal);
/* Restore vpGain */
mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer,
VP880_VP_GAIN_WRT, VP880_VP_GAIN_LEN, pLineObj->calLineData.vpGain);
/* Restore ICR2 */
mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer,
VP880_ICR2_WRT, VP880_ICR2_LEN, pLineObj->calLineData.icr2);
VpMemCpy(pLineObj->icr2Values, pLineObj->calLineData.icr2, VP880_ICR2_LEN);
/* Restore ICR3 */
mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer,
VP880_ICR3_WRT, VP880_ICR3_LEN, pLineObj->calLineData.icr3);
VpMemCpy(pLineObj->icr3Values, pLineObj->calLineData.icr3, VP880_ICR2_LEN);
/*
* Restore Line State (note: this won't correctly update the
* calibrated DC feed settings because we're still in calibration.
* So we have to do that manually)
*/
Vp880SetLineState(pLineCtx, pLineObj->lineState.usrCurrent);
if (pLineObj->calLineData.reversePol) {
/* write polrev dcfeed here */
mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer,
VP880_DC_FEED_WRT, VP880_DC_FEED_LEN, pLineObj->calLineData.dcFeedPr);
} else {
/* write normal dcfeed here */
mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer,
VP880_DC_FEED_WRT, VP880_DC_FEED_LEN, pLineObj->calLineData.dcFeed);
}
Vp880LLSetSysState(deviceId, pLineCtx, 0, FALSE);
#ifdef VP880_LP_SUPPORT
/* Force an update on the line */
Vp880LowPowerMode(pDevCtx);
#endif
break;
}
default:
VP_CALIBRATION(VpLineCtxType, pLineCtx,("Cal Error - Bad State jumping to DONE"));
pLineObj->calLineData.calLineState = VP880_CAL_RESTORE;
runAnotherState = TRUE;
pDevObj->responseData = VP_CAL_FAILURE;
break;
}
/* write down any data required by a state */
if (mpiIndex > 0) {
VpMpiCmdWrapper(deviceId, ecVal, mpiBuffer[0],
mpiIndex-1, &mpiBuffer[1]);
}
pLineObj->calLineData.calLineState = nextState;
return runAnotherState;
}
#ifdef VP880_TRACKER_SUPPORT
/*
* ComputeFinalVas()
* This function computes the final VAS value based on converged VAS and
* overhead. If the result exceeds silicon capabilities, the battery is
* adjusted and the new value saved to the device object error value. This
* value is directly used for Battery Settings and provided in the calibration
* profile (see VpCal(VP_CAL_GET_SYSTEM_COEFFF)).
*/
void
ComputeFinalVas(
VpLineCtxType *pLineCtx,
uint16 *vasValue)
{
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("ComputeFinalVas: Adding Overhead (%d) to base VAS Value (%d)",
VP880_VAS_OVERHEAD, *vasValue));
/*
* Apply known adjustments JUST to the computed VAS Value. This result does
* not need (yet) to correspond to a programmable value.
*/
*vasValue += VP880_VAS_OVERHEAD;
/*
* Determine if a battery adjustment is necessary just based on the required
* vas value exceeding programmable limits.
*/
if (*vasValue > VP880_VAS_MAX) {
Vp880LineObjectType *pLineObj = pLineCtx->pLineObj;
VpDevCtxType *pDevCtx = pLineCtx->pDevCtx;
Vp880DeviceObjectType *pDevObj = pDevCtx->pDevObj;
uint8 channelId = pLineObj->channelId; /* Used several times... */
int32 newTarget;
int16 targetCalVoltage, batteryCorrection, batteryOverage;
/*
* VAS and Battery Adjustments are in two different scales. This will
* require fixing one (VAS) and round up (Batttery Adjustment). It may
* give an overall lower VAS+Battery by rounding VAS because VAS is in
* lower steps, but the Battery needs to be minimized.
*
* Remove the maximum VAS setting and round the remaining to the nearest
* available battery step.
*/
batteryCorrection = (*vasValue - VP880_VAS_MAX);
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("ComputeFinalVas: Raw Battery Correction: %d",
batteryCorrection));
/* Convert the current setting into scale of 1mv */
targetCalVoltage = pDevObj->vp880SysCalData.abvError[0] * 10;
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("ComputeFinalVas: Target Cal Voltage (%d) mV from Cal Profile: (%d)",
targetCalVoltage, pDevObj->vp880SysCalData.abvError[0]));
/* Compute the unconstrained new battery calibration target. */
newTarget = (targetCalVoltage + batteryCorrection);
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("ComputeFinalVas: Current Battery Calibration %d New Target Theory %ld",
targetCalVoltage, newTarget));
/*
* At this point, the battery calibration target computed may not be
* programmable in the silicon. Round up and limit to the max setting.
* Keep track of the overage being programmed because we'll want to reduce
* VAS by this amount or as close as possible without going too low.
*/
batteryOverage = (VP880_BAT_CAL_STEP - (newTarget % VP880_BAT_CAL_STEP));
newTarget += batteryOverage;
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("ComputeFinalVas: Rounded Battery Correction: %ld", newTarget));
/*
* In case we can't adjust the battery enough to match the theoretical
* requirement, limit to max and disable VAS reduction.
*/
if (newTarget > VP880_BAT_CAL_MAX) {
newTarget = VP880_BAT_CAL_MAX;
batteryOverage = 0;
}
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("ComputeFinalVas: Final Battery Correction: %ld", newTarget));
/*
* The value is now in a programmable range, but does not correspond to
* the error scale from the calibration profile and stored in the device
* object. That is in 10mV, this is 10x greater than that.
*/
newTarget /= 10;
/*
* Make sure the value we just computed is NOT lower than the value
* previously computed. This can occur during VAS calibration due to
* differences in polarity.
*/
if (newTarget > pDevObj->vp880SysCalData.abvError[channelId]) {
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("ComputeFinalVas: Modifying Current ABV Error from %d to %d on Channel %d",
pDevObj->vp880SysCalData.abvError[channelId], (int16)newTarget, channelId));
pDevObj->vp880SysCalData.abvError[channelId] = (int16)newTarget;
/*
* Write to the silicon - make sure Wideband Mode Bit IF set is
* disabled for this write. It shouldn't occur, but be 100% sure
*/
Vp880BatteryCalAdjust(pDevObj, (pLineObj->ecVal & VP880_EC_BITS_MASK));
}
/*
* Don't forget that the pointer provided needs to correspond to the
* final VAS value being programmed. Reduce by as much as possible
* without reducing by more than theoretical.
*/
*vasValue = VP880_VAS_MAX
- (batteryOverage - (batteryOverage % VP880_VAS_STEP));
}
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("ComputeFinalVas: Overhead %d => rounded off final VAS %d",
VP880_VAS_OVERHEAD, *vasValue));
return;
}
#endif
static void
SetAdc(
VpLineCtxType *pLineCtx,
VpDeviceIdType deviceId,
uint8 ecVal,
uint8 adcRoute)
{
Vp880LineObjectType *pLineObj = pLineCtx->pLineObj;
uint8 adcConfig;
VpMpiCmdWrapper(deviceId, ecVal, VP880_CONV_CFG_RD,
VP880_CONV_CFG_LEN, &adcConfig);
/* set the adc requested measurement do not adjust the sample rate */
adcConfig = (adcConfig & ~VP880_CONV_CONNECT_BITS) | adcRoute;
/* adcConfig = adcRoute; */
VpMpiCmdWrapper(deviceId, ecVal, VP880_CONV_CFG_WRT,
VP880_CONV_CFG_LEN, &adcConfig);
/* store the currently requested ADC route */
pLineObj->calLineData.typeData.loopData.adcRoute = adcRoute;
/* reset the adcLoopCounter to 0*/
pLineObj->calLineData.typeData.loopData.adcLoopMax = 0;
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("INFO: setting ADC to 0x%02x", adcRoute));
return;
}
static bool
GetXData(
VpLineCtxType *pLineCtx,
VpDeviceIdType deviceId,
uint8 ecVal,
int16 *pData)
{
Vp880LineObjectType *pLineObj = pLineCtx->pLineObj;
uint8 *adcLoopMax = &pLineObj->calLineData.typeData.loopData.adcLoopMax;
uint8 reqAdcRoute = pLineObj->calLineData.typeData.loopData.adcRoute;
uint8 currentAdc;
VpMpiCmdWrapper(deviceId, ecVal, VP880_CONV_CFG_RD,
VP880_CONV_CFG_LEN, &currentAdc);
if ((currentAdc & 0xF) == reqAdcRoute) {
/*
* if the ADC is still set to what we want it to
* requested setting then take the measurement.
*/
uint8 xdata[2];
VpMpiCmdWrapper(deviceId, ecVal, VP880_TX_PCM_DATA_RD,
VP880_TX_PCM_DATA_LEN, xdata);
*pData = ( (((int16)xdata[0] << 8) & 0xFF00) | ((int16)xdata[1] & 0x00FF) );
return TRUE;
} else if ((*adcLoopMax)++ < 10) {
/*
* if the ADC is not correct but we have not exceeded
* our loopcount, then set it again and get out.
*/
uint8 adcAgain = (currentAdc & ~VP880_CONV_CONNECT_BITS) | reqAdcRoute;
VpMpiCmdWrapper(deviceId, ecVal, VP880_CONV_CFG_WRT,
VP880_CONV_CFG_LEN, &adcAgain);
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("WARNING: ADC route set to 0x%02X, trying for 0x%02x",
(currentAdc & 0x0F), reqAdcRoute));
return FALSE;
}
/*
* if the adc is still not right but we have
* exceeded our loop count then just move on
* and print a debug error.
*/
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("ERROR: unable to set ADC to %i after 10 attempts.. moving on", reqAdcRoute));
return TRUE;
}
/**
* Vp880AdcSettling() -- Tracker and ABS Function
* This function read ADC/PCM and set the converter register
*
* Preconditions:
* The device and line context must be created and initialized before calling
* this function.
*
* Postconditions:
* This function return the value pcm red.
*/
int16
Vp880AdcSettling(
Vp880DeviceObjectType *pDevObj,
uint8 ecVal,
uint8 adcConfig,
bool *validData)
{
VpDeviceIdType deviceId = pDevObj->deviceId;
uint8 xdataTemp[VP880_TX_PCM_DATA_LEN];
int16 tempNew;
uint8 cfg[VP880_CONV_CFG_LEN];
VP_API_FUNC_INT(None, VP_NULL, ("Vp880AdcSettling+"));
/*
* If the device mode was changed (by other channel), need to change it back
* so data can be taken.
*/
if ((pDevObj->staticInfo.rcnPcn[VP880_RCN_LOCATION] > VP880_REV_VC) &&
(pDevObj->devMode[0] & VP880_DEV_MODE_TEST_DATA)) {
pDevObj->devMode[0] &= ~(VP880_DEV_MODE_TEST_DATA);
VpMpiCmdWrapper(deviceId, ecVal, VP880_DEV_MODE_WRT, VP880_DEV_MODE_LEN,
pDevObj->devMode);
}
if (validData != VP_NULL) {
VpMpiCmdWrapper(deviceId, ecVal, VP880_CONV_CFG_RD, VP880_CONV_CFG_LEN, cfg);
if (cfg[0] != adcConfig) {
*validData = FALSE;
VP_CALIBRATION(None, NULL,("Vp880AdcSettling() - CONVERTER FAIL (0x%02X -> should be 0x%02X) on ecVal 0x%02X",
cfg[0], adcConfig, ecVal));
VpMpiCmdWrapper(deviceId, ecVal, VP880_CONV_CFG_WRT,
VP880_CONV_CFG_LEN, &adcConfig);
} else {
*validData = TRUE;
}
}
VpMpiCmdWrapper(deviceId, ecVal, VP880_TX_PCM_DATA_RD, VP880_TX_PCM_DATA_LEN,
xdataTemp);
tempNew = ((xdataTemp[0] << 8) | xdataTemp[1]);
VP_CALIBRATION(None, NULL,("Vp880AdcSettling(adcConfig = 0x%02X): AdcPcm %d ecVal 0x%02X",
adcConfig, tempNew, ecVal));
VP_API_FUNC_INT(None, VP_NULL, ("Vp880AdcSettling-"));
return tempNew;
} /* Vp880AdcSettling() */
#endif
#ifdef VP880_TRACKER_SUPPORT
/**
* Vp880BatteryCalAdjust()
* This function computes the battery calibration error and adjust the device
* register and object content.
*
* Preconditions:
* The device and line context must be created and initialized before calling
* this function.
*
* Postconditions:
* Battery calibration registers are adjusted. Device object is updated.
*/
void
Vp880BatteryCalAdjust(
Vp880DeviceObjectType *pDevObj,
uint8 ecVal)
{
uint8 channelId = ((ecVal == VP880_EC_CH1) ? 0 : 1);
VpDeviceIdType deviceId = pDevObj->deviceId;
uint8 swCal[VP880_BAT_CALIBRATION_LEN];
int32 abvError =
(pDevObj->vp880SysCalData.abvError[channelId] * 10000 / VP880_V_PCM_LSB);
uint16 swCalError;
VP_API_FUNC_INT(None, VP_NULL, ("Vp880BatteryCalAdjust+"));
VpMpiCmdWrapper(deviceId, ecVal, VP880_BAT_CALIBRATION_RD,
VP880_BAT_CALIBRATION_LEN, swCal);
swCal[0] &= ~(VP880_BAT_CAL_SWCAL_MASK);
/* Conversion from 7.324mV to 1.25V */
swCalError = (ABS(abvError) / 171);
if (((ABS(abvError) + 85) / 171) > swCalError) {
swCalError+=1;
}
swCalError = (swCalError > 3) ? 3 : swCalError;
swCal[0] |= (swCalError << 3);
/*
* Positive error means voltage is too low (not negative enough).
* Positive adjustment makes the battery voltage more negative.
*/
swCal[0] |= (abvError > 0) ? 0 : VP880_BAT_CAL_SWCAL_SIGN;
VP_CALIBRATION(None, VP_NULL,
("Ch %d: Battery Calibration Correction 0x%02X 0x%02X",
channelId, swCal[0], swCal[1]));
/*
* This write MUST take into account Wideband setting because it can occur
* during normal system operation using "Apply System Coefficients". If
* called during normal calibration, the value of pDevObj must be cleared
* of the Wideband setting.
*/
VpMpiCmdWrapper(deviceId, (pDevObj->ecVal | ecVal), VP880_BAT_CALIBRATION_WRT,
VP880_BAT_CALIBRATION_LEN, swCal);
pDevObj->vp880SysCalData.abvError[0] = swCal[0];
pDevObj->vp880SysCalData.abvError[1] = swCal[1];
VP_API_FUNC_INT(None, VP_NULL, ("Vp880BatteryCalAdjust-"));
return;
}
#endif
/**
* Vp880AdjustIla() -- Tracker and ABS Function
* This function adjusts the line object data for the adjusted ILA value. No
* changes are made however if ILA calibration was not previously done.
*
* Preconditions:
* The device and line context must be created and initialized before calling
* this function.
*
* Postconditions:
* If previous calibration done, return TRUE and adjust line object data.
* Otherwise, return FALSE and no line object change made.
*/
bool
Vp880AdjustIla(
VpLineCtxType *pLineCtx,
uint8 targetIla)
{
Vp880LineObjectType *pLineObj = pLineCtx->pLineObj;
VpDevCtxType *pDevCtx = pLineCtx->pDevCtx;
Vp880DeviceObjectType *pDevObj = pDevCtx->pDevObj;
uint8 channelId = pLineObj->channelId;
int32 imtMeasured = 0;
uint8 imtTarget;
int16 ilaError, imtActual;
uint8 ilaAdjust;
VP_API_FUNC_INT(VpLineCtxType, pLineCtx, ("Vp880AdjustIla+"));
/*
* This function can run IF we're currently in calibration OR if the line
* has been previously calibrated.
*/
if ((pLineObj->calLineData.calDone == FALSE) /* Line not previously calibrated */
&& (!(pLineObj->status & VP880_LINE_IN_CAL))) { /* Not currently in cal */
VP_API_FUNC_INT(VpLineCtxType, pLineCtx, ("Vp880AdjustIla-"));
return FALSE;
}
if (targetIla < 4) { /* 18mA to < 22mA */
imtMeasured = pDevObj->vp880SysCalData.ila20[channelId];
imtTarget = 20;
} else if (targetIla < 10) { /* 23mA to < 28mA */
imtMeasured = pDevObj->vp880SysCalData.ila25[channelId];
imtTarget = 25;
} else if (targetIla < 18) { /* 29mA to < 36mA */
imtMeasured = pDevObj->vp880SysCalData.ila32[channelId];
imtTarget = 32;
} else { /* 36mA and higher */
imtMeasured = pDevObj->vp880SysCalData.ila40[channelId];
imtTarget = 40;
}
/* Always force ref ILA into the the normal and rev polarity feeds */
pLineObj->calLineData.dcFeed[VP880_ILA_INDEX] &= ~VP880_ILA_MASK;
pLineObj->calLineData.dcFeed[VP880_ILA_INDEX] |=
(pLineObj->calLineData.dcFeedRef[VP880_ILA_INDEX] & VP880_ILA_MASK);
pLineObj->calLineData.dcFeedPr[VP880_ILA_INDEX] &= ~VP880_ILA_MASK;
pLineObj->calLineData.dcFeedPr[VP880_ILA_INDEX] |=
(pLineObj->calLineData.dcFeedRef[VP880_ILA_INDEX] & VP880_ILA_MASK);
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Vp880AdjustIla: dcFeedPr 0x%02X 0x%02X",
pLineObj->calLineData.dcFeedPr[0], pLineObj->calLineData.dcFeedPr[1]));
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Vp880AdjustIla: dcFeed 0x%02X 0x%02X",
pLineObj->calLineData.dcFeed[0], pLineObj->calLineData.dcFeed[1]));
/* determine the error */
imtActual = imtMeasured - pDevObj->vp880SysCalData.ilaOffsetNorm[channelId];
ilaError = imtActual - (imtTarget * VP880_ILA_SCALE_1MA);
/*
* only make an adjustment only if the error is greater
* than or equal to 500uA = 273 at PCM
*/
if (ABS(ilaError) >= (VP880_ILA_SCALE_1MA / 2)) {
uint8 tempIlaValue = pLineObj->calLineData.dcFeedRef[VP880_ILA_INDEX] & VP880_ILA_MASK;
int8 tempLowValue = (int8)tempIlaValue;
ilaAdjust = ((ABS(ilaError)+(VP880_ILA_SCALE_1MA / 2)) / VP880_ILA_SCALE_1MA);
if (ilaError < 0) {
tempIlaValue += ilaAdjust;
if (tempIlaValue <= VP880_ILA_MASK) {
pLineObj->calLineData.dcFeed[VP880_ILA_INDEX] += ilaAdjust;
} else {
pLineObj->calLineData.dcFeed[VP880_ILA_INDEX] |= VP880_ILA_MASK;
}
} else {
tempLowValue -= ilaAdjust;
if (tempLowValue >= 0) {
pLineObj->calLineData.dcFeed[VP880_ILA_INDEX] -= ilaAdjust;
} else {
pLineObj->calLineData.dcFeed[VP880_ILA_INDEX] &= ~VP880_ILA_MASK;
}
}
}
VP_CALIBRATION(VpLineCtxType, pLineCtx, ("Chan %d: ILA Actual Norm (10uA) %d",
channelId,
(int16)(imtActual * 100 / VP880_ILA_SCALE_1MA)));
VP_CALIBRATION(VpLineCtxType, pLineCtx, ("Chan %d: ILA Target (10uA) %d ILA Error Norm (10uA) %d",
channelId,
(int16)(((targetIla + 18) * 100)),
(int16)(ilaError * 100 / VP880_ILA_SCALE_1MA)));
VP_API_FUNC_INT(VpLineCtxType, pLineCtx, ("Vp880AdjustIla-"));
return TRUE;
} /* Vp880AdjustIla() */
/**
* Vp880AdjustVoc() -- Tracker and ABS Function
* This function adjusts the line object data for the adjusted VOC value. No
* changes are made however if VOC calibration was not previously done.
*
* Preconditions:
* The device and line context must be created and initialized before calling
* this function.
*
* Postconditions:
* If previous calibration done, return TRUE and adjust line object data.
* Otherwise, return FALSE and no line object change made.
*/
bool
Vp880AdjustVoc(
VpLineCtxType *pLineCtx,
uint8 targetVoc,
bool previousCal)
{
Vp880LineObjectType *pLineObj = pLineCtx->pLineObj;
uint8 channelId = pLineObj->channelId;
VpDevCtxType *pDevCtx = pLineCtx->pDevCtx;
Vp880DeviceObjectType *pDevObj = pDevCtx->pDevObj;
int16 vocActual, vocActualRev;
int32 pcmTargetVoc;
int16 vocErrorList[VP880_NUM_POLARITY];
uint8 vocErrIndex;
uint8 *dcFeedByte[VP880_NUM_POLARITY];
VP_API_FUNC_INT(VpLineCtxType, pLineCtx, ("Vp880AdjustVoc+"));
dcFeedByte[VP880_NORM_POLARITY] = &(pLineObj->calLineData.dcFeed[0]);
dcFeedByte[VP880_REV_POLARITY] = &(pLineObj->calLineData.dcFeedPr[0]);
pcmTargetVoc = (int32)(targetVoc * 3);
pcmTargetVoc += 36;
pcmTargetVoc *= VP880_V_1V_SCALE;
pcmTargetVoc /= VP880_V_1V_RANGE;
if (previousCal == FALSE) {
vocActual =
pLineObj->calLineData.typeData.vocData.vocNorm
- pDevObj->vp880SysCalData.vocOffset[channelId][VP880_NORM_POLARITY];
vocActualRev =
pLineObj->calLineData.typeData.vocData.vocRev
- pDevObj->vp880SysCalData.vocOffset[channelId][VP880_REV_POLARITY];
/*
* Target is always positive. Normal feed is positive. Negative error means
* voltage is too low (magnitude), positive means too high (magnitude).
*/
pDevObj->vp880SysCalData.vocError[channelId][VP880_NORM_POLARITY] = (vocActual - (int16)pcmTargetVoc);
VP_CALIBRATION(VpLineCtxType, pLineCtx, ("(In 10mV): VOC Norm %d Rev %d OffsetNorm %d OffsetRev %d Channel %d",
(int16)(pLineObj->calLineData.typeData.vocData.vocNorm * VP880_V_PCM_LSB/VP880_V_SCALE),
(int16)(pLineObj->calLineData.typeData.vocData.vocRev * VP880_V_PCM_LSB/VP880_V_SCALE),
(int16)(pDevObj->vp880SysCalData.vocOffset[channelId][VP880_NORM_POLARITY] * VP880_V_PCM_LSB/VP880_V_SCALE),
(int16)(pDevObj->vp880SysCalData.vocOffset[channelId][VP880_REV_POLARITY] * VP880_V_PCM_LSB/VP880_V_SCALE),
channelId));
VP_CALIBRATION(VpLineCtxType, pLineCtx, ("Chan %d: VOC (10mV) Actual Norm %d Rev Norm %d",
channelId,
(int16)(vocActual * VP880_V_PCM_LSB/VP880_V_SCALE),
(int16)(vocActualRev * VP880_V_PCM_LSB/VP880_V_SCALE)));
/*
* Target is always positive. Reverse feed is negative. Negative error means
* voltage is too low (magnitude), positive means too high (magnitude).
*/
pDevObj->vp880SysCalData.vocError[channelId][VP880_REV_POLARITY] = (-vocActualRev - (int16)pcmTargetVoc);
VP_CALIBRATION(VpLineCtxType, pLineCtx, ("Chan %d: VOC Target %d VOC Error Norm %d Error Rev %d",
channelId,
(int16)((targetVoc * 3 + 36) * 100),
(int16)(pDevObj->vp880SysCalData.vocError[channelId][VP880_NORM_POLARITY] * VP880_V_PCM_LSB/VP880_V_SCALE),
(int16)(pDevObj->vp880SysCalData.vocError[channelId][VP880_REV_POLARITY] * VP880_V_PCM_LSB/VP880_V_SCALE)));
VP_CALIBRATION(VpLineCtxType, pLineCtx, ("Chan %d: DC Feed Values Normal Before 0x%02X 0x%02X",
channelId, pLineObj->calLineData.dcFeed[0],
pLineObj->calLineData.dcFeed[1]));
VP_CALIBRATION(VpLineCtxType, pLineCtx, ("Chan %d: DC Feed Values Reverse Before 0x%02X 0x%02X",
channelId, pLineObj->calLineData.dcFeedPr[0],
pLineObj->calLineData.dcFeedPr[1]));
}
/*
* Adjust if error is more than 1/2 a step size for each parameter based
* on PCM scale.
*/
vocErrorList[VP880_NORM_POLARITY] = pDevObj->vp880SysCalData.vocError[channelId][VP880_NORM_POLARITY];
vocErrorList[VP880_REV_POLARITY] = pDevObj->vp880SysCalData.vocError[channelId][VP880_REV_POLARITY];
for (vocErrIndex = 0; vocErrIndex < VP880_NUM_POLARITY; vocErrIndex++) {
/* VOC Scale: 1.5V = 204.8 at PCM. Adjust to account for bit shift */
if (ABS(vocErrorList[vocErrIndex]) >= 205) {
if (vocErrorList[vocErrIndex] < 0) {
/* Error is low, so need to increase VOC */
/* Saturate the value, to prevent the rollover */
if ((*dcFeedByte[vocErrIndex] & VP880_VOC_MASK) != VP880_VOC_MASK) {
/* Not saturated within scale. So can adjust up */
*dcFeedByte[vocErrIndex] += 0x04;
} else if ((*dcFeedByte[vocErrIndex] & VP880_VOC_LOW_RANGE) ==
VP880_VOC_LOW_RANGE) {
/*
* Saturated within scale, but not within device. Change
* scale (moves up 3V) and clear incremental values or we'll
* end up at the top of the high range.
*/
*dcFeedByte[vocErrIndex] &= ~VP880_VOC_MASK;
*dcFeedByte[vocErrIndex] &= ~VP880_VOC_LOW_RANGE;
}
} else {
/* Error is high, so need to decrease VOC */
/* Saturate the value, to prevent the rollover */
if ((*dcFeedByte[vocErrIndex] & VP880_VOC_MASK) != 0x00) {
/* Not saturated within scale. So can adjust down */
*dcFeedByte[vocErrIndex] -= 0x04;
} else if ((*dcFeedByte[vocErrIndex] & VP880_VOC_LOW_RANGE) !=
VP880_VOC_LOW_RANGE) {
/*
* Saturated within scale, but not within device. Change
* scale (moves down 3V) and max incremental values or we'll
* end up at the bottom of the low range.
*/
*dcFeedByte[vocErrIndex] |= VP880_VOC_MASK;
*dcFeedByte[vocErrIndex] |= VP880_VOC_LOW_RANGE;
}
}
}
}
VP_CALIBRATION(VpLineCtxType, pLineCtx, ("Vp880AdjustVoc() Chan %d: DC Feed Values Normal After 0x%02X 0x%02X",
channelId, pLineObj->calLineData.dcFeed[0],
pLineObj->calLineData.dcFeed[1]));
VP_CALIBRATION(VpLineCtxType, pLineCtx, ("Vp880AdjustVoc() Chan %d: DC Feed Values Reverse After 0x%02X 0x%02X",
channelId, pLineObj->calLineData.dcFeedPr[0],
pLineObj->calLineData.dcFeedPr[1]));
VP_API_FUNC_INT(VpLineCtxType, pLineCtx, ("Vp880AdjustVoc-"));
return TRUE;
} /* Vp880AdjustVoc() */
/**
* Vp880Cal() -- Tracker and ABS Function
* This function calibrates a selected block of the device/line.
*
* Preconditions:
* The device and line context must be created and initialized before calling
* this function.
*
* Postconditions:
* This function generates an event upon completing the requested action.
*/
VpStatusType
Vp880Cal(
VpLineCtxType *pLineCtx,
VpCalType calType,
void *inputArgs)
{
Vp880LineObjectType *pLineObj = pLineCtx->pLineObj;
VpDevCtxType *pDevCtx = pLineCtx->pDevCtx;
Vp880DeviceObjectType *pDevObj = pDevCtx->pDevObj;
VpDeviceIdType deviceId = pDevObj->deviceId;
VpStatusType status = VP_STATUS_SUCCESS;
uint8 profileIndex;
uint8 *profileData;
VP_API_FUNC_INT(VpLineCtxType, pLineCtx, ("Vp880Cal+"));
VpSysEnterCritical(deviceId, VP_CODE_CRITICAL_SEC);
switch(calType) {
case VP_CAL_GET_SYSTEM_COEFF:
if (pDevObj->stateInt & VP880_SYS_CAL_COMPLETE) {
/* Data length is header (6 bytes) + 880 calibration data */
pDevObj->mpiLen = 6 + VP880_CAL_STRUCT_SIZE;
pLineObj->responseData = (uint8)VP_CAL_GET_SYSTEM_COEFF;
pLineObj->lineEvents.response |= VP_EVID_CAL_CMP;
} else {
status = VP_STATUS_LINE_NOT_CONFIG;
}
break;
case VP_CAL_APPLY_SYSTEM_COEFF:
profileData = (uint8 *)inputArgs;
if (profileData == VP_NULL) {
VpMemSet(&pDevObj->vp880SysCalData, 0, sizeof(Vp880SysCalResultsType));
pDevObj->stateInt &= ~(VP880_SYS_CAL_COMPLETE | VP880_CAL_RELOAD_REQ | VP880_DEVICE_CAL_COMPLETE);
pDevObj->stateInt |= VP880_SYS_CAL_RESET;
pLineObj->lineEvents.response |= VP_EVID_CAL_CMP;
pLineObj->responseData = VP_CAL_SUCCESS;
VP_API_FUNC_INT(VpLineCtxType, pLineCtx, ("Vp880Cal-"));
VpSysExitCritical(deviceId, VP_CODE_CRITICAL_SEC);
return VP_STATUS_SUCCESS;
}
if ((profileData[VP_PROFILE_TYPE_LSB] != VP_PRFWZ_PROFILE_CAL) ||
(profileData[VP_PROFILE_TYPE_MSB] != VP_DEV_880_SERIES) ||
(profileData[VP_PROFILE_LENGTH] < (VP880_CAL_STRUCT_SIZE + 2))) {
VP_API_FUNC_INT(VpLineCtxType, pLineCtx, ("Vp880Cal-"));
VpSysExitCritical(deviceId, VP_CODE_CRITICAL_SEC);
return VP_STATUS_INVALID_ARG;
}
profileIndex = VP_PROFILE_DATA_START;
pDevObj->vp880SysCalData.abvError[0] = VpConvertToInt16(&profileData[profileIndex]);
profileIndex+=2;
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("ABV Y Error %d", pDevObj->vp880SysCalData.abvError[0]));
pDevObj->vp880SysCalData.abvError[1] = VpConvertToInt16(&profileData[profileIndex]);
profileIndex+=2;
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("ABV Z Error %d", pDevObj->vp880SysCalData.abvError[1]));
pDevObj->vp880SysCalData.vocOffset[0][0] = VpConvertToInt16(&profileData[profileIndex]);
profileIndex+=2;
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("VOC Offset Norm Ch 0 %d", pDevObj->vp880SysCalData.vocOffset[0][0]));
pDevObj->vp880SysCalData.vocError[0][0] = VpConvertToInt16(&profileData[profileIndex]);
profileIndex+=2;
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("VOC Error Norm Ch 0 %d", pDevObj->vp880SysCalData.vocError[0][0]));
pDevObj->vp880SysCalData.vocOffset[0][1] = VpConvertToInt16(&profileData[profileIndex]);
profileIndex+=2;
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("VOC Offset Rev Ch 0 %d", pDevObj->vp880SysCalData.vocOffset[0][1]));
pDevObj->vp880SysCalData.vocError[0][1] = VpConvertToInt16(&profileData[profileIndex]);
profileIndex+=2;
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("VOC Error Rev Ch 0 %d", pDevObj->vp880SysCalData.vocError[0][1]));
pDevObj->vp880SysCalData.vocOffset[1][0] = VpConvertToInt16(&profileData[profileIndex]);
profileIndex+=2;
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("VOC Offset Norm Ch 1 %d", pDevObj->vp880SysCalData.vocOffset[1][0]));
pDevObj->vp880SysCalData.vocError[1][0] = VpConvertToInt16(&profileData[profileIndex]);
profileIndex+=2;
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("VOC Error Norm Ch 1 %d", pDevObj->vp880SysCalData.vocError[1][0]));
pDevObj->vp880SysCalData.vocOffset[1][1] = VpConvertToInt16(&profileData[profileIndex]);
profileIndex+=2;
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("VOC Offset Rev Ch 1 %d", pDevObj->vp880SysCalData.vocOffset[1][1]));
pDevObj->vp880SysCalData.vocError[1][1] = VpConvertToInt16(&profileData[profileIndex]);
profileIndex+=2;
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("VOC Error Rev Ch 1 %d", pDevObj->vp880SysCalData.vocError[1][1]));
pDevObj->vp880SysCalData.sigGenAError[0][0] = VpConvertToInt16(&profileData[profileIndex]);
profileIndex+=2;
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("SigGenA Norm Ch 0 Error %d", pDevObj->vp880SysCalData.sigGenAError[0][0]));
pDevObj->vp880SysCalData.sigGenAError[0][1] = VpConvertToInt16(&profileData[profileIndex]);
profileIndex+=2;
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("SigGenA Rev Ch 0 Error %d", pDevObj->vp880SysCalData.sigGenAError[0][1]));
pDevObj->vp880SysCalData.sigGenAError[1][0] = VpConvertToInt16(&profileData[profileIndex]);
profileIndex+=2;
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("SigGenA Norm Ch 1 Error %d", pDevObj->vp880SysCalData.sigGenAError[1][0]));
pDevObj->vp880SysCalData.sigGenAError[1][1] = VpConvertToInt16(&profileData[profileIndex]);
profileIndex+=2;
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("SigGenA Rev Ch 1 Error %d", pDevObj->vp880SysCalData.sigGenAError[1][1]));
pDevObj->vp880SysCalData.ila20[0] = VpConvertToInt16(&profileData[profileIndex]);
profileIndex+=2;
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("ILA 20mA Ch 0 %d", pDevObj->vp880SysCalData.ila20[0]));
pDevObj->vp880SysCalData.ila20[1] = VpConvertToInt16(&profileData[profileIndex]);
profileIndex+=2;
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("ILA 20mA Ch 1 %d", pDevObj->vp880SysCalData.ila20[1]));
pDevObj->vp880SysCalData.ila25[0] = VpConvertToInt16(&profileData[profileIndex]);
profileIndex+=2;
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("ILA 25mA Ch 0 %d", pDevObj->vp880SysCalData.ila25[0]));
pDevObj->vp880SysCalData.ila25[1] = VpConvertToInt16(&profileData[profileIndex]);
profileIndex+=2;
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("ILA 25mA Ch 1 %d", pDevObj->vp880SysCalData.ila25[1]));
pDevObj->vp880SysCalData.ila32[0] = VpConvertToInt16(&profileData[profileIndex]);
profileIndex+=2;
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("ILA 32mA Ch 0 %d", pDevObj->vp880SysCalData.ila32[0]));
pDevObj->vp880SysCalData.ila32[1] = VpConvertToInt16(&profileData[profileIndex]);
profileIndex+=2;
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("ILA 32mA Ch 1 %d", pDevObj->vp880SysCalData.ila32[1]));
pDevObj->vp880SysCalData.ila40[0] = VpConvertToInt16(&profileData[profileIndex]);
profileIndex+=2;
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("ILA 40mA Ch 0 %d", pDevObj->vp880SysCalData.ila40[0]));
pDevObj->vp880SysCalData.ila40[1] = VpConvertToInt16(&profileData[profileIndex]);
profileIndex+=2;
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("ILA 40mA Ch 1 %d", pDevObj->vp880SysCalData.ila40[1]));
pDevObj->vp880SysCalData.ilaOffsetNorm[0] = VpConvertToInt16(&profileData[profileIndex]);
profileIndex+=2;
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("ILA Offset Ch 0 %d", pDevObj->vp880SysCalData.ilaOffsetNorm[0]));
pDevObj->vp880SysCalData.ilaOffsetNorm[1] = VpConvertToInt16(&profileData[profileIndex]);
profileIndex+=2;
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("ILA Offset Ch 1 %d", pDevObj->vp880SysCalData.ilaOffsetNorm[1]));
pDevObj->vp880SysCalData.ilgOffsetNorm[0] = VpConvertToInt16(&profileData[profileIndex]);
profileIndex+=2;
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("ILG Offset Ch 0 %d", pDevObj->vp880SysCalData.ilgOffsetNorm[0]));
pDevObj->vp880SysCalData.ilgOffsetNorm[1] = VpConvertToInt16(&profileData[profileIndex]);
profileIndex+=2;
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("ILG Offset Ch 1 %d", pDevObj->vp880SysCalData.ilgOffsetNorm[1]));
pDevObj->vp880SysCalData.vas[0][0] = profileData[profileIndex++];
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("VAS Norm Ch 0 %d", pDevObj->vp880SysCalData.vas[0][0]));
pDevObj->vp880SysCalData.vas[0][1] = profileData[profileIndex++];
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("VAS Rev Ch 0 %d", pDevObj->vp880SysCalData.vas[0][1]));
pDevObj->vp880SysCalData.vas[1][0] = profileData[profileIndex++];
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("VAS Norm Ch 1 %d", pDevObj->vp880SysCalData.vas[1][0]));
pDevObj->vp880SysCalData.vas[1][1] = profileData[profileIndex++];
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("VAS Rev Ch 1 %d", pDevObj->vp880SysCalData.vas[1][1]));
pDevObj->vp880SysCalData.vagOffsetNorm[0] = VpConvertToInt16(&profileData[profileIndex]);
profileIndex+=2;
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("VAG Offset Norm Ch 0 %d", pDevObj->vp880SysCalData.vagOffsetNorm[0]));
pDevObj->vp880SysCalData.vagOffsetNorm[1] = VpConvertToInt16(&profileData[profileIndex]);
profileIndex+=2;
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("VAG Offset Norm Ch 1 %d", pDevObj->vp880SysCalData.vagOffsetNorm[1]));
pDevObj->vp880SysCalData.vagOffsetRev[0] = VpConvertToInt16(&profileData[profileIndex]);
profileIndex+=2;
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("VAG Offset Rev Ch 0 %d", pDevObj->vp880SysCalData.vagOffsetRev[0]));
pDevObj->vp880SysCalData.vagOffsetRev[1] = VpConvertToInt16(&profileData[profileIndex]);
profileIndex+=2;
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("VAG Offset Rev Ch 1 %d", pDevObj->vp880SysCalData.vagOffsetRev[1]));
pDevObj->vp880SysCalData.vbgOffsetNorm[0] = VpConvertToInt16(&profileData[profileIndex]);
profileIndex+=2;
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("VBG Offset Norm Ch 0 %d", pDevObj->vp880SysCalData.vbgOffsetNorm[0]));
pDevObj->vp880SysCalData.vbgOffsetNorm[1] = VpConvertToInt16(&profileData[profileIndex]);
profileIndex+=2;
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("VBG Offset Norm Ch 1 %d", pDevObj->vp880SysCalData.vbgOffsetNorm[1]));
pDevObj->vp880SysCalData.vbgOffsetRev[0] = VpConvertToInt16(&profileData[profileIndex]);
profileIndex+=2;
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("VBG Offset Rev Ch 0 %d", pDevObj->vp880SysCalData.vbgOffsetRev[0]));
pDevObj->vp880SysCalData.vbgOffsetRev[1] = VpConvertToInt16(&profileData[profileIndex]);
profileIndex+=2;
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("VBG Offset Rev Ch 1 %d", pDevObj->vp880SysCalData.vbgOffsetRev[1]));
pDevObj->vp880SysCalData.absNormCal[0] = profileData[profileIndex++];
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("Auto-Bat Switch Norm Ch 0 Cal %d", pDevObj->vp880SysCalData.absNormCal[0]));
pDevObj->vp880SysCalData.absPolRevCal[0] = profileData[profileIndex++];
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("Auto-Bat Switch Rev Ch 0 Cal %d", pDevObj->vp880SysCalData.absPolRevCal[0]));
pDevObj->vp880SysCalData.absNormCal[1] = profileData[profileIndex++];
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("Auto-Bat Switch Norm Ch 1 Cal %d", pDevObj->vp880SysCalData.absNormCal[1]));
pDevObj->vp880SysCalData.absPolRevCal[1] = profileData[profileIndex++];
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("Auto-Bat Switch Rev Ch 1 Cal %d", pDevObj->vp880SysCalData.absPolRevCal[1]));
pDevObj->vp880SysCalData.swyOffset[0] = VpConvertToInt16(&profileData[profileIndex]);
profileIndex+=2;
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("SWY Offset Ch 0 %d", pDevObj->vp880SysCalData.swyOffset[0]));
pDevObj->vp880SysCalData.swyOffset[1] = VpConvertToInt16(&profileData[profileIndex]);
profileIndex+=2;
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("SWY Offset Ch 1 %d", pDevObj->vp880SysCalData.swyOffset[1]));
pDevObj->vp880SysCalData.swzOffset[0] = VpConvertToInt16(&profileData[profileIndex]);
profileIndex+=2;
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("SWZ Offset Ch 0 %d", pDevObj->vp880SysCalData.swzOffset[0]));
pDevObj->vp880SysCalData.swzOffset[1] = VpConvertToInt16(&profileData[profileIndex]);
profileIndex+=2;
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("SWZ Offset Ch 1 %d", pDevObj->vp880SysCalData.swzOffset[1]));
pDevObj->vp880SysCalData.swxbOffset[0] = VpConvertToInt16(&profileData[profileIndex]);
profileIndex+=2;
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("XB Offset Ch 0 %d", pDevObj->vp880SysCalData.swxbOffset[0]));
pDevObj->vp880SysCalData.swxbOffset[1] = VpConvertToInt16(&profileData[profileIndex]);
profileIndex+=2;
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("XB Offset Ch 1 %d", pDevObj->vp880SysCalData.swxbOffset[1]));
pDevObj->vp880SysCalData.tipCapCal[0] = VpConvertToInt32(&profileData[profileIndex]);
profileIndex+=4;
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("Tip Cap Ch 0 %li", pDevObj->vp880SysCalData.tipCapCal[0]));
pDevObj->vp880SysCalData.tipCapCal[1] = VpConvertToInt32(&profileData[profileIndex]);
profileIndex+=4;
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("Tip Cap Ch 1 %li", pDevObj->vp880SysCalData.tipCapCal[1]));
pDevObj->vp880SysCalData.ringCapCal[0] = VpConvertToInt32(&profileData[profileIndex]);
profileIndex+=4;
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("Ring Cap Ch 0 %li", pDevObj->vp880SysCalData.ringCapCal[0]));
pDevObj->vp880SysCalData.ringCapCal[1] = VpConvertToInt32(&profileData[profileIndex]);
profileIndex+=4;
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("Ring Cap Ch 1 %li", pDevObj->vp880SysCalData.ringCapCal[1]));
VP_CALIBRATION(VpDevCtxType, pDevCtx, ("Calibration Data Length - %d", profileIndex));
pDevObj->stateInt |= (VP880_SYS_CAL_COMPLETE | VP880_CAL_RELOAD_REQ | VP880_DEVICE_CAL_COMPLETE);
pLineObj->lineEvents.response |= VP_EVID_CAL_CMP;
pLineObj->responseData = VP_CAL_SUCCESS;
break;
default:
status = VP_STATUS_INVALID_ARG;
break;
}
VP_API_FUNC_INT(VpLineCtxType, pLineCtx, ("Vp880Cal-"));
VpSysExitCritical(deviceId, VP_CODE_CRITICAL_SEC);
return status;
} /* Vp880Cal() */
#endif /* VP_CC_880_SERIES */