| /** \file vp792_api.h |
| * vp792_api.h |
| * |
| * Header file that define all the commands for the Vp792 device. |
| * |
| * Copyright (c) 2010, Zarlink Semiconductor, Inc. |
| * |
| * $Revision: 8475 $ |
| * $LastChangedDate: 2011-04-05 11:30:04 -0500 (Tue, 05 Apr 2011) $ |
| */ |
| |
| #ifndef VP792_API_H |
| #define VP792_API_H |
| |
| #define VP792_MIN_SLAC_ID 0 |
| #define VP792_MAX_SLAC_ID 7 |
| |
| #define VP792_MAX_OUTSTANDING_RESPONSES 10 |
| |
| /* Maximum number of profiles of each type in the Profile Table: */ |
| #define VP_792_DEV_PROF_TABLE_SIZE 1 |
| #define VP_792_AC_PROF_TABLE_SIZE 2 |
| #define VP_792_DC_PROF_TABLE_SIZE 2 |
| #define VP_792_RINGING_PROF_TABLE_SIZE 2 |
| #define VP_792_TONE_CADENCE_PROF_TABLE_SIZE 11 |
| #define VP_792_TONE_PROF_TABLE_SIZE 10 |
| #define VP_792_RING_CADENCE_PROF_TABLE_SIZE 4 |
| #define VP_792_METERING_PROF_TABLE_SIZE 2 |
| #define VP_792_CALLERID_PROF_TABLE_SIZE 2 |
| |
| /* Maximum length of each type of profile (bytes): */ |
| #define VP792_DEV_PROFILE_LEN 45 |
| #define VP792_DC_PROFILE_LEN 44 |
| #define VP792_AC_PROFILE_LEN 128 |
| #define VP792_CID_PROFILE_LEN 200 |
| #define VP792_MTR_PROFILE_LEN 22 |
| #define VP792_TONE_PROFILE_LEN 32 |
| #define VP792_RINGCAD_PROFILE_LEN 72 |
| #define VP792_TONECAD_PROFILE_LEN 72 |
| #define VP792_RING_PROFILE_LEN 38 |
| |
| /* Lengths of profile sections that need to be stored or otherwise handled |
| * separately from the whole. (words) */ |
| #define VP792_AC_PROFILE_REGDATA_LEN 1 |
| #define VP792_DC_PROFILE_REGDATA_LEN 22 |
| #define VP792_RING_PROFILE_REGDATA_LEN 34 |
| |
| typedef enum |
| { |
| VP_792_SEQ_OFF, |
| VP_792_SEQ_RING, |
| VP_792_SEQ_TONE, |
| VP_792_SEQ_OTHER |
| } Vp792SequencerUseType; |
| |
| #include "vp_hal.h" |
| |
| /* Struct for the Profile Table: */ |
| typedef struct { |
| #define VP792_NUM_PROFILE_TYPES 9 |
| uint16 valid[VP792_NUM_PROFILE_TYPES]; |
| |
| #ifdef VP_COMMON_ADDRESS_SPACE |
| /* We only need to save profile pointers in the device object. */ |
| VpProfilePtrType pDevice[VP_792_DEV_PROF_TABLE_SIZE]; |
| VpProfilePtrType pAc[VP_792_AC_PROF_TABLE_SIZE]; |
| VpProfilePtrType pDc[VP_792_DC_PROF_TABLE_SIZE]; |
| VpProfilePtrType pRinging[VP_792_RINGING_PROF_TABLE_SIZE]; |
| VpProfilePtrType pRingCad[VP_792_RING_CADENCE_PROF_TABLE_SIZE]; |
| VpProfilePtrType pTone[VP_792_TONE_PROF_TABLE_SIZE]; |
| VpProfilePtrType pMetering[VP_792_METERING_PROF_TABLE_SIZE]; |
| VpProfilePtrType pCallerId[VP_792_CALLERID_PROF_TABLE_SIZE]; |
| VpProfilePtrType pToneCad[VP_792_TONE_CADENCE_PROF_TABLE_SIZE]; |
| #else |
| /* Profiles must be copied into the device object. */ |
| VpProfileDataType device[VP_792_DEV_PROF_TABLE_SIZE][VP792_DEV_PROFILE_LEN]; |
| VpProfileDataType ac[VP_792_AC_PROF_TABLE_SIZE][VP792_AC_PROFILE_LEN]; |
| VpProfileDataType dc[VP_792_DC_PROF_TABLE_SIZE][VP792_DC_PROFILE_LEN]; |
| VpProfileDataType ringing[VP_792_RINGING_PROF_TABLE_SIZE][VP792_RING_PROFILE_LEN]; |
| VpProfileDataType ringCad[VP_792_RING_CADENCE_PROF_TABLE_SIZE][VP792_RINGCAD_PROFILE_LEN]; |
| VpProfileDataType tone[VP_792_TONE_PROF_TABLE_SIZE][VP792_TONE_PROFILE_LEN]; |
| VpProfileDataType metering[VP_792_METERING_PROF_TABLE_SIZE][VP792_MTR_PROFILE_LEN]; |
| VpProfileDataType callerId[VP_792_CALLERID_PROF_TABLE_SIZE][VP792_CID_PROFILE_LEN]; |
| VpProfileDataType toneCad[VP_792_TONE_CADENCE_PROF_TABLE_SIZE][VP792_TONECAD_PROFILE_LEN]; |
| #endif |
| |
| } Vp792ProfileTableType; |
| |
| typedef enum |
| { |
| VP792_REQUEST_SET_REL_GAIN, |
| VP792_REQUEST_GET_LOOP_COND, |
| VP792_REQUEST_GET_OPTION, |
| VP792_REQUEST_DEVICE_IO_ACCESS_EXT, |
| VP792_REQUEST_LINE_IO_ACCESS, |
| VP792_REQUEST_QUERY, |
| VP792_REQUEST_LOW_LEVEL_CMD_16, |
| VP792_REQUEST_SENDSIG_MSGWAIT, |
| VP792_REQUEST_TEST_INTERNAL, |
| VP792_REQUEST_TEST_CMP, |
| VP792_REQUEST_TIMER_CMP, |
| VP792_REQUEST_REGISTER_DUMP |
| } Vp792RequestTagType; |
| |
| /* Struct for information about pending responses (used in |
| VpGetResults()): */ |
| typedef struct { |
| bool outstanding; |
| |
| Vp792RequestTagType requestType; |
| |
| union { |
| struct { |
| uint16 handle; |
| uint8 channelId; |
| } setRelGain; |
| |
| struct { |
| uint16 handle; |
| uint8 channelId; |
| } getLoopCond; |
| |
| struct { |
| uint16 handle; |
| uint8 channelId; |
| VpOptionIdType optionId; |
| } getOption; |
| |
| struct { |
| VpDeviceIoAccessExtType deviceIoAccess; |
| } deviceIoAccessExt; |
| |
| struct { |
| uint16 handle; |
| VpLineIoAccessType lineIoAccess; |
| } lineIoAccess; |
| |
| struct { |
| uint16 handle; |
| uint8 channelId; |
| VpQueryIdType queryId; |
| } query; |
| |
| struct { |
| uint16 handle; |
| uint8 channelId; |
| VpLowLevelCmdType cmdType; |
| uint16 writeWords[2]; |
| uint8 numWriteWords; |
| uint8 numReadWords; |
| } lowLevelCmd16; |
| |
| struct { |
| uint16 eventId; |
| uint16 handle; |
| uint8 channelId; |
| uint16 respSize; |
| uint16 cmdId; |
| } testLine; |
| |
| struct { |
| uint16 handle; |
| uint8 channelId; |
| bool internal; |
| } genTimer; |
| |
| struct { |
| uint8 channelId; |
| uint8 commandId; |
| uint8 numReadWords; |
| } registerDump; |
| } args; |
| } Vp792ResponseRequestType; |
| |
| typedef struct { |
| uint32 opaqueData[2400]; |
| } Vp792OpaquePmDevObjType; |
| |
| /* Vp792-specific Device Object */ |
| typedef struct { |
| /* Customer-defined device identifier struct, passed to HAL functions: */ |
| VpDeviceIdType deviceId; |
| |
| /* Slac identifier mapped with VpMapSlacId(). This member allows for |
| multiple device objects to share a common deviceId (which is the case |
| when they share a chip-select on the SPI bus). */ |
| uint8 slacId; |
| |
| /* Total number of channels controlled by this device: */ |
| uint8 maxChannels; |
| |
| /* SLAC revision info */ |
| struct { |
| uint16 device; |
| uint16 product; |
| uint16 version; |
| uint32 patchAddress; |
| } rev; |
| |
| /* A flag indicating whether VpInitDevice() has completed: */ |
| bool devInit; |
| |
| /* The Profile Table: */ |
| Vp792ProfileTableType profTable; |
| |
| /* PCM Clock Rate in units of 1KHz */ |
| uint16 pcmClockRate; |
| |
| /* High bits of the VP-API-II timestamp. We maintain the high bits here |
| because the SLAC's timestamp has finer granularity. */ |
| uint16 timeStampHiBits; |
| |
| /* Struct for locally-maintained device-specific options: */ |
| struct { |
| VpOptionCriticalFltType criticalFlt; |
| VpOptionEventMaskType eventMask; |
| uint16 pulseEnabled; |
| uint16 dtmfEnabled; |
| VpOptionParkModeType parkMode; |
| uint32 debugSelect; |
| } options; |
| |
| /* Temporary storage for interrupt indication, while command mailbox is busy. */ |
| uint16 intInd[2]; |
| |
| /* Array for keeping track of outstanding response requests: */ |
| Vp792ResponseRequestType responseRequest[VP792_MAX_OUTSTANDING_RESPONSES]; |
| |
| /* Index (in the above array) of the next result to be returned by |
| VpGetResults(): */ |
| uint16 requestIdx; |
| |
| /* SLAC response mailbox cache (temporary storage used in cases of mailbox |
| congestion, where we need to empty the response mailbox before we can |
| issue another command in the command mailbox): */ |
| struct { |
| uint8 count; /* When the cache is nonempty, count > 0. */ |
| #define VP792_MAX_RSPSIZE 42 |
| uint16 data[2][VP792_MAX_RSPSIZE]; |
| } respMboxCache; |
| |
| /* Bitmask indicating which device-specific event handlers are running. */ |
| uint16 eventHandlers; |
| |
| /* State variables for EhInitDevice() event handler: */ |
| struct { |
| |
| #ifdef VP_COMMON_ADDRESS_SPACE |
| /* We only need to save profile pointers in the line object. */ |
| VpProfilePtrType pDevProfile; |
| VpProfilePtrType pAcProfile; |
| VpProfilePtrType pDcProfile; |
| VpProfilePtrType pRingProfile; |
| #else |
| /* Profiles must be copied into the line object. */ |
| uint16 profilesValid; |
| VpProfileDataType devProfile[VP792_DEV_PROFILE_LEN]; |
| VpProfileDataType acProfile[VP792_AC_PROFILE_LEN]; |
| VpProfileDataType dcProfile[VP792_DC_PROFILE_LEN]; |
| VpProfileDataType ringProfile[VP792_RING_PROFILE_LEN]; |
| #endif |
| |
| } ehInitDevice; |
| |
| #ifdef VP792_INCLUDE_TESTLINE_CODE |
| Vp792OpaquePmDevObjType opaquePmDevObj; |
| #endif |
| |
| } Vp792DeviceObjectType; |
| |
| /* Vp792-specific Line Object */ |
| typedef struct |
| { |
| |
| /* Number used by the Vp792 to uniquely identify this line: */ |
| uint8 channelId; |
| |
| /* Line termination type: */ |
| VpTermType termType; |
| |
| /* Customer-defined line identifier struct, returned in the event |
| * structure by VpGetEvent() when an event occurs on this line: */ |
| VpLineIdType lineId; |
| |
| /* A flag indicating whether VpInitLine() has completed: */ |
| bool lineInit; |
| |
| /* Struct for locally-maintained line-specific options: */ |
| struct { |
| VpOptionDtmfModeControlType dtmfControlMode; |
| VpOptionZeroCrossType zeroCross; |
| VpOptionPulseModeType pulseMode; |
| VpOptionEventMaskType eventMask; |
| VpOptionRingControlType ringControl; |
| VpOptionPcmTxRxCntrlType pcmTxRxCntrl; |
| VpOptionLoopbackType loopback; |
| uint16 afeConfig; /* cached AFE_CONFIG value for loopback option */ |
| uint32 debugSelect; |
| } options; |
| |
| struct { |
| #ifdef VP_COMMON_ADDRESS_SPACE |
| /* We only need to save profile pointers in the line object. */ |
| VpProfilePtrType pAc; |
| VpProfilePtrType pDc; |
| VpProfilePtrType pRinging; |
| VpProfilePtrType pRingCad; |
| VpProfilePtrType pTone; |
| VpProfilePtrType pMetering; |
| VpProfilePtrType pCallerId; |
| VpProfilePtrType pToneCad; |
| #else |
| /* Profiles must be copied into the line object. */ |
| uint16 valid; |
| VpProfileDataType ac[VP792_AC_PROFILE_LEN]; |
| VpProfileDataType dc[VP792_DC_PROFILE_LEN]; |
| VpProfileDataType ringing[VP792_RING_PROFILE_LEN]; |
| VpProfileDataType ringCad[VP792_RINGCAD_PROFILE_LEN]; |
| VpProfileDataType tone[VP792_TONE_PROFILE_LEN]; |
| VpProfileDataType metering[VP792_MTR_PROFILE_LEN]; |
| VpProfileDataType callerId[VP792_CID_PROFILE_LEN]; |
| VpProfileDataType toneCad[VP792_TONECAD_PROFILE_LEN]; |
| #endif |
| |
| } profiles; |
| |
| /* Bitmask indicating which line-specific event handlers are running. */ |
| uint16 eventHandlers; |
| |
| /* State variables for EhSetLineState() event handler: */ |
| struct { |
| bool waitForMeterAbort; |
| bool waitForSequencerReady; |
| VpLineStateType newState; |
| } ehSetLineState; |
| |
| /* Current API line state */ |
| VpLineStateType currentState; |
| |
| /* Currently-detected ongoing DTMF digit (if any): */ |
| uint16 dtmfDigitDetected; |
| |
| /* Sequencer state variables: */ |
| struct { |
| |
| /* If a sequencer-abort command has been sent to the SLAC, but the |
| VP792_EVID_SEQ event has not yet arrived, this is TRUE. */ |
| bool aborting; |
| |
| /* Event handlers which will be started only after the current |
| sequence is aborted: */ |
| uint16 deferredHandlers; |
| |
| /* Keeps track of what, if anything, is using the sequencer. */ |
| Vp792SequencerUseType activeSequence; |
| |
| /* Buffer for holding a new sequencer program while we wait for the |
| old sequence to be aborted: */ |
| #define _VP792_CMDSIZE_WR_SEQ_CTL 35 |
| uint16 program[_VP792_CMDSIZE_WR_SEQ_CTL]; |
| |
| /* Register values are cached here during hook mask and RX-disable |
| intervals: */ |
| uint16 lastDsh; |
| uint16 lastVpCfg2; |
| |
| bool hookMaskInterval; |
| } sequencer; |
| |
| /* State variables for VpSendSignal(): */ |
| struct { |
| |
| /* Stores the ongoing send signal type (if any), and the one that will |
| be applied when the sequencer becomes available. */ |
| VpSendSignalType currentSignal; |
| VpSendSignalType newSignal; |
| |
| /* Stores the value that was in the DRIVE_ST variable before the signal |
| started. */ |
| uint16 driveSt; |
| |
| /* State variables for Vp792SendSignal(VP_SENDSIG_MSG_WAIT_PULSE): */ |
| struct { |
| int16 voltage; |
| |
| struct { |
| struct { |
| uint16 v1; |
| uint16 vas; |
| uint16 ila; |
| } on; |
| struct { |
| uint16 v1; |
| uint16 vas; |
| uint16 ila; |
| } off; |
| |
| uint16 vasOffset; |
| uint16 rfd; |
| uint16 rptc; |
| } dcParams; |
| |
| bool readingDcParams; |
| bool aborting; |
| |
| uint16 requestIdx; /* for RD_DC_PARAMS request */ |
| } msgWait; |
| } sendSig; |
| |
| /* Caller ID state variables */ |
| struct { |
| |
| /* Currently active Caller ID profile. This will be the same as |
| profiles.pCidProfile if VpInitRing() was called, but it will be |
| different if VpSendCid() was called. */ |
| #ifdef VP_COMMON_ADDRESS_SPACE |
| VpProfilePtrType pCidProfile; |
| #else |
| uint16 cidProfileValid; |
| VpProfileDataType cidProfile[VP792_CID_PROFILE_LEN]; |
| #endif |
| |
| /* Sending data using FSK or DTMF? */ |
| bool isFsk; |
| |
| /* FSK data state */ |
| struct { |
| /* Whether the API should compute the checksum */ |
| bool autoChecksum; |
| |
| /* SLAC device buffer status bits */ |
| uint8 bufStatus; |
| |
| /* Preamble */ |
| uint16 seizureBits; |
| uint16 markBits; |
| |
| uint8 checksum; |
| } fsk; |
| |
| struct { |
| /* Message data buffer */ |
| bool nonempty; |
| uint8 buf[VP_SIZEOF_CID_MSG_BUFFER * 2]; |
| uint8 head; |
| uint8 tail; |
| } data; |
| |
| bool dtmfDetectInterval; |
| uint8 dtmfTones[2]; |
| } callerId; |
| |
| /* Metering state variables */ |
| struct { |
| bool active; |
| uint16 eventRate; |
| } metering; |
| } Vp792LineObjectType; |
| |
| /* Vp792 Group Device Object */ |
| |
| typedef struct |
| { |
| |
| VpDeviceIdType deviceId; |
| |
| /* Temporary storage for interrupt indication, while mailbox is busy. */ |
| uint16 intInd[2]; |
| |
| } Vp792GroupDeviceObjectType; |
| |
| #endif /* VP792_API_H */ |
