libsangoma.h

Go to the documentation of this file.

/*******************************************************************************/
#ifndef _LIBSANGOMA_H
#define _LIBSANGOMA_H

#ifdef __linux__
#ifndef __LINUX__
/* most wanpipe driver headers require __LINUX__ to be defined */
#define __LINUX__
#endif
#endif

#ifdef __cplusplus
extern "C" {    /* for C++ users */
#endif

#include <stdio.h>


#define WANPIPE_TDM_API 1

/*TODO: LIBSANGOMA_VERSION_CODE should be generated out of LIBSANGOMA_LT_CURRENT and friends in configure.in */

#define LIBSANGOMA_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))

#define LIBSANGOMA_VERSION_CODE LIBSANGOMA_VERSION(3,3,0)

#define LIBSANGOMA_VERSION_STR "3.3.0"

#define WP_API_FEATURE_ANALOG_STATS 1

struct sangoma_wait_obj;
#define sangoma_wait_obj_t struct sangoma_wait_obj


#define SANGOMA_DECLARE_TDM_API_CMD(_name_)         wanpipe_api_t _name_

#define SANGOMA_INIT_TDM_API_CMD(_name_)            memset(&_name_,0,sizeof(_name_)); \
                                                        SANGOMA_INIT_TDM_API_CMD_RESULT(_name_)

#define SANGOMA_INIT_TDM_API_CMD_RESULT(_name_)     (_name_).wp_cmd.result = SANG_STATUS_GENERAL_ERROR 

#define SANGOMA_DECLARE_INIT_TDM_API_CMD(_name_)    wanpipe_tdm_api_t _name_; SANGOMA_INIT_TDM_API_CMD(_name_);


#if defined(WIN32) || defined(WIN64)
#ifndef __WINDOWS__
#define __WINDOWS__
#endif
#include <windows.h>
#include <winioctl.h>
#include <conio.h>
#include <stddef.h> 
#include <stdlib.h> 
#include <time.h>

#ifdef __COMPILING_LIBSANGOMA__
# define _LIBSNG_CALL __declspec(dllexport) __cdecl
#else
# ifdef __LIBSANGOMA_IS_STATIC_LIB__
/* libsangoma is static lib OR 'compiled in' */
#  define _LIBSNG_CALL __cdecl
# else
/* compiling an application which will use libsangoma.dll */
#  define _LIBSNG_CALL __declspec(dllimport) __cdecl
# endif
#endif /* __COMPILING_LIBSANGOMA__ */

#define SANGOMA_INFINITE_API_POLL_WAIT INFINITE
#define SANGOMA_WAIT_INFINITE INFINITE

#define sangoma_msleep(x)   Sleep(x)

#define sangoma_ctime(time) _ctime64(time)

#else
/* L I N U X */
#include <stdlib.h>
#include <stdarg.h>
#include <ctype.h>
#include <unistd.h>
#include <sys/time.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/signal.h>
#include <sys/select.h>
#include <sys/wait.h>
#include <sys/resource.h>
#include <netinet/in.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>
#include <net/if.h>
#include <poll.h>
#include <signal.h>
#include <pthread.h>
#include <stdint.h>

#define _LIBSNG_CALL

#define INVALID_HANDLE_VALUE -1

#define SANGOMA_INFINITE_API_POLL_WAIT -1
#define SANGOMA_WAIT_INFINITE -1

#define __cdecl

#ifndef FALSE
#define FALSE       0
#endif

#ifndef TRUE
#define TRUE        1
#endif

#define sangoma_msleep(x) usleep(x*1000)
#define _getch      getchar
#define Sleep       sangoma_msleep
#define _stricmp    strcmp
#define _snprintf   snprintf
#define _vsnprintf      vsnprintf

typedef int HANDLE;
typedef int DWORD;
typedef char TCHAR;


#if 0
typedef int BOOL;
typedef unsigned char UCHAR;
typedef unsigned long ULONG;
typedef unsigned short USHORT;
typedef unsigned char * LPSTR;
typedef unsigned char * PUCHAR;
typedef void * PVOID;
typedef unsigned int UINT;
#endif

typedef void * LPTHREAD_START_ROUTINE;
typedef pthread_mutex_t CRITICAL_SECTION;

#define EnterCriticalSection(arg)   pthread_mutex_lock(arg)
/* On success, pthread_mutex_trylock() returns 0. On error, non-zero value is returned. */
#define TryEnterCriticalSection(arg)    (pthread_mutex_trylock(arg)==0 ? 1 : 0)
#define LeaveCriticalSection(arg)   pthread_mutex_unlock(arg)
#define InitializeCriticalSection(arg)  pthread_mutex_init(arg, NULL);

typedef struct tm SYSTEMTIME;
typedef char * LPCTSTR;

#define sangoma_ctime(time) ctime((time_t*)time)

#endif/* WIN32 */


#ifdef LIBSANGOMA_LIGHT
#include "wanpipe_api_iface.h"
#include "wanpipe_api_hdr.h"
#include "sdla_te1.h"
#include "wanpipe_events.h"
#include "wanpipe_api_deprecated.h"
#else
#include "wanpipe_api.h"

#ifdef WP_API_FEATURE_LIBSNG_HWEC
# include "wanpipe_events.h"
# include "wanec_api.h"
# include "wanec_iface_api.h"
#endif
#endif


#ifdef __LINUX__
#include "wanpipe_kernel.h"
#endif

typedef int32_t sangoma_status_t;

#define FNAME_LEN       100
#define LIBSNG_FUNC_DBG()   if(0)printf("%s(): line:%d\n", __FUNCTION__, __LINE__)
#define LIBSNG_DBG_PRINT    if(0)printf

typedef wp_api_hdr_t sangoma_api_hdr_t;

typedef enum _sangoma_wait_obj_type
{
    UNKNOWN_WAIT_OBJ = 0, 
    SANGOMA_GENERIC_WAIT_OBJ = 0, 
    SANGOMA_DEVICE_WAIT_OBJ, 
    SANGOMA_DEVICE_WAIT_OBJ_SIG, 
} sangoma_wait_obj_type_t;

#define DECODE_SANGOMA_WAIT_OBJECT_TYPE(type)\
    type == SANGOMA_GENERIC_WAIT_OBJ    ? "SANGOMA_GENERIC_WAIT_OBJ"    :\
    type == SANGOMA_DEVICE_WAIT_OBJ     ? "SANGOMA_DEVICE_WAIT_OBJ"     :\
    type == SANGOMA_DEVICE_WAIT_OBJ_SIG ? "SANGOMA_DEVICE_WAIT_OBJ_SIG" :\
    "Invalid Wait Object type!"

/* 
 * Possible flags for sangoma waitable objects 
 * this definitions MUST match POLLIN, POLLOUT and POLLPRI 
 * SANG_WAIT_OBJ_IS_SIGNALED has no posix equivalent though
 * Users are encouraged to use this flags instead of the system ones
 */
typedef enum _sangoma_wait_obj_flags {
  SANG_WAIT_OBJ_HAS_INPUT = WP_POLLIN,
  SANG_WAIT_OBJ_HAS_OUTPUT = WP_POLLOUT,
  SANG_WAIT_OBJ_HAS_EVENTS = WP_POLLPRI,
  SANG_WAIT_OBJ_IS_SIGNALED = 0x400 /* matches GNU extension POLLMSG */
} sangoma_wait_obj_flags_t;

/*
 * Note for data format of Input/Output and Bit-order in libsangoma API.
 * The bit-order depends on Span/Channel configuration.
 *
 * TDM_CHAN_VOICE_API - expected input is ulaw/alaw, output is ulaw/alaw,
 * TDM_SPAN_VOICE_API - expected input is ulaw/alaw, output is ulaw/alaw
 *
 * DATA_API - data can be in any format, not bitswapped by AFT hardware
 * API - data can be in any format, not bitswapped by AFT hardware
*/

/************************************************************/
sng_fd_t _LIBSNG_CALL sangoma_open_api_span_chan(int span, int chan);


sng_fd_t _LIBSNG_CALL __sangoma_open_api_span_chan(int span, int chan);
#define __sangoma_open_tdmapi_span_chan __sangoma_open_api_span_chan

sng_fd_t _LIBSNG_CALL sangoma_open_api_span(int span);

sng_fd_t _LIBSNG_CALL sangoma_open_dev_by_name(const char *dev_name);


#ifndef LIBSANGOMA_TDMAPI_CTRL
#define LIBSANGOMA_TDMAPI_CTRL 1
#endif

sng_fd_t _LIBSNG_CALL sangoma_open_api_ctrl(void);

sng_fd_t _LIBSNG_CALL sangoma_logger_open(void);

sng_fd_t _LIBSNG_CALL sangoma_open_driver_ctrl(int port_no);



void _LIBSNG_CALL sangoma_close(sng_fd_t *fd);



int _LIBSNG_CALL sangoma_get_open_cnt(sng_fd_t fd, wanpipe_api_t *tdm_api);


/************************************************************/
int _LIBSNG_CALL sangoma_writemsg(sng_fd_t fd, void *hdrbuf, int hdrlen,
                         void *databuf, unsigned short datalen, int flag);


int _LIBSNG_CALL sangoma_readmsg(sng_fd_t fd, void *hdrbuf, int hdrlen,
                        void *databuf, int datalen, int flag);




/************************************************************/
sangoma_status_t _LIBSNG_CALL sangoma_waitfor(sangoma_wait_obj_t *sangoma_wait_obj, uint32_t inflags, uint32_t *outflags, int32_t timeout);

sangoma_status_t _LIBSNG_CALL sangoma_waitfor_many(sangoma_wait_obj_t *sangoma_wait_objects[], uint32_t in_flags[], uint32_t out_flags[],
        uint32_t number_of_sangoma_wait_objects, int32_t system_wait_timeout);

sangoma_status_t _LIBSNG_CALL sangoma_wait_obj_create(sangoma_wait_obj_t **sangoma_wait_object, sng_fd_t fd, sangoma_wait_obj_type_t object_type);

sangoma_status_t _LIBSNG_CALL sangoma_wait_obj_delete(sangoma_wait_obj_t **sangoma_wait_object);

sangoma_status_t _LIBSNG_CALL sangoma_wait_obj_signal(sangoma_wait_obj_t *sangoma_wait_object);

sng_fd_t _LIBSNG_CALL sangoma_wait_obj_get_fd(sangoma_wait_obj_t *sangoma_wait_object);

void _LIBSNG_CALL sangoma_wait_obj_set_context(sangoma_wait_obj_t *sangoma_wait_object, void *context);

PVOID _LIBSNG_CALL sangoma_wait_obj_get_context(sangoma_wait_obj_t *sangoma_wait_object);


/************************************************************/
int _LIBSNG_CALL sangoma_cmd_exec(sng_fd_t fd, wanpipe_api_t *tdm_api);


int _LIBSNG_CALL sangoma_get_full_cfg(sng_fd_t fd, wanpipe_api_t *tdm_api);

int _LIBSNG_CALL sangoma_tdm_set_usr_period(sng_fd_t fd, wanpipe_api_t *tdm_api, int period);

int _LIBSNG_CALL sangoma_tdm_get_usr_period(sng_fd_t fd, wanpipe_api_t *tdm_api);

int _LIBSNG_CALL sangoma_tdm_get_usr_mtu_mru(sng_fd_t fd, wanpipe_api_t *tdm_api);


int _LIBSNG_CALL sangoma_flush_bufs(sng_fd_t fd, wanpipe_api_t *tdm_api);

int _LIBSNG_CALL sangoma_flush_rx_bufs(sng_fd_t fd, wanpipe_api_t *tdm_api);
int _LIBSNG_CALL sangoma_flush_tx_bufs(sng_fd_t fd, wanpipe_api_t *tdm_api);

int _LIBSNG_CALL sangoma_flush_event_bufs(sng_fd_t fd, wanpipe_api_t *tdm_api);


int _LIBSNG_CALL sangoma_tdm_enable_rbs_events(sng_fd_t fd, wanpipe_api_t *tdm_api, int poll_in_sec);

int _LIBSNG_CALL sangoma_tdm_disable_rbs_events(sng_fd_t fd, wanpipe_api_t *tdm_api);

int _LIBSNG_CALL sangoma_tdm_write_rbs(sng_fd_t fd, wanpipe_api_t *tdm_api, int channel, unsigned char rbs);

int _LIBSNG_CALL sangoma_tdm_read_rbs(sng_fd_t fd, wanpipe_api_t *tdm_api, int channel, unsigned char *rbs);

int _LIBSNG_CALL sangoma_tdm_enable_dtmf_events(sng_fd_t fd, wanpipe_api_t *tdm_api);

int _LIBSNG_CALL sangoma_tdm_disable_dtmf_events(sng_fd_t fd, wanpipe_api_t *tdm_api);


#ifdef WP_API_FEATURE_FAX_EVENTS

int _LIBSNG_CALL sangoma_tdm_enable_fax_events(sng_fd_t fd, wanpipe_api_t *tdm_api);

int _LIBSNG_CALL sangoma_tdm_disable_fax_events(sng_fd_t fd, wanpipe_api_t *tdm_api);

int _LIBSNG_CALL sangoma_tdm_get_hw_fax(sng_fd_t fd, wanpipe_api_t *tdm_api);

#endif


int _LIBSNG_CALL sangoma_tdm_enable_rm_dtmf_events(sng_fd_t fd, wanpipe_api_t *tdm_api);

int _LIBSNG_CALL sangoma_tdm_disable_rm_dtmf_events(sng_fd_t fd, wanpipe_api_t *tdm_api);

int _LIBSNG_CALL sangoma_tdm_enable_rxhook_events(sng_fd_t fd, wanpipe_api_t *tdm_api);

int _LIBSNG_CALL sangoma_tdm_disable_rxhook_events(sng_fd_t fd, wanpipe_api_t *tdm_api);

int _LIBSNG_CALL sangoma_tdm_enable_ring_events(sng_fd_t fd, wanpipe_api_t *tdm_api);

int _LIBSNG_CALL sangoma_tdm_disable_ring_events(sng_fd_t fd, wanpipe_api_t *tdm_api);


int _LIBSNG_CALL sangoma_tdm_enable_ring_detect_events(sng_fd_t fd, wanpipe_api_t *tdm_api);

int _LIBSNG_CALL sangoma_tdm_disable_ring_detect_events(sng_fd_t fd, wanpipe_api_t *tdm_api);

int _LIBSNG_CALL sangoma_tdm_enable_ring_trip_detect_events(sng_fd_t fd, wanpipe_api_t *tdm_api);

int _LIBSNG_CALL sangoma_tdm_disable_ring_trip_detect_events(sng_fd_t fd, wanpipe_api_t *tdm_api);

int _LIBSNG_CALL sangoma_tdm_enable_tone_events(sng_fd_t fd, wanpipe_api_t *tdm_api, uint16_t tone_id);

int _LIBSNG_CALL sangoma_tdm_disable_tone_events(sng_fd_t fd, wanpipe_api_t *tdm_api);

int _LIBSNG_CALL sangoma_tdm_txsig_onhook(sng_fd_t fd, wanpipe_api_t *tdm_api);

int _LIBSNG_CALL sangoma_tdm_txsig_offhook(sng_fd_t fd, wanpipe_api_t *tdm_api);

int _LIBSNG_CALL sangoma_tdm_txsig_start(sng_fd_t fd, wanpipe_api_t *tdm_api);

int _LIBSNG_CALL sangoma_tdm_txsig_kewl(sng_fd_t fd, wanpipe_api_t *tdm_api);

int _LIBSNG_CALL sangoma_tdm_enable_hwec(sng_fd_t fd, wanpipe_api_t *tdm_api);

int _LIBSNG_CALL sangoma_tdm_disable_hwec(sng_fd_t fd, wanpipe_api_t *tdm_api);

int _LIBSNG_CALL sangoma_tdm_get_fe_alarms(sng_fd_t fd, wanpipe_api_t *tdm_api, unsigned int *alarms);



#ifdef WP_API_FEATURE_LINK_STATUS
# ifndef LIBSANGOMA_GET_LINKSTATUS

# define LIBSANGOMA_GET_LINKSTATUS 1
# endif

int _LIBSNG_CALL sangoma_get_link_status(sng_fd_t fd, wanpipe_api_t *tdm_api, unsigned char *current_status);

#endif

/* set current Line Connection state - Connected/Disconnected */
#ifndef LIBSANGOMA_GET_FESTATUS

#define LIBSANGOMA_GET_FESTATUS 1
#endif

int _LIBSNG_CALL sangoma_set_fe_status(sng_fd_t fd, wanpipe_api_t *tdm_api, unsigned char new_status);



#ifdef WP_API_FEATURE_BUFFER_MULT

int _LIBSNG_CALL sangoma_tdm_set_buffer_multiplier(sng_fd_t fd, wanpipe_api_t *tdm_api, unsigned int multiplier);

#endif


int _LIBSNG_CALL sangoma_enable_bri_bchan_loopback(sng_fd_t fd, wanpipe_api_t *tdm_api, int channel);

int _LIBSNG_CALL sangoma_disable_bri_bchan_loopback(sng_fd_t fd, wanpipe_api_t *tdm_api, int channel);


int _LIBSNG_CALL sangoma_get_tx_queue_sz(sng_fd_t fd, wanpipe_api_t *tdm_api);


int _LIBSNG_CALL sangoma_set_tx_queue_sz(sng_fd_t fd, wanpipe_api_t *tdm_api, int size);

int _LIBSNG_CALL sangoma_get_rx_queue_sz(sng_fd_t fd, wanpipe_api_t *tdm_api);

int _LIBSNG_CALL sangoma_set_rx_queue_sz(sng_fd_t fd, wanpipe_api_t *tdm_api, int size);


#ifndef LIBSANGOMA_GET_HWCODING

#define LIBSANGOMA_GET_HWCODING 1
#endif

int _LIBSNG_CALL sangoma_get_hw_coding(sng_fd_t fd, wanpipe_api_t *tdm_api);



#ifndef LIBSANGOMA_GET_HWDTMF

#define LIBSANGOMA_GET_HWDTMF 1
#endif

int _LIBSNG_CALL sangoma_tdm_get_hw_dtmf(sng_fd_t fd, wanpipe_api_t *tdm_api);

int _LIBSNG_CALL sangoma_tdm_get_hw_ec(sng_fd_t fd, wanpipe_api_t *tdm_api);


#ifdef WP_API_FEATURE_EC_CHAN_STAT

int _LIBSNG_CALL sangoma_tdm_get_hwec_chan_status(sng_fd_t fd, wanpipe_api_t *tdm_api);

#endif

#ifdef WP_API_FEATURE_HWEC_PERSIST    

int _LIBSNG_CALL sangoma_tdm_get_hwec_persist_status(sng_fd_t fd, wanpipe_api_t *tdm_api);   
#endif

int _LIBSNG_CALL sangoma_span_chan_toif(int span, int chan, char *interface_name);

int _LIBSNG_CALL sangoma_span_chan_fromif(char *interface_name, int *span, int *chan);


int _LIBSNG_CALL sangoma_interface_wait_up(int span, int chan, int sectimeout);

int _LIBSNG_CALL sangoma_get_driver_version(sng_fd_t fd, wanpipe_api_t *tdm_api, wan_driver_version_t *drv_ver);

int _LIBSNG_CALL sangoma_get_firmware_version(sng_fd_t fd, wanpipe_api_t *tdm_api, unsigned char *ver);

int _LIBSNG_CALL sangoma_get_cpld_version(sng_fd_t fd, wanpipe_api_t *tdm_api, unsigned char *ver);

int _LIBSNG_CALL sangoma_get_aft_customer_id(sng_fd_t fd, unsigned char *out_customer_id);

#ifdef WP_API_FEATURE_LED_CTRL

int _LIBSNG_CALL sangoma_port_led_ctrl(sng_fd_t fd, unsigned char led_state);   

#endif


#ifdef  WP_API_FEATURE_FE_RW

int _LIBSNG_CALL sangoma_fe_reg_write(sng_fd_t fd, uint32_t offset, uint8_t data);

int _LIBSNG_CALL sangoma_fe_reg_read(sng_fd_t fd, uint32_t offset, uint8_t *data);
#endif

int _LIBSNG_CALL sangoma_get_stats(sng_fd_t fd, wanpipe_api_t *tdm_api, wanpipe_chan_stats_t *stats);

int _LIBSNG_CALL sangoma_flush_stats(sng_fd_t fd, wanpipe_api_t *tdm_api);

int _LIBSNG_CALL sangoma_set_rm_rxflashtime(sng_fd_t fd, wanpipe_api_t *tdm_api, int rxflashtime);

#ifdef WP_API_FEATURE_RM_GAIN

int _LIBSNG_CALL sangoma_set_rm_tx_gain(sng_fd_t fd, wanpipe_api_t *tdm_api, int value);


int _LIBSNG_CALL sangoma_set_rm_rx_gain(sng_fd_t fd, wanpipe_api_t *tdm_api, int value);

#endif /* WP RM GAIN feature */

int _LIBSNG_CALL sangoma_tdm_set_polarity(sng_fd_t fd, wanpipe_api_t *tdm_api, int polarity);

int _LIBSNG_CALL sangoma_tdm_txsig_onhooktransfer(sng_fd_t fd, wanpipe_api_t *tdm_api);


#ifdef WP_API_FEATURE_LOOP

int _LIBSNG_CALL sangoma_tdm_enable_loop(sng_fd_t fd, wanpipe_api_t *tdm_api);

int _LIBSNG_CALL sangoma_tdm_disable_loop(sng_fd_t fd, wanpipe_api_t *tdm_api);    
#endif

/************************************************************/
int _LIBSNG_CALL sangoma_read_event(sng_fd_t fd, wanpipe_api_t *tdm_api);

#ifdef WP_API_FEATURE_LOGGER

sangoma_status_t _LIBSNG_CALL sangoma_logger_cmd_exec(sng_fd_t fd, wp_logger_cmd_t *logger_cmd);

sangoma_status_t _LIBSNG_CALL sangoma_logger_read_event(sng_fd_t fd, wp_logger_cmd_t *logger_cmd);

sangoma_status_t _LIBSNG_CALL sangoma_logger_flush_buffers(sng_fd_t fd, wp_logger_cmd_t *logger_cmd);

sangoma_status_t _LIBSNG_CALL sangoma_logger_get_statistics(sng_fd_t fd, wp_logger_cmd_t *logger_cmd);

sangoma_status_t _LIBSNG_CALL sangoma_logger_reset_statistics(sng_fd_t fd, wp_logger_cmd_t *logger_cmd);

sangoma_status_t _LIBSNG_CALL sangoma_logger_get_open_handle_counter(sng_fd_t fd, wp_logger_cmd_t *logger_cmd);

sangoma_status_t _LIBSNG_CALL sangoma_logger_get_logger_level(sng_fd_t fd, wp_logger_cmd_t *logger_cmd);

sangoma_status_t _LIBSNG_CALL sangoma_logger_set_logger_level(sng_fd_t fd, wp_logger_cmd_t *logger_cmd);

#endif /* WP LOGGER FEATURE */


#ifdef WP_API_FEATURE_DRIVER_GAIN

int _LIBSNG_CALL sangoma_set_tx_gain(sng_fd_t fd, wanpipe_api_t *tdm_api, float gain_val);

int _LIBSNG_CALL sangoma_set_rx_gain(sng_fd_t fd, wanpipe_api_t *tdm_api, float gain_val);

int _LIBSNG_CALL sangoma_clear_tx_gain(sng_fd_t fd, wanpipe_api_t *tdm_api);

int _LIBSNG_CALL sangoma_clear_rx_gain(sng_fd_t fd, wanpipe_api_t *tdm_api);
#endif

#ifndef LIBSANGOMA_LIGHT

/************************************************************/
int _LIBSNG_CALL sangoma_driver_port_start(sng_fd_t fd, port_management_struct_t *port_mgmnt, unsigned short port_no);


int _LIBSNG_CALL sangoma_driver_port_stop(sng_fd_t fd, port_management_struct_t *port_mgmnt, unsigned short port_no);


int _LIBSNG_CALL sangoma_driver_port_set_config(sng_fd_t fd, port_cfg_t *port_cfg, unsigned short port_no);


int _LIBSNG_CALL sangoma_driver_port_get_config(sng_fd_t fd, port_cfg_t *port_cfg, unsigned short port_no);


int _LIBSNG_CALL sangoma_driver_get_hw_info(sng_fd_t fd, port_management_struct_t *port_mgmnt, unsigned short port_no);


int _LIBSNG_CALL sangoma_driver_get_version(sng_fd_t fd, port_management_struct_t *port_mgmnt, unsigned short port_no);




#ifdef  WP_API_FEATURE_HARDWARE_RESCAN

int _LIBSNG_CALL sangoma_driver_hw_rescan(sng_fd_t fd, port_management_struct_t *port_mgmnt, int *detected_port_cnt);
#endif

int _LIBSNG_CALL sangoma_write_port_config_on_persistent_storage(hardware_info_t *hardware_info, port_cfg_t *port_cfg, unsigned short port_no);


/************************************************************/
int _LIBSNG_CALL sangoma_mgmt_cmd(sng_fd_t fd, wan_udp_hdr_t* wan_udp);


#endif  /* LIBSANGOMA_LIGHT */


/*================================================================
 * DEPRECATED Function Calls - Not to be used any more
 * Here for backward compatibility 
 *================================================================*/


#ifndef LIBSANGOMA_SET_FESTATUS

#define LIBSANGOMA_SET_FESTATUS 1
#endif

int _LIBSNG_CALL sangoma_get_fe_status(sng_fd_t fd, wanpipe_api_t *tdm_api, unsigned char *current_status);



int _LIBSNG_CALL sangoma_tdm_set_codec(sng_fd_t fd, wanpipe_api_t *tdm_api, int codec);

int _LIBSNG_CALL sangoma_tdm_get_codec(sng_fd_t fd, wanpipe_api_t *tdm_api);


sng_fd_t _LIBSNG_CALL sangoma_create_socket_by_name(char *device, char *card);

int _LIBSNG_CALL sangoma_interface_toi(char *interface_name, int *span, int *chan);


int _LIBSNG_CALL sangoma_tdm_set_power_level(sng_fd_t fd, wanpipe_api_t *tdm_api, int power);

int _LIBSNG_CALL sangoma_tdm_get_power_level(sng_fd_t fd, wanpipe_api_t *tdm_api);




#ifdef WP_API_FEATURE_LIBSNG_HWEC

sangoma_status_t _LIBSNG_CALL sangoma_hwec_config_init(char *device_name, wan_custom_param_t custom_params[], unsigned int number_of_custom_params);

sangoma_status_t _LIBSNG_CALL sangoma_hwec_config_release(char *device_name);

sangoma_status_t _LIBSNG_CALL sangoma_hwec_config_operation_mode(char *device_name, int mode, unsigned int fe_chan_map);

sangoma_status_t _LIBSNG_CALL sangoma_hwec_config_power_on(char *device_name,  unsigned int fe_chan_map);

sangoma_status_t _LIBSNG_CALL sangoma_hwec_config_power_off(char *device_name,  unsigned int fe_chan_map);

sangoma_status_t _LIBSNG_CALL sangoma_hwec_enable(char *device_name,  unsigned int fe_chan_map);

sangoma_status_t _LIBSNG_CALL sangoma_hwec_disable(char *device_name, unsigned int fe_chan_map);

sangoma_status_t _LIBSNG_CALL sangoma_hwec_config_channel_parameter(char *device_name, char *parameter, char *parameter_value, unsigned int channel_map);

sangoma_status_t _LIBSNG_CALL sangoma_hwec_config_tone_detection(char *device_name, int tone_id, int enable, unsigned int fe_chan_map, unsigned char port_map);

sangoma_status_t _LIBSNG_CALL sangoma_hwec_print_statistics(char *device_name, int full, unsigned int fe_chan_map);

sangoma_status_t _LIBSNG_CALL sangoma_hwec_audio_buffer_load(char *device_name, char *filename, char pcmlaw, int *out_buffer_id);

 sangoma_status_t _LIBSNG_CALL sangoma_hwec_audio_mem_buffer_load(char *device_name, unsigned char *buffer, unsigned int in_size, char pcmlaw, int *out_buffer_id);

sangoma_status_t _LIBSNG_CALL sangoma_hwec_audio_buffer_unload(char *device_name, int in_buffer_id);

sangoma_status_t _LIBSNG_CALL sangoma_hwec_audio_buffer_playout(char *device_name, unsigned int fe_chan_map, 
                                                                unsigned char port, int in_buffer_id, int start,
                                                                int repeat_cnt, int duration);

sangoma_status_t _LIBSNG_CALL sangoma_hwec_config_verbosity(int verbosity_level);

void _LIBSNG_CALL sangoma_hwec_initialize_custom_parameter_structure(wan_custom_param_t *custom_param, char *parameter_name, char *parameter_value);


sangoma_status_t _LIBSNG_CALL sangoma_hwec_get_channel_statistics(sng_fd_t fd, unsigned int fe_chan, 
                int *hwec_api_return_code, wanec_chan_stats_t *wanec_chan_stats, int verbose, int reset);


sangoma_status_t _LIBSNG_CALL sangoma_hwec_get_global_chip_statistics(sng_fd_t fd,
            int *hwec_api_return_code, wanec_chip_stats_t *wanec_chip_stats, int verbose, int reset);


sangoma_status_t _LIBSNG_CALL sangoma_hwec_get_chip_image_info(sng_fd_t fd,
            int *hwec_api_return_code, wanec_chip_image_t *wanec_chip_image, int verbose);

#ifdef WP_API_FEATURE_LIBSNG_HWEC_DTMF_REMOVAL

sangoma_status_t _LIBSNG_CALL sangoma_hwec_set_hwdtmf_removal(sng_fd_t fd, unsigned int fe_chan,
        int *hwec_api_return_code, int enable, int verbose);
#endif /* WP_API_FEATURE_LIBSNG_HWEC */
#endif



#ifdef WP_API_FEATURE_SS7_FORCE_RX

int _LIBSNG_CALL sangoma_ss7_force_rx(sng_fd_t fd, wanpipe_api_t *tdm_api);
#endif

#ifdef WP_API_FEATURE_SS7_CFG_STATUS

int _LIBSNG_CALL sangoma_ss7_get_cfg_status(sng_fd_t fd, wanpipe_api_t *tdm_api, wan_api_ss7_cfg_status_t *ss7_cfg_status);
#endif


#ifdef __cplusplus
}
#endif/* __WINDOWS__ */


