sangoma_interface.h

Go to the documentation of this file.

/*******************************************************************************/
#ifndef SANGOMA_INTERFACE_H
#define SANGOMA_INTERFACE_H

#include <stdio.h>
#include <stddef.h>     //for offsetof()
#include <stdlib.h>

#if defined(__WINDOWS__)
# include <windows.h>
# include <winioctl.h>
# include <conio.h>
# include "bit_win.h"
# include "wanpipe_time.h" //for usleep()

#elif defined(__LINUX__)

/* Include headers */
# include <stddef.h>
# include <errno.h>
# include <fcntl.h>
# include <string.h>
# include <ctype.h>
# include <sys/stat.h>
# include <sys/ioctl.h>
# include <sys/types.h>
# include <dirent.h>
# include <unistd.h>
# include <sys/socket.h>
# include <netdb.h>
# include <sys/un.h>
# include <sys/wait.h>
# include <unistd.h>
# include <signal.h>
# include <time.h>
#else
# error "sangoma_interface.h: undefined OS type"
#endif

/*
 * FSK CallerID and DTMF detection note:
 *  Stelephony.dll expects input BitStream (aLaw or uLaw audio) from a SINGLE timeslot.
 *  It is always the case for Analog cards, but not for the Digital cards, where
 *  API may provide input from a SINGLE or from MULTIPLE timeslots.
 */
#define USE_STELEPHONY_API 1 /* set to zero if don't need to compile 
                                libstelephony.dll function calls */

#include "wanpipe_api.h"
#include "sangoma_cthread.h"
#include "sample.h"

#include <libsangoma.h>

#if USE_STELEPHONY_API
# include <libstelephony.h>
#endif

class sangoma_interface : public sangoma_cthread
{
    sng_fd_t    sangoma_dev;

    void *sng_wait_obj;

    //receive stuff
    ULONG       rx_frames_count;
    ULONG       rx_bytes_count;
    //for counting frames with CRC/Abort errors
    ULONG       bad_rx_frames_count;
    DWORD       dwRxThreadId; 

    //transmit stuff
    ULONG       tx_bytes_count;
    ULONG       tx_frames_count;
    UCHAR       tx_test_byte;

    //IOCTL management structures and variables
    wan_udp_hdr_t   wan_udp;

    unsigned char get_wan_udphdr_data_byte(unsigned char off);

    unsigned char *get_wan_udphdr_data_ptr(unsigned char off);

    unsigned char set_wan_udphdr_data_byte(unsigned char off, unsigned char data);

    int             protocol_cb_size;
    int             wan_protocol;
    unsigned char   adapter_type;

    wanpipe_api_cmd_t tdm_api_cmd;

    wanpipe_api_t wp_api;
    
    void RxThreadFunc();
    void TxThreadFunc();

    int read_data();
    int read_event();

    int write_data(wp_api_hdr_t *hdr, void *tx_buffer);

    void cleanup();

    wan_cmd_api_t       wanpipe_api_cmd;
    
    int get_wan_config();

    int get_interface_configuration(if_cfg_t *wanif_conf_ptr);

    int get_fe_type(unsigned char* adapter_type);

    int wanpipe_api_ioctl(wan_cmd_api_t *api_cmd);

    unsigned char wp_brt[256];

    void generate_bit_rev_table();

    char is_rbs_monitoring_enabled;

#if USE_STELEPHONY_API

    stelephony_callback_functions_t scf;
    void *stelObj;
    void *DtmfBuffer;
    void *FskCidBuffer;
    void TxStelEncoderBuffer(void *pStelEncoderBuffer);
    CRITICAL_SECTION    StelTxCriticalSection;
#endif

    //data
    char                terminate_tx_rx_threads;

    wp_api_hdr_t        rxhdr;
    unsigned char       rx_data[MAX_NO_DATA_BYTES_IN_FRAME];

    wp_api_hdr_t        txhdr;
    unsigned char       tx_data[MAX_NO_DATA_BYTES_IN_FRAME];

    callback_functions_t    callback_functions;

    if_cfg_t                wanif_conf_struct;

    int WanpipeNumber;

    int InterfaceNumber;

#if DBG_TIMING
    wan_debug_t     wan_debug_rx_timing;
#endif

protected:
    virtual unsigned long threadFunction(struct ThreadParam& thParam);

public:
    char                device_name[DEV_NAME_LEN];

