Google Git
Sign in
gfiber / barebox / mindspeed / e07691a57d188e073fec943fc23b6bbafda64d16 / . / diags / legerity / api-II / api_lib / vp880_api / vp880_init.c
blob: f8eae227474345224ac64e1c965c792b2c7c6659 [file] [log] [blame]
/** \file vp880_init.c
* vp880_init.c
*
* This file contains the line and device initialization functions for
* the Vp880 device API.
*
* Copyright (c) 2011, Microsemi
*
* $Revision: 1.1.2.1.8.3 $
* $LastChangedDate: 2012-01-03 10:13:15 -0600 (Tue, 03 Jan 2012) $
*/
#include "../includes/vp_api_cfg.h"
#ifdef VP_CC_880_SERIES
/* INCLUDES */
#include "../../arch/uvb/vp_api_types.h"
#include "../includes/vp_api.h"
#include "../includes/vp_api_int.h"
#include "../includes/vp880_api.h"
#include "../vp880_api/vp880_api_int.h"
#include "../../arch/uvb/vp_hal.h"
#include "../../arch/uvb/sys_service.h"
/**< Vp880 Initalization Function Prototypes */
static VpStatusType Vp880Init(VpDevCtxType *pDevCtx);
static VpStatusType
Vp880InitDevice(
VpDevCtxType *pDevCtx,
VpProfilePtrType pDevProfile,
VpProfilePtrType pAcProfile,
VpProfilePtrType pDcProfile,
VpProfilePtrType pRingProfile,
VpProfilePtrType pFxoAcProfile,
VpProfilePtrType pFxoCfgProfile);
static VpStatusType Vp880DeviceReset(Vp880DeviceObjectType *pDevObj);
static VpStatusType
Vp880InitLine(
VpLineCtxType *pLineCtx,
VpProfilePtrType pAcProfile,
VpProfilePtrType pDcFeedOrFxoCfgProfile,
VpProfilePtrType pRingProfile);
static VpStatusType
Vp880InitProfile(
VpDevCtxType *pDevCtx,
VpProfileType type,
VpProfilePtrType pProfileIndex,
VpProfilePtrType pProfile);
#ifdef VP880_FXS_SUPPORT
static void Vp880CopyDefaultFRProfile(Vp880DeviceObjectType *pDevObj);
#endif /* VP880_FXS_SUPPORT */
/**
* VpMakeVp880DeviceObject()
* This function performs the main tasks of VpMakeDeviceObject() for Vp880 type
* of devices.
*
* Preconditions:
* Same as VpMakeDeviceObject(), and in addition the deviceType pointed to by
* pDevCtx should be Vp880 series type.
*
* Postconditions:
* VpAPI Function pointers for pDevCtx are initialized to Vp880 specific
* functions. This completes the function abstraction for "this" device.
*/
VpStatusType
VpMakeVp880DeviceObject(
VpDevCtxType *pDevCtx, /**< Device context to be initialized with function
* pointers
*/
Vp880DeviceObjectType *pDevObj) /**< Device object containing information
* for the device pointed to by pDevCtx
*/
{
VpMemSet(pDevObj, 0, sizeof(Vp880DeviceObjectType));
pDevObj->staticInfo.maxChannels = VP880_MAX_NUM_CHANNELS;
#ifdef VP_DEBUG
pDevObj->debugSelectMask = VP_OPTION_DEFAULT_DEBUG_SELECT;
#endif
/* Initialize other elements in the device object */
return VpMakeVp880DeviceCtx(pDevCtx, pDevObj);
} /* VpMakeVp880DeviceObject() */
/**
* VpMakeVp880DeviceCtx()
* This function initializes the device context to handle Vp880 functionality.
*
* Preconditions:
* This function should be called after initializing the device object. This
* function can be called more than once since it does not modify the contents
* of the device object.
*
* Postconditions:
* Initializes device context to be able to handle Vp780 functionality.
*/
VpStatusType
VpMakeVp880DeviceCtx(
VpDevCtxType *pDevCtx, /**< Device Context to be initialized */
Vp880DeviceObjectType *pDevObj) /**< Device Object that has been already
* initialized
*/
{
uint8 channelCount, maxChan;
/* All error checking of arguments performed in calling functions */
/* Initialize Device context */
pDevCtx->pDevObj = pDevObj;
pDevCtx->deviceType = VP_DEV_880_SERIES;
/*
* Initialize all of the line context pointers to null in the device context
*/
maxChan = pDevObj->staticInfo.maxChannels;
for (channelCount = 0; channelCount < maxChan; channelCount++) {
pDevCtx->pLineCtx[channelCount] = VP_NULL;
}
/* Functions in apiInit.c */
pDevCtx->funPtrsToApiFuncs.MakeLineObject = Vp880MakeLineObject;
pDevCtx->funPtrsToApiFuncs.InitDevice = Vp880InitDevice;
pDevCtx->funPtrsToApiFuncs.InitLine = Vp880InitLine;
pDevCtx->funPtrsToApiFuncs.ConfigLine = Vp880ConfigLine;
pDevCtx->funPtrsToApiFuncs.InitProfile = Vp880InitProfile;
#ifdef VP880_FXS_SUPPORT
pDevCtx->funPtrsToApiFuncs.FreeRun = Vp880FreeRun;
#ifdef VP_CSLAC_SEQ_EN
pDevCtx->funPtrsToApiFuncs.InitRing = Vp880InitRing;
pDevCtx->funPtrsToApiFuncs.InitCid = Vp880InitCid;
pDevCtx->funPtrsToApiFuncs.InitMeter = VpCSLACInitMeter;
pDevCtx->funPtrsToApiFuncs.DtmfDigitDetected = VpCSLACDtmfDigitDetected;
#endif /* VP_CSLAC_SEQ_EN */
#endif /* VP880_FXS_SUPPORT */
#ifndef VP_REDUCED_API_IF
pDevCtx->funPtrsToApiFuncs.ClearResults = VpCSLACClearResults;
#endif /* VP_REDUCED_API_IF */
/* Functions in apicnt.c */
pDevCtx->funPtrsToApiFuncs.SetLineState = Vp880SetLineState;
pDevCtx->funPtrsToApiFuncs.SetLineTone = Vp880SetLineTone;
#ifdef CSLAC_GAIN_RELATIVE
pDevCtx->funPtrsToApiFuncs.SetRelGain = Vp880SetRelGain;
#endif /* CSLAC_GAIN_RELATIVE */
#ifdef VP880_FXS_SUPPORT
pDevCtx->funPtrsToApiFuncs.SetRelayState = Vp880SetRelayState;
#endif /* VP880_FXS_SUPPORT */
#ifdef VP_CSLAC_SEQ_EN
pDevCtx->funPtrsToApiFuncs.SendSignal = Vp880SendSignal;
#ifdef VP880_FXS_SUPPORT
pDevCtx->funPtrsToApiFuncs.SendCid = Vp880SendCid;
pDevCtx->funPtrsToApiFuncs.ContinueCid = Vp880ContinueCid;
pDevCtx->funPtrsToApiFuncs.StartMeter = VpCSLACStartMeter;
#endif /* VP880_FXS_SUPPORT */
#endif /* VP_CSLAC_SEQ_EN */
pDevCtx->funPtrsToApiFuncs.SetOption = Vp880SetOption;
#ifndef VP880_SIMPLE_POLLED_MODE
pDevCtx->funPtrsToApiFuncs.VirtualISR = Vp880VirtualISR;
#endif /* VP880_SIMPLE_POLLED_MODE */
pDevCtx->funPtrsToApiFuncs.ApiTick = Vp880ApiTick;
#if !defined(VP_REDUCED_API_IF) || defined(ZARLINK_CFG_INTERNAL)
pDevCtx->funPtrsToApiFuncs.LowLevelCmd = Vp880LowLevelCmd;
#endif /* !defined(VP_REDUCED_API_IF) || defined(ZARLINK_CFG_INTERNAL) */
pDevCtx->funPtrsToApiFuncs.DeviceIoAccess = Vp880DeviceIoAccess;
/* Functions in apiQuery.c */
pDevCtx->funPtrsToApiFuncs.GetEvent = Vp880GetEvent;
pDevCtx->funPtrsToApiFuncs.GetLineStatus = VpCSLACGetLineStatus;
pDevCtx->funPtrsToApiFuncs.GetDeviceStatus = Vp880GetDeviceStatus;
pDevCtx->funPtrsToApiFuncs.FlushEvents = Vp880FlushEvents;
pDevCtx->funPtrsToApiFuncs.GetResults = Vp880GetResults;
pDevCtx->funPtrsToApiFuncs.GetOption = Vp880GetOption;
#ifdef VP880_INCLUDE_TESTLINE_CODE
/* Technically a "Query" function, but used only for Line Test purposes */
pDevCtx->funPtrsToApiFuncs.GetRelayState = Vp880GetRelayState;
#endif /* VP880_INCLUDE_TESTLINE_CODE */
#if (VP_CC_DEBUG_SELECT & VP_DBG_ERROR)
pDevCtx->funPtrsToApiFuncs.RegisterDump = Vp880RegisterDump;
pDevCtx->funPtrsToApiFuncs.ObjectDump = Vp880ObjectDump;
#endif /* (VP_CC_DEBUG_SELECT & VP_DBG_ERROR) */
/* Functions in apiTestLine.c */
#ifdef VP880_INCLUDE_TESTLINE_CODE
pDevCtx->funPtrsToApiFuncs.TestLineInt = Vp880TestLineInt;
pDevCtx->funPtrsToApiFuncs.TestLineCallback = Vp880TestLineCallback;
pDevCtx->funPtrsToApiFuncs.TestLine = Vp880TestLine;
#endif /* VP880_INCLUDE_TESTLINE_CODE */
/* Functions in apiCal.c */
#if defined (VP880_FXS_SUPPORT) && defined (VP_CSLAC_RUNTIME_CAL_ENABLED)
#if !defined(VP_REDUCED_API_IF) || defined (VP_ENABLE_PROD_TEST)
/*
* The VpCalCodec() function is largely removed from the VP-API-II interface
* because it is not required. Once a system is calibrated, it does not need
* to be recalibrated AND actions performed in VpCalCodec() occur during
* VpInitDevice() (hence, no need for the application to directly call
* VpCalCodec()). However, for Production test purposes it is
* required. This is because backdoor methods are used to change the target
* voltage without intending to fully reinitialize the device. This can only
* be achieved by forcing battery calibration to repeat, which is done in
* the VpCalCodec() function (i.e., calling VpInitDevice() is not desired).
*/
pDevCtx->funPtrsToApiFuncs.CalCodec = Vp880CalCodec;
#endif /* !defined(VP_REDUCED_API_IF) || defined (VP_ENABLE_PROD_TEST) */
pDevCtx->funPtrsToApiFuncs.CalLine = Vp880CalLine;
#endif /* defined (VP880_FXS_SUPPORT) && defined (VP_CSLAC_RUNTIME_CAL_ENABLED) */
pDevCtx->funPtrsToApiFuncs.Cal = Vp880Cal;
return VP_STATUS_SUCCESS;
}
/**
* VpMakeVp880LineObject()
* This function initializes a line context using the information that is
* passed. This function is like a C++ constructor. It initializes the passed
* line context and line object based on the paramters provided. The passed line
* object type should match with the type of device object type. See VP-API
* reference guide for more information.
*
* Preconditions:
* This function assumes device context has already been created and
* initialized. This function should only be called after downloading the boot
* image the device when applicable (like for VCP class of devices).
*
* Postconditions:
* This function initializes the line context/line object. Line related VP-API
* functions can be called after calling this function.
*/
VpStatusType
Vp880MakeLineObject(
VpTermType termType,
uint8 channelId,
VpLineCtxType *pLineCtx,
void *pVoidLineObj,
VpDevCtxType *pDevCtx)
{
Vp880LineObjectType *pLineObj = pVoidLineObj;
Vp880DeviceObjectType *pDevObj = pDevCtx->pDevObj;
VpDeviceIdType deviceId = pDevObj->deviceId;
if (channelId >= pDevObj->staticInfo.maxChannels) {
return VP_STATUS_INVALID_ARG;
}
VpSysEnterCritical(deviceId, VP_CODE_CRITICAL_SEC);
VpMemSet(pLineObj, 0, sizeof(Vp880LineObjectType));
#ifdef VP_DEBUG
pLineObj->debugSelectMask = VP_OPTION_DEFAULT_DEBUG_SELECT;
#endif
switch (termType) {
#ifdef VP880_FXO_SUPPORT
case VP_TERM_FXO_GENERIC:
case VP_TERM_FXO_DISC: {
Vp880DeviceStateIntType chanMap[] =
{VP880_LINE0_IS_FXO, VP880_LINE1_IS_FXO};
/*
* At this point, it is only a recommendation. We'll adjust this
* when we determine the device type found in VpInitDevice()
*/
if (pDevObj->state & VP_DEV_INIT_CMP) {
if (chanMap[channelId] & pDevObj->stateInt) {
pLineObj->status |= VP880_IS_FXO;
} else {
VpSysExitCritical(deviceId, VP_CODE_CRITICAL_SEC);
return VP_STATUS_ERR_VTD_CODE;
}
} else {
pLineObj->status |= VP880_IS_FXO;
}
pDevObj->stateInt |= ((channelId == 0) ? VP880_LINE0_LP : VP880_LINE1_LP);
/*
* The "calDone" flag for the line object has to be set in order
* for VP_CAL_GET_SYSTEM_COEFF to return valid data. Otherwise, it
* would think the system is not 100% calibrated and return an error
* code. The FXO lines do not require calibration so this is the
* only opportuity to set this flag.
*/
pLineObj->calLineData.calDone = TRUE;
}
break;
#endif /* VP880_FXO_SUPPORT */
#ifdef VP880_FXS_SUPPORT
case VP_TERM_FXS_GENERIC:
case VP_TERM_FXS_ISOLATE:
case VP_TERM_FXS_SPLITTER:
pLineObj->status = VP880_INIT_STATUS;
pDevObj->stateInt &= ((channelId == 0) ? ~VP880_LINE0_LP : ~VP880_LINE1_LP);
break;
#ifdef VP880_LP_SUPPORT
case VP_TERM_FXS_LOW_PWR:
case VP_TERM_FXS_ISOLATE_LP:
case VP_TERM_FXS_SPLITTER_LP:
pLineObj->status = VP880_INIT_STATUS;
pDevObj->stateInt |= ((channelId == 0) ? VP880_LINE0_LP : VP880_LINE1_LP);
break;
#endif /* VP880_LP_SUPPORT */
#endif /* VP880_FXS_SUPPORT */
default:
VpSysExitCritical(deviceId, VP_CODE_CRITICAL_SEC);
return VP_STATUS_ERR_VTD_CODE;
}
pLineCtx->pLineObj = pLineObj;
pLineCtx->pDevCtx = pDevCtx;
pDevCtx->pLineCtx[channelId] = pLineCtx;
pLineObj->channelId = channelId;
pLineObj->termType = termType;
pLineObj->ecVal = ((channelId == 0) ? VP880_EC_CH1 : VP880_EC_CH2);
VpSysExitCritical(deviceId, VP_CODE_CRITICAL_SEC);
/* Everything else done by device/line specific functions */
return VP_STATUS_SUCCESS;
}
/**
* Vp880Init
* This function initializes the device, and (contrary to InitDevice) does
* not initialize any channels. This function should be called internal to the
* API only.
*
* Preconditions:
* The device context must be of a Vp880 device type.
*
* Postconditions:
* This function returns a failure code if the clock configuration is not set
* correctly based on the device data set in InitDevice.
*/
VpStatusType
Vp880Init(
VpDevCtxType *pDevCtx)
{
Vp880DeviceObjectType *pDevObj = pDevCtx->pDevObj;
VpDeviceIdType deviceId = pDevObj->deviceId;
uint8 intMaskData[] = {0x7F, 0xFF};
uint8 clkNotStable;
uint8 clkTestCount;
VP_API_FUNC_INT(VpDevCtxType, pDevCtx, ("Vp880Init+"));
/*
* If the MPI Bus gets out of sequence for any reason, a HW reset command
* will not work and this function may fail. To be sure a reset occurs, the
* following sequence is required.
*/
if(Vp880DeviceReset(pDevObj) != VP_STATUS_SUCCESS) {
VP_ERROR(VpDevCtxType, pDevCtx, ("Device Failed to Reset Properly"));
VP_API_FUNC_INT(VpDevCtxType, pDevCtx, ("Vp880Init-"));
return VP_STATUS_FAILURE;
}
/*
* Setup mclk. The MCLK mask set the mclk frequency, sets the mclk source
* (the MCLK pin or the PCLK pin), and sets the interrupt pin output drive
* mode (TTL or open collector)
*/
VpMpiCmdWrapper(deviceId, VP880_EC_CH1, VP880_MCLK_CNT_WRT, VP880_MCLK_CNT_LEN,
&pDevObj->devProfileData.devCfg1);
/* Setup the Clock Fail Interrupt */
VpMpiCmdWrapper(deviceId, VP880_EC_CH1, VP880_INT_MASK_WRT, VP880_INT_MASK_LEN,
intMaskData);
/*
* Wait for the CFAIL bit to clear before proceding. If the CFAIL bit does
* not clear after several trys, give up and return an error condition. Wait
* between each read of the status register.
*/
clkNotStable = VP880_CFAIL_MASK;
clkTestCount = MAX_CFAIL_TEST;
while(clkNotStable && (--clkTestCount) != 0) {
VpSysWait(CFAIL_TEST_INTERVAL*10);
VpMpiCmdWrapper(deviceId, VP880_EC_CH1, VP880_UL_SIGREG_RD,
VP880_UL_SIGREG_LEN, pDevObj->intReg);
clkNotStable = pDevObj->intReg[0] & VP880_CFAIL_MASK;
}
/*
* The CFAIL bit did not clear so the part will not complete initialization.
* Return error status to indicate failure.
*/
if(clkNotStable) {
pDevObj->deviceEvents.faults |= VP_DEV_EVID_CLK_FLT;
VP_ERROR(VpDevCtxType, pDevCtx, ("Device Failed to Reset Clock Fault"));
VP_API_FUNC_INT(VpDevCtxType, pDevCtx, ("Vp880Init-"));
return VP_STATUS_FAILURE;
}
/* Setup interrupts back to default */
intMaskData[0] = 0xFF; /* Clear all Device Interrupt Masks */
VpMpiCmdWrapper(deviceId, VP880_EC_CH1, VP880_INT_MASK_WRT, VP880_INT_MASK_LEN, intMaskData);
/*
* The PCM mask tells the device which clock edge to grab and xmit the
* PCM data on and also which clock period LSB of the PCM data starts on
*/
VpMpiCmdWrapper(deviceId, VP880_EC_CH1, VP880_XR_CS_WRT, VP880_XR_CS_LEN,
&pDevObj->devProfileData.clockSlot);
VP_API_FUNC_INT(VpDevCtxType, pDevCtx, ("Vp880Init-"));
return VP_STATUS_SUCCESS;
} /* Vp880Init */
/**
* Vp880DeviceReset
* This function resets the MPI buffer and HW reset of the device. The method
* for doing this depends on the silicon revision due to I/O1 driver
* requirements.
*
* Preconditions:
* None.
*
* Postconditions:
* The Device is reset, and I/O1 is in a safe condition.
*/
VpStatusType
Vp880DeviceReset(
Vp880DeviceObjectType *pDevObj)
{
VpDeviceIdType deviceId = pDevObj->deviceId;
uint8 mpiCmdData, deviceRcn;
VpStatusType status;
VP_API_FUNC_INT(None, VP_NULL, ("Vp880DeviceReset+"));
/*
* First, make sure the MPI buffer is cleared so we can write to the
* device correctly prior to HW reset. Also verify a valid RCN/PCN.
*/
if ((status = Vp880InitDevicePcnRcn(pDevObj, deviceId)) != VP_STATUS_SUCCESS) {
return status;
}
deviceRcn = pDevObj->staticInfo.rcnPcn[VP880_RCN_LOCATION];
if (deviceRcn >= VP880_REV_JE) {
mpiCmdData = VP880_IODATA_IO1;
VP_LINE_STATE(None, NULL, ("3. Write IODATA 0x%02X on Both Channels",
VP880_IODATA_IO1));
VpMpiCmdWrapper(deviceId, (VP880_EC_CH1 | VP880_EC_CH2), VP880_IODATA_REG_WRT,
VP880_IODATA_REG_LEN, &mpiCmdData);
VpSysWait(24); /* EMR's take 2-3 ms to open/close */
}
/* Proceed with normal device level reset and required delay */
VpMpiCmdWrapper(deviceId, VP880_EC_CH1, VP880_HW_RESET_WRT, 0, VP_NULL);
VpSysWait(20);
VP_API_FUNC_INT(None, VP_NULL, ("Vp880DeviceReset-"));
return VP_STATUS_SUCCESS;
}
/*******************************************************************************
* Vp880InitDevicePcnRcn()
* Read in the PCN so we will know what type of device specifically we
* are working with. This affects the max number of lines supported by the
* device as well as the type of lines (and may affect the line init)
*
* Note: EC value is not important for this command
*
* Arguments:
* pDevObj -
* deviceId -
*
* Preconditions:
*
* Postconditions:
******************************************************************************/
VpStatusType
Vp880InitDevicePcnRcn(
Vp880DeviceObjectType *pDevObj,
VpDeviceIdType deviceId)
{
uint8 devicePcn, deviceRcn;
/*
* If Device has already been succesfully initialized, don't need to run
* this process.
*/
if (pDevObj->state & VP_DEV_INIT_CMP) {
return VP_STATUS_SUCCESS;
}
VpCSLACClearMPIBuffer(deviceId);
/*
* Read revision code
* If >= JA then force I/O as below
* Force I/O1 to '1', and wait for (if present) the external relay to
* open
*/
VpMpiCmdWrapper(deviceId, VP880_EC_CH1, VP880_RCN_PCN_RD, VP880_RCN_PCN_LEN,
pDevObj->staticInfo.rcnPcn);
devicePcn = pDevObj->staticInfo.rcnPcn[VP880_PCN_LOCATION];
deviceRcn = pDevObj->staticInfo.rcnPcn[VP880_RCN_LOCATION];
/* MPI Failure if the PCN and RCN are both 0x00 or 0xFF */
if (((devicePcn == 0xFF) && (deviceRcn == 0xFF)) ||
((devicePcn == 0x00) && (deviceRcn == 0x00))) {
pDevObj->state &= ~(VP_DEV_INIT_IN_PROGRESS | VP_DEV_INIT_CMP);
VP_ERROR(None, VP_NULL, ("Device Failed to Detect Revision/PCN Properly: 0x%02X 0x%02X",
deviceRcn, devicePcn));
VP_API_FUNC_INT(None, VP_NULL, ("Vp880InitDevicePcnRcn-"));
return VP_STATUS_FAILURE;
}
/*
* Force the revision code to at least JE on devices that behave just
* like JE and later devices, but have earlier revisions.
*
* NOTE: The revision code is used by I/O control, Set Relay State, Line
* test and other. Be VERY CAREFULL changing this "rcn force" to make sure
* no other major area is broken. A global search and code review everywhere
* the RCN is evaluated is the minimum required before making such a change.
*/
if (((devicePcn == VP880_DEV_PCN_88536) || (devicePcn == VP880_DEV_PCN_88264))
&& (deviceRcn < VP880_REV_JE)) {
deviceRcn = VP880_REV_JE;
pDevObj->staticInfo.rcnPcn[VP880_RCN_LOCATION] = VP880_REV_JE;
}
if (deviceRcn < VP880_REV_VC) {
pDevObj->state &= ~(VP_DEV_INIT_IN_PROGRESS | VP_DEV_INIT_CMP);
VP_ERROR(None, VP_NULL, ("Unsupported Silicon Revision %d",
pDevObj->staticInfo.rcnPcn[VP880_RCN_LOCATION]));
VP_API_FUNC_INT(None, VP_NULL, ("Vp880InitDevicePcnRcn-"));
return VP_STATUS_FAILURE;
}
/*
* Verify that we recognize the device by limiting to the range of those supported in the
* Vp880PcnType table. If not recognized (although may be a valid PN) return an error because
* the API-II does not know how to handle it. More often, the error is occuring because the
* hardware cannot talk to the device.
*/
switch(devicePcn) {
#ifdef VP880_FXO_SUPPORT
case VP880_DEV_PCN_88010: /**< FXO Only Silicon */
pDevObj->stateInt |= VP880_LINE0_IS_FXO;
#endif /* VP880_FXO_SUPPORT */
#if defined (VP880_FXS_SUPPORT) && defined (VP880_TRACKER_SUPPORT)
case VP880_DEV_PCN_88111: /* FXS-Tracker */
case VP880_DEV_PCN_88116: /* FXS-Tracker - Wideband */
case VP880_DEV_PCN_88131: /* FXS-Tracker */
case VP880_DEV_PCN_88136: /* FXS-Tracker - Wideband */
#endif /* (VP880_FXS_SUPPORT) && defined (VP880_TRACKER_SUPPORT) */
pDevObj->staticInfo.maxChannels = 1;
pDevObj->stateInt |= VP880_IS_SINGLE_CHANNEL;
break;
#if defined (VP880_TRACKER_SUPPORT) || defined (VP880_FXO_SUPPORT)
case VP880_DEV_PCN_88311: /* FXO/FXS-Tracker */
case VP880_DEV_PCN_88331: /* FXO/FXS-Tracker */
pDevObj->stateInt |= VP880_LINE1_IS_FXO;
#endif /* (VP880_TRACKER_SUPPORT) || defined (VP880_FXO_SUPPORT) */
#ifdef VP880_FXS_SUPPORT
#ifdef VP880_TRACKER_SUPPORT
case VP880_DEV_PCN_88211: /* 2FXS-Tracker */
case VP880_DEV_PCN_88216: /* 2FXS-Tracker - Wideband */
case VP880_DEV_PCN_88231: /* 2FXS-Tracker */
case VP880_DEV_PCN_88236: /* 2FXS-Tracker - Wideband */
case VP880_DEV_PCN_88506: /* 2FXS-Tracker - Wideband Split Package*/
case VP880_DEV_PCN_88536: /* 2FXS-Tracker - Wideband, IP Block */
#endif /* VP880_TRACKER_SUPPORT */
#ifdef VP880_ABS_SUPPORT
case VP880_DEV_PCN_88221: /* 2FXS-ABS */
case VP880_DEV_PCN_88226: /* 2FXS-ABS - Wideband */
case VP880_DEV_PCN_88241: /* 2FXS-ABS */
case VP880_DEV_PCN_88246: /* 2FXS-ABS - Wideband */
case VP880_DEV_PCN_88264: /* 2FXS-ABS - Wideband, ZSI */
case VP880_DEV_PCN_88286_QFN: /* 2FXS-ABS, HV, WB, No Test Load */
case VP880_DEV_PCN_88266_QFN: /* 2FXS-ABS, LV, WB, No Test Load */
#endif /* VP880_ABS_SUPPORT */
#endif /* VP880_FXS_SUPPORT */
pDevObj->staticInfo.maxChannels = 2;
pDevObj->stateInt &= ~VP880_IS_SINGLE_CHANNEL;
break;
default:
pDevObj->state &= ~(VP_DEV_INIT_IN_PROGRESS | VP_DEV_INIT_CMP);
VP_ERROR(None, VP_NULL, ("Revision/PCN Unknown"));
VP_API_FUNC_INT(None, VP_NULL, ("Vp880InitDevicePcnRcn-"));
return VP_STATUS_FAILURE;
}
if (devicePcn & VP880_TRACKER_MASK) {
#if defined (VP880_TRACKER_SUPPORT) && defined (VP880_FXS_SUPPORT)
/* Mark as non-ABS device type */
pDevObj->stateInt &= ~VP880_IS_ABS;
#endif /* (VP880_TRACKER_SUPPORT) && defined (VP880_FXS_SUPPORT) */
} else {
if (devicePcn == VP880_DEV_PCN_88010) {
#ifdef VP880_FXO_SUPPORT
/* FXO only devices */
pDevObj->stateInt |= VP880_IS_FXO_ONLY;
#endif /* VP880_FXO_SUPPORT */
} else {
#ifdef VP880_ABS_SUPPORT
/* Last choice is ABS type */
pDevObj->stateInt |= VP880_IS_ABS;
#endif /* VP880_ABS_SUPPORT */
}
}
/*
* Check for High Voltage Device and line test switch
* Currently high voltage and test switch go hand in hand but may not in
* the future that is why there are two bits but only a test for one.
*/
if ((devicePcn & VP880_HV_MASK) == VP880_HV_MASK) {
pDevObj->stateInt |= VP880_IS_HIGH_VOLTAGE;
/* All HV devices support Line Test */
pDevObj->stateInt |= VP880_IS_TEST_CAPABLE;
if ((devicePcn != VP880_DEV_PCN_88506) && (devicePcn != VP880_DEV_PCN_88286_QFN)) {
pDevObj->stateInt |= VP880_HAS_TEST_LOAD_SWITCH;
}
} else {
/* Le88266 also supports Line Test but is LV */
if ((devicePcn == VP880_DEV_PCN_88264) ||
(devicePcn == VP880_DEV_PCN_88266_QFN) ||
((devicePcn == VP880_DEV_PCN_88226) && (deviceRcn > VP880_REV_VC))) {
pDevObj->stateInt |= VP880_IS_TEST_CAPABLE;
}
pDevObj->stateInt &= ~VP880_IS_HIGH_VOLTAGE;
pDevObj->stateInt &= ~VP880_HAS_TEST_LOAD_SWITCH;
}
#ifdef VP880_ALWAYS_USE_INTERNAL_TEST_TERMINATION
/* If this option is defined, we will treat this device as if it has no
* physical test load. The internal test termination only works for
* revisions newer than VC, so ignore this override if it can't be used */
if (deviceRcn > VP880_REV_VC) {
pDevObj->stateInt &= ~VP880_HAS_TEST_LOAD_SWITCH;
}
#endif /* VP880_ALWAYS_USE_INTERNAL_TEST_TERMINATION */
#ifdef VP_ENABLE_PROD_TEST
/* Workaround to enable LM Production Tests */
/*
* The HV flag is incorrectly set (actually) but done so because earlier
* Line Test used this flag for determing Line Test Capabilities. Later
* Low Voltage silicon that supported Line Testing of course voided this
* rule requiring a new flag that specifically indicates Test Capable or not
* (hence - VP880_IS_TEST_CAPABLE). To be fully compatible, both flags must
* be set.
*
* Note that these settings SHOULD NOT be enabled for normal production
* purposes. Although it enables some amount of line testing (sufficient to
* measure some key parameters in the Appliations lab), test performance and
* accuracy is not gauranteed. Only a very limited number of tests from the
* VeriVoice Line Test Suite are used. Other tests may not run at all or
* run into a system lockup condition.
*/
pDevObj->stateInt |= (VP880_IS_HIGH_VOLTAGE | VP880_IS_TEST_CAPABLE);
#endif /* VP_ENABLE_PROD_TEST */
/* Check for Wideband Mode support */
if ((devicePcn == VP880_DEV_PCN_88506) ||
(devicePcn == VP880_DEV_PCN_88286_QFN) ||
(devicePcn == VP880_DEV_PCN_88266_QFN) ||
((devicePcn & VP880_IS_IT_WB) == VP880_IS_IT_WB)) {
pDevObj->stateInt |= VP880_WIDEBAND;
}
/* Check for Cal Circuit and relay protection */
if (VP880_REV_VC == deviceRcn) {
if (pDevObj->stateInt & VP880_IS_SINGLE_CHANNEL) {
/* none of the single channel rev 2 devices have a cal circuit */
pDevObj->stateInt &= ~VP880_HAS_CALIBRATE_CIRCUIT;
} else {
pDevObj->stateInt |= VP880_HAS_CALIBRATE_CIRCUIT;
}
} else {
/* all other revs should have cal circuit and require relay protection */
pDevObj->stateInt |= VP880_HAS_CALIBRATE_CIRCUIT;
pDevObj->stateInt |= VP880_RLY_PROT_REQ;
}
if ((devicePcn == VP880_DEV_PCN_88506) || (devicePcn == VP880_DEV_PCN_88536)) {
pDevObj->stateInt |= VP880_RLY_PROT_REQ;
}
return VP_STATUS_SUCCESS;
}
/**
* Vp880InitDevice
* This function initializes the device and all lines associated with this
* device (if line profiles are passed to this function). The device profile
* passed must be valid otherwise an error code is returned and the device
* remains in it's previously initialized state.
*
* Preconditions:
* None (device context is not NULL and is of Vp880 type, which is handled in
* higher level software)
*
* Postconditions:
* This device is initialized to the configuration specified in the device
* profile, and the FXS lines associated with this device are initialized by the
* FXS specific AC, DC, and Ringing profiles passed, and the FXO lines
* associated with this device are initialized by the FXO specific AC and Config
* profiles passed. If the FXO/FXS profiles are all NULL, then only the device
* initialization occurs. This function returns an error code if the device
* profile trying to be used for initialization is VP_PTABLE_NULL (either
* passed or by a non-initialized index).
*/
VpStatusType
Vp880InitDevice(
VpDevCtxType *pDevCtx,
VpProfilePtrType pDevProfile, /**< The profile pointer for the device
* configuration parameters
*/
VpProfilePtrType pAcProfile, /**< The profile pointer (or index) for
* the AC characteristic to apply to the
* FXS lines
*/
VpProfilePtrType pDcProfile, /**< The profile pointer (or index) for
* the DC characteristic to apply to the
* FXS lines
*/
VpProfilePtrType pRingProfile, /**< The profile pointer (or index) for
* the Ringing characteristic to apply to
* the FXS lines
*/
VpProfilePtrType pFxoAcProfile, /**< The profile pointer (or index) for
* the AC characteristic to apply to the
* FXO lines
*/
VpProfilePtrType pFxoCfgProfile)/**< The profile pointer for the FXO
* specific supervision paramaters.
*/
{
VpLineCtxType *pLineCtx;
Vp880DeviceObjectType *pDevObj = pDevCtx->pDevObj;
VpDeviceIdType deviceId = pDevObj->deviceId;
Vp880LineObjectType *pLineObj;
uint8 ecVal = pDevObj->ecVal;
#ifdef VP880_FXS_SUPPORT
uint8 ecAll = (VP880_EC_CH1 | VP880_EC_CH2);
#endif /* VP880_FXS_SUPPORT */
uint8 maxChan, chan, pcn, rcn, mpiData;
VpProfilePtrType pDevProf;
#if defined (VP880_TRACKER_SUPPORT) && defined (VP880_FXS_SUPPORT)
uint8 intSwParam[VP880_INT_SWREG_PARAM_LEN] = {0x5C, 0x4B, 0xC4, 0x4B, 0xC4, 0x4B};
#endif /* defined (VP880_TRACKER_SUPPORT) && defined (VP880_FXS_SUPPORT) */
#ifdef VP880_ABS_SUPPORT
uint8 systemConfig = 0;
#endif /* VP880_ABS_SUPPORT */
#ifdef VP880_CURRENT_LIMIT
uint8 intSwParamLimit[VP880_INT_SWREG_PARAM_LEN] = {0xB2, 0x00, 0xB1, 0x00, 0x60, 0x40};
#endif /* VP880_CURRENT_LIMIT */
VpStatusType status = VP_STATUS_SUCCESS;
int profIndex = VpGetProfileIndex(pDevProfile);
VP_API_FUNC_INT(None, VP_NULL, ("Vp880InitDevice+"));
/*
* Get Profile Index returns -1 if the profile passed is a pointer or
* of VP_PTABLE_NULL type. Otherwise it returns the index
*/
if (profIndex < 0) {
/*
* A pointer is passed or VP_PTABLE_NULL. If it's a pointer, make
* sure the content is valid for the profile type.
*/
if (pDevProfile != VP_PTABLE_NULL) {
if(VpVerifyProfileType(VP_PROFILE_DEVICE, pDevProfile) != TRUE) {
VP_API_FUNC_INT(None, VP_NULL, ("Vp880InitDevice-"));
return VP_STATUS_ERR_PROFILE;
}
} else {
VpSysEnterCritical(deviceId, VP_CODE_CRITICAL_SEC);
pDevObj->state &= ~VP_DEV_INIT_IN_PROGRESS;
VpSysExitCritical(deviceId, VP_CODE_CRITICAL_SEC);
VP_API_FUNC_INT(None, VP_NULL, ("Vp880InitDevice-"));
return VP_STATUS_ERR_PROFILE;
}
pDevProf = pDevProfile;
} else if (profIndex < VP_CSLAC_DEV_PROF_TABLE_SIZE) {
pDevProf = pDevObj->devProfileTable.pDevProfileTable[profIndex];
if (pDevProf == VP_PTABLE_NULL) {
return VP_STATUS_ERR_PROFILE;
}
} else {
VP_API_FUNC_INT(None, VP_NULL, ("Vp880InitDevice-"));
return VP_STATUS_ERR_PROFILE;
}
VpSysEnterCritical(deviceId, VP_CODE_CRITICAL_SEC);
/* Initialize the API's device status variables */
if (pDevObj->state & VP_DEV_INIT_CMP) {
pDevObj->state = (VP_DEV_WARM_REBOOT | VP_DEV_INIT_IN_PROGRESS);
} else {
pDevObj->state = VP_DEV_INIT_IN_PROGRESS;
}
pDevObj->timeStamp = 0;
/* Initialize the API's device dynamic variables */
pDevObj->dynamicInfo.lastChan = 0;
pDevObj->dynamicInfo.bat1Fault = FALSE;
pDevObj->dynamicInfo.bat2Fault = FALSE;
pDevObj->dynamicInfo.bat3Fault = FALSE;
pDevObj->dynamicInfo.clkFault = FALSE;
/*
* Reset the internal state information except for possibly previously
* loaded calibration values.
*/
pDevObj->stateInt &= (VP880_SYS_CAL_COMPLETE | VP880_DEVICE_CAL_COMPLETE);
pDevObj->devProfileData.profVersion = (uint8)(pDevProf[VP_PROFILE_VERSION]);
pDevObj->devProfileData.pcmClkRate =
(uint16)(((pDevProf[VP880_DEV_PROFILE_PCLK_MSB] << 8) & 0xFF00)
| (pDevProf[VP880_DEV_PROFILE_PCLK_LSB] & 0x00FF));
pDevObj->devProfileData.devCfg1 = (uint8)(pDevProf[VP880_DEV_PROFILE_DEVCFG1]);
pDevObj->devProfileData.clockSlot = (uint8)(pDevProf[VP880_DEV_PROFILE_CLOCK_SLOT]);
pDevObj->devProfileData.systemConfig = (uint8)(pDevProf[VP880_DEV_PROFILE_SYSTEM_CFG]);
pDevObj->devProfileData.tickRate =
(uint16)(((pDevProf[VP880_DEV_PROFILE_TICKRATE_MSB] << 8) & 0xFF00)
| (pDevProf[VP880_DEV_PROFILE_TICKRATE_LSB] & 0x00FF));
#ifdef VP880_FXS_SUPPORT
if (pDevProf[VP880_DEV_PROFILE_OPERATIONAL_CFG] & VP880_DEV_PROFILE_PK_PWR_MGMT) {
pDevObj->devProfileData.peakManagement = TRUE;
} else {
pDevObj->devProfileData.peakManagement = FALSE;
}
if (pDevProf[VP880_DEV_PROFILE_OPERATIONAL_CFG] & VP880_DEV_PROFILE_LOW_VOLT_OVERRIDE) {
pDevObj->devProfileData.lowVoltOverride = TRUE;
} else {
pDevObj->devProfileData.lowVoltOverride = FALSE;
}
#endif /* VP880_FXS_SUPPORT */
/*
* Support only version of the profile that contain the switching
* regulator parameters. Otherwise, we really don't know what to do...
*/
if (pDevProf[VP_PROFILE_VERSION] < VP_CSLAC_DEV_PROFILE_VERSION_SW_CONFIG) {
pDevObj->state &= ~(VP_DEV_INIT_IN_PROGRESS | VP_DEV_INIT_CMP);
VpSysExitCritical(deviceId, VP_CODE_CRITICAL_SEC);
VP_ERROR(None, VP_NULL, ("Unsupported Device Profile Version"));
VP_API_FUNC_INT(None, VP_NULL, ("Vp880InitDevice Unsupported Profile Version-"));
return VP_STATUS_ERR_PROFILE;
} else {
VpMemCpy(pDevObj->swParams, &pDevProf[VP880_DEV_PROFILE_SWITCHER_CMD+1],
VP880_REGULATOR_PARAM_LEN);
}
/* Initialize device */
/*
* If not successful, the Clock Fail bit did not clear so return error code
*/
if ((status = Vp880Init(pDevCtx)) != VP_STATUS_SUCCESS) {
pDevObj->state &= ~(VP_DEV_INIT_IN_PROGRESS | VP_DEV_INIT_CMP);
VpSysExitCritical(deviceId, VP_CODE_CRITICAL_SEC);
VP_API_FUNC_INT(None, VP_NULL, ("Vp880Init Init Failure-"));
return status;
}
pcn = pDevObj->staticInfo.rcnPcn[VP880_PCN_LOCATION];
rcn = pDevObj->staticInfo.rcnPcn[VP880_RCN_LOCATION];
maxChan = pDevObj->staticInfo.maxChannels;
#ifdef VP880_LP_SUPPORT
/*
* Make initial assumption that the device has lines such that low power
* mode is in affect. The line controls will change as necessary.
*/
pDevObj->stateInt |= (VP880_LINE0_LP | VP880_LINE1_LP);
#else /* VP880_LP_SUPPORT */
pDevObj->stateInt &= ~(VP880_LINE0_LP | VP880_LINE1_LP);
#endif /* VP880_LP_SUPPORT */
/* Check if device is Tracker and if so, initialize for FXS functionality */
if (pcn & VP880_TRACKER_MASK) {
#if defined (VP880_TRACKER_SUPPORT) && defined (VP880_FXS_SUPPORT)
uint8 icr3Vals[VP880_ICR3_LEN] = {0x00, 0x00, 0x00, 0x00};
/* Initialize Tracker device sensitve items */
/*
* Configure the Switcher for Flyback or Buckboost per device
* profile. If the device is in Buckboost mode, config the internal
* switcher
*/
if (pDevProf[VP_PROFILE_VERSION] >= VP_CSLAC_DEV_PROFILE_VERSION_INT_SW_CONFIG) {
/* Write the internal switcher parameters */
VpMpiCmdWrapper(deviceId, ecVal, VP880_INT_SWREG_PARAM_WRT,
VP880_INT_SWREG_PARAM_LEN, (uint8 *)&pDevProf[VP880_DEV_PROFILE_TRACKER_INT_SW_REG]);
} else {
/* Write the default internal parameters */
VpMpiCmdWrapper(deviceId, ecVal, VP880_INT_SWREG_PARAM_WRT,
VP880_INT_SWREG_PARAM_LEN, intSwParam);
}
if (pDevProf[VP_PROFILE_VERSION] >= VP_CSLAC_DEV_PROFILE_VERSION_INT_SW_CONFIG_FR) {
/* Cache the internal switcher parameters for free run mode */
VpMemCpy(pDevObj->intSwParamsFR, &pDevProf[VP880_DEV_PROFILE_TRACKER_INT_SW_REG +
VP880_INT_SWREG_PARAM_LEN], VP880_INT_SWREG_PARAM_LEN);
} else {
Vp880CopyDefaultFRProfile(pDevObj);
}
VpMpiCmdWrapper(deviceId, ecVal, VP880_REGULATOR_PARAM_WRT,
VP880_REGULATOR_PARAM_LEN, pDevObj->swParams);
VpMemCpy(pDevObj->swParamsCache, pDevObj->swParams, VP880_REGULATOR_PARAM_LEN);
/* Device is reset, so ch1 and 2 are at same values for ICR's
* NOTE: This also has to be done in VpInitLine() due to SW
* Reset.
*/
icr3Vals[VP880_ICR3_LINE_CTRL_INDEX] = VP880_ICR3_VREF_CTRL;
icr3Vals[VP880_ICR3_LINE_CTRL_INDEX+1] = VP880_ICR3_VREF_CTRL;
VpMpiCmdWrapper(deviceId, ecAll, VP880_ICR3_WRT, VP880_ICR3_LEN, icr3Vals);
VP_LINE_STATE(None, NULL, ("Init: ICR3 0x%02X 0x%02X 0x%02X 0x%02X Ch %d",
icr3Vals[0], icr3Vals[1], icr3Vals[2], icr3Vals[3], ecAll));
/*
* Wait at least 5ms before turning the switchers on for Vref to
* stabilize. We'll wait 10ms to be safe.
*/
VpSysWait(80);
/*
* Enable the switchers in low power. The power mode is changed as
* needed during normal operation.
*/
mpiData = VP880_SWY_LP | VP880_SWZ_LP;
VpMpiCmdWrapper(deviceId, ecVal, VP880_REGULATOR_CTRL_WRT,
VP880_REGULATOR_CTRL_LEN, &mpiData);
#endif /* (VP880_TRACKER_SUPPORT) && defined (VP880_FXS_SUPPORT) */
} else {
#ifdef VP880_ABS_SUPPORT
if (pDevProf[VP_PROFILE_VERSION] >=
VP_CSLAC_DEV_PROFILE_VERSION_INT_SW_CONFIG) {
/* Write the internal switcher parameters */
VpMpiCmdWrapper(deviceId, ecVal, VP880_INT_SWREG_PARAM_WRT,
VP880_INT_SWREG_PARAM_LEN, (uint8 *)&pDevProf[VP880_DEV_PROFILE_ABS_INT_SW_REG]);
/* Extract Y/Z Voltages. "0" if not set by Profile Wizard */
pDevObj->yVolt = pDevProf[VP880_ABS_DEV_PROFILE_YVOLT];
pDevObj->zVolt = pDevProf[VP880_ABS_DEV_PROFILE_ZVOLT];
}
if (pDevProf[VP_PROFILE_VERSION] >= VP_CSLAC_DEV_PROFILE_VERSION_INT_SW_CONFIG_FR) {
/* Cache the internal switcher parameters for free run mode */
VpMemCpy(pDevObj->intSwParamsFR, &pDevProf[VP880_DEV_PROFILE_ABS_INT_SW_REG +
VP880_INT_SWREG_PARAM_LEN], VP880_INT_SWREG_PARAM_LEN);
} else {
/* No free run timing available -> save default ones */
Vp880CopyDefaultFRProfile(pDevObj);
}
/*
* Make sure lines are in disconnect state (recover from shutdown)
* even if there are no line contexts associated with this device.
*/
mpiData = VP880_SS_DISCONNECT;
VpMpiCmdWrapper(deviceId, ecAll, VP880_SYS_STATE_WRT, VP880_SYS_STATE_LEN, &mpiData);
mpiData = VP880_SWY_OFF;
VpMpiCmdWrapper(deviceId, ecVal, VP880_REGULATOR_CTRL_WRT,
VP880_REGULATOR_CTRL_LEN, &mpiData);
#ifdef VP880_CURRENT_LIMIT
/* Implement a user compile option to limit the switcher power */
VpMpiCmdWrapper(deviceId, ecVal, VP880_INT_SWREG_PARAM_WRT,
VP880_INT_SWREG_PARAM_LEN, intSwParamLimit);
#endif /* VP880_CURRENT_LIMIT */
if (!(pDevObj->stateInt & VP880_IS_FXO_ONLY)) {
systemConfig = (pDevObj->devProfileData.systemConfig & VP880_ABS_CFG_MASK);
#ifdef VP880_AUTO_BAT_DETECT
if ((status = Vp880AutoBatDetect(pDevObj,
&pDevProf[VP880_DEV_PROFILE_SWITCHER_CMD+1])) != VP_STATUS_SUCCESS) {
pDevObj->state &= ~(VP_DEV_INIT_IN_PROGRESS | VP_DEV_INIT_CMP);
VpSysExitCritical(deviceId, VP_CODE_CRITICAL_SEC);
VP_API_FUNC_INT(None, VP_NULL, ("Vp880InitDevice Exit Error %d-", status));
return status;
}
#else /* VP880_AUTO_BAT_DETECT */
VpMpiCmdWrapper(deviceId, ecVal, VP880_REGULATOR_PARAM_WRT,
VP880_REGULATOR_PARAM_LEN, pDevObj->swParams);
VpMemCpy(pDevObj->swParamsCache, pDevObj->swParams, VP880_REGULATOR_PARAM_LEN);
mpiData = VP880_SWY_LP | VP880_SWZ_LP;
VpMpiCmdWrapper(deviceId, ecVal, VP880_REGULATOR_CTRL_WRT,
VP880_REGULATOR_CTRL_LEN, &mpiData);
if (systemConfig != VP880_ABS_CFG_SLAVE) {
VpSysWait(240); /* 125us * 240 = 30ms */
VpSysWait(160); /* 125us * 160 = 20ms */
if (systemConfig == VP880_ABS_CFG_SINGLE) {
mpiData = VP880_SWY_MP | VP880_SWZ_MP;
} else { /* systemConfig == VP880_ABS_CFG_MASTER */
mpiData = VP880_SWY_HP | VP880_SWZ_HP;
}
VpMpiCmdWrapper(deviceId, ecVal, VP880_REGULATOR_CTRL_WRT,
VP880_REGULATOR_CTRL_LEN, &mpiData);
}
#endif /* VP880_AUTO_BAT_DETECT */
}
#endif /* VP880_ABS_SUPPORT */
}
/*
* No matter how they were provided, cache the internal switcher parameters
* and the switcher parameters.
*/
VpMpiCmdWrapper(deviceId, ecVal, VP880_INT_SWREG_PARAM_RD,
VP880_INT_SWREG_PARAM_LEN, pDevObj->intSwParams);
VpMpiCmdWrapper(deviceId, ecVal, VP880_REGULATOR_PARAM_RD,
VP880_REGULATOR_PARAM_LEN, pDevObj->swParamsCache);
VpMemCpy(pDevObj->swParams, pDevObj->swParamsCache,
VP880_REGULATOR_PARAM_LEN);
/* Initialize each channel */
for (chan = 0; chan < maxChan; chan++) {
/*
* For Init Line to work, the device cannot be non-initialized because
* the init line function tries to set the line state. Therefore,
* temporarily set the device init flag to TRUE then immediately after
* line init, set back to FALSE until device init is complete
*/
pLineCtx = pDevCtx->pLineCtx[chan];
if (pLineCtx != VP_NULL) {
pLineObj = pLineCtx->pLineObj;
if (pLineObj->status & VP880_IS_FXO) {
status = Vp880InitLine(pLineCtx, pFxoAcProfile, pFxoCfgProfile,
VP_PTABLE_NULL);
} else {
status = Vp880InitLine(pLineCtx, pAcProfile, pDcProfile,
pRingProfile);
#ifdef VP880_INCLUDE_TESTLINE_CODE
/* initialize the calibration coeffs */
pDevObj->calOffsets[chan].nullOffset = 0;
pDevObj->calOffsets[chan].vabOffset = 0;
pDevObj->calOffsets[chan].vahOffset = 0;
pDevObj->calOffsets[chan].vbhOffset = 0;
#endif /* VP880_INCLUDE_TESTLINE_CODE */
}
if (status != VP_STATUS_SUCCESS) {
pDevObj->state &=
~(VP_DEV_INIT_IN_PROGRESS | VP_DEV_INIT_CMP);
VpSysExitCritical(deviceId, VP_CODE_CRITICAL_SEC);
VP_API_FUNC_INT(None, VP_NULL, ("Vp880InitDevice Exit Error %d-",
status));
return status;
}
} else {
/*
* If the per-channel configuration register did not get set, we
* have to set it in order for calibration to run consistently.
* Note that the Auto-System-State Control bit in the System State
* Configuration Register is the same for both FXS and FXO lines.
*/
mpiData = VP880_AUTO_SSC_DIS;
VpMpiCmdWrapper(deviceId, (VP880_EC_CH1 | VP880_EC_CH2),
VP880_SS_CONFIG_WRT, VP880_SS_CONFIG_LEN, &mpiData);
}
}
status = VpImplementDefaultSettings(pDevCtx, VP_NULL);
/*
* This clears the Init Line Events and any other erroneous event that
* may have been created due to initialization
*/
Vp880FlushEvents(pDevCtx);
#ifdef VP880_INCLUDE_TESTLINE_CODE
/*
* This clears the Test structure
*/
pDevObj->currentTest.prepared = FALSE;
pDevObj->currentTest.testState = -1;
pDevObj->currentTest.testId = VP_NUM_TEST_IDS;
#endif /* VP880_INCLUDE_TESTLINE_CODE */
if (status == VP_STATUS_SUCCESS) {
if (pDevObj->stateInt & VP880_DEVICE_CAL_COMPLETE) {
VP_CALIBRATION(None, VP_NULL, ("Calibration Previously Complete: Device 0x%08lX RCN %d",
pDevObj->stateInt, rcn));
pDevObj->state &= ~VP_DEV_IN_CAL;
pDevObj->state &= ~(VP_DEV_INIT_IN_PROGRESS);
pDevObj->deviceEvents.response |= VP_DEV_EVID_DEV_INIT_CMP;
VpMpiCmdWrapper(deviceId, VP880_EC_CH1, VP880_BAT_CALIBRATION_WRT,
VP880_BAT_CALIBRATION_LEN, pDevObj->calData.abvData.switcherAdjust[0]);
VpMpiCmdWrapper(deviceId, VP880_EC_CH2, VP880_BAT_CALIBRATION_WRT,
VP880_BAT_CALIBRATION_LEN, pDevObj->calData.abvData.switcherAdjust[1]);
} else {
#ifdef VP_CSLAC_RUNTIME_CAL_ENABLED
VP_CALIBRATION(None, VP_NULL, ("Cal Required: Device 0x%08lX RCN %d",
pDevObj->stateInt, rcn));
pDevObj->state |= VP_DEV_IN_CAL;
pDevObj->calData.calDeviceState = VP880_CAL_INIT;
if (pDevObj->stateInt & VP880_IS_ABS) { /* Start for ABS Device */
#ifdef VP880_ABS_SUPPORT
if ((systemConfig != VP880_ABS_CFG_SLAVE) && (Vp880SetCalFlags(pDevObj) == TRUE)) {
VP_CALIBRATION(None, VP_NULL, ("NOT Running Slave Mode Device 0x%08lX RCN %d",
pDevObj->stateInt, rcn));
Vp880CalCodecInt(pDevCtx);
} else {
VP_CALIBRATION(None, VP_NULL, ("Slave Mode OR Cal Flags = FALSE Device 0x%08lX RCN %d",
pDevObj->stateInt, rcn));
pDevObj->state &= ~VP_DEV_IN_CAL;
pDevObj->state &= ~(VP_DEV_INIT_IN_PROGRESS);
pDevObj->deviceEvents.response |= VP_DEV_EVID_DEV_INIT_CMP;
}
#endif /* VP880_ABS_SUPPORT */
} else { /* Start for Tracker Device if JE (JA 8827x) silicon */
#ifdef VP880_TRACKER_SUPPORT
if (rcn >= VP880_REV_JE) {
pDevObj->state |= VP_DEV_ABV_CAL;
Vp880CalCodecInt(pDevCtx);
} else {
pDevObj->state &= ~VP_DEV_IN_CAL;
pDevObj->state &= ~(VP_DEV_INIT_IN_PROGRESS);
pDevObj->deviceEvents.response |= VP_DEV_EVID_DEV_INIT_CMP;
}
#endif /* VP880_TRACKER_SUPPORT */
}
#else /* VP_CSLAC_RUNTIME_CAL_ENABLED */
VP_CALIBRATION(None, VP_NULL, ("\n\rCal Required, Disabled at Compile: Device 0x%08lX RCN %d",
pDevObj->stateInt, rcn));
pDevObj->state &= ~VP_DEV_IN_CAL;
pDevObj->state &= ~(VP_DEV_INIT_IN_PROGRESS);
pDevObj->deviceEvents.response |= VP_DEV_EVID_DEV_INIT_CMP;
#endif /* VP_CSLAC_RUNTIME_CAL_ENABLED */
}
}
/*
* ZSI devices can't have TX Timeslot = 0. So initialize the channels to
* [tx, rx] -> channel 0 = [1, 1], channel 1 = [2, 2]
*/
if ((pcn == VP880_DEV_PCN_88536) || (pcn == VP880_DEV_PCN_88264)) {
uint8 txTimeSlot = 0;
uint8 rxTimeSlot = 1;
VpMpiCmdWrapper(deviceId, VP880_EC_CH1, VP880_TX_TS_WRT, VP880_TX_TS_LEN,
&txTimeSlot);
VpMpiCmdWrapper(deviceId, VP880_EC_CH1, VP880_RX_TS_WRT, VP880_RX_TS_LEN,
&rxTimeSlot);
txTimeSlot = 1;
rxTimeSlot = 2;
VpMpiCmdWrapper(deviceId, VP880_EC_CH2, VP880_TX_TS_WRT, VP880_TX_TS_LEN,
&txTimeSlot);
VpMpiCmdWrapper(deviceId, VP880_EC_CH2, VP880_RX_TS_WRT, VP880_RX_TS_LEN,
&rxTimeSlot);
}
/*
* Success, Failure, or Calibration started -- we're not in "InitDevice"
* function anymore. So normal rules apply.
*/
pDevObj->state |= VP_DEV_INIT_CMP;
VpSysExitCritical(deviceId, VP_CODE_CRITICAL_SEC);
VP_API_FUNC_INT(None, VP_NULL, ("Vp880InitDevice Exit Normal: State 0x%04X Event 0x%04X-",
pDevObj->state, pDevObj->deviceEvents.response));
return status;
} /* Vp880InitDevice */
/**
* Vp880InitLine
* This function initializes a line of a device with the specified parameters
* and API default values. It is a "Line Reset".
*
* Preconditions:
* The device associated with this line must be initialized.
*
* Postconditions:
* The line pointed to be the line context passed is initialized with the
* profile data specified. This function returns the success code if the device
* associated with this line is initialized.
*/
VpStatusType
Vp880InitLine(
VpLineCtxType *pLineCtx,
VpProfilePtrType pAcProfile, /**< Pointer to AC coefficient data or
* profile index to be applied to this line.
*/
VpProfilePtrType pDcOrFxoProfile, /**< Pointer to DC Feed (FXS) or Cfg
* (FX0) profile or profile index to be
* applied to this line.
*/
VpProfilePtrType pRingProfile) /**< Pointer to Ringing profile or profile
* index to apply to this line
*/
{
Vp880LineObjectType *pLineObj = pLineCtx->pLineObj;
VpDevCtxType *pDevCtx = pLineCtx->pDevCtx;
Vp880DeviceObjectType *pDevObj = pDevCtx->pDevObj;
uint8 channelId = pLineObj->channelId;
uint8 ecValMap[] = {VP880_EC_CH1, VP880_EC_CH2};
uint8 ecVal = ecValMap[channelId];
uint8 alwaysOn[VP880_CADENCE_TIMER_LEN] = {0x3F, 0xFF, 0x00, 0x00};
uint8 opFunc[VP880_OP_FUNC_LEN] = {VP880_ENABLE_LOADED_COEFFICIENTS};
#ifdef VP880_FXS_SUPPORT
uint8 defaultRingParams[VP880_RINGER_PARAMS_LEN] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
VpProfileDataType dcDefaultProf[] = {
0x00, 0x01, 0x01, 0x0A, 0x00, 0x08, 0xC2, 0x1B, 0x84, 0xB3, 0x05, 0xC6,
0x13, 0x08
};
#endif /* VP880_FXS_SUPPORT */
#ifdef VP880_FXO_SUPPORT
VpProfileDataType fxoDefaultProf[] =
{
/* FXO/Dialing Profile */
0x00, 0xFE, 0x00, 0x12, 0x00, 0x00, 0x00, 0x27, 0x00, 0x28, 0x00, 0x78,
0x0C, 0x08, 0x00, 0x28, 0xEB, 0x79, 0x04, 0x03, 0x26, 0x3A
};
uint8 fxoCidLine;
#endif /* VP880_FXO_SUPPORT */
VpStatusType status = VP_STATUS_SUCCESS;
uint8 mpiData;
VpDeviceIdType deviceId = pDevObj->deviceId;
/* Proceed if device state is either in progress or complete */
if (pDevObj->state & (VP_DEV_INIT_CMP | VP_DEV_INIT_IN_PROGRESS)) {
} else {
return VP_STATUS_DEV_NOT_INITIALIZED;
}
/*
* Do not proceed if the device calibration is in progress. This could
* damage the device.
*/
if (pDevObj->state & VP_DEV_IN_CAL) {
return VP_STATUS_DEV_NOT_INITIALIZED;
}
VpSysEnterCritical(deviceId, VP_CODE_CRITICAL_SEC);
pLineObj->ecVal = ecVal;
pLineObj->status &= ~VP880_INIT_COMPLETE;
#ifdef VP_CSLAC_SEQ_EN
VpMemSet(pLineObj->intSequence, 0, VP880_INT_SEQ_LEN);
#ifdef VP880_FXS_SUPPORT
pLineObj->callerId.status = VP_CID_RESET_VALUE;
pLineObj->suspendCid = FALSE;
pLineObj->pRingingCadence = VP_PTABLE_NULL;
pLineObj->pCidProfileType1 = VP_PTABLE_NULL;
#endif /* VP880_FXS_SUPPORT */
#endif /* VP_CSLAC_SEQ_EN */
pLineObj->status &= ~(VP880_BAD_LOOP_SUP);
/* Initialize cached transmit and receive gains for SetRelGain to 1.0. */
pLineObj->gain.gxInt = 0x4000;
pLineObj->gain.grInt = 0x4000;
/* Inititialize API line state variables */
if (pLineObj->status & VP880_IS_FXO) {
#ifdef VP880_FXO_SUPPORT
pLineObj->lineState.currentState = VP_LINE_FXO_LOOP_OPEN;
pLineObj->lineState.previous = VP_LINE_FXO_LOOP_OPEN;
#endif /* VP880_FXO_SUPPORT */
} else {
#ifdef VP880_FXS_SUPPORT
pLineObj->lineState.currentState = VP_LINE_DISCONNECT;
pLineObj->lineState.previous = VP_LINE_DISCONNECT;
pLineObj->lineState.usrCurrent = VP_LINE_DISCONNECT;
#endif /* VP880_FXS_SUPPORT */
}
/* Force a line state check and update hook information */
pLineObj->lineState.condition = VP_CSLAC_STATUS_INVALID;
#ifdef VP880_FXS_SUPPORT
pLineObj->dpStruct.hookSt = FALSE;
pLineObj->dpStruct2.hookSt = FALSE;
VpInitDP(&pLineObj->dpStruct);
VpInitDP(&pLineObj->dpStruct2);
pLineObj->internalTestTermApplied = FALSE;
/* Set the cached ICR values to device reset conditions. */
VpMemSet(pLineObj->icr1Values, 0, VP880_ICR1_LEN);
VpMemSet(pLineObj->icr2Values, 0, VP880_ICR2_LEN);
VpMemSet(pLineObj->icr3Values, 0, VP880_ICR3_LEN);
VpMemSet(pLineObj->icr4Values, 0, VP880_ICR4_LEN);
#endif /* VP880_FXS_SUPPORT */
#ifdef VP880_LP_SUPPORT
pLineObj->leakyLineCnt = 0; /* Used only for LP Mode */
if (VpIsLowPowerTermType(pLineObj->termType) == TRUE) {
/*
* Manually Force the ICR values for LPM-Disconnect since we have no
* idea the status of the other line.
*/
VP_LINE_STATE(VpLineCtxType, pLineCtx,
("Updating Cached ICR Values for LPM on Channel %d", channelId));
pLineObj->icr1Values[0] = 0x0F;
pLineObj->icr1Values[2] = 0xC0;
pLineObj->icr2Values[0] = 0xCC;
pLineObj->icr2Values[1] = 0x4C;
pLineObj->icr2Values[2] = 0x2C;
pLineObj->icr2Values[3] = 0x58;
pLineObj->icr3Values[0] = 0x31;
pLineObj->icr3Values[1] = 0x01;
pLineObj->icr4Values[2] = 0x0E;
pLineObj->icr4Values[3] = 0x0E;
pLineObj->status |= VP880_LOW_POWER_EN;
pDevObj->stateInt |= ((channelId == 0) ? VP880_LINE0_LP : VP880_LINE1_LP);
}
#endif /* VP880_LP_SUPPORT */
#ifdef VP_CSLAC_SEQ_EN
VpMemSet(&pLineObj->cadence, 0, sizeof(VpSeqDataType));
#endif /* VP_CSLAC_SEQ_EN */
/* Force a codec update */
pLineObj->codec = VP_NUM_OPTION_CODEC_TYPE_IDS;
#ifdef VP880_FXS_SUPPORT
/* It is possible that CalCodec set ABS calibration values in ICR6 before
* this point, so read these from the device */
VpMpiCmdWrapper(deviceId, ecVal, VP880_ICR6_RD, VP880_ICR6_LEN, pLineObj->icr6Values);
/*
* Workaround for I/O1 relay driver. Problem is the I/O1 pin does not have
* proper voltage clamps to protect against normal voltage spikes that
* occur as a result of transitioning to Input or Open Drain on a driven
* relay coil. So this workaround will check to see if the pin is currently
* being used to close an external relay, and force it open. Then it has
* to wait for 3ms for the relay to fully open (coil to fully discharge).
*/
if ((pDevObj->stateInt & VP880_RLY_PROT_REQ)
&& ((pLineObj->termType == VP_TERM_FXS_ISOLATE)
|| (pLineObj->termType == VP_TERM_FXS_ISOLATE_LP)
|| (pLineObj->termType == VP_TERM_FXS_SPLITTER))) {
if((pLineObj->termType == VP_TERM_FXS_ISOLATE) ||
(pLineObj->termType == VP_TERM_FXS_ISOLATE_LP)) {
Vp880SetRelayState(pLineCtx, VP_RELAY_NORMAL);
} else {
Vp880SetRelayState(pLineCtx, VP_RELAY_RESET);
}
/* Wait for relay coil to fully discharge */
VpSysWait(24);
}
#endif /* VP880_FXS_SUPPORT */
/*
* Operating Conditions - Remove all loopbacks, connect TX/RX PCM Hwy
* Note that TX/RX PCM Highway is set when Set Linestate function is
* called.
*/
pLineObj->opCond[0] = VP880_NORMAL_OP_COND_MODE;
VpMpiCmdWrapper(deviceId, ecVal, VP880_OP_COND_WRT, VP880_OP_COND_LEN,
pLineObj->opCond);
/* Operating Functions - Use loaded coefficients */
VpMpiCmdWrapper(deviceId, ecVal, VP880_OP_FUNC_WRT, VP880_OP_FUNC_LEN,
opFunc);
/* Disable the internal device cadencer .. done in the API */
VpMpiCmdWrapper(deviceId, ecVal, VP880_CADENCE_TIMER_WRT,
VP880_CADENCE_TIMER_LEN, alwaysOn);
/* Start the channel out in the standby state or loop open (if FXO) */
if (pLineObj->status & VP880_IS_FXO) {
#ifdef VP880_FXO_SUPPORT
pLineObj->lineTimers.type = VP_CSLAC_FXO_TIMER;
/*
* InitTimerVars has to know the timer type but called before
* Set Line State. If set line state starts any timers, calling
* InitTimerVars would disable those causing possible initialization
* issues.
*/
InitTimerVars(pLineCtx);
/* Disable auto system state control
* NOTE: NEVER enable the Auto-Thermal Fault disconnect in the silicon
* because the silicon is too fast for the VP-API-II. It would be possible
* to get a thermal fault, have the silicon disable the line, and have
* the thermal fault go away all before the VP-API-II sees it. In that
* condition, the line will be disabled without the application being
* aware of it.
*/
mpiData = VP880_AUTO_SSC_DIS;
VpMpiCmdWrapper(deviceId, ecVal, VP880_SS_CONFIG_WRT, VP880_SS_CONFIG_LEN, &mpiData);
if (pLineObj->termType == VP_TERM_FXO_DISC) {
fxoCidLine = VP880_IODATA_IO3;
} else {
fxoCidLine = VP880_FXO_CID_LINE;
}
mpiData &= ~VP880_IODIR_IO1_MASK;
mpiData = (VP880_IODIR_IO1_OUTPUT | (fxoCidLine << 1));
#ifdef VP880_CLARE_RINGING_DETECT
mpiData |= VP880_IODIR_EXPDT_MASK; /* Ringing detector on IO4 */
VpMpiCmdWrapper(deviceId, ecVal, VP880_IODIR_REG_WRT, VP880_IODIR_REG_LEN, &mpiData);
#endif /* VP880_CLARE_RINGING_DETECT */
#ifdef VP_CSLAC_SEQ_EN
pLineObj->digitGenStruct.dtmfOnTime = VP_FXO_DTMF_ON_DEFAULT;
pLineObj->digitGenStruct.dtmfOffTime = VP_FXO_DTMF_OFF_DEFAULT;
pLineObj->digitGenStruct.breakTime = VP_FXO_PULSE_BREAK_DEFAULT;
pLineObj->digitGenStruct.makeTime = VP_FXO_PULSE_MAKE_DEFAULT;
pLineObj->digitGenStruct.flashTime = VP_FXO_FLASH_HOOK_DEFAULT;
pLineObj->digitGenStruct.dpInterDigitTime = VP_FXO_INTERDIG_DEFAULT;
pLineObj->digitGenStruct.dtmfHighFreqLevel[0] = 0x1C;
pLineObj->digitGenStruct.dtmfHighFreqLevel[1] = 0x32;
pLineObj->digitGenStruct.dtmfLowFreqLevel[0] = 0x1C;
pLineObj->digitGenStruct.dtmfLowFreqLevel[1] = 0x32;
#endif /* VP_CSLAC_SEQ_EN */
if (pDcOrFxoProfile == VP_NULL) {
status = Vp880ConfigLine(pLineCtx, pAcProfile, fxoDefaultProf, VP_PTABLE_NULL);
} else {
status = Vp880ConfigLine(pLineCtx, pAcProfile, pDcOrFxoProfile, VP_PTABLE_NULL);
}
if (status != VP_STATUS_SUCCESS) {
VpSysExitCritical(deviceId, VP_CODE_CRITICAL_SEC);
return status;
}
/* Activate Codec and enable Supervision */
/*
* Set to Loop Open. Set current state to Loop Close in order to force line
* state function to change to Loop Open. Otherwise, no changes are made
* since it thinks device is already set correctly.
*/
pLineObj->lineState.currentState = VP_LINE_FXO_LOOP_CLOSE;
Vp880SetLineStateInt(pLineCtx, VP_LINE_FXO_LOOP_OPEN);
pLineObj->lineState.usrCurrent = VP_LINE_FXO_LOOP_OPEN;
#endif /* VP880_FXO_SUPPORT */
} else {
#ifdef VP880_FXS_SUPPORT
/*
* LPM supported on HV-Tracker devices only. Note that the HV check for
* LPM support ignores if there is an application level LV override.
* The override occurs because customers want a LV (low cost) design,
* but are given only HV silicon.
*/
if ((pDevObj->stateInt & VP880_IS_ABS) || (!(pDevObj->stateInt & VP880_IS_HIGH_VOLTAGE))) {
if (VpIsLowPowerTermType(pLineObj->termType)) {
pLineObj->termType = VP_TERM_FXS_GENERIC;
pDevObj->stateInt &= ~VP880_LINE0_LP;
pDevObj->stateInt &= ~VP880_LINE1_LP;
VpSysExitCritical(deviceId, VP_CODE_CRITICAL_SEC);
return VP_STATUS_ERR_VTD_CODE;
}
}
pLineObj->lineTimers.type = VP_CSLAC_FXS_TIMER;
/*
* InitTimerVars has to know the timer type but called before
* Set Line State. If set line state starts any timers, calling
* InitTimerVars would disable those causing possible initialization
* issues.
*/
InitTimerVars(pLineCtx);
/*
* Enable Auto Bat Switch (ABS), Disable Auto-Battery Shutdown (Tracker)
* and disable Auto State Control (both).
* NOTE: NEVER enable the Auto-Thermal Fault disconnect in the silicon
* because the silicon is too fast for the VP-API-II. It would be possible
* to get a thermal fault, have the silicon disable the line, and have
* the thermal fault go away all before the VP-API-II sees it. In that
* condition, the line will be disabled without the application being
* aware of it.
*/
mpiData = VP880_AUTO_SSC_DIS;
VpMpiCmdWrapper(deviceId, ecVal, VP880_SS_CONFIG_WRT,
VP880_SS_CONFIG_LEN, &mpiData);
/* Complete all other non device senstive items */
/* Initialize default values for Ringing */
VpMemCpy(pLineObj->ringingParams, defaultRingParams,
VP880_RINGER_PARAMS_LEN);
pLineObj->status &= ~(VP880_UNBAL_RINGING);
if (pDevObj->staticInfo.rcnPcn[VP880_RCN_LOCATION] > VP880_REV_VC) {
uint8 converterCfg[VP880_CONV_CFG_LEN];
/* Set the pcm buffer update rate based on the tickrate */
if(pDevObj->devProfileData.tickRate <=160) {
converterCfg[0] = VP880_CC_8KHZ_RATE;
pDevObj->txBufferDataRate = VP880_CC_8KHZ_RATE;
} else if(pDevObj->devProfileData.tickRate <=320){
converterCfg[0] = VP880_CC_4KHZ_RATE;
pDevObj->txBufferDataRate = VP880_CC_4KHZ_RATE;
} else if(pDevObj->devProfileData.tickRate <=640){
converterCfg[0] = VP880_CC_2KHZ_RATE;
pDevObj->txBufferDataRate = VP880_CC_2KHZ_RATE;
} else if(pDevObj->devProfileData.tickRate <=1280){
converterCfg[0] = VP880_CC_1KHZ_RATE;
pDevObj->txBufferDataRate = VP880_CC_1KHZ_RATE;
} else {
converterCfg[0] = VP880_CC_500HZ_RATE;
pDevObj->txBufferDataRate = VP880_CC_500HZ_RATE;
}
VpMpiCmdWrapper(deviceId, ecVal, VP880_CONV_CFG_WRT,
VP880_CONV_CFG_LEN, converterCfg);
pDevObj->devMode[0] |= VP880_DEV_MODE_TEST_DATA;
VpMpiCmdWrapper(deviceId, ecVal, VP880_DEV_MODE_WRT,
VP880_DEV_MODE_LEN, pDevObj->devMode);
}
#ifdef VP880_CURRENT_LIMIT
pLineObj->icr2Values[VP880_ICR2_SWY_CTRL_INDEX] |= VP880_ICR2_SWY_LIM_CTRL;
pLineObj->icr2Values[VP880_ICR2_SWY_CTRL_INDEX+1] &= ~VP880_ICR2_SWY_LIM_CTRL;
#endif /* VP880_CURRENT_LIMIT */
#ifdef VP880_TRACKER_SUPPORT
if (!(pDevObj->stateInt & VP880_IS_ABS)) {
if (VpIsLowPowerTermType(pLineObj->termType) == FALSE) {
pLineObj->lineTimers.timers.timer[VP_LINE_DISCONNECT_EXIT] =
(MS_TO_TICKRATE(VP880_SPEEDUP_HOLD_TIME,
pDevObj->devProfileData.tickRate)) | VP_ACTIVATE_TIMER;
/* Initialize the Disconnect Exit Timer State */
pLineObj->discTimerExitState = 0;
VP_LINE_STATE(VpLineCtxType, pLineCtx,
("Chan %d Setting VP_LINE_DISCONNECT_EXIT time to %d ms (VP880_SPEEDUP_HOLD_TIME) at time %d",
pLineObj->channelId, VP880_SPEEDUP_HOLD_TIME, pDevObj->timeStamp));
pLineObj->icr1Values[VP880_ICR1_BIAS_OVERRIDE_LOCATION] |=
VP880_ICR1_LINE_BIAS_OVERRIDE;
pLineObj->icr1Values[VP880_ICR1_BIAS_OVERRIDE_LOCATION+1] &=
(VP880_ICR1_LINE_BIAS_OVERRIDE | VP880_ICR1_LINE_BIAS_OVERRIDE_NORM);
pLineObj->icr1Values[VP880_ICR1_BIAS_OVERRIDE_LOCATION+1] |=
VP880_ICR1_LINE_BIAS_OVERRIDE_NORM;
VpMpiCmdWrapper(deviceId, ecVal, VP880_ICR1_WRT, VP880_ICR1_LEN,
pLineObj->icr1Values);
pLineObj->icr2Values[VP880_ICR2_SENSE_INDEX] |=
(VP880_ICR2_DAC_SENSE | VP880_ICR2_FEED_SENSE);
pLineObj->icr2Values[VP880_ICR2_SENSE_INDEX+1] &= ~VP880_ICR2_DAC_SENSE;
pLineObj->icr2Values[VP880_ICR2_SENSE_INDEX+1] |= VP880_ICR2_FEED_SENSE;
}
/* Tracker Workaround:
* Enable VRef while in Disconnect. Otherwise the Switcher will
* shutdown because it thinks it's not needed.
*/
pLineObj->icr3Values[VP880_ICR3_LINE_CTRL_INDEX] |= VP880_ICR3_VREF_CTRL;
pLineObj->icr3Values[VP880_ICR3_LINE_CTRL_INDEX+1] |= VP880_ICR3_VREF_CTRL;
VpMpiCmdWrapper(deviceId, ecVal, VP880_ICR3_WRT, VP880_ICR3_LEN,
pLineObj->icr3Values);
VP_LINE_STATE(VpLineCtxType, pLineCtx, ("Line Init: ICR3 0x%02X 0x%02X 0x%02X 0x%02X Ch %d",
pLineObj->icr3Values[0], pLineObj->icr3Values[1],
pLineObj->icr3Values[2], pLineObj->icr3Values[3], channelId));
#ifndef VP880_CURRENT_LIMIT
/* Eliminate use of 50V clamp for all conditions */
pLineObj->icr2Values[VP880_ICR2_SWY_CTRL_INDEX] |=
(VP880_ICR2_SWY_LIM_CTRL1 | VP880_ICR2_SWY_LIM_CTRL);
pLineObj->icr2Values[VP880_ICR2_SWY_CTRL_INDEX+1] |= VP880_ICR2_SWY_LIM_CTRL1;
#endif /* VP880_CURRENT_LIMIT */
/* Force ICR4 update - make sure it is what we think it is.. */
VpMpiCmdWrapper(deviceId, ecVal, VP880_ICR4_WRT, VP880_ICR4_LEN,
pLineObj->icr4Values);
}
#endif /* VP880_TRACKER_SUPPORT */
VP_LINE_STATE(VpLineCtxType, pLineCtx, ("Line Init: ICR2 0x%02X 0x%02X 0x%02X 0x%02X Ch %d",
pLineObj->icr2Values[0], pLineObj->icr2Values[1],
pLineObj->icr2Values[2], pLineObj->icr2Values[3], channelId));
VpMpiCmdWrapper(deviceId, ecVal, VP880_ICR2_WRT, VP880_ICR2_LEN, pLineObj->icr2Values);
if (pDcOrFxoProfile == VP_PTABLE_NULL) {
status = Vp880ConfigLine(pLineCtx, pAcProfile, dcDefaultProf, pRingProfile);
} else {
status = Vp880ConfigLine(pLineCtx, pAcProfile, pDcOrFxoProfile, pRingProfile);
}
if (status != VP_STATUS_SUCCESS) {
VpSysExitCritical(deviceId, VP_CODE_CRITICAL_SEC);
return status;
}
/* Set to Disconnect */
/*
* Set to Disconnect. Set current state to Standby in order to force line
* state function to change to Disconnect. Otherwise, no changes are made
* since it thinks device is already set correctly.
*/
pLineObj->lineState.currentState = VP_LINE_STANDBY;
Vp880SetLineStateInt(pLineCtx, VP_LINE_DISCONNECT);
pLineObj->lineState.usrCurrent = VP_LINE_DISCONNECT;
#endif /* VP880_FXS_SUPPORT */
}
status = VpImplementDefaultSettings(VP_NULL, pLineCtx);
#ifdef VP880_FXS_SUPPORT
Vp880SetRelayState(pLineCtx, VP_RELAY_NORMAL);
#endif /* VP880_FXS_SUPPORT */
/* Post the line init complete event if status is succesfull */
if (status == VP_STATUS_SUCCESS) {
pLineObj->lineEvents.response |= VP_LINE_EVID_LINE_INIT_CMP;
pLineObj->status |= VP880_INIT_COMPLETE;
}
#ifdef VP880_FXO_SUPPORT
if (pLineObj->status & VP880_IS_FXO) {
pLineObj->lineTimers.timers.fxoTimer.disconnectDebounce = VP_FXO_DISCONNECT_DEBOUNCE;
}
#endif /* VP880_FXO_SUPPORT */
VpSysExitCritical(deviceId, VP_CODE_CRITICAL_SEC);
return status;
} /* Vp880InitLine */
/**
* Vp880ConfigLine
* This function reloads a line of a device with the specified parameters.
*
* Preconditions:
* The device associated with this line must be initialized.
*
* Postconditions:
* The line pointed to be the line context passed is initialized with the
* profile data specified. This function returns the success code if the device
* associated with this line is initialized.
*/
VpStatusType
Vp880ConfigLine(
VpLineCtxType *pLineCtx,
VpProfilePtrType pAcProfile, /**< Pointer to AC coefficient data or
* profile index to be applied to this line.
*/
VpProfilePtrType pDcOrFxoProfile, /**< Pointer to DC Feed (FXS) or Cfg
* (FX0) profile or profile index to be
* applied to this line.
*/
VpProfilePtrType pRingProfile) /**< Pointer to Ringing profile or profile
* index to apply to this line
*/
{
Vp880LineObjectType *pLineObj = pLineCtx->pLineObj;
VpDevCtxType *pDevCtx = pLineCtx->pDevCtx;
Vp880DeviceObjectType *pDevObj = pDevCtx->pDevObj;
uint8 ecVal = pLineObj->ecVal;
#ifdef VP880_FXS_SUPPORT
uint8 channelId = pLineObj->channelId;
uint8 sysStateConfig[VP880_SS_CONFIG_LEN];
uint8 ringTypeByte;
VpProfilePtrType pRingProf = VP_PTABLE_NULL;
#endif
uint8 profileIndex;
VpProfileDataType *pMpiData;
VpProfilePtrType pAcProf = VP_PTABLE_NULL;
VpProfilePtrType pDcFxoCfgProf = VP_PTABLE_NULL;
VpDeviceIdType deviceId = pDevObj->deviceId;
#ifdef CSLAC_GAIN_RELATIVE
uint8 gainCSD[VP880_GR_GAIN_LEN];
#endif
#ifdef VP880_FXO_SUPPORT
uint8 loopSuperParams;
/*
* Default value used if non provided. Note Ringing Detect 17-33Hz at 1/2
* period due to 2x pulse from ringing detect input.
*/
#ifndef VP880_CLARE_RINGING_DETECT
uint8 fxoLoopThreshLow[VP880_LOOP_SUP_LEN] = {0x1C, 0xE1, 0x79, 0xEB};
uint8 fxoLoopThreshHigh[VP880_LOOP_SUP_LEN] = {0x19, 0xF4, 0x79, 0xEB};
#endif
uint8 fxoLoopThresh[VP880_LOOP_SUP_LEN] = {0x19, 0xF4, 0x38, 0x78};
#endif
/* Proceed if device state is either in progress or complete */
if (pDevObj->state & (VP_DEV_INIT_CMP | VP_DEV_INIT_IN_PROGRESS)) {
} else {
return VP_STATUS_DEV_NOT_INITIALIZED;
}
/*
* Do not proceed if the device calibration is in progress. This could
* damage the device.
*/
if (pDevObj->state & VP_DEV_IN_CAL) {
return VP_STATUS_DEV_NOT_INITIALIZED;
}
/* Check the legality of the AC profile */
if (!VpCSLACIsProfileValid(VP_PROFILE_AC,
VP_CSLAC_AC_PROF_TABLE_SIZE, pDevObj->profEntry.acProfEntry,
pDevObj->devProfileTable.pAcProfileTable, pAcProfile, &pAcProf)) {
return VP_STATUS_ERR_PROFILE;
}
if (pLineObj->status & VP880_IS_FXO) {
#ifdef VP880_FXO_SUPPORT
/* Check the legality of the FXO profile */
if (!VpCSLACIsProfileValid(VP_PROFILE_FXO_CONFIG,
VP_CSLAC_FXO_CONFIG_PROF_TABLE_SIZE,
pDevObj->profEntry.fxoConfigProfEntry,
pDevObj->devProfileTable.pFxoConfigProfileTable,
pDcOrFxoProfile, &pDcFxoCfgProf)) {
return VP_STATUS_ERR_PROFILE;
}
#endif
} else {
#ifdef VP880_FXS_SUPPORT
/* Check the legality of the DC profile */
if (!VpCSLACIsProfileValid(VP_PROFILE_DC, VP_CSLAC_DC_PROF_TABLE_SIZE,
pDevObj->profEntry.dcProfEntry,
pDevObj->devProfileTable.pDcProfileTable,
pDcOrFxoProfile, &pDcFxoCfgProf)) {
return VP_STATUS_ERR_PROFILE;
}
#endif
}
#ifdef VP880_FXS_SUPPORT
/* Check the legality of the Ringing profile */
if (!VpCSLACIsProfileValid(VP_PROFILE_RING, VP_CSLAC_RINGING_PROF_TABLE_SIZE,
pDevObj->profEntry.ringingProfEntry,
pDevObj->devProfileTable.pRingingProfileTable, pRingProfile,
&pRingProf)) {
return VP_STATUS_ERR_PROFILE;
}
#endif
VpSysEnterCritical(deviceId, VP_CODE_CRITICAL_SEC);
/*
* Do not modify the line if line is in calibration. This could cause line
* calibration failure. Write to the update values that will be applied
* when calibration is complete (for provided profiles).
*/
if (pLineObj->status & VP880_LINE_IN_CAL) {
uint8 profileSize = 0;
if (pAcProf != VP_PTABLE_NULL) {
/* Error if the provided profile is larger than what we can copy */
profileSize = pAcProf[VP_PROFILE_LENGTH] + VP_PROFILE_LENGTH + 1;
if (profileSize > VP880_AC_PROFILE_SIZE) {
VpSysExitCritical(deviceId, VP_CODE_CRITICAL_SEC);
return VP_STATUS_DEVICE_BUSY;
}
/* Size is ok. Copy profile and set update required flag */
pLineObj->calLineData.updateFlags |= AC_PROFILE_UPDATE_REQ;
VpMemCpy(pLineObj->calLineData.acProfile, pAcProf, profileSize);
}
if (pDcFxoCfgProf != VP_PTABLE_NULL) {
/* Error if the provided profile is larger than what we can copy */
profileSize = pDcFxoCfgProf[VP_PROFILE_LENGTH] + VP_PROFILE_LENGTH + 1;
if (profileSize > VP880_DC_PROFILE_SIZE) {
VpSysExitCritical(deviceId, VP_CODE_CRITICAL_SEC);
return VP_STATUS_DEVICE_BUSY;
}
/* Size is ok. Copy profile and set update required flag */
pLineObj->calLineData.updateFlags |= DC_PROFILE_UPDATE_REQ;
VpMemCpy(pLineObj->calLineData.dcProfile, pDcFxoCfgProf, profileSize);
}
#ifdef VP880_FXS_SUPPORT
if (pRingProf != VP_PTABLE_NULL) {
/* Error if the provided profile is larger than what we can copy */
profileSize = pRingProf[VP_PROFILE_LENGTH] + VP_PROFILE_LENGTH + 1;
if (profileSize > VP880_RINGING_PROFILE_SIZE) {
VpSysExitCritical(deviceId, VP_CODE_CRITICAL_SEC);
return VP_STATUS_DEVICE_BUSY;
}
/* Size is ok. Copy profile and set update required flag */
pLineObj->calLineData.updateFlags |= RINGING_PROFILE_UPDATE_REQ;
VpMemCpy(pLineObj->calLineData.ringingProfile, pRingProf, profileSize);
}
#endif
VpSysExitCritical(deviceId, VP_CODE_CRITICAL_SEC);
return VP_STATUS_SUCCESS;
}
/* Load AC Coefficients */
if (pAcProf != VP_PTABLE_NULL) {
profileIndex = VP_PROFILE_MPI_LEN + 1;
pMpiData = (VpProfileDataType *)(&pAcProfile[profileIndex]);
VpMpiCmdWrapper(deviceId, ecVal, NOOP_CMD,
pAcProfile[VP_PROFILE_MPI_LEN], pMpiData);
#ifdef CSLAC_GAIN_RELATIVE
/* Update cached transmit and receive gains for SetRelGain */
VpMpiCmdWrapper(deviceId, ecVal, VP880_GX_GAIN_RD, VP880_GX_GAIN_LEN, gainCSD);
pLineObj->gain.gxInt = 0x4000 + VpConvertCsd2Fixed(gainCSD);
VpMpiCmdWrapper(deviceId, ecVal, VP880_GR_GAIN_RD, VP880_GR_GAIN_LEN, gainCSD);
pLineObj->gain.grInt = VpConvertCsd2Fixed(gainCSD);
#endif
#ifdef CSLAC_GAIN_ABS
pLineObj->gain.absGxGain = VP_ABS_GAIN_UNKNOWN;
pLineObj->gain.absGrGain = VP_ABS_GAIN_UNKNOWN;
#endif
}
if (pLineObj->status & VP880_IS_FXO) {
#ifdef VP880_FXO_SUPPORT
/* Configure an FXO line type */
if (pDcFxoCfgProf != VP_PTABLE_NULL) {
#ifdef VP880_CLARE_RINGING_DETECT
uint8 tempRegValue;
#endif /* VP880_CLARE_RINGING_DETECT */
/*
* LIU Threshold may have been provided in Volts or by Register Value. Convert to
* register value only.
*/
uint8 liuVoltage = pDcFxoCfgProf[VP_FXO_DIALING_PROFILE_LIU_THRESHOLD_MIN];
if (liuVoltage > 15) { /* Only 3-bits in the device, so if larger than 15 it's volts */
/* Round out to nearest programmable device setting */
uint8 tempLiuVolt = (liuVoltage - 16);
/* Steps are in 11V increments, so find the remainder */
uint8 liuError = (tempLiuVolt % 11);
if (liuError > 5) {
tempLiuVolt += (11 - liuError);
} else {
tempLiuVolt -= liuError;
}
/* Update liuVoltage to match Device values */
liuVoltage = (tempLiuVolt / 11);
}
#ifndef VP880_CLARE_RINGING_DETECT
/*
* Force device Ringing Detector unless the minimum frequency is
* lower than device can support.
*/
if (pDcFxoCfgProf[VP_FXO_DIALING_PROFILE_RING_PERIOD_MAX_ACT]
>= VP880_MAX_RING_DET_PERIOD) {
/* Cache the "Low Freq" loop supervision register content */
VpMemCpy(fxoLoopThresh, fxoLoopThreshLow, VP880_LOOP_SUP_LEN);
} else {
/* Cache the "High Freq" loop supervision register content */
VpMemCpy(fxoLoopThresh, fxoLoopThreshHigh, VP880_LOOP_SUP_LEN);
}
profileIndex = VP_FXO_DIALING_PROFILE_DISC_VOLTAGE_MIN;
loopSuperParams = (pDcFxoCfgProf[profileIndex] << 3);
loopSuperParams &= 0x38;
fxoLoopThresh[0] &= ~(0x38);
fxoLoopThresh[0] |= loopSuperParams;
/*
* Use the profile parameters for Ringing Detect minimum ONLY if
* the minimum ringing detect frequency is within range of device.
* Otherwise, force LIU/Ring Detect to 60V.
*/
if (pDcFxoCfgProf[VP_FXO_DIALING_PROFILE_RING_PERIOD_MAX_ACT]
< VP880_MAX_RING_DET_PERIOD) {
fxoLoopThresh[0] &= ~(VP880_LOOP_SUP_LIU_THRESH_BITS);
fxoLoopThresh[0] |= liuVoltage;
}
fxoLoopThresh[VP880_RING_PERIOD_MIN_INDEX] =
pDcFxoCfgProf[VP_FXO_DIALING_PROFILE_RING_PERIOD_MIN];
/*
* Cache the Minimum Ringing Detect Period that is implemented in
* SW.
*/
pLineObj->ringDetMin =
pDcFxoCfgProf[VP_FXO_DIALING_PROFILE_RING_PERIOD_MIN];
pLineObj->ringDetMin /= 4;
profileIndex = VP_FXO_DIALING_PROFILE_RING_PERIOD_MAX_ACT;
pLineObj->ringDetMax = pDcFxoCfgProf[profileIndex];
profileIndex = VP_FXO_DIALING_PROFILE_RING_PERIOD_MAX;
fxoLoopThresh[3] = pDcFxoCfgProf[profileIndex];
#else /* VP880_CLARE_RINGING_DETECT */
profileIndex = VP_FXO_DIALING_PROFILE_DISC_VOLTAGE_MIN;
loopSuperParams = (pDcFxoCfgProf[profileIndex] << 3);
loopSuperParams &= 0x38;
fxoLoopThresh[0] &= ~(0x38);
fxoLoopThresh[0] |= loopSuperParams;
fxoLoopThresh[0] |= VP880_RING_DETECT_PERIOD_ONLY;
profileIndex = VP_FXO_DIALING_PROFILE_LIU_THRESHOLD_MIN;
fxoLoopThresh[0] &= ~(VP880_LOOP_SUP_LIU_THRESH_BITS);
fxoLoopThresh[0] |= liuVoltage;
profileIndex = VP_FXO_DIALING_PROFILE_RING_PERIOD_MIN;
#ifdef VP880_FXO_FULL_WAVE_RINGING
tempRegValue = pDcFxoCfgProf[profileIndex] / 2;
#else /* VP880_FXO_FULL_WAVE_RINGING */
tempRegValue = pDcFxoCfgProf[profileIndex];
#endif /* VP880_FXO_FULL_WAVE_RINGING */
fxoLoopThresh[VP880_RING_PERIOD_MIN_INDEX] = tempRegValue;
/*
* Cache the Minimum Ringing Detect Period that is implemented in
* SW.
*/
pLineObj->ringDetMin = pDcFxoCfgProf[profileIndex];
pLineObj->ringDetMin /= 4;
profileIndex = VP_FXO_DIALING_PROFILE_RING_PERIOD_MAX_ACT;
pLineObj->ringDetMax = pDcFxoCfgProf[profileIndex];
profileIndex = VP_FXO_DIALING_PROFILE_RING_PERIOD_MAX;
#ifdef VP880_FXO_FULL_WAVE_RINGING
tempRegValue = pDcFxoCfgProf[profileIndex] / 2;
#else /* VP880_FXO_FULL_WAVE_RINGING */
tempRegValue = pDcFxoCfgProf[profileIndex];
#endif /* VP880_FXO_FULL_WAVE_RINGING */
fxoLoopThresh[3] = tempRegValue;
#endif /* VP880_CLARE_RINGING_DETECT */
if (pLineObj->ringDetMax == 0) {
pLineObj->ringDetMax = fxoLoopThresh[3] / 4;
}
#ifdef VP_CSLAC_SEQ_EN
profileIndex = VP_FXO_DIALING_PROFILE_DTMF_ON_MSB;
pLineObj->digitGenStruct.dtmfOnTime = (pDcFxoCfgProf[profileIndex] << 8)&0xFF00;
profileIndex = VP_FXO_DIALING_PROFILE_DTMF_ON_LSB;
pLineObj->digitGenStruct.dtmfOnTime |= pDcFxoCfgProf[profileIndex];
profileIndex = VP_FXO_DIALING_PROFILE_DTMF_OFF_MSB;
pLineObj->digitGenStruct.dtmfOffTime = (pDcFxoCfgProf[profileIndex] << 8)&0xFF00;
profileIndex = VP_FXO_DIALING_PROFILE_DTMF_OFF_LSB;
pLineObj->digitGenStruct.dtmfOffTime |= pDcFxoCfgProf[profileIndex];
profileIndex = VP_FXO_DIALING_PROFILE_PULSE_BREAK;
pLineObj->digitGenStruct.breakTime = pDcFxoCfgProf[profileIndex];
profileIndex = VP_FXO_DIALING_PROFILE_PULSE_MAKE;
pLineObj->digitGenStruct.makeTime = pDcFxoCfgProf[profileIndex];
profileIndex = VP_FXO_DIALING_PROFILE_FLASH_HOOK_MSB;
pLineObj->digitGenStruct.flashTime = (pDcFxoCfgProf[profileIndex] << 8)&0xFF00;
profileIndex = VP_FXO_DIALING_PROFILE_FLASH_HOOK_LSB;
pLineObj->digitGenStruct.flashTime |= pDcFxoCfgProf[profileIndex];
profileIndex = VP_FXO_DIALING_PROFILE_INTERDIGIT_MSB;
pLineObj->digitGenStruct.dpInterDigitTime = (pDcFxoCfgProf[profileIndex] << 8)&0xFF00;
profileIndex = VP_FXO_DIALING_PROFILE_INTERDIGIT_LSB;
pLineObj->digitGenStruct.dpInterDigitTime = pDcFxoCfgProf[profileIndex];
profileIndex = VP_PROFILE_VERSION;
if (pDcFxoCfgProf[profileIndex] >= VP_CSLAC_FXO_VERSION_DTMF_LEVEL) {
profileIndex = VP_FXO_DIALING_PROFILE_DTMF_HIGH_LVL_MSB;
pLineObj->digitGenStruct.dtmfHighFreqLevel[0] = pDcFxoCfgProf[profileIndex];
profileIndex = VP_FXO_DIALING_PROFILE_DTMF_HIGH_LVL_LSB;
pLineObj->digitGenStruct.dtmfHighFreqLevel[1] = pDcFxoCfgProf[profileIndex];
profileIndex = VP_FXO_DIALING_PROFILE_DTMF_LOW_LVL_MSB;
pLineObj->digitGenStruct.dtmfLowFreqLevel[0] = pDcFxoCfgProf[profileIndex];
profileIndex = VP_FXO_DIALING_PROFILE_DTMF_LOW_LVL_LSB;
pLineObj->digitGenStruct.dtmfLowFreqLevel[1] = pDcFxoCfgProf[profileIndex];
} else {
pLineObj->digitGenStruct.dtmfHighFreqLevel[0] = 0x1C;
pLineObj->digitGenStruct.dtmfHighFreqLevel[1] = 0x32;
pLineObj->digitGenStruct.dtmfLowFreqLevel[0] = 0x1C;
pLineObj->digitGenStruct.dtmfLowFreqLevel[1] = 0x32;
}
#endif /* VP_CSLAC_SEQ_EN */
fxoLoopThresh[VP880_LIU_DBNC_INDEX] &= ~VP880_LIU_DBNC_MASK;
fxoLoopThresh[VP880_LIU_DBNC_INDEX] |=
((fxoLoopThresh[VP880_RING_PERIOD_MIN_INDEX] >> 3) & VP880_LIU_DBNC_MASK);
if (!(fxoLoopThresh[VP880_RING_PERIOD_MIN_INDEX] & VP880_RING_PERIOD_1MS)) {
if ((fxoLoopThresh[VP880_LIU_DBNC_INDEX] & VP880_LIU_DBNC_MASK) > 0) {
fxoLoopThresh[VP880_LIU_DBNC_INDEX]--;
}
}
VpMpiCmdWrapper(deviceId, ecVal, VP880_LOOP_SUP_WRT, VP880_LOOP_SUP_LEN, fxoLoopThresh);
/* Cache the loop supervision register content */
VpMemCpy(pLineObj->loopSup, fxoLoopThresh, VP880_LOOP_SUP_LEN);
}
/* Cache this so we don't have to read it all the time */
VpMemCpy(fxoLoopThresh, pLineObj->loopSup, VP880_LOOP_SUP_LEN);
pLineObj->lineTimers.timers.fxoTimer.maxPeriod = fxoLoopThresh[3];
#endif /* VP880_FXO_SUPPORT */
} else {
#ifdef VP880_FXS_SUPPORT
/* Configure an FXS line type */
/* Ringing changed if profile passed */
if (pRingProf != VP_PTABLE_NULL) {
uint8 tempRingPr[255];
int16 biasErr;
/*
* Clear flags to indicate generators are not programmed to user
* specified Ringing values.
*/
pLineObj->status &= ~(VP880_RING_GEN_NORM | VP880_RING_GEN_REV);
/*
* Ringing Profile May affect the system state register, so read
* what it is before the profile, and set it back to all values
* except what can change in the profile
*/
VpMpiCmdWrapper(deviceId, ecVal, VP880_SS_CONFIG_RD,
VP880_SS_CONFIG_LEN, sysStateConfig);
profileIndex = VP_PROFILE_MPI_LEN + 1;
pMpiData = (VpProfileDataType *)&pRingProf[profileIndex];
VpMemCpy(tempRingPr, pMpiData, pRingProf[VP_PROFILE_MPI_LEN]);
biasErr = (int16)((((uint16)(tempRingPr[2]) << 8) & 0xFF00) +
((uint16)(tempRingPr[3]) & 0x00FF));
/* Apply the offset calibration to the BIAS */
if ((pLineObj->slicValueCache & VP880_SS_POLARITY_MASK) == 0x00) {
/* Normal polarity */
biasErr -= ((pDevObj->vp880SysCalData.sigGenAError[channelId][0] -
pDevObj->vp880SysCalData.vocOffset[channelId][VP880_NORM_POLARITY]) * 16 / 10);
} else {
/* Reverse polarity */
biasErr += ((pDevObj->vp880SysCalData.sigGenAError[channelId][0] -
pDevObj->vp880SysCalData.vocOffset[channelId][VP880_REV_POLARITY]) * 16 / 10);
}
tempRingPr[2] = (uint8)((biasErr >> 8) & 0x00FF);
tempRingPr[3] = (uint8)(biasErr & 0x00FF);
VpMpiCmdWrapper(deviceId, ecVal, NOOP_CMD, pRingProf[VP_PROFILE_MPI_LEN], tempRingPr);
VpMemCpy(pLineObj->ringingParams, &pRingProf[profileIndex + 1],
VP880_RINGER_PARAMS_LEN);
ringTypeByte = pRingProf[VP_PROFILE_MPI_LEN +
pRingProf[VP_PROFILE_MPI_LEN] + VP_PROFILE_RING_TYPE_OFFSET];
pLineObj->status &= ~(VP880_UNBAL_RINGING);
pLineObj->status |= (ringTypeByte ? VP880_UNBAL_RINGING : 0x0000);
/*
* Nothing in this register should be allowed to change, but the
* Ringing profile may have changed this value to be compatible
* with other device profiles. So correct it.
*/
VpMpiCmdWrapper(deviceId, ecVal, VP880_SS_CONFIG_WRT,
VP880_SS_CONFIG_LEN, sysStateConfig);
}
/* Set Loop Supervision and DC Feed */
if (pDcFxoCfgProf != VP_PTABLE_NULL) {
profileIndex = VP_PROFILE_MPI_LEN + 1;
pMpiData = (VpProfileDataType *)&pDcFxoCfgProf[profileIndex];
if (pDevObj->stateInt & VP880_IS_ABS) { /* ABS Workaround */
#ifdef VP880_ABS_SUPPORT
/* If the VOC set >= theshold, disable longitudinal clamps */
if ((pDcFxoCfgProf[VP880_VOC_PROFILE_POSITION] & VP880_VOC_MASK)
>= VP880_VOC_51V) {
pLineObj->icr3Values[VP880_ICR3_LINE_CTRL_INDEX] &= ~VP880_ICR3_SAT_LIM_25_CTRL;
pLineObj->icr3Values[VP880_ICR3_LONG_UNCLAMP_INDEX] |= VP880_ICR3_LONG_UNCLAMP;
pLineObj->icr3Values[VP880_ICR3_LONG_UNCLAMP_INDEX+1] |= VP880_ICR3_LONG_UNCLAMP;
} else {
pLineObj->icr3Values[VP880_ICR3_LINE_CTRL_INDEX]
|= VP880_ICR3_SAT_LIM_25_CTRL;
pLineObj->icr3Values[VP880_ICR3_LINE_CTRL_INDEX+1]
&= ~VP880_ICR3_SAT_LIM_25_CTRL;
pLineObj->icr3Values[VP880_ICR3_LONG_UNCLAMP_INDEX]
&= ~VP880_ICR3_LONG_UNCLAMP;
}
#endif /* VP880_ABS_SUPPORT */
} else { /* Tracker Workaround */
#ifdef VP880_TRACKER_SUPPORT
/* If the VOC set > 48V, disable longitudinal clamps */
if ((pDcFxoCfgProf[VP880_VOC_PROFILE_POSITION] & VP880_VOC_MASK) > VP880_VOC_48V) {
/* Disable longitudinal clamps */
pLineObj->icr3Values[VP880_ICR3_LONG_UNCLAMP_INDEX] |= VP880_ICR3_LONG_UNCLAMP;
pLineObj->icr3Values[VP880_ICR3_LONG_UNCLAMP_INDEX+1] |= VP880_ICR3_LONG_UNCLAMP;
/* Remove Workaround from other conditions */
pLineObj->icr3Values[VP880_ICR3_LONG_FIXED_INDEX] &= ~VP880_ICR3_LONG_FIXED;
} else {
/* If the VOC <= 48V, enable longitudinal clamps */
pLineObj->icr3Values[VP880_ICR3_LONG_FIXED_INDEX] |= VP880_ICR3_LONG_FIXED;
pLineObj->icr3Values[VP880_ICR3_LONG_FIXED_INDEX+1] &= ~VP880_ICR3_LONG_FIXED;
/* Remove Workaround from other conditions */
pLineObj->icr3Values[VP880_ICR3_LONG_UNCLAMP_INDEX] &= ~VP880_ICR3_LONG_UNCLAMP;
}
#endif /* VP880_TRACKER_SUPPORT */
}
if (pDcFxoCfgProf[VP_PROFILE_VERSION] >= 1) {
/* This profile contains a hook hysteresis value */
pLineObj->hookHysteresis = pDcFxoCfgProf[VP880_HOOK_HYST_POSITION];
} else {
pLineObj->hookHysteresis = 0;
}
VP_LINE_STATE(VpLineCtxType, pLineCtx,
("Config Line: Channel %d: Writing ICR2 0x%02X 0x%02X 0x%02X 0x%02X",
channelId, pLineObj->icr2Values[0], pLineObj->icr2Values[1],
pLineObj->icr2Values[2], pLineObj->icr2Values[3]));
VpMpiCmdWrapper(deviceId, ecVal, VP880_ICR2_WRT, VP880_ICR2_LEN, pLineObj->icr2Values);
VP_LINE_STATE(VpLineCtxType, pLineCtx,
("ICR3 Workaround: 0x%02X 0x%02X 0x%02X 0x%02X Ch %d",
pLineObj->icr3Values[0], pLineObj->icr3Values[1],
pLineObj->icr3Values[2], pLineObj->icr3Values[3], channelId));
VpMpiCmdWrapper(deviceId, ecVal, VP880_ICR3_WRT, VP880_ICR3_LEN, pLineObj->icr3Values);
/* Cache the loop supervision register content */
VpMemCpy(pLineObj->loopSup, &pMpiData[1], VP880_LOOP_SUP_LEN);
/* If off-hook -> apply the hysteresis */
if ((VpCslacLineCondType)(pLineObj->lineState.condition & VP_CSLAC_HOOK)
== VP_CSLAC_HOOK) {
if ((pMpiData[1] & VP880_LOOP_SUP_LIU_THRESH_BITS) >= pLineObj->hookHysteresis) {
pMpiData[1] -= pLineObj->hookHysteresis;
} else {
pMpiData[1] &= ~VP880_LOOP_SUP_LIU_THRESH_BITS;
}
}
/* Write the Profile Data */
VpMpiCmdWrapper(deviceId, ecVal, NOOP_CMD, pDcFxoCfgProf[VP_PROFILE_MPI_LEN], pMpiData);
if (pDevObj->staticInfo.rcnPcn[VP880_RCN_LOCATION] >= VP880_REV_JE) {
uint8 icr5Values[VP880_ICR5_LEN];
VpMpiCmdWrapper(deviceId, ecVal, VP880_ICR5_RD, VP880_ICR5_LEN, icr5Values);
icr5Values[VP880_ICR5_FEED_HOLD_INDEX] &= ~VP880_ICR5_FEED_HOLD_MASK;
/* Device value is x + 18mA, so threshold is > 35mA */
if ((pDcFxoCfgProf[VP880_ILA_PROFILE_POSITION] & VP880_ILA_MASK) > 17) {
icr5Values[VP880_ICR5_FEED_HOLD_INDEX] |= 0xF0;
} else {
icr5Values[VP880_ICR5_FEED_HOLD_INDEX] |= 0xA0;
}
VpMpiCmdWrapper(deviceId, ecVal, VP880_ICR5_WRT, VP880_ICR5_LEN, icr5Values);
}
/* Copy Feed for Calibration reference */
VP_CALIBRATION(VpLineCtxType, pLineCtx, ("Copying DC Feed Reference in VpConfigLine()"));
VpMpiCmdWrapper(deviceId, ecVal, VP880_DC_FEED_RD,
VP880_DC_FEED_LEN, pLineObj->calLineData.dcFeedRef);
/* Update the line and device objects (dc feed register) for calibrated values. */
Vp880UpdateCalValue(pLineCtx);
}
#endif /* VP880_FXS_SUPPORT */
}
VpSysExitCritical(deviceId, VP_CODE_CRITICAL_SEC);
return VP_STATUS_SUCCESS;
} /* Vp880ConfigLine() */
/*
* Vp880UpdateCalValue()
* This function loads the device with calibration values provided by VpCal()
* "Apply System Coefficient" process.
*
* Preconditions:
* System calibration values provided or calibration previously run.
*
* Postconditions:
* The device is loaded per the applied calibration values.
*/
bool
Vp880UpdateCalValue(
VpLineCtxType *pLineCtx)
{
Vp880LineObjectType *pLineObj = pLineCtx->pLineObj;
VpDevCtxType *pDevCtx = pLineCtx->pDevCtx;
Vp880DeviceObjectType *pDevObj = pDevCtx->pDevObj;
VpDeviceIdType deviceId = pDevObj->deviceId;
uint8 ecVal = pLineObj->ecVal;
bool calStatus = FALSE;
VP_API_FUNC_INT(VpLineCtxType, pLineCtx, ("Vp880UpdateCalValue+"));
if ((pLineObj->calLineData.dcFeedRef[0] == 0x00) || (pLineObj->status & VP880_IS_FXO)) {
VP_API_FUNC_INT(VpLineCtxType, pLineCtx, ("Vp880UpdateCalValue-"));
return calStatus;
}
/*
* Update the target DC Feed registers used after calibration has
* been run. So we don't need to replace VAS (0 only if calibration
* not run, but then corrected during calibration).
*/
pLineObj->calLineData.dcFeed[0] &= ~VP880_VOC_VALUE_MASK;
pLineObj->calLineData.dcFeed[0] |= (pLineObj->calLineData.dcFeedRef[0] & VP880_VOC_VALUE_MASK);
pLineObj->calLineData.dcFeedPr[0] &= ~VP880_VOC_VALUE_MASK;
pLineObj->calLineData.dcFeedPr[0] |= (pLineObj->calLineData.dcFeedRef[0] & VP880_VOC_VALUE_MASK);
pLineObj->calLineData.dcFeedPr[1] &= ~VP880_ILA_MASK;
pLineObj->calLineData.dcFeedPr[1] |= (pLineObj->calLineData.dcFeedRef[1] & VP880_ILA_MASK);
pLineObj->calLineData.dcFeed[1] &= ~VP880_ILA_MASK;
pLineObj->calLineData.dcFeed[1] |= (pLineObj->calLineData.dcFeedRef[1] & VP880_ILA_MASK);
/*
* Adjust for the errors if previously calibrated. The ILA function
* returns "TRUE" if an adjustment was made meaning calibration
* done previously, FALSE if not.
*/
if (Vp880AdjustIla(pLineCtx, (pLineObj->calLineData.dcFeedRef[1] & VP880_ILA_MASK)) == TRUE) {
calStatus = TRUE;
Vp880AdjustVoc(pLineCtx, ((pLineObj->calLineData.dcFeedRef[0] >> 2) & 0x7), TRUE);
if (!(pDevObj->stateInt & VP880_IS_ABS)) { /* Tracker only */
#ifdef VP880_TRACKER_SUPPORT
uint16 vasVoltScale;
uint8 channelId = pLineObj->channelId;
/* Set VAS to device calibrated values */
vasVoltScale = (VP880_VAS_START + (uint16)pDevObj->vp880SysCalData.vas[channelId][VP880_NORM_POLARITY] * VP880_VAS_STEP);
VpCSLACSetVas(pLineObj->calLineData.dcFeed, vasVoltScale);
vasVoltScale = (VP880_VAS_START + (uint16)pDevObj->vp880SysCalData.vas[channelId][VP880_REV_POLARITY] * VP880_VAS_STEP);
VpCSLACSetVas(pLineObj->calLineData.dcFeedPr, vasVoltScale);
/*
* BatteryCalAdjust() takes care of the device object wideband 'OR'
* operation to the provided ec value as needed.
*/
Vp880BatteryCalAdjust(pDevObj, VP880_EC_CH1);
Vp880BatteryCalAdjust(pDevObj, VP880_EC_CH2);
#endif /* VP880_TRACKER_SUPPORT */
} else {
#ifdef VP880_ABS_SUPPORT
VpLineStateType lineState;
int16 targetVoltY, targetVoltZ;
VpGetLineState(pLineCtx, &lineState);
Vp880GetLineStateABS(pLineCtx, lineState, FALSE);
/* Compute Errors and make corrections */
targetVoltY = (pDevObj->swParams[VP880_SWY_LOCATION] & VP880_VOLTAGE_MASK);
targetVoltZ = (pDevObj->swParams[VP880_SWZ_LOCATION] & VP880_VOLTAGE_MASK);
VP_CALIBRATION(VpLineCtxType, pLineCtx, ("ABS: Channel %d in State %d TargetY %d TargetZ %d",
pLineObj->channelId, lineState, targetVoltY, targetVoltZ));
Vp880AbvMakeAdjustment(pDevObj, &targetVoltY, &targetVoltZ);
#endif /* VP880_ABS_SUPPORT */
}
if (pLineObj->slicValueCache & VP880_SS_POLARITY_MASK) {
VpMpiCmdWrapper(deviceId, ecVal, VP880_DC_FEED_WRT,
VP880_DC_FEED_LEN, pLineObj->calLineData.dcFeedPr);
} else {
VpMpiCmdWrapper(deviceId, ecVal, VP880_DC_FEED_WRT,
VP880_DC_FEED_LEN, pLineObj->calLineData.dcFeed);
}
}
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Vp880UpdateCalValue() Chan %d: DC Feed Values Normal 0x%02X 0x%02X",
pLineObj->channelId,
pLineObj->calLineData.dcFeed[0], pLineObj->calLineData.dcFeed[1]));
VP_CALIBRATION(VpLineCtxType, pLineCtx,
("Vp880UpdateCalValue() Chan %d: DC Feed Values Reverse 0x%02X 0x%02X",
pLineObj->channelId,
pLineObj->calLineData.dcFeedPr[0], pLineObj->calLineData.dcFeedPr[1]));
VP_API_FUNC_INT(VpLineCtxType, pLineCtx, ("Vp880UpdateCalValue-"));
return calStatus;
} /* Vp880UpdateCalValue() */
/**
* Vp880InitProfile()
* This function is used to initialize profile tables in Vp880.
*
* Preconditions:
* The device associated with this line must be initialized.
*
* Postconditions:
* Stores the given profile at the specified index of the profile table.
*/
VpStatusType
Vp880InitProfile(
VpDevCtxType *pDevCtx,
VpProfileType type,
VpProfilePtrType pProfileIndex,
VpProfilePtrType pProfile)
{
Vp880DeviceObjectType *pDevObj = pDevCtx->pDevObj;
VpDeviceIdType deviceId = pDevObj->deviceId;
VpStatusType status = VP_STATUS_SUCCESS;
uint8 profIndex8; /* Used for 8-bit profile table masking */
uint16 profIndex16; /* Used for 16-bit profile table masking */
/*
* If the profile data is an index, indicated by Get Profile Index return
* value of > -1, return an error (cannot init an indexed entry with an
* index).
*/
int profileIndex = VpGetProfileIndex(pProfile);
if (profileIndex >= 0) {
return VP_STATUS_INVALID_ARG;
}
/*
* If pProfileIndex is -1, the profile is of pointer type and invalid,
* otherwise it is an index. If it's an index, make sure the range is
* valid.
*/
profileIndex = VpGetProfileIndex(pProfileIndex);
if (profileIndex < 0) {
return VP_STATUS_INVALID_ARG;
}
profIndex8 = (uint8)profileIndex;
profIndex16 = (uint16)profileIndex;
VpSysEnterCritical(deviceId, VP_CODE_CRITICAL_SEC);
/*
* The correct types are passed, but check to make sure the specific profile type being
* initialized is valid as well as the index value
*/
switch(type) {
case VP_PROFILE_DEVICE:
if (profIndex8 >= VP_CSLAC_DEV_PROF_TABLE_SIZE) {
status = VP_STATUS_INVALID_ARG;
} else {
if(VpVerifyProfileType(VP_PROFILE_DEVICE, pProfile) == TRUE) {
pDevObj->devProfileTable.pDevProfileTable[profIndex8] = pProfile;
/*
* If the profile is null, then clear the flag in the profile entry table to
* indicate that this profile is no longer valid.
*/
if (pProfile == VP_PTABLE_NULL) {
pDevObj->profEntry.devProfEntry &= ~(0x01 << profIndex8);
} else {
pDevObj->profEntry.devProfEntry |= (0x01 << profIndex8);
}
} else {
status = VP_STATUS_ERR_PROFILE;
}
}
break;
case VP_PROFILE_AC:
if (profIndex8 >= VP_CSLAC_AC_PROF_TABLE_SIZE) {
status = VP_STATUS_INVALID_ARG;
} else {
if(VpVerifyProfileType(VP_PROFILE_AC, pProfile) == TRUE) {
pDevObj->devProfileTable.pAcProfileTable[profIndex8] = pProfile;
/*
* If the profile is null, then clear the flag in the profile entry table to
* indicate that this profile is no longer valid.
*/
if (pProfile == VP_PTABLE_NULL) {
pDevObj->profEntry.acProfEntry &= ~(0x01 << profIndex8);
} else {
pDevObj->profEntry.acProfEntry |= (0x01 << profIndex8);
}
} else {
status = VP_STATUS_ERR_PROFILE;
}
}
break;
case VP_PROFILE_DC:
if (profIndex8 >= VP_CSLAC_DC_PROF_TABLE_SIZE) {
status = VP_STATUS_INVALID_ARG;
} else {
if(VpVerifyProfileType(VP_PROFILE_DC, pProfile) == TRUE) {
pDevObj->devProfileTable.pDcProfileTable[profIndex8] = pProfile;
/*
* If the profile is null, then clear the flag in the profile entry table to
* indicate that this profile is no longer valid.
*/
if (pProfile == VP_PTABLE_NULL) {
pDevObj->profEntry.dcProfEntry &= ~(0x01 << profIndex8);
} else {
pDevObj->profEntry.dcProfEntry |= (0x01 << profIndex8);
}
} else {
status = VP_STATUS_ERR_PROFILE;
}
}
break;
case VP_PROFILE_RING:
if (profIndex8 >= VP_CSLAC_RINGING_PROF_TABLE_SIZE) {
status = VP_STATUS_INVALID_ARG;
} else {
if(VpVerifyProfileType(VP_PROFILE_RING, pProfile) == TRUE) {
pDevObj->devProfileTable.pRingingProfileTable[profIndex8] = pProfile;
/*
* If the profile is null, then clear the flag in the profile entry table to
* indicate that this profile is no longer valid.
*/
if (pProfile == VP_PTABLE_NULL) {
pDevObj->profEntry.ringingProfEntry &= ~(0x01 << profIndex8);
} else {
pDevObj->profEntry.ringingProfEntry |= (0x01 << profIndex8);
}
} else {
status = VP_STATUS_ERR_PROFILE;
}
}
break;
case VP_PROFILE_RINGCAD:
if (profIndex8 >= VP_CSLAC_RING_CADENCE_PROF_TABLE_SIZE) {
status = VP_STATUS_INVALID_ARG;
} else {
if(VpVerifyProfileType(VP_PROFILE_RINGCAD, pProfile) == TRUE) {
pDevObj->devProfileTable.pRingingCadProfileTable[profIndex8] = pProfile;
/*
* If the profile is null, then clear the flag in the profile entry table to
* indicate that this profile is no longer valid.
*/
if (pProfile == VP_PTABLE_NULL) {
pDevObj->profEntry.ringCadProfEntry &= ~(0x01 << profIndex8);
} else {
pDevObj->profEntry.ringCadProfEntry |= (0x01 << profIndex8);
}
} else {
status = VP_STATUS_ERR_PROFILE;
}
}
break;
case VP_PROFILE_TONE:
if (profIndex16 >= VP_CSLAC_TONE_PROF_TABLE_SIZE) {
status = VP_STATUS_INVALID_ARG;
} else {
if(VpVerifyProfileType(VP_PROFILE_TONE, pProfile) == TRUE) {
pDevObj->devProfileTable.pToneProfileTable[profIndex16] = pProfile;
/*
* If the profile is null, then clear the flag in the profile entry table to
* indicate that this profile is no longer valid.
*/
if (pProfile == VP_PTABLE_NULL) {
pDevObj->profEntry.toneProfEntry &= ~(0x01 << profIndex16);
} else {
pDevObj->profEntry.toneProfEntry |= (0x01 << profIndex16);
}
} else {
status = VP_STATUS_ERR_PROFILE;
}
}
break;
case VP_PROFILE_TONECAD:
if (profIndex16 >= VP_CSLAC_TONE_CADENCE_PROF_TABLE_SIZE) {
status = VP_STATUS_INVALID_ARG;
} else {
if(VpVerifyProfileType(VP_PROFILE_TONECAD, pProfile) == TRUE) {
pDevObj->devProfileTable.pToneCadProfileTable[profIndex16] = pProfile;
/*
* If the profile is null, then clear the flag in the profile entry table to
* indicate that this profile is no longer valid.
*/
if (pProfile == VP_PTABLE_NULL) {
pDevObj->profEntry.toneCadProfEntry &= ~(0x01 << profIndex16);
} else {
pDevObj->profEntry.toneCadProfEntry |= (0x01 << profIndex16);
}
} else {
status = VP_STATUS_ERR_PROFILE;
}
}
break;
case VP_PROFILE_METER:
if (profIndex8 >= VP_CSLAC_METERING_PROF_TABLE_SIZE) {
status = VP_STATUS_INVALID_ARG;
} else {
if(VpVerifyProfileType(VP_PROFILE_METER, pProfile) == TRUE) {
pDevObj->devProfileTable.pMeteringProfileTable[profIndex8] = pProfile;
/*
* If the profile is null, then clear the flag in the profile entry table to
* indicate that this profile is no longer valid.
*/
if (pProfile == VP_PTABLE_NULL) {
pDevObj->profEntry.meterProfEntry &= ~(0x01 << profIndex8);
} else {
pDevObj->profEntry.meterProfEntry |= (0x01 << profIndex8);
}
} else {
status = VP_STATUS_ERR_PROFILE;
}
}
break;
case VP_PROFILE_CID:
if (profIndex8 >= VP_CSLAC_CALLERID_PROF_TABLE_SIZE) {
status = VP_STATUS_INVALID_ARG;
} else {
if(VpVerifyProfileType(VP_PROFILE_CID, pProfile) == TRUE) {
pDevObj->devProfileTable.pCallerIdProfileTable[profIndex8] = pProfile;
/*
* If the profile is null, then clear the flag in the profile entry table to
* indicate that this profile is no longer valid.
*/
if (pProfile == VP_PTABLE_NULL) {
pDevObj->profEntry.cidCadProfEntry &= ~(0x01 << profIndex8);
} else {
pDevObj->profEntry.cidCadProfEntry |= (0x01 << profIndex8);
}
} else {
status = VP_STATUS_ERR_PROFILE;
}
}
break;
case VP_PROFILE_FXO_CONFIG:
if (profIndex8 >= VP_CSLAC_FXO_CONFIG_PROF_TABLE_SIZE) {
status = VP_STATUS_INVALID_ARG;
} else {
if(VpVerifyProfileType(VP_PROFILE_FXO_CONFIG, pProfile) == TRUE) {
pDevObj->devProfileTable.pFxoConfigProfileTable[profIndex8] = pProfile;
/*
* If the profile is null, then clear the flag in the profile entry table to
* indicate that this profile is no longer valid.
*/
if (pProfile == VP_PTABLE_NULL) {
pDevObj->profEntry.fxoConfigProfEntry &= ~(0x01 << profIndex8);
} else {
pDevObj->profEntry.fxoConfigProfEntry |= (0x01 << profIndex8);
}
} else {
status = VP_STATUS_ERR_PROFILE;
}
}
break;
default:
status = VP_STATUS_INVALID_ARG;
break;
}
VpSysExitCritical(deviceId, VP_CODE_CRITICAL_SEC);
return status;
} /* Vp880InitProfile() */
#ifdef VP880_FXS_SUPPORT
/**
* Vp880FreeRun()
* This function is called by the application when it wants to prepare the
* system for a restart, or by the VP-API-II internally when a clock fault or
* other "sign" of a restart is detected.
*
* Preconditions:
* Conditions defined by purpose of Api Tick.
*
* Postconditions:
* Device and line are in states 'ready" for a system reboot to occur. Lines
* are set to VP_LINE_STANDBY if previously ringing.
*/
VpStatusType
Vp880FreeRun(
VpDevCtxType *pDevCtx,
VpFreeRunModeType freeRunMode)
{
VpLineCtxType *pLineCtx;
Vp880DeviceObjectType *pDevObj = pDevCtx->pDevObj;
Vp880LineObjectType *pLineObj;
VpDeviceIdType deviceId = pDevObj->deviceId;
uint8 maxChan = pDevObj->staticInfo.maxChannels;
uint8 ecVal = pDevObj->ecVal;
VpLineStateType lineState;
uint8 powerMode[VP880_REGULATOR_CTRL_LEN];
uint8 channelId;
VP_API_FUNC(VpDevCtxType, pDevCtx, ("Vp880FreeRun Mode %d", freeRunMode));
VpSysEnterCritical(deviceId, VP_CODE_CRITICAL_SEC);
/*
* Time value is passed in 500us increment. If timeOut = 0, only PCLK
* recovery exits restart prepare operations. If less than one tick, force
* a one tick timeout.
*/
if (freeRunMode == VP_FREE_RUN_STOP) {
Vp880RestartComplete(pDevCtx);
/*
* Clear the device as being forced into free run mode by application.
* This allows PCLK fault detection to automatically enter/exit free
* run mode.
*/
pDevObj->stateInt &= ~VP880_FORCE_FREE_RUN;
VpSysExitCritical(deviceId, VP_CODE_CRITICAL_SEC);
return VP_STATUS_SUCCESS;
}
/* Take the lines out of Ringing if necessary */
for (channelId = 0; channelId < maxChan; channelId++) {
pLineCtx = pDevCtx->pLineCtx[channelId];
if (pLineCtx != VP_NULL) {
pLineObj = pLineCtx->pLineObj;
if (pLineObj->status & VP880_LINE_IN_CAL) {
lineState = pLineObj->calLineData.usrState;
} else {
lineState = pLineObj->lineState.usrCurrent;
}
if (lineState == VP_LINE_RINGING) {
Vp880SetLineState(pLineCtx, VP_LINE_STANDBY);
}
if (lineState == VP_LINE_RINGING_POLREV) {
Vp880SetLineState(pLineCtx, VP_LINE_STANDBY_POLREV);
}
}
}
/*
* Load the free run timing, if available. Otherwise just force the switcher
* to HP mode and take control.
*/
if (pDevObj->intSwParamsFR[0] != 0x00) {
VpMpiCmdWrapper(deviceId, ecVal, VP880_INT_SWREG_PARAM_WRT,
VP880_INT_SWREG_PARAM_LEN, pDevObj->intSwParamsFR);
} else {
/* Force control of the power mode */
pDevObj->swParamsCache[VP880_SWY_AUTOPOWER_INDEX] |= VP880_SWY_AUTOPOWER_DIS;
pDevObj->swParamsCache[VP880_SWZ_AUTOPOWER_INDEX] |= VP880_SWZ_AUTOPOWER_DIS;
VpMpiCmdWrapper(deviceId, ecVal, VP880_REGULATOR_PARAM_WRT,
VP880_REGULATOR_PARAM_LEN, pDevObj->swParamsCache);
/* Change the Switchers to High Power Mode */
powerMode[0] = VP880_SWY_HP | VP880_SWZ_HP;
VpMpiCmdWrapper(deviceId, ecVal, VP880_REGULATOR_CTRL_WRT,
VP880_REGULATOR_CTRL_LEN, powerMode);
}
/*
* Mark the device as being forced into free run mode by application. This
* prevents auto-recovery when PCLK is restored.
*/
pDevObj->stateInt |= VP880_FORCE_FREE_RUN;
VpSysExitCritical(deviceId, VP_CODE_CRITICAL_SEC);
return VP_STATUS_SUCCESS;
} /* Vp880FreeRun() */
/**
* Vp880RestartComplete()
* This function is called by the VP-API-II internally when a clock fault is
* removed.
*
* Preconditions:
* Conditions defined by purpose of Api Tick.
*
* Postconditions:
* Device and line are in states recovered from a reboot.
*/
void
Vp880RestartComplete(
VpDevCtxType *pDevCtx)
{
Vp880DeviceObjectType *pDevObj = pDevCtx->pDevObj;
VpDeviceIdType deviceId = pDevObj->deviceId;
uint8 ecVal = pDevObj->ecVal;
uint8 powerMode[VP880_REGULATOR_CTRL_LEN];
/*
* Restore original timing if they were changed, otherwise change back the
* power mode and relinquish control.
*/
if (pDevObj->intSwParamsFR[0] != 0x00) {
/* Restore the original timings */
VpMpiCmdWrapper(deviceId, ecVal, VP880_INT_SWREG_PARAM_WRT,
VP880_INT_SWREG_PARAM_LEN, pDevObj->intSwParams);
} else {
/* Change the Switchers to the original Power Mode */
if (pDevObj->stateInt & VP880_IS_ABS) {
#ifdef VP880_ABS_SUPPORT
uint8 systemConfig = (pDevObj->devProfileData.systemConfig & VP880_ABS_CFG_MASK);
if (systemConfig == VP880_ABS_CFG_SLAVE) {
powerMode[0] = VP880_SWY_LP | VP880_SWY_LP;
} else if (systemConfig == VP880_ABS_CFG_SINGLE) {
powerMode[0] = VP880_SWY_MP | VP880_SWY_MP;
} else { /* systemConfig == VP880_ABS_CFG_MASTER */
powerMode[0] = VP880_SWY_HP | VP880_SWY_HP;
}
#endif /* VP880_ABS_SUPPORT */
} else {
#ifdef VP880_TRACKER_SUPPORT
powerMode[0] = VP880_SWY_LP | VP880_SWZ_LP;
#endif /* VP880_TRACKER_SUPPORT */
}
VpMpiCmdWrapper(deviceId, ecVal, VP880_REGULATOR_CTRL_WRT,
VP880_REGULATOR_CTRL_LEN, powerMode);
/* Relinquish control of the power mode */
pDevObj->swParamsCache[VP880_SWY_AUTOPOWER_INDEX] &= ~VP880_SWY_AUTOPOWER_DIS;
pDevObj->swParamsCache[VP880_SWZ_AUTOPOWER_INDEX] &= ~VP880_SWZ_AUTOPOWER_DIS;
VpMpiCmdWrapper(deviceId, ecVal, VP880_REGULATOR_PARAM_WRT,
VP880_REGULATOR_PARAM_LEN, pDevObj->swParamsCache);
}
} /* Vp880RestartComplete() */
/**
* Vp880CopyDefaultFRProfile()
* This function is used to copy the default Free Run switcher timing parameters
* to the device object used in Free Run mode. This is needed when values are
* not provided in the device profile.
*
* Preconditions:
* None.
*
* Postconditions:
* The device object is updated with the default free run switcher timing values.
*/
static void
Vp880CopyDefaultFRProfile(
Vp880DeviceObjectType *pDevObj)
{
if (pDevObj->stateInt & VP880_IS_ABS) {
#ifdef VP880_ABS_SUPPORT
/* ABS free run default profile */
uint8 intSwParamsFR_ABS[VP880_INT_SWREG_PARAM_LEN] = {
0x2C, 0x40, 0x2C, 0x40, 0x2C, 0x40
};
VpMemCpy(pDevObj->intSwParamsFR, intSwParamsFR_ABS, VP880_INT_SWREG_PARAM_LEN);
#endif /* VP880_ABS_SUPPORT */
} else {
#ifdef VP880_TRACKER_SUPPORT
/*
* The 1st timing value can't be 0x00, so it's a marker value -> no profile
* available
*/
uint8 intSwParamsFR_DFLT[VP880_INT_SWREG_PARAM_LEN] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
VpMemCpy(pDevObj->intSwParamsFR, intSwParamsFR_DFLT, VP880_INT_SWREG_PARAM_LEN);
#endif /* VP880_TRACKER_SUPPORT */
}
} /* Vp880CopyDefaultFRProfile() */
#endif /* VP880_FXS_SUPPORT */
#endif