/**
* VpInitRing()
* This function is used to initialize Ringing and CID profile to a given line.
* See VP-API reference guide for more information.
*
* Preconditions:
* The line context and device context should be created initialized. The boot
* image should be downloaded before calling this function (for applicable
* devices).
*
* Postconditions:
* Applies the Caller ID and Ringing profile.
*/
VpStatusType
VpInitRing(
VpLineCtxType *pLineCtx, /**< Line context */
VpProfilePtrType pCadProfile, /**< Ringing cadence profile */
VpProfilePtrType pCidProfile) /**< Caller ID profile */
{
VpStatusType status;
VP_API_ENTER(VpLineCtxType, pLineCtx, "InitRing");
/* Basic argument checking */
if (pCadProfile == VP_NULL && pCidProfile != VP_NULL) {
/* It doesn't make sense to load a caller ID profile with
* no ring cadence */
VP_ERROR(VpLineCtxType, pLineCtx, ("VpInitRing(): Cannot use a NULL ring cadence with a non-NULL caller ID profile"));
status = VP_STATUS_INVALID_ARG;
} else if (pLineCtx == VP_NULL) {
VP_ERROR(VpLineCtxType, pLineCtx, ("VpInitRing(): Invalid NULL pLineCtx"));
status = VP_STATUS_INVALID_ARG;
} else {
VpDevCtxType *pDevCtx = pLineCtx->pDevCtx;
status = VP_CALL_DEV_FUNC(InitRing, (pLineCtx, pCadProfile, pCidProfile));
}
VP_API_EXIT(VpLineCtxType, pLineCtx, "InitRing", status);
return status;
} /* VpInitRing() */
/*
* VpInitSlac()
* This function performs the same operations on a per-SLAC basis that
* VpInitDevice() does for all devices. See VpInitDevice() for details.
*
* Preconditions:
* The device and line context must be created and initialized and the
* controller device must be initialized (via VpInitDevice).
*
* Postconditions:
* SLAC is calibrated and all lines associated with this SLAC are initialized
* with the AC, DC, and Ringing Paramaters passed.
*/
VpStatusType
VpInitSlac(
VpLineCtxType *pLineCtx, /**< Pointer any line context associated
* with the SLAC being initialized.
*/
VpProfilePtrType pDevProfile, /**< Pointer to Device Profile */
VpProfilePtrType pAcProfile, /**< Pointer to AC Profile that is applied
* to all FXS lines on this SLAC
*/
VpProfilePtrType pDcProfile, /**< Pointer to DC Profile that is applied
* to all FXS lines on this SLAC
*/
VpProfilePtrType pRingProfile) /**< Pointer to Ringing Profile that is
* applied to all FXS lines on this SLAC
*/
{
VpStatusType status;
VP_API_ENTER(VpLineCtxType, pLineCtx, "InitSlac");
/* Basic argument checking */
if (pLineCtx == VP_NULL) {
status = VP_STATUS_INVALID_ARG;
} else {
VpDevCtxType *pDevCtx = pLineCtx->pDevCtx;
status = VP_CALL_DEV_FUNC(InitSlac, (pLineCtx, pDevProfile, pAcProfile, pDcProfile, pRingProfile));
}
VP_API_EXIT(VpLineCtxType, pLineCtx, "InitSlac", status);
return status;
} /* VpInitSlac() */
/**
* VpSetOption()
* This function is used to set various options that are supported by VP-API.
* For a detailed description of how this function can be used to set device,
* line specific, device specific options and to various types of options
* please see VP-API user guide.
*
* Preconditions:
* Device/Line context should be created and initialized. For applicable
* devices bootload should be performed before calling the function.
*
* Postconditions:
* This function sets the requested option.
*/
VpStatusType
VpSetOption(
VpLineCtxType *pLineCtx,
VpDevCtxType *pDevCtxParam,
VpOptionIdType optionId,
void *value)
{
VpDevCtxType *pDevCtx;
VpStatusType status = VP_STATUS_SUCCESS;
bool singleLine = (pLineCtx != VP_NULL);
/* Basic argument checking */
if (singleLine) {
VP_API_FUNC(VpLineCtxType, pLineCtx, ("VpSetOption(%s):", VpGetString_VpOptionIdType(optionId)));
if (pDevCtxParam != VP_NULL) {
status = VP_STATUS_INVALID_ARG;
}
pDevCtx = pLineCtx->pDevCtx;
} else {
pDevCtx = pDevCtxParam;
if (pDevCtx == VP_NULL) {
#ifdef VP_DEBUG
/* Special case: We need a way of modifying this global variable. */
if (optionId == VP_OPTION_ID_DEBUG_SELECT) {
VP_API_FUNC(None, VP_NULL, ("VpSetOption(%s):", VpGetString_VpOptionIdType(VP_OPTION_ID_DEBUG_SELECT)));
#ifdef VP_CC_KWRAP
KWrapSetOption(VP_NULL, VP_NULL, VP_OPTION_ID_DEBUG_SELECT, value);
#endif
vpDebugSelectMask = *(uint32 *)value;
VP_API_EXIT(None, VP_NULL, "SetOption", VP_STATUS_SUCCESS);
return VP_STATUS_SUCCESS;
}
#endif
status = VP_STATUS_INVALID_ARG;
}
VP_API_FUNC(VpDevCtxType, pDevCtxParam, ("VpSetOption(%s):", VpGetString_VpOptionIdType(optionId)));
}
if (status == VP_STATUS_SUCCESS) {
status = VP_CALL_DEV_FUNC(SetOption, (pLineCtx, pDevCtxParam, optionId, value));
}
#if (VP_CC_DEBUG_SELECT & VP_DBG_API_FUNC)
if (singleLine) {
VP_API_EXIT(VpLineCtxType, pLineCtx, "SetOption", status);
} else {
VP_API_EXIT(VpDevCtxType, pDevCtx, "SetOption", status);
}
#endif
return status;
} /* VpSetOption() */
/**
* VpSoftReset()
* This function resets VCP without requiring another image load.
* See VP-API reference guide for more information.
*
* Preconditions:
* The device and must be created and initialized before calling this function.
*
* Postconditions:
* The part is reset.
*/
VpStatusType
VpSoftReset(
VpDevCtxType *pDevCtx)
{
VpStatusType status;
VP_API_ENTER(VpDevCtxType, pDevCtx, "SoftReset");
/* Basic argument checking */
if (pDevCtx == VP_NULL) {
status = VP_STATUS_INVALID_ARG;
} else {
status = VP_CALL_DEV_FUNC(SoftReset, (pDevCtx));
}
VP_API_EXIT(VpDevCtxType, pDevCtx, "SoftReset", status);
return status;
} /* VpSoftReset() */
/**
* VpRegisterDump()
* This function is used to dump the content of all device registers.
*
* Preconditions:
* Device context should be created.
*
* Postconditions:
* Debug output of "all" registers.
*/
VpStatusType
VpRegisterDump(
VpDevCtxType *pDevCtx)
{
VpStatusType status;
VP_API_ENTER(VpDevCtxType, pDevCtx, "RegisterDump");
/* Basic argument checking */
if (pDevCtx == VP_NULL) {
status = VP_STATUS_INVALID_ARG;
} else {
status = VP_CALL_DEV_FUNC(RegisterDump, (pDevCtx));
}
VP_API_EXIT(VpDevCtxType, pDevCtx, "RegisterDump", status);
return status;
} /* VpRegisterDump() */
/**
* VpDeviceIoAccessExt()
* This function is used to access device IO pins of the VTD. See VP-API-II
* documentation for more information about this function.
*
* Preconditions:
* Device/Line context should be created and initialized. For applicable
* devices bootload should be performed before calling the function.
*
* Postconditions:
* Reads/Writes from device IO pins.
*/
VpStatusType
VpDeviceIoAccessExt(
VpDevCtxType *pDevCtx,
VpDeviceIoAccessExtType *pDeviceIoAccess)
{
VpStatusType status;
VP_API_ENTER(VpDevCtxType, pDevCtx, "DeviceIoAccessExt");
/* Basic argument checking */
if ((pDevCtx == VP_NULL) || (pDeviceIoAccess == VP_NULL)) {
status = VP_STATUS_INVALID_ARG;
} else {
status = VP_CALL_DEV_FUNC(DeviceIoAccessExt, (pDevCtx, pDeviceIoAccess));
}
VP_API_EXIT(VpDevCtxType, pDevCtx, "DeviceIoAccessExt", status);
return status;
} /* VpDeviceIoAccessExt() */
/**
* VpDeviceIoAccess()
* This function is used to access device IO pins of the VTD. See VP-API-II
* documentation for more information about this function.
*
* Preconditions:
* Device/Line context should be created and initialized. For applicable
* devices bootload should be performed before calling the function.
*
* Postconditions:
* Reads/Writes from device IO pins.
*/
VpStatusType
VpDeviceIoAccess(
VpDevCtxType *pDevCtx,
VpDeviceIoAccessDataType *pDeviceIoData)
{
VpStatusType status;
VP_API_ENTER(VpDevCtxType, pDevCtx, "DeviceIoAccess");
/* Basic argument checking */
if (pDevCtx == VP_NULL) {
status = VP_STATUS_INVALID_ARG;
} else {
status = VP_CALL_DEV_FUNC(DeviceIoAccess, (pDevCtx, pDeviceIoData));
}
VP_API_EXIT(VpDevCtxType, pDevCtx, "DeviceIoAccess", status);
return status;
} /* VpDeviceIoAccess() */
/**
* VpCalLine()
* This function initiates a calibration operation for analog circuits
* associated with a given line. See VP-API reference guide for more
* information.
* Preconditions:
* The device and line context must be created and initialized before calling
* this function.
*
* Postconditions:
* This function generates an event upon completing the requested action.
*/
VpStatusType
VpCalLine(
VpLineCtxType *pLineCtx)
{
VpStatusType status;
VP_API_ENTER(VpLineCtxType, pLineCtx, "CalLine");
/* Basic argument checking */
if (pLineCtx == VP_NULL) {
status = VP_STATUS_INVALID_ARG;
} else {
VpDevCtxType *pDevCtx = pLineCtx->pDevCtx;
status = VP_CALL_DEV_FUNC(CalLine, (pLineCtx));
}
VP_API_EXIT(VpLineCtxType, pLineCtx, "CalLine", status);
return status;
} /* VpCalLine() */
/**
* VpSetRelayState()
* This function controls the state of VTD controlled relays. See VP-API-II
* documentation for more information about this function.
*
* Preconditions:
* Device/Line context should be created and initialized. For applicable
* devices bootload should be performed before calling the function.
*
* Postconditions:
* The indicated relay state is set for the given line.
*/
VpStatusType
VpSetRelayState(
VpLineCtxType *pLineCtx,
VpRelayControlType rState)
{
VpStatusType status;
VP_API_ENTER(VpLineCtxType, pLineCtx, "SetRelayState");
/* Basic argument checking */
if (pLineCtx == VP_NULL) {
status = VP_STATUS_INVALID_ARG;
} else {
VpDevCtxType *pDevCtx = pLineCtx->pDevCtx;
status = VP_CALL_DEV_FUNC(SetRelayState, (pLineCtx, rState));
}
VP_API_EXIT(VpLineCtxType, pLineCtx, "SetRelayState", status);
return status;
} /* VpSetRelayState() */
/**
* VpCal()
* This function runs a selected calibration option.
*
* Preconditions:
* The device and line context must be created and initialized before calling
* this function.
*
* Postconditions:
* This function generates an event upon completing the requested action. Event
* indicates if calibration was successfull and if results are available.
*/
VpStatusType
VpCal(
VpLineCtxType *pLineCtx,
VpCalType calType,
void *inputArgs)
{
VpStatusType status;
VP_API_ENTER(VpLineCtxType, pLineCtx, "Cal");
/* Basic argument checking */
if (pLineCtx == VP_NULL) {
status = VP_STATUS_INVALID_ARG;
} else {
VpDevCtxType *pDevCtx = pLineCtx->pDevCtx;
status = VP_CALL_DEV_FUNC(Cal, (pLineCtx, calType, inputArgs));
}
VP_API_EXIT(VpLineCtxType, pLineCtx, "Cal", status);
return status;
} /* VpCal() */
/*
* VpFreeRun()
* This function prepares the devices and lines for a system restart.
*
* Preconditions:
* This function should be called only after creating and initializing the
* device context and line context (atleast for those lines which need service).
*
* Postconditions:
* Device and lines are in a system restart "ready" state.
*/
VpStatusType
VpFreeRun(
VpDevCtxType *pDevCtx, /**< Pointer to device context for the
* device that will be initialized
*/
VpFreeRunModeType freeRunMode)
{
VpStatusType status;
VP_API_ENTER(VpDevCtxType, pDevCtx, "FreeRun");
/* Basic argument checking */
if (pDevCtx == VP_NULL) {
status = VP_STATUS_INVALID_ARG;
} else {
status = VP_CALL_DEV_FUNC(FreeRun, (pDevCtx, freeRunMode));
}
VP_API_EXIT(VpDevCtxType, pDevCtx, "FreeRun", status);
return status;
} /* VpFreeRun() */
/**
* VpInitCid()
* This function is used to send caller ID information. See VP-API reference
* guide for more information.
*
* Preconditions:
* The device and line context must be created and initialized before calling
* this function. This function needs to be called before placing the line in to
* ringing state.
*
* Postconditions:
* This function transmits the given CID information on the line (when the line
* is placed in the ringing state).
*/
VpStatusType
VpInitCid(
VpLineCtxType *pLineCtx,
uint8 length,
uint8p pCidData)
{
VpStatusType status;
VP_API_ENTER(VpLineCtxType, pLineCtx, "InitCid");
/* Basic argument checking */
if (pLineCtx == VP_NULL) {
status = VP_STATUS_INVALID_ARG;
} else {
VpDevCtxType *pDevCtx = pLineCtx->pDevCtx;
status = VP_CALL_DEV_FUNC(InitCid, (pLineCtx, length, pCidData));
}
VP_API_EXIT(VpLineCtxType, pLineCtx, "InitCid", status);
return status;
} /* VpInitCid() */
/**
* VpInitProfile()
* This function is used to initialize profile tables in VCP. See
* VP-API reference guide for more information.
*
* Preconditions:
* The device and line context must be created and initialized before calling
* this function.
*
* Postconditions:
* Stores the given profile at the specified index of the profile table.
*/
VpStatusType
VpInitProfile(
VpDevCtxType *pDevCtx,
VpProfileType type,
VpProfilePtrType pProfileIndex,
VpProfilePtrType pProfile)
{
VpStatusType status;
VP_API_ENTER(VpDevCtxType, pDevCtx, "InitProfile");
/* Basic argument checking */
if (pDevCtx == VP_NULL || pProfileIndex == VP_PTABLE_NULL) {
status = VP_STATUS_INVALID_ARG;
} else {
status = VP_CALL_DEV_FUNC(InitProfile, (pDevCtx, type, pProfileIndex, pProfile));
}
VP_API_EXIT(VpDevCtxType, pDevCtx, "InitProfile", status);
return status;
} /* VpInitProfile() */
/**
* VpLineIoAccess()
* This function is used to access the IO pins of the VTD associated with a
* particular line. See VP-API-II documentation for more information about
* this function.
*
* Preconditions:
* Device/Line context should be created and initialized. For applicable
* devices bootload should be performed before calling the function.
*
* Postconditions:
* Reads/Writes from line IO pins.
*/
VpStatusType
VpLineIoAccess(
VpLineCtxType *pLineCtx,
VpLineIoAccessType *pLineIoAccess,
uint16 handle)
{
VpStatusType status;
VP_API_ENTER(VpLineCtxType, pLineCtx, "LineIoAccess");
/* Basic argument checking */
if (pLineCtx == VP_NULL) {
status = VP_STATUS_INVALID_ARG;
} else {
VpDevCtxType *pDevCtx = pLineCtx->pDevCtx;
status = VP_CALL_DEV_FUNC(LineIoAccess, (pLineCtx, pLineIoAccess, handle));
}
VP_API_EXIT(VpLineCtxType, pLineCtx, "LineIoAccess", status);
return status;
} /* VpLineIoAccess() */
/**
* VpSendSignal()
* This function is used to send a signal on a line. The signal type is
* specified by the type parameter and the parameters associated with the signal
* type are specified by the structure pointer passed.
*
* Preconditions:
* Device/Line context should be created and initialized. For applicable
* devices bootload should be performed before calling the function.
*
* Postconditions:
* Applies a signal to the line.
*/
VpStatusType
VpSendSignal(
VpLineCtxType *pLineCtx,
VpSendSignalType signalType,
void *pSignalData)
{
VpStatusType status;
VP_API_ENTER(VpLineCtxType, pLineCtx, "SendSignal");
/* Basic argument checking */
if (pLineCtx == VP_NULL) {
status = VP_STATUS_INVALID_ARG;
} else {
VpDevCtxType *pDevCtx = pLineCtx->pDevCtx;
status = VP_CALL_DEV_FUNC(SendSignal, (pLineCtx, signalType, pSignalData));
}
VP_API_EXIT(VpLineCtxType, pLineCtx, "SendSignal", status);
return status;
} /* VpSendSignal() */
/**
* VpSetLineTone()
* This function is used to set a tone on a given line. See VP-API-II
* documentation for more information about this function.
*
* Preconditions:
* Device/Line context should be created and initialized. For applicable
* devices bootload should be performed before calling the function.
*
* Postconditions:
* Starts/Stops tone generation for a given line.
*/
VpStatusType
VpSetLineTone(
VpLineCtxType *pLineCtx,
VpProfilePtrType pToneProfile,
VpProfilePtrType pCadProfile,
VpDtmfToneGenType *pDtmfControl)
{
VpStatusType status;
VP_API_ENTER(VpLineCtxType, pLineCtx, "SetLineTone");
/* Basic argument checking */
if (pLineCtx == VP_NULL) {
status = VP_STATUS_INVALID_ARG;
} else {
VpDevCtxType *pDevCtx = pLineCtx->pDevCtx;
status = VP_CALL_DEV_FUNC(SetLineTone, (pLineCtx, pToneProfile, pCadProfile, pDtmfControl));
}
VP_API_EXIT(VpLineCtxType, pLineCtx, "SetLineTone", status);
return status;
} /* VpSetLineTone() */
/**
* VpLowLevelCmd()
* This function provides a by-pass mechanism for the VP-API. THE USE
* OF THIS FUNCTION BY THE APPLICATION CODE IS STRONGLY DISCOURAGED. THIS
* FUNCTION CALL BREAKS THE SYNCHRONIZATION BETWEEN THE VP-API AND THE
* VTD. See VP-API-II documentation for more information about this function.
*
* Preconditions:
* Device/Line context should be created and initialized. For applicable
* devices bootload should be performed before calling the function.
*
* Postconditions:
* Performs the indicated low-level command access.
*/
VpStatusType
VpLowLevelCmd(
VpLineCtxType *pLineCtx,
uint8 *pCmdData,
uint8 len,
uint16 handle)
{
VpStatusType status;
VP_API_ENTER(VpLineCtxType, pLineCtx, "LowLevelCmd");
/* Basic argument checking */
if (pLineCtx == VP_NULL) {
status = VP_STATUS_INVALID_ARG;
} else {
VpDevCtxType *pDevCtx = pLineCtx->pDevCtx;
status = VP_CALL_DEV_FUNC(LowLevelCmd, (pLineCtx, pCmdData, len, handle));
}
VP_API_EXIT(VpLineCtxType, pLineCtx, "LowLevelCmd", status);
return status;
} /* VpLowLevelCmd() */
/**
* This function provides generic timer functionality. Please see VP-API
* documentation for more information.
*
* Preconditions:
* This function assumes the passed line context is created and initialized.
*
* Postconditions:
* Starts or cancels a timer.
*/
VpStatusType
VpGenTimerCtrl(
VpLineCtxType *pLineCtx,
VpGenTimerCtrlType timerCtrl,
uint32 duration,
uint16 handle)
{
VpStatusType status;
VP_API_ENTER(VpLineCtxType, pLineCtx, "GenTimerCtrl");
/* Basic argument checking */
if (pLineCtx == VP_NULL) {
status = VP_STATUS_INVALID_ARG;
} else {
VpDevCtxType *pDevCtx = pLineCtx->pDevCtx;
status = VP_CALL_DEV_FUNC(GenTimerCtrl, (pLineCtx, timerCtrl, duration, handle));
}
VP_API_EXIT(VpLineCtxType, pLineCtx, "GenTimerCtrl", status);
return status;
} /* VpGenTimerCtrl() */
/**
* VpConfigLine()
* This function initializes the line with the AC, DC, and Ringing parameters
* passed. See VP-API reference guide for more information.
*
* Preconditions:
* The device and line context must be created and initialized also device must
* be initialized (via VpInitDevice).
*
* Postconditions:
* The line is initialized with the AC, DC, and Ringing parameters passed.
* DC and Ringing parameters apply to FXS lines only.
*/
VpStatusType
VpConfigLine(
VpLineCtxType *pLineCtx,
VpProfilePtrType pAcProfile,
VpProfilePtrType pDcFeedOrFxoCfgProfile,
VpProfilePtrType pRingProfile)
{
VpStatusType status;
VP_API_ENTER(VpLineCtxType, pLineCtx, "ConfigLine");
/* Basic argument checking */
if (pLineCtx == VP_NULL) {
status = VP_STATUS_INVALID_ARG;
} else {
VpDevCtxType *pDevCtx = pLineCtx->pDevCtx;
status = VP_CALL_DEV_FUNC(ConfigLine, (pLineCtx, pAcProfile, pDcFeedOrFxoCfgProfile, pRingProfile));
}
VP_API_EXIT(VpLineCtxType, pLineCtx, "ConfigLine", status);
return status;
} /* VpConfigLine() */
/**
* VpSetRelGain()
* This function adjusts the transmit and receive path relative gains. See
* VP-API-II documentation for more information about this function.
*
* Preconditions:
* Device/Line context should be created and initialized. For applicable
* devices bootload should be performed before calling the function.
*
* Postconditions:
* The requested relative gains will be applied.
*/
VpStatusType
VpSetRelGain(
VpLineCtxType *pLineCtx,
uint16 txLevel,
uint16 rxLevel,
uint16 handle)
{
VpStatusType status;
VP_API_ENTER(VpLineCtxType, pLineCtx, "SetRelGain");
/* Basic argument checking */
if (pLineCtx == VP_NULL) {
status = VP_STATUS_INVALID_ARG;
} else {
VpDevCtxType *pDevCtx = pLineCtx->pDevCtx;
status = VP_CALL_DEV_FUNC(SetRelGain, (pLineCtx, txLevel, rxLevel, handle));
}
VP_API_EXIT(VpLineCtxType, pLineCtx, "SetRelGain", status);
return status;
} /* VpSetRelGain() */
/**
* VpStartMeter()
* This function starts(can also abort) metering pulses on the line. See
* VP-API-II documentation for more information about this function.
*
* Preconditions:
* Device/Line context should be created and initialized. For applicable
* devices bootload should be performed before calling the function.
*
* Postconditions:
* Metering pulses are transmitted on the line.
*/
VpStatusType
VpStartMeter(
VpLineCtxType *pLineCtx,
uint16 onTime,
uint16 offTime,
uint16 numMeters)
{
VpStatusType status;
VP_API_ENTER(VpLineCtxType, pLineCtx, "StartMeter");
/* Basic argument checking */
if (pLineCtx == VP_NULL) {
status = VP_STATUS_INVALID_ARG;
} else {
VpDevCtxType *pDevCtx = pLineCtx->pDevCtx;
status = VP_CALL_DEV_FUNC(StartMeter, (pLineCtx, onTime, offTime, numMeters));
}
VP_API_EXIT(VpLineCtxType, pLineCtx, "StartMeter", status);
return status;
} /* VpStartMeter() */
/*
* VpBootLoad()
* This function is used to download the boot image to the device.
* This function must be called upon power on reset for VCP classes
* of devices to download boot image for these devices. This function is
* not applicable for CSLAC class of devices. See VP-API-II documentation
* for more information about this function.
*
* Preconditions:
* Device context must be created before calling this function.
*
* Postconditions:
* This function downloads the boot image to the part and configures the part
* to start excecuting the image that was downloaded.
*/
VpStatusType
VpBootLoad(
VpDevCtxType *pDevCtx,
VpBootStateType state,
VpImagePtrType pImageBuffer,
uint32 bufferSize,
VpScratchMemType *pScratchMem,
VpBootModeType validation)
{
VpStatusType status;
VP_API_ENTER(VpDevCtxType, pDevCtx, "BootLoad");
if (pDevCtx == VP_NULL) {
status = VP_STATUS_INVALID_ARG;
} else {
status = VP_CALL_DEV_FUNC(BootLoad, (pDevCtx, state, pImageBuffer, bufferSize, pScratchMem, validation));
}
VP_API_EXIT(VpDevCtxType, pDevCtx, "BootLoad", status);
return status;
} /* VpBootLoad() */
/*
* VpInitDevice()
* This function calibrates the device and initializes all lines (for which
* line context has been created and intialized) on the device with the AC, DC,
* and Ringing parameters passed. See VP-API reference guide for more
* information.
*
* Preconditions:
* This function should be called only after creating and initializing the
* device context and line context (atleast for those lines which need service).
*
* Postconditions:
* Device is calibrated and all lines (for whom line context has been created
* and initialized) associated with this device are initialized with the AC, DC,
* and Ringing Paramaters passed (DC and Ringing apply to FXS type lines only).
*/
VpStatusType
VpInitDevice(
VpDevCtxType *pDevCtx, /**< Pointer to device context for the
* device that will be initialized
*/
VpProfilePtrType pDevProfile, /**< Pointer to Device Profile */
VpProfilePtrType pAcProfile, /**< Pointer to AC Profile that is applied
* to all FXS lines on this device
*/
VpProfilePtrType pDcProfile, /**< Pointer to DC Profile that is applied
* to all FXS lines on this device
*/
VpProfilePtrType pRingProfile, /**< Pointer to Ringing Profile that is
* applied to all FXS lines on this device
*/
VpProfilePtrType pFxoAcProfile, /**< Pointer to AC Profile that is applied
* to all FXO lines on this device
*/
VpProfilePtrType pFxoCfgProfile)/**< Pointer to Config Profile that is
* applied to all FXO lines on this device
*/
{
VpStatusType status;
VP_API_ENTER(VpDevCtxType, pDevCtx, "InitDevice");
#if (VP_CC_DEBUG_SELECT & VP_DBG_INFO)
VpPrintVpApiVersion();
#endif
/* Basic argument checking */
if (pDevCtx == VP_NULL) {
VP_ERROR(VpDevCtxType, pDevCtx, ("InitDevice: Null Device Profile"));
status = VP_STATUS_INVALID_ARG;
} else {
status = VP_CALL_DEV_FUNC(InitDevice, (pDevCtx, pDevProfile, pAcProfile, pDcProfile, pRingProfile, pFxoAcProfile, pFxoCfgProfile));
}
VP_API_EXIT(VpDevCtxType, pDevCtx, "InitDevice", status);
return status;
} /* VpInitDevice() */
/**
* VpInitCustomTerm()
* This function is used to initialize the I/O control for a custom termination
* type.
*
* Preconditions:
* The device and line context must be created and initialized before calling
* this function. It is required to be called for term type CUSTOM before calling
* VpInitDevice()/VpInitLine().
*
* Postconditions:
* This function initializes I/O control parameters as per given profile. When
* called with device context only, all custom lines on the device are affected
* by the profile passed. When a line context only is passed, then only that
* line context is affected.
*/
VpStatusType
VpInitCustomTermType(
VpDevCtxType *pDevCtxParam,
VpLineCtxType *pLineCtx,
VpProfilePtrType pCustomTermProfile)
{
VpDevCtxType *pDevCtx;
VpStatusType status = VP_STATUS_SUCCESS;
bool singleLine = (pLineCtx != VP_NULL);
/* Basic argument checking */
if (singleLine) {
VP_API_ENTER(VpLineCtxType, pLineCtx, "InitCustomTermType");
if (pDevCtxParam != VP_NULL) {
status = VP_STATUS_INVALID_ARG;
}
pDevCtx = pLineCtx->pDevCtx;
} else {
VP_API_ENTER(VpDevCtxType, pDevCtxParam, "InitCustomTermType");
pDevCtx = pDevCtxParam;
if (pDevCtx == VP_NULL) {
status = VP_STATUS_INVALID_ARG;
}
}
if (status == VP_STATUS_SUCCESS) {
status = VP_CALL_DEV_FUNC(InitCustomTerm, (pDevCtxParam, pLineCtx, pCustomTermProfile));
}
#if (VP_CC_DEBUG_SELECT & VP_DBG_API_FUNC)
if (singleLine) {
VP_API_EXIT(VpLineCtxType, pLineCtx, "InitCustomTermType", status);
} else {
VP_API_EXIT(VpDevCtxType, pDevCtxParam, "InitCustomTermType", status);
}
#endif
return status;
} /* VpInitCustomTermType() */
/**
* VpInitMeter()
* This function is used to initialize metering parameters. See VP-API
* reference guide for more information.
*
* Preconditions:
* The device and line context must be created and initialized before calling
* this function. This function needs to be called before placing the line in to
* ringing state.
*
* Postconditions:
* This function initializes metering parameters as per given profile.
*/
VpStatusType
VpInitMeter(
VpLineCtxType *pLineCtx,
VpProfilePtrType pMeterProfile)
{
VpStatusType status;
VP_API_ENTER(VpLineCtxType, pLineCtx, "InitMeter");
/* Basic argument checking */
if (pLineCtx == VP_NULL) {
status = VP_STATUS_INVALID_ARG;
} else if (pMeterProfile == VP_NULL) {
/* If metering profile is null, there is nothing to do. */
status = VP_STATUS_SUCCESS;
} else {
VpDevCtxType *pDevCtx = pLineCtx->pDevCtx;
status = VP_CALL_DEV_FUNC(InitMeter, (pLineCtx, pMeterProfile));
}
VP_API_EXIT(VpLineCtxType, pLineCtx, "InitMeter", status);
return status;
} /* VpInitMeter() */
/**
* VpCalCodec()
* This function initiates a calibration operation for analog circuits
* associated with all the lines of a device. See VP-API reference guide for
* more information.
* Preconditions:
* The device and line context must be created and initialized before calling
* this function.
*
* Postconditions:
* This function generates an event upon completing the requested action.
*/
VpStatusType
VpCalCodec(
VpLineCtxType *pLineCtx,
VpDeviceCalType mode)
{
VpStatusType status;
VP_API_ENTER(VpLineCtxType, pLineCtx, "CalCodec");
/* Basic argument checking */
if (
(pLineCtx == VP_NULL) ||
((mode != VP_DEV_CAL_NOW) && (mode != VP_DEV_CAL_NBUSY))
) {
status = VP_STATUS_INVALID_ARG;
} else {
VpDevCtxType *pDevCtx = pLineCtx->pDevCtx;
status = VP_CALL_DEV_FUNC(CalCodec, (pLineCtx, mode));
}
VP_API_EXIT(VpLineCtxType, pLineCtx, "CalCodec", status);
return status;
} /* VpCalCodec() */
/**
* VpLowLevelCmd16()
* This function provides a by-pass mechanism for the VP-API. THE USE
* OF THIS FUNCTION BY THE APPLICATION CODE IS STRONGLY DISCOURAGED. THIS
* FUNCTION CALL BREAKS THE SYNCHRONIZATION BETWEEN THE VP-API AND THE
* VTD. See VP-API-II documentation for more information about this function.
*
* Preconditions:
* Device/Line context should be created and initialized. For applicable
* devices bootload should be performed before calling the function.
*
* Postconditions:
* Performs the indicated low-level command access.
*/
VpStatusType
VpLowLevelCmd16(
VpLineCtxType *pLineCtx,
VpLowLevelCmdType cmdType,
uint16 *writeWords,
uint8 numWriteWords,
uint8 numReadWords,
uint16 handle)
{
VpStatusType status;
VP_API_ENTER(VpLineCtxType, pLineCtx, "LowLevelCmd16");
/* Basic argument checking */
if (pLineCtx == VP_NULL) {
status = VP_STATUS_INVALID_ARG;
} else {
VpDevCtxType *pDevCtx = pLineCtx->pDevCtx;
status = VP_CALL_DEV_FUNC(LowLevelCmd16, (pLineCtx, cmdType, writeWords, numWriteWords, numReadWords, handle));
}
VP_API_EXIT(VpLineCtxType, pLineCtx, "LowLevelCmd16", status);
return status;
} /* VpLowLevelCmd16() */
/**
* VpStartMeter32Q()
* This function starts(can also abort) metering pulses on the line. See
* VP-API-II documentation for more information about this function. This
* version of the function supports 32-bit minDelay, onTime, and offTime
* parameters at 1ms increments.
*
* Preconditions:
* Device/Line context should be created and initialized. For applicable
* devices bootload should be performed before calling the function.
*
* Postconditions:
* Metering pulses are transmitted on the line.
*/
VpStatusType
VpStartMeter32Q(
VpLineCtxType *pLineCtx,
uint32 minDelay,
uint32 onTime,
uint32 offTime,
uint16 numMeters,
uint16 eventRate)
{
VpStatusType status;
VP_API_ENTER(VpLineCtxType, pLineCtx, "StartMeter32Q");
/* Basic argument checking */
if (pLineCtx == VP_NULL) {
status = VP_STATUS_INVALID_ARG;
} else {
VpDevCtxType *pDevCtx = pLineCtx->pDevCtx;
status = VP_CALL_DEV_FUNC(StartMeter32Q, (pLineCtx, minDelay, onTime, offTime, numMeters, eventRate));
}
VP_API_EXIT(VpLineCtxType, pLineCtx, "StartMeter32Q", status);
return status;
} /* VpStartMeter32Q() */
/**
* VpSetBFilter()
* This function enables the B-Filter and programs it with the B-Filter values
* provided in the ac profile, or disables the B-Filter.
*
* Preconditions:
* The line must be created and initialized before calling this function.
*
* Postconditions:
* The B-Filter is programmed to either disabled values or to the values passed
* in the AC-Profile.
*/
VpStatusType
VpSetBFilter(
VpLineCtxType *pLineCtx,
VpBFilterModeType bFiltMode,
VpProfilePtrType pAcProfile)
{
VpStatusType status;
VP_API_ENTER(VpLineCtxType, pLineCtx, "SetBFilter");
/* Basic argument checking */
if (
(pLineCtx == VP_NULL) ||
((bFiltMode == VP_BFILT_EN) && (pAcProfile == VP_NULL))
) {
status = VP_STATUS_INVALID_ARG;
} else {
VpDevCtxType *pDevCtx = pLineCtx->pDevCtx;
status = VP_CALL_DEV_FUNC(SetBFilter, (pLineCtx, bFiltMode, pAcProfile));
}
VP_API_EXIT(VpLineCtxType, pLineCtx, "SetBFilter", status);
return status;
} /* VpSetBFilter() */
/**
* VpSetBatteries()
* This function sets the battery values in the device, which for some devices
* may result in improved feed performance.
*
* Preconditions:
* The device must be created and initialized before calling this function.
*
* Postconditions:
* The device is programmed to use the battery values provided, or programmed
* to use measured battery voltages.
*/
VpStatusType
VpSetBatteries(
VpLineCtxType *pLineCtx,
VpBatteryModeType battMode,
VpBatteryValuesType *pBatt)
{
VpStatusType status;
VP_API_ENTER(VpLineCtxType, pLineCtx, "SetBatteries");
/* Basic argument checking */
if (
(pLineCtx == VP_NULL) ||
((battMode == VP_BATT_MODE_EN) && (pBatt == VP_NULL))
) {
status = VP_STATUS_INVALID_ARG;
} else {
VpDevCtxType *pDevCtx = pLineCtx->pDevCtx;
status = VP_CALL_DEV_FUNC(SetBatteries, (pLineCtx, battMode, pBatt));
}
VP_API_EXIT(VpLineCtxType, pLineCtx, "SetBatteries", status);
return status;
} /* VpSetBatteries() */