    //methods
    sangoma_interface(int wanpipe_number, int interface_number);
    ~sangoma_interface();

    int DoManagementCommand(sng_fd_t drv, wan_udp_hdr_t* packet);

    int init(callback_functions_t *callback_functions_ptr);
    int run();
    int stop();

    int transmit(wp_api_hdr_t *hdr, void *data);

    int receive (wp_api_hdr_t *hdr, void *data);

    void bit_swap_a_buffer(unsigned char *data, int len);

    void get_te1_56k_stat(void);
    void set_lb_modes(unsigned char type, unsigned char mode);
    int loopback_command(u_int8_t type, u_int8_t mode, u_int32_t chan_map);

    int get_operational_stats(wanpipe_chan_stats_t *stats);
    int flush_operational_stats (void);

    int CreateSwDtmfTxThread(void *buffer);
    int CreateFskCidTxThread(void *buffer);

    int enable_rbs_monitoring();
    char get_rbs(rbs_management_t *rbs_management_ptr);
    char set_rbs(rbs_management_t *rbs_management_ptr);

    int tdm_enable_rbs_events(int polls_per_second);
    int tdm_disable_rbs_events();

    int set_tx_idle_flag(unsigned char new_idle_flag);
    int get_open_handles_counter();

    //remove all data from API driver's transmit queue
    int flush_tx_buffers (void);

    sng_fd_t open_api_device();

    unsigned char get_adapter_type();
    unsigned int get_sub_media();
    void set_fe_debug_mode(sdla_fe_debug_t *fe_debug);

    void get_api_driver_version(PDRIVER_VERSION version);

    void get_card_customer_id(u_int8_t *customer_id);

#if USE_STELEPHONY_API
    int resetFSKCID(void);
    int sendCallerID(char *name, char *number);
    int sendSwDTMF(char dtmf_char);
#endif

    //TDM API calls
    int tdm_enable_rxhook_events();
    int tdm_disable_rxhook_events();

    /* DTMF Detection on A200 Analog card (SLIC) chip */
    int tdm_enable_rm_dtmf_events();
    int tdm_disable_rm_dtmf_events();

    /* DTMF Detection on Octasic chip */
    int tdm_enable_dtmf_events(uint8_t channel);
    int tdm_disable_dtmf_events(uint8_t channel);

    int tdm_enable_ring_detect_events();
    int tdm_disable_ring_detect_events();

    int tdm_enable_ring_trip_detect_events();
    int tdm_disable_ring_trip_detect_events();

    int tdm_enable_ring_events();
    int tdm_disable_ring_events();

    int tdm_txsig_onhook();
    int tdm_txsig_offhook();

    int tdm_enable_tone_events(uint16_t tone_id);
    int tdm_disable_tone_events();

    int tdm_front_end_activate();
    int tdm_front_end_deactivate();

    int tdm_control_flash_events(int rxflashtime);

    /* get current state of the line - is it Connected or Disconnected */
    int tdm_get_front_end_status(unsigned char *status);

    int tdm_set_user_period(unsigned int usr_period);

    int tdmv_api_ioctl(wanpipe_api_cmd_t *api_cmd);

    int reset_interface_state();

    int start_ring_tone();
    int stop_ring_tone();

    int start_congestion_tone();
    int stop_congestion_tone();

    int start_busy_tone();
    int stop_busy_tone();

    int stop_all_tones();

    int start_dial_tone();
    int stop_dial_tone();

    int start_ringing_phone();
    int stop_ringing_phone();

    int fxo_go_off_hook();
    int fxo_go_on_hook();

    //BRI only:
    int tdm_enable_bri_bchan_loopback(u_int8_t channel);
    int tdm_disable_bri_bchan_loopback(u_int8_t channel);

};


#if defined(__WINDOWS__)

#define HANDLE_DEVICE_IOCTL_RESULT(bResult)\
{ \
    if(bResult == 0){ \
        /* check message log */ \
        printf("%s(): Line: %d: Error!!\n", __FUNCTION__, __LINE__); \
        DecodeLastError(__FUNCTION__); \
        return 1; \
    } \
}

#endif /*__WINDOWS__*/

#endif//SANGOMA_INTERFACE_H

---