/** \file vp880_fxs_control.c
 * vp880_fxs_control.c
 *
 *  This file contains the control functions for the FXS lines of the VP880
 * device.
 *
 * Copyright (c) 2011, Microsemi
 *
 * $Revision: 1.1.2.1.8.3 $
 * $LastChangedDate: 2010-03-23 14:01:46 -0500 (Tue, 23 Mar 2010) $
 */

#include "../includes/vp_api_cfg.h"

#if defined (VP_CC_880_SERIES) && defined (VP880_FXS_SUPPORT)

/* INCLUDES */
#include "../../arch/uvb/vp_api_types.h"
#include "../../arch/uvb/vp_hal.h"
#include "../includes/vp_api_int.h"
#include "../includes/vp880_api.h"
#include "../vp880_api/vp880_api_int.h"
#include "../../arch/uvb/sys_service.h"

/**< Functions called by Set Line State to abstract device states used for ABS
 * and non ABS devices (if they are different). Set line state then operates
 * on device state only (abstracted from API-II line state).
 */
static void
Vp880ApplyInternalTestTerm(
    VpLineCtxType *pLineCtx);

static void
Vp880RemoveInternalTestTerm(
    VpLineCtxType *pLineCtx);

/**
 * Vp880ProcessFxsLine()
 *  This function should only be called by Vp880ApiTick on FXS lines. It
 * performs all line processing for operations that are Tick based
 *
 * Preconditions:
 *  Conditions defined by purpose of Api Tick.
 *
 * Postconditions:
 *  The Api variables and events (as appropriate) for the line passed have been
 * updated.
 */