#if defined(__WINDOWS__)

#ifdef __cplusplus
extern "C" {    /* for C++ users */
#endif

sangoma_status_t _LIBSNG_CALL sangoma_unload_driver();
sangoma_status_t _LIBSNG_CALL sangoma_load_driver();
void _LIBSNG_CALL sangoma_reset_port_numbers();
sangoma_status_t _LIBSNG_CALL sangoma_get_driver_version_from_registry(char *out_buffer, int out_buffer_length);
sangoma_status_t _LIBSNG_CALL sangoma_set_driver_mode_of_all_hw_devices(int driver_mode);

#ifdef __cplusplus
}
#endif/* __WINDOWS__ */

#else

#define sangoma_open_tdmapi_span_chan sangoma_open_api_span_chan
#define sangoma_open_tdmapi_span sangoma_open_api_span
#define sangoma_open_tdmapi_ctrl sangoma_open_api_ctrl
#define sangoma_tdm_get_fe_status sangoma_get_fe_status
#define sangoma_socket_close sangoma_close
#define sangoma_tdm_get_hw_coding sangoma_get_hw_coding
#define sangoma_tdm_set_fe_status sangoma_set_fe_status
#define sangoma_tdm_get_link_status sangoma_get_link_status
#define sangoma_tdm_flush_bufs sangoma_flush_bufs
#define sangoma_tdm_cmd_exec sangoma_cmd_exec
#define sangoma_tdm_read_event sangoma_read_event
#define sangoma_readmsg_tdm sangoma_readmsg
#define sangoma_readmsg_socket sangoma_readmsg
#define sangoma_sendmsg_socket sangoma_writemsg
#define sangoma_writemsg_tdm sangoma_writemsg
#define sangoma_create_socket_intr sangoma_open_api_span_chan
#endif

#endif  /* _LIBSANGOMA_H */