ASR_BASE
Change-Id: Icf3719cc0afe3eeb3edc7fa80a2eb5199ca9dda1
diff --git a/marvell/services/dxslic/api_lib/src/dxs_api.c b/marvell/services/dxslic/api_lib/src/dxs_api.c
new file mode 100644
index 0000000..0b58fbd
--- /dev/null
+++ b/marvell/services/dxslic/api_lib/src/dxs_api.c
@@ -0,0 +1,2056 @@
+/******************************************************************************
+
+ Copyright (c) 2006-2015 Lantiq Deutschland GmbH
+ Copyright (c) 2015 Lantiq Beteiligungs-GmbH & Co.KG
+ Copyright 2018, Intel Corporation.
+
+ For licensing information, see the file 'LICENSE' in the root folder of
+ this software module.
+
+******************************************************************************/
+
+/**
+ \file dxs_api.c
+ This file contains the function prototypes specific to the DXS library
+ interface and is used by applications.
+*/
+
+/* ========================================================================== */
+/* Includes */
+/* ========================================================================== */
+#include "dxs.h"
+#include "dxs_init.h"
+#include "dxs_errno.h"
+#include "dxs_error.h"
+#include "dxs_config.h"
+#include "dxs_bbd.h"
+#include "dxs_wait.h"
+#include "dxs_sdd.h"
+#include "dxs_gpio.h"
+#include "dxs_cid.h"
+#include "dxs_pcm.h"
+#include "dxs_dwld.h"
+#include "dxs_sig.h"
+#include "dxs_debug_api.h"
+#include "dxs_event.h"
+#include "dxs_dcdc_hw.h"
+#include "dxs_ring.h"
+
+/* ========================================================================== */
+/* Macro definitions */
+/* ========================================================================== */
+#define DXS_DEV_CTX_GET \
+ do { \
+ pDev = dxs_get_dev(dxs); \
+ if (pDev == NULL) { \
+ DXS_ERROR_PUSH(DXS_statusDevNotFound); \
+ return DXS_statusDevNotFound; \
+ } \
+ } while(0)
+
+#define DXS_DEV_INIT_VALIDATE \
+ do { \
+ if (!(pDev->flags & DXS_DEV_INITIALIZED)) { \
+ DXS_ERROR_PUSH(DXS_statusDevNotInitialized); \
+ return DXS_statusDevNotInitialized; \
+ } \
+ } while(0)
+
+#define DXS_CH_CTX_GET \
+ do { \
+ if (line >= pDev->nChannels) { \
+ DXS_ERROR_PUSH(DXS_statusChannelNotFound); \
+ return DXS_statusChannelNotFound; \
+ } \
+ pCh = &pDev->pChannel[line]; \
+ if (pCh == NULL){ \
+ DXS_ERROR_PUSH(DXS_statusChannelNotFound); \
+ return DXS_statusChannelNotFound; \
+ } \
+ } while(0)
+
+#define DXS_API_EXIT(ret) \
+ do { \
+ if (ret != DXS_statusOk) { \
+ DXS_ERROR_PUSH(ret); \
+ } \
+ return ret; \
+ } while(0)
+
+#define DXS_DEV_API_ENTRY \
+ do { \
+ DXS_DEV_CTX_GET; \
+ DXS_ERROR_RESET; \
+ DXS_DEV_INIT_VALIDATE; \
+ } while(0)
+
+#define DXS_CH_API_ENTRY \
+ do { \
+ DXS_DEV_API_ENTRY; \
+ DXS_CH_CTX_GET; \
+ } while(0)
+
+/* ========================================================================== */
+/* Type definitions */
+/* ========================================================================== */
+
+/* ========================================================================== */
+/* Global variables */
+/* ========================================================================== */
+
+/* ========================================================================== */
+/* Function prototypes */
+/* ========================================================================== */
+
+/* ========================================================================== */
+/* Function implementation */
+/* ========================================================================== */
+/**
+ DXS Device Init
+
+ \param dxs - device number
+ \param chipSelect - CS number
+ \param irqNumber - IRQ line number
+ \param dcdcType - DCDC variant handled by DXS_DCDC_Var_t type
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsInit(uint8_t dxs, uint8_t chipSelect, int32_t irqNumber,
+ uint8_t dcdcType, uint8_t acc_mode)
+{
+ DXS_DEVICE_t *pDev;
+ int32_t ret;
+
+ DXS_DEV_CTX_GET;
+ DXS_ERROR_RESET;
+
+ ret = dxs_init(pDev, chipSelect, irqNumber, dcdcType, acc_mode, dxs);
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ DXS Device Exit
+
+ \param dxs - device number
+
+ \return
+ - DXS_statusOk
+*/
+int32_t DxsExit(uint8_t dxs)
+{
+ DXS_DEVICE_t *pDev;
+ int32_t ret;
+
+ DXS_DEV_API_ENTRY;
+
+ ret = dxs_exit(pDev);
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ DXS BBD Download
+
+ \param dxs - channel number
+ \param pBbd - pointer to BBD data
+ \param nBytes - BBD data size
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsBBD(uint8_t dxs, uint8_t line, uint8_t *pBbd, uint32_t nBytes)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret;
+
+ DXS_CH_API_ENTRY;
+
+ ret = dxs_bbd_download(pCh, pBbd, nBytes);
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ DXS PRAM Patch Download
+
+ \param dxs - device number
+ \param pPatch - pointer to PRAM patch data
+ \param nBytes - PRAM patch data size
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsPatch(uint8_t dxs, uint8_t *pPatch, uint32_t nBytes)
+{
+ DXS_DEVICE_t *pDev;
+ int32_t ret;
+
+ DXS_DEV_API_ENTRY;
+
+ ret = DXS_FW_Select(pDev, pPatch, nBytes);
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ DXS Firmware Capabilities Read
+
+ \param dxs - device number
+ \param pCap - pointer to DXS_Caps_t structure
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsCapabilitiesRead(uint8_t dxs, DXS_Caps_t *pCap)
+{
+ DXS_DEVICE_t *pDev;
+ int32_t ret;
+
+ DXS_DEV_API_ENTRY;
+
+ ret = dxs_caps_read(pDev, pCap);
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ DXS Version Read
+
+ \param dxs - device number
+ \param pVersion - pointer to DXS_Version_t structure
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsVersionRead(uint8_t dxs, DXS_Version_t *pVersion)
+{
+ DXS_DEVICE_t *pDev;
+ int32_t ret;
+
+ DXS_DEV_API_ENTRY;
+
+ ret = dxs_vers_read(pDev, pVersion);
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ DXS Sleep Mode Enable
+
+ \param dxs - device number
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsSleepEnable(uint8_t dxs)
+{
+ DXS_DEVICE_t *pDev;
+ int32_t ret;
+
+ DXS_DEV_API_ENTRY;
+
+ ret = dxs_sleep(pDev, 1);
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ DXS Sleep Mode Disable
+
+ \param dxs - device number
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsSleepDisable(uint8_t dxs)
+{
+ DXS_DEVICE_t *pDev;
+ int32_t ret;
+
+ DXS_DEV_API_ENTRY;
+
+ ret = dxs_sleep(pDev, 0);
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ PCM Interface Enable
+
+ \param dxs - device number
+ \param xoff - transmit bit offset
+ \param dbl - double bit clock
+ \param xs - transmit slope
+ \param rs - receive slope
+ \param drv0 - bit 0 drive length
+ \param sh - shift control
+ \param roff - receive bit offset
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsPcmInterfaceEnable(uint8_t dxs, uint8_t xoff, uint8_t dbl,
+ uint8_t xs, uint8_t rs, uint8_t drv0,
+ uint8_t sh, uint8_t roff)
+{
+ DXS_DEVICE_t *pDev;
+ int32_t ret;
+
+ DXS_DEV_API_ENTRY;
+
+ ret = dxs_pcm_if_config(pDev, xoff, dbl, xs, rs, drv0, sh, roff);
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ PCM Channel Enable
+
+ \param dxs - device number
+ \param line - line number
+ \param wb - wideband
+ \param wbtsc - wideband PCM time slot configuration
+ \param codec - codec
+ \param xts - transmit highway time slot
+ \param rts - receive highway time slot
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsPcmChannelEnable(uint8_t dxs, uint8_t line, uint8_t wb, uint8_t wbtsc,
+ uint8_t codec, uint8_t xts, uint8_t rts)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret;
+
+ DXS_CH_API_ENTRY;
+
+ ret = dxs_pcm_ch_act(pCh, wb, wbtsc, codec, xts, rts);
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ PCM Channel Disable
+
+ \param dxs - device number
+ \param line - line number
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsPcmChannelDisable(uint8_t dxs, uint8_t line)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret;
+
+ DXS_CH_API_ENTRY;
+
+ ret = dxs_pcm_ch_deact(pCh);
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ PCM Channel Mute in RX direction
+
+ \param dxs - device number
+ \param line - line number
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsPcmChannelMute(uint8_t dxs, uint8_t line)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret;
+
+ DXS_CH_API_ENTRY;
+
+ ret = dxs_pcm_ch_mute(pCh, 1);
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ PCM Channel Unmute in RX direction
+
+ \param dxs - device number
+ \param line - line number
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsPcmChannelUnmute(uint8_t dxs, uint8_t line)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret;
+
+ DXS_CH_API_ENTRY;
+
+ ret = dxs_pcm_ch_mute(pCh, 0);
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ Ring configuration
+
+ \param dxs - device number
+ \param line - line number
+ \param waveForm - waveform type
+ \param crestFactor - crest factor
+ \param frequency - frequency
+ \param amplitude - amplitude
+ \param dcOffset - DC offset
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsRingConfig(uint8_t dxs, uint8_t line, uint8_t waveForm,
+ uint8_t crestFactor, uint8_t frequency,
+ uint16_t amplitude, uint16_t dcOffset)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret;
+
+ DXS_CH_API_ENTRY;
+
+ ret = DXS_SDD_RingConfigAPI(pCh, waveForm, crestFactor, frequency,
+ amplitude, dcOffset);
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ Message Waiting Lamp configuration
+
+ \param dxs - device number
+ \param line - line number
+ \param voltage - voltage
+ \param thresh - threshold
+ \param slope - slope
+ \param onTime - on-time
+ \param offTime - off-time
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsMwlConfig(uint8_t dxs, uint8_t line, uint8_t voltage, uint8_t thresh,
+ uint16_t slope, uint16_t onTime, uint16_t offTime)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret;
+
+ DXS_CH_API_ENTRY;
+
+ ret = DXS_SDD_MwlConfigAPI(pCh, voltage, thresh, slope, onTime, offTime);
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ Digital gain configuration
+
+ \param dxs - device number
+ \param line - line number
+ \param usg - upstream relative level setting
+ \param dsg - downstream relative level setting
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsGainsSet(uint8_t dxs, uint8_t line, int16_t TxGain, int16_t RxGain)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret;
+
+ DXS_CH_API_ENTRY;
+
+ ret = DXS_SDD_GainSet(pCh, TxGain, RxGain);
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ Digital gain readback
+
+ \param dxs - device number
+ \param line - line number
+ \param pusg - pointer to upstream relative level setting
+ \param pdsg - pointer to downstream relative level setting
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsGainsGet(uint8_t dxs, uint8_t line, int16_t *pTxGain, int16_t *pRxGain)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret;
+
+ DXS_CH_API_ENTRY;
+
+ ret = DXS_SDD_GainGet(pCh, pTxGain, pRxGain);
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ Line feeding mode set
+
+ \param dxs - device number
+ \param line - line number
+ \param mode - line feeding mode
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsLineModeSet(uint8_t dxs, uint8_t line, int mode)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret;
+
+ DXS_CH_API_ENTRY;
+
+ /* We need to signal that calibration was started by API */
+ if (mode == DXS_LINE_FEED_CALIBRATE)
+ (void) DXS_SDD_CalibrationInternalSet(pCh, 0);
+ ret = DXS_SDD_LineModeSet(pCh, mode);
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ Line feeding mode read
+
+ \param dxs - device number
+ \param line - line number
+ \param pMode - pointer to line feeding mode
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsLineModeGet(uint8_t dxs, uint8_t line, int *pMode)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret;
+
+ DXS_CH_API_ENTRY;
+
+ ret = DXS_SDD_LineModeGet(pCh, pMode);
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ Read from DXS internal register
+ (requires --enable-debug-api)
+
+ \param dxs - device number
+ \param offset - register offset
+ \param pValue - pointer to value returned
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsDebugRegRead16(uint8_t dxs, uint8_t offset, uint16_t *pValue)
+{
+ DXS_DEVICE_t *pDev;
+ int32_t ret = DXS_statusFeatNotCompiledIn;
+
+ DXS_DEV_API_ENTRY;
+
+#ifdef DXS_FEAT_DEBUG_API
+ ret = dxs_reg_read (pDev, offset, pValue, 1);
+#endif /* DXS_FEAT_DEBUG_API */
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ Write into DXS internal register
+ (requires --enable-debug-api)
+
+ \param dxs - device number
+ \param offset - register offset
+ \param value - value
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsDebugRegWrite16(uint8_t dxs, uint8_t offset, uint16_t value)
+{
+ DXS_DEVICE_t *pDev;
+ int32_t ret = DXS_statusFeatNotCompiledIn;
+ uint16_t temp_value = value;
+
+ DXS_DEV_API_ENTRY;
+
+#ifdef DXS_FEAT_DEBUG_API
+ ret = dxs_reg_write (pDev, offset, &temp_value, 1);
+#endif /* DXS_FEAT_DEBUG_API */
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ Read from DXS internal register
+ (requires --enable-debug-api)
+
+ \param dxs - device number
+ \param offset - register offset
+ \param pValue - pointer to value returned
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsDebugRegRead32(uint8_t dxs, uint8_t offset, uint32_t *pValue)
+{
+ DXS_DEVICE_t *pDev;
+ int32_t ret = DXS_statusFeatNotCompiledIn;
+
+ DXS_DEV_API_ENTRY;
+
+#ifdef DXS_FEAT_DEBUG_API
+ ret = dxs_reg_read (pDev, offset, (uint16_t *)pValue, 2);
+#endif /* DXS_FEAT_DEBUG_API */
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ Write into DXS internal register
+ (requires --enable-debug-api)
+
+ \param dxs - device number
+ \param offset - register offset
+ \param value - value
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsDebugRegWrite32(uint8_t dxs, uint8_t offset, uint32_t value)
+{
+ DXS_DEVICE_t *pDev;
+ int32_t ret = DXS_statusFeatNotCompiledIn;
+ uint32_t temp_value = value;
+
+ DXS_DEV_API_ENTRY;
+
+#ifdef DXS_FEAT_DEBUG_API
+ ret = dxs_reg_write (pDev, offset, (uint16_t *)&temp_value, 2);
+#endif /* DXS_FEAT_DEBUG_API */
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ Read DXS firmware command
+ (requires --enable-debug-api)
+
+ \param dxs - device number
+ \param hdr - command header
+ \param pLength - length of data
+ \param pData - pointer to read data into
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsDebugCmdRead(uint8_t dxs, uint32_t hdr,
+ uint8_t *pLength, uint32_t *pData)
+{
+ DXS_DEVICE_t *pDev;
+ int32_t ret = DXS_statusFeatNotCompiledIn;
+
+ DXS_DEV_API_ENTRY;
+
+#ifdef DXS_FEAT_DEBUG_API
+ ret = dxs_cmd_read (pDev, hdr, pData, pLength);
+#endif /* DXS_FEAT_DEBUG_API */
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ Write DXS firmware command
+ (requires --enable-debug-api)
+
+ \param dxs - device number
+ \param length - the length of buffer
+ \param pCmd - pointer to buffer with command
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsDebugCmdWrite(uint8_t dxs, uint8_t length, uint32_t *pCmd)
+{
+ DXS_DEVICE_t *pDev;
+ int32_t ret = DXS_statusFeatNotCompiledIn;
+
+ DXS_DEV_API_ENTRY;
+
+#ifdef DXS_FEAT_DEBUG_API
+ ret = dxs_cmd_write (pDev, pCmd, length);
+#endif /* DXS_FEAT_DEBUG_API */
+
+ DXS_API_EXIT(ret);
+}
+
+#if 0
+/*
+ * DxsDebugBBDGet()
+ * requires --enable-debug-api
+ */
+int32_t DxsDebugBBDGet(uint8_t dxs, int nBuffer, uchar *pBbd, int *nByte)
+{
+ DXS_DEVICE_t *pDev;
+ int32_t ret = DXS_statusFeatNotCompiledIn;
+
+ DXS_DEV_API_ENTRY;
+
+#ifdef DXS_FEAT_DEBUG_API
+ /* TODO: ret = dxs_bbd_get (pDev, pCmd, length); */
+#endif /* DXS_FEAT_DEBUG_API */
+
+ DXS_API_EXIT(ret);
+}
+#endif
+
+/**
+ Tone Configuration
+ (requires --enable-tg)
+
+ \param dxs - device number
+ \param line - line number
+ \param level1 - level for frequency 1
+ \param level2 - level for frequency 2
+ \param freq1 - tone frequency 1
+ \param freq2 - tone frequency 2
+ \param amModulated - amplitude modulation flag
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsToneConfig(uint8_t dxs, uint8_t line, int16_t level1,
+ int16_t level2, uint16_t freq1, uint16_t freq2,
+ uint8_t amModulated)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret = DXS_statusFeatNotCompiledIn;
+
+ DXS_CH_API_ENTRY;
+
+#ifdef DXS_FEAT_TG
+ ret = dxs_tone_config(pCh, level1, level2, freq1, freq2, amModulated, 1);
+#endif /* DXS_FEAT_TG */
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ Tone Playout Enable
+ (requires --enable-tg)
+
+ \param dxs - device number
+ \param line - line number
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsToneEnable(uint8_t dxs, uint8_t line)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret = DXS_statusFeatNotCompiledIn;
+
+ DXS_CH_API_ENTRY;
+
+#ifdef DXS_FEAT_TG
+ ret = dxs_tone_start(pCh);
+#endif /* DXS_FEAT_TG */
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ Tone Playout Disable
+ (requires --enable-tg)
+
+ \param dxs - device number
+ \param line - line number
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsToneDisable(uint8_t dxs, uint8_t line)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret = DXS_statusFeatNotCompiledIn;
+
+ DXS_CH_API_ENTRY;
+
+#ifdef DXS_FEAT_TG
+ ret = dxs_tone_stop(pCh);
+#endif /* DXS_FEAT_TG */
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ CID Generator Coefficients update
+ (requires --enable-fsk)
+
+ \param dxs - device number
+ \param line - line number
+ \param level - CID send level
+ \param seizure - number of seizure bytes
+ \param mark - number of mark bits
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsFskConfig(uint8_t dxs, uint8_t line, int16_t level,
+ uint16_t seizure, uint16_t mark)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret = DXS_statusFeatNotCompiledIn;
+
+ DXS_CH_API_ENTRY;
+
+#ifdef DXS_FEAT_FSK
+ ret = DXS_FSK_Configure(pCh, level, seizure, mark);
+#endif /* DXS_FEAT_FSK */
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ CID Generator Enable
+ (requires --enable-fsk)
+
+ \param dxs - device number
+ \param line - line number
+ \param standard - CID standard
+ \param autodeact - auto deactivation
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsFskEnable(uint8_t dxs, uint8_t line, uint8_t standard, uint8_t autodeact)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret = DXS_statusFeatNotCompiledIn;
+
+ DXS_CH_API_ENTRY;
+
+#ifdef DXS_FEAT_FSK
+ ret = DXS_FSK_Enable(pCh, standard, autodeact);
+#endif /* DXS_FEAT_FSK */
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ CID Generator Disable
+ (requires --enable-fsk)
+
+ \param dxs - device number
+ \param line - line number
+ \param autodeact - auto deactivation
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsFskDisable(uint8_t dxs, uint8_t line, uint8_t autodeact)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret = DXS_statusFeatNotCompiledIn;
+
+ DXS_CH_API_ENTRY;
+
+#ifdef DXS_FEAT_FSK
+ ret = DXS_FSK_Disable(pCh, autodeact);
+#endif /* DXS_FEAT_FSK */
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ Send new data to the CID sender
+ (requires --enable-fsk)
+
+ \param dxs - device number
+ \param line - line number
+ \param nByte - data buffer size
+ \param pByte - pointer to data buffer
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsFskData(uint8_t dxs, uint8_t line, uint8_t nByte, uint8_t *pByte)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret = DXS_statusFeatNotCompiledIn;
+
+ DXS_CH_API_ENTRY;
+
+#ifdef DXS_FEAT_FSK
+ ret = DXS_FSK_Data(pCh, nByte, pByte);
+#endif /* DXS_FEAT_FSK */
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ Enable UTD
+ (requires --enable-utd)
+
+ \param dxs - device number
+ \param line - line number
+ \param tone_idx - tone index
+ \param direction - detection direction
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsUtdEnable(uint8_t dxs, uint8_t line, uint16_t tone_idx,
+ int direction)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret = DXS_statusFeatNotCompiledIn;
+
+ DXS_CH_API_ENTRY;
+#ifdef DXS_FEAT_UTD
+ ret = DXS_SIG_UtdEnable(pCh, tone_idx, direction);
+#endif /* DXS_FEAT_UTD */
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ Disable UTD
+ (requires --enable-utd)
+
+ \param dxs - device number
+ \param line - line number
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsUtdDisable(uint8_t dxs, uint8_t line)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret = DXS_statusFeatNotCompiledIn;
+
+ DXS_CH_API_ENTRY;
+
+#ifdef DXS_FEAT_UTD
+ ret = DXS_SIG_UtdDisable(pCh);
+#endif /* DXS_FEAT_UTD */
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ DTMF Receiver Coefficients
+ (requires --enable-dtmfd)
+
+ \param dxs - device number
+ \param line - line number
+ \param level - minimum signal level
+ \param twist - maximum allowed twist
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsDtmfConfig(uint8_t dxs, uint8_t line, int16_t level, int16_t twist)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret = DXS_statusFeatNotCompiledIn;
+
+ DXS_CH_API_ENTRY;
+
+#ifdef DXS_FEAT_DTMFD
+ ret = dxs_dtmf_config(pCh, level, twist);
+#endif /* DXS_FEAT_DTMFD */
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ DTMF Receiver Enable
+ (requires --enable-dtmfd)
+
+ \param dxs - device number
+ \param line - line number
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsDtmfEnable(uint8_t dxs, uint8_t line)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret = DXS_statusFeatNotCompiledIn;
+
+ DXS_CH_API_ENTRY;
+
+#ifdef DXS_FEAT_DTMFD
+ ret = dxs_dtmf_enable(pCh, 1);
+#endif /* DXS_FEAT_DTMFD */
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ DTMF Receiver Disable
+ (requires --enable-dtmfd)
+
+ \param dxs - device number
+ \param line - line number
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsDtmfDisable(uint8_t dxs, uint8_t line)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret = DXS_statusFeatNotCompiledIn;
+
+ DXS_CH_API_ENTRY;
+
+#ifdef DXS_FEAT_DTMFD
+ ret = dxs_dtmf_enable(pCh, 0);
+#endif /* DXS_FEAT_DTMFD */
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ Set GR-909 limits
+ (requires --enable-gr909)
+
+ \param dxs - device number
+ \param line - line number
+ \param pGR909Conf - pointer to SDD GR909 configuration structure
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsGr909LimitsSet(uint8_t dxs, uint8_t line,
+ DXS_GR909Config_t *pGR909Conf)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret = DXS_statusFeatNotCompiledIn;
+
+ DXS_CH_API_ENTRY;
+
+#ifdef DXS_FEAT_GR909
+ ret = DXS_SDD_GR909LimitsSet(pCh, pGR909Conf);
+#endif /* DXS_FEAT_GR909 */
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ Get GR-909 limits
+ (requires --enable-gr909)
+
+ \param dxs - device number
+ \param line - line number
+ \param pGR909Conf - pointer to SDD GR909 configuration structure
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsGr909LimitsGet(uint8_t dxs, uint8_t line,
+ DXS_GR909Config_t *pGR909Conf)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret = DXS_statusFeatNotCompiledIn;
+
+ DXS_CH_API_ENTRY;
+
+#ifdef DXS_FEAT_GR909
+ ret = DXS_SDD_GR909LimitsGet(pCh, pGR909Conf);
+#endif /* DXS_FEAT_GR909 */
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ Get GR-909 results
+ (requires --enable-gr909)
+
+ \param dxs - device number
+ \param line - line number
+ \param pGR909Result - pointer to SDD GR909 result structure
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsGr909ResultGet(uint8_t dxs, uint8_t line,
+ DXS_GR909Result_t *pGR909Result)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret = DXS_statusFeatNotCompiledIn;
+
+ DXS_CH_API_ENTRY;
+
+#ifdef DXS_FEAT_GR909
+ ret = DXS_SDD_GR909ResultGet(pCh, pGR909Result);
+#endif /* DXS_FEAT_GR909 */
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ GPIO port configuration
+ (requires --enable-gpio)
+
+ \param dxs - device number
+ \param pGpioConf - pointer to GPIO configuration structure
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsGpioPortConfig(uint8_t dxs, DXS_GpioConfig_t *pGpioConf)
+{
+ DXS_DEVICE_t *pDev;
+ int32_t ret = DXS_statusFeatNotCompiledIn;
+
+ DXS_DEV_API_ENTRY;
+
+#ifdef DXS_FEAT_GPIO
+ ret = DXS_GPIO_Config(pDev, pGpioConf);
+#endif /* DXS_FEAT_GPIO */
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ GPIO write
+ (requires --enable-gpio)
+
+ \param dxs - device number
+ \param pin - GPIO pin number
+ \param val - value
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsGpioWrite(uint8_t dxs, uint8_t pin, uint8_t val)
+{
+ DXS_DEVICE_t *pDev;
+ int32_t ret = DXS_statusFeatNotCompiledIn;
+
+ DXS_DEV_API_ENTRY;
+
+#ifdef DXS_FEAT_GPIO
+ ret = DXS_GPIO_Write(pDev, pin, val);
+#endif /* DXS_FEAT_GPIO */
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ GPIO read
+ (requires --enable-gpio)
+
+ \param dxs - device number
+ \param pin - GPIO pin number
+ \param *value - value
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsGpioRead(uint8_t dxs, uint8_t pin, uint8_t *value)
+{
+ DXS_DEVICE_t *pDev;
+ int32_t ret = DXS_statusFeatNotCompiledIn;
+
+ DXS_DEV_API_ENTRY;
+
+#ifdef DXS_FEAT_GPIO
+ ret = DXS_GPIO_Read(pDev, pin, value);
+#endif /* DXS_FEAT_GPIO */
+
+ DXS_API_EXIT(ret);
+}
+
+
+/**
+ Read the results of calibration measurements.
+
+ \param dxs - device number
+ \param line - line number
+ \param pCalibration - pointer to calibration structure
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsCalibrationGet(uint8_t dxs, uint8_t line,
+ DXS_Calibration_t *pCalibration)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret;
+
+ DXS_CH_API_ENTRY;
+
+ ret = DXS_SDD_CalibrationGet(pCh, pCalibration);
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ Write hardware configuration values.
+
+ \param dxs - device number
+ \param line - line number
+ \param pCalibration - pointer to calibration structure
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsCalibrationSet(uint8_t dxs, uint8_t line,
+ DXS_Calibration_t *pCalibration)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret;
+
+ DXS_CH_API_ENTRY;
+
+ ret = DXS_SDD_CalibrationSet(pCh, pCalibration);
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ Sets the validation times for hook, pulse digit and flashhook.
+
+ \param dxs - device number
+ \param line - line number
+ \param pTime - type of validation setting, min and max time in
+ milliseconds.
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsHookValTimeSet(uint8_t dxs, uint8_t line, DXS_HookValTime_t *pTime)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret = DXS_statusFeatNotCompiledIn;
+
+ DXS_CH_API_ENTRY;
+
+#ifdef DXS_FEAT_HSM
+ ret = DXS_Dial_HookValTimeSet(pCh, pTime);
+#endif /* DXS_FEAT_HSM */
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ Get capacitance measurement result
+
+ \param dxs - device number
+ \param line - line number
+ \param pCapacitance - pointer to capacitance measurement structure
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsCapMeasurementResultGet(uint8_t dxs, uint8_t line,
+ DXS_Capacitance_t *pCapacitance)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret = DXS_statusFeatNotCompiledIn;
+
+ DXS_CH_API_ENTRY;
+
+#ifdef DXS_FEAT_CAPMEAS
+ ret = DXS_SDD_CapMeasurementResultGet(pCh, 1, pCapacitance);
+#endif /* DXS_FEAT_CAPMEAS */
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ Get continuous measurements result
+
+ \param dxs - device number
+ \param line - line number
+ \param pResult - pointer to continuous measurement structure
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsContMeasurementResultGet(uint8_t dxs, uint8_t line,
+ DXS_ContMeasurementResult_t *pResult)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret;
+
+ DXS_CH_API_ENTRY;
+
+ ret = DXS_SDD_ContMeasurementResultGet(pCh, pResult);
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ Enable metering pulse. The pulse length can be programmed
+ with SDD_BasicConfig.
+ (requires --enable-metering)
+
+ \param dxs - device number
+ \param line - line number
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsMeteringPulseEnable(uint8_t dxs, uint8_t line)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret = DXS_statusFeatNotCompiledIn;
+
+ DXS_CH_API_ENTRY;
+
+#ifdef DXS_FEAT_METERING
+ ret = DXS_SIG_MeterPulseEnable(pCh);
+#endif /* DXS_FEAT_METERING */
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ Disable metering pulse.
+ (requires --enable-metering)
+
+ \param dxs - device number
+ \param line - line number
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsMeteringPulseDisable(uint8_t dxs, uint8_t line)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret = DXS_statusFeatNotCompiledIn;
+
+ DXS_CH_API_ENTRY;
+
+#ifdef DXS_FEAT_METERING
+ ret = DXS_SIG_MeterPulseDisable(pCh);
+#endif /* DXS_FEAT_METERING */
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ Open Loop Calibration
+
+ \param dxs - device number
+ \param line - line number
+ \param loops - number of loops
+ \param pOLCalibrationResult - pointer to Open Loop Calibration structure
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsOpenLoopCalibration(uint8_t dxs, uint8_t line, uint8_t loops,
+ DXS_OLCalibration_t *pOLCalibrationResult)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret = DXS_statusFeatNotCompiledIn;
+
+ DXS_CH_API_ENTRY;
+
+#if defined(DXS_FEAT_CAPMEAS) && defined(DXS_FEAT_GR909)
+ ret = DXS_SDD_OLCalibration(pCh, loops, pOLCalibrationResult);
+#endif /* DXS_FEAT_CAPMEAS && DXS_FEAT_GR909 */
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ Function to set the Open Loop Calibration configuration
+
+ \param dxs - device number
+ \param line - line number
+ \param pOLCalibration - pointer to Open Loop Calibration structure
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsOpenLoopConfigSet(uint8_t dxs, uint8_t line,
+ DXS_OLCalibration_t *pOLCalibration)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret = DXS_statusFeatNotCompiledIn;
+
+ DXS_CH_API_ENTRY;
+
+#if defined(DXS_FEAT_CAPMEAS) && defined(DXS_FEAT_GR909)
+ ret = DXS_SDD_OLCalibrationConfigSet(pCh, pOLCalibration);
+#endif /* DXS_FEAT_CAPMEAS && DXS_FEAT_GR909 */
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ Function to get the Open Loop Calibration configuration
+
+ \param dxs - device number
+ \param line - line number
+ \param pOLCalibration - pointer to Open Loop Calibration structure
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsOpenLoopConfigGet(uint8_t dxs, uint8_t line,
+ DXS_OLCalibration_t *pOLCalibration)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret = DXS_statusFeatNotCompiledIn;
+
+ DXS_CH_API_ENTRY;
+
+#if defined(DXS_FEAT_CAPMEAS) && defined(DXS_FEAT_GR909)
+ ret = DXS_SDD_OLCalibrationConfigGet(pCh, pOLCalibration);
+#endif /* DXS_FEAT_CAPMEAS && DXS_FEAT_GR909 */
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ Function to start the ACLM measurement
+
+ \param dxs - device number
+ \param line - line number
+ \param aclm_mt - ACLM measurment code
+
+ \return
+ - \ref DXS_status_t code
+*/
+int32_t DxsAcLmMeasurementStart(uint8_t dxs, uint8_t line,
+ DXS_ACLM_Measurement_t aclm_mt)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret = DXS_statusFeatNotCompiledIn;
+
+ DXS_CH_API_ENTRY;
+
+#ifdef DXS_FEAT_ACMETER
+ ret = DXS_SDD_ACLM_Start(pCh, aclm_mt);
+#endif /* DXS_FEAT_ACMETER */
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ Function to retrieve the available ACLM measurement result number
+
+ \param dxs - device number
+ \param line - line number
+ \param aclm_mt - ACLM measurment code
+ \param pResNum - ACLM result number (output)
+
+ \return
+ - \ref DXS_status_t code
+*/
+int32_t DxsAcLmMeasResNumGet(uint8_t dxs, uint8_t line,
+ DXS_ACLM_Measurement_t aclm_mt,
+ int32_t *pResNum)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret = DXS_statusFeatNotCompiledIn;
+
+ DXS_CH_API_ENTRY;
+
+#ifdef DXS_FEAT_ACMETER
+ ret = DXS_SDD_ACLM_ResultGet(pCh,
+ aclm_mt, DXS_ACLM_RESULT_NUMBER, 0, pResNum);
+#endif /* DXS_FEAT_ACMETER */
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ Function to retrieve the argument of particular ACLM measurement index
+
+ \param dxs - device number
+ \param line - line number
+ \param aclm_mt - ACLM measurment code
+ \param index - ACLM measurment index
+ \param pResArg - ACLM result argument (output)
+
+ \return
+ - \ref DXS_status_t code
+*/
+int32_t DxsAcLmMeasResArgGet(uint8_t dxs, uint8_t line,
+ DXS_ACLM_Measurement_t aclm_mt,
+ int32_t index, int32_t *pResArg)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret = DXS_statusFeatNotCompiledIn;
+
+ DXS_CH_API_ENTRY;
+
+#ifdef DXS_FEAT_ACMETER
+ ret = DXS_SDD_ACLM_ResultGet(pCh,
+ aclm_mt, DXS_ACLM_RESULT_ARG, index, pResArg);
+#endif /* DXS_FEAT_ACMETER */
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ Function to retrieve the result value of particular ACLM measurement index
+
+ \param dxs - device number
+ \param line - line number
+ \param aclm_mt - ACLM measurment code
+ \param index - ACLM measurment index
+ \param pResArg - ACLM result argument (output)
+
+ \return
+ - \ref DXS_status_t code
+*/
+int32_t DxsAcLmMeasResValGet(uint8_t dxs, uint8_t line,
+ DXS_ACLM_Measurement_t aclm_mt,
+ int32_t index, int32_t *pResVal)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret = DXS_statusFeatNotCompiledIn;
+
+ DXS_CH_API_ENTRY;
+
+#ifdef DXS_FEAT_ACMETER
+ ret = DXS_SDD_ACLM_ResultGet(pCh,
+ aclm_mt, DXS_ACLM_RESULT_VALUE, index, pResVal);
+#endif /* DXS_FEAT_ACMETER */
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ Function to initialize CID interface for a channel
+
+ \param dxs - device number
+ \param line - line number
+ \param std - CID standard
+ \param as - CID alert signal
+ \param fmt - CID data format
+ \param dtmf_ack_idx - DTMF index for acknowledgment (type2)
+
+ \return
+ - \ref DXS_status_t code
+*/
+int32_t DxsCidInit (uint8_t dxs, uint8_t line, DXS_CID_Std_t std,
+ DXS_CID_AS_t as, DXS_CID_DATA_FMT_t fmt, uint8_t dtmf_ack_idx)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret = DXS_statusFeatNotCompiledIn;
+
+ DXS_CH_API_ENTRY;
+
+#ifdef DXS_FEAT_CID
+ ret = DXS_CID_Init(pCh, std, as, fmt, dtmf_ack_idx);
+#endif /* DXS_FEAT_CID */
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ Function to configure timers for a given CID standard.
+
+ \param dxs - device number
+ \param line - line number
+ \param std - CID standard
+ \param pTimers - pointer to timer union
+
+ \return
+ - \ref DXS_status_t code
+*/
+int32_t DxsCidTimerConfig (uint8_t dxs, uint8_t line, DXS_CID_Std_t std,
+ DXS_CID_Timers_t *pTimers)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret = DXS_statusFeatNotCompiledIn;
+
+ DXS_CH_API_ENTRY;
+
+#ifdef DXS_FEAT_CID
+ ret = DXS_CID_TimerConfig(pCh, std, pTimers);
+#endif /* DXS_FEAT_CID */
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ Function to create (or update) the CID message per channel
+
+ \param dxs - device number
+ \param line - line number
+ \param msg_type - CID message type
+ \param param - CID message parameter
+ \param pData - pointer to char data of the parameter value
+ \param length - length of the data pointed by pData
+
+ \return
+ - \ref DXS_status_t code
+*/
+int32_t DxsCidMsgSetup(uint8_t dxs, uint8_t line, DXS_CID_MsgType_t msg_type,
+ DXS_CID_MsgParam_t param, char *pData, uint8_t length)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret = DXS_statusFeatNotCompiledIn;
+
+ DXS_CH_API_ENTRY;
+
+#ifdef DXS_FEAT_CID
+ ret = DXS_CID_MsgUpdate(pCh, msg_type, param, pData, length);
+#endif /* DXS_FEAT_CID */
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ Function to delete entirely the CID message per channel
+
+ \param dxs - device number
+ \param line - line number
+
+ \return
+ - \ref DXS_status_t code
+*/
+int32_t DxsCidMsgReset(uint8_t dxs, uint8_t line)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret = DXS_statusFeatNotCompiledIn;
+
+ DXS_CH_API_ENTRY;
+
+#ifdef DXS_FEAT_CID
+ ret = DXS_CID_MsgCleanup(pCh);
+#endif /* DXS_FEAT_CID */
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ Function to start the playout of CID TypeI sequence
+
+ \param dxs - device number
+ \param line - line number
+ \param std - CID standard
+ \param as - Alert signal
+ \param fmt - Data format
+ \param msg_type - message type selected for playout
+
+ \return
+ - \ref DXS_status_t code
+*/
+int32_t DxsCidTypeIMsgStart(uint8_t dxs, uint8_t line,
+ DXS_CID_MsgType_t msg_type)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret = DXS_statusFeatNotCompiledIn;
+
+ DXS_CH_API_ENTRY;
+
+#ifdef DXS_FEAT_CID
+ ret = DXS_CID_TypeI_Play(pCh, msg_type, DXS_CID_CALL_FROM_CID_API);
+#endif /* DXS_FEAT_CID */
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ Function to start the playout of CID TypeII sequence
+
+ \param dxs - device number
+ \param line - line number
+ \param std - CID standard
+ \param as - Alert signal
+ \param fmt - Data format
+ \param msg_type - message type selected for playout
+
+ \return
+ - \ref DXS_status_t code
+*/
+int32_t DxsCidTypeIIMsgStart(uint8_t dxs, uint8_t line,
+ DXS_CID_MsgType_t msg_type)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret = DXS_statusFeatNotCompiledIn;
+
+ DXS_CH_API_ENTRY;
+
+#ifdef DXS_FEAT_CID
+ ret = DXS_CID_TypeII_Play(pCh, msg_type);
+#endif /* DXS_FEAT_CID */
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ Function to stop the playout of CID sequence
+
+ \param dxs - device number
+ \param line - line number
+
+ \return
+ - \ref DXS_status_t code
+*/
+int32_t DxsCidSeqStop(uint8_t dxs, uint8_t line)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret = DXS_statusFeatNotCompiledIn;
+
+ DXS_CH_API_ENTRY;
+
+#ifdef DXS_FEAT_CID
+ ret = DXS_CID_Stop(pCh);
+#endif /* DXS_FEAT_CID */
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ Function to configure the ringing cadence
+
+ \param dxs - device number
+ \param line - line number
+ \param pRC - pointer to \ref DXS_RingCadence_t structure
+
+ \return
+ - \ref DXS_status_t code
+*/
+int32_t DxsRingCadenceInit(uint8_t dxs, uint8_t line, DXS_RingCadence_t *pRC)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret;
+
+ DXS_CH_API_ENTRY;
+
+ ret = DXS_RING_CadenceInit(pCh, pRC);
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ Function to start the ringing cadence
+
+ \param dxs - device number
+ \param line - line number
+
+ \return
+ - \ref DXS_status_t code
+*/
+int32_t DxsRingCadenceStart(uint8_t dxs, uint8_t line)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret;
+
+ DXS_CH_API_ENTRY;
+
+ ret = DXS_RING_CadenceStart(pCh);
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ Function to stop the ringing cadence
+
+ \param dxs - device number
+ \param line - line number
+
+ \return
+ - \ref DXS_status_t code
+*/
+int32_t DxsRingCadenceStop(uint8_t dxs, uint8_t line)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret;
+
+ DXS_CH_API_ENTRY;
+
+ ret = DXS_RING_CadenceStop(pCh);
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ Prevent ESD mode and line voltage drop
+ on PCM clock failure
+
+ \param dxs - device number
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsClockFailLineFeedFreeze (uint8_t dxs)
+{
+ DXS_DEVICE_t *pDev;
+ int32_t ret;
+
+ DXS_DEV_API_ENTRY;
+
+ ret = DXS_CfEsdSwitch(pDev, 0);
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ Allow ESD mode and line voltage drop
+ on PCM clock failure
+
+ \param dxs - device number
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsClockFailLineFeedUnFreeze (uint8_t dxs)
+{
+ DXS_DEVICE_t *pDev;
+ int32_t ret;
+
+ DXS_DEV_API_ENTRY;
+
+ ret = DXS_CfEsdSwitch(pDev, 1);
+
+ DXS_API_EXIT(ret);
+}
+
+/* =================== MULTI-CHANNEL SHARED HW SUPPORT ====================== */
+
+/**
+ Configure the driver for the master channel.
+
+ \param dxs - device number
+ \param line - line number
+
+ \return
+ - DXS_statusOk
+ - DXS_statusDevNotFound
+ - DXS_statusDevNotInitialized
+ - DXS_statusChannelNotFound
+ - DXS_statusInvalidParam
+*/
+int32_t DxsSharedDcDcMasterSet (uint8_t dxs, uint8_t line)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret;
+
+ DXS_CH_API_ENTRY;
+
+ ret = DXS_DCDC_HW_SharedDcDcMasterChSet(pCh);
+
+ DXS_API_EXIT(ret);
+}
+/* ========================================================================== */
+
+/* ===================== E V E N T S U P P O R T ========================== */
+
+/**
+ Initialize Waiting List
+
+ \return
+ - waiting list instance
+*/
+DXS_WaitList_t DxsWaitListInit(void)
+{
+ return dxs_wl_init();
+}
+
+/**
+ Initialize Waiting List
+
+ \param wl - waiting list instance
+
+*/
+void DxsWaitListDestroy(DXS_WaitList_t wl)
+{
+ dxs_wl_destroy(wl);
+}
+
+/**
+ Add device to the waiting list
+
+ \param dxs - device number
+ \param wl - waiting list instance
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsWaitListDevAdd(uint8_t dxs, DXS_WaitList_t wl)
+{
+ DXS_DEVICE_t *pDev;
+ int32_t ret;
+
+ DXS_DEV_API_ENTRY;
+
+ ret = dxs_wl_dev_add(pDev, wl);
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ Remove device from the waiting list
+
+ \param dxs - device number
+ \param wl - waiting list instance
+
+ \return
+ - DXS_statusOk or DXS_statusError
+*/
+int32_t DxsWaitListDevRemove(uint8_t dxs, DXS_WaitList_t wl)
+{
+ DXS_DEVICE_t *pDev;
+ int32_t ret;
+
+ DXS_DEV_API_ENTRY;
+
+ ret = dxs_wl_dev_remove(pDev, wl);
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ Wait on the Waiting List instance
+
+ \param wl - waiting list instance
+
+ \return
+ - the first device number on the Waiting List
+ having non-empty event queue
+ or negative value in case of error
+*/
+int32_t DxsWaitForEvent(DXS_WaitList_t wl)
+{
+ return dxs_wait(wl);
+}
+
+/**
+ Read a single event from the device
+
+ \param dxs - device number
+ \param pEvent - pointer to DXS_Event_t structure
+
+ \return
+ - the remaining event count in device event queue
+ or negative value in case of error
+*/
+int32_t DxsEventGet(uint8_t dxs, DXS_Event_t *pEvent)
+{
+ DXS_DEVICE_t *pDev;
+
+ DXS_DEV_API_ENTRY;
+
+ /* no DXS_API_EXIT macro, as the function returns
+ the event count instead of a status code */
+
+ return dxs_event_get(pDev, pEvent);
+}
+
+/**
+ Enable dispatching of a particular event on a given line
+ to the application.
+
+ \param dxs Device number.
+ \param line Line number.
+ \param event Event id
+
+ \return
+ Return value according to \ref DXS_status_t.
+*/
+int32_t DxsEventEnable(uint8_t dxs, uint8_t line, DXS_Event_id_t event)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret;
+
+ DXS_CH_API_ENTRY;
+
+ ret = DXS_EventEnable(pCh, event);
+
+ DXS_API_EXIT(ret);
+}
+
+/**
+ Disable dispatching of a particular event on a given line
+ to the application.
+
+ \param dxs Device number.
+ \param line Line number.
+ \param event Event id
+
+ \return
+ Return value according to \ref DXS_status_t.
+*/
+int32_t DxsEventDisable(uint8_t dxs, uint8_t line, DXS_Event_id_t event)
+{
+ DXS_DEVICE_t *pDev;
+ DXS_CHANNEL_t *pCh;
+ int32_t ret;
+
+ DXS_CH_API_ENTRY;
+
+ ret = DXS_EventDisable(pCh, event);
+
+ DXS_API_EXIT(ret);
+}
+
+/* ========================================================================== */