/** \file vp890_api.h
 * vp890_api.h
 *
 *  Header file that define all the commands for the Vp890 device.
 *
 * $Revision: 9253 $
 * $LastChangedDate: 2011-12-14 11:08:16 -0600 (Wed, 14 Dec 2011) $
 */

#ifndef VP890_API_H
#define VP890_API_H

#include "vp_hal.h"
#include "vp_CSLAC_types.h"
#include "vp_api_common.h"

#ifdef VP890_INCLUDE_TESTLINE_CODE
#include "vp_api_test.h"
  #ifdef VP890_EZ_MPI_PCM_COLLECT
  #include  "vp_pcm_compute.h"
  #endif
#endif

/*
 * Note that this value must be >=2 even when only using the single FXO device.
 * That's because this is often used in looping through the line context pointers
 * in the device context indexed by "channelId". The FXO channelId = 1 so the
 * loop operations must be allowed to index into the second element.
 */
#define VP890_MAX_NUM_CHANNELS   2

#define VP890_MAX_MPI_DATA      15   /* Max data from any MPI read command */
#define VP890_INT_SEQ_LEN       22

#ifndef VP890_UL_SIGREG_LEN
#define VP890_UL_SIGREG_LEN         0x02
#endif

#ifndef VP890_B1_FILTER_LEN
#define VP890_B1_FILTER_LEN         0x0E
#endif

#ifndef VP890_B2_FILTER_LEN
#define VP890_B2_FILTER_LEN         0x02
#endif

#ifndef VP890_SIGA_PARAMS_LEN
#define VP890_SIGA_PARAMS_LEN       0x0B
#endif

#ifndef VP890_DC_FEED_LEN
#define VP890_DC_FEED_LEN           0x02
#endif


#ifndef VP890_ICR1_LEN
#define VP890_ICR1_LEN              0x04
#endif

#ifndef VP890_ICR2_LEN
#define VP890_ICR2_LEN              0x04
#endif

#ifndef VP890_ICR3_LEN
#define VP890_ICR3_LEN              0x04
#endif

#ifndef VP890_ICR4_LEN
#define VP890_ICR4_LEN              0x04
#endif

#ifndef VP890_DC_CAL_REG_LEN
#define VP890_DC_CAL_REG_LEN        0x02
#endif

#ifndef VP890_LOOP_SUP_LEN
#define VP890_LOOP_SUP_LEN          0x04
#endif

#ifndef VP890_TEST_DATA_LEN
#define VP890_TEST_DATA_LEN         0x0E
#endif

#ifndef VP890_REGULATOR_PARAM_LEN
#define VP890_REGULATOR_PARAM_LEN   0x03
#endif

#ifndef VP890_REGULATOR_TIMING_LEN
#define VP890_REGULATOR_TIMING_LEN  0x06
#endif

#ifndef VP890_REGULATOR_CTRL_LEN
#define VP890_REGULATOR_CTRL_LEN    0x01
#endif

#ifndef VP890_CONV_CFG_LEN
#define VP890_CONV_CFG_LEN      0x01
#endif

/**< Required Vp890 Device and Line Objects for user instantiation if a Vp890
 * device is used
 */

/**< Structure that defines the Vp890 Device Profile. Current as of the first
 * Device Profile version (ver 0).
 */
typedef struct Vp890DeviceProfileType {
    uint8   profVersion;
    uint16  pcmClkRate;      /**< Used to verify valid TX/RX Timeslot setting */
    uint8   mClkMask;
    uint16  tickRate;        /**< Primary API-II tick for this device */
    uint8   devCfg1;
    uint8   clockSlot;

#ifdef VP890_FXS_SUPPORT
    uint8   swParams[VP890_REGULATOR_PARAM_LEN];
    uint8   timingParams[VP890_REGULATOR_TIMING_LEN];
    uint8   timingParamsFR[VP890_REGULATOR_TIMING_LEN];

    bool    peakManagement;
    bool    lowVoltOverride;
#endif
} Vp890DeviceProfileType;

#if defined (VP890_INCLUDE_TESTLINE_CODE)

