| /** \file vp_debug.c |
| * vp_debug.c |
| * |
| * This file contains the implementation of VP_DEBUG MACRO. |
| * |
| * Copyright (c) 2011, Microsemi |
| * |
| * $Revision: 1.1.2.1.14.1.8.3 $ |
| * $LastChangedDate: 2011-11-07 13:39:50 -0600 (Mon, 07 Nov 2011) $ |
| */ |
| |
| #include "vp_api_cfg.h" |
| #include "vp_api.h" |
| #include "vp_debug.h" |
| |
| #if defined (VP_CC_VCP2_SERIES) || defined (VP_CC_MELT_SERIES) |
| #include "hbi_common.h" |
| #endif |
| |
| uint32 vpDebugSelectMask = VP_OPTION_DEFAULT_DEBUG_SELECT; |
| |
| /** |
| * 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() */ |
| |
| /** |
| * VpObjectDump() |
| * This function is used to dump the contents of a Device Context and Device |
| * Object (if pDevCtx != VP_NULL) and/or the contents of a Line Context and Line |
| * Object (if pLineCtx != VP_NULL). Either pDevCtx or pLineCtx must be VP_NULL, |
| * but not both. |
| * |
| * Preconditions: |
| * VP_CC_DEBUG_SELECT must include VP_DBG_ERROR for this function to be |
| * compiled in. |
| * |
| * Postconditions: |
| * Debug output of "all" registers. |
| */ |
| VpStatusType |
| VpObjectDump( |
| VpLineCtxType *pLineCtx, |
| VpDevCtxType *pDevCtx) |
| { |
| VpStatusType status = VP_STATUS_FUNC_NOT_SUPPORTED; |
| |
| #if (VP_CC_DEBUG_SELECT & (VP_DBG_API_FUNC | VP_DBG_INFO)) |
| bool singleLine = (pLineCtx != VP_NULL); |
| #endif |
| |
| #if (VP_CC_DEBUG_SELECT & VP_DBG_API_FUNC) |
| if (singleLine) { |
| VP_API_ENTER(VpLineCtxType, pLineCtx, "ObjectDump"); |
| } else { |
| VP_API_ENTER(VpDevCtxType, pDevCtx, "ObjectDump"); |
| } |
| #endif |
| |
| /* Basic argument checking */ |
| if ( |
| ((pDevCtx == VP_NULL) && (pLineCtx == VP_NULL)) || |
| ((pDevCtx != VP_NULL) && (pLineCtx != VP_NULL)) |
| ) { |
| status = VP_STATUS_INVALID_ARG; |
| } else { |
| |
| #if (VP_CC_DEBUG_SELECT & VP_DBG_INFO) |
| VpSysDebugPrintf("\npDevCtx = %lu\n", (unsigned long)pDevCtx); |
| VpSysDebugPrintf("pLineCtx = %lu\n", (unsigned long)pLineCtx); |
| |
| /* Contexts are device-independent, so code for displaying them is |
| included here. */ |
| if (singleLine) { |
| VpSysDebugPrintf("\nDumping Line Context:\n"); |
| VpSysDebugPrintf("\tpLineCtx->pDevCtx = %lu\n", (unsigned long)(pLineCtx->pDevCtx)); |
| VpSysDebugPrintf("\tpLineCtx->pLineObj = %lu\n", (unsigned long)(pLineCtx->pLineObj)); |
| pDevCtx = pLineCtx->pDevCtx; |
| status = VP_CALL_DEV_FUNC(ObjectDump, (pLineCtx, VP_NULL)); |
| } else { |
| int line; |
| VpSysDebugPrintf("\nDumping Device Context:\n"); |
| VpSysDebugPrintf("\tpDevCtx->deviceType = %d\n", (int)(pDevCtx->deviceType)); |
| VpSysDebugPrintf("\tpDevCtx->pDevObj = %lu\n", (unsigned long)(pDevCtx->pDevObj)); |
| VpSysDebugPrintf("\tpDevCtx->pLineCtx[%d] = {", VP_MAX_LINES_PER_DEVICE); |
| for (line = 0; line < VP_MAX_LINES_PER_DEVICE; line++) { |
| VpSysDebugPrintf(" %lu", (unsigned long)(pDevCtx->pLineCtx[line])); |
| } |
| VpSysDebugPrintf(" }\n"); |
| status = VP_CALL_DEV_FUNC(ObjectDump, (VP_NULL, pDevCtx)); |
| } |
| #endif /* (VP_CC_DEBUG_SELECT & VP_DBG_INFO) */ |
| |
| } |
| |
| #if (VP_CC_DEBUG_SELECT & VP_DBG_API_FUNC) |
| if (singleLine) { |
| VP_API_EXIT(VpLineCtxType, pLineCtx, "ObjectDump", status); |
| } else { |
| VP_API_EXIT(VpDevCtxType, pDevCtx, "ObjectDump", status); |
| } |
| #endif |
| |
| return status; |
| } /* VpObjectDump() */ |
| |
| #ifdef VP_DEBUG |
| |
| static bool |
| DeviceDebugEnabled( |
| uint32 debugSelectMask, |
| char *msgTypeStr, |
| VpDeviceIdType deviceId) |
| { |
| if (!debugSelectMask) |
| return FALSE; |
| |
| /* Display the message type and device ID. */ |
| VpSysDebugPrintf(msgTypeStr); |
| VP_PRINT_DEVICE_ID(deviceId); |
| VpSysDebugPrintf(": "); |
| return TRUE; |
| } |
| |
| static bool |
| LineDebugEnabled( |
| uint32 debugSelectMask, |
| char *msgTypeStr, |
| VpLineIdType lineId) |
| { |
| if (!debugSelectMask) |
| return FALSE; |
| |
| /* Display the message type and line ID. */ |
| VpSysDebugPrintf(msgTypeStr); |
| VP_PRINT_LINE_ID((lineId)); |
| VpSysDebugPrintf(": "); |
| return TRUE; |
| } |
| |
| /* This function is a "fallback" for the case where an object was expected, but |
| VP_NULL was passed. */ |
| static bool |
| NULLDebugEnabled( |
| uint32 msgType, |
| char *errorMsg, |
| char *msgTypeStr) |
| { |
| if (msgType & vpDebugSelectMask) { |
| VpSysDebugPrintf(color_fg(red) "%s", errorMsg); |
| } |
| return VpDebugEnabled_None(msgType, msgTypeStr, VP_NULL); |
| } |
| |
| #if defined (VP_CC_VCP2_SERIES) |
| bool |
| VpDebugEnabled_VpVcp2DeviceObjectType( |
| uint32 msgType, |
| char *msgTypeStr, |
| VpVcp2DeviceObjectType *pDevObj) |
| { |
| uint32 debugSelectMask; |
| VpDeviceIdType deviceId; |
| |
| if (pDevObj == VP_NULL) { |
| return NULLDebugEnabled(msgType, "(pDevObj == VP_NULL) ", msgTypeStr); |
| } |
| |
| debugSelectMask = pDevObj->debugSelectMask; |
| deviceId = pDevObj->deviceId; |
| VP_ASSERT(pDevObj != VP_NULL); |
| return DeviceDebugEnabled(msgType & debugSelectMask, msgTypeStr, deviceId); |
| } |
| |
| bool |
| VpDebugEnabled_VpVcp2LineObjectType( |
| uint32 msgType, |
| char *msgTypeStr, |
| VpVcp2LineObjectType *pLineObj) |
| { |
| uint32 debugSelectMask; |
| VpLineIdType lineId; |
| |
| if (pLineObj == VP_NULL) { |
| return NULLDebugEnabled(msgType, "(pLineObj == VP_NULL) ", msgTypeStr); |
| } |
| |
| debugSelectMask = pLineObj->debugSelectMask; |
| lineId = pLineObj->lineId; |
| VP_ASSERT(pLineObj != VP_NULL); |
| return LineDebugEnabled(msgType & debugSelectMask, msgTypeStr, lineId); |
| } |
| #endif /* VP_CC_VCP2_SERIES*/ |
| |
| #if defined (VP_CC_MELT_SERIES) |
| bool |
| VpDebugEnabled_VpMeltDeviceObjectType( |
| uint32 msgType, |
| char *msgTypeStr, |
| VpMeltDeviceObjectType *pDevObj) |
| { |
| uint32 debugSelectMask; |
| VpDeviceIdType deviceId; |
| |
| if (pDevObj == VP_NULL) { |
| return NULLDebugEnabled(msgType, "(pDevObj == VP_NULL) ", msgTypeStr); |
| } |
| |
| debugSelectMask = pDevObj->debugSelectMask; |
| deviceId = pDevObj->deviceId; |
| VP_ASSERT(pDevObj != VP_NULL); |
| return DeviceDebugEnabled(msgType & debugSelectMask, msgTypeStr, deviceId); |
| } |
| |
| bool |
| VpDebugEnabled_VpMeltLineObjectType( |
| uint32 msgType, |
| char *msgTypeStr, |
| VpMeltLineObjectType *pLineObj) |
| { |
| uint32 debugSelectMask; |
| VpLineIdType lineId; |
| |
| if (pLineObj == VP_NULL) { |
| return NULLDebugEnabled(msgType, "(pLineObj == VP_NULL) ", msgTypeStr); |
| } |
| |
| debugSelectMask = pLineObj->debugSelectMask; |
| lineId = pLineObj->lineId; |
| VP_ASSERT(pLineObj != VP_NULL); |
| return LineDebugEnabled(msgType & debugSelectMask, msgTypeStr, lineId); |
| } |
| #endif /* VP_CC_MELT_SERIES */ |
| |
| #ifdef VP_CC_890_SERIES |
| bool |
| VpDebugEnabled_Vp890DeviceObjectType( |
| uint32 msgType, |
| char *msgTypeStr, |
| Vp890DeviceObjectType *pDevObj) |
| { |
| uint32 debugSelectMask; |
| VpDeviceIdType deviceId; |
| |
| if (pDevObj == VP_NULL) { |
| return NULLDebugEnabled(msgType, "(pDevObj == VP_NULL) ", msgTypeStr); |
| } |
| |
| debugSelectMask = pDevObj->debugSelectMask; |
| deviceId = pDevObj->deviceId; |
| VP_ASSERT(pDevObj != VP_NULL); |
| return DeviceDebugEnabled(msgType & debugSelectMask, msgTypeStr, deviceId); |
| } |
| |
| bool |
| VpDebugEnabled_Vp890LineObjectType( |
| uint32 msgType, |
| char *msgTypeStr, |
| Vp890LineObjectType *pLineObj) |
| { |
| uint32 debugSelectMask; |
| VpLineIdType lineId; |
| |
| if (pLineObj == VP_NULL) { |
| return NULLDebugEnabled(msgType, "(pLineObj == VP_NULL) ", msgTypeStr); |
| } |
| |
| debugSelectMask = pLineObj->debugSelectMask; |
| lineId = pLineObj->lineId; |
| VP_ASSERT(pLineObj != VP_NULL); |
| return LineDebugEnabled(msgType & debugSelectMask, msgTypeStr, lineId); |
| } |
| #endif /* VP_CC_890_SERIES */ |
| |
| #ifdef VP_CC_880_SERIES |
| bool |
| VpDebugEnabled_Vp880DeviceObjectType( |
| uint32 msgType, |
| char *msgTypeStr, |
| Vp880DeviceObjectType *pDevObj) |
| { |
| uint32 debugSelectMask; |
| VpDeviceIdType deviceId; |
| |
| if (pDevObj == VP_NULL) { |
| return NULLDebugEnabled(msgType, "(pDevObj == VP_NULL) ", msgTypeStr); |
| } |
| |
| debugSelectMask = pDevObj->debugSelectMask; |
| deviceId = pDevObj->deviceId; |
| VP_ASSERT(pDevObj != VP_NULL); |
| return DeviceDebugEnabled(msgType & debugSelectMask, msgTypeStr, deviceId); |
| } |
| |
| bool |
| VpDebugEnabled_Vp880LineObjectType( |
| uint32 msgType, |
| char *msgTypeStr, |
| Vp880LineObjectType *pLineObj) |
| { |
| uint32 debugSelectMask; |
| VpLineIdType lineId; |
| |
| if (pLineObj == VP_NULL) { |
| return NULLDebugEnabled(msgType, "(pLineObj == VP_NULL) ", msgTypeStr); |
| } |
| |
| debugSelectMask = pLineObj->debugSelectMask; |
| lineId = pLineObj->lineId; |
| VP_ASSERT(pLineObj != VP_NULL); |
| return LineDebugEnabled(msgType & debugSelectMask, msgTypeStr, lineId); |
| } |
| #endif /* VP_CC_880_SERIES */ |
| |
| #ifdef VP_CC_580_SERIES |
| bool |
| VpDebugEnabled_Vp580DeviceObjectType( |
| uint32 msgType, |
| char *msgTypeStr, |
| Vp580DeviceObjectType *pDevObj) |
| { |
| uint32 debugSelectMask; |
| VpDeviceIdType deviceId; |
| |
| if (pDevObj == VP_NULL) { |
| return NULLDebugEnabled(msgType, "(pDevObj == VP_NULL) ", msgTypeStr); |
| } |
| |
| debugSelectMask = pDevObj->debugSelectMask; |
| deviceId = pDevObj->deviceId; |
| VP_ASSERT(pDevObj != VP_NULL); |
| return DeviceDebugEnabled(msgType & debugSelectMask, msgTypeStr, deviceId); |
| } |
| |
| bool |
| VpDebugEnabled_Vp580LineObjectType( |
| uint32 msgType, |
| char *msgTypeStr, |
| Vp580LineObjectType *pLineObj) |
| { |
| uint32 debugSelectMask; |
| VpLineIdType lineId; |
| |
| if (pLineObj == VP_NULL) { |
| return NULLDebugEnabled(msgType, "(pLineObj == VP_NULL) ", msgTypeStr); |
| } |
| |
| debugSelectMask = pLineObj->debugSelectMask; |
| lineId = pLineObj->lineId; |
| VP_ASSERT(pLineObj != VP_NULL); |
| return LineDebugEnabled(msgType & debugSelectMask, msgTypeStr, lineId); |
| } |
| #endif /* VP_CC_580_SERIES */ |
| |
| #ifdef VP_CC_792_SERIES |
| static bool |
| VpDebugEnabled_Vp792DeviceObjectType( |
| uint32 msgType, |
| char *msgTypeStr, |
| Vp792DeviceObjectType *pDevObj) |
| { |
| uint32 debugSelectMask; |
| VpDeviceIdType deviceId; |
| |
| if (pDevObj == VP_NULL) { |
| return NULLDebugEnabled(msgType, "(pDevObj == VP_NULL) ", msgTypeStr); |
| } |
| |
| debugSelectMask = pDevObj->options.debugSelect; |
| deviceId = pDevObj->deviceId; |
| VP_ASSERT(pDevObj != VP_NULL); |
| return DeviceDebugEnabled(msgType & debugSelectMask, msgTypeStr, deviceId); |
| } |
| |
| static bool |
| VpDebugEnabled_Vp792LineObjectType( |
| uint32 msgType, |
| char *msgTypeStr, |
| Vp792LineObjectType *pLineObj) |
| { |
| uint32 debugSelectMask; |
| VpLineIdType lineId; |
| |
| if (pLineObj == VP_NULL) { |
| return NULLDebugEnabled(msgType, "(pLineObj == VP_NULL) ", msgTypeStr); |
| } |
| |
| debugSelectMask = pLineObj->options.debugSelect; |
| lineId = pLineObj->lineId; |
| VP_ASSERT(pLineObj != VP_NULL); |
| return LineDebugEnabled(msgType & debugSelectMask, msgTypeStr, lineId); |
| } |
| #endif /* VP_CC_792_SERIES */ |
| |
| bool |
| VpDebugEnabled_VpDeviceIdType( |
| uint32 msgType, |
| char *msgTypeStr, |
| VpDeviceIdType *pDeviceId) |
| { |
| VP_ASSERT(pDeviceId != VP_NULL); |
| return DeviceDebugEnabled(msgType & vpDebugSelectMask, msgTypeStr, *pDeviceId); |
| } |
| |
| bool |
| VpDebugEnabled_VpLineIdType( |
| uint32 msgType, |
| char *msgTypeStr, |
| VpLineIdType *pLineId) |
| { |
| VP_ASSERT(pLineId != VP_NULL); |
| return LineDebugEnabled(msgType & vpDebugSelectMask, msgTypeStr, *pLineId); |
| } |
| |
| |
| /* |
| * This function returns TRUE if the specified message type is enabled for the specified device. |
| * As a side effect, it displays the message type and device ID. |
| */ |
| bool |
| VpDebugEnabled_VpDevCtxType( |
| uint32 msgType, |
| char *msgTypeStr, |
| VpDevCtxType *pDevCtx) |
| { |
| if (pDevCtx == VP_NULL) { |
| return NULLDebugEnabled(msgType, "(pDevCtx == VP_NULL) ", msgTypeStr); |
| } |
| |
| switch (pDevCtx->deviceType) { |
| |
| #ifdef VP_CC_VCP2_SERIES |
| case VP_DEV_VCP2_SERIES: |
| return VpDebugEnabled_VpVcp2DeviceObjectType(msgType, msgTypeStr, pDevCtx->pDevObj); |
| #endif |
| #ifdef VP_CC_MELT_SERIES |
| case VP_DEV_MELT_SERIES: |
| return VpDebugEnabled_VpMeltDeviceObjectType(msgType, msgTypeStr, pDevCtx->pDevObj); |
| #endif |
| #ifdef VP_CC_890_SERIES |
| case VP_DEV_890_SERIES: |
| return VpDebugEnabled_Vp890DeviceObjectType(msgType, msgTypeStr, pDevCtx->pDevObj); |
| #endif |
| #ifdef VP_CC_880_SERIES |
| case VP_DEV_880_SERIES: |
| return VpDebugEnabled_Vp880DeviceObjectType(msgType, msgTypeStr, pDevCtx->pDevObj); |
| #endif |
| #ifdef VP_CC_792_SERIES |
| case VP_DEV_792_SERIES: |
| return VpDebugEnabled_Vp792DeviceObjectType(msgType, msgTypeStr, pDevCtx->pDevObj); |
| #endif |
| default: |
| /* For other device types (for which we are still using VP_DOUT) |
| use the global debug select mask. */ |
| return VpDebugEnabled_None(msgType, msgTypeStr, (void *)0); |
| } |
| } |
| |
| /* |
| * This function returns TRUE if the specified message type is enabled for the specified line. |
| * As a side effect, it displays the message type and line ID. |
| */ |
| bool |
| VpDebugEnabled_VpLineCtxType( |
| uint32 msgType, |
| char *msgTypeStr, |
| VpLineCtxType *pLineCtx) |
| { |
| if (pLineCtx == VP_NULL) { |
| return NULLDebugEnabled(msgType, "(pLineCtx == VP_NULL) ", msgTypeStr); |
| } |
| |
| if (pLineCtx->pDevCtx == VP_NULL) { |
| return NULLDebugEnabled(msgType, "(pLineCtx->pDevCtx == VP_NULL) ", msgTypeStr); |
| } |
| |
| switch (pLineCtx->pDevCtx->deviceType) { |
| |
| #ifdef VP_CC_VCP2_SERIES |
| case VP_DEV_VCP2_SERIES: |
| return VpDebugEnabled_VpVcp2LineObjectType(msgType, msgTypeStr, pLineCtx->pLineObj); |
| #endif |
| #ifdef VP_CC_MELT_SERIES |
| case VP_DEV_MELT_SERIES: |
| return VpDebugEnabled_VpMeltLineObjectType(msgType, msgTypeStr, pLineCtx->pLineObj); |
| #endif |
| #ifdef VP_CC_890_SERIES |
| case VP_DEV_890_SERIES: |
| return VpDebugEnabled_Vp890LineObjectType(msgType, msgTypeStr, pLineCtx->pLineObj); |
| #endif |
| #ifdef VP_CC_880_SERIES |
| case VP_DEV_880_SERIES: |
| return VpDebugEnabled_Vp880LineObjectType(msgType, msgTypeStr, pLineCtx->pLineObj); |
| #endif |
| #ifdef VP_CC_580_SERIES |
| case VP_DEV_580_SERIES: |
| return VpDebugEnabled_Vp580LineObjectType(msgType, msgTypeStr, pLineCtx->pLineObj); |
| #endif |
| #ifdef VP_CC_792_SERIES |
| case VP_DEV_792_SERIES: |
| return VpDebugEnabled_Vp792LineObjectType(msgType, msgTypeStr, pLineCtx->pLineObj); |
| #endif |
| default: |
| /* For other device types (for which we are still using VP_DOUT) |
| use the global debug select mask. */ |
| return VpDebugEnabled_None(msgType, msgTypeStr, (void *)0); |
| } |
| } |
| |
| bool |
| VpDebugEnabled_None( |
| uint32 msgType, |
| char *msgTypeStr, |
| void *nothing) |
| { |
| if (!(msgType & vpDebugSelectMask)) |
| return FALSE; |
| |
| VpSysDebugPrintf(msgTypeStr); |
| VpSysDebugPrintf(": "); |
| return TRUE; |
| } |
| |
| #ifdef VP_DEBUG |
| static const char * |
| VpGetEnumString( |
| const char *strTable[], |
| int numStrings, |
| int value) |
| { |
| static char buf[7] = "0x0000"; /* not reentrant */ |
| static const char hex[16] = "0123456789ABCD"; |
| |
| if ((value < 0) || (value >= numStrings) || (strTable[value] == VP_NULL)) { |
| |
| /* Can't find a string for the requested value. */ |
| buf[5] = hex[value & 0xF]; |
| value >>= 4; |
| buf[4] = hex[value & 0xF]; |
| value >>= 4; |
| buf[3] = hex[value & 0xF]; |
| value >>= 4; |
| buf[2] = hex[value & 0xF]; |
| return buf; |
| } |
| |
| /* Found the requested string in the table. */ |
| return strTable[value]; |
| } |
| #endif /* VP_DEBUG */ |
| |
| #if (VP_CC_DEBUG_SELECT & (VP_DBG_API_FUNC | VP_DBG_EVENT)) |
| const char * |
| VpGetString_VpStatusType( |
| VpStatusType status) |
| { |
| static const char *strTable[VP_STATUS_NUM_TYPES] = { |
| "SUCCESS", |
| "FAILURE", |
| "FUNC_NOT_SUPPORTED", |
| "INVALID_ARG", |
| "MAILBOX_BUSY", |
| "ERR_VTD_CODE", |
| "OPTION_NOT_SUPPORTED", |
| "ERR_VERIFY", |
| "DEVICE_BUSY", |
| "MAILBOX_EMPTY", |
| "ERR_MAILBOX_DATA", |
| "ERR_HBI", |
| "ERR_IMAGE", |
| "IN_CRTCL_SECTN", |
| "DEV_NOT_INITIALIZED", |
| "ERR_PROFILE", |
| "16", |
| "CUSTOM_TERM_NOT_CFG", |
| "DEDICATED_PINS", |
| "INVALID_LINE", |
| "LINE_NOT_CONFIG", |
| "INPUT_PARAM_OOR" |
| }; |
| |
| /* Make sure we update the above table when we update VpStatusType: */ |
| VP_ASSERT(VP_STATUS_NUM_TYPES == 22); |
| |
| return VpGetEnumString(strTable, VP_STATUS_NUM_TYPES, (int)status); |
| } |
| #endif /* (VP_CC_DEBUG_SELECT & (VP_DBG_API_FUNC | VP_DBG_EVENT)) */ |
| |
| #if (VP_CC_DEBUG_SELECT & VP_DBG_API_FUNC) |
| const char * |
| VpGetString_VpOptionIdType( |
| VpOptionIdType optionId) |
| { |
| static const char *strTable[VP_NUM_OPTION_IDS] = { |
| "VP_DEVICE_OPTION_ID_PULSE", /* only differs by prefix */ |
| "CRITICAL_FLT", |
| "ZERO_CROSS", |
| "RAMP2STBY", |
| "PULSE_MODE", |
| "TIMESLOT", |
| "CODEC", |
| "PCM_HWY", |
| "LOOPBACK", |
| "LINE_STATE", |
| "EVENT_MASK", |
| VP_NULL, |
| "RING_CNTRL", |
| VP_NULL, |
| "DTMF_MODE", |
| "DEVICE_IO", |
| VP_NULL, |
| "PCM_TXRX_CNTRL", |
| "PULSE2", |
| "LINE_IO_CFG", |
| "DEV_IO_CFG", |
| "DTMF_SPEC", |
| "PARK_MODE", |
| "DCFEED_SLOPE", |
| "SWITCHER_CTRL", |
| "HOOK_DETECT_MODE", |
| VP_NULL, |
| VP_NULL, |
| VP_NULL, |
| VP_NULL, |
| VP_NULL, |
| VP_NULL, |
| VP_NULL, |
| VP_NULL, |
| VP_NULL, |
| VP_NULL, |
| "VP_OPTION_ID_PULSE", /* only differs by prefix */ |
| "DEBUG_SELECT", |
| "ABS_GAIN", |
| "PCM_SIG_CTL", |
| "LINESTATE_CTL_MODE" |
| }; |
| |
| /* Make sure we update the above table when we update VpOptionIdType: */ |
| VP_ASSERT(VP_NUM_OPTION_IDS == 0x29); |
| |
| return VpGetEnumString(strTable, VP_NUM_OPTION_IDS, (int)optionId); |
| } |
| #endif /* (VP_CC_DEBUG_SELECT & VP_DBG_API_FUNC) */ |
| |
| #ifdef VP_DEBUG |
| const char * |
| VpGetString_VpProfileType( |
| VpProfileType profType) |
| { |
| static const char *strTable[VP_NUM_PROFILE_TYPES] = { |
| "DEVICE", |
| "AC", |
| "DC", |
| "RING", |
| "RINGCAD", |
| "TONE", |
| "METER", |
| "CID", |
| "TONECAD", |
| "FXO_CONFIG", |
| "CUSTOM_TERM", |
| "CAL" |
| }; |
| |
| /* Make sure we update the above table when we update VpProfileType: */ |
| VP_ASSERT(VP_NUM_PROFILE_TYPES == 12); |
| |
| return VpGetEnumString(strTable, VP_NUM_PROFILE_TYPES, (int)profType); |
| } |
| #endif /* VP_DEBUG */ |
| |
| #if (VP_CC_DEBUG_SELECT & VP_DBG_EVENT) |
| void VpDisplayEvent( |
| VpEventType *pEvent) |
| { |
| typedef struct { |
| VpEventCategoryType category; |
| uint16 id; |
| char *nameStr; |
| bool hasEventData; |
| bool hasParmHandle; |
| } VpEventInfo; |
| |
| static const VpEventInfo eventInfoTable[] = { |
| { VP_EVCAT_FAULT, VP_DEV_EVID_BAT_FLT, "BAT_FLT", TRUE, FALSE }, |
| { VP_EVCAT_FAULT, VP_DEV_EVID_CLK_FLT, "CLK_FLT", TRUE, FALSE }, |
| { VP_EVCAT_FAULT, VP_LINE_EVID_THERM_FLT, "THERM_FLT", TRUE, FALSE }, |
| { VP_EVCAT_FAULT, VP_LINE_EVID_DC_FLT, "DC_FLT", TRUE, FALSE }, |
| { VP_EVCAT_FAULT, VP_LINE_EVID_AC_FLT, "AC_FLT", TRUE, FALSE }, |
| { VP_EVCAT_FAULT, VP_LINE_EVID_SYNC_FLT, "SYNC_FLT", FALSE, FALSE }, |
| { VP_EVCAT_FAULT, VP_LINE_EVID_RES_LEAK_FLT, "RES_LEAK_FLT", TRUE, TRUE }, |
| { VP_EVCAT_FAULT, VP_LINE_EVID_SEAL_CUR_FLT, "SEAL_CURRENT_FLT", TRUE, FALSE }, |
| { VP_EVCAT_FAULT, VP_DEV_EVID_WDT_FLT, "WDT_FLT", FALSE, FALSE }, |
| { VP_EVCAT_FAULT, VP_DEV_EVID_EVQ_OFL_FLT, "EVQ_OFL_FLT", FALSE, FALSE }, |
| { VP_EVCAT_FAULT, VP_DEV_EVID_SYSTEM_FLT, "SYSTEM_FLT", TRUE, FALSE }, |
| { VP_EVCAT_SIGNALING, VP_LINE_EVID_HOOK_OFF, "HOOK_OFF", FALSE, TRUE }, |
| { VP_EVCAT_SIGNALING, VP_LINE_EVID_HOOK_ON, "HOOK_ON", FALSE, TRUE }, |
| { VP_EVCAT_SIGNALING, VP_LINE_EVID_GKEY_DET, "GKEY_DET", FALSE, TRUE }, |
| { VP_EVCAT_SIGNALING, VP_LINE_EVID_GKEY_REL, "GKEY_REL", FALSE, FALSE }, |
| { VP_EVCAT_SIGNALING, VP_LINE_EVID_FLASH, "FLASH", FALSE, TRUE }, |
| { VP_EVCAT_SIGNALING, VP_LINE_EVID_STARTPULSE, "STARTPULSE", FALSE, TRUE }, |
| { VP_EVCAT_SIGNALING, VP_LINE_EVID_DTMF_DIG, "DTMF_DIG", TRUE, FALSE }, |
| { VP_EVCAT_SIGNALING, VP_LINE_EVID_PULSE_DIG, "PULSE_DIG", TRUE, TRUE }, |
| { VP_EVCAT_SIGNALING, VP_LINE_EVID_MTONE, "MTONE", FALSE, FALSE }, |
| { VP_EVCAT_SIGNALING, VP_DEV_EVID_TS_ROLLOVER, "TS_ROLLOVER", FALSE, FALSE }, |
| { VP_EVCAT_SIGNALING, VP_LINE_EVID_US_TONE_DETECT, "US_TONE_DETECT", TRUE, TRUE }, |
| { VP_EVCAT_SIGNALING, VP_LINE_EVID_DS_TONE_DETECT, "DS_TONE_DETECT", TRUE, TRUE }, |
| { VP_EVCAT_SIGNALING, VP_DEV_EVID_SEQUENCER, "SEQUENCER", TRUE, TRUE }, |
| { VP_EVCAT_SIGNALING, VP_LINE_EVID_BREAK_MAX, "BREAK_MAX", TRUE, TRUE }, |
| { VP_EVCAT_SIGNALING, VP_LINE_EVID_EXTD_FLASH, "EXTD_FLASH", FALSE, TRUE }, |
| { VP_EVCAT_SIGNALING, VP_LINE_EVID_HOOK_PREQUAL, "HOOK_PREQUAL", TRUE, TRUE }, |
| { VP_EVCAT_RESPONSE, VP_DEV_EVID_BOOT_CMP, "BOOT_CMP", TRUE, FALSE }, |
| { VP_EVCAT_RESPONSE, VP_LINE_EVID_LLCMD_TX_CMP, "LLCMD_TX_CMP", FALSE, FALSE }, |
| { VP_EVCAT_RESPONSE, VP_LINE_EVID_LLCMD_RX_CMP, "LLCMD_RX_CMP", FALSE, TRUE }, |
| { VP_EVCAT_RESPONSE, VP_DEV_EVID_DNSTR_MBOX, "DNSTR_MBOX", FALSE, FALSE }, |
| { VP_EVCAT_RESPONSE, VP_LINE_EVID_RD_OPTION, "RD_OPTION", TRUE, TRUE }, |
| { VP_EVCAT_RESPONSE, VP_LINE_EVID_RD_LOOP, "RD_LOOP", FALSE, TRUE }, |
| { VP_EVCAT_RESPONSE, VP_EVID_CAL_CMP, "CAL_CMP", FALSE, FALSE }, |
| { VP_EVCAT_RESPONSE, VP_EVID_CAL_BUSY, "CAL_BUSY", FALSE, FALSE }, |
| { VP_EVCAT_RESPONSE, VP_LINE_EVID_GAIN_CMP, "GAIN_CMP", FALSE, TRUE }, |
| { VP_EVCAT_RESPONSE, VP_DEV_EVID_DEV_INIT_CMP, "DEV_INIT_CMP", TRUE, FALSE }, |
| { VP_EVCAT_RESPONSE, VP_LINE_EVID_LINE_INIT_CMP, "LINE_INIT_CMP", FALSE, FALSE }, |
| { VP_EVCAT_RESPONSE, VP_DEV_EVID_IO_ACCESS_CMP, "IO_ACCESS_CMP", TRUE, FALSE }, |
| { VP_EVCAT_RESPONSE, VP_LINE_EVID_LINE_IO_RD_CMP, "LINE_IO_RD_CMP", FALSE, TRUE }, |
| { VP_EVCAT_RESPONSE, VP_LINE_EVID_LINE_IO_WR_CMP, "LINE_IO_WR_CMP", FALSE, TRUE }, |
| { VP_EVCAT_RESPONSE, VP_LINE_EVID_SLAC_INIT_CMP, "SLAC_INIT_CMP", TRUE, FALSE }, |
| { VP_EVCAT_TEST, VP_LINE_EVID_TEST_CMP, "TEST_CMP", FALSE, TRUE }, |
| { VP_EVCAT_TEST, VP_LINE_EVID_DTONE_DET, "DTONE_DET", TRUE, FALSE }, |
| { VP_EVCAT_TEST, VP_LINE_EVID_DTONE_LOSS, "DTONE_LOSS", TRUE, FALSE }, |
| { VP_EVCAT_TEST, VP_DEV_EVID_STEST_CMP, "STEST_CMP", TRUE, FALSE }, |
| { VP_EVCAT_TEST, VP_DEV_EVID_CHKSUM, "CHKSUM", FALSE, TRUE }, |
| { VP_EVCAT_PROCESS, VP_LINE_EVID_MTR_CMP, "MTR_CMP", FALSE, FALSE }, |
| { VP_EVCAT_PROCESS, VP_LINE_EVID_MTR_ABORT, "MTR_ABORT", TRUE, FALSE }, |
| { VP_EVCAT_PROCESS, VP_LINE_EVID_CID_DATA, "CID_DATA", TRUE, FALSE }, |
| { VP_EVCAT_PROCESS, VP_LINE_EVID_RING_CAD, "RING_CAD", TRUE, FALSE }, |
| { VP_EVCAT_PROCESS, VP_LINE_EVID_SIGNAL_CMP, "SIGNAL_CMP", TRUE, TRUE }, |
| { VP_EVCAT_PROCESS, VP_LINE_EVID_MTR_CAD, "MTR_CAD", TRUE, FALSE }, |
| { VP_EVCAT_PROCESS, VP_LINE_EVID_TONE_CAD, "TONE_CAD", FALSE, FALSE }, |
| { VP_EVCAT_PROCESS, VP_LINE_EVID_MTR_ROLLOVER, "MTR_ROLLOVER", TRUE, TRUE }, |
| { VP_EVCAT_FXO, VP_LINE_EVID_RING_ON, "RING_ON", FALSE, TRUE }, |
| { VP_EVCAT_FXO, VP_LINE_EVID_LIU, "LIU", FALSE, TRUE }, |
| { VP_EVCAT_FXO, VP_LINE_EVID_LNIU, "LNIU", FALSE, TRUE }, |
| { VP_EVCAT_FXO, VP_LINE_EVID_FEED_DIS, "FEED_DIS", FALSE, TRUE }, |
| { VP_EVCAT_FXO, VP_LINE_EVID_FEED_EN, "FEED_EN", FALSE, TRUE }, |
| { VP_EVCAT_FXO, VP_LINE_EVID_DISCONNECT, "DISCONNECT", FALSE, TRUE }, |
| { VP_EVCAT_FXO, VP_LINE_EVID_RECONNECT, "RECONNECT", FALSE, TRUE }, |
| { VP_EVCAT_FXO, VP_LINE_EVID_POLREV, "POLREV", TRUE, TRUE }, |
| { VP_EVCAT_FXO, VP_LINE_EVID_POH, "POH", TRUE, TRUE }, |
| { VP_EVCAT_FXO, VP_LINE_EVID_PNOH, "PNOH", TRUE, TRUE }, |
| { (VpEventCategoryType)0, 0, "", TRUE, TRUE } |
| }; |
| const VpEventInfo *pEventInfo = eventInfoTable; |
| char eventDataStr[16] = ""; |
| char parmHandleStr[16] = ""; |
| char eventNameStr[32] = ""; |
| bool lineSpecific = (pEvent->pLineCtx != VP_NULL); |
| |
| if (pEvent->status != VP_STATUS_SUCCESS) { |
| VP_DOUT_(EVENT, VP_DBG_EVENT_COLOR, VpDevCtxType, pEvent->pDevCtx, ("status = %s", VpGetString_VpStatusType(pEvent->status))); |
| return; |
| } |
| |
| /* Find the event in the table. */ |
| while ( |
| (pEventInfo->id != 0) && |
| ((pEventInfo->category != pEvent->eventCategory) || (pEventInfo->id != pEvent->eventId)) |
| ) { |
| pEventInfo++; |
| } |
| |
| /* Build display strings. */ |
| if (pEventInfo->id == 0) { |
| sprintf(eventNameStr, "cat=0x%4.4X id=0x%4.4X", pEvent->eventCategory, pEvent->eventId); |
| } else { |
| sprintf(eventNameStr, "id=%s", pEventInfo->nameStr); |
| } |
| if (pEventInfo->hasEventData) { |
| sprintf(eventDataStr, " data=0x%4.4X", pEvent->eventData); |
| } |
| if (pEventInfo->hasParmHandle) { |
| sprintf(parmHandleStr, " parm=0x%4.4X", pEvent->parmHandle); |
| } |
| |
| #define PRINTF_VPEVENT \ |
| ("%s%s%s%s", eventNameStr, eventDataStr, parmHandleStr, (pEvent->hasResults ? " +results" : "")) |
| |
| if (lineSpecific) { |
| VP_DOUT_(EVENT, VP_DBG_EVENT_COLOR, VpLineCtxType, pEvent->pLineCtx, PRINTF_VPEVENT); |
| } else { |
| VP_DOUT_(EVENT, VP_DBG_EVENT_COLOR, VpDevCtxType, pEvent->pDevCtx, PRINTF_VPEVENT); |
| } |
| } |
| |
| void VpDisplayResults( |
| VpEventType *pEvent, |
| void *pResult) |
| { |
| char outbuf[800]; |
| char *pOut = outbuf + sprintf(outbuf, "results={"); |
| bool lineSpecific = (pEvent->pLineCtx != VP_NULL); |
| VpEventCategoryType cat = pEvent->eventCategory; |
| uint16 id = pEvent->eventId; |
| |
| if (!pEvent->hasResults) { |
| return; |
| } |
| |
| if ( |
| ((cat == VP_EVCAT_RESPONSE) && (id == VP_DEV_EVID_BOOT_CMP)) || |
| ((cat == VP_EVCAT_TEST) && (id == VP_DEV_EVID_CHKSUM)) |
| ) { |
| VpChkSumType *pChkSum = (VpChkSumType *)pResult; |
| pOut += sprintf(pOut, "loadChecksum=0x%8.8X ", (unsigned)pChkSum->loadChecksum); |
| pOut += sprintf(pOut, "vInfo={"); |
| pOut += sprintf(pOut, "vtdRevCode=0x%4.4X ", pChkSum->vInfo.vtdRevCode); |
| pOut += sprintf(pOut, "swProductId=0x%2.2X ", pChkSum->vInfo.swProductId); |
| pOut += sprintf(pOut, "swVerMajor=0x%2.2X ", pChkSum->vInfo.swVerMajor); |
| pOut += sprintf(pOut, "swVerMinor=0x%2.2X}", pChkSum->vInfo.swVerMinor); |
| } else if ((cat == VP_EVCAT_TEST) && (id == VP_LINE_EVID_TEST_CMP)) { |
| /* To do */ |
| pOut += sprintf(pOut, "(test result not displayed)"); |
| } else if (cat == VP_EVCAT_RESPONSE) { |
| switch (pEvent->eventId) { |
| case VP_LINE_EVID_LLCMD_RX_CMP: { |
| uint8 *pData = (uint8 *)pResult; |
| uint16 bytes = pEvent->eventData; |
| while (bytes--) { |
| pOut += sprintf(pOut, " %2.2X", *(pData++)); |
| } |
| break; |
| } |
| case VP_LINE_EVID_RD_OPTION: |
| /* To do */ |
| pOut += sprintf(pOut, "(option value not displayed)"); |
| break; |
| case VP_LINE_EVID_RD_LOOP: { |
| VpLoopCondResultsType *pLoopCond = (VpLoopCondResultsType *)pResult; |
| pOut += sprintf(pOut, "rloop=%d ", pLoopCond->rloop); |
| pOut += sprintf(pOut, "ilg=%d ", pLoopCond->ilg); |
| pOut += sprintf(pOut, "imt=%d ", pLoopCond->imt); |
| pOut += sprintf(pOut, "vbat1=%d ", pLoopCond->vbat1); |
| pOut += sprintf(pOut, "vsab=%d ", pLoopCond->vsab); |
| pOut += sprintf(pOut, "vbat2=%d ", pLoopCond->vbat2); |
| pOut += sprintf(pOut, "mspl=%d ", pLoopCond->mspl); |
| pOut += sprintf(pOut, "vbat3=%d ", pLoopCond->vbat3); |
| pOut += sprintf(pOut, "selectedBat=%d ", pLoopCond->selectedBat); |
| pOut += sprintf(pOut, "dcFeedReg=%d", pLoopCond->dcFeedReg); |
| break; |
| } |
| case VP_LINE_EVID_GAIN_CMP: { |
| VpRelGainResultsType *pRelGain = (VpRelGainResultsType *)pResult; |
| pOut += sprintf(pOut, "gResult=%d ", pRelGain->gResult); |
| pOut += sprintf(pOut, "gxValue=%4.4X ", pRelGain->gxValue); |
| pOut += sprintf(pOut, "grValue=%4.4X", pRelGain->grValue); |
| break; |
| } |
| case VP_DEV_EVID_IO_ACCESS_CMP: |
| /* We can't distinguish between VpDeviceIoAccessDataType and |
| VpDeviceIoAccessExtType here. */ |
| pOut += sprintf(pOut, "(cannot display result)"); |
| break; |
| case VP_LINE_EVID_LINE_IO_RD_CMP: { |
| VpLineIoAccessType *pLineIoAccess = (VpLineIoAccessType *)pResult; |
| pOut += sprintf(pOut, "direction=%d ", pLineIoAccess->direction); |
| pOut += sprintf(pOut, "ioBits={"); |
| pOut += sprintf(pOut, "mask=%2.2X ", pLineIoAccess->ioBits.mask); |
| pOut += sprintf(pOut, "data=%2.2X}", pLineIoAccess->ioBits.data); |
| break; |
| } |
| case VP_LINE_EVID_QUERY_CMP: { |
| VpQueryResultsType *pQueryResults = (VpQueryResultsType *)pResult; |
| int i; |
| switch (pEvent->eventData) { |
| case VP_QUERY_ID_TEMPERATURE: |
| pOut += sprintf(pOut, "temp=%d", pQueryResults->temp); |
| break; |
| case VP_QUERY_ID_METER_COUNT: |
| pOut += sprintf(pOut, "meterCount=%u", pQueryResults->meterCount); |
| break; |
| case VP_QUERY_ID_LOOP_RES: |
| pOut += sprintf(pOut, "rloop=%u", pQueryResults->rloop); |
| break; |
| case VP_QUERY_ID_SEAL_CUR: |
| pOut += sprintf(pOut, "sealCur={"); |
| pOut += sprintf(pOut, "sealApplyTime=%u ", pQueryResults->sealCur.sealApplyTime); |
| pOut += sprintf(pOut, "sealCycleTime=%u ", pQueryResults->sealCur.sealCycleTime); |
| pOut += sprintf(pOut, "maxCurrent=%u ", pQueryResults->sealCur.maxCurrent); |
| pOut += sprintf(pOut, "minCurrent=%u ", pQueryResults->sealCur.minCurrent); |
| pOut += sprintf(pOut, "sealMaskArray[]={"); |
| for (i = 0; i < VP_SEAL_CURRENT_ARRAY_SIZE; i++) { |
| pOut += sprintf(pOut, "0x%4.4X ", pQueryResults->sealCur.sealMaskArray[i]); |
| } |
| pOut += sprintf(pOut, "} }"); |
| break; |
| default: |
| /* Unknown Query ID. */ |
| VP_ERROR(VpDevCtxType, pEvent->pDevCtx, ("Unknown query ID %d", pEvent->eventData)); |
| return; |
| } |
| break; |
| } |
| default: |
| VP_ERROR(VpDevCtxType, pEvent->pDevCtx, ("Unknown event results type (eventId=0x%4.4X)", pEvent->eventId)); |
| return; |
| } |
| } |
| |
| sprintf(pOut, "}"); |
| if (lineSpecific) { |
| VP_DOUT_(EVENT, VP_DBG_EVENT_COLOR, VpLineCtxType, pEvent->pLineCtx, ("%s", outbuf)); |
| } else { |
| VP_DOUT_(EVENT, VP_DBG_EVENT_COLOR, VpDevCtxType, pEvent->pDevCtx, ("%s", outbuf)); |
| } |
| } |
| |
| #endif /* (VP_CC_DEBUG_SELECT & VP_DBG_EVENT) */ |
| |
| #if ((VP_CC_DEBUG_SELECT & VP_DBG_HAL) && (defined(VP_CC_VCP2_SERIES) || defined(VP_CC_MELT_SERIES) || \ |
| defined(VP_CC_VCP_SERIES) || defined(VP_CC_792_SERIES))) |
| void |
| VpDisplayHbiAccess( |
| VpDeviceType deviceType, |
| VpDeviceIdType deviceId, |
| unsigned bufLen, |
| uint16 *buf) |
| { |
| VP_HAL(VpDeviceIdType, &deviceId, ("%u-word opaque HBI block {", bufLen)); |
| |
| while (bufLen > 0) { |
| uint16 cmd = *buf++; |
| unsigned dataLength = VpDisplayHbiCmd(deviceType, deviceId, cmd); |
| bufLen--; |
| if (dataLength > 0) { |
| if (dataLength > bufLen) { |
| VP_ERROR(VpDeviceIdType, &deviceId, ("Not enough data for HAL Access!")); |
| dataLength = bufLen; |
| } |
| VpDisplayHbiData(deviceId, dataLength, buf); |
| buf += dataLength; |
| bufLen -= dataLength; |
| } |
| } |
| |
| VP_HAL(VpDeviceIdType, &deviceId, ("} end of block")); |
| } |
| |
| #define HBI_WORDS_PER_LINE 8 |
| #define HBI_WORD_FILLER "---- " |
| #define HBI_COMMAND_LINE_FILLER " = " |
| |
| unsigned |
| VpDisplayHbiCmd( |
| VpDeviceType deviceType, |
| VpDeviceIdType deviceId, |
| uint16 cmd) |
| { |
| char output[128]; |
| unsigned dataLength = 0; |
| |
| switch (deviceType) { |
| |
| #if (defined(VP_CC_VCP2_SERIES) || defined(VP_CC_MELT_SERIES) || defined(VP_CC_VCP_SERIES)) |
| case VP_DEV_VCP_SERIES: |
| case VP_DEV_VCP2_SERIES: |
| case VP_DEV_MELT_SERIES: |
| if (cmd == 0xFFFF) { |
| sprintf(output, "%4.4X%s%s", (int)cmd, HBI_COMMAND_LINE_FILLER, "No Op"); |
| } else if ((cmd & 0xFF00) == 0xFE00) { |
| sprintf(output, "%4.4X%s%s 0x%2.2X", (int)cmd, HBI_COMMAND_LINE_FILLER, |
| "Select Page", (int)(cmd & 0xFF)); |
| } else if ((cmd & 0xFF00) == (0xFD00)) { |
| sprintf(output, "%4.4X%s%s 0x%2.2X", (int)cmd, HBI_COMMAND_LINE_FILLER, |
| "Config Interface", (int)(cmd & 0xFF)); |
| } else if ((cmd & 0xFE00) == (0xFA00)) { |
| dataLength = (cmd & 0xFF) + 1; |
| sprintf(output, "%4.4X%s%s (%u word%s)", (int)cmd, HBI_COMMAND_LINE_FILLER, |
| "Continue Paged Access", dataLength, (dataLength > 1 ? "s" : "")); |
| } else if ((cmd & 0xFE00) == (0xF800)) { |
| dataLength = (cmd & 0xFF) + 1; |
| sprintf(output, "%4.4X%s%s (%u word%s)", (int)cmd, HBI_COMMAND_LINE_FILLER, |
| "Start Paged Access", dataLength, (dataLength > 1 ? "s" : "")); |
| } else { |
| unsigned offset = (cmd & 0x7F00) >> 8; |
| bool direct = ((cmd & 0x8000) != 0); |
| bool write = ((cmd & 0x0080) != 0); |
| dataLength = (cmd & 0x007F) + 1; |
| sprintf(output, "%4.4X%s%s Offset %s (%u word%s at offset 0x%2.2X)", (int)cmd, |
| HBI_COMMAND_LINE_FILLER, (direct ? "Direct" : "Paged"), |
| (write ? "Write" : "Read"), dataLength, (dataLength > 1 ? "s" : ""), |
| offset); |
| } |
| break; |
| #endif /* (defined(VP_CC_VCP2_SERIES) || defined(VP_CC_VCP_SERIES) || defined(VP_CC_MELT_SERIES)) */ |
| |
| #ifdef VP_CC_792_SERIES |
| case VP_DEV_792_SERIES: |
| if (cmd == 0xFFFF) { |
| sprintf(output, "%4.4X%s %s", (int)cmd, HBI_COMMAND_LINE_FILLER, "No Op"); |
| } else if (cmd == 0xF701) { |
| dataLength = 2; |
| sprintf(output, "%4.4X%s %s", (int)cmd, HBI_COMMAND_LINE_FILLER, "Read Shared Interrupt Regs"); |
| } else if ((cmd & 0xFF00) == (0xFD00)) { |
| sprintf(output, "%4.4X%s %s 0x%2.2X", (int)cmd, HBI_COMMAND_LINE_FILLER, |
| "Config Interface", (int)(cmd & 0xFF)); |
| } else if ((cmd & 0xFF00) == 0xFE00) { |
| if ((cmd & 0x00FF) == 0x00FF) { |
| sprintf(output, "%4.4X%s %s", (int)cmd, HBI_COMMAND_LINE_FILLER, |
| "Code Load Page Broadcast"); |
| } else if ((cmd & 0x008F) == 0x0080) { |
| unsigned slacId = (cmd & 0x0070) >> 4; |
| sprintf(output, "%4.4X%s(slac %u) %s", (int)cmd, HBI_COMMAND_LINE_FILLER, slacId, |
| "Select Code Load Page"); |
| } else if ((cmd & 0x0080) == 0x0000) { |
| unsigned slacId = (cmd & 0x0070) >> 4; |
| unsigned page = cmd & 0x000F; |
| sprintf(output, "%4.4X%s(slac %u) %s %u", (int)cmd, HBI_COMMAND_LINE_FILLER, slacId, |
| "Select Page", page); |
| } else { |
| sprintf(output, "%4.4X%s%s", (int)cmd, HBI_COMMAND_LINE_FILLER, |
| "INVALID COMMAND WORD!"); |
| } |
| } else if ((cmd & 0xFF00) == (0xFD00)) { |
| sprintf(output, "%4.4X%s %s 0x%2.2X", (int)cmd, HBI_COMMAND_LINE_FILLER, |
| "Config Interface", (int)(cmd & 0xFF)); |
| } else if ((cmd & 0xFF00) == (0xFC00)) { |
| unsigned offset = (cmd & 0x00F0) >> 4; |
| dataLength = (cmd & 0x000F) + 1; |
| sprintf(output, "%4.4X%s %s (%u word%s at offset 0x%2.2X)", (int)cmd, HBI_COMMAND_LINE_FILLER, |
| "Direct Page Broadcast", dataLength, (dataLength > 1 ? "s" : ""), offset); |
| } else if ((cmd & 0xFE00) == (0xFA00)) { |
| dataLength = (cmd & 0xFF) + 1; |
| sprintf(output, "%4.4X%s %s (%u word%s)", (int)cmd, HBI_COMMAND_LINE_FILLER, |
| "Continue Mailbox Access", dataLength, (dataLength > 1 ? "s" : "")); |
| } else if ((cmd & 0xFE00) == (0xF800)) { |
| dataLength = (cmd & 0xFF) + 1; |
| sprintf(output, "%4.4X%s %s (%u word%s)", (int)cmd, HBI_COMMAND_LINE_FILLER, |
| "Start Mailbox Access", dataLength, (dataLength > 1 ? "s" : "")); |
| } else if (cmd & 0x8000) { |
| unsigned offset = (cmd & 0x7F00) >> 8; |
| bool write = (cmd & 0x0080); |
| unsigned slacId = (cmd & 0x0070) >> 4; |
| dataLength = (cmd & 0x000F) + 1; |
| sprintf(output, "%4.4X%s(slac %u) %s %s (%u word%s at offset 0x%2.2X)", |
| (int)cmd, HBI_COMMAND_LINE_FILLER, slacId, |
| "Direct Page", (write ? "Write" : "Read"), dataLength, |
| (dataLength > 1 ? "s" : ""), offset); |
| } else { |
| unsigned offset = (cmd & 0x7F00) >> 8; |
| bool write = ((cmd & 0x0080) != 0); |
| dataLength = (cmd & 0x007F) + 1; |
| sprintf(output, "%4.4X%s Paged %s (%u word%s at offset 0x%2.2X)", (int)cmd, |
| HBI_COMMAND_LINE_FILLER, (write ? "Write" : "Read"), dataLength, |
| (dataLength > 1 ? "s" : ""), offset); |
| } |
| break; |
| #endif /* VP_CC_792_SERIES */ |
| |
| default: |
| sprintf(output, "%4.4X (cmd)", (int)cmd); |
| } |
| |
| VP_HAL(VpDeviceIdType, &deviceId, ("%s", output)); |
| return dataLength; |
| } |
| |
| void |
| VpDisplayHbiData( |
| VpDeviceIdType deviceId, |
| unsigned bufLen, |
| uint16 *buf) |
| { |
| char output[128] = " "; |
| char *pOut = &output[7]; |
| unsigned disp = 0; |
| |
| if (buf == VP_NULL) { |
| VP_HAL(VpDeviceIdType, &deviceId, (" (%u words of zeroes)", bufLen)); |
| return; |
| } |
| |
| while (bufLen--) { |
| pOut += sprintf(pOut, "%4.4X ", *buf++); |
| disp++; |
| if ((bufLen == 0) || ((disp % HBI_WORDS_PER_LINE) == 0)) { |
| VP_HAL(VpDeviceIdType, &deviceId, ("%s", output)); |
| pOut = &output[7]; |
| } |
| } |
| } |
| |
| bool |
| VpHalHbiReadWrapper( |
| VpDeviceType deviceType, |
| VpDeviceIdType deviceId, |
| uint16 cmd, |
| uint8 numwords, |
| uint16p data) |
| { |
| bool status = VpHalHbiRead(deviceId, cmd, numwords, data); |
| VpDisplayHbiCmd(deviceType, deviceId, cmd); |
| VpDisplayHbiData(deviceId, numwords + 1, data); |
| return status; |
| } |
| |
| #endif /* ((VP_CC_DEBUG_SELECT & VP_DBG_HAL) && (defined(VP_CC_VCP2_SERIES) || defined(VP_CC_MELT_SERIES) || defined(VP_CC_VCP_SERIES))) */ |
| |
| #if (VP_CC_DEBUG_SELECT & VP_DBG_SSL) |
| |
| const char * |
| VpGetString_VpCriticalSecType( |
| VpCriticalSecType criticalSecType) |
| { |
| static const char *strTable[VP_NUM_CRITICAL_SEC_TYPES] = { |
| "VP_MPI_CRITICAL_SEC", |
| "VP_HBI_CRITICAL_SEC", |
| "VP_CODE_CRITICAL_SEC" |
| }; |
| |
| VP_ASSERT(VP_NUM_CRITICAL_SEC_TYPES == VP_CODE_CRITICAL_SEC + 1); |
| |
| return VpGetEnumString(strTable, VP_NUM_CRITICAL_SEC_TYPES, (int)criticalSecType); |
| } |
| |
| uint8 |
| VpSysEnterCriticalWrapper( |
| VpDeviceIdType deviceId, |
| VpCriticalSecType criticalSecType) |
| { |
| uint8 depth = VpSysEnterCritical(deviceId, criticalSecType); |
| VP_SSL(VpDeviceIdType, &(deviceId), ("VpSysEnterCritical(%s) = %u", VpGetString_VpCriticalSecType(criticalSecType), (unsigned)depth)); |
| return depth; |
| } |
| |
| uint8 |
| VpSysExitCriticalWrapper( |
| VpDeviceIdType deviceId, |
| VpCriticalSecType criticalSecType) |
| { |
| uint8 depth = VpSysExitCritical(deviceId, criticalSecType); |
| VP_SSL(VpDeviceIdType, &(deviceId), ("VpSysExitCritical(%s) = %u", VpGetString_VpCriticalSecType(criticalSecType), (unsigned)depth)); |
| return depth; |
| } |
| |
| #endif /* (VP_CC_DEBUG_SELECT & VP_DBG_SSL) */ |
| |
| #if defined (VP_CC_880_SERIES) || defined (VP_CC_890_SERIES) |
| #if (VP_CC_DEBUG_SELECT & VP_DBG_ERROR) |
| void |
| VpPrintTermType( |
| VpTermType termType) |
| { |
| #define VP_SUPPORT_TERM_SIZE (8) |
| uint8 termIndex; |
| VpTermType termSupported[VP_SUPPORT_TERM_SIZE] = { |
| VP_TERM_FXS_GENERIC, VP_TERM_FXS_ISOLATE, VP_TERM_FXS_SPLITTER, |
| VP_TERM_FXS_LOW_PWR, VP_TERM_FXS_SPLITTER_LP, VP_TERM_FXS_ISOLATE_LP, |
| VP_TERM_FXO_GENERIC, VP_TERM_FXO_DISC |
| }; |
| char *termString[VP_SUPPORT_TERM_SIZE] = { |
| "VP_TERM_FXS_GENERIC", "VP_TERM_FXS_ISOLATE", "VP_TERM_FXS_SPLITTER", |
| "VP_TERM_FXS_LOW_PWR", "VP_TERM_FXS_SPLITTER_LP", "VP_TERM_FXS_ISOLATE_LP", |
| "VP_TERM_FXO_GENERIC", "VP_TERM_FXO_DISC" |
| }; |
| |
| for (termIndex = 0; termIndex < VP_SUPPORT_TERM_SIZE; termIndex++) { |
| if (termType == termSupported[termIndex]) { |
| VpSysDebugPrintf("\n\n\rpLineObj->termType = %d : %s", |
| termType, termString[termIndex]); |
| return; |
| } |
| } |
| VpSysDebugPrintf("\n\n\rpLineObj->termType = %d : UNKNOWN TERM TYPE", |
| termType); |
| } |
| |
| void |
| VpPrintLineStateType( |
| VpLineStateType lineState, |
| char *strLineState) |
| { |
| #define VP_SUPPORT_STATE_SIZE (18) |
| uint8 stateIndex; |
| |
| VpLineStateType lineStateArray[VP_SUPPORT_STATE_SIZE] = { |
| VP_LINE_STANDBY, VP_LINE_TIP_OPEN, VP_LINE_ACTIVE, VP_LINE_ACTIVE_POLREV, |
| VP_LINE_TALK, VP_LINE_TALK_POLREV, VP_LINE_OHT, VP_LINE_OHT_POLREV, |
| VP_LINE_DISCONNECT, VP_LINE_RINGING, VP_LINE_RINGING_POLREV, |
| VP_LINE_STANDBY_POLREV, VP_LINE_RING_OPEN, VP_LINE_FXO_OHT, |
| VP_LINE_FXO_LOOP_OPEN, VP_LINE_FXO_LOOP_CLOSE, VP_LINE_FXO_TALK, |
| VP_LINE_FXO_RING_GND |
| }; |
| char *lineStateStr[VP_SUPPORT_STATE_SIZE] = { |
| "VP_LINE_STANDBY", "VP_LINE_TIP_OPEN", "VP_LINE_ACTIVE", |
| "VP_LINE_ACTIVE_POLREV", "VP_LINE_TALK", "VP_LINE_TALK_POLREV", |
| "VP_LINE_OHT", "VP_LINE_OHT_POLREV", "VP_LINE_DISCONNECT", |
| "VP_LINE_RINGING", "VP_LINE_RINGING_POLREV", "VP_LINE_STANDBY_POLREV", |
| "VP_LINE_RING_OPEN", "VP_LINE_FXO_OHT", "VP_LINE_FXO_LOOP_OPEN", |
| "VP_LINE_FXO_LOOP_CLOSE", "VP_LINE_FXO_TALK", "VP_LINE_FXO_RING_GND" |
| }; |
| |
| for (stateIndex = 0; stateIndex < VP_SUPPORT_STATE_SIZE; stateIndex++) { |
| if (lineState == lineStateArray[stateIndex]) { |
| VpSysDebugPrintf("\n\r%s = %d : %s", |
| strLineState, lineState, lineStateStr[stateIndex]); |
| return; |
| } |
| } |
| VpSysDebugPrintf("\n\r%s = %d : UNKNOWN LINE STATE", |
| strLineState, lineState); |
| } |
| |
| void |
| VpPrintOptionRingControlType( |
| VpOptionRingControlType *ringCtrl) |
| { |
| VpPrintOptionZeroCrossType(ringCtrl->zeroCross); |
| VpSysDebugPrintf("\npLineObj->ringCtrl.ringExitDbncDur = %d", ringCtrl->ringExitDbncDur); |
| VpPrintLineStateType(ringCtrl->ringTripExitSt, "pLineObj->ringCtrl.ringTripExitSt"); |
| |
| } |
| |
| void |
| VpPrintOptionZeroCrossType( |
| VpOptionZeroCrossType zeroCross) |
| { |
| switch(zeroCross) { |
| case VP_OPTION_ZC_M4B: |
| VpSysDebugPrintf("\npLineObj->ringCtrl.zeroCross = VP_OPTION_ZC_M4B"); |
| break; |
| |
| case VP_OPTION_ZC_B4M: |
| VpSysDebugPrintf("\npLineObj->ringCtrl.zeroCross = VP_OPTION_ZC_B4M"); |
| break; |
| |
| case VP_OPTION_ZC_NONE: |
| VpSysDebugPrintf("\npLineObj->ringCtrl.zeroCross = VP_OPTION_ZC_NONE"); |
| break; |
| |
| default: |
| VpSysDebugPrintf("\npLineObj->ringCtrl.zeroCross = UNKNOWN (%d)", |
| zeroCross); |
| } |
| } |
| |
| void |
| VpPrintRelayControlType( |
| VpRelayControlType relayState) |
| { |
| switch(relayState) { |
| case VP_RELAY_NORMAL: |
| VpSysDebugPrintf("\npLineObj->relayState = VP_RELAY_NORMAL"); |
| break; |
| |
| case VP_RELAY_RESET: |
| VpSysDebugPrintf("\npLineObj->relayState = VP_RELAY_RESET"); |
| break; |
| |
| case VP_RELAY_BRIDGED_TEST: |
| VpSysDebugPrintf("\npLineObj->relayState = VP_RELAY_BRIDGED_TEST"); |
| break; |
| |
| default: |
| VpSysDebugPrintf("\npLineObj->relayState = UNKNOWN (%d)", |
| relayState); |
| } |
| } |
| |
| void |
| VpPrintOptionCodecType( |
| VpOptionCodecType codec) |
| { |
| char *codecStr[] = { |
| "VP_OPTION_ALAW", "VP_OPTION_MLAW", "VP_OPTION_LINEAR", |
| "VP_OPTION_WIDEBAND" |
| }; |
| |
| if (codec <= 3) { |
| VpSysDebugPrintf("\npLineObj->codec = %s", codecStr[codec]); |
| } else { |
| VpSysDebugPrintf("\npLineObj->codec = UNKNOWN (%d)", codec); |
| } |
| } |
| |
| void |
| VpPrintOptionPcmTxRxCntrlType( |
| VpOptionPcmTxRxCntrlType pcmTxRxCtrl) |
| { |
| char *pcmCtrlStr[] = { |
| "VP_OPTION_PCM_BOTH", "VP_OPTION_PCM_RX_ONLY", "VP_OPTION_PCM_TX_ONLY", |
| "VP_OPTION_PCM_ALWAYS_ON" |
| }; |
| |
| if (pcmTxRxCtrl <= 3) { |
| VpSysDebugPrintf("\npLineObj->pcmTxRxCtrl = %s", pcmCtrlStr[pcmTxRxCtrl]); |
| } else { |
| VpSysDebugPrintf("\npLineObj->pcmTxRxCtrl = UNKNOWN (%d)", pcmTxRxCtrl); |
| } |
| } |
| |
| void |
| VpPrintCallerIdType( |
| VpCallerIdType *callerId) |
| { |
| uint8 msgIndex; |
| |
| VpSysDebugPrintf("\n\npLineObj->callerId.status = 0x%08lX", callerId->status); |
| VpSysDebugPrintf("\npLineObj->callerId.dtmfStatus = 0x%04X", callerId->dtmfStatus); |
| VpSysDebugPrintf("\npLineObj->callerId.digitDet = 0x%04X", callerId->digitDet); |
| VpSysDebugPrintf("\npLineObj->callerId.cliTimer = %d", callerId->cliTimer); |
| VpSysDebugPrintf("\npLineObj->callerId.currentData = 0x%02X", callerId->currentData); |
| VpSysDebugPrintf("\npLineObj->callerId.cidCheckSum = 0x%04X", callerId->cidCheckSum); |
| VpSysDebugPrintf("\npLineObj->callerId.cliDebounceTime = %d", callerId->cliDebounceTime); |
| VpSysDebugPrintf("\npLineObj->callerId.pCliProfile = %p", callerId->pCliProfile); |
| VpSysDebugPrintf("\npLineObj->callerId.cliDetectTone1 = 0x%04X", callerId->cliDetectTone1); |
| VpSysDebugPrintf("\npLineObj->callerId.cliDetectTone2 = 0x%04X", callerId->cliDetectTone2); |
| VpSysDebugPrintf("\npLineObj->callerId.cliMPIndex = %d", callerId->cliMPIndex); |
| VpSysDebugPrintf("\npLineObj->callerId.cliMSIndex = %d", callerId->cliMSIndex); |
| VpSysDebugPrintf("\npLineObj->callerId.cliIndex = %d", callerId->cliIndex); |
| |
| VpSysDebugPrintf("\npLineObj->callerId.primaryMsgLen = %d", callerId->primaryMsgLen); |
| VpSysDebugPrintf("\npLineObj->callerId.primaryBuffer ="); |
| for (msgIndex = 0; msgIndex < VP_SIZEOF_CID_MSG_BUFFER; msgIndex++) { |
| if (!(msgIndex % 10)) { |
| VpSysDebugPrintf("\n\t"); |
| } |
| VpSysDebugPrintf(" 0x%02X", callerId->primaryBuffer[msgIndex]); |
| } |
| |
| VpSysDebugPrintf("\npLineObj->callerId.secondaryMsgLen = %d", callerId->secondaryMsgLen); |
| VpSysDebugPrintf("\npLineObj->callerId.secondaryBuffer ="); |
| for (msgIndex = 0; msgIndex < VP_SIZEOF_CID_MSG_BUFFER; msgIndex++) { |
| if (!(msgIndex % 10)) { |
| VpSysDebugPrintf("\n\t"); |
| } |
| VpSysDebugPrintf(" 0x%02X", callerId->secondaryBuffer[msgIndex]); |
| } |
| } |
| |
| void |
| VpPrintVpCslacTimerStruct( |
| VpCslacTimerStruct *lineTimers) |
| { |
| if (lineTimers->type == VP_CSLAC_FXO_TIMER) { |
| #if (defined(VP_CC_880_SERIES) && defined(VP880_FXO_SUPPORT)) \ |
| || (defined(VP_CC_890_SERIES) && defined(VP890_FXO_SUPPORT)) |
| VpSysDebugPrintf("\npLineObj->lineTimers.type = VP_CSLAC_FXO_TIMER"); |
| VpSysDebugPrintf("\n\ttimers.fxoTimer.highToLowTime = %d", |
| lineTimers->timers.fxoTimer.highToLowTime); |
| VpSysDebugPrintf("\n\ttimers.fxoTimer.prevHighToLowTime = %d", |
| lineTimers->timers.fxoTimer.prevHighToLowTime); |
| VpSysDebugPrintf("\n\ttimers.fxoTimer.timeLastPolRev = %d", |
| lineTimers->timers.fxoTimer.timeLastPolRev); |
| VpSysDebugPrintf("\n\ttimers.fxoTimer.timePrevPolRev = %d", |
| lineTimers->timers.fxoTimer.timePrevPolRev); |
| VpSysDebugPrintf("\n\ttimers.fxoTimer.maxPeriod = %d", |
| lineTimers->timers.fxoTimer.maxPeriod); |
| VpSysDebugPrintf("\n\ttimers.fxoTimer.lastStateChange = %d", |
| lineTimers->timers.fxoTimer.lastStateChange); |
| VpSysDebugPrintf("\n\ttimers.fxoTimer.lastNotLiu = %d", |
| lineTimers->timers.fxoTimer.lastNotLiu); |
| VpSysDebugPrintf("\n\ttimers.fxoTimer.disconnectDebounce = %d", |
| lineTimers->timers.fxoTimer.disconnectDebounce); |
| VpSysDebugPrintf("\n\ttimers.fxoTimer.disconnectDuration = %d", |
| lineTimers->timers.fxoTimer.disconnectDuration); |
| VpSysDebugPrintf("\n\ttimers.fxoTimer.liuDebounce = %d", |
| lineTimers->timers.fxoTimer.liuDebounce); |
| VpSysDebugPrintf("\n\ttimers.fxoTimer.ringOffDebounce = %d", |
| lineTimers->timers.fxoTimer.ringOffDebounce); |
| VpSysDebugPrintf("\n\ttimers.fxoTimer.ringTimer = %d", |
| lineTimers->timers.fxoTimer.ringTimer); |
| VpSysDebugPrintf("\n\ttimers.fxoTimer.cidCorrectionTimer = %d", |
| lineTimers->timers.fxoTimer.cidCorrectionTimer); |
| VpSysDebugPrintf("\n\ttimers.fxoTimer.bCalTimer = %d", |
| lineTimers->timers.fxoTimer.bCalTimer); |
| VpSysDebugPrintf("\n\ttimers.fxoTimer.fxoDiscIO2Change = %d", |
| lineTimers->timers.fxoTimer.fxoDiscIO2Change); |
| VpSysDebugPrintf("\n\ttimers.fxoTimer.pllRecovery = %d", |
| lineTimers->timers.fxoTimer.pllRecovery); |
| VpSysDebugPrintf("\n\ttimers.fxoTimer.currentMonitorTimer = %d", |
| lineTimers->timers.fxoTimer.currentMonitorTimer); |
| VpSysDebugPrintf("\n\ttimers.fxoTimer.measureBFilterTimer = %d", |
| lineTimers->timers.fxoTimer.measureBFilterTimer); |
| VpSysDebugPrintf("\n\ttimers.fxoTimer.lowVoltageTimer = %d", |
| lineTimers->timers.fxoTimer.lowVoltageTimer); |
| VpSysDebugPrintf("\n\rpLineObj->cadence.noCount = %s", |
| ((lineTimers->timers.fxoTimer.noCount == TRUE) ? "TRUE" : "FALSE")); |
| VpSysDebugPrintf("\n\rpLineObj->cadence.lastState = %s", |
| ((lineTimers->timers.fxoTimer.lastState == TRUE) ? "TRUE" : "FALSE")); |
| #endif |
| } else { |
| uint8 timerIndex; |
| char *timerNames[VP_LINE_TIMER_LAST] = { |
| "VP_LINE_CID_DEBOUNCE", "VP_LINE_TIMER_CID_DTMF", |
| "VP_LINE_TIMER_FAULT", "VP_LINE_RING_EXIT_PROCESS", |
| "VP_LINE_HOOK_FREEZE", "VP_LINE_DISCONNECT_EXIT", |
| "VP_LINE_GND_START_TIMER", "VP_LINE_CAL_LINE_TIMER", |
| "VP_LINE_PING_TIMER", "VP_LINE_TRACKER_DISABLE", |
| "VP_LINE_GPIO_CLKOUT_TIMER", "VP_LINE_INTERNAL_TESTTERM_TIMER", |
| "VP_LINE_SPEEDUP_RECOVERY_TIMER" |
| }; |
| |
| VpSysDebugPrintf("\npLineObj->lineTimers.type = VP_CSLAC_FXS_TIMER"); |
| VpSysDebugPrintf("\npLineObj->lineTimers.trackingTime = %d", |
| lineTimers->timers.trackingTime); |
| VpSysDebugPrintf("\npLineObj->lineTimers.timer ="); |
| for (timerIndex = 0; timerIndex < VP_LINE_TIMER_LAST; timerIndex++) { |
| if (!(timerIndex % 10)) { |
| VpSysDebugPrintf("\n\t"); |
| } |
| VpSysDebugPrintf(" 0x%04X", lineTimers->timers.timer[timerIndex]); |
| if (lineTimers->timers.timer[timerIndex] & VP_ACTIVATE_TIMER) { |
| VpSysDebugPrintf(" - %s is Active\n\t", timerNames[timerIndex]); |
| } |
| } |
| } |
| } |
| |
| void |
| VpPrintSeqDataType( |
| VpSeqDataType *cadence) |
| { |
| VpSysDebugPrintf("\n\npLineObj->cadence.pActiveCadence = %p", cadence->pActiveCadence); |
| VpSysDebugPrintf("\npLineObj->cadence.pCurrentPos = %p", cadence->pCurrentPos); |
| VpSysDebugPrintf("\npLineObj->cadence.status = 0x%04X", cadence->status); |
| VpSysDebugPrintf("\npLineObj->cadence.index = %d", cadence->index); |
| VpSysDebugPrintf("\npLineObj->cadence.length = %d", cadence->length); |
| { |
| uint8 branchDepth; |
| VpSysDebugPrintf("\npLineObj->cadence.count ="); |
| for (branchDepth = 0; branchDepth < VP_CSLAC_MAX_BRANCH_DEPTH; branchDepth++) { |
| VpSysDebugPrintf(" 0x%02X", cadence->count[branchDepth]); |
| } |
| } |
| { |
| uint8 regDataIndex; |
| VpSysDebugPrintf("\npLineObj->cadence.regData ="); |
| for (regDataIndex = 0; regDataIndex < VPCSLAC_MAX_GENERATOR_DATA; regDataIndex++) { |
| if (!(regDataIndex % 10)) { |
| VpSysDebugPrintf("\n\t"); |
| } |
| VpSysDebugPrintf(" 0x%02X", cadence->regData[regDataIndex]); |
| } |
| } |
| VpSysDebugPrintf("\npLineObj->cadence.timeRemain = %d", cadence->timeRemain); |
| VpSysDebugPrintf("\npLineObj->cadence.branchAt = %d", cadence->branchAt); |
| VpSysDebugPrintf("\npLineObj->cadence.meteringBurst = %d", cadence->meteringBurst); |
| VpSysDebugPrintf("\n\rpLineObj->cadence.meterPendingAbort = %s", |
| ((cadence->meterPendingAbort == TRUE) ? "TRUE" : "FALSE")); |
| VpPrintLineStateType(cadence->meterAbortLineState, "pLineObj->cadence.meterAbortLineState"); |
| |
| VpSysDebugPrintf("\npLineObj->cadence.startFreq = 0x%04X", cadence->startFreq); |
| VpSysDebugPrintf("\npLineObj->cadence.stopFreq = 0x%04X", cadence->stopFreq); |
| VpSysDebugPrintf("\npLineObj->cadence.freqStep = 0x%04X", cadence->freqStep); |
| VpSysDebugPrintf("\n\rpLineObj->cadence.isFreqIncrease = %s", |
| ((cadence->isFreqIncrease == TRUE) ? "TRUE" : "FALSE")); |
| |
| VpSysDebugPrintf("\npLineObj->cadence.startLevel = 0x%04X", cadence->startLevel); |
| VpSysDebugPrintf("\npLineObj->cadence.stopLevel = 0x%04X", cadence->stopLevel); |
| VpSysDebugPrintf("\npLineObj->cadence.levelStep = 0x%04X", cadence->levelStep); |
| } |
| |
| void |
| VpPrintCidSeqDataType( |
| VpCidSeqDataType *cidSeq) |
| { |
| VpSysDebugPrintf("\n\npLineObj->cidSeq.pActiveCadence = %p", cidSeq->pActiveCadence); |
| VpSysDebugPrintf("\npLineObj->cidSeq.pCurrentPos = %p", cidSeq->pCurrentPos); |
| VpSysDebugPrintf("\npLineObj->cidSeq.index = %d", cidSeq->index); |
| VpSysDebugPrintf("\npLineObj->cidSeq.timeRemain = %d", cidSeq->timeRemain); |
| } |
| |
| void |
| VpPrintApiIntLineState( |
| VpApiIntLineStateType *lineState) |
| { |
| VpPrintLineStateType(lineState->currentState, "pLineObj->lineState.currentState"); |
| VpPrintLineStateType(lineState->previous, "pLineObj->lineState.previous"); |
| VpPrintLineStateType(lineState->usrCurrent, "pLineObj->lineState.usrCurrent"); |
| VpSysDebugPrintf("\npLineObj->lineState.condition = 0x%04X", lineState->condition); |
| VpSysDebugPrintf("\npLineObj->lineState.calType = %d", lineState->calType); |
| } |
| |
| void |
| VpPrintDigitGenDataType( |
| VpDigitGenerationDataType *digitGenStruct) |
| { |
| VpSysDebugPrintf("\n\rpLineObj->digitGenStruct.dtmfOnTime = %d", |
| digitGenStruct->dtmfOnTime); |
| VpSysDebugPrintf("\n\rpLineObj->digitGenStruct.dtmfOffTime = %d", |
| digitGenStruct->dtmfOffTime); |
| VpSysDebugPrintf("\n\rpLineObj->digitGenStruct.breakTime = %d", |
| digitGenStruct->breakTime); |
| VpSysDebugPrintf("\n\rpLineObj->digitGenStruct.makeTime = %d", |
| digitGenStruct->makeTime); |
| VpSysDebugPrintf("\n\rpLineObj->digitGenStruct.flashTime = %d", |
| digitGenStruct->flashTime); |
| VpSysDebugPrintf("\n\rpLineObj->digitGenStruct.dpInterDigitTime = %d", |
| digitGenStruct->dpInterDigitTime); |
| VpSysDebugPrintf("\n\rpLineObj->digitGenStruct.dtmfHighFreqLevel = %d %d", |
| digitGenStruct->dtmfHighFreqLevel[0], digitGenStruct->dtmfHighFreqLevel[1]); |
| VpSysDebugPrintf("\n\rpLineObj->digitGenStruct.dtmfLowFreqLevel = %d %d", |
| digitGenStruct->dtmfLowFreqLevel[0], digitGenStruct->dtmfLowFreqLevel[1]); |
| } |
| |
| void |
| VpPrintDynamicInfoStruct( |
| VpDeviceDynamicInfoType *dynamicInfo) |
| { |
| VpSysDebugPrintf("\n\n\rpDevObj->dynamicInfo.lastChan = %d", |
| dynamicInfo->lastChan); |
| VpSysDebugPrintf("\n\rpDevObj->dynamicInfo.clkFault = %s", |
| ((dynamicInfo->clkFault == TRUE) ? "TRUE" : "FALSE")); |
| VpSysDebugPrintf("\n\rpDevObj->dynamicInfo.bat1Fault = %s", |
| ((dynamicInfo->bat1Fault == TRUE) ? "TRUE" : "FALSE")); |
| VpSysDebugPrintf("\n\rpDevObj->dynamicInfo.bat2Fault = %s", |
| ((dynamicInfo->bat2Fault == TRUE) ? "TRUE" : "FALSE")); |
| VpSysDebugPrintf("\n\rpDevObj->dynamicInfo.bat3Fault = %s", |
| ((dynamicInfo->bat3Fault == TRUE) ? "TRUE" : "FALSE")); |
| } |
| |
| void |
| VpPrintStaticInfoStruct( |
| VpDeviceStaticInfoType *staticInfo) |
| { |
| VpSysDebugPrintf("\n\rpDevObj->staticInfo.rcnPcn = 0x%02X 0x%02X", |
| staticInfo->rcnPcn[0], staticInfo->rcnPcn[1]); |
| VpSysDebugPrintf("\n\rpDevObj->staticInfo.maxChannels = %d", |
| staticInfo->maxChannels); |
| } |
| |
| /* Bit-wise values from VpDeviceStateType */ |
| void |
| VpPrintStateInformation( |
| uint16 state) |
| { |
| VpSysDebugPrintf("\n\n\rpDevObj->state = 0x%04X", state); |
| } |
| |
| void |
| VpPrintDeviceProfileStruct( |
| VpDeviceType deviceType, |
| void *devProfileData) |
| { |
| if (deviceType == VP_DEV_880_SERIES) { |
| #ifdef VP_CC_880_SERIES |
| VpSysDebugPrintf("\n\n\rpDevObj->devProfileData.profVersion = %d", |
| ((Vp880DeviceProfileType *)devProfileData)->profVersion); |
| VpSysDebugPrintf("\n\rpDevObj->devProfileData.pcmClkRate = %d", |
| ((Vp880DeviceProfileType *)devProfileData)->pcmClkRate); |
| VpSysDebugPrintf("\n\rpDevObj->devProfileData.tickRate = 0x%04X", |
| ((Vp880DeviceProfileType *)devProfileData)->tickRate); |
| VpSysDebugPrintf("\n\rpDevObj->devProfileData.devCfg1 = 0x%02X", |
| ((Vp880DeviceProfileType *)devProfileData)->devCfg1); |
| VpSysDebugPrintf("\n\rpDevObj->devProfileData.clockSlot = 0x%02X", |
| ((Vp880DeviceProfileType *)devProfileData)->clockSlot); |
| #endif |
| |
| } else if (deviceType == VP_DEV_890_SERIES) { |
| #ifdef VP_CC_890_SERIES |
| VpSysDebugPrintf("\n\n\rpDevObj->devProfileData.profVersion = %d", |
| ((Vp890DeviceProfileType *)devProfileData)->profVersion); |
| VpSysDebugPrintf("\n\rpDevObj->devProfileData.pcmClkRate = %d", |
| ((Vp890DeviceProfileType *)devProfileData)->pcmClkRate); |
| VpSysDebugPrintf("\n\rpDevObj->devProfileData.mClkMask = 0x%02X", |
| ((Vp890DeviceProfileType *)devProfileData)->mClkMask); |
| VpSysDebugPrintf("\n\rpDevObj->devProfileData.tickRate = 0x%04X", |
| ((Vp890DeviceProfileType *)devProfileData)->tickRate); |
| VpSysDebugPrintf("\n\rpDevObj->devProfileData.devCfg1 = 0x%02X", |
| ((Vp890DeviceProfileType *)devProfileData)->devCfg1); |
| VpSysDebugPrintf("\n\rpDevObj->devProfileData.clockSlot = 0x%02X", |
| ((Vp890DeviceProfileType *)devProfileData)->clockSlot); |
| |
| #ifdef VP890_FXS_SUPPORT |
| VpSysDebugPrintf("\n\rpDevObj->devProfileData.swParams = 0x%02X 0x%02X 0x%02X", |
| ((Vp890DeviceProfileType *)devProfileData)->swParams[0], |
| ((Vp890DeviceProfileType *)devProfileData)->swParams[1], |
| ((Vp890DeviceProfileType *)devProfileData)->swParams[2]); |
| VpSysDebugPrintf("\n\rpDevObj->devProfileData.timingParams = 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X", |
| ((Vp890DeviceProfileType *)devProfileData)->timingParams[0], |
| ((Vp890DeviceProfileType *)devProfileData)->timingParams[1], |
| ((Vp890DeviceProfileType *)devProfileData)->timingParams[2], |
| ((Vp890DeviceProfileType *)devProfileData)->timingParams[3], |
| ((Vp890DeviceProfileType *)devProfileData)->timingParams[4], |
| ((Vp890DeviceProfileType *)devProfileData)->timingParams[5]); |
| VpSysDebugPrintf("\n\rpDevObj->devProfileData.timingParamsFR = 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X", |
| ((Vp890DeviceProfileType *)devProfileData)->timingParamsFR[0], |
| ((Vp890DeviceProfileType *)devProfileData)->timingParamsFR[1], |
| ((Vp890DeviceProfileType *)devProfileData)->timingParamsFR[2], |
| ((Vp890DeviceProfileType *)devProfileData)->timingParamsFR[3], |
| ((Vp890DeviceProfileType *)devProfileData)->timingParamsFR[4], |
| ((Vp890DeviceProfileType *)devProfileData)->timingParamsFR[5]); |
| VpSysDebugPrintf("\n\rpDevObj->devProfileData.peakManagement = %s", |
| ((((Vp890DeviceProfileType *)devProfileData)->peakManagement == TRUE) ? "TRUE" : "FALSE")); |
| VpSysDebugPrintf("\n\rpDevObj->devProfileData.lowVoltOverride = %s", |
| ((((Vp890DeviceProfileType *)devProfileData)->lowVoltOverride == TRUE) ? "TRUE" : "FALSE")); |
| #endif /* VP890_FXS_SUPPORT */ |
| #endif /* VP_CC_890_SERIES */ |
| } |
| } |
| |
| void |
| VpPrintEventMaskStruct( |
| bool isDeviceInfo, |
| bool isMask, |
| VpOptionEventMaskType *eventMask) |
| { |
| char objectString[30]; |
| char lineOrDevString[30]; |
| |
| if (isMask) { |
| VpMemCpy(objectString, "EventsMask", sizeof("EventsMask")); |
| } else { |
| VpMemCpy(objectString, "Events", sizeof("Events")); |
| } |
| |
| if (isDeviceInfo) { |
| VpMemCpy(lineOrDevString, "pDevObj->device", sizeof("pDevObj->device")); |
| } else { |
| VpMemCpy(lineOrDevString, "pLineObj->line", sizeof("pLineObj->line")); |
| } |
| |
| VpSysDebugPrintf("\n\n\r%s%s.faults = 0x%04X", lineOrDevString, objectString, |
| eventMask->faults); |
| VpSysDebugPrintf("\n\r%s%s.signaling = 0x%04X", lineOrDevString, objectString, |
| eventMask->signaling); |
| VpSysDebugPrintf("\n\r%s%s.response = 0x%04X", lineOrDevString, objectString, |
| eventMask->response); |
| VpSysDebugPrintf("\n\r%s%s.test = 0x%04X", lineOrDevString, objectString, |
| eventMask->test); |
| VpSysDebugPrintf("\n\r%s%s.process = 0x%04X", lineOrDevString, objectString, |
| eventMask->process); |
| VpSysDebugPrintf("\n\r%s%s.fxo = 0x%04X", lineOrDevString, objectString, |
| eventMask->fxo); |
| VpSysDebugPrintf("\n\r%s%s.packet = 0x%04X", lineOrDevString, objectString, |
| eventMask->packet); |
| } |
| |
| void |
| VpPrintCriticalFltStruct( |
| VpOptionCriticalFltType *criticalFault) |
| { |
| VpSysDebugPrintf("\n\n\rpDevObj->criticalFault.acFltDiscEn = %s", |
| ((criticalFault->acFltDiscEn == TRUE) ? "TRUE" : "FALSE")); |
| VpSysDebugPrintf("\n\rpDevObj->criticalFault.dcFltDiscEn = %s", |
| ((criticalFault->dcFltDiscEn == TRUE) ? "TRUE" : "FALSE")); |
| VpSysDebugPrintf("\n\rpDevObj->criticalFault.thermFltDiscEn = %s", |
| ((criticalFault->thermFltDiscEn == TRUE) ? "TRUE" : "FALSE")); |
| } |
| |
| void |
| VpPrintGetResultsOptionStruct( |
| VpGetResultsOptionsType *getResultsOption) |
| { |
| VpSysDebugPrintf("\n\n\rpDevObj->getResultsOption.chanId = %d", |
| getResultsOption->chanId); |
| VpSysDebugPrintf("\n\rpDevObj->getResultsOption.optionType = 0x%04X", |
| getResultsOption->optionType); |
| { |
| uint8 byteCount; |
| uint8 *pOptionData = (uint8 *)(&getResultsOption->optionData); |
| uint8 optionSize = sizeof(VpGetResultsOptionsDataType); |
| |
| VpSysDebugPrintf("\n\rpDevObj->getResultsOption.optionData ="); |
| for (byteCount = 0; byteCount < optionSize; byteCount++) { |
| if (!(byteCount % 10)) { |
| VpSysDebugPrintf("\n\t"); |
| } |
| VpSysDebugPrintf(" 0x%02X", *pOptionData); |
| pOptionData++; |
| } |
| } |
| } |
| |
| void |
| VpPrintRelGainResultsStruct( |
| VpRelGainResultsType *relGainResults) |
| { |
| VpSysDebugPrintf("\n\n\rpDevObj->relGainResults.gResult = %d", |
| relGainResults->gResult); |
| VpSysDebugPrintf("\n\rpDevObj->relGainResults.gxValue = 0x%04X", |
| relGainResults->gxValue); |
| VpSysDebugPrintf("\n\rpDevObj->relGainResults.grValue = 0x%04X", |
| relGainResults->grValue); |
| } |
| |
| void |
| VpPrintDeviceProfileTable( |
| VpCSLACDeviceProfileTableType *devProfileTable) |
| { |
| uint8 byteCount; |
| |
| VpSysDebugPrintf("\n\n\rpDevObj->devProfileTable.pDevProfileTable ="); |
| for (byteCount = 0; byteCount < VP_CSLAC_DEV_PROF_TABLE_SIZE; byteCount++) { |
| if (!(byteCount % 10)) { |
| VpSysDebugPrintf("\n\t"); |
| } |
| VpSysDebugPrintf(" %p", devProfileTable->pDevProfileTable[byteCount]); |
| } |
| |
| VpSysDebugPrintf("\n\rpDevObj->devProfileTable.pAcProfileTable ="); |
| for (byteCount = 0; byteCount < VP_CSLAC_AC_PROF_TABLE_SIZE; byteCount++) { |
| if (!(byteCount % 10)) { |
| VpSysDebugPrintf("\n\t"); |
| } |
| VpSysDebugPrintf(" %p", devProfileTable->pAcProfileTable[byteCount]); |
| } |
| |
| VpSysDebugPrintf("\n\rpDevObj->devProfileTable.pDcProfileTable ="); |
| for (byteCount = 0; byteCount < VP_CSLAC_DC_PROF_TABLE_SIZE; byteCount++) { |
| if (!(byteCount % 10)) { |
| VpSysDebugPrintf("\n\t"); |
| } |
| VpSysDebugPrintf(" %p", devProfileTable->pDcProfileTable[byteCount]); |
| } |
| |
| VpSysDebugPrintf("\n\rpDevObj->devProfileTable.pRingingProfileTable ="); |
| for (byteCount = 0; byteCount < VP_CSLAC_RINGING_PROF_TABLE_SIZE; byteCount++) { |
| if (!(byteCount % 10)) { |
| VpSysDebugPrintf("\n\t"); |
| } |
| VpSysDebugPrintf(" %p", devProfileTable->pRingingProfileTable[byteCount]); |
| } |
| |
| VpSysDebugPrintf("\n\rpDevObj->devProfileTable.pToneCadProfileTable ="); |
| for (byteCount = 0; byteCount < VP_CSLAC_TONE_CADENCE_PROF_TABLE_SIZE; byteCount++) { |
| if (!(byteCount % 10)) { |
| VpSysDebugPrintf("\n\t"); |
| } |
| VpSysDebugPrintf(" %p", devProfileTable->pToneCadProfileTable[byteCount]); |
| } |
| |
| VpSysDebugPrintf("\n\rpDevObj->devProfileTable.pToneProfileTable ="); |
| for (byteCount = 0; byteCount < VP_CSLAC_TONE_PROF_TABLE_SIZE; byteCount++) { |
| if (!(byteCount % 10)) { |
| VpSysDebugPrintf("\n\t"); |
| } |
| VpSysDebugPrintf(" %p", devProfileTable->pToneProfileTable[byteCount]); |
| } |
| |
| VpSysDebugPrintf("\n\rpDevObj->devProfileTable.pRingingCadProfileTable ="); |
| for (byteCount = 0; byteCount < VP_CSLAC_RING_CADENCE_PROF_TABLE_SIZE; byteCount++) { |
| if (!(byteCount % 10)) { |
| VpSysDebugPrintf("\n\t"); |
| } |
| VpSysDebugPrintf(" %p", devProfileTable->pRingingCadProfileTable[byteCount]); |
| } |
| |
| VpSysDebugPrintf("\n\rpDevObj->devProfileTable.pMeteringProfileTable ="); |
| for (byteCount = 0; byteCount < VP_CSLAC_METERING_PROF_TABLE_SIZE; byteCount++) { |
| if (!(byteCount % 10)) { |
| VpSysDebugPrintf("\n\t"); |
| } |
| VpSysDebugPrintf(" %p", devProfileTable->pMeteringProfileTable[byteCount]); |
| } |
| |
| VpSysDebugPrintf("\n\rpDevObj->devProfileTable.pCallerIdProfileTable ="); |
| for (byteCount = 0; byteCount < VP_CSLAC_CALLERID_PROF_TABLE_SIZE; byteCount++) { |
| if (!(byteCount % 10)) { |
| VpSysDebugPrintf("\n\t"); |
| } |
| VpSysDebugPrintf(" %p", devProfileTable->pCallerIdProfileTable[byteCount]); |
| } |
| |
| VpSysDebugPrintf("\n\rpDevObj->devProfileTable.pFxoConfigProfileTable ="); |
| for (byteCount = 0; byteCount < VP_CSLAC_FXO_CONFIG_PROF_TABLE_SIZE; byteCount++) { |
| if (!(byteCount % 10)) { |
| VpSysDebugPrintf("\n\t"); |
| } |
| VpSysDebugPrintf(" %p", devProfileTable->pFxoConfigProfileTable[byteCount]); |
| } |
| |
| VpSysDebugPrintf("\n\rpDevObj->devProfileTable.pCustomTermProfileTable ="); |
| for (byteCount = 0; byteCount < VP_CSLAC_CUSTOM_TERM_PROF_TABLE_SIZE; byteCount++) { |
| if (!(byteCount % 10)) { |
| VpSysDebugPrintf("\n\t"); |
| } |
| VpSysDebugPrintf(" %p", devProfileTable->pCustomTermProfileTable[byteCount]); |
| } |
| } |
| |
| void |
| VpPrintProfileTableEntry( |
| VpCSLACProfileTableEntryType *profEntry) |
| { |
| VpSysDebugPrintf("\n\n\rpDevObj->profEntry.devProfEntry = 0x%04X", |
| profEntry->devProfEntry); |
| VpSysDebugPrintf("\n\rpDevObj->profEntry.acProfEntry = 0x%04X", |
| profEntry->acProfEntry); |
| VpSysDebugPrintf("\n\rpDevObj->profEntry.dcProfEntry = 0x%04X", |
| profEntry->dcProfEntry); |
| VpSysDebugPrintf("\n\rpDevObj->profEntry.ringingProfEntry = 0x%04X", |
| profEntry->ringingProfEntry); |
| VpSysDebugPrintf("\n\rpDevObj->profEntry.ringCadProfEntry = 0x%04X", |
| profEntry->ringCadProfEntry); |
| VpSysDebugPrintf("\n\rpDevObj->profEntry.toneProfEntry = 0x%04X", |
| profEntry->toneProfEntry); |
| VpSysDebugPrintf("\n\rpDevObj->profEntry.toneCadProfEntry = 0x%04X", |
| profEntry->toneCadProfEntry); |
| VpSysDebugPrintf("\n\rpDevObj->profEntry.meterProfEntry = 0x%04X", |
| profEntry->meterProfEntry); |
| VpSysDebugPrintf("\n\rpDevObj->profEntry.cidCadProfEntry = 0x%04X", |
| profEntry->cidCadProfEntry); |
| VpSysDebugPrintf("\n\rpDevObj->profEntry.fxoConfigProfEntry = 0x%04X", |
| profEntry->fxoConfigProfEntry); |
| VpSysDebugPrintf("\n\rpDevObj->profEntry.customTermProfEntry = 0x%04X", |
| profEntry->customTermProfEntry); |
| } |
| |
| #if defined (VP890_FXS_SUPPORT) || defined (VP880_FXS_SUPPORT) |
| void |
| VpPrintPulseSpecs( |
| uint8 specNumber, |
| VpOptionPulseType *pulseSpecs) |
| { |
| char specString[2] = {'\0', '\0'}; |
| |
| if (specNumber == 1) { |
| specString[0] = '2'; |
| } |
| |
| VpSysDebugPrintf("\n\n\rpDevObj->pulseSpecs%s.breakMin = %d", |
| specString, pulseSpecs->breakMin); |
| VpSysDebugPrintf("\n\rpDevObj->pulseSpecs%s.breakMax = %d", |
| specString, pulseSpecs->breakMax); |
| VpSysDebugPrintf("\n\rpDevObj->pulseSpecs%s.makeMin = %d", |
| specString, pulseSpecs->makeMin); |
| VpSysDebugPrintf("\n\rpDevObj->pulseSpecs%s.makeMax = %d", |
| specString, pulseSpecs->makeMax); |
| VpSysDebugPrintf("\n\rpDevObj->pulseSpecs%s.interDigitMin = %d", |
| specString, pulseSpecs->interDigitMin); |
| VpSysDebugPrintf("\n\rpDevObj->pulseSpecs%s.flashMin = %d", |
| specString, pulseSpecs->flashMin); |
| VpSysDebugPrintf("\n\rpDevObj->pulseSpecs%s.flashMax = %d", |
| specString, pulseSpecs->flashMax); |
| #ifdef EXTENDED_FLASH_HOOK |
| VpSysDebugPrintf("\n\rpDevObj->pulseSpecs%s.onHookMin = %d", |
| specString, pulseSpecs->onHookMin); |
| #endif |
| |
| } |
| |
| void |
| VpPrintDPStateMachine( |
| uint8 stateMachineNum, |
| VpDialPulseDetectType *dpStruct) |
| { |
| char specString[2] = {'\0', '\0'}; |
| char *dpState[4] = { |
| "VP_DP_DETECT_STATE_LOOP_OPEN", |
| "VP_DP_DETECT_STATE_LOOP_CLOSE", |
| "VP_DP_DETECT_STATE_IDLE", |
| "UNKNOWN" |
| }; |
| uint8 stateIndex = (dpStruct->state < 3) ? dpStruct->state : 3; |
| |
| if (stateMachineNum == 1) { |
| specString[0] = '2'; |
| } |
| |
| VpSysDebugPrintf("\n\n\rpLineObj->dpStruct%s.digits = %d", |
| specString, dpStruct->digits); |
| VpSysDebugPrintf("\n\rpLineObj->dpStruct%s.lo_time = %d", |
| specString, dpStruct->lo_time); |
| VpSysDebugPrintf("\n\rpLineObj->dpStruct%s.lc_time = %d", |
| specString, dpStruct->lc_time); |
| VpSysDebugPrintf("\n\rpLineObj->dpStruct%s.state = %d:%s", |
| specString, dpStruct->state, dpState[stateIndex]); |
| VpSysDebugPrintf("\n\rpLineObj->dpStruct%s.hookSt = %s", |
| specString, ((dpStruct->hookSt == TRUE) ? "TRUE" : "FALSE")); |
| VpSysDebugPrintf("\n\rpLineObj->dpStruct%s.signalingData = %d\n\r", |
| specString, dpStruct->signalingData); |
| } |
| |
| #endif /* defined (VP890_FXS_SUPPORT) || defined (VP880_FXS_SUPPORT) */ |
| |
| void |
| VpPrintDeviceTimers( |
| uint16 devTimer[VP_DEV_TIMER_LAST]) |
| { |
| uint8 byteCount; |
| char *timerNames[VP_DEV_TIMER_LAST] = { |
| "VP_DEV_TIMER_TESTLINE", "VP_DEV_TIMER_CLKFAIL", "VP_DEV_TIMER_ABSCAL", |
| "VP_DEV_TIMER_LP_CHANGE", "VP_DEV_TIMER_ABV_CAL", "VP_DEV_TIMER_ENTER_RINGING", |
| "VP_DEV_TIMER_EXIT_RINGING", "VP_DEV_TIMER_WB_MODE_CHANGE" |
| }; |
| |
| VpSysDebugPrintf("\n\rpDevObj->devTimer ="); |
| for (byteCount = 0; byteCount < VP_DEV_TIMER_LAST; byteCount++) { |
| if (!(byteCount % 10)) { |
| VpSysDebugPrintf("\n\t"); |
| } |
| VpSysDebugPrintf(" 0x%04X", devTimer[byteCount]); |
| if (devTimer[byteCount] & VP_ACTIVATE_TIMER) { |
| VpSysDebugPrintf(" - %s is Active\n\t", timerNames[byteCount]); |
| } |
| } |
| } |
| |
| #endif /* VP_CC_DEBUG_SELECT & VP_DBG_ERROR */ |
| #endif /* defined (VP_CC_880_SERIES) || defined (VP_CC_890_SERIES) */ |
| |
| #endif /* VP_DEBUG */ |
