| /** \file vp880_api.h |
| * vp880_api.h |
| * |
| * Header file that define all the commands for the Vp880 device. |
| * |
| * Copyright (c) 2011, Microsemi |
| * |
| * $Revision: 9253 $ |
| * $LastChangedDate: 2011-12-14 11:08:16 -0600 (Wed, 14 Dec 2011) $ |
| */ |
| |
| #ifndef VP880_API_H |
| #define VP880_API_H |
| |
| #include "vp_hal.h" |
| #include "vp_CSLAC_types.h" |
| #include "vp_api_common.h" |
| |
| #define VP880_MAX_NUM_CHANNELS 2 |
| |
| #ifdef VP880_INCLUDE_TESTLINE_CODE |
| #include "vp_api_test.h" |
| #ifdef VP880_EZ_MPI_PCM_COLLECT |
| #include "vp_pcm_compute.h" |
| #endif |
| #endif |
| |
| #define VP880_MAX_MPI_DATA 15 /* Max data from any MPI read command */ |
| #define VP880_INT_SEQ_LEN 22 |
| |
| #ifndef VP880_DC_FEED_LEN |
| #define VP880_DC_FEED_LEN 0x02 |
| #endif |
| |
| #ifndef VP880_REGULATOR_PARAM_LEN |
| #define VP880_REGULATOR_PARAM_LEN 0x03 |
| #endif |
| |
| #ifndef VP880_LOOP_SUP_LEN |
| #define VP880_LOOP_SUP_LEN 0x04 |
| #endif |
| |
| #ifndef VP880_SIGA_PARAMS_LEN |
| #define VP880_SIGA_PARAMS_LEN 0x0B |
| #endif |
| |
| #ifndef VP880_UL_SIGREG_LEN |
| #define VP880_UL_SIGREG_LEN 0x02 |
| #endif |
| |
| #ifndef VP880_B1_FILTER_LEN |
| #define VP880_B1_FILTER_LEN 0x0E |
| #endif |
| |
| #ifndef VP880_B2_FILTER_LEN |
| #define VP880_B2_FILTER_LEN 0x02 |
| #endif |
| |
| #ifndef VP880_ICR1_LEN |
| #define VP880_ICR1_LEN 0x04 |
| #endif |
| |
| #ifndef VP880_ICR2_LEN |
| #define VP880_ICR2_LEN 0x04 |
| #endif |
| |
| #ifndef VP880_ICR3_LEN |
| #define VP880_ICR3_LEN 0x04 |
| #endif |
| |
| #ifndef VP880_ICR4_LEN |
| #define VP880_ICR4_LEN 0x04 |
| #endif |
| |
| #ifndef VP880_ICR5_LEN |
| #define VP880_ICR5_LEN 0x02 |
| #endif |
| |
| #ifndef VP880_ICR6_LEN |
| #define VP880_ICR6_LEN 0x02 |
| #endif |
| |
| #ifndef VP880_ICR6_LEN |
| #define VP880_ICR6_LEN 0x02 |
| #endif |
| |
| #ifndef VP880_BAT_CALIBRATION_LEN |
| #define VP880_BAT_CALIBRATION_LEN 0x02 |
| #endif |
| |
| #ifndef VP880_REGULATOR_CTRL_LEN |
| #define VP880_REGULATOR_CTRL_LEN 0x01 |
| #endif |
| |
| #ifndef VP880_TX_PCM_BUFF_LEN |
| #define VP880_TX_PCM_BUFF_LEN 0x0E |
| #endif |
| |
| #ifndef VP880_INT_SWREG_PARAM_LEN |
| #define VP880_INT_SWREG_PARAM_LEN 0x06 |
| #endif |
| |
| #ifndef VP880_DISN_LEN |
| #define VP880_DISN_LEN 0x01 |
| #endif |
| |
| #ifndef VP880_VP_GAIN_LEN |
| #define VP880_VP_GAIN_LEN 0x01 |
| #endif |
| |
| #ifndef VP880_SYS_STATE_LEN |
| #define VP880_SYS_STATE_LEN 0x01 |
| #endif |
| |
| #ifndef VP880_OP_FUNC_LEN |
| #define VP880_OP_FUNC_LEN 0x01 |
| #endif |
| |
| #ifndef VP880_OP_COND_LEN |
| #define VP880_OP_COND_LEN 0x01 |
| #endif |
| |
| #ifndef VP880_CONV_CFG_LEN |
| #define VP880_CONV_CFG_LEN 0x01 |
| #endif |
| |
| #ifndef VP880_DEV_MODE_LEN |
| #define VP880_DEV_MODE_LEN 0x01 |
| #endif |
| |
| #ifndef VP880_GEN_CTRL_LEN |
| #define VP880_GEN_CTRL_LEN 0x01 |
| #endif |
| |
| #ifndef VP880_CID_PARAM_LEN |
| #define VP880_CID_PARAM_LEN 0x01 |
| #endif |
| |
| |
| /**< Required Vp880 Device and Line Objects for user instantiation if a Vp880 device is used */ |
| |
| /**< Structure that defines the Vp880 Device Profile. Current as of the first |
| * Device Profile version (ver 0). |
| */ |
| typedef struct Vp880DeviceProfileType { |
| uint8 profVersion; |
| uint16 pcmClkRate; /**< Used to verify valid TX/RX Timeslot setting */ |
| uint16 tickRate; /**< Primary API-II tick for this device */ |
| uint8 devCfg1; |
| uint8 clockSlot; |
| uint8 systemConfig; /**< Used to indicate system supply configuration */ |
| |
| #ifdef VP880_FXS_SUPPORT |
| bool peakManagement; |
| bool lowVoltOverride; |
| #endif |
| } Vp880DeviceProfileType; |
| |
| /* Byte/Bit definitions from the device profile */ |
| #define VP880_DEV_PROFILE_OPERATIONAL_CFG (2u) |
| #define VP880_DEV_PROFILE_PK_PWR_MGMT 0x01 |
| #define VP880_DEV_PROFILE_LOW_VOLT_OVERRIDE 0x02 |
| |
| #define VP880_DEV_PROFILE_PCLK_MSB (6u) |
| #define VP880_DEV_PROFILE_PCLK_LSB (7u) |
| #define VP880_DEV_PROFILE_DEVCFG1 (8u) |
| |
| #define VP880_DEV_PROFILE_SYSTEM_CFG (9u) |
| #define VP880_ABS_CFG_SINGLE 0x00 |
| #define VP880_ABS_CFG_SLAVE 0x01 |
| #define VP880_ABS_CFG_MASTER 0x02 |
| #define VP880_ABS_CFG_MASK 0x03 |
| |
| #define VP880_DEV_PROFILE_CLOCK_SLOT (10u) |
| #define VP880_DEV_PROFILE_MAX_EVENTS (11u) |
| #define VP880_DEV_PROFILE_TICKRATE_MSB (12u) |
| #define VP880_DEV_PROFILE_TICKRATE_LSB (13u) |
| #define VP880_DEV_PROFILE_SWITCHER_CMD (14u) |
| #define VP880_DEV_PROFILE_SWITCHER_DATA0 (15u) |
| #define VP880_DEV_PROFILE_SWITCHER_DATA1 (16u) |
| #define VP880_DEV_PROFILE_SWITCHER_DATA2 (17u) |
| |
| #define VP880_ABS_DEV_PROFILE_YVOLT (18u) |
| #define VP880_ABS_DEV_PROFILE_ZVOLT (19u) |
| |
| #define VP880_DEV_PROFILE_TRACKER_INT_SW_REG (18u) |
| |
| #define VP880_DEV_PROFILE_ABS_INT_SW_REG (24u) |
| |
| |
| /**< Line Status types to minimize code space in line object (compared to each |
| * status being maintined by a uint8 type) |
| */ |
| typedef enum Vp880LineStatusType { |
| VP880_INIT_STATUS = 0x0000, |
| |
| VP880_IS_FXO = 0x0001, /**< Set if the line is configured for FXO */ |
| |
| VP880_SLS_CALL_FROM_API = 0x0002, /**< Set if Set Line State is called |
| * from an API function (e.g., cadence). |
| */ |
| |
| VP880_BAD_LOOP_SUP = 0x0004, /**< 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). |
| */ |
| |
| VP880_UNBAL_RINGING = 0x0008, /**< Set if this line uses unbal ringing */ |
| |
| VP880_DP_SET1_DONE = 0x0010, /**< Set when Dial Pulse detection machine |
| * is "done" on the current dial pulse using |
| * the "first" set of DP parameters |
| */ |
| |
| VP880_DP_SET2_DONE = 0x0020, /**< Set when Dial Pulse detection machine |
| * is "done" on the current dial pulse using |
| * the 2nd set of DP parameters |
| */ |
| |
| VP880_LINE_IN_CAL = 0x0040, /**< Set when line is calibrating */ |
| |
| VP880_LOW_POWER_EN = 0x0080, /**< Set when line is operating in low power |
| * mode |
| */ |
| |
| VP880_LINE_LEAK = 0x0100, /**< Set when leakage is detected on the line |
| * such that low power mode is prevented. |
| */ |
| |
| VP880_INIT_COMPLETE = 0x0800, /**< Set when InitLine has been completed |
| * on this line. |
| */ |
| VP880_PREVIOUS_HOOK = 0x1000, /**< Set if Last Hook Event reported was |
| * off-hook, cleared if last event was |
| * on-hook. |
| */ |
| |
| VP880_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. |
| */ |
| VP880_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. |
| */ |
| } Vp880LineStatusType; |
| |
| #if defined (VP880_INCLUDE_TESTLINE_CODE) |
| /* Definitions for Test arguments */ |
| typedef union Vp880TestArgsType { |
| 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; |
| } Vp880TestArgsType; |
| |
| typedef struct Vp880LineTestCalType { |
| uint8 slacState; |
| uint8 vpGain; |
| uint8 opCond; |
| uint8 opFunction; |
| uint8 icr2[VP880_ICR2_LEN]; |
| uint8 icr3[VP880_ICR3_LEN]; |
| uint8 icr4[VP880_ICR4_LEN]; |
| uint8 icr6[VP880_ICR6_LEN]; |
| } Vp880LineTestCalType; |
| |
| typedef struct Vp880TestHeapType { |
| uint8 adcState; |
| int16 nextState; /**< Used when a pcm collection routine is started */ |
| |
| Vp880TestArgsType testArgs; /**< Saved test input arguments of current test */ |
| |
| uint8 opCond; /**< Saved Operation Condition */ |
| uint8 opFunction; /**< Saved Operation Functions */ |
| uint8 sigCtrl; /**< Signal Generator Control */ |
| uint8 slacState; /**< Saved Slac State */ |
| uint8 sysConfig; /** Saved System Configurations */ |
| uint8 vpGain; /**< Voice Path Gain */ |
| uint8 switchReg[VP880_REGULATOR_PARAM_LEN]; /**< Switching Reg Parameters */ |
| uint8 dcFeed[VP880_DC_FEED_LEN]; /**< Saved DC Feed Parameters */ |
| uint8 disn; /**< Digital Imped. Scaling Network */ |
| uint8 SwRegCtrl; /**< Switching Regulator Control */ |
| |
| uint8 icr1[VP880_ICR1_LEN]; |
| uint8 icr2[VP880_ICR2_LEN]; |
| uint8 icr3[VP880_ICR3_LEN]; |
| uint8 icr4[VP880_ICR4_LEN]; |
| uint8 icr6[VP880_ICR6_LEN]; |
| uint8 lpSuper[VP880_LOOP_SUP_LEN]; /**< Saved Loop Sup. Parameters */ |
| uint8 sigGenAB[VP880_SIGA_PARAMS_LEN]; /**< Saved Signal Generator A & B */ |
| uint8 b1Filter[VP880_B1_FILTER_LEN]; /**< Saved B1 filter coefficients */ |
| uint8 b2Filter[VP880_B2_FILTER_LEN]; /**< Saved B2 filter coefficients */ |
| |
| /* lg res flt uses this to bump up the battery */ |
| uint8 batCal[VP880_BAT_CALIBRATION_LEN]; |
| |
| /* 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 registers during calibration */ |
| Vp880LineTestCalType 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[VP880_CONV_CFG_LEN]; |
| bool xtraBuffer; |
| |
| /* The following members are for EZ mode calculations only*/ |
| #ifdef VP880_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 |
| |
| } Vp880TestHeapType; |
| |
| typedef struct Vp880CurrentTestType { |
| Vp880TestHeapType *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; |
| |
| } Vp880CurrentTestType; |
| |
| typedef struct Vp880CalOffCoeffs { |
| int16 nullOffset; |
| int16 vabOffset; |
| int16 vahOffset; |
| int16 valOffset; |
| int16 vbhOffset; |
| int16 vblOffset; |
| int16 imtOffset; |
| int16 ilgOffset; |
| } Vp880CalOffCoeffs; |
| |
| #endif /*VP880_INCLUDE_TESTLINE_CODE*/ |
| |
| typedef struct Vp880AbvCalData { |
| uint8 passCnt; |
| bool initChange; /**< As needed, set to TRUE when a state is changed in |
| * the calibration state machine. |
| */ |
| |
| int16 swyVolt[2]; /**< One per channel used to measure SWY Voltage */ |
| int16 swzVolt[2]; /**< One per channel used to measure SWZ Voltage */ |
| |
| uint8 isrpData[VP880_INT_SWREG_PARAM_LEN]; |
| uint8 icr1[2][VP880_ICR1_LEN]; |
| uint8 icr2[2][VP880_ICR2_LEN]; |
| uint8 icr3[2][VP880_ICR3_LEN]; |
| uint8 icr4[2][VP880_ICR4_LEN]; |
| uint8 disnVal[2][VP880_DISN_LEN]; |
| uint8 vpGain[2][VP880_VP_GAIN_LEN]; |
| uint8 sysState[2][VP880_SYS_STATE_LEN]; |
| uint8 opFunc[2][VP880_OP_FUNC_LEN]; |
| uint8 opCond[2][VP880_OP_COND_LEN]; |
| uint8 converterCfg[2][VP880_CONV_CFG_LEN]; |
| |
| /* |
| * This the switcher adjustments as determined by battery and VAS calibration |
| * procedures. |
| */ |
| uint8 switcherAdjust[2][VP880_BAT_CALIBRATION_LEN]; |
| |
| /* This is to be compatible with VVA P1.3.0 */ |
| int16 swyOffset[2]; |
| int16 swzOffset[2]; |
| |
| /* This is to be compatible with VVA P1.3.0 but not currently measured. */ |
| int16 swxbOffset[2]; |
| } Vp880AbvCalData; |
| |
| typedef struct Vp880CalLoopData { |
| int16 prevVal; |
| uint8 loopNum; |
| uint8 adcLoopMax; |
| uint8 adcRoute; |
| } Vp880CalLoopData; |
| |
| typedef struct Vp880VocCalData { |
| int16 vocNorm; |
| int16 vocRev; |
| } Vp880VocCalData; |
| |
| typedef struct Vp880CalTypeData { |
| int16 swyVolt; |
| Vp880CalLoopData loopData; |
| Vp880VocCalData vocData; |
| } Vp880CalTypeData; |
| |
| |
| #define VP880_AC_PROFILE_SIZE (80) /* 80 Bytes is fixed size known for 880 |
| * AC Profiles up to PW 2.0.0 |
| */ |
| #define VP880_DC_PROFILE_SIZE (20) /* 16 bytes should be enough, but this |
| * profile size has changed over time. |
| * Safe value with a few more bytes. |
| */ |
| |
| #define VP880_RINGING_PROFILE_SIZE (22) /* 22 byte Ringing Profile size is |
| * the only size ever created for |
| * VE880 API. This should be enough. |
| */ |
| |
| /* |
| * Bit-Masks for calibration update required if line configuration change |
| * attempted during calibration. Note that this only needs to flag/update the |
| * line configuration that may affect calibration. |
| */ |
| #define AC_PROFILE_UPDATE_REQ 0x1 |
| #define DC_PROFILE_UPDATE_REQ 0x2 |
| #define RINGING_PROFILE_UPDATE_REQ 0x4 |
| #define CODEC_UPDATE_REQ 0x8 |
| |
| /* these are in order of execution ALWAYS do not reorder them !!!! */ |
| typedef enum Vp880CalLineState { |
| VP880_CAL_SETUP = 0, |
| VP880_CAL_SETUP_RELEASE_CLAMPS, |
| VP880_RAMP_TO_POLREV_SETUP, |
| VP880_RAMP_TO_POLREV_RAMP1, |
| VP880_RAMP_TO_POLREV_SWAP_POLARITY, |
| VP880_RAMP_TO_POLREV_RAMP2, |
| VP880_RAMP_TO_POLREV_GOACTIVE, |
| VP880_RAMP_TO_POLREV_COMPLETE, |
| |
| VP880_IMT_PR_SETUP = 20, |
| VP880_IMT_PR_SET_ADC, |
| VP880_IMT_PR_MEASURE, |
| |
| #ifdef VP880_TRACKER_SUPPORT |
| VP880_VAS_PR_SETUP = 30, |
| VP880_VAS_PR_STEP, |
| VP880_VAS_PR_SET_ADC, |
| VP880_VAS_PR_MEASURE, |
| VP880_VAS_PR_STORE, |
| #endif |
| |
| VP880_VAB_PR_SETUP = 40, |
| VP880_VAB_PR_MEASURE, |
| |
| VP880_VAB_PR_ADC_OFFSET_SETUP = 50, |
| VP880_VAB_PR_ADC_OFFSET_MEASURE, |
| |
| VP880_VA_PR_ADC_OFFSET_SETUP = 60, |
| VP880_VA_PR_ADC_OFFSET_MEASURE, |
| |
| VP880_VB_PR_ADC_OFFSET_SETUP = 70, |
| VP880_VB_PR_ADC_OFFSET_MEASURE, |
| |
| VP880_COLLAPSE_FEED = 80, |
| |
| VP880_GENA_NP_OFFSET_SETUP = 90, |
| VP880_GENA_NP_OFFSET_SET_ADC, |
| VP880_GENA_NP_OFFSET_MEASURE, |
| VP880_GENA_NP_OFFSET_RESTORE, |
| |
| VP880_ILG_OFFSET_SETUP = 100, |
| VP880_ILG_OFFSET_MEASURE, |
| |
| VP880_ILA_OFFSET_SETUP = 110, |
| VP880_ILA_OFFSET_MEASURE, |
| |
| |
| VP880_RESTORE_DAC = 120, |
| |
| VP880_VAB_NP_ADC_OFFSET_SETUP = 130, |
| VP880_VAB_NP_ADC_OFFSET_MEASURE, |
| |
| VP880_VA_NP_ADC_OFFSET_SETUP = 140, |
| VP880_VA_NP_ADC_OFFSET_MEASURE, |
| |
| VP880_VB_NP_ADC_OFFSET_SETUP = 150, |
| VP880_VB_NP_ADC_OFFSET_MEASURE, |
| |
| VP880_ILA_SETUP = 160, |
| VP880_ILA_ADJUST, |
| VP880_ILA_SET_ADC, |
| VP880_ILA_MEASURE, |
| VP880_ILA_MEASURE_TRACKER, |
| VP880_ILA_MEASURE_ABS, |
| |
| VP880_RESTORE_FEED = 170, |
| |
| VP880_IMT_NP_SETUP = 180, |
| VP880_IMT_NP_SET_ADC, |
| VP880_IMT_NP_MEASURE, |
| |
| #ifdef VP880_TRACKER_SUPPORT |
| VP880_VAS_NP_SETUP = 190, |
| VP880_VAS_NP_STEP, |
| VP880_VAS_NP_SET_ADC, |
| VP880_VAS_NP_MEASURE, |
| VP880_VAS_NP_STORE, |
| #endif |
| |
| VP880_VAB_NP_SETUP = 200, |
| VP880_VAB_NP_MEASURE, |
| |
| VP880_CAL_ADJUST = 210, |
| |
| VP880_CAL_RESTORE = 254, |
| |
| /**< Used in API to force valid/unused initial value */ |
| VP880_CAL_ENUM_SIZE = (VP880_CAL_RESTORE + 1) |
| |
| } Vp880CalLineState; |
| |
| typedef struct Vp880CalLineData { |
| bool calDone; /**< TRUE when calibration has been performed on |
| * this line |
| */ |
| bool reversePol; /**< TRUE when line is in reverse polarity */ |
| |
| Vp880CalTypeData typeData; |
| |
| uint8 codecReg; |
| |
| uint8 dcFeedRef[VP880_DC_FEED_LEN]; /**< Customer settings per profile */ |
| uint8 dcFeed[VP880_DC_FEED_LEN]; /**< Normal polarity calibrated values */ |
| uint8 dcFeedPr[VP880_DC_FEED_LEN]; /**< Reverse polarity calibrated values */ |
| |
| Vp880CalLineState calLineState; |
| uint8 sysState; |
| |
| uint8 icr2[VP880_ICR2_LEN]; |
| uint8 icr3[VP880_ICR3_LEN]; |
| |
| uint8 disnVal[VP880_DISN_LEN]; |
| uint8 vpGain[VP880_VP_GAIN_LEN]; |
| uint8 loopSup[VP880_LOOP_SUP_LEN]; |
| |
| bool forceCalDataWrite; |
| |
| /* Signal generator calibration temporary backup */ |
| uint8 sigGenA[VP880_SIGA_PARAMS_LEN]; |
| uint8 calReg[VP880_ICR6_LEN]; |
| uint8 asscReg; |
| |
| /**< Battery Calibration values used to compute final VAS values */ |
| uint8 swCal[VP880_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; /**< Starting point for VAS to reduce calibration time. |
| * This value is based on battery adjustment and the |
| * minimum vas allowed ("minVas" above). |
| */ |
| |
| /* |
| * Cached user data applied after calibration in case line configuration is |
| * changed during calibration. |
| */ |
| uint8 updateFlags; /* |
| * Bit-Mask to mark the information that needs to be |
| * updated when calibration is complete. Note that some |
| * information is automatically updated when calibration |
| * is complete simply as part of the restore process. |
| */ |
| uint8 acProfile[VP880_AC_PROFILE_SIZE]; |
| uint8 dcProfile[VP880_DC_PROFILE_SIZE]; |
| uint8 ringingProfile[VP880_RINGING_PROFILE_SIZE]; |
| |
| VpLineStateType usrState; |
| |
| } Vp880CalLineData; |
| |
| typedef enum Vp880CalDeviceState { |
| VP880_CAL_INIT = 0, |
| VP880_CAL_ERROR, |
| VP880_CAL_MEASURE, |
| VP880_CAL_OFFSET, |
| VP880_CAL_ADC, |
| VP880_CAL_STATE_CHANGE, |
| VP880_CAL_INVERT_POL, |
| VP880_CONVERTER_CHECK, |
| VP880_CAL_DONE, |
| VP880_CAL_CLEANUP, |
| VP880_CAL_EXIT |
| } Vp880CalDeviceState; |
| |
| typedef struct Vp880CalDeviceData { |
| Vp880AbvCalData abvData; |
| Vp880CalDeviceState calDeviceState; |
| int16 calSet; /* Target values for calibration */ |
| uint8 iteration; /**< Used as fail-safe to prevent infinte retries */ |
| } Vp880CalDeviceData; |
| |
| typedef struct Vp880RingParams { |
| bool channelArray[VP880_MAX_NUM_CHANNELS]; |
| uint8 stage[VP880_MAX_NUM_CHANNELS]; |
| uint8 swRegParam[VP880_REGULATOR_PARAM_LEN]; |
| } Vp880RingParams; |
| |
| typedef struct Vp880LineObjectType { |
| 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} |
| */ |
| |
| uint8 ecVal; |
| |
| VpTermType termType; /**< Termination type */ |
| |
| uint16 status; /**< Bit-mask of Vp880LineStatusType Keeps track of line state/config info*/ |
| |
| #ifdef VP_CSLAC_SEQ_EN |
| VpSeqDataType cadence; /**< Sequencer related information */ |
| |
| /**< Array to control internally run sequences */ |
| VpProfileDataType intSequence[VP880_INT_SEQ_LEN]; |
| |
| #ifdef VP880_FXS_SUPPORT |
| VpCallerIdType callerId; /**< Caller ID related information */ |
| VpCidSeqDataType cidSeq; /**< CID Sequencer related information */ |
| uint8 tickBeginState[VP880_CID_PARAM_LEN]; |
| uint8 cidBytesRemain; |
| bool delayConsumed; /**< Set to TRUE when Polling Mode CID uses the loop |
| * read/delay method and has started it. |
| */ |
| |
| bool suspendCid; |
| |
| VpProfilePtrType pRingingCadence; /**< Currently used ringing cadence on |
| * this line |
| */ |
| |
| VpProfilePtrType pMeterProfile; /**< Currently used metering profile on |
| * this line |
| */ |
| |
| VpProfilePtrType pCidProfileType1; /**< Currently used caller ID profile |
| * on this line for sequenced cid |
| */ |
| #endif /* VP880_FXS_SUPPORT */ |
| |
| #ifdef VP880_FXO_SUPPORT |
| VpDigitGenerationDataType digitGenStruct; /**< Used on FXO lines for |
| * generating pulse digits |
| */ |
| #endif /* VP880_FXO_SUPPORT */ |
| #endif /* VP_CSLAC_SEQ_EN */ |
| |
| #ifdef VP880_FXS_SUPPORT |
| 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; |
| |
| /* |
| * 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[VP880_SIGA_PARAMS_LEN]; |
| |
| 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. |
| */ |
| /* Loop supervision parameters */ |
| uint8 hookHysteresis; |
| |
| bool internalTestTermApplied; |
| |
| VpOptionRingControlType ringCtrl; |
| |
| /* |
| * Used to track states for Ground Start Exit Timer Management. Use two steps - first step |
| * completes final state control, the second step is for final hook and ground key debounce. |
| */ |
| uint8 gsTimerExitState; |
| |
| /* |
| * Used to track states for Disconnect Exit Timer Management. Use two steps - first step |
| * completes final state control, the second step is for final hook and ground key debounce. |
| */ |
| uint8 discTimerExitState; |
| |
| VpRelayControlType relayState; /**< Used to hold current line relay state */ |
| |
| #endif |
| |
| VpOptionEventMaskType lineEventsMask; |
| VpOptionEventMaskType lineEvents; |
| |
| uint16 signaling1; |
| uint16 signaling2; |
| uint8 signalingData; /**< Holds data for Signaling events on this line */ |
| |
| |
| #ifdef VP880_FXO_SUPPORT |
| uint8 fxoData; /**< Holds data for FXO events on this line */ |
| uint8 preRingPolRev; /**< The polarity detected prior to ring detect */ |
| VpCslacLineCondType preDisconnect; /**< The disconnect state prior to timer start */ |
| |
| 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. |
| */ |
| #endif |
| |
| uint16 processData; /**< Holds data for Process events on this line */ |
| |
| uint8 responseData; /**< Holds data for Response events on this line */ |
| |
| VpCslacTimerStruct lineTimers; /**< Timers for "this" line */ |
| VpApiIntLineStateType lineState; /**< Line state info used for state |
| * transition handling and recall |
| */ |
| uint8 nextSlicValue; |
| uint8 slicValueCache; /**< Used to reduce MPI reads. */ |
| |
| /* |
| * Holds user definition for Loop Supervision configuration when |
| * "badLoopSup" is TRUE |
| */ |
| uint8 loopSup[VP880_LOOP_SUP_LEN]; |
| |
| uint16 lineEventHandle; /**< Line specific event handle information */ |
| |
| VpOptionPcmTxRxCntrlType pcmTxRxCtrl; /* Defines how the PCM highway is |
| * set for "talk" linestates |
| */ |
| |
| uint16 dtmfDigitSense; /**< Used to hold the DTMF digit reported |
| * with VpDtmfDigitDetected() until the |
| * VP_LINE_EVID_DTMF_DIG is generated. |
| */ |
| |
| VpLineIdType lineId; /**< Application provided value for mapping a line to |
| * a line context |
| */ |
| /* |
| * NOTE: Do not move the location or name of these 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. |
| */ |
| struct Vp880RelGainValues { |
| uint16 gxInt; /**< Cached GX register, in 2.14 int format */ |
| uint16 grInt; /**< Cached GR register, in 2.14 int format */ |
| int16 absGxGain; /**< Cached ABS A-to-D Gain, simplifies code. */ |
| int16 absGrGain; /**< Cached ABS D-to-A Gain, simplifies code. */ |
| } gain; |
| |
| Vp880CalLineData calLineData; |
| |
| VpOptionCodecType codec; |
| |
| #ifdef VP880_FXS_SUPPORT |
| VpHowlerModeCachedValues howlerModeCache; |
| |
| uint8 icr1Values[VP880_ICR1_LEN]; /**< Cached to minimize device access */ |
| uint8 icr2Values[VP880_ICR2_LEN]; /**< Cached to minimize device access */ |
| uint8 icr3Values[VP880_ICR3_LEN]; /**< Cached to minimize device access */ |
| uint8 icr4Values[VP880_ICR4_LEN]; /**< Cached to minimize device access */ |
| uint8 icr6Values[VP880_ICR6_LEN]; /**< Cached to minimize device access */ |
| #endif |
| |
| uint8 opCond[VP880_OP_COND_LEN]; /**< Cached to minimize device access */ |
| uint8 sigGenCtrl[VP880_GEN_CTRL_LEN]; /**< Cached to minimize device access */ |
| |
| #ifdef VP_DEBUG |
| /* For runtime enabling of debug output: */ |
| uint32 debugSelectMask; |
| #endif |
| |
| } Vp880LineObjectType; |
| |
| /* |
| * 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. |
| */ |
| typedef uint32 Vp880DeviceStateIntType; |
| #define VP880_IS_ABS (0x0001) /**< Set when the device is ABS type */ |
| #define VP880_RLY_PROT_REQ (0x0002) /**< Set when the device requires relay protction on I/O 1 */ |
| #define VP880_HAS_TEST_LOAD_SWITCH (0x0004) /**< Set when test load swith is available */ |
| #define VP880_HAS_CALIBRATE_CIRCUIT (0x0008) /**< Set when test cal circuit is available */ |
| |
| #define VP880_IS_HIGH_VOLTAGE (0x0010) /**< Set when device is a high voltage device */ |
| #define VP880_IS_SINGLE_CHANNEL (0x0020) /**< Set when a single channel device is found*/ |
| #define VP880_SYS_CAL_RESET (0x0040) /**< Set when Apply Cal is passed NULL to reset calibration values */ |
| #define VP880_LINE0_IS_FXO (0x0080) /**< Set if device detection indicates line0 as FXO */ |
| |
| #define VP880_LINE1_IS_FXO (0x0100) /**< Set if device detection indicates line1 as FXO */ |
| #define VP880_WIDEBAND (0x0200) /**< Set if device supports Wideband mode */ |
| #define VP880_LINE0_LP (0x0400) /**< Set if line 0 allows low power mode */ |
| #define VP880_LINE1_LP (0x0800) /**< Set if line 1 allows low power mode */ |
| |
| #define VP880_IS_FXO_ONLY (0x1000) /**< Set when the device contains only FXO lines */ |
| #define VP880_SYS_CAL_COMPLETE (0x2000) /**< Set when the system calibration structure has been initialied */ |
| #define VP880_CAL_RELOAD_REQ (0x4000) /**< Set when the line calibration values need to be reloaded. */ |
| #define VP880_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. |
| */ |
| |
| #define VP880_SWY_DECAY_CMP (0x10000) |
| #define VP880_SWZ_DECAY_CMP (0x20000) |
| |
| #define VP880_IS_TEST_CAPABLE (0x40000) /**< Set for devices that support Line Test */ |
| |
| /* |
| * This value is set when either Device Calibration (VpInitDevice()/VpCalCodec() |
| * completes successfully, or when loaded values by Apply System Coeff. After |
| * VpInitDevice() this should only be NOT SET if device calibration failed or |
| * if null was passed to Apply System Coeff. |
| */ |
| #define VP880_DEVICE_CAL_COMPLETE (0x80000) |
| |
| |
| #define VP880_SYS_CAL_POLARITY_LENGTH 2 |
| #define VP880_SYS_CAL_CHANNEL_LENGTH 2 |
| |
| /* Contains calibration error values -- in +/-10mv LSB */ |
| typedef struct Vp880SysCalResultsType { |
| int16 abvError[2]; |
| |
| int16 vocOffset[VP880_SYS_CAL_CHANNEL_LENGTH][VP880_SYS_CAL_POLARITY_LENGTH]; |
| int16 vocError[VP880_SYS_CAL_CHANNEL_LENGTH][VP880_SYS_CAL_POLARITY_LENGTH]; |
| |
| int16 sigGenAError[VP880_SYS_CAL_CHANNEL_LENGTH][VP880_SYS_CAL_POLARITY_LENGTH]; |
| |
| int16 ila20[VP880_SYS_CAL_CHANNEL_LENGTH]; |
| int16 ila25[VP880_SYS_CAL_CHANNEL_LENGTH]; |
| int16 ila32[VP880_SYS_CAL_CHANNEL_LENGTH]; |
| int16 ila40[VP880_SYS_CAL_CHANNEL_LENGTH]; |
| |
| int16 ilaOffsetNorm[VP880_SYS_CAL_CHANNEL_LENGTH]; |
| int16 ilgOffsetNorm[VP880_SYS_CAL_CHANNEL_LENGTH]; |
| |
| /* Used for Tracker only */ |
| uint8 vas[VP880_SYS_CAL_CHANNEL_LENGTH][VP880_SYS_CAL_POLARITY_LENGTH]; |
| |
| int16 vagOffsetNorm[VP880_SYS_CAL_CHANNEL_LENGTH]; |
| int16 vagOffsetRev[VP880_SYS_CAL_CHANNEL_LENGTH]; |
| int16 vbgOffsetNorm[VP880_SYS_CAL_CHANNEL_LENGTH]; |
| int16 vbgOffsetRev[VP880_SYS_CAL_CHANNEL_LENGTH]; |
| |
| /* Used for ABS only */ |
| uint8 absNormCal[VP880_SYS_CAL_CHANNEL_LENGTH]; |
| uint8 absPolRevCal[VP880_SYS_CAL_CHANNEL_LENGTH]; |
| |
| int16 swyOffset[VP880_SYS_CAL_CHANNEL_LENGTH]; /**< Used to hold SWY Offset */ |
| int16 swzOffset[VP880_SYS_CAL_CHANNEL_LENGTH]; /**< Used to hold SWZ Offset */ |
| int16 swxbOffset[VP880_SYS_CAL_CHANNEL_LENGTH]; /**< Used to hold SWXB Offset */ |
| |
| /* Used for capacitance line test only */ |
| int32 tipCapCal[VP880_SYS_CAL_CHANNEL_LENGTH]; |
| int32 ringCapCal[VP880_SYS_CAL_CHANNEL_LENGTH]; |
| } Vp880SysCalResultsType; |
| |
| #define VP880_CAL_STRUCT_SIZE (40*sizeof(int16) + 8*sizeof(uint8) + 4*sizeof(int32)) |
| |
| typedef struct Vp880DeviceObjectType { |
| /* Device identifier set by the application -- passed to the HAL */ |
| VpDeviceIdType deviceId; |
| |
| /* Silicon RCN/PCN and number of channels supported */ |
| VpDeviceStaticInfoType staticInfo; |
| |
| /* |
| * Weak attempt to put everything that changes during run-time into a |
| * single structure. Good idea in principle, but in practice the devices |
| * are too dis-similar to share many common structures. |
| * |
| * This holds the "last channel checked" event information, clock fault, |
| * and battery fault. |
| */ |
| VpDeviceDynamicInfoType dynamicInfo; |
| |
| /* |
| * Variety of common device level status such as init/not init, init in |
| * progress, test buffer read y/n?, etc.. Internally used by the VP-API-II |
| * to communicate device state. |
| * |
| * This is a bit-mask of VpDeviceStateType values |
| */ |
| uint16 state; |
| |
| /* |
| * Similar to common device level status, this is for 880 specific type of |
| * device level information. Such as ABS/Tracker, LPM lines, etc.. |
| * |
| * This is a bit-mask of Vp880DeviceStateIntType values |
| */ |
| uint32 stateInt; |
| |
| /*-----------------3/18/2010 3:51PM----------------- |
| * Device Level OPTION Values |
| * --------------------------------------------------*/ |
| /* OPTION_ID_EVENT_MASK for device level events */ |
| VpOptionEventMaskType deviceEventsMask; |
| |
| /* OPTION_ID_PULSE */ |
| VpOptionPulseType pulseSpecs; |
| |
| /* OPTION_ID_PULSE2 */ |
| VpOptionPulseType pulseSpecs2; |
| |
| /* OPTION_ID_CRITICAL_FLT */ |
| VpOptionCriticalFltType criticalFault; |
| |
| /* |
| * Stored device level events. Note that this is an alternative method to |
| * an event queue. So if an event queue is later used, this value could be |
| * removed and all it's uses replaced. |
| */ |
| VpOptionEventMaskType deviceEvents; |
| |
| /* |
| * Device level timers such as clock fault, LPM Enter/Exit, VpCalCodec() |
| * steps, etc.. |
| */ |
| uint16 devTimer[VP_DEV_TIMER_LAST]; |
| |
| /* |
| * Soft values from the device profile that are used throughout the VP-API-II |
| * (not only in Init). Note that other values may be provided by the device |
| * profile, but are stored in other ways generally because they also may NOT |
| * be provided in the device profile (i.e., API has default values). |
| */ |
| Vp880DeviceProfileType devProfileData; |
| |
| /* This is the profile pointer table per the VP-API-II User's Guide. */ |
| VpCSLACDeviceProfileTableType devProfileTable; |
| |
| /* |
| * This is the structure indicating which profile table entries have been |
| * initialized. If profile tables are disabled, this and the device profile |
| * table (devProfileTable) can be removed. |
| */ |
| VpCSLACProfileTableEntryType profEntry; |
| |
| /* |
| * Raw information from the device signaling register last read. This |
| * information is internally converted into useable VP-API-II information. |
| */ |
| uint8 intReg[VP880_UL_SIGREG_LEN]; |
| uint8 intReg2[VP880_UL_SIGREG_LEN]; |
| |
| /* Buffer to support VpLowLevelCmd() only. */ |
| #if !defined(VP_REDUCED_API_IF) || defined(ZARLINK_CFG_INTERNAL) |
| uint8 mpiData[VP880_MAX_MPI_DATA]; |
| #endif |
| |
| /* |
| * Data length copied into mpiData buffer -- used for VpLowLevelCmd() and |
| * Apply/Get System Calibration |
| */ |
| uint8 mpiLen; |
| |
| /* Handle to return with events as applicable */ |
| uint16 eventHandle; |
| |
| /* |
| * VP-API-II timing in 500us increments (per the VP-API-II User's Guide). |
| * Generally incremented at the tick rate. |
| */ |
| uint16 timeStamp; |
| int16 timeRemainder; /**< leftover of tick time for tickrates not divisible by 0.5ms */ |
| |
| /* Data returned with response events as applicable */ |
| uint8 responseData; |
| |
| /* Data returned with "Get Option" events */ |
| VpGetResultsOptionsType getResultsOption; |
| |
| /* Data returned with VpSetRelGain() function call/event. */ |
| VpRelGainResultsType relGainResults; |
| |
| #if defined (VP880_INCLUDE_TESTLINE_CODE) |
| /* Testing structure */ |
| VpTestResultType testResults; |
| |
| Vp880CurrentTestType currentTest; |
| |
| /**< Used to hold calibration offset coeffs. One per channel */ |
| Vp880CalOffCoeffs calOffsets[VP880_MAX_NUM_CHANNELS]; |
| |
| #endif /* VP880_INCLUDE_TESTLINE_CODE */ |
| |
| |
| /* |
| * Used to hold battery switch calibration offset. One per channel, per |
| * polarity |
| */ |
| uint8 calState; |
| Vp880CalDeviceData calData; |
| |
| /* |
| * Used to get better hook granularity and pcm buffered data. |
| */ |
| uint8 txBuffer[VP880_TX_PCM_BUFF_LEN]; |
| uint8 txBufferDataRate; |
| |
| /* |
| * These switcher paramaters are from the user setting in the |
| * device profile. They should never be changed except in Init (in case |
| * the values provided are illegal). |
| */ |
| uint8 swParams[VP880_REGULATOR_PARAM_LEN]; |
| |
| /* |
| * These switcher paramaters should always be a SW representation of the |
| * silicon used to reduce device level access. The driver MUST change this |
| * setting if the device itself is changed. |
| */ |
| uint8 swParamsCache[VP880_REGULATOR_PARAM_LEN]; |
| |
| /* |
| * These internal switcher paramaters are from the user setting in the |
| * device profile. They should never be changed except in Init (in case |
| * the values provided are illegal). |
| */ |
| uint8 intSwParams[VP880_INT_SWREG_PARAM_LEN]; |
| |
| /* |
| * These internal switcher paramaters are for Free Run mode only and should |
| * only be set during Init Device (in case a set was not provided or if the |
| * provided set is illegal). |
| */ |
| uint8 intSwParamsFR[VP880_INT_SWREG_PARAM_LEN]; |
| |
| uint8 yVolt; /* Y-Switcher Target in 1V step */ |
| uint8 zVolt; /* Z-Switcher Target in 1V step */ |
| |
| #if defined (VP_CC_880_SERIES) || defined (VP_CC_KWRAP) |
| Vp880SysCalResultsType vp880SysCalData; |
| #endif |
| |
| /* used to store the in-rush current function data */ |
| Vp880RingParams ringParams; |
| |
| #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; |
| |
| /* Device Mode Register (0x5E/5F) cached to minimize MPI traffic */ |
| uint8 devMode[VP880_DEV_MODE_LEN]; |
| } Vp880DeviceObjectType; |
| |
| #endif /**< vp880_api.h */ |