/* Definitions for Test arguments */
typedef union Vp890TestArgsType {
    VpTestPrepareType           prepare;
    VpTestConcludeType          conclude;
    VpTestOpenVType             openV;
    VpTestDcRLoopType           dcRloop;
    VpTestAcRLoopType           acRloop;
    VpTest3EleResAltResType     resFltAlt;
    VpTestMSocketType           mSocket;
    VpTestXConnectType          xConnect;
    VpTest3EleCapAltResType     capAlt;
    VpTestLoopCondType          loopCond;
    VpTestLoopbackType          loopback;
    VpTestRampType              ramp;
    VpTestRampInitType          rampInit;
} Vp890TestArgsType;

typedef struct Vp890LineTestCalType {
    uint8 slacState;
    uint8 vpGain;
    uint8 opCond;
    uint8 opFunction;
    uint8 switchTimes[VP890_REGULATOR_TIMING_LEN];
    uint8 icr2[VP890_ICR2_LEN];
    uint8 icr3[VP890_ICR3_LEN];
    uint8 icr4[VP890_ICR4_LEN];
    uint8 icr6[VP890_DC_CAL_REG_LEN];
} Vp890LineTestCalType;

typedef struct Vp890TestHeapType {
    uint8 adcState;
    int16 nextState; /**< Used when a pcm collection routine is started */

    Vp890TestArgsType testArgs; /**< Saved test input arguments of current test */

    uint8 opCond;                           /**< Saved Operation Condition */
    uint8 opFunction;                       /**< Saved Operation Functions */
    uint8 opMode;                           /**< Saved Operating Mode */
    uint8 sysConfig;                        /** Saved System Configurations */
    uint8 sigCtrl;                          /**< Signal Generator Control */
    uint8 convCfg;                          /**< Saved Converter Config */
    uint8 slacState;                        /**< Saved Slac State */
    uint8 vpGain;                           /**< Voice Path Gain */
    uint8 disn;                             /**< Digital Imped. Scaling Network */
    uint8 lpSuper[VP890_LOOP_SUP_LEN];      /**< Saved Loop Sup. Parameters */
    uint8 dcFeed[VP890_DC_FEED_LEN];        /**< Saved DC Feed Parameters */
    uint8 switchReg[VP890_REGULATOR_PARAM_LEN]; /**< Switching Reg Parameters */
    uint8 switchTimes[VP890_REGULATOR_TIMING_LEN]; /**< Switching Reg Timing */

    uint8 icr1[VP890_ICR1_LEN];
    uint8 icr2[VP890_ICR2_LEN];
    uint8 icr3[VP890_ICR3_LEN];
    uint8 icr4[VP890_ICR4_LEN];
    uint8 icr6[VP890_DC_CAL_REG_LEN];
    uint8 sigGenAB[VP890_SIGA_PARAMS_LEN]; /**< Saved Signal Generator A & B*/
    uint8 b1Filter[VP890_B1_FILTER_LEN];   /**< Saved B1 filter coefficients */
    uint8 b2Filter[VP890_B2_FILTER_LEN];   /**< Saved B2 filter coefficients */

    /* used for collecting PCM data */
    bool pcmRequest;        /** < indication that pcm data was requested */
    VpPcmOperationMaskType operationMask;

    VpPcmOperationResultsType pcmResults; /** < stores the pcm operation results */

    /* Used for common setup functions */
    uint16 commonSetupState;

    /* Used for storing line event mask data */
    VpOptionEventMaskType preTestEventMask;

    /* Used for saving and restoring slac state after calibration */
    uint8 calSlacState;

     /* Used for saving and restoring registers during calibration */
    Vp890LineTestCalType calRegs;

    /* Used for resflt lg speed up*/
    uint16 speedupTime;
    int16 previousAvg;
    int16 vabComputed;
    uint8 loopCnt;
    bool compensate;
    bool lowGain;

    /* Used in the capacitance test */
    int16 adcSampleBuffer[52];
    uint8 requestedSamples;
    uint8 saveConvConfig[VP890_CONV_CFG_LEN];
    bool xtraBuffer;

    /* The following members are for EZ mode calculations only*/
#ifdef VP890_EZ_MPI_PCM_COLLECT
    VpPcmComputeTempType ezPcmTemp;

    /* Used to debug under and overflow pcm collect conditions */
#ifdef VP_DEBUG
    int8 underFlowValue;
    uint32 overCnt;
    uint32 underCnt;
#endif

#endif

} Vp890TestHeapType;