VpStatusType
Vp880ProcessFxsLine(
    Vp880DeviceObjectType *pDevObj,
    VpLineCtxType *pLineCtx)
{
    Vp880LineObjectType *pLineObj = pLineCtx->pLineObj;
    uint8 channelId = pLineObj->channelId;
    bool dpStatus[2] = {FALSE, FALSE};
    VpOptionEventMaskType lineEvents1;
    VpOptionEventMaskType lineEvents2;
    VpDialPulseDetectStatesType beforeState, afterState;
    uint8 hookStatus = 0, i, validSamples;
    uint8 hookIncrement;
    bool dp2Valid;

#ifdef VP880_INCLUDE_TESTLINE_CODE
    /* Skip processing during line test */
    if (Vp880IsChnlUndrTst(pDevObj, channelId) == TRUE) {
        return VP_STATUS_SUCCESS;
    }
#endif

    lineEvents1.signaling = 0;
    lineEvents2.signaling = 0;

    /* If the secondary pulse params are all 0 (default), mark them as invalid
     * so that they will not be used. */
    if (pDevObj->pulseSpecs2.breakMin == 0 &&
        pDevObj->pulseSpecs2.breakMax == 0 &&
        pDevObj->pulseSpecs2.makeMin == 0 &&
        pDevObj->pulseSpecs2.makeMax == 0 &&
#ifdef EXTENDED_FLASH_HOOK
        pDevObj->pulseSpecs2.onHookMin == 0 &&
#endif
        pDevObj->pulseSpecs2.interDigitMin == 0 &&
        pDevObj->pulseSpecs2.flashMin == 0 &&
        pDevObj->pulseSpecs2.flashMax == 0) {

        dp2Valid = FALSE;

    } else {
        dp2Valid = TRUE;
    }

    /*
     * If the line is configured for Dial Pulse Detection, run the Dial Pulse
     * detection code. Dial Pulse detection code will generate the appropriate
     * events
     */
    if((pLineObj->pulseMode == VP_OPTION_PULSE_DECODE_ON) &&
       (!(pLineObj->lineState.condition & VP_CSLAC_LINE_LEAK_TEST))) {
        /*
         * Based on the following (vp880_api_int.h):
         *
         *  #define VP880_CC_500HZ_RATE     0x40
         *  #define VP880_CC_1KHZ_RATE      0x30
         *  #define VP880_CC_2KHZ_RATE      0x20
         *  #define VP880_CC_4KHZ_RATE      0x10
         *  #define VP880_CC_8KHZ_RATE      0x00
         */

        /*
         * Get the incremental steps sizes in 125us increments used to apply to the on/off-hook
         * times below, which is also the same scale as the Dial Pulse Detection Parameters.
         */
        uint8 shiftAmt = ((pDevObj->txBufferDataRate >> 4) & 0x7);
        hookIncrement = (1 << shiftAmt);

        validSamples = ((pDevObj->txBuffer[VP880_TX_BUF_HOOK_MSB_INDEX]
            & VP880_TX_BUF_LEN_MASK) >> 4);

        if (validSamples == 7) {
            validSamples = 6;
        }

        if (channelId == 0) {
            hookStatus = pDevObj->txBuffer[VP880_TX_BUF_HOOK_LSB_INDEX]
                & VP880_TX_BUF_HOOK_CHAN1_MASK;
        } else {
            hookStatus = (pDevObj->txBuffer[VP880_TX_BUF_HOOK_MSB_INDEX]
                & VP880_TX_BUF_HOOK_MSB_MASK) << 2;
            hookStatus |= ((pDevObj->txBuffer[VP880_TX_BUF_HOOK_LSB_INDEX]
                & VP880_TX_BUF_HOOK_CHAN2_MASK) >> 6);
        }
        /*
         * If the line is currently in Low Power Mode, the meaning applied to the hook detector is
         * inverted from it's normal meaning. A "high" signal level into the hook detector, which
         * normally measures current, will cause the hook bit to be set = '1'. The SW has to
         * understand that the hook detector is being fed line voltage when in LPM and interpret
         * that to mean the customer phone is on-hook. In normal detection mode where the
         * hook detector is being fed current, a "high" signal level means high current = phone is
         * off-hook.
         */
        if (pLineObj->status & VP880_LOW_POWER_EN) {
            hookStatus = ~hookStatus;
        }

        beforeState = pLineObj->dpStruct.state;

        /*
         * This flag is set when the Test Buffer (more specifically, the Hook-Bit buffer) has been
         * read this tick. It could happen when a hook interrupt occurs or not (i.e., there are a
         * few reasons for reading the test buffer). It should ONLY be set on silicon > VC, but it
         * isn't too much effort to check for both Hook-Bit Buffer read AND > VC silicon before
         * processing the data.
         */
        if ((pDevObj->state & VP_DEV_TEST_BUFFER_READ) &&
            (pDevObj->staticInfo.rcnPcn[VP880_RCN_LOCATION] > VP880_REV_VC)) {
            /*
             * Loop Open and Loop Close times are only at the accuracy of the tickrate now. We
             * want to improve that by looking for the point the hook status changed in the hook-bit
             * buffer and adjust based on the hook bit buffer sample rate (i.e., hook increment set
             * above).
             */
            VP_HOOK(VpLineCtxType, pLineCtx,
                    ("CH%d Validsamples %d, buffer %02X %02X %d%d%d%d%d%d  at time %d",
                     channelId,
                     ((pDevObj->txBuffer[VP880_TX_BUF_HOOK_MSB_INDEX] & VP880_TX_BUF_LEN_MASK) >> 4),
                     pDevObj->txBuffer[0], pDevObj->txBuffer[1],
                     (hookStatus & 0x20) == 0x20,
                     (hookStatus & 0x10) == 0x10,
                     (hookStatus & 0x08) == 0x08,
                     (hookStatus & 0x04) == 0x04,
                     (hookStatus & 0x02) == 0x02,
                     (hookStatus & 0x01) == 0x01,
                     pDevObj->timeStamp));

            for (i = 1; i < (1 << validSamples); i <<= 1) {
                if (beforeState == VP_DP_DETECT_STATE_LOOP_CLOSE) {
                    if (!(hookStatus & i)) {
                        VP_HOOK(VpLineCtxType, pLineCtx,
                                ("CH%d - Loop Close Time (%d) at time (%d) Hook Increment (%d)",
                                 channelId, pLineObj->dpStruct.lc_time, pDevObj->timeStamp,
                                 hookIncrement));

                        if (pLineObj->dpStruct.lc_time > hookIncrement) {
                            pLineObj->dpStruct.lc_time -= hookIncrement;
                        }
                        if (pLineObj->dpStruct2.lc_time > hookIncrement) {
                            pLineObj->dpStruct2.lc_time -= hookIncrement;
                        }
                    } else {
                        break;
                    }
                } else if (beforeState == VP_DP_DETECT_STATE_LOOP_OPEN) {
                    if (hookStatus & i) {
                        VP_HOOK(VpLineCtxType, pLineCtx,
                                ("CH%d - Loop Open Time (%d) at time (%d) Hook Increment (%d)",
                                 channelId, pLineObj->dpStruct.lo_time, pDevObj->timeStamp,
                                 hookIncrement));

                        if (pLineObj->dpStruct.lo_time > hookIncrement) {
                            pLineObj->dpStruct.lo_time -= hookIncrement;
                        }
                        if (pLineObj->dpStruct2.lo_time > hookIncrement) {
                            pLineObj->dpStruct2.lo_time -= hookIncrement;
                        }
                    } else {
                        break;
                    }
                }
            }

            VP_HOOK(VpLineCtxType, pLineCtx,
                    ("CH%d Fine Measurement Loop Open Time (%d) Loop Close Time (%d) at time %d",
                     channelId, pLineObj->dpStruct.lo_time, pLineObj->dpStruct.lc_time,
                     pDevObj->timeStamp));
        }

        if ((!(pDevObj->stateInt & VP880_IS_ABS)) &&
            (pDevObj->swParamsCache[VP880_REGULATOR_TRACK_INDEX] & VP880_REGULATOR_FIXED_RING)) {
            /* Compensate for slow onhook detection with Fixed Mode Tracking Designs */
            if (beforeState == VP_DP_DETECT_STATE_LOOP_CLOSE && !(pLineObj->dpStruct.hookSt)) {
                if (pLineObj->dpStruct.lc_time > VP880_PULSE_DETECT_ADJUSTMENT_LONG) {
                    pLineObj->dpStruct.lc_time -= VP880_PULSE_DETECT_ADJUSTMENT_LONG;
                    VP_HOOK(VpLineCtxType, pLineCtx,
                            ("CH%d Long Compensation to Loop Close Time (%d) at time (%d)",
                             channelId, pLineObj->dpStruct.lc_time, pDevObj->timeStamp));
                }
            }
            if (beforeState == VP_DP_DETECT_STATE_LOOP_CLOSE && !(pLineObj->dpStruct2.hookSt)) {
                if (pLineObj->dpStruct2.lc_time > VP880_PULSE_DETECT_ADJUSTMENT_LONG) {
                    pLineObj->dpStruct2.lc_time -= VP880_PULSE_DETECT_ADJUSTMENT_LONG;
                }
            }
        } else {
            /* Compensate just for the silicon */
            if (beforeState == VP_DP_DETECT_STATE_LOOP_CLOSE && !(pLineObj->dpStruct.hookSt)) {
                if (pLineObj->dpStruct.lc_time > VP880_PULSE_DETECT_ADJUSTMENT_SHORT) {
                    pLineObj->dpStruct.lc_time -= VP880_PULSE_DETECT_ADJUSTMENT_SHORT;
                    VP_HOOK(VpLineCtxType, pLineCtx,
                            ("CH%d Short Compensation to Loop Close Time (%d) at time (%d)",
                             channelId, pLineObj->dpStruct.lc_time, pDevObj->timeStamp));
                }
            }
            if (beforeState == VP_DP_DETECT_STATE_LOOP_CLOSE && !(pLineObj->dpStruct2.hookSt)) {
                if (pLineObj->dpStruct2.lc_time > VP880_PULSE_DETECT_ADJUSTMENT_SHORT) {
                    pLineObj->dpStruct2.lc_time -= VP880_PULSE_DETECT_ADJUSTMENT_SHORT;
                }
            }
        }

        dpStatus[0] = VpUpdateDP(pDevObj->devProfileData.tickRate,
            &pDevObj->pulseSpecs, &pLineObj->dpStruct, &lineEvents1);
        if (dp2Valid == TRUE) {
            dpStatus[1] = VpUpdateDP(pDevObj->devProfileData.tickRate,
                &pDevObj->pulseSpecs2, &pLineObj->dpStruct2, &lineEvents2);
        }
        afterState = pLineObj->dpStruct.state;
        /* Update the loop open and close times according to the hook change
         * within a tick */

        /* If the state changed, adjust the hook timings */
        if (beforeState != afterState) {
            if (pDevObj->state & VP_DEV_TEST_BUFFER_READ) {
                for (i = 1; i < (1 << validSamples); i <<= 1) {
                    if (afterState == VP_DP_DETECT_STATE_LOOP_CLOSE) {
                        if (hookStatus & i) {
                            pLineObj->dpStruct.lc_time += hookIncrement;
                            pLineObj->dpStruct2.lc_time += hookIncrement;
                        } else {
                            break;
                        }
                    } else if (afterState == VP_DP_DETECT_STATE_LOOP_OPEN) {
                        if (!(hookStatus & i)) {
                            pLineObj->dpStruct.lo_time += hookIncrement;
                            pLineObj->dpStruct2.lo_time += hookIncrement;
                        } else {
                            break;
                        }
                    }
                }
            }
            if (afterState == VP_DP_DETECT_STATE_LOOP_OPEN) {
                if ((!(pDevObj->stateInt & VP880_IS_ABS)) &&
                    (pDevObj->swParamsCache[VP880_REGULATOR_TRACK_INDEX] & VP880_REGULATOR_FIXED_RING)) {
                    /* Compensate for slow onhook detection with Fixed Mode Tracking Designs */
                    pLineObj->dpStruct.lo_time += VP880_PULSE_DETECT_ADJUSTMENT_LONG;
                    pLineObj->dpStruct2.lo_time += VP880_PULSE_DETECT_ADJUSTMENT_LONG;
                } else {
                    /* Compensate for silicon only */
                    pLineObj->dpStruct.lo_time += VP880_PULSE_DETECT_ADJUSTMENT_SHORT;
                    pLineObj->dpStruct2.lo_time += VP880_PULSE_DETECT_ADJUSTMENT_SHORT;
                }
            }
        }

        /*
         * The state machines will not necessarily complete at the same time, so
         * keep track of each and when both are done, report a passing digit if
         * one exists, or invalid if no criteria was met.
         */
        if (dpStatus[0] == TRUE) {
            pLineObj->signaling1 = lineEvents1.signaling;
            pLineObj->lineEventHandle = pDevObj->timeStamp;

            if (!(pLineObj->lineEvents.signaling & VP_LINE_EVID_BREAK_MAX)) {
                pLineObj->status |= VP880_DP_SET1_DONE;
            }
        }

        if (dpStatus[1] == TRUE && dp2Valid == TRUE) {
            pLineObj->signaling2 = lineEvents2.signaling;
            pLineObj->lineEventHandle = pDevObj->timeStamp;

            if (!(pLineObj->lineEvents.signaling & VP_LINE_EVID_BREAK_MAX)) {
                pLineObj->status |= VP880_DP_SET2_DONE;
            }
        }

        /* Report events if:
         *  Both DP sets are done, OR
         *  Set 1 is done and set 2 is invalid */
        if ((pLineObj->status & VP880_DP_SET1_DONE) &&
            ((pLineObj->status & VP880_DP_SET2_DONE) ||
             dp2Valid == FALSE))
        {
            /* Use the results of DP set 1 if it detected a valid digit, or
             * if DP set 2 detected an invalid digit, or if set 2 is disabled */
            if (pLineObj->dpStruct.digits != -1 ||
                pLineObj->dpStruct2.digits == -1 ||
                dp2Valid == FALSE)
            {
                pLineObj->signalingData = pLineObj->dpStruct.digits;
                pLineObj->lineEvents.signaling |= pLineObj->signaling1;
                pLineObj->lineEventHandle = VP_DP_PARAM1;
            } else {
                pLineObj->signalingData = pLineObj->dpStruct2.digits;
                pLineObj->lineEvents.signaling |= pLineObj->signaling2;
                pLineObj->lineEventHandle = VP_DP_PARAM2;
            }

            if (pLineObj->signalingData == 0) {
                pLineObj->signalingData = pLineObj->lineEventHandle;
                pLineObj->lineEventHandle = pDevObj->timeStamp;
            }

            pLineObj->status &= ~(VP880_DP_SET1_DONE | VP880_DP_SET2_DONE);
            pLineObj->signaling1 = 0;
            pLineObj->signaling2 = 0;
        }
    }

#ifdef VP_CSLAC_SEQ_EN
    /*
     * If Caller ID sequencer is in progress, update unless it's in a state of
     * suspension. If suspended, re-enable if device is in underrun (no more
     * data to transmit).
     */
    if ((pLineObj->callerId.status & VP_CID_IN_PROGRESS)
     || (pLineObj->suspendCid == TRUE)) {
        VpDeviceIdType deviceId = pDevObj->deviceId;
        uint8 ecVal = pLineObj->ecVal;

        VP_API_FUNC_INT(VpLineCtxType, pLineCtx, ("Vp880ProcessFxsLine()+"));

        /* First read of the CID State Machine this tick. */
        VpMpiCmdWrapper(deviceId, ecVal, VP880_CID_PARAM_RD,
            VP880_CID_PARAM_LEN, pLineObj->tickBeginState);
        pLineObj->delayConsumed = FALSE;

        if (pLineObj->suspendCid == TRUE) {
            /*
             * Check to see if the Device Buffer is empty. If it is, continue
             * with CID.
             */
            uint8 cidState = (pLineObj->tickBeginState[0] & VP880_CID_STATE_MASK);

            if ((cidState == VP880_CID_STATE_URUN)
             || (cidState == VP880_CID_STATE_IDLE)) {
                uint8 cidParam = pLineObj->tickBeginState[0];

                pLineObj->suspendCid = FALSE;
                cidParam &= ~(VP880_CID_FRAME_BITS);
                cidParam |= VP880_CID_DIS;

                Vp880MuteChannel(pLineCtx, FALSE);
                if (cidParam != pLineObj->tickBeginState[0]) {
                    pLineObj->tickBeginState[0] = cidParam;
                    VP_CID(VpLineCtxType, pLineCtx,
                        ("Stopping FSK Generator with 0x%02X to CID Params at time %d",
                        pLineObj->tickBeginState[0], pDevObj->timeStamp));
                    VpMpiCmdWrapper(deviceId, ecVal, VP880_CID_PARAM_WRT,
                        VP880_CID_PARAM_LEN, pLineObj->tickBeginState);
                    pLineObj->callerId.status &= ~VP_CID_FSK_ACTIVE;
                }
            }
        }

        if (pLineObj->callerId.status & VP_CID_IN_PROGRESS) {
            VpCidSeq(pLineCtx);
        }
        VP_API_FUNC_INT(VpLineCtxType, pLineCtx, ("Vp880ProcessFxsLine()-"));
    }
#endif
    return VP_STATUS_SUCCESS;
}

