| /** \file vp880_tracker_calibration.c |
| * vp880_tracker_calibration.c |
| * |
| * This file contains the tracker device calibration functions for |
| * the Vp880 device API. |
| * |
| * Copyright (c) 2011, Microsemi |
| * |
| * $Revision: 1.1.2.1.8.3 $ |
| * $LastChangedDate: 2010-04-01 17:44:54 -0500 (Thu, 01 Apr 2010) $ |
| */ |
| |
| #include "../includes/vp_api_cfg.h" |
| |
| #if defined (VP_CC_880_SERIES) && defined (VP880_TRACKER_SUPPORT) |
| |
| /* 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" |
| |
| #ifdef VP_CSLAC_RUNTIME_CAL_ENABLED |
| |
| /* Functions that are called only inside this file. */ |
| static void Vp880AbvInit(VpDevCtxType *pDevCtx); |
| static void Vp880AbvSetAdc(VpDevCtxType *pDevCtx); |
| static void Vp880AbvStateChange(VpDevCtxType *pDevCtx); |
| static void Vp880AbvMeasure(VpDevCtxType *pDevCtx); |
| |
| #endif /* VP_CSLAC_RUNTIME_CAL_ENABLED */ |
| |
| #ifdef VP_CSLAC_RUNTIME_CAL_ENABLED |
| |
| /** |
| * Vp880CalAbv() -- Tracker Only Function |
| * This function initiates a calibration operation for Absolute Switcher |
| * circuits associated with all the lines of a device. See VP-API reference |
| * guide for more information. SWYV SWZV are global for every Channels |
| * Line must be in Disconnect state before to start the Calibration |
| * |
| * 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 |
| Vp880CalAbv( |
| VpDevCtxType *pDevCtx) |
| { |
| Vp880DeviceObjectType *pDevObj = pDevCtx->pDevObj; |
| VpDeviceIdType deviceId = pDevObj->deviceId; |
| VpStatusType status = VP_STATUS_SUCCESS; |
| uint8 ecVal; |
| uint8 fxsChannels; |
| bool calCleanup = FALSE; |
| |
| VP_API_FUNC_INT(VpDevCtxType, pDevCtx, ("Vp880CalAbv+")); |
| |
| if ((pDevObj->stateInt & VP880_IS_SINGLE_CHANNEL) || (pDevObj->stateInt & VP880_LINE1_IS_FXO)) { |
| ecVal = VP880_EC_CH1; |
| fxsChannels = 1; |
| } else { |
| ecVal = VP880_EC_CH1 | VP880_EC_CH2; |
| fxsChannels = 2; |
| } |
| |
| if (pDevObj->calData.calDeviceState == VP880_CAL_INIT |
| || pDevObj->calData.calDeviceState == VP880_CAL_EXIT) { |
| VP_CALIBRATION(VpDevCtxType, pDevCtx, |
| ("Vp880CalAbv: - Setting to Vp880CalInit at time %d", pDevObj->timeStamp)); |
| |
| pDevObj->calData.calDeviceState = VP880_CAL_INIT; |
| Vp880CalInit(pDevCtx); |
| } |
| |
| switch(pDevObj->calData.calDeviceState) { |
| case VP880_CAL_INIT: |
| VP_CALIBRATION(VpDevCtxType, pDevCtx, |
| ("Vp880CalAbv: - Running Vp880AbvInit at time %d", |
| pDevObj->timeStamp)); |
| Vp880AbvInit(pDevCtx); |
| break; |
| |
| case VP880_CAL_ADC: |
| VP_CALIBRATION(VpDevCtxType, pDevCtx, |
| ("Vp880CalAbv: - Running Vp880AbvSetAdc at time %d", |
| pDevObj->timeStamp)); |
| Vp880AbvSetAdc(pDevCtx); |
| break; |
| |
| case VP880_CAL_STATE_CHANGE: |
| VP_CALIBRATION(VpDevCtxType, pDevCtx, |
| ("Vp880CalAbv: - Running Vp880AbvStateChange at time %d", |
| pDevObj->timeStamp)); |
| Vp880AbvStateChange(pDevCtx); |
| break; |
| |
| case VP880_CAL_MEASURE: |
| VP_CALIBRATION(VpDevCtxType, pDevCtx, |
| ("Vp880CalAbv - Running Vp880AbvMeasure at time %d", |
| pDevObj->timeStamp)); |
| Vp880AbvMeasure(pDevCtx); |
| break; |
| |
| case VP880_CAL_DONE: |
| VP_CALIBRATION(VpDevCtxType, pDevCtx, |
| ("ABV Cal Done at time %d", pDevObj->timeStamp)); |
| calCleanup = TRUE; |
| break; |
| |
| case VP880_CAL_ERROR: |
| /* Fall through intentional */ |
| default: |
| VP_ERROR(VpDevCtxType, pDevCtx, |
| ("Vp880CalAbv: ERROR - Cal Done at time %d", pDevObj->timeStamp)); |
| calCleanup = TRUE; |
| status = VP_STATUS_FAILURE; |
| pDevObj->responseData = VP_CAL_FAILURE; |
| break; |
| } /* end of switch(pDevObj->calData.calDeviceState) */ |
| |
| if (calCleanup == TRUE) { |
| uint8 channelId; |
| uint8 convCfg[VP880_CONV_CFG_LEN]; |
| uint8 mpiBuffer[9 + VP880_SYS_STATE_LEN + VP880_ICR1_LEN |
| + VP880_ICR2_LEN + VP880_ICR3_LEN + VP880_ICR4_LEN |
| + VP880_DISN_LEN + VP880_VP_GAIN_LEN |
| + VP880_OP_FUNC_LEN + VP880_CONV_CFG_LEN]; |
| uint8 mpiIndex = 0; |
| |
| convCfg[0] = (VP880_METALLIC_AC_V | pDevObj->txBufferDataRate); |
| |
| pDevObj->calData.calDeviceState = VP880_CAL_EXIT; |
| if (pDevObj->state & VP_DEV_INIT_IN_PROGRESS) { |
| pDevObj->deviceEvents.response |= VP_DEV_EVID_DEV_INIT_CMP; |
| pDevObj->state |= VP_DEV_INIT_CMP; |
| } else { |
| pDevObj->deviceEvents.response |= VP_EVID_CAL_CMP; |
| } |
| pDevObj->state &= ~(VP_DEV_INIT_IN_PROGRESS | VP_DEV_IN_CAL); |
| pDevObj->state &= ~VP_DEV_ABV_CAL; |
| |
| if (pDevObj->responseData == VP_CAL_FAILURE) { |
| pDevObj->stateInt &= ~VP880_DEVICE_CAL_COMPLETE; |
| } else { |
| pDevObj->stateInt |= VP880_DEVICE_CAL_COMPLETE; |
| } |
| |
| /* Restore device mode to test buffer if exists */ |
| if (pDevObj->staticInfo.rcnPcn[VP880_RCN_LOCATION] > VP880_REV_VC) { |
| pDevObj->devMode[0] |= VP880_DEV_MODE_TEST_DATA; |
| VpMpiCmdWrapper(deviceId, ecVal, VP880_DEV_MODE_WRT, |
| VP880_DEV_MODE_LEN, pDevObj->devMode); |
| } |
| |
| for (channelId = 0; channelId < pDevObj->staticInfo.maxChannels; channelId++) { |
| VpLineCtxType *pLineCtx = pDevCtx->pLineCtx[channelId]; |
| |
| mpiIndex = 0; |
| ecVal = (channelId == 0) ? VP880_EC_CH1 : VP880_EC_CH2; |
| |
| /* Restore slic state -- could be FXO also */ |
| VP_CALIBRATION(VpDevCtxType, pDevCtx, |
| ("CH %d: Calibration Cleanup -- Setting to State 0x%02X at time %d", |
| channelId, pDevObj->calData.abvData.sysState[channelId][0], pDevObj->timeStamp)); |
| |
| mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer, |
| VP880_SYS_STATE_WRT, VP880_SYS_STATE_LEN, |
| &pDevObj->calData.abvData.sysState[channelId][0]); |
| |
| VP_CALIBRATION(VpDevCtxType, pDevCtx, |
| ("CH %d: Calibration Cleanup -- Writing ICR1 to 0x%02X 0x%02X 0x%02X 0x%02X", |
| channelId, |
| pDevObj->calData.abvData.icr1[channelId][0], |
| pDevObj->calData.abvData.icr1[channelId][1], |
| pDevObj->calData.abvData.icr1[channelId][2], |
| pDevObj->calData.abvData.icr1[channelId][3])); |
| |
| mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer, VP880_ICR1_WRT, |
| VP880_ICR1_LEN, &pDevObj->calData.abvData.icr1[channelId][0]); |
| |
| VP_CALIBRATION(VpDevCtxType, pDevCtx, |
| ("CH %d: Calibration Cleanup -- Writing ICR2 to 0x%02X 0x%02X 0x%02X 0x%02X", |
| channelId, |
| pDevObj->calData.abvData.icr2[channelId][0], |
| pDevObj->calData.abvData.icr2[channelId][1], |
| pDevObj->calData.abvData.icr2[channelId][2], |
| pDevObj->calData.abvData.icr2[channelId][3])); |
| |
| mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer, VP880_ICR2_WRT, |
| VP880_ICR2_LEN, &pDevObj->calData.abvData.icr2[channelId][0]); |
| |
| VP_CALIBRATION(VpDevCtxType, pDevCtx, |
| ("CH %d: Calibration Cleanup -- Writing ICR3 to 0x%02X 0x%02X 0x%02X 0x%02X", |
| channelId, |
| pDevObj->calData.abvData.icr3[channelId][0], |
| pDevObj->calData.abvData.icr3[channelId][1], |
| pDevObj->calData.abvData.icr3[channelId][2], |
| pDevObj->calData.abvData.icr3[channelId][3])); |
| |
| mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer, VP880_ICR3_WRT, |
| VP880_ICR3_LEN, &pDevObj->calData.abvData.icr3[channelId][0]); |
| |
| VP_CALIBRATION(VpDevCtxType, pDevCtx, |
| ("CH %d: Calibration Cleanup -- Writing ICR4 to 0x%02X 0x%02X 0x%02X 0x%02X", |
| channelId, |
| pDevObj->calData.abvData.icr4[channelId][0], |
| pDevObj->calData.abvData.icr4[channelId][1], |
| pDevObj->calData.abvData.icr4[channelId][2], |
| pDevObj->calData.abvData.icr4[channelId][3])); |
| |
| mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer, VP880_ICR4_WRT, |
| VP880_ICR4_LEN, &pDevObj->calData.abvData.icr4[channelId][0]); |
| |
| VP_CALIBRATION(VpDevCtxType, pDevCtx, |
| ("CH %d: Calibration Cleanup -- Writing DISN to 0x%02X", |
| channelId, pDevObj->calData.abvData.disnVal[channelId][0])); |
| |
| mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer, VP880_DISN_WRT, |
| VP880_DISN_LEN, &pDevObj->calData.abvData.disnVal[channelId][0]); |
| |
| VP_CALIBRATION(VpDevCtxType, pDevCtx, |
| ("CH %d: Calibration Cleanup -- Writing VP Gain to 0x%02X", |
| channelId, pDevObj->calData.abvData.vpGain[channelId][0])); |
| |
| mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer, VP880_VP_GAIN_WRT, |
| VP880_VP_GAIN_LEN, &pDevObj->calData.abvData.vpGain[channelId][0]); |
| |
| VP_CALIBRATION(VpDevCtxType, pDevCtx, |
| ("CH %d: Calibration Cleanup -- Writing OP FUNC to 0x%02X", |
| channelId, pDevObj->calData.abvData.opFunc[channelId][0])); |
| |
| mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer, VP880_OP_FUNC_WRT, |
| VP880_OP_FUNC_LEN, &pDevObj->calData.abvData.opFunc[channelId][0]); |
| |
| /* Restore Converter Configuration */ |
| VP_CALIBRATION(VpDevCtxType, pDevCtx, |
| ("CH %d: Calibration Cleanup -- Writing CONVERTER to 0x%02X", |
| channelId, convCfg[0])); |
| |
| mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer, VP880_CONV_CFG_WRT, |
| VP880_CONV_CFG_LEN, convCfg); |
| |
| /* send down the mpi commands */ |
| VpMpiCmdWrapper(deviceId, ecVal, mpiBuffer[0], mpiIndex-1, &mpiBuffer[1]); |
|
|
| /*
|
| * The Disconnect Pending flag will be set if the line started a disconnect sequence
|
| * and before the timer completed then started this calibration. In fact, this is
|
| * normal when coming out of VpInitDevice(). So once all other registers are restored
|
| * we have to complete the disconnect sequence.
|
| */ |
| if (pDevObj->state & VP_DEV_DISC_PENDING) { |
| if (pLineCtx != VP_NULL) { |
| Vp880ServiceDiscExitTimer(pLineCtx); |
| } |
| } |
| } /* end of loop "for (channelId = 0; ...)" */ |
| pDevObj->state &= ~VP_DEV_DISC_PENDING; |
|
|
| } /* eid of "if (calCleanup == TRUE)" */ |
| |
| VP_API_FUNC_INT(VpDevCtxType, pDevCtx, ("Vp880CalAbv-")); |
| return status; |
| } |
| |
| /** |
| * Vp880AbvInit() -- Tracker (ABV Cal) only Function |
| * This function initiates a calibration operation for ABV |
| * 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. |
| */ |
| void |
| Vp880AbvInit( |
| VpDevCtxType *pDevCtx) |
| { |
| Vp880DeviceObjectType *pDevObj = pDevCtx->pDevObj; |
| VpDeviceIdType deviceId = pDevObj->deviceId; |
| uint8 disnVal[VP880_DISN_LEN] = {0x00}; |
| uint8 vpGain[VP880_VP_GAIN_LEN] = {0x00}; |
| uint8 channelId; |
| |
| uint8 isrpMods[VP880_INT_SWREG_PARAM_LEN] = { |
| 0x00, 0x40, 0x00, 0x40, 0x00, 0x40 |
| }; |
| |
| uint8 icr1[VP880_ICR1_LEN] = {0x00, 0x00, 0x00, 0x00}; |
| uint8 icr2[VP880_ICR2_LEN] = {0x00, 0xEC, 0x2C, 0x2C}; |
| uint8 icr3[VP880_ICR3_LEN] = {0x30, 0x20, 0x00, 0x00}; |
| uint8 icr4[VP880_ICR4_LEN] = {0x01, 0x01, 0x00, 0x00}; |
| |
| uint8 data, ecVal; |
| uint8 swCal[VP880_BAT_CALIBRATION_LEN]; |
| |
| uint8 mpiBuffer[9 + VP880_ICR2_LEN + VP880_SYS_STATE_LEN + VP880_ICR3_LEN + |
| VP880_ICR4_LEN + VP880_OP_FUNC_LEN + VP880_OP_COND_LEN + |
| VP880_DISN_LEN + VP880_VP_GAIN_LEN + VP880_ICR1_LEN]; |
| uint8 mpiIndex = 0; |
| |
| VP_API_FUNC_INT(VpDevCtxType, pDevCtx, ("Vp880AbvInit+")); |
| |
| /* |
| * Initialize and use to measure each channels offset and voltage using |
| * same functions. |
| */ |
| pDevObj->calData.abvData.passCnt = 0; |
| |
| /* Channel specific registers to restore at end of calibration */ |
| for (channelId = 0; channelId < pDevObj->staticInfo.maxChannels; channelId++) { |
| ecVal = (channelId == 0) ? VP880_EC_CH1 : VP880_EC_CH2; |
| |
| /* Save off current slic state */ |
| VpMpiCmdWrapper(deviceId, ecVal, VP880_SYS_STATE_RD, VP880_SYS_STATE_LEN, |
| &pDevObj->calData.abvData.sysState[channelId][0]); |
| |
| /* |
| * Disable switcher by setting duty cycle = 0. Global, so only need |
| * to do once. |
| */ |
| if (channelId == 0) { |
| VpMpiCmdWrapper(deviceId, ecVal, VP880_INT_SWREG_PARAM_WRT, |
| VP880_INT_SWREG_PARAM_LEN, isrpMods); |
| } |
| |
| /* Clear existing correction factors */ |
| VpMpiCmdWrapper(deviceId, ecVal, VP880_BAT_CALIBRATION_RD, |
| VP880_BAT_CALIBRATION_LEN, swCal); |
| swCal[0] &= ~(VP880_BAT_CAL_SWCAL_MASK); |
| VpMpiCmdWrapper(deviceId, ecVal, VP880_BAT_CALIBRATION_WRT, |
| VP880_BAT_CALIBRATION_LEN, swCal); |
| |
| VpMpiCmdWrapper(deviceId, ecVal, VP880_ICR1_RD, VP880_ICR1_LEN, |
| &pDevObj->calData.abvData.icr1[channelId][0]); |
| VP_CALIBRATION(VpDevCtxType, pDevCtx, |
| ("Saving ICR1 0x%02X 0x%02X 0x%02X 0x%02X Ch %d", |
| pDevObj->calData.abvData.icr1[channelId][0], |
| pDevObj->calData.abvData.icr1[channelId][1], |
| pDevObj->calData.abvData.icr1[channelId][2], |
| pDevObj->calData.abvData.icr1[channelId][3], |
| channelId)); |
| |
| VpMpiCmdWrapper(deviceId, ecVal, VP880_ICR2_RD, VP880_ICR2_LEN, |
| &pDevObj->calData.abvData.icr2[channelId][0]); |
| |
| VP_CALIBRATION(VpDevCtxType, pDevCtx, |
| ("Saving ICR2 0x%02X 0x%02X 0x%02X 0x%02X Ch %d", |
| pDevObj->calData.abvData.icr2[channelId][0], |
| pDevObj->calData.abvData.icr2[channelId][1], |
| pDevObj->calData.abvData.icr2[channelId][2], |
| pDevObj->calData.abvData.icr2[channelId][3], |
| channelId)); |
| |
| VpMpiCmdWrapper(deviceId, ecVal, VP880_ICR3_RD, VP880_ICR3_LEN, |
| &pDevObj->calData.abvData.icr3[channelId][0]); |
| VP_CALIBRATION(VpDevCtxType, pDevCtx, |
| ("Saving ICR3 0x%02X 0x%02X 0x%02X 0x%02X Ch %d", |
| pDevObj->calData.abvData.icr3[channelId][0], |
| pDevObj->calData.abvData.icr3[channelId][1], |
| pDevObj->calData.abvData.icr3[channelId][2], |
| pDevObj->calData.abvData.icr3[channelId][3], |
| channelId)); |
| |
| VpMpiCmdWrapper(deviceId, ecVal, VP880_ICR4_RD, VP880_ICR4_LEN, |
| &pDevObj->calData.abvData.icr4[channelId][0]); |
| |
| VP_CALIBRATION(VpDevCtxType, pDevCtx, |
| ("Saving ICR4 0x%02X 0x%02X 0x%02X 0x%02X Ch %d", |
| pDevObj->calData.abvData.icr4[channelId][0], |
| pDevObj->calData.abvData.icr4[channelId][1], |
| pDevObj->calData.abvData.icr4[channelId][2], |
| pDevObj->calData.abvData.icr4[channelId][3], |
| channelId)); |
| |
| VpMpiCmdWrapper(deviceId, ecVal, VP880_DISN_RD, VP880_DISN_LEN, |
| &pDevObj->calData.abvData.disnVal[channelId][0]); |
| |
| VP_CALIBRATION(VpDevCtxType, pDevCtx,("Saving DISN 0x%02X Ch %d", |
| pDevObj->calData.abvData.disnVal[channelId][0], |
| channelId)); |
| |
| VpMpiCmdWrapper(deviceId, ecVal, VP880_VP_GAIN_RD, VP880_VP_GAIN_LEN, |
| &pDevObj->calData.abvData.vpGain[channelId][0]); |
| |
| VP_CALIBRATION(VpDevCtxType, pDevCtx,("Saving VP Gain 0x%02X Ch %d", |
| pDevObj->calData.abvData.vpGain[channelId][0], |
| channelId)); |
| |
| VpMpiCmdWrapper(deviceId, ecVal, VP880_OP_FUNC_RD, VP880_OP_FUNC_LEN, |
| &pDevObj->calData.abvData.opFunc[channelId][0]); |
| |
| VP_CALIBRATION(VpDevCtxType, pDevCtx,("Saving OP FUNC 0x%02X Ch %d", |
| pDevObj->calData.abvData.opFunc[channelId][0], |
| channelId)); |
| } |
| |
| if ((pDevObj->stateInt & VP880_IS_SINGLE_CHANNEL) |
| || (pDevObj->stateInt & VP880_LINE1_IS_FXO)) { |
| ecVal = VP880_EC_CH1; |
| } else { |
| ecVal = VP880_EC_CH1 | VP880_EC_CH2; |
| } |
| |
| /* Disable the switchers */ |
| VP_CALIBRATION(VpDevCtxType, pDevCtx, |
| ("Writing ICR2 0x%02X 0x%02X 0x%02X 0x%02X BOTH channels", |
| icr2[0], icr2[1], icr2[2], icr2[3])); |
| mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer, VP880_ICR2_WRT, |
| VP880_ICR2_LEN, icr2); |
| |
| VP_CALIBRATION(VpDevCtxType, pDevCtx, |
| ("Writing ICR1 0x%02X 0x%02X 0x%02X 0x%02X BOTH channels", |
| icr1[0], icr1[1], icr1[2], icr1[3])); |
| mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer, VP880_ICR1_WRT, |
| VP880_ICR1_LEN, icr1); |
| |
| /* Force sink supply current to reduce voltage */ |
| data = VP880_SS_ACTIVE; |
| VP_CALIBRATION(VpDevCtxType, pDevCtx, |
| ("Calibration: Setting Ch %d to State 0x%02X at time %d BOTH channels", |
| channelId, data, pDevObj->timeStamp)); |
| mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer, VP880_SYS_STATE_WRT, |
| VP880_SYS_STATE_LEN, &data); |
| |
| /* Enable line control to access VBAT sense */ |
| VP_CALIBRATION(VpDevCtxType, pDevCtx, |
| ("1. Calibration: Write ICR3 0x%02X 0x%02X 0x%02X 0x%02X BOTH channels", |
| icr3[0], icr3[1], icr3[2], icr3[3])); |
| mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer, VP880_ICR3_WRT, |
| VP880_ICR3_LEN, icr3); |
| |
| /* Enable ADC */ |
| VP_CALIBRATION(VpDevCtxType, pDevCtx, |
| ("Calibration: Write ICR4 0x%02X 0x%02X 0x%02X 0x%02X BOTH channels", |
| icr4[0], icr4[1], icr4[2], icr4[3])); |
| mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer, VP880_ICR4_WRT, |
| VP880_ICR4_LEN, icr4); |
| |
| /* Set compression to Linear Mode and default AC Coefficients */ |
| data = VP880_LINEAR_CODEC; |
| mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer, VP880_OP_FUNC_WRT, |
| VP880_OP_FUNC_LEN, &data); |
| VP_CALIBRATION(VpDevCtxType, pDevCtx, |
| ("Calibration: Force OP Func to 0x%02X BOTH channels", data)); |
| |
| /* Cut TX/RX PCM and disable HPF */ |
| data = (VP880_CUT_TXPATH | VP880_CUT_RXPATH | VP880_HIGH_PASS_DIS); |
| mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer, |
| VP880_OP_COND_WRT, VP880_OP_COND_LEN, &data); |
| VP_CALIBRATION(VpDevCtxType, pDevCtx, |
| ("Calibration: Force OP Cond to 0x%02X BOTH channels", data)); |
| |
| /* Set DISN = 0 and Voice Path Gain to 0dB. */ |
| mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer, VP880_DISN_WRT, |
| VP880_DISN_LEN, disnVal); |
| VP_CALIBRATION(VpDevCtxType, pDevCtx, |
| ("Calibration: DISN to 0x%02X BOTH channels", disnVal[0])); |
| |
| mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer, VP880_VP_GAIN_WRT, |
| VP880_VP_GAIN_LEN, vpGain); |
| |
| VP_CALIBRATION(VpDevCtxType, pDevCtx, |
| ("Calibration: VP Gain to 0x%02X BOTH channels", vpGain[0])); |
| |
| /* send down the mpi commands */ |
| VpMpiCmdWrapper(deviceId, ecVal, mpiBuffer[0], mpiIndex-1, &mpiBuffer[1]); |
| |
| /* Wait at least 100ms before collecting data */ |
| pDevObj->devTimer[VP_DEV_TIMER_ABV_CAL] = |
| MS_TO_TICKRATE(VP880_CAL_ABV_LONG, |
| pDevObj->devProfileData.tickRate) | VP_ACTIVATE_TIMER; |
| |
| /* Advance state to measure ADC offset */ |
| pDevObj->calData.calDeviceState = VP880_CAL_STATE_CHANGE; |
| |
| VP_API_FUNC_INT(VpDevCtxType, pDevCtx, ("Vp880AbvInit-")); |
| } /* end Vp880AbvInit */ |
| |
| /** |
| * Vp880AbvStateChange () -- Tracker (ABV Cal) only function |
| * This function changes the line state and sets the converter configuration |
| * in order to give time for the converter to stabilize before taking the first |
| * set of data. |
| * |
| * Preconditions: |
| * The device and line context must be created and initialized before calling |
| * this function. |
| * |
| * Postconditions: |
| */ |
| void |
| Vp880AbvStateChange( |
| VpDevCtxType *pDevCtx) |
| { |
| Vp880DeviceObjectType *pDevObj = pDevCtx->pDevObj; |
| VpDeviceIdType deviceId = pDevObj->deviceId; |
| uint8 data, ecVal; |
| uint8 converterCfg[VP880_CONV_CFG_LEN] = {VP880_SWITCHER_Y}; |
| |
| VP_API_FUNC_INT(VpDevCtxType, pDevCtx, ("Vp880AbvStateChange+")); |
| |
| if ((pDevObj->stateInt & VP880_IS_SINGLE_CHANNEL) |
| || (pDevObj->stateInt & VP880_LINE1_IS_FXO)) { |
| ecVal = VP880_EC_CH1; |
| } else { |
| ecVal = VP880_EC_CH1 | VP880_EC_CH2; |
| } |
| |
| /* Help discharge the battery */ |
| data = (VP880_SS_ACTIVE | VP880_SS_ACTIVATE_MASK); |
| VP_CALIBRATION(VpDevCtxType, pDevCtx, |
| ("Calibration: Setting ALL_LINES to State 0x%02X at time %d", |
| data, pDevObj->timeStamp)); |
| VpMpiCmdWrapper(deviceId, ecVal, VP880_SYS_STATE_WRT, VP880_SYS_STATE_LEN, |
| &data); |
| |
| /* Don't care about the data, just force the converter configuration */ |
| VpMpiCmdWrapper(deviceId, VP880_EC_CH1, VP880_CONV_CFG_WRT, |
| VP880_CONV_CFG_LEN, converterCfg); |
| /* |
| * Force bad initial sample to force decay check to fail. This should be a |
| * reasonably high value (far above any reasonable offset) to force the |
| * first test to fail. |
| */ |
| pDevObj->vp880SysCalData.swyOffset[0] = 13000; |
| |
| /* Reset the iteration value used later to avoid infinite retries */ |
| pDevObj->calData.iteration = 0; |
| |
| /* |
| * Allow the converter to stabilize and most line conditions to fully |
| * discharge the battery. Note that the very first check of the data will |
| * fail because the preset value will be much different than the new value. |
| * The decay algorithm takes that into account and sets the first delay |
| * based on iteration. |
| */ |
| pDevObj->devTimer[VP_DEV_TIMER_ABV_CAL] = |
| MS_TO_TICKRATE(VP880_CAL_ABV_LONG, |
| pDevObj->devProfileData.tickRate) | VP_ACTIVATE_TIMER; |
| |
| pDevObj->calData.calDeviceState = VP880_CAL_ADC; |
| |
| VP_API_FUNC_INT(VpDevCtxType, pDevCtx, ("Vp880AbvStateChange-")); |
| } /* end Vp880AbvStateChange */ |
| |
| /** |
| * Vp880AbvSetAdc() -- Tracker (ABV Cal) only function |
| * This function set the converter to read the right pcm set the right state |
| * machine |
| * |
| * Preconditions: |
| * The device and line context must be created and initialized before calling |
| * this function. |
| * |
| * Postconditions: |
| */ |
| void |
| Vp880AbvSetAdc( |
| VpDevCtxType *pDevCtx) |
| { |
| Vp880DeviceObjectType *pDevObj = pDevCtx->pDevObj; |
| VpDeviceIdType deviceId = pDevObj->deviceId; |
| uint8 ecVal, channelId; |
| uint8 swYZ[VP880_REGULATOR_PARAM_LEN]; |
| bool abvSetAdcDone = FALSE; |
| uint8 converterCfg[VP880_CONV_CFG_LEN] = {VP880_SWITCHER_Z}; |
| bool validData; |
| int16 newValue; |
| |
| VP_API_FUNC_INT(VpDevCtxType, pDevCtx, ("Vp880AbvSetAdc+")); |
| |
| if ((pDevObj->stateInt & VP880_IS_SINGLE_CHANNEL) |
| || (pDevObj->stateInt & VP880_LINE1_IS_FXO)) { |
| ecVal = VP880_EC_CH1; |
| } else { |
| ecVal = VP880_EC_CH1 | VP880_EC_CH2; |
| } |
| |
| pDevObj->calData.iteration++; |
| |
| /* Now we'll switch to channel specific measurements */ |
| /* Read SWY from first channel, SWZ from second channel */ |
| if (pDevObj->calData.abvData.passCnt == 0) { |
| newValue = |
| Vp880AdcSettling(pDevObj, VP880_EC_CH1, VP880_SWITCHER_Y, &validData) |
| + VP880_TRACKER_BAT_OFFSET; |
| |
| if (validData == FALSE) { |
| /* |
| * Data is bad. Need to reset converter (done automatically in |
| * ADC Settling function) and repeat measurement. |
| */ |
| if (pDevObj->calData.iteration < 10) { |
| pDevObj->devTimer[VP_DEV_TIMER_ABV_CAL] = |
| MS_TO_TICKRATE(VP880_CAL_ABV_DELAY, |
| pDevObj->devProfileData.tickRate) | VP_ACTIVATE_TIMER; |
| return; |
| } else { |
| /* Repeated as much as we can. Set 0V offset and move on. */ |
| newValue = 0; |
| } |
| } else if ((ABS(pDevObj->vp880SysCalData.swyOffset[0] - newValue) > VP880_V_1V_PCM) |
| && (ABS(newValue) > VP880_V_1V_PCM)) { |
| /* We're in a voltage decay. Need to wait longer to settle. */ |
| VP_CALIBRATION(VpDevCtxType, pDevCtx, |
| ("Voltage Decay Detected: Old Value %d New Value %d", |
| pDevObj->vp880SysCalData.swyOffset[0], newValue)); |
| |
| pDevObj->vp880SysCalData.swyOffset[0] = newValue; |
| |
| if (pDevObj->calData.iteration < 10) { |
| pDevObj->devTimer[VP_DEV_TIMER_ABV_CAL] = |
| MS_TO_TICKRATE(VP880_CAL_ABV_DECAY_STEP, |
| pDevObj->devProfileData.tickRate) | VP_ACTIVATE_TIMER; |
| return; |
| } else { |
| newValue = 0; |
| } |
| } |
| |
| /* |
| * Data is valid or we're going with what we've got. Reset iteration |
| * count for next data set. |
| */ |
| pDevObj->calData.iteration = 0; |
| pDevObj->vp880SysCalData.swyOffset[0] = newValue; |
| |
| /* This is done to be compatible with VVA P1.3.0 */ |
| pDevObj->calData.abvData.swyOffset[0] = |
| pDevObj->vp880SysCalData.swyOffset[0]; |
| |
| VP_CALIBRATION(VpDevCtxType, pDevCtx, ("Chan 0 Offset (10mV): SWY %d", |
| ((int16)(pDevObj->vp880SysCalData.swyOffset[0] * VP880_V_PCM_LSB / VP880_V_SCALE)))); |
| |
| if (ecVal == VP880_EC_CH1) { |
| abvSetAdcDone = TRUE; |
| } else { |
| VpMpiCmdWrapper(deviceId, VP880_EC_CH2, VP880_CONV_CFG_WRT, |
| VP880_CONV_CFG_LEN, converterCfg); |
| |
| /* Wait for converter data to settle */ |
| pDevObj->devTimer[VP_DEV_TIMER_ABV_CAL] = |
| MS_TO_TICKRATE(VP880_CAL_ABV_DELAY, |
| pDevObj->devProfileData.tickRate) | VP_ACTIVATE_TIMER; |
| |
| pDevObj->calData.abvData.passCnt++; |
| } |
| } else if (pDevObj->calData.abvData.passCnt == 1) { |
| pDevObj->vp880SysCalData.swzOffset[1] = |
| Vp880AdcSettling(pDevObj, VP880_EC_CH2, VP880_SWITCHER_Z, &validData) |
| + VP880_TRACKER_BAT_OFFSET; |
| |
| if (validData == FALSE) { |
| /* |
| * Data is bad. Need to reset converter (done automatically in |
| * ADC Settling function) and repeat measurement |
| */ |
| if (pDevObj->calData.iteration < 10) { |
| pDevObj->devTimer[VP_DEV_TIMER_ABV_CAL] = |
| MS_TO_TICKRATE(VP880_CAL_ABV_DELAY, |
| pDevObj->devProfileData.tickRate) | VP_ACTIVATE_TIMER; |
| return; |
| } else { |
| /* Repeated as much as we can. Set 0V offset and move on. */ |
| pDevObj->vp880SysCalData.swzOffset[1] = 0; |
| } |
| } |
| /* |
| * Data is valid or we're going with what we've got. Reset iteration |
| * count for next data set. |
| */ |
| pDevObj->calData.iteration = 0; |
| |
| /* This is done to be compatible with VVA P1.3.0 */ |
| pDevObj->calData.abvData.swzOffset[1] = |
| pDevObj->vp880SysCalData.swzOffset[1]; |
| |
| VP_CALIBRATION(VpDevCtxType, pDevCtx, ("Chan 1 Offset (10mV): SWZ %d", |
| ((int16)(pDevObj->vp880SysCalData.swzOffset[1] * VP880_V_PCM_LSB / VP880_V_SCALE)))); |
| |
| converterCfg[0] = VP880_SWITCHER_Y; |
| VpMpiCmdWrapper(deviceId, VP880_EC_CH2, VP880_CONV_CFG_WRT, |
| VP880_CONV_CFG_LEN, converterCfg); |
| |
| converterCfg[0] = VP880_SWITCHER_Z; |
| VpMpiCmdWrapper(deviceId, VP880_EC_CH1, VP880_CONV_CFG_WRT, |
| VP880_CONV_CFG_LEN, converterCfg); |
| |
| /* Wait for converter data to settle */ |
| pDevObj->devTimer[VP_DEV_TIMER_ABV_CAL] = MS_TO_TICKRATE(VP880_CAL_ABV_DELAY, |
| pDevObj->devProfileData.tickRate) | VP_ACTIVATE_TIMER; |
| |
| pDevObj->calData.abvData.passCnt++; |
| } else { |
| pDevObj->vp880SysCalData.swzOffset[0] = |
| Vp880AdcSettling(pDevObj, VP880_EC_CH1, VP880_SWITCHER_Z, &validData) |
| + VP880_TRACKER_BAT_OFFSET; |
| |
| if (validData == FALSE) { |
| /* |
| * Data is bad. Need to reset converter (done automatically in |
| * ADC Settling function and repeat measurement |
| */ |
| if (pDevObj->calData.iteration < 10) { |
| pDevObj->devTimer[VP_DEV_TIMER_ABV_CAL] = |
| MS_TO_TICKRATE(VP880_CAL_ABV_DELAY, |
| pDevObj->devProfileData.tickRate) | VP_ACTIVATE_TIMER; |
| return; |
| } else { |
| /* Repeated as much as we can. Set 0V offset and move on. */ |
| pDevObj->vp880SysCalData.swzOffset[0] = 0; |
| |
| /* |
| * Data is valid or we're going with what we've got. Reset |
| * iteration count for next data set. |
| */ |
| pDevObj->calData.iteration = 0; |
| } |
| } |
| |
| /* This is done to be compatible with VVA P1.3.0 */ |
| pDevObj->calData.abvData.swzOffset[0] = |
| pDevObj->vp880SysCalData.swzOffset[0]; |
| |
| VP_CALIBRATION(VpDevCtxType, pDevCtx, ("Chan 0 Offset: SWZ %d", |
| ((pDevObj->vp880SysCalData.swzOffset[0] * VP880_V_PCM_LSB) / 10000))); |
| |
| pDevObj->vp880SysCalData.swyOffset[1] = |
| Vp880AdcSettling(pDevObj, VP880_EC_CH2, VP880_SWITCHER_Y, &validData) |
| + VP880_TRACKER_BAT_OFFSET; |
| |
| if (validData == FALSE) { |
| /* |
| * Data is bad. Need to reset converter (done automatically in |
| * ADC Settling function and repeat measurement |
| */ |
| if (pDevObj->calData.iteration < 10) { |
| pDevObj->devTimer[VP_DEV_TIMER_ABV_CAL] = |
| MS_TO_TICKRATE(VP880_CAL_ABV_DELAY, |
| pDevObj->devProfileData.tickRate) | VP_ACTIVATE_TIMER; |
| return; |
| } else { |
| pDevObj->vp880SysCalData.swyOffset[1] = 0; |
| } |
| } |
| /* |
| * Data is valid or we're going with what we've got. Reset iteration |
| * count for next data set. |
| */ |
| pDevObj->calData.iteration = 0; |
| |
| /* This is done to be compatible with VVA P1.3.0 */ |
| pDevObj->calData.abvData.swyOffset[1] = |
| pDevObj->vp880SysCalData.swyOffset[1]; |
| |
| VP_CALIBRATION(VpDevCtxType, pDevCtx, ("Chan 1 Offset: SWY %d", |
| ((pDevObj->vp880SysCalData.swyOffset[1] * VP880_V_PCM_LSB) / 10000))); |
| |
| abvSetAdcDone = TRUE; |
| } |
| |
| if (abvSetAdcDone == TRUE) { |
| uint8 lineState = (VP880_SS_DISCONNECT | VP880_SS_ACTIVATE_MASK); |
| VP_CALIBRATION(VpDevCtxType, pDevCtx, |
| ("Calibration: Returning ALL_LINES to State 0x%02X at time %d", |
| lineState, pDevObj->timeStamp)); |
| VpMpiCmdWrapper(deviceId, (VP880_EC_CH1 | VP880_EC_CH2), |
| VP880_SYS_STATE_WRT, VP880_SYS_STATE_LEN, &lineState); |
| |
| /* |
| * Copy the Ringing Voltage to the Floor Voltage, everything else |
| * directly from the device profile |
| */ |
| swYZ[0] = pDevObj->swParams[0]; |
| |
| swYZ[VP880_SWY_LOCATION] = |
| (pDevObj->swParams[VP880_SWZ_LOCATION] & VP880_VOLTAGE_MASK); |
| swYZ[VP880_SWY_LOCATION] |= |
| (pDevObj->swParams[VP880_SWY_LOCATION] & ~VP880_VOLTAGE_MASK); |
| |
| swYZ[2] = pDevObj->swParams[2]; |
| |
| VP_CALIBRATION(VpDevCtxType, pDevCtx, |
| ("Vp880AbvInit: swYZ: 0x%02X 0x%02X 0x%02X", |
| swYZ[0], swYZ[1], swYZ[2])); |
| |
| /* Program switcher floor voltage to target ringing voltage */ |
| VpMpiCmdWrapper(deviceId, VP880_EC_CH1, VP880_REGULATOR_PARAM_WRT, |
| VP880_REGULATOR_PARAM_LEN, swYZ); |
| VpMemCpy(pDevObj->swParamsCache, swYZ, VP880_REGULATOR_PARAM_LEN); |
| |
| /* |
| * Restore internal switcher parameters to take voltage measurement. This |
| * is a global register so it doesn't matter which EC value is used. |
| */ |
| VpMpiCmdWrapper(deviceId, VP880_EC_CH1, VP880_INT_SWREG_PARAM_WRT, |
| VP880_INT_SWREG_PARAM_LEN, pDevObj->intSwParams); |
| |
| VP_CALIBRATION(VpDevCtxType, pDevCtx, |
| ("Writing to Internal Switching Regulator: 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X", |
| pDevObj->intSwParams[0], pDevObj->intSwParams[1], pDevObj->intSwParams[2], |
| pDevObj->intSwParams[3], pDevObj->intSwParams[4], pDevObj->intSwParams[5])); |
| |
| pDevObj->calData.calSet = pDevObj->swParams[VP880_SWREG_RING_V_BYTE]; |
| |
| VP_CALIBRATION(VpDevCtxType, pDevCtx, |
| ("Vp880AbvInit: ABV Set Value Target %d", |
| ((pDevObj->calData.calSet * 5) + 5))); |
| |
| /* |
| * If the line is or was a Low Power Termination type the ICR values |
| * could be in a condition where the switcher is not enabled. So force |
| * to known/working values - Note: Actual device values are restored at |
| * the end of calibration |
| */ |
| for (channelId = 0; |
| channelId < pDevObj->staticInfo.maxChannels; channelId++) { |
| uint8 icr1[VP880_ICR1_LEN] = {0x0F, 0x08, 0xC0, 0x00}; |
| uint8 icr2[VP880_ICR2_LEN] = {0x00, 0x00, 0x2C, 0x7C}; |
| uint8 icr3[VP880_ICR3_LEN] = {0x30, 0x21, 0x00, 0x00}; |
| uint8 icr4[VP880_ICR4_LEN] = {0x01, 0x01, 0x00, 0x00}; |
| |
| ecVal = (channelId == 0) ? VP880_EC_CH1 : VP880_EC_CH2; |
| |
| VpMpiCmdWrapper(deviceId, ecVal, VP880_ICR1_WRT, VP880_ICR1_LEN, icr1); |
| VpMpiCmdWrapper(deviceId, ecVal, VP880_ICR2_WRT, VP880_ICR2_LEN, icr2); |
| VpMpiCmdWrapper(deviceId, ecVal, VP880_ICR3_WRT, VP880_ICR3_LEN, icr3); |
| VpMpiCmdWrapper(deviceId, ecVal, VP880_ICR4_WRT, VP880_ICR4_LEN, icr4); |
| } |
| |
| /* Things will take time to settle after programming switcher. */ |
| pDevObj->devTimer[VP_DEV_TIMER_ABV_CAL] = MS_TO_TICKRATE(VP880_CAL_ABV_LONG, |
| pDevObj->devProfileData.tickRate) | VP_ACTIVATE_TIMER; |
| |
| pDevObj->calData.calDeviceState = VP880_CAL_MEASURE; |
| |
| /* Reset iteration and pass count for next data set. */ |
| pDevObj->calData.iteration = 0; |
| pDevObj->calData.abvData.passCnt = 0; |
| } |
| |
| VP_API_FUNC_INT(VpDevCtxType, pDevCtx, ("Vp880AbvSetAdc-")); |
| } /* end Vp880AbvSetAdc */ |
| |
| /** |
| * Vp880AbvMeasure() -- Tracker (ABV Cal) only function |
| * This function read switcher value and compare with the value read from the |
| * pcm data if the value is bigger than 1.25v this function will make a |
| * correction voltage. |
| * |
| * Preconditions: |
| * The device and line context must be created and initialized before calling |
| * this function. |
| * |
| * Postconditions: |
| * Battery calibration registers are adjusted |
| . Channel specific registers are |
| * restored. |
| */ |
| void |
| Vp880AbvMeasure( |
| VpDevCtxType *pDevCtx) |
| { |
| Vp880DeviceObjectType *pDevObj = pDevCtx->pDevObj; |
| VpDeviceIdType deviceId = pDevObj->deviceId; |
| uint8 ecVal; |
| int32 abvError, abvTarget; |
| bool validData; |
| |
| VP_API_FUNC_INT(VpDevCtxType, pDevCtx, ("Vp880AbvMeasure+")); |
| |
| pDevObj->calData.iteration++; |
| |
| if ((pDevObj->stateInt & VP880_IS_SINGLE_CHANNEL) |
| || (pDevObj->stateInt & VP880_LINE1_IS_FXO)) { |
| ecVal = VP880_EC_CH1; |
| } else { |
| ecVal = VP880_EC_CH1 | VP880_EC_CH2; |
| } |
| |
| if (pDevObj->calData.abvData.passCnt == 0) { |
| /* |
| * Exiting this state always requires resetting the timer to keep the |
| * calibration moving along. |
| */ |
| pDevObj->devTimer[VP_DEV_TIMER_ABV_CAL] = |
| MS_TO_TICKRATE(VP880_CAL_ABV_DELAY, |
| pDevObj->devProfileData.tickRate) | VP_ACTIVATE_TIMER; |
| |
| /* Now we'll switch to channel specific measurements */ |
| /* Read SWY from first channel */ |
| pDevObj->calData.abvData.swyVolt[0] = |
| Vp880AdcSettling(pDevObj, VP880_EC_CH1, VP880_SWITCHER_Y, &validData); |
| |
| if (validData == FALSE) { |
| /* |
| * Data is bad. Need to reset converter (done automatically in |
| * ADC Settling function and repeat measurement |
| */ |
| if (pDevObj->calData.iteration < 10) { |
| return; |
| } |
| } |
| VP_CALIBRATION(VpDevCtxType, pDevCtx, |
| ("Chan 0 Voltage: SWY %d at time %d", |
| ((pDevObj->calData.abvData.swyVolt[0] * VP880_V_PCM_LSB) / 10000), |
| pDevObj->timeStamp)); |
| |
| /* Now have all data necessary to compute error and adjust channel 0 */ |
| abvTarget = (pDevObj->calData.calSet * 5) + 5; /* Gets it to V scale */ |
| abvTarget *= 1000; |
| abvTarget *= 1000; |
| abvTarget /= VP880_V_PCM_LSB; /* Now we're scaled to the PCM data */ |
| |
| if (pDevObj->calData.iteration >= 10) { |
| pDevObj->calData.abvData.swyVolt[0] = abvTarget; |
| } |
| abvError = abvTarget - |
| (pDevObj->calData.abvData.swyVolt[0] |
| - pDevObj->vp880SysCalData.swyOffset[0]); |
| |
| pDevObj->vp880SysCalData.abvError[0] = (((int16)abvError * VP880_V_PCM_LSB) / 10000); |
| /* |
| * Check if the error is "excessive" - meaning after a max 3.75V |
| * adjustment, it is still more than 30% out of spec. |
| */ |
| VP_CALIBRATION(VpDevCtxType, pDevCtx, |
| ("Chan 0 Pct Error %li", (ABS((abvError * 100) / abvTarget)))); |
| if ((ABS((abvError * 100) / abvTarget)) > 30) { |
| pDevObj->responseData = VP_CAL_FAILURE; |
| } |
| |
| VP_CALIBRATION(VpDevCtxType, pDevCtx, |
| ("1. Chan 0 Voltage Error: SWY %d Target Converted %d", |
| pDevObj->vp880SysCalData.abvError[0], |
| (((int16)abvTarget * VP880_V_PCM_LSB) / 10000))); |
| |
| /* Write the correction value to CH1 register. Steps in 1.25V increment */ |
| Vp880BatteryCalAdjust(pDevObj, VP880_EC_CH1); |
| |
| pDevObj->calData.abvData.passCnt = 1; |
| pDevObj->calData.iteration = 0; |
| return; |
| } else if (pDevObj->calData.abvData.passCnt == 1) { |
| if (ecVal == (VP880_EC_CH1 | VP880_EC_CH2)) { |
| /* Read SWZ voltages from second channel */ |
| pDevObj->calData.abvData.swzVolt[1] = |
| Vp880AdcSettling(pDevObj, VP880_EC_CH2, VP880_SWITCHER_Z, &validData); |
| |
| if (validData == FALSE) { |
| /* |
| * Data is bad. Need to reset converter (done automatically in |
| * ADC Settling function) and repeat measurement. |
| */ |
| if (pDevObj->calData.iteration < 10) { |
| pDevObj->devTimer[VP_DEV_TIMER_ABV_CAL] = |
| MS_TO_TICKRATE(VP880_CAL_ABV_DELAY, |
| pDevObj->devProfileData.tickRate) | VP_ACTIVATE_TIMER; |
| return; |
| } |
| } |
| |
| VP_CALIBRATION(VpDevCtxType, pDevCtx, ("Chan 1 Voltage: SWZ %d", |
| ((pDevObj->calData.abvData.swzVolt[1] * VP880_V_PCM_LSB) / 10000))); |
| |
| /* Now have all data necessary to compute error and adjust channel 0 */ |
| abvTarget = (pDevObj->calData.calSet * 5) + 5; /* Gets it to V scale */ |
| abvTarget *= 1000; |
| abvTarget *= 1000; |
| abvTarget /= VP880_V_PCM_LSB; /* Now we're scaled to the PCM data */ |
| |
| if (pDevObj->calData.iteration >= 10) { |
| pDevObj->calData.abvData.swzVolt[1] = abvTarget; |
| } |
| |
| abvError = abvTarget - |
| (pDevObj->calData.abvData.swzVolt[1] |
| - pDevObj->vp880SysCalData.swzOffset[1]); |
| |
| pDevObj->vp880SysCalData.abvError[1] = |
| (((int16)abvError * VP880_V_PCM_LSB) / 10000); |
| |
| /* |
| * Check if the error is "excessive" - meaning after a max 3.75V |
| * adjustment, it is still more than 30% out of spec. |
| */ |
| VP_CALIBRATION(VpDevCtxType, pDevCtx, |
| ("Chan 1 Pct Error %li", (ABS((abvError * 100) / abvTarget)))); |
| if ((ABS((abvError * 100) / abvTarget)) > 30) { |
| pDevObj->responseData = VP_CAL_FAILURE; |
| } |
| |
| VP_CALIBRATION(VpDevCtxType, pDevCtx, |
| ("Chan 1 (SWZ): Offset %d Voltage %d Error Raw %d (PCM) Error Converted %d (10mV)", |
| pDevObj->vp880SysCalData.swzOffset[1], |
| pDevObj->calData.abvData.swzVolt[1], |
| (int16)abvError, |
| pDevObj->vp880SysCalData.abvError[1])); |
| |
| /* Write the correction value to CH2 register. Steps in 1.25V increment */ |
| Vp880BatteryCalAdjust(pDevObj, VP880_EC_CH2); |
| } |
| } |
| |
| /* Restore Switching Regulator Parameters */ |
| VpMpiCmdWrapper(deviceId, ecVal, VP880_REGULATOR_PARAM_WRT, |
| VP880_REGULATOR_PARAM_LEN, pDevObj->swParams); |
| VpMemCpy(pDevObj->swParamsCache, pDevObj->swParams, VP880_REGULATOR_PARAM_LEN); |
| |
| pDevObj->calData.calDeviceState = VP880_CAL_DONE; |
| |
| /* Things will take time to settle. */ |
| pDevObj->devTimer[VP_DEV_TIMER_ABV_CAL] = MS_TO_TICKRATE(VP880_CAL_ABV_LONG, |
| pDevObj->devProfileData.tickRate) | VP_ACTIVATE_TIMER; |
| |
| VP_API_FUNC_INT(VpDevCtxType, pDevCtx, ("Vp880AbvMeasure-")); |
| return; |
| } /*end Vp880AbvMeasure */ |
| |
| /** |
| * Vp880CalInit() -- Tracker Only function, called by Vp880CalAbv() |
| * This function initiates a calibration operation for VOC 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. |
| */ |
| void |
| Vp880CalInit( |
| VpDevCtxType *pDevCtx) |
| { |
| Vp880DeviceObjectType *pDevObj = pDevCtx->pDevObj; |
| uint8 ecVal = (VP880_EC_CH1 | VP880_EC_CH2); |
| VpDeviceIdType deviceId = pDevObj->deviceId; |
| |
| VP_API_FUNC_INT(VpDevCtxType, pDevCtx, ("Vp880CalInit+")); |
| |
| /* |
| * Make sure device mode is where we need it. All channel specific registers |
| * read (for restore purposes) in functions called by the tick. |
| */ |
| if (pDevObj->staticInfo.rcnPcn[VP880_RCN_LOCATION] > VP880_REV_VC) { |
| pDevObj->devMode[0] &= ~(VP880_DEV_MODE_TEST_DATA); |
| VpMpiCmdWrapper(deviceId, ecVal, VP880_DEV_MODE_WRT, VP880_DEV_MODE_LEN, |
| pDevObj->devMode); |
| } |
| |
| VP_API_FUNC_INT(VpDevCtxType, pDevCtx, ("Vp880CalInit-")); |
| } |
| |
| #endif /* VP_CSLAC_RUNTIME_CAL_ENABLED */ |
| #endif /* VP_CC_880_SERIES && VP880_TRACKER_SUPPORT */ |