typedef struct Vp890CurrentTestType {
    Vp890TestHeapType *pTestHeap;
    uint8 testHeapId;

    uint8 channelId;    /**< Channel # for "this" line on the device.  Indexed
                         * starting at 0, should not exceed the max number of
                         * lines supported by the device - 1 (max = 2, then
                         * channelId = {0, 1}
                         */

    bool prepared;          /**< indicates if the current test is prepared */
    bool preparing;         /**< indicates if the test prepare is complete */
    bool concluding;        /**< indicates that the device is concluding a test */
    bool nonIntrusiveTest;  /**< indicates a "stealth" test */
    VpTestIdType testId;    /** < indicates the test currently running */

    int16 testState;        /**< maintains the currnt state of the current TestId */
    uint16 handle;

} Vp890CurrentTestType;

typedef struct Vp890CalOffCoeffs {
    int16 nullOffset;
    int16 vabOffset;
    int16 vahOffset;
    int16 valOffset;
    int16 vbhOffset;
    int16 vblOffset;
    int16 batOffset;
    int16 imtOffset;
    int16 ilgOffset;
} Vp890CalOffCoeffs;

#endif /*VP890_INCLUDE_TESTLINE_CODE*/

typedef enum Vp890BFiltCalStates {
    VP890_BFILT_MEASURE,
    VP890_BFILT_END
} Vp890BFiltCalStates;

#ifndef VP890_B1_FILTER_LEN
#define VP890_B1_FILTER_LEN         0x0E
#endif

#ifndef VP890_B2_FILTER_LEN
#define VP890_B2_FILTER_LEN         0x02
#endif

#ifndef VP890_OP_FUNC_LEN
#define VP890_OP_FUNC_LEN           0x01
#endif

#ifndef VP890_OP_COND_LEN
#define VP890_OP_COND_LEN           0x01
#endif

#ifndef VP890_CONV_CFG_LEN
#define VP890_CONV_CFG_LEN          0x01
#endif

#ifndef VP890_VP_GAIN_LEN
#define VP890_VP_GAIN_LEN           0x01
#endif

#ifndef VP890_DISN_LEN
#define VP890_DISN_LEN              0x01
#endif

#ifndef VP890_SYS_STATE_LEN
#define VP890_SYS_STATE_LEN         0x01
#endif

#ifndef VP890_GEN_CTRL_LEN
#define VP890_GEN_CTRL_LEN          0x01
#endif

#ifndef VP890_DEV_MODE_LEN
#define VP890_DEV_MODE_LEN          0x01
#endif

#ifndef VP890_CID_PARAM_LEN
#define VP890_CID_PARAM_LEN         0x01
#endif

#ifndef VP890_BAT_CALIBRATION_LEN
#define VP890_BAT_CALIBRATION_LEN   0x02
#endif

typedef struct Vp890CalBFilterData {
    VpCalBFilterType inputData;
    uint8 b1FiltData[VP890_B1_FILTER_LEN];
    uint8 b2FiltData[VP890_B2_FILTER_LEN];
    uint8 opFunct[VP890_OP_FUNC_LEN];
    uint8 opCond[VP890_OP_COND_LEN];
    uint8 convCfg[VP890_CONV_CFG_LEN];
    uint8 vpGain[VP890_VP_GAIN_LEN];
    uint16 vRms;
    uint8 listLength;   /* In number of B-Filter coefficient sets */
    int8 currentSet;    /* Number of currently running B-Filter set */
    int8 bestSet;       /* Number of the best set so far */
} Vp890CalBFilterData;

#define VP890_BFILT_SAMPLE_TIME     (70)

/*
 * IMPORTANT: Make sure to update the "stateInt" member of the device object if
 * the size of this type changes. There is no instance of this type itself.
 */
#define VP890_RESET             (0x0000)    /**< Set at the begining of init device */
#define VP890_IS_HIGH_VOLTAGE   (0x0010)    /**< Set when device is high voltage device */
#define VP890_IS_SINGLE_CHANNEL (0x0020)    /**< Set when a single channel device is found*/
#define VP890_LINE1_IS_FXO      (0x0100)    /**< Set if device detection indicates line1 as FXO */
#define VP890_WIDEBAND          (0x0200)    /**< Set if device supports Wideband mode */
#define VP890_LINE0_LP          (0x0400)    /**< Set if line 0 allows low power mode */
#define VP890_LINE1_LP          (0x0800)    /**< Set if line 1 allows low power mode */
#define VP890_IS_FXO_ONLY       (0x1000)    /**< Set when the device contains only FXO lines */
#define VP890_SYS_CAL_COMPLETE  (0x2000)    /**< Set when the system calibration structure has been initialied */
#define VP890_CAL_RELOAD_REQ    (0x4000)    /**< Set when the line calibration values need to be reloaded. */
#define VP890_FORCE_FREE_RUN    (0x8000)    /**< Set when app calls VpFreeRun() (start), cleared when called with stop.
                                             * This prevents the VP-API-II from automatically exiting free run mode
                                             * upon PCLK recovery.
                                             */