/**
 * Vp880SetRelayState()
 *  This function controls the state of controlled relays for the VP880 device.
 *
 * Preconditions:
 *  Device/Line context should be created and initialized. For applicable
 * devices bootload should be performed before calling the function.
 *
 * Postconditions:
 *  The indicated relay state is set for the given line.
 */
VpStatusType
Vp880SetRelayState(
    VpLineCtxType *pLineCtx,
    VpRelayControlType rState)
{
    Vp880LineObjectType *pLineObj = pLineCtx->pLineObj;
    uint8 ecVal = pLineObj->ecVal;
    VpTermType termType = pLineObj->termType;

    VpDevCtxType *pDevCtx = pLineCtx->pDevCtx;
    Vp880DeviceObjectType *pDevObj = pDevCtx->pDevObj;
    VpDeviceIdType deviceId = pDevObj->deviceId;
    uint8 pcn = pDevObj->staticInfo.rcnPcn[VP880_PCN_LOCATION];
    uint8 revCode = pDevObj->staticInfo.rcnPcn[VP880_RCN_LOCATION];

    uint8 ioDirection[VP880_IODIR_REG_LEN];
    uint8 ioData[VP880_IODATA_REG_LEN];

    uint8 mpiBuffer[3 + VP880_IODIR_REG_LEN + VP880_IODATA_REG_LEN + VP880_ICR1_LEN];
    uint8 mpiIndex = 0;

    /*
     * In case this function fails, make sure the line object is unchanged by
     * pre-saving it's current value. First step prior to 100% verifiying if
     * this function will be success is to pre-clear the relay control bits.
     */
    uint8 preIcr1Values = pLineObj->icr1Values[VP880_ICR1_TEST_LOAD_LOCATION];

    VpSysEnterCritical(deviceId, VP_CODE_CRITICAL_SEC);

    VP_API_FUNC_INT(VpLineCtxType, pLineCtx, ("Vp880SetRelayState+"));

    /* Proceed if device state is either in progress or complete */
    if (pDevObj->state & (VP_DEV_INIT_CMP | VP_DEV_INIT_IN_PROGRESS)) {
    } else {
        VpSysExitCritical(deviceId, VP_CODE_CRITICAL_SEC);
        VP_API_FUNC_INT(VpLineCtxType, pLineCtx, ("Vp880SetRelayState-"));
        return VP_STATUS_DEV_NOT_INITIALIZED;
    }

    /*
     * Do not proceed if the device calibration is in progress. This could
     * damage the device.
     */
    if (pDevObj->state & VP_DEV_IN_CAL) {
        VpSysExitCritical(deviceId, VP_CODE_CRITICAL_SEC);
        VP_API_FUNC_INT(VpLineCtxType, pLineCtx, ("Vp880SetRelayState-"));
        return VP_STATUS_DEV_NOT_INITIALIZED;
    }

    /*
     * Handle the VP_RELAY_BRIDGED_TEST case for devices that do not have a
     * physical test load.  Use the internal test termination algorithm instead.
     * If the VP880_ALWAYS_USE_INTERNAL_TEST_TERMINATION option is defined in
     * vp_api_cfg.h the HAS_TEST_LOAD_SWITCH flag will always be cleared at
     * initialization so that this method will always be used.  The internal
     * test termination is only supported for revisions newer than VC.
     */
    if (rState == VP_RELAY_BRIDGED_TEST &&
        !(pDevObj->stateInt & VP880_HAS_TEST_LOAD_SWITCH) &&
        revCode > VP880_REV_VC) {
        Vp880ApplyInternalTestTerm(pLineCtx);

        pLineObj->relayState = VP_RELAY_BRIDGED_TEST;

        VpSysExitCritical(deviceId, VP_CODE_CRITICAL_SEC);
        return VP_STATUS_SUCCESS;
    }

    /* If the internal test termination is currently applied and we're going
     * to a state other than BRIDGED_TEST, restore the internal settings */
    if (pLineObj->internalTestTermApplied == TRUE &&
        rState != VP_RELAY_BRIDGED_TEST) {
        Vp880RemoveInternalTestTerm(pLineCtx);
    }

    /* Read registers that may have partial modifications */
    VpMpiCmdWrapper(deviceId, ecVal, VP880_IODIR_REG_RD, VP880_IODIR_REG_LEN,
        ioDirection);

    VpMpiCmdWrapper(deviceId, ecVal, VP880_IODATA_REG_RD, VP880_IODATA_REG_LEN,
        ioData);

    /* Always set the value for Test Load Control. */
    pLineObj->icr1Values[VP880_ICR1_TEST_LOAD_LOCATION-1] |=
        VP880_ICR1_TEST_LOAD_MASK;

    /* Preclear test load bits */
    pLineObj->icr1Values[VP880_ICR1_TEST_LOAD_LOCATION]
        &= ~(VP880_ICR1_TEST_LOAD_MASK);

    switch (pLineObj->termType) {
        case VP_TERM_FXS_GENERIC:
        case VP_TERM_FXS_LOW_PWR:
            switch (rState) {
                case VP_RELAY_BRIDGED_TEST:
                    if (!(pDevObj->stateInt & VP880_HAS_TEST_LOAD_SWITCH)) {

                        /* Restore values prior to caling this function. */
                        pLineObj->icr1Values[VP880_ICR1_TEST_LOAD_LOCATION] = preIcr1Values;

                        VpSysExitCritical(deviceId, VP_CODE_CRITICAL_SEC);
                        VP_API_FUNC_INT(VpLineCtxType, pLineCtx, ("Vp880SetRelayState-"));
                        return VP_STATUS_INVALID_ARG;
                    }

                    pLineObj->icr1Values[VP880_ICR1_TEST_LOAD_LOCATION]
                        |= VP880_ICR1_TEST_LOAD_METALLIC;

                    /* Test Load bits pre-cleared. Can pick up at Normal */

                case VP_RELAY_NORMAL:
                    break;

                default:
                    /* Restore values prior to caling this function. */
                    pLineObj->icr1Values[VP880_ICR1_TEST_LOAD_LOCATION] = preIcr1Values;

                    VpSysExitCritical(deviceId, VP_CODE_CRITICAL_SEC);
                    VP_API_FUNC_INT(VpLineCtxType, pLineCtx, ("Vp880SetRelayState-"));
                    return VP_STATUS_INVALID_ARG;
            }
            break;

        case VP_TERM_FXS_ISOLATE:
        case VP_TERM_FXS_ISOLATE_LP:
        case VP_TERM_FXS_SPLITTER:
        case VP_TERM_FXS_SPLITTER_LP:
            ioDirection[0] &= ~VP880_IODIR_IO1_MASK;
            ioData[0] &= ~(VP880_IODATA_IO1);

            switch (rState) {
                case VP_RELAY_BRIDGED_TEST:
                    if (!(pDevObj->stateInt & VP880_HAS_TEST_LOAD_SWITCH)) {
                        /* Restore values prior to caling this function. */
                        pLineObj->icr1Values[VP880_ICR1_TEST_LOAD_LOCATION] = preIcr1Values;

                        VpSysExitCritical(deviceId, VP_CODE_CRITICAL_SEC);
                        VP_API_FUNC_INT(VpLineCtxType, pLineCtx, ("Vp880SetRelayState-"));
                        return VP_STATUS_INVALID_ARG;
                    }

                    pLineObj->icr1Values[VP880_ICR1_TEST_LOAD_LOCATION]
                        |= VP880_ICR1_TEST_LOAD_METALLIC;

                    /* Test Load bits pre-cleared. Can pick up at Normal */

                case VP_RELAY_NORMAL:
                    if (revCode <= VP880_REV_VC) {
                        ioDirection[0] |= VP880_IODIR_IO1_OPEN_DRAIN;

                        if ((termType == VP_TERM_FXS_ISOLATE) ||
                            (termType == VP_TERM_FXS_ISOLATE_LP)) {
                            /*
                             * Dir = open drain, Set Data = 0
                             * This causes the output to go high.
                             */
                            ioData[0] &= ~VP880_IODATA_IO1;
                        } else {
                            /*
                             * Dir = open drain, Set Data = 1
                             * This causes the output to go low.
                             */
                            ioData[0] |= VP880_IODATA_IO1;
                        }
                    } else {
                        /*
                         * Devices VP880_DEV_PCN_88536 and VP880_DEV_PCN_88264
                         * are affected here because the VP-API-II forces the
                         * revision code to >= JA
                         */
                        if ((termType == VP_TERM_FXS_ISOLATE) ||
                            (termType == VP_TERM_FXS_ISOLATE_LP)) {
                            /*
                             * Dir = output, Set Data = 1
                             * This causes the output to go high.
                             */
                            ioDirection[0] |= VP880_IODIR_IO1_OUTPUT;
                            ioData[0] |= VP880_IODATA_IO1;
                        } else {
                            if ((pcn == VP880_DEV_PCN_88536) ||
                                (pcn == VP880_DEV_PCN_88264)) {
                                /*
                                 * Dir = output, Set Data = 0
                                 * This causes the output to go low.
                                 */
                                ioDirection[0] |= VP880_IODIR_IO1_OUTPUT;
                                ioData[0] &= ~VP880_IODATA_IO1;
                            } else {
                                /*
                                 * Dir = open drain, Set Data = 1
                                 * This causes the output to go low.
                                 */
                                ioDirection[0] |= VP880_IODIR_IO1_OPEN_DRAIN;
                                ioData[0] |= VP880_IODATA_IO1;
                            }
                        }
                    }
                    break;

                case VP_RELAY_RESET:
                    if (revCode <= VP880_REV_VC) {
                        ioDirection[0] |= VP880_IODIR_IO1_OPEN_DRAIN;
                        if ((termType == VP_TERM_FXS_ISOLATE) ||
                            (termType == VP_TERM_FXS_ISOLATE_LP)) {
                            /*
                             * Dir = open drain, Set Data = 1.
                             * This causes the output to go low
                             */
                            ioData[0] |= VP880_IODATA_IO1;
                        } else {
                            /*
                             * Dir = open drain, Set Data = 0
                             * This causes the output to go high.
                             */
                            ioData[0] &= ~VP880_IODATA_IO1;
                        }
                    } else {
                        /*
                         * Devices VP880_DEV_PCN_88536 and VP880_DEV_PCN_88264
                         * are affected here because the VP-API-II forces the
                         * revision code to >= JA
                         */
                        if ((termType == VP_TERM_FXS_ISOLATE) ||
                            (termType == VP_TERM_FXS_ISOLATE_LP)) {
                            if ((pcn == VP880_DEV_PCN_88536) ||
                                (pcn == VP880_DEV_PCN_88264)) {
                                /*
                                 * Dir = output, Set Data = 0.
                                 * This causes the output to go low
                                 */
                                ioDirection[0] |= VP880_IODIR_IO1_OUTPUT;
                                ioData[0] &= ~VP880_IODATA_IO1;
                            } else {
                                /*
                                 * Dir = open drain, Set Data = 1.
                                 * This causes the output to go low
                                 */
                                ioDirection[0] |= VP880_IODIR_IO1_OPEN_DRAIN;
                                ioData[0] |= VP880_IODATA_IO1;
                            }
                        } else {
                            /*
                             * Dir = output, Set Data = 1
                             * This causes the output to go high.
                             */
                            ioDirection[0] |= VP880_IODIR_IO1_OUTPUT;
                            ioData[0] |= VP880_IODATA_IO1;
                        }
                    }
                    break;

                default:
                    /* Restore values prior to caling this function. */
                    pLineObj->icr1Values[VP880_ICR1_TEST_LOAD_LOCATION] = preIcr1Values;

                    VpSysExitCritical(deviceId, VP_CODE_CRITICAL_SEC);
                    VP_API_FUNC_INT(VpLineCtxType, pLineCtx, ("Vp880SetRelayState-"));
                    return VP_STATUS_INVALID_ARG;
            }
            break;

        default:
            /* Restore values prior to caling this function. */
            pLineObj->icr1Values[VP880_ICR1_TEST_LOAD_LOCATION] = preIcr1Values;

            VpSysExitCritical(deviceId, VP_CODE_CRITICAL_SEC);
            VP_API_FUNC_INT(VpLineCtxType, pLineCtx, ("Vp880SetRelayState-"));
            return VP_STATUS_INVALID_ARG;
    }

    VP_LINE_STATE(VpLineCtxType, pLineCtx, ("1. Write IODATA 0x%02X on Ch %d",
        ioData[0], pLineObj->channelId));

    VP_LINE_STATE(VpLineCtxType, pLineCtx, ("2. Write IODIR 0x%02X on Channel %d",
        ioDirection[0], pLineObj->channelId));

    /*
     * Note in this ONE VP-API-II case for ICR1 Write, we don't go through
     * protected write because that's handled above in this function.
     */
    mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer, VP880_ICR1_WRT,
        VP880_ICR1_LEN, pLineObj->icr1Values);

    VP_LINE_STATE(VpLineCtxType, pLineCtx, ("Vp880SetRelayState(): Write ICR1 0x%02X 0x%02X 0x%02X 0x%02X Ch %d",
        pLineObj->icr1Values[0], pLineObj->icr1Values[1],
        pLineObj->icr1Values[2], pLineObj->icr1Values[3], pLineObj->channelId));

    mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer, VP880_IODATA_REG_WRT,
        VP880_IODATA_REG_LEN, ioData);

    mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer, VP880_IODIR_REG_WRT,
        VP880_IODIR_REG_LEN, ioDirection);

    /* send down the mpi commands */
    VpMpiCmdWrapper(deviceId, ecVal, mpiBuffer[0], mpiIndex-1, &mpiBuffer[1]);

    pLineObj->relayState = rState;

    VpSysExitCritical(deviceId, VP_CODE_CRITICAL_SEC);

    VP_API_FUNC_INT(VpLineCtxType, pLineCtx, ("Vp880SetRelayState-"));
    return VP_STATUS_SUCCESS;
}

