/** * 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() */