/**< Line Status types to minimize code space in line object (compared to each
 * status being maintined by a uint8 type)
 */
typedef enum Vp890LineStatusType {
    VP890_INIT_STATUS   = 0x0000,

    VP890_IS_FXO        = 0x0001,   /**< Set if the line is configured for FXO */

    VP890_BAD_LOOP_SUP  = 0x0002,   /**< Set when the Loop Supervision has been
                                     * changed in such a way inconsistent with
                                     * the user's specifications. This is done
                                     * in internal to the API to make some
                                     * functions work (e.g., Msg Wait Pulse).
                                     */

    VP890_DP_SET1_DONE  = 0x0004,   /**< Set when Dial Pulse detection machine
                                     * is "done" on the current dial pulse using
                                     * the "first" set of DP parameters
                                     */

    VP890_DP_SET2_DONE  = 0x0008,   /**< Set when Dial Pulse detection machine
                                     * is "done" on the current dial pulse using
                                     * the 2nd set of DP parameters
                                     */

    VP890_SLS_CALL_FROM_API = 0x0010,   /**< Set if Set Line State is called
                                         * from an API function (e.g., cadence).
                                         */

    VP890_LINE_IN_CAL = 0x0020,     /**< Set while line running cal routine */

    VP890_LOW_POWER_EN = 0x0080,    /**< Set when line is operating in low power
                                     * mode
                                     */

    VP890_LINE_LEAK = 0x0100,      /**< Set when leakage is detected on the line
                                    * such that low power mode is prevented.
                                    */
    VP890_CHECK_LEAK = 0x0200,     /**< Set when API-II is testing for leakage
                                    * on the line
                                    */
    VP890_INIT_COMPLETE = 0x0800,  /**< Set when InitLine has been completed
                                    * on this line.
                                    */
    VP890_PREVIOUS_HOOK = 0x1000,  /**< Set if Last Hook Event reported was
                                    * off-hook, cleared if last event was
                                    * on-hook.
                                    */
    VP890_RING_GEN_NORM = 0x2000,  /**< Set when the Generators are known last
                                    * to be programmed to the application
                                    * specified ringing profile. Cleared
                                    * when line tests are run because the same
                                    * generator is used for non-ringing.
                                    */
    VP890_RING_GEN_REV = 0x4000    /**< Set when the Generators are known last
                                    * to be programmed to the application
                                    * specified ringing profile. Cleared
                                    * when line tests are run because the same
                                    * generator is used for non-ringing.
                                    */
} Vp890LineStatusType;

typedef struct Vp890CidCorrectionPair {
    uint16  volts;
    uint16  gain;
} Vp890CidCorrectionPair;

typedef enum Vp890PllRecoveryStateType {
    VP890_PLL_RECOVERY_ST_RESET,
    VP890_PLL_RECOVERY_ST_DISABLE,
    VP890_PLL_RECOVERY_ST_ENABLE_1,
    VP890_PLL_RECOVERY_ST_ENABLE_2,
    VP890_PLL_RECOVERY_ST_MEASURE,
    VP890_PLL_RECOVERY_ST_ENUM_SIZE = FORCE_STANDARD_C_ENUM_SIZE/* Portability Req*/
} Vp890PllRecoveryStateType;

typedef struct Vp890CalLoopData {
    int16 prevVal;
    uint8 loopNum;
    uint8 adcLoopMax;
    uint8 adcRoute;
} Vp890CalLoopData;

typedef struct Vp890IlaCalData {
    int16 ilaNorm;
    int16 ilgNorm;
} Vp890IlaCalData;

typedef struct Vp890VocCalData {
    int16 vocNorm;
    int16 vocRev;
} Vp890VocCalData;