/**
 * Vp880ApplyInternalTestTerm()
 *  Configures ICR settings for the internal test termination algorithm, which
 * is used instead of a physical test load for devices which do not have one.
 * The internal test termination works by internally shorting tip and ring.
 */
static void
Vp880ApplyInternalTestTerm(
    VpLineCtxType *pLineCtx)
{
    Vp880LineObjectType *pLineObj = pLineCtx->pLineObj;
    VpDevCtxType *pDevCtx = pLineCtx->pDevCtx;
    Vp880DeviceObjectType *pDevObj = pDevCtx->pDevObj;
    VpDeviceIdType deviceId = pDevObj->deviceId;
    uint8 ecVal = pLineObj->ecVal;
    uint16 timerDelay;
    uint8 icr1Reg[VP880_ICR1_LEN];

    uint8 mpiBuffer[3 + VP880_ICR6_LEN + VP880_ICR4_LEN + VP880_ICR1_LEN];
    uint8 mpiIndex = 0;

    if (pLineObj->internalTestTermApplied == TRUE) {
        return;
    }

    VpSysEnterCritical(deviceId, VP_CODE_CRITICAL_SEC);

    /* Disconnect VAB sensing */
    pLineObj->icr6Values[VP880_DC_CAL_CUT_INDEX] |= VP880_C_TIP_SNS_CUT;
    pLineObj->icr6Values[VP880_DC_CAL_CUT_INDEX] |= VP880_C_RING_SNS_CUT;
    mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer, VP880_ICR6_WRT,
        VP880_ICR6_LEN, pLineObj->icr6Values);

    /* Reverse the polarity of the ground key detector to disable ground
     * key event */
    pLineObj->icr4Values[VP880_ICR4_GKEY_DET_LOCATION] |= VP880_ICR4_GKEY_POL;
    pLineObj->icr4Values[VP880_ICR4_GKEY_DET_LOCATION+1] |= VP880_ICR4_GKEY_POL;
    mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer, VP880_ICR4_WRT,
        VP880_ICR4_LEN, pLineObj->icr4Values);

    /*
     * Forcing the SLIC DC bias for 200ms helps collapse the battery voltage, especially for fixed
     * tracking designs.  We're taking over ICR1 completely here.  Other parts of the code will set
     * pLineObj->icr1Values but will not actually write to the register while this relay state is
     * active. See Vp880ProtectedWriteICR1(). When we leave this relay state, we will restore
     * pLineObj->icr1Values
     */
    icr1Reg[0] = 0xFF;
    icr1Reg[2] = 0xFF;
    if (pDevObj->stateInt & VP880_IS_ABS) {
#ifdef VP880_ABS_SUPPORT
        icr1Reg[1] = 0x68;
        icr1Reg[3] = 0x06;
#endif
    } else {
#ifdef VP880_TRACKER_SUPPORT
        icr1Reg[1] = 0xFF;
        icr1Reg[3] = 0x0F;
#endif
    }
    VP_LINE_STATE(VpLineCtxType, pLineCtx,
                  ("Vp880ApplyInternalTestTerm(): Write ICR1 0x%02X 0x%02X 0x%02X 0x%02X Ch %d",
                   icr1Reg[0], icr1Reg[1], icr1Reg[2], icr1Reg[3], pLineObj->channelId));
    mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer, VP880_ICR1_WRT, VP880_ICR1_LEN, icr1Reg);

    /* send down the mpi commands */
    VpMpiCmdWrapper(deviceId, ecVal, mpiBuffer[0], mpiIndex-1, &mpiBuffer[1]);

    /* Start a timer to change the ICR1 settings later to make tip and ring
     * outputs high impedance so that they tend to pull to battery. */
    if ((pDevObj->stateInt & VP880_IS_ABS) ||
        !(pDevObj->swParams[VP880_REGULATOR_TRACK_INDEX]
             & VP880_REGULATOR_FIXED_RING_SWY)) {
        /* Use a short delay for ABS and non-fixed tracking devices */
        timerDelay = VP880_INTERNAL_TESTTERM_SETTLING_TIME_SHORT;
    } else {
        /* Use a longer delay for fixed tracking devices */
        timerDelay = VP880_INTERNAL_TESTTERM_SETTLING_TIME_LONG;
    }
    pLineObj->lineTimers.timers.timer[VP_LINE_INTERNAL_TESTTERM_TIMER] =
        (MS_TO_TICKRATE(timerDelay, pDevObj->devProfileData.tickRate)) | VP_ACTIVATE_TIMER;

    pLineObj->internalTestTermApplied = TRUE;

    VpSysExitCritical(deviceId, VP_CODE_CRITICAL_SEC);
} /* Vp880ApplyInternalTestTerm() */

