| /** \file vp880_fxo_control.c |
| * vp880_fxo_control.c |
| * |
| * This file contains the control functions for the Vp880 device API. |
| * |
| * Copyright (c) 2011, Microsemi |
| * |
| * $Revision: 1.1.2.1.8.3 $ |
| * $LastChangedDate: 2010-03-16 09:44:15 -0500 (Tue, 16 Mar 2010) $ |
| */ |
| |
| #include "vp_api_cfg.h" |
| |
| #if defined (VP_CC_880_SERIES) && defined (VP880_FXO_SUPPORT) |
| |
| /* INCLUDES */ |
| #include "vp_api_types.h" |
| #include "vp_hal.h" |
| #include "vp_api_int.h" |
| #include "vp880_api.h" |
| #include "vp880_api_int.h" |
| #include "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). |
| */ |
| #ifndef VP880_CLARE_RINGING_DETECT |
| static void |
| Vp880LowRingFreqDetect( |
| VpLineCtxType *pLineCtx, |
| VpCslacLineCondType *tempRingingSt, |
| VpCslacLineCondType *tempPolRevSt, |
| bool *retFlag); |
| #endif |
| |
| /** |
| * Vp880SetFxoState() |
| * This function sets the line state for an FXO line. |
| * |
| * Preconditions: |
| * See VpSetLineState() |
| * |
| * Postconditions: |
| * Returns success code if the channel can be set and the line state. |
| */ |
| VpStatusType |
| Vp880SetFxoState( |
| VpLineCtxType *pLineCtx, /**< Line context to change line state on */ |
| VpLineStateType state) /**< The desired line state to set */ |
| { |
| Vp880LineObjectType *pLineObj = pLineCtx->pLineObj; |
| uint8 ecVal = pLineObj->ecVal; |
| |
| VpDevCtxType *pDevCtx = pLineCtx->pDevCtx; |
| Vp880DeviceObjectType *pDevObj = pDevCtx->pDevObj; |
| VpDeviceIdType deviceId = pDevObj->deviceId; |
| |
| VpLineStateType currentState = pLineObj->lineState.currentState; |
| uint8 fxoCidLine; |
| uint8 userByte, userByteBefore; |
| |
| VP_API_FUNC_INT(VpLineCtxType, pLineCtx, ("Vp880SetFxoState+")); |
| |
| /* |
| * FXO is straightforward, just set as defined by termination type since we already know it's
|
| * not an unsupported state (except error maybe) |
| */ |
| VpMpiCmdWrapper(deviceId, ecVal, VP880_IODATA_REG_RD, VP880_IODATA_REG_LEN, &userByteBefore); |
| userByte = userByteBefore; |
| |
| if ((pLineObj->termType == VP_TERM_FXO_GENERIC) |
| || (pLineObj->termType == VP_TERM_FXO_DISC)) { |
| /* Pre-clear both bits for convenience */ |
| if (pLineObj->termType == VP_TERM_FXO_DISC) { |
| fxoCidLine = VP880_IODATA_IO3; |
| } else { |
| fxoCidLine = VP880_FXO_CID_LINE; |
| } |
| |
| userByte &= (uint8)(~(VP880_IODATA_IO1 | fxoCidLine)); |
| |
| switch(state) { |
| case VP_LINE_FXO_TALK: |
| /* IO3/IO1 = 00, so ok */ |
| break; |
| |
| case VP_LINE_FXO_OHT: |
| /* IO3/IO1 = 01, so set IO1 to 1 */ |
| userByte |= VP880_IODATA_IO1; |
| break; |
| |
| case VP_LINE_FXO_LOOP_CLOSE: |
| /* IO3/IO1 = 10, so set IO3 to 1 */ |
| userByte |= fxoCidLine; |
| break; |
| |
| case VP_LINE_FXO_LOOP_OPEN: |
| /* IO3/IO1 = 11, so set IO3 and IO1 to 1 */ |
| userByte |= (fxoCidLine | VP880_IODATA_IO1); |
| break; |
| |
| default: |
| /* This should be redundant from TX/RX PCM code section above */ |
| return VP_STATUS_INVALID_ARG; |
| } |
| |
| VP_FXO_FUNC(VpLineCtxType, pLineCtx, ("Set FXO State %d Register 0x%02X at time %d", |
| state, userByte, pDevObj->timeStamp)); |
| |
| /* Set the loop open/close bit */
|
| VpMpiCmdWrapper(deviceId, ecVal, VP880_IODATA_REG_WRT, VP880_IODATA_REG_LEN, &userByte); |
| |
| } else { |
| VP_API_FUNC_INT(VpLineCtxType, pLineCtx, ("Vp880SetFxoState-")); |
| return VP_STATUS_INVALID_ARG; |
| } |
| |
| if ( ((state == VP_LINE_FXO_TALK) || (state == VP_LINE_FXO_LOOP_CLOSE)) |
| && ((currentState == VP_LINE_FXO_OHT) || (currentState == VP_LINE_FXO_LOOP_OPEN)) ) { |
| VP_FXO_FUNC(VpLineCtxType, pLineCtx, ("Last State Change Timer Set at %d", |
| pDevObj->timeStamp)); |
| |
| pLineObj->lineTimers.timers.fxoTimer.lastStateChange = 0; |
| } |
| |
| if ( ((state == VP_LINE_FXO_OHT) || (state == VP_LINE_FXO_LOOP_OPEN)) |
| && ((currentState == VP_LINE_FXO_TALK) || (currentState == VP_LINE_FXO_LOOP_CLOSE)) ) { |
| VP_FXO_FUNC(VpLineCtxType, pLineCtx, ("Last State Change Timer Set at %d", |
| pDevObj->timeStamp)); |
| |
| pLineObj->lineTimers.timers.fxoTimer.lastStateChange = 0; |
| } |
| |
| /* Set the FXO CODEC Mode */ |
| userByte = (VP880_FXO_ACTIVATE_CODEC | VP880_FXO_SUPERVISION_EN); |
| |
| /* Perform the FXO Line State change */ |
| if (pLineObj->slicValueCache != userByte) { |
| pLineObj->slicValueCache = userByte; |
| VpMpiCmdWrapper(deviceId, ecVal, VP880_SYS_STATE_WRT, |
| VP880_SYS_STATE_LEN, &pLineObj->slicValueCache); |
| } |
| |
| VP_API_FUNC_INT(VpLineCtxType, pLineCtx, ("Vp880SetFxoState-")); |
| |
| return VP_STATUS_SUCCESS; |
| } |
| |
| #ifndef VP880_CLARE_RINGING_DETECT |
| /** |
| * Vp880LowRingFreqDetect() |
| * This function should only be called by Vp880ProcessFxoLine. It performs |
| * Ringing and PolRev detection on lines configured to detect ringing |
| * frequencies below what the device can support. |
| * |
| * Preconditions: |
| * Conditions defined by purpose of Vp880ProcessFxoLine. |
| * |
| * Postconditions: |
| * The Api variables and events (as appropriate) for the line passed have been |
| * updated. Return Flag passed is set to TRUE if an event is pending. |
| */ |
| void |
| Vp880LowRingFreqDetect( |
| VpLineCtxType *pLineCtx, |
| VpCslacLineCondType *tempRingingSt, |
| VpCslacLineCondType *tempPolRevSt, |
| bool *retFlag) |
| { |
| VpDevCtxType *pDevCtx = pLineCtx->pDevCtx; |
| Vp880LineObjectType *pLineObj = pLineCtx->pLineObj; |
| Vp880DeviceObjectType *pDevObj = pDevCtx->pDevObj; |
| uint8 channelId = pLineObj->channelId; |
| uint16 polRevPeriod; |
| |
| if (*tempPolRevSt != |
| (VpCslacLineCondType)(pLineObj->lineState.condition & VP_CSLAC_POLREV)) { |
| pLineObj->lineState.condition &= ~VP_CSLAC_POLREV; |
| pLineObj->lineState.condition |= *tempPolRevSt; |
| pLineObj->lineState.condition &= ~VP_CSLAC_POLREV_REPORTED; |
| |
| /* |
| * Capture the period of the last two pol revs. Used for |
| * Ringing Detection |
| */ |
| pLineObj->lineTimers.timers.fxoTimer.prevHighToLowTime = |
| ((pLineObj->lineTimers.timers.fxoTimer.timePrevPolRev |
| + pLineObj->lineTimers.timers.fxoTimer.timeLastPolRev) |
| / 4); |
| |
| pLineObj->lineTimers.timers.fxoTimer.timePrevPolRev = |
| pLineObj->lineTimers.timers.fxoTimer.timeLastPolRev; |
| pLineObj->lineTimers.timers.fxoTimer.timeLastPolRev = 0; |
| } |
| |
| if (pDevObj->intReg[channelId] & VP880_LIU1_MASK) { |
| pLineObj->lineState.condition |= VP_CSLAC_LIU; |
| } else { |
| pLineObj->lineState.condition &= ~VP_CSLAC_LIU; |
| pLineObj->lineTimers.timers.fxoTimer.lastNotLiu = |
| pLineObj->ringDetMax * 2; |
| } |
| |
| polRevPeriod = |
| pLineObj->lineTimers.timers.fxoTimer.prevHighToLowTime; |
| |
| if ((pLineObj->lineTimers.timers.fxoTimer.timePrevPolRev / 4) |
| < pLineObj->ringDetMax) { |
| if (pLineObj->lineState.condition & VP_CSLAC_POLREV) { |
| pLineObj->fxoData = VP_POLREV_REVERSE; |
| } else { |
| pLineObj->fxoData = VP_POLREV_NORMAL; |
| } |
| } |
| |
| /* Evaluate the detectors */ |
| /* |
| * If the LIU Threshold has been exceeded, it's definitely not |
| * PolRev, but may be ringing. If it has been completely |
| * debounced, then Ringing is removed if we previously had |
| * Ringing. |
| */ |
| if (pLineObj->lineTimers.timers.fxoTimer.lastNotLiu) { |
| /* |
| * The threshold has been exceeded for a period within the |
| * debounce interval. Check on Ringing condition. |
| */ |
| |
| if ((pLineObj->lineTimers.timers.fxoTimer.timeLastPolRev / 4) |
| > pLineObj->ringDetMax) { |
| /* |
| * This occurs because we had a recent LIU threshold, |
| * but the frequency is not correct. No action other |
| * than clearing Ringing state is necessary. |
| */ |
| *tempRingingSt = VP_CSLAC_STATUS_INVALID; |
| if (pLineObj->lineState.condition & VP_CSLAC_POLREV) { |
| pLineObj->fxoData = VP_POLREV_REVERSE; |
| } else { |
| pLineObj->fxoData = VP_POLREV_NORMAL; |
| } |
| } else if ((polRevPeriod <= pLineObj->ringDetMax) |
| && (polRevPeriod >= pLineObj->ringDetMin)) { |
| *tempRingingSt = VP_CSLAC_RINGING; |
| } else { |
| /* |
| * This prevents compiler warning because it forces |
| * the value to an initialized state |
| */ |
| *tempRingingSt = |
| (VpCslacLineCondType)(pLineObj->lineState.condition & VP_CSLAC_RINGING); |
| } |
| } else { |
| *tempRingingSt = 0; |
| |
| /* We were not ringing, so process for polrev event */ |
| if (!(pLineObj->lineState.condition & VP_CSLAC_RINGING)) { |
| /* |
| * Require a 5ms delay (plus LIU 2ms the debounce time) |
| * from previous polrev to occur before allowing it to |
| * be detected as "Not Ringing". This gives time for |
| * most ringing signals to exceed the LIU threshold. |
| */ |
| if ((pLineObj->lineTimers.timers.fxoTimer.timeLastPolRev / 4) >= 5) { |
| if (!(pLineObj->lineState.condition & VP_CSLAC_POLREV_REPORTED)) { |
| pLineObj->lineState.condition |= VP_CSLAC_POLREV_REPORTED; |
| |
| /* |
| * Based on how Ringing behaves, we could get out |
| * of sync w.r.t., PolRev. So don't report an event |
| * unless the PolRev changed. |
| */ |
| if (pLineObj->lineState.condition & VP_CSLAC_POLREV) { |
| if (pLineObj->fxoData != VP_POLREV_REVERSE) { |
| pLineObj->fxoData = VP_POLREV_REVERSE; |
| pLineObj->lineEventHandle = pDevObj->timeStamp; |
| pLineObj->lineEvents.fxo |= VP_LINE_EVID_POLREV; |
| *retFlag = TRUE; |
| pLineObj->preRingPolRev = VP_POLREV_REVERSE; |
| } |
| } else { |
| if (pLineObj->fxoData != VP_POLREV_NORMAL) { |
| pLineObj->fxoData = VP_POLREV_NORMAL; |
| pLineObj->lineEventHandle = pDevObj->timeStamp; |
| pLineObj->lineEvents.fxo |= VP_LINE_EVID_POLREV; |
| pLineObj->preRingPolRev = VP_POLREV_NORMAL; |
| *retFlag = TRUE; |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| /** |
| * Vp880ProcessFxoLine() |
| * This function should only be called by Vp880ServiceInterrupts on FXO 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. |
| */ |
| bool |
| Vp880ProcessFxoLine( |
| Vp880DeviceObjectType *pDevObj, |
| VpLineCtxType *pLineCtx) |
| { |
| Vp880LineObjectType *pLineObj = pLineCtx->pLineObj; |
| bool retFlag = FALSE; |
| VpCslacLineCondType tempRingingSt, tempDiscSt, tempPolRevSt, tempLiu; |
| uint8 channelId = pLineObj->channelId, discMask = 0; |
| VpLineStateType currentState = pLineObj->lineState.currentState; |
| |
| /* |
| * Ignore the detector for a period after the last hook state change, or |
| * a longer period after the last hook state change AND if the previous |
| * line condition was Ringing |
| */ |
| if ((pLineObj->lineTimers.timers.fxoTimer.lastStateChange < VP_FXO_STATE_CHANGE_DEBOUNCE) || |
| ((pLineObj->lineTimers.timers.fxoTimer.lastStateChange < VP_FXO_RING_TRIP_DEBOUNCE) |
| && (pLineObj->lineState.condition & VP_CSLAC_RINGING)) |
| #ifdef VP_CSLAC_SEQ_EN |
| || ((pLineObj->cadence.status & VP_CADENCE_STATUS_ACTIVE) |
| && (pLineObj->intSequence[VP_PROFILE_TYPE_LSB] == VP_PRFWZ_PROFILE_MOMENTARY_LOOP_OPEN_INT)) |
| #endif |
| ) { |
| /* Middle of detector Mask. Skip this process */ |
| } else { |
| if ((pLineObj->termType == VP_TERM_FXO_DISC) |
| && ((currentState == VP_LINE_FXO_TALK) || (currentState == VP_LINE_FXO_LOOP_CLOSE))) { |
| discMask = pDevObj->intReg[channelId] & VP880_IO2_1_MASK; |
| } else { |
| discMask = pDevObj->intReg[channelId] & VP880_DISC1_MASK; |
| } |
| |
| if (discMask) { |
| tempDiscSt = VP_CSLAC_DISC; |
| } else { |
| tempDiscSt = VP_CSLAC_STATUS_INVALID; |
| } |
| |
| if (pDevObj->intReg[channelId] & VP880_POL1_MASK) { |
| tempPolRevSt = VP_CSLAC_POLREV; |
| } else { |
| tempPolRevSt = VP_CSLAC_STATUS_INVALID; |
| } |
| |
| if (pLineObj->ringDetMax >= VP880_MAX_RING_DET_PERIOD) { |
| Vp880LowRingFreqDetect(pLineCtx, &tempRingingSt, &tempPolRevSt, |
| &retFlag); |
| } else { |
| if (pDevObj->intReg[channelId] & VP880_LIU1_MASK) { |
| tempLiu = VP_CSLAC_LIU; |
| } else { |
| tempLiu = VP_CSLAC_STATUS_INVALID; |
| } |
| |
| if (tempLiu != (VpCslacLineCondType)(pLineObj->lineState.condition & VP_CSLAC_LIU)) { |
| pLineObj->lineState.condition &= ~VP_CSLAC_LIU; |
| pLineObj->lineState.condition |= tempLiu; |
| |
| pLineObj->lineEventHandle = pDevObj->timeStamp; |
| pLineObj->lineEvents.fxo |= |
| ((tempLiu) ? VP_LINE_EVID_LIU : VP_LINE_EVID_LNIU); |
| retFlag = TRUE; |
| } |
| |
| if (pDevObj->intReg[channelId] & VP880_RING1_DET_MASK) { |
| tempRingingSt = VP_CSLAC_RINGING; |
| } else { |
| tempRingingSt = VP_CSLAC_STATUS_INVALID; |
| } |
| |
| if (tempPolRevSt != |
| (VpCslacLineCondType)(pLineObj->lineState.condition & VP_CSLAC_POLREV)) { |
| pLineObj->lineState.condition &= ~VP_CSLAC_POLREV; |
| pLineObj->lineState.condition |= tempPolRevSt; |
| pLineObj->lineState.condition &= ~VP_CSLAC_POLREV_REPORTED; |
| |
| if ((tempRingingSt != VP_CSLAC_RINGING) |
| && ((pLineObj->lineTimers.timers.fxoTimer.timeLastPolRev / 4) |
| > pLineObj->ringDetMax)) { |
| pLineObj->lineEventHandle = pDevObj->timeStamp; |
| pLineObj->lineEvents.fxo |= VP_LINE_EVID_POLREV; |
| retFlag = TRUE; |
| pLineObj->preRingPolRev = |
| (pLineObj->lineState.condition & VP_CSLAC_POLREV) ? |
| VP_POLREV_REVERSE : VP_POLREV_NORMAL; |
| } |
| |
| pLineObj->lineTimers.timers.fxoTimer.timeLastPolRev = 0; |
| |
| if (pLineObj->lineState.condition & VP_CSLAC_POLREV) { |
| pLineObj->fxoData = VP_POLREV_REVERSE; |
| } else { |
| pLineObj->fxoData = VP_POLREV_NORMAL; |
| } |
| } |
| } |
| |
| /* |
| * Our cached state is inconsistent with recently detected conditions. |
| * Generate the event. |
| */ |
| if ((VpCslacLineCondType)(pLineObj->lineState.condition & VP_CSLAC_RINGING) != tempRingingSt) { |
| pLineObj->lineEventHandle = pDevObj->timeStamp; |
| |
| if (tempRingingSt == VP_CSLAC_RINGING) { |
| pLineObj->lineEvents.fxo |= VP_LINE_EVID_RING_ON; |
| pLineObj->lineState.condition |= VP_CSLAC_RINGING; |
| } else { |
| pLineObj->lineEvents.fxo |= VP_LINE_EVID_RING_OFF; |
| pLineObj->lineState.condition &= ~(VP_CSLAC_RINGING); |
| |
| if (pLineObj->preRingPolRev != pLineObj->fxoData) { |
| pLineObj->preRingPolRev = pLineObj->fxoData; |
| pLineObj->lineEvents.fxo |= VP_LINE_EVID_POLREV; |
| } |
| } |
| retFlag = TRUE; |
| } |
| |
| /* If the feed conditions changed, continue line processing */ |
| if((VpCslacLineCondType)(pLineObj->lineState.condition & VP_CSLAC_DISC) != tempDiscSt) { |
| /* |
| * Update actual line condition, even if not reporting an |
| * event |
| */ |
| if (tempDiscSt == VP_CSLAC_DISC) { |
| pLineObj->lineState.condition |= VP_CSLAC_DISC; |
| } else { |
| pLineObj->lineState.condition &= ~(VP_CSLAC_DISC); |
| } |
| |
| /* |
| * If line has been stable, update the pre-Disconnect value that |
| * is used at end of timer to determine if event should be |
| * generated. |
| */ |
| if (pLineObj->lineTimers.timers.fxoTimer.disconnectDebounce == 0) { |
| pLineObj->preDisconnect = tempDiscSt; |
| } |
| |
| /* Line status changed. Therefore, reset timer */ |
| pLineObj->lineTimers.timers.fxoTimer.disconnectDebounce = |
| VP_FXO_DISCONNECT_DEBOUNCE; |
| |
| /* |
| * Immediate disconnect changes detected do not result in |
| * API-II event. So retFlag remains as set previously. |
| */ |
| } else { |
| /* |
| * If the disconnect signal came back to the current state, stop |
| * the debounce count |
| */ |
| if (pLineObj->termType == VP_TERM_FXO_DISC) { |
| pLineObj->lineTimers.timers.fxoTimer.noCount = TRUE; |
| pLineObj->lineTimers.timers.fxoTimer.fxoDiscIO2Change = 0; |
| } |
| } |
| } /* end interrupt detect */ |
| return retFlag; |
| } /* end Vp880ProcessFxoLine */ |
| /* end of VP880_CLARE_RINGING_DETECT */ |
| #else |
| |
| /** |
| * Vp880ProcessFxoLine() |
| * This function should only be called by Vp880ServiceInterrupts on FXO 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. |
| */ |
| bool |
| Vp880ProcessFxoLine( |
| Vp880DeviceObjectType *pDevObj, |
| VpLineCtxType *pLineCtx) |
| { |
| Vp880LineObjectType *pLineObj = pLineCtx->pLineObj; |
| bool retFlag = FALSE; |
| VpCslacLineCondType tempRingingSt, tempDiscSt, tempPolRevSt, tempLiu; |
| uint8 channelId = pLineObj->channelId, discMask = 0; |
| VpLineStateType currentState = pLineObj->lineState.currentState; |
| VpFXOTimerType *pFxoTimers = &pLineObj->lineTimers.timers.fxoTimer; |
| |
| /* |
| * Ignore the detector for a period after the last hook state change, or |
| * a longer period after the last hook state change AND if the previous |
| * line condition was Ringing |
| */ |
| if ((pFxoTimers->lastStateChange < VP_FXO_STATE_CHANGE_DEBOUNCE) || |
| ((pFxoTimers->lastStateChange < VP_FXO_RING_TRIP_DEBOUNCE) |
| && (pLineObj->lineState.condition & VP_CSLAC_RINGING)) |
| #ifdef VP_CSLAC_SEQ_EN |
| || ((pLineObj->cadence.status & VP_CADENCE_STATUS_ACTIVE) |
| && (pLineObj->intSequence[VP_PROFILE_TYPE_LSB] |
| == VP_PRFWZ_PROFILE_MOMENTARY_LOOP_OPEN_INT)) |
| #endif |
| ) { |
| /* Middle of detector Mask. Skip this process */ |
| } else { |
| if ((pLineObj->termType == VP_TERM_FXO_DISC) |
| && ((currentState == VP_LINE_FXO_TALK) |
| || (currentState == VP_LINE_FXO_LOOP_CLOSE))) { |
| discMask = pDevObj->intReg[channelId] & VP880_IO2_1_MASK; |
| } else { |
| discMask = pDevObj->intReg[channelId] & VP880_DISC1_MASK; |
| } |
| |
| tempDiscSt = ((discMask != 0) ? VP_CSLAC_RAW_DISC : VP_CSLAC_STATUS_INVALID); |
| |
| tempPolRevSt = ((pDevObj->intReg[channelId] & VP880_POL1_MASK) |
| ? VP_CSLAC_POLREV : VP_CSLAC_STATUS_INVALID); |
| tempRingingSt = ((pDevObj->intReg[channelId] & VP880_RING1_DET_MASK) |
| ? VP_CSLAC_RINGING : VP_CSLAC_STATUS_INVALID); |
| |
| /* |
| * Ringing Detector is unstable in presence of Disconnect, and the |
| * Disconnect is filtered for generally 28-40ms. So if currently |
| * detecting Disconnect or just "recently" stopped detecting Disconnect, |
| * prevent Ringing events and Ring_On status. |
| */ |
| if ((pLineObj->lineState.condition & (VP_CSLAC_LIU | VP_CSLAC_RAW_DISC | VP_CSLAC_DISC)) || |
| (pFxoTimers->disconnectDebounce > 0)) { |
| tempRingingSt = VP_CSLAC_STATUS_INVALID; |
| } |
| |
| if ((currentState == VP_LINE_FXO_TALK) |
| || (currentState == VP_LINE_FXO_LOOP_CLOSE)) { |
| tempLiu = (VpCslacLineCondType)(pLineObj->lineState.condition & VP_CSLAC_LIU); |
| } else { |
| tempLiu = (pDevObj->intReg[channelId] & VP880_LIU1_MASK) |
| ? VP_CSLAC_LIU : VP_CSLAC_STATUS_INVALID; |
| } |
| |
| /* |
| * Multiple PolRevs can/will be detected prior to ringing but not after |
| * (ringing "off" occurs when the line is stable). So we have to know |
| * what the polarity was if a PolRev event was generated prior to |
| * ringing, so we generate a corresponding correction event post ringing. |
| */ |
| if((VpCslacLineCondType)(pLineObj->lineState.condition & VP_CSLAC_RINGING) != tempRingingSt) { |
| pLineObj->lineEventHandle = pDevObj->timeStamp; |
| if (tempRingingSt == VP_CSLAC_RINGING) { |
| pLineObj->lineEvents.fxo |= VP_LINE_EVID_RING_ON; |
| pLineObj->lineState.condition |= VP_CSLAC_RINGING; |
| } else { |
| pLineObj->lineEvents.fxo |= VP_LINE_EVID_RING_OFF; |
| pLineObj->lineState.condition &= ~(VP_CSLAC_RINGING); |
| |
| VP_FXO_FUNC(VpLineCtxType, pLineCtx, ("Ringing Stop. Pre-Ring PolRev %d Current %d", |
| pLineObj->preRingPolRev, tempPolRevSt)); |
| |
| if (((pLineObj->preRingPolRev == VP_POLREV_NORMAL) && (tempPolRevSt)) |
| || ((pLineObj->preRingPolRev == VP_POLREV_REVERSE) && (!(tempPolRevSt)))) { |
| /* |
| * PolRev is out of sync due to transitions prior to ringing |
| * detect. Correct it. |
| */ |
| tempPolRevSt = ((tempPolRevSt == VP_CSLAC_POLREV) |
| ? VP_CSLAC_STATUS_INVALID : VP_CSLAC_POLREV); |
| } |
| } |
| retFlag = TRUE; |
| } |
| |
| if (pLineObj->lineState.condition & VP_CSLAC_RINGING) { |
| /* Not PolRev events if ringing is detected. */ |
| tempPolRevSt = (VpCslacLineCondType)(pLineObj->lineState.condition & VP_CSLAC_POLREV); |
| } |
| |
| if ((tempPolRevSt != (VpCslacLineCondType)(pLineObj->lineState.condition & VP_CSLAC_POLREV))) { |
| pLineObj->lineState.condition &= ~VP_CSLAC_POLREV; |
| pLineObj->lineState.condition |= tempPolRevSt; |
| pLineObj->lineState.condition &= ~VP_CSLAC_POLREV_REPORTED; |
| |
| if ((pFxoTimers->timeLastPolRev / 4) > pLineObj->ringDetMax) { |
| pLineObj->lineEventHandle = pDevObj->timeStamp; |
| pLineObj->lineEvents.fxo |= VP_LINE_EVID_POLREV; |
| retFlag = TRUE; |
| pLineObj->preRingPolRev = |
| (pLineObj->lineState.condition & VP_CSLAC_POLREV) ? |
| VP_POLREV_REVERSE : VP_POLREV_NORMAL; |
| } |
| |
| pFxoTimers->timeLastPolRev = 0; |
| |
| if (pLineObj->lineState.condition & VP_CSLAC_POLREV) { |
| pLineObj->fxoData = VP_POLREV_REVERSE; |
| } else { |
| pLineObj->fxoData = VP_POLREV_NORMAL; |
| } |
| } |
| |
| if (tempLiu != (VpCslacLineCondType)(pLineObj->lineState.condition & VP_CSLAC_LIU)) { |
| VP_FXO_FUNC(VpLineCtxType, pLineCtx, ("LIU Change to %d at time %d", |
| tempLiu, pDevObj->timeStamp)); |
| |
| pLineObj->lineState.condition &= ~VP_CSLAC_LIU; |
| pLineObj->lineState.condition |= tempLiu; |
| |
| pLineObj->lineEventHandle = pDevObj->timeStamp; |
| pLineObj->lineEvents.fxo |= |
| ((tempLiu == VP_CSLAC_LIU) ? VP_LINE_EVID_LIU : VP_LINE_EVID_LNIU); |
| |
| if (tempLiu == VP_CSLAC_STATUS_INVALID) { |
| /* |
| * Line status changed. Therefore, reset timer to prevent |
| * Ringing events. |
| */ |
| pFxoTimers->disconnectDebounce = VP_FXO_DISCONNECT_DEBOUNCE; |
| } |
| |
| retFlag = TRUE; |
| } |
| |
| /* If the feed conditions changed, continue line processing */ |
| if((VpCslacLineCondType)(pLineObj->lineState.condition & VP_CSLAC_RAW_DISC) != tempDiscSt) { |
| VP_FXO_FUNC(VpLineCtxType, pLineCtx, ("RAW_DISC Change to %d at time %d", |
| tempDiscSt, pDevObj->timeStamp)); |
| /* |
| * Update actual line condition, even if not reporting an |
| * event |
| */ |
| if (tempDiscSt == VP_CSLAC_RAW_DISC) { |
| pLineObj->lineState.condition |= VP_CSLAC_RAW_DISC; |
| } else { |
| pLineObj->lineState.condition &= ~VP_CSLAC_RAW_DISC; |
| } |
| |
| /* |
| * Line status changed. Therefore, reset timer and state we think |
| * the line is in. This is resolved when timer expires. |
| */ |
| pFxoTimers->disconnectDebounce = VP_FXO_DISCONNECT_DEBOUNCE; |
| pLineObj->preDisconnect = tempDiscSt; |
| |
| /* |
| * Immediate disconnect changes detected do not result in |
| * API-II event. So retFlag remains as set previously. |
| */ |
| } else { |
| /* |
| * If the disconnect signal came back to the current state, stop |
| * the debounce count |
| */ |
| if (pLineObj->termType == VP_TERM_FXO_DISC) { |
| pFxoTimers->noCount = TRUE; |
| pFxoTimers->fxoDiscIO2Change = 0; |
| } |
| } |
| } /* end interrupt detect */ |
| return retFlag; |
| } /* end Vp880ProcessFxoLine */ |
| #endif |
| |
| #endif |