typedef struct Vp890CalTypeData {
    int16 swyVolt;
    Vp890CalLoopData loopData;
    Vp890IlaCalData ilaData;
    Vp890VocCalData vocData;
    Vp890CalBFilterData bFilterData;
} Vp890CalTypeData;

typedef struct Vp890CalLineData {
    bool calDone;           /**< TRUE when calibration has been performed on
                             * this line
                             */
    bool reversePol;        /**< TRUE if CAL starts in polrev */

    Vp890CalTypeData typeData;

    uint8 codecReg;

    uint8 dcFeedRef[VP890_DC_FEED_LEN];         /* Copied from dc profile */
    uint8 dcFeed[VP890_DC_FEED_LEN];            /* use for VAS and VOC */
    uint8 dcFeedPr[VP890_DC_FEED_LEN];          /* use for VAS and VOC */

    uint16 calState;
    uint8 sysState;

    uint8 icr2[VP890_ICR2_LEN];
    uint8 icr3[VP890_ICR3_LEN];

    uint8 disnVal[VP890_DISN_LEN];
    uint8 vpGain[VP890_VP_GAIN_LEN];
    uint8 loopSup[VP890_LOOP_SUP_LEN];

    bool forceCalDataWrite;

    /* Signal generator calibration temporary backup */
    uint8 sigGenA[VP890_SIGA_PARAMS_LEN];
    uint8 calReg[VP890_DC_CAL_REG_LEN];
    uint8 asscReg;

    /**< Battery Calibration values used to compute final VAS values */
    uint8 swCal[VP890_BAT_CALIBRATION_LEN];

    uint16 minVas;  /**< Minimum VAS value determined during IMT calibration.
                     * This is stored in the same format used to compute the VAS
                     * value rather than the device format. This increases the
                     * data memory space requirements slightly, but reduces the
                     * size for code space and simplifies the logic when applied.
                     */
    uint16 vasStart;    /**< Used to speedup VAS calibration by providing the
                         * minimum starting VAS. This value is computed from the
                         * battery adjustment and minVas (above).
                         */
} Vp890CalLineData;

typedef enum Vp890FxoCurrentMonitorStates {
    VP890_CURRENT_MONITOR_DISABLED,
    VP890_CURRENT_MONITOR_OFFSET,
    VP890_CURRENT_MONITOR_BUFFER0,
    VP890_CURRENT_MONITOR_BUFFER1,
    VP890_CURRENT_MONITOR_BUFFER2,
    VP890_CURRENT_MONITOR_BUFFER3,
    VP890_CURRENT_MONITOR_BUFFER4,
    VP890_CURRENT_MONITOR_NORMAL
} Vp890FxoCurrentMonitorStates;

#define VP890_PCM_BUF_SIZE    5
typedef struct Vp890FxoCurrentMonitorType {
    Vp890FxoCurrentMonitorStates    stateValue;
    int16                           currentBuffer[VP890_PCM_BUF_SIZE];
    int16                           currentOffset;

    uint8                           offsetMeasurements;

    /* This is updated when delta across all data is minimal */
    int32                           steadyStateAverage;

    /* Set TRUE when last set of data experienced a line transient */
    bool                            invalidData;
} Vp890FxoCurrentMonitorType;

typedef struct Vp890FxoLowVoltageMonitorType {
    bool enabled;
    uint8 numDisc;
    uint8 numNotDisc;
} Vp890FxoLowVoltageMonitorType;

#define VP890_SYS_CAL_POLARITY_LENGTH  2
#define VP890_SYS_CAL_CHANNEL_LENGTH   1