/**
 * Vp880RemoveInternalTestTerm()
 *  This function reverts the settings that control the internal test
 * termination.
 */
static void
Vp880RemoveInternalTestTerm(
    VpLineCtxType *pLineCtx)
{
    Vp880LineObjectType *pLineObj = pLineCtx->pLineObj;
    VpDevCtxType *pDevCtx = pLineCtx->pDevCtx;
    Vp880DeviceObjectType *pDevObj = pDevCtx->pDevObj;
    VpDeviceIdType deviceId = pDevObj->deviceId;
    uint8 ecVal = pLineObj->ecVal;

    uint8 mpiBuffer[3 + VP880_ICR6_LEN + VP880_ICR4_LEN + VP880_ICR1_LEN];
    uint8 mpiIndex = 0;

    VpSysEnterCritical(deviceId, VP_CODE_CRITICAL_SEC);

    /* Restore VAB sensing */
    pLineObj->icr6Values[VP880_DC_CAL_CUT_INDEX] &= ~VP880_C_TIP_SNS_CUT;
    pLineObj->icr6Values[VP880_DC_CAL_CUT_INDEX] &= ~VP880_C_RING_SNS_CUT;
    mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer, VP880_ICR6_WRT,
        VP880_ICR6_LEN, pLineObj->icr6Values);

    /* Restore ground key polarity setting */
    pLineObj->icr4Values[VP880_ICR4_GKEY_DET_LOCATION] &= ~VP880_ICR4_GKEY_POL;
    pLineObj->icr4Values[VP880_ICR4_GKEY_DET_LOCATION+1] &= ~VP880_ICR4_GKEY_POL;
    mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer, VP880_ICR4_WRT,
        VP880_ICR4_LEN, pLineObj->icr4Values);

    /* Restore ICR1 to the cached value in pLineObj->icr1Values */
    VP_LINE_STATE(VpLineCtxType, pLineCtx, ("Vp880RemoveInternalTestTerm(): Write ICR1 0x%02X 0x%02X 0x%02X 0x%02X Ch %d",
        pLineObj->icr1Values[0], pLineObj->icr1Values[1],
        pLineObj->icr1Values[2], pLineObj->icr1Values[3], pLineObj->channelId));

    mpiIndex = VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer, VP880_ICR1_WRT,
        VP880_ICR1_LEN, pLineObj->icr1Values);

    /* send down the mpi commands */
    VpMpiCmdWrapper(deviceId, ecVal, mpiBuffer[0], mpiIndex-1, &mpiBuffer[1]);

    /* Deactivate the timer in case it is still running */
    pLineObj->lineTimers.timers.timer[VP_LINE_INTERNAL_TESTTERM_TIMER]
        &= ~VP_ACTIVATE_TIMER;

    pLineObj->internalTestTermApplied = FALSE;

    VpSysExitCritical(deviceId, VP_CODE_CRITICAL_SEC);
} /* Vp880RemoveInternalTestTerm() */

/**
 * Vp880OffHookMgmt()
 *  This function manages the device and API behavior when an off-hook is
 * detected from the device AFTER all normal debounce timers have expired.
 *
 * Preconditions:
 *  This function is called internally by the API-II only.
 *
 * Postconditions:
 *  Device and API is updated accordingly. Returns TRUE if an event is posted.
 */
bool
Vp880OffHookMgmt(
    Vp880DeviceObjectType *pDevObj,
    VpLineCtxType *pLineCtx,
    uint8 ecVal)
{
    Vp880LineObjectType *pLineObj = pLineCtx->pLineObj;
    bool retFlag = FALSE;

#ifdef VP_CSLAC_SEQ_EN
    VpProfilePtrType pCadence;
#endif

    VP_HOOK(VpLineCtxType, pLineCtx, ("Off-Hook on Line %d at Time %d Low Power 0x%02X",
        pLineObj->channelId, pDevObj->timeStamp, (pLineObj->status & VP880_LOW_POWER_EN)));

    pLineObj->dpStruct.hookSt = TRUE;
    pLineObj->dpStruct2.hookSt = TRUE;

    pLineObj->leakyLineCnt = 0;
    pLineObj->status &= ~VP880_LINE_LEAK;

    if(pLineObj->pulseMode == VP_OPTION_PULSE_DECODE_OFF) {
        pLineObj->lineEvents.signaling |= VP_LINE_EVID_HOOK_OFF;
        pLineObj->lineEventHandle = pDevObj->timeStamp;
        retFlag = TRUE;
    }

#ifdef VP_CSLAC_SEQ_EN
    /*
     * If an off-hook is detected when the active cadence is a Message Waiting
     * Pulse on the line, restore the line state.
     */
    pCadence = pLineObj->cadence.pActiveCadence;
    if (pCadence != VP_PTABLE_NULL) {
        if (pCadence[VP_PROFILE_TYPE_LSB] == VP_PRFWZ_PROFILE_MSG_WAIT_PULSE_INT) {
            VP_LINE_STATE(VpLineCtxType, pLineCtx, ("Stopping Active Message Waiting Pulse"));
            Vp880SetLineState(pLineCtx, pLineObj->lineState.currentState);
        }
    }
#endif
    return retFlag;
}