/* Contains calibration error values -- in +/-10mv LSB */
typedef struct Vp890SysCalResultsType {
    int16 abvError[1];

    int16 vocOffset[VP890_SYS_CAL_CHANNEL_LENGTH][VP890_SYS_CAL_POLARITY_LENGTH];
    int16 vocError[VP890_SYS_CAL_CHANNEL_LENGTH][VP890_SYS_CAL_POLARITY_LENGTH];

    int16 sigGenAError[VP890_SYS_CAL_CHANNEL_LENGTH][VP890_SYS_CAL_POLARITY_LENGTH];

    int16 ila20[VP890_SYS_CAL_CHANNEL_LENGTH];
    int16 ila25[VP890_SYS_CAL_CHANNEL_LENGTH];
    int16 ila32[VP890_SYS_CAL_CHANNEL_LENGTH];
    int16 ila40[VP890_SYS_CAL_CHANNEL_LENGTH];

    int16 ilaOffsetNorm[VP890_SYS_CAL_CHANNEL_LENGTH];
    int16 ilgOffsetNorm[VP890_SYS_CAL_CHANNEL_LENGTH];

    uint8 vas[VP890_SYS_CAL_CHANNEL_LENGTH][VP890_SYS_CAL_POLARITY_LENGTH];

    int16 vagOffsetNorm[VP890_SYS_CAL_CHANNEL_LENGTH];
    int16 vagOffsetRev[VP890_SYS_CAL_CHANNEL_LENGTH];
    int16 vbgOffsetNorm[VP890_SYS_CAL_CHANNEL_LENGTH];
    int16 vbgOffsetRev[VP890_SYS_CAL_CHANNEL_LENGTH];

    int16 swyOffset[VP890_SYS_CAL_CHANNEL_LENGTH];     /**< Used to hold SWY Offset */

    /* Used for capacitance line test only */
    int32 tipCapCal[VP890_SYS_CAL_CHANNEL_LENGTH];
    int32 ringCapCal[VP890_SYS_CAL_CHANNEL_LENGTH];
} Vp890SysCalResultsType;

#define VP890_CAL_STRUCT_SIZE   (18*sizeof(int16) + 2*sizeof(uint8) + 2*sizeof(int32))

/* Vp890 specific Device Object */
typedef struct Vp890DeviceObjectType {
    VpDeviceIdType                  deviceId;           /* Device Id indication */

    VpDeviceStaticInfoType          staticInfo;         /**< Info that will not change during runtime. */
    VpDeviceDynamicInfoType         dynamicInfo;        /**< Info that will change during runtime */

    /* state is a bit-mask of VpDeviceStateType values */
    uint16                          state;

    /* stateInt is a bit-mask of values */
    uint16                          stateInt;

    VpOptionEventMaskType           deviceEventsMask;
    VpOptionEventMaskType           deviceEvents;
    uint16                          eventHandle;        /** Application defined event handle */
    uint16                          timeStamp;          /**< Used to track event timing. Increment by ticks */
    int16                           timeRemainder;
    VpGetResultsOptionsType         getResultsOption;
    VpOptionCriticalFltType         criticalFault;

    VpRelGainResultsType            relGainResults;

    /* Used only to reduce MPI traffic (avoid read/modify/write */
#ifdef VP890_FXS_SUPPORT
    uint8                           swParamsCache[VP890_REGULATOR_PARAM_LEN];
    uint8                           switchCtrl[VP890_REGULATOR_CTRL_LEN];
#endif

    uint8                           devMode[VP890_DEV_MODE_LEN];

    uint16                          devTimer[VP_DEV_TIMER_LAST];

    Vp890DeviceProfileType          devProfileData;
    VpCSLACDeviceProfileTableType   devProfileTable;
    VpCSLACProfileTableEntryType    profEntry;

#ifdef VP890_INCLUDE_TESTLINE_CODE
    VpTestResultType                testResults;
#endif

    uint8                           intReg[VP890_UL_SIGREG_LEN];  /**< Holds signaling data info for the device */
    uint8                           intReg2[VP890_UL_SIGREG_LEN];

    uint8                           responseData;   /**< Holds data for Response events on the device */

    uint8                           txBufferDataRate;

#if !defined(VP_REDUCED_API_IF) || defined(ZARLINK_CFG_INTERNAL)
    uint8                           mpiData[VP890_MAX_MPI_DATA];  /**< Buffer for MPI Low level reads to
                                                                   * hold maximum amount of MPI data that
                                                                   * is possible
                                                                   */
#endif

    uint8                           mpiLen;       /**< Length of data to be copied into mpiData buffer */

#ifdef VP890_FXS_SUPPORT
    /*  Two sets of dial pulse specifications are provide to support NTT dial
     * pulse detection windows of 10pps and 20pps while excluding 15pps */
    VpOptionPulseType pulseSpecs;
    VpOptionPulseType pulseSpecs2;
#endif

    uint8 testDataBuffer[VP890_TEST_DATA_LEN];

#if defined (VP890_INCLUDE_TESTLINE_CODE)
    Vp890CurrentTestType currentTest;
    Vp890CalOffCoeffs calOffsets[VP890_MAX_NUM_CHANNELS];
#endif /* VP890_INCLUDE_TESTLINE_CODE */

#if defined (VP_CC_890_SERIES) || defined (VP_CC_KWRAP)
    Vp890SysCalResultsType vp890SysCalData;
#endif

#ifdef VP_DEBUG
    /* For runtime enabling of debug output: */
    uint32 debugSelectMask;
#endif

    /* Used to hold the device level ecVal (to keep track of WB mode). */
    uint8 ecVal;

    /*
     * Holds the last channel information changed to/from Wideband mode since
     * the last tick. If = 0, no change has been made. If = 1, ch0 if = 2, ch1.
     * This is a handshake with the tick which detects it is not 0, makes the
     * appropriate change and sets it back to 0.
     */
    uint8 lastCodecChange;
} Vp890DeviceObjectType;

/* 890 specific Line Object */
typedef struct Vp890LineObjectType {
    uint8                           channelId;
    uint8                           ecVal;

    VpTermType                      termType;

    VpLineIdType                    lineId;             /**< Application provided value for mapping
                                                         * a user defined type to a line context
                                                         */

    VpApiIntLineStateType           lineState;          /**< Line state info used for state
                                                         * transition handling and recall */
    uint16                          status;             /**< Bit-mask of Vp890LineStatusType */

    VpOptionCodecType               codec;

    /**< Used to delay slic write for LPM or Disconnect handling. */
    uint8                           nextSlicValue;

   /**< Used to reduce MPI reads. */
    uint8                           slicValueCache;
    uint8                           opCond[VP890_OP_COND_LEN];

    VpCslacTimerStruct              lineTimers;         /**< Timers for "this" line */
    VpOptionEventMaskType           lineEvents;
    VpOptionEventMaskType           lineEventsMask;
    uint16                          lineEventHandle;    /**< Line specific event handle information */
    uint16                          signaling1;
    uint16                          signaling2;

    uint16                          dtmfDigitSense;     /**< Used to hold the DTMF digit reported
                                                         * with VpDtmfDigitDetected() until the
                                                         * VP_LINE_EVID_DTMF_DIG is generated. */
    uint8                           signalingData;      /**< Holds data for Signaling events on this line */
    uint16                          processData;        /**< Holds data for Process events on this line */
    uint16                          responseData;       /**< Holds data for Response events on this line */

#ifdef VP890_FXO_SUPPORT
    uint8                           fxoData;            /**< Holds data for FXO events on this line */
    uint8                           fxoRingStateFlag;   /**< Indicates a state change request during ringing,
                                                             to be serviced when ringing is over */
    VpLineStateType                 fxoRingState;       /**< State to change to when ringing is over */

    VpCslacLineCondType             preDisconnect;      /**< The disconnect state prior to timer start */

    VpDigitGenerationDataType       digitGenStruct;     /**< Used on FXO lines for
                                                         * generating pulse digits */

    uint8                           ringDetMax;         /**< Stores the user specified maximum
                                                         * ringing detect period for FXO lines. This
                                                         * value may be outside the device range, in
                                                         * which case the SW will implement upper
                                                         * period detection */

    uint8                           ringDetMin;         /**< Stores the user specified maximum
                                                         * ringing detect period for FXO lines that
                                                         * is within the device range. This value is
                                                         * used as "minimum" that is detected by SW.
                                                         * Actual minimum period is supported by the
                                                         * device period detector itself. */

    uint8                           dPoh;               /**< Stores the user specified parallel
                                                         * offhook integration time for use
                                                         * in timing for the POH event */

    uint8                           userDtg;             /* User-configured DTG setting */
    uint8                           cidDtg;              /* DTG register setting for CID
                                                          * correction */
    int8                            cidCorrectionSample; /* Last line voltage sample for CID
                                                          * correction */
    uint8                           cidCorrectionCtr;    /* Counter for CID correction line
                                                          * voltage samples */
    Vp890PllRecoveryStateType       pllRecoveryState;    /* State for the pll issue fix */
    uint8                           pllRecoverAttempts;    /* Number if pll recovery retries */

    Vp890FxoCurrentMonitorType      currentMonitor;
    Vp890FxoLowVoltageMonitorType   lowVoltageDetection;
#endif

#ifdef VP890_FXS_SUPPORT
    /*
     * Array to hold ringing parameters used in the Signal Generator.  This is
     * needed when signal generator A is set to a tone, then set back to ringing
     * without the user re-specifying the ringing profile
     */
    uint8                           ringingParams[VP890_SIGA_PARAMS_LEN];

    VpProfilePtrType                pRingingCadence;    /**< Currently used ringing cadence on
                                                         * this line */

    VpOptionRingControlType         ringCtrl;

    VpProfilePtrType                pCidProfileType1;   /**< Currently used caller ID profile
                                                         * on this line for sequenced cid */

    VpDialPulseDetectType           dpStruct;           /**< Used on FXS lines for detecting pulse
                                                         * digits*/

    VpDialPulseDetectType           dpStruct2;          /**< Used on FXS lines for detecting pulse
                                                         * digits using 2nd set of dp specs. */

    VpOptionPulseModeType           pulseMode;

    VpRelayControlType              relayState;    /* Used to hold current line
                                                    * relay state */

    uint8 dcCalValues[VP890_DC_CAL_REG_LEN];

    /* Loop supervision parameters */
    uint8 hookHysteresis;

    bool internalTestTermApplied;
#endif

    Vp890CalLineData                calLineData;    /* Data used during VpCalLine() */

    /* Holds user definition for Loop Supervision configuration when
     * "badLoopSup" is TRUE */
    uint8                           loopSup[VP890_LOOP_SUP_LEN];

    VpOptionPcmTxRxCntrlType        pcmTxRxCtrl;   /* Defines how the PCM highway is
                                                    * set for "talk" linestates */

    /*
     * NOTE: Do not move the location or name of gx/grBase members. These may be
     * used by applications to determine the gain of the GX/GR blocks in the
     * AC profile. Using return from VpSetRelGain() is not usefull because that
     * is the register setting. The customer would have to know how to convert
     * that to linear values, which is not generally documented.
     */
    uint16                          gxBase;       /**< Cached GX register, in 2.14 int format */
    uint16                          gxCidLevel;   /**< GX Caller ID correction factor (2.14) */
    uint16                          gxUserLevel;  /**< User specified relative GX level (2.14) */
    uint16                          grBase;       /**< Cached GR register, in 2.14 int format */
    uint16                          grUserLevel;  /**< User specified relative GR level (2.14) */

    int16 absGxGain; /**< Cached ABS A-to-D Gain, simplifies code. */
    int16 absGrGain; /**< Cached ABS D-to-A Gain, simplifies code. */

#ifdef VP_CSLAC_SEQ_EN
#ifdef VP890_FXS_SUPPORT
    VpCallerIdType                  callerId; /**< Caller ID related information */
    VpCidSeqDataType                cidSeq;   /**< CID Sequencer related information */

    bool                            suspendCid;
    uint8                           tickBeginState[VP890_CID_PARAM_LEN];
    uint8                           cidBytesRemain;
    bool                            delayConsumed; /**< Set to TRUE when Polling Mode CID uses the
                                                    * loop read/delay method and has started it.
                                                    */
#endif

    VpSeqDataType                   cadence;  /**< Sequencer related information */

    /**< Array to control internally run sequences */
    VpProfileDataType               intSequence[VP890_INT_SEQ_LEN];
#endif

#ifdef VP890_LP_SUPPORT
    uint8 leakyLineCnt; /*
                         * Keeps track of # of times off-hook was detected (LP Mode)
                         * that was not further verified after exiting LP Mode. Reset
                         * when off-hook is verified.
                         */
#endif

#ifdef VP890_FXS_SUPPORT
    VpHowlerModeCachedValues howlerModeCache;

    uint8 icr2Values[VP890_ICR2_LEN];   /**< Cached to minimize device access */
    uint8 icr3Values[VP890_ICR3_LEN];   /**< Cached to minimize device access */
    uint8 icr4Values[VP890_ICR4_LEN];   /**< Cached to minimize device access */
#endif

    /* Used in FXO PLL Recovery, FXS Line Test,  and FXS Generic and Low Power Mode Control */
    uint8 icr1Values[VP890_ICR1_LEN];   /**< Cached to minimize device access */

    uint8 sigGenCtrl[VP890_GEN_CTRL_LEN];   /**< Cached to minimize device access */

#ifdef VP_DEBUG
    /* For runtime enabling of debug output: */
    uint32 debugSelectMask;
#endif

} Vp890LineObjectType;

#endif /* VP890_API_H */