/**
 * Vp880OnHookMgmt()
 *  This function manages the device and API behavior when an on-hook is
 * detected from the device AFTER all normal debounce timers have expired.
 *
 * Preconditions:
 *  This function is called internally by the API-II only.
 *
 * Postconditions:
 *  Device and API is updated accordingly.
 */
bool
Vp880OnHookMgmt(
    Vp880DeviceObjectType *pDevObj,
    VpLineCtxType *pLineCtx,
    uint8 ecVal)
{
    Vp880LineObjectType *pLineObj = pLineCtx->pLineObj;
    VpDeviceIdType deviceId = pDevObj->deviceId;
    bool retFlag = FALSE;

#ifdef VP880_ABS_SUPPORT
    uint8 slacState;
#endif

    VP_HOOK(VpLineCtxType, pLineCtx, ("On-Hook on Line %d at Time %d",
        pLineObj->channelId, pDevObj->timeStamp));

    /* Restore the initial threshold */
    if (pLineObj->hookHysteresis != 0) {
        VpMpiCmdWrapper(deviceId, ecVal, VP880_LOOP_SUP_WRT, VP880_LOOP_SUP_LEN,
            pLineObj->loopSup);
    }

    pLineObj->dpStruct.hookSt = FALSE;
    pLineObj->dpStruct2.hookSt = FALSE;

    if ((pLineObj->pulseMode == VP_OPTION_PULSE_DECODE_OFF) &&
        (!(pLineObj->status & VP880_LINE_LEAK))) {
        /*
         * If this is the first time after initialization that we are checking
         * for on-hook and it is on-hook, don't generate an interrupt
         */
        VP_HOOK(VpLineCtxType, pLineCtx,
            ("Dial Pulse Detect Disabled - checking initial on-hook.."));

        if (!(pLineObj->lineState.condition & VP_CSLAC_STATUS_VALID)) {
            VP_HOOK(VpLineCtxType, pLineCtx,
                ("Line Previously Initialized - Generating On-Hook Event"));

            pLineObj->lineEvents.signaling |= VP_LINE_EVID_HOOK_ON;
            pLineObj->lineEventHandle = pDevObj->timeStamp;
            retFlag = TRUE;
        }
    } else {
        VP_HOOK(VpLineCtxType, pLineCtx,
            ("Dial Pulse Detect Enabled. On-Hook from Dial Pulse State Machine."));
    }
    if (VpIsLowPowerTermType(pLineObj->termType)) {
        VP_HOOK(VpLineCtxType, pLineCtx, ("User State %d Current State %d",
            pLineObj->lineState.usrCurrent, pLineObj->lineState.currentState));

        if (pLineObj->lineState.usrCurrent == VP_LINE_STANDBY) {
            pLineObj->lineState.currentState = VP_LINE_STANDBY;
            Vp880LLSetSysState(deviceId, pLineCtx, 0x00, FALSE);
        }
    }

#ifdef VP880_ABS_SUPPORT
    slacState = pLineObj->slicValueCache;

    if (pDevObj->stateInt & VP880_IS_ABS) {
        switch(slacState & VP880_SS_LINE_FEED_MASK) {
            /*
             * Feed states where the SLIC needs to be put into high battery mode
             * to optimize feed conditions and transient response.
             */
            case (VP880_SS_ACTIVE & VP880_SS_LINE_FEED_MASK):
            case (VP880_SS_IDLE & VP880_SS_LINE_FEED_MASK):
            case (VP880_SS_ACTIVE_MID_BAT & VP880_SS_LINE_FEED_MASK):
                slacState &= ~VP880_SS_LINE_FEED_MASK;
                if(pLineObj->lineState.usrCurrent == VP_LINE_STANDBY) {
                    slacState |= VP880_SS_IDLE;
                } else {
                    slacState |= VP880_SS_ACTIVE_MID_BAT;
                }
                Vp880LLSetSysState(deviceId, pLineCtx, slacState, TRUE);
                break;

            default:
                /*
                 * Another state that either should not cause off-hook detection,
                 * or state that is handled by API-II functionality (e.g.,
                 * Ring Trip).
                 */
                break;
        }
    }
#endif

    return retFlag;
}

/*
 * Vp880ProtectedWriteICR1()
 *  This function is a wrapper for writing to ICR1.  If the internal test
 * termination is applied, ICR1 must not be changed, so this function copies
 * the data into the line object cache and returns without writing anything to
 * the device.  If the internal test termination is not applied, the write
 * is performed.
 *
 * Note: This function must be called from within a critical section.
 */
#ifdef VP880_FXS_SUPPORT
uint8
Vp880ProtectedWriteICR1(
    Vp880LineObjectType *pLineObj,
    uint8 mpiIndex,
    uint8 *mpiBuffer)
{
    if (pLineObj->internalTestTermApplied == FALSE) {
        VP_LINE_STATE(None, VP_NULL, ("Vp880ProtectedWriteICR1(): Channel %d Writing ICR1 0x%02X 0x%02X 0x%02X 0x%02X",
            pLineObj->channelId,
            pLineObj->icr1Values[0], pLineObj->icr1Values[1],
            pLineObj->icr1Values[2], pLineObj->icr1Values[3]));

        return VpCSLACBuildMpiBuffer(mpiIndex, mpiBuffer, VP880_ICR1_WRT,
            VP880_ICR1_LEN, pLineObj->icr1Values);
    }
    return mpiIndex;
}
#endif  /* VP880_FXS_SUPPORT */
#endif