libsangoma_hwec.c

Go to the documentation of this file.

/*******************************************************************************/
#include "libsangoma.h"
#include "libsangoma-pvt.h"
#include "wanpipe_includes.h"

#ifdef WP_API_FEATURE_LIBSNG_HWEC

#include "wanpipe_events.h"
#include "wanec_api.h"
#include "wanec_iface_api.h"

#if defined (__WINDOWS__)
# include "wanpipe_time.h"  /* wp_sleep() */
# pragma comment( lib, "waneclib" ) /* import functions from waneclib.dll */
#endif/* __WINDOWS__) */

static int libsng_hwec_verbosity_level = 0x00;

/************************************************************/
static sangoma_status_t sangoma_hwec_bypass(char *device_name, int enable, unsigned int fe_chan_map)
{
    sangoma_status_t rc;
    wanec_api_hwec_t hwec;

    memset(&hwec, 0, sizeof(wanec_api_hwec_t));

    hwec.enable = enable;
    hwec.fe_chan_map = fe_chan_map;

    /* WAN_EC_API_CMD_HWEC_ENABLE/WAN_EC_API_CMD_HWEC_DISABLE - Controls the "bypass" mode.)*/
    rc = wanec_api_hwec(device_name, libsng_hwec_verbosity_level, &hwec);

    return rc;
}

static int sangoma_hwec_is_numeric_parameter(char *parameter)
{
    int i;
    static char *WANEC_numeric_params[] = {
        "WANEC_TailDisplacement",
        "WANEC_MaxPlayoutBuffers",
        "WANEC_MaxConfBridges",
        "WANEC_EchoOperationMode",
        "WANEC_ComfortNoiseMode",
        "WANEC_NonLinearityBehaviorA",
        "WANEC_NonLinearityBehaviorB",
        "WANEC_DoubleTalkBehavior",
        "WANEC_RinLevelControlGainDb",
        "WANEC_SoutLevelControlGainDb",
        "WANEC_RinAutomaticLevelControlTargetDb",
        "WANEC_SoutAutomaticLevelControlTargetDb",
        "WANEC_RinHighLevelCompensationThresholdDb",
        "WANEC_AnrSnrEnhancementDb",
        "WANEC_AecTailLength",
        NULL
    };

    i = 0;
    while(WANEC_numeric_params[i]){
        if (!wp_strncasecmp(parameter, WANEC_numeric_params[i], strlen(parameter))) {
            return 1;/* this IS a numeric parameter */
        }
        i++;
    };

    return 0;/* NOT a numeric parameter */
}

static sangoma_status_t sangoma_hwec_ioctl(sng_fd_t fd, wan_ec_api_t *ec_api)
{
    wanpipe_api_t tdm_api;
    sangoma_status_t err;

    /* it is very important to zero out 'tdm_api' */
    memset(&tdm_api, 0x00, sizeof(tdm_api));

    WANPIPE_API_INIT_CHAN((&tdm_api), ec_api->fe_chan);
    SANGOMA_INIT_TDM_API_CMD_RESULT(tdm_api);

    tdm_api.wp_cmd.cmd = WP_API_CMD_EC_IOCTL;

    tdm_api.wp_cmd.iovec_list.iovec_list[0].iov_base = ec_api;
    tdm_api.wp_cmd.iovec_list.iovec_list[0].iov_len = sizeof(*ec_api);

    err = sangoma_cmd_exec(fd, &tdm_api);
    if (err) {
        DBG_HWEC("sangoma_cmd_exec() Failed: err %d !\n", err);
        return err;
    }

#if 0
    if (WAN_EC_API_RC_OK != ec_api->err) {

        /* IOCTL ok, but error in cmd - caller must check 'ec_api->err' */
        switch(ec_api->err){
        case WAN_EC_API_RC_INVALID_STATE:
            DBG_HWEC("WP_API_CMD_EC_IOCTL Failed: Invalid State: %s !\n", 
                WAN_EC_STATE_DECODE(ec_api->state));
            break;
        case WAN_EC_API_RC_FAILED:
        case WAN_EC_API_RC_INVALID_CMD:
        case WAN_EC_API_RC_INVALID_DEV:
        case WAN_EC_API_RC_BUSY:
        case WAN_EC_API_RC_INVALID_CHANNELS:
        case WAN_EC_API_RC_INVALID_PORT:
        default:
            DBG_HWEC("WP_API_CMD_EC_IOCTL Failed: %s !\n",
                WAN_EC_API_RC_DECODE(ec_api->err));
            break;
        }
    }
#endif

    return SANG_STATUS_SUCCESS;
}

/***************************************************************
 * Public Functions. (Exported)
 ***************************************************************/ 

void _LIBSNG_CALL sangoma_hwec_initialize_custom_parameter_structure(wan_custom_param_t *custom_param, char *parameter_name, char *parameter_value)
{
    memset(custom_param, 0x00, sizeof(*custom_param));

    strncpy( custom_param->name, parameter_name, sizeof(custom_param->name) );

    if (sangoma_hwec_is_numeric_parameter(parameter_name)) {
        custom_param->dValue = atoi(parameter_value);
    } else {
        strncpy(custom_param->sValue, parameter_value, sizeof(custom_param->sValue));
    }
}

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 rc = SANG_STATUS_SUCCESS;
    wanec_api_config_t config;

    memset(&config, 0x00, sizeof(config));

    if (number_of_custom_params >= 1 && number_of_custom_params <= 4) {

        wan_custom_param_t *custom_parms_ptr;
        unsigned int i, custom_params_memory_size;

        custom_params_memory_size = sizeof(wan_custom_param_t) * number_of_custom_params;

        /* Do NOT change memory at custom_params[] (it belongs to the caller).
         * Instead allocate temporary buffer, and use information in custom_params[]
         * for proper initialization the temproary buffer and
         * and send if down to API driver. */
        custom_parms_ptr = malloc(custom_params_memory_size);
        if (!custom_parms_ptr) {
            return SANG_STATUS_FAILED_ALLOCATE_MEMORY;
        }

        memset(custom_parms_ptr, 0x00, custom_params_memory_size);

        for (i = 0; i < number_of_custom_params; i++) {

            strcpy( custom_parms_ptr[i].name, custom_params[i].name );

            if (sangoma_hwec_is_numeric_parameter(custom_params[i].name)) {
                custom_parms_ptr[i].dValue = atoi(custom_params[i].sValue);
            } else {
                strcpy(custom_parms_ptr[i].sValue, custom_params[i].sValue);
            }
        } /* for() */

        config.conf.param_no = number_of_custom_params;
        config.conf.params = custom_parms_ptr;

    }/* if() */

    /* Load firmware on EC chip AND apply configuration, if any. */
    rc = wanec_api_config( device_name, libsng_hwec_verbosity_level, &config );

    if (config.conf.params) {
        free(config.conf.params);
    }

    return rc;
}


sangoma_status_t _LIBSNG_CALL sangoma_hwec_config_release(char *device_name)
{
    sangoma_status_t rc;
    wanec_api_release_t release;

    memset(&release, 0, sizeof(wanec_api_release_t));

    rc = wanec_api_release( device_name, libsng_hwec_verbosity_level, &release );

    return rc;
}

sangoma_status_t _LIBSNG_CALL sangoma_hwec_config_operation_mode(char *device_name, int mode, unsigned int fe_chan_map)
{
    sangoma_status_t rc;
    wanec_api_opmode_t  opmode;

    memset(&opmode, 0, sizeof(wanec_api_opmode_t));

    opmode.mode = mode;
    opmode.fe_chan_map = fe_chan_map;

    /* modes are:
    WANEC_API_OPMODE_NORMAL,
    WANEC_API_OPMODE_HT_FREEZE,
    WANEC_API_OPMODE_HT_RESET, 
    WANEC_API_OPMODE_POWER_DOWN,
    WANEC_API_OPMODE_NO_ECHO,
    WANEC_API_OPMODE_SPEECH_RECOGNITION.
    */
    rc = wanec_api_opmode(device_name, libsng_hwec_verbosity_level, &opmode);

    return rc;
}

sangoma_status_t _LIBSNG_CALL sangoma_hwec_config_power_on(char *device_name,  unsigned int fe_chan_map)
{
    return sangoma_hwec_config_operation_mode(device_name, WANEC_API_OPMODE_NORMAL, fe_chan_map);
}

sangoma_status_t _LIBSNG_CALL sangoma_hwec_config_power_off(char *device_name,  unsigned int fe_chan_map)
{
    return sangoma_hwec_config_operation_mode(device_name, WANEC_API_OPMODE_POWER_DOWN, fe_chan_map);
}

sangoma_status_t _LIBSNG_CALL sangoma_hwec_enable(char *device_name,  unsigned int fe_chan_map)
{
    return sangoma_hwec_bypass(device_name, 1 /* enable */, fe_chan_map);
}


sangoma_status_t _LIBSNG_CALL sangoma_hwec_disable(char *device_name, unsigned int fe_chan_map)
{
    return sangoma_hwec_bypass(device_name, 0 /* disable */, 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 rc;
    wanec_api_modify_t channelModify;
    wan_custom_param_t custom_param;

    memset(&channelModify, 0x00, sizeof(channelModify));

    sangoma_hwec_initialize_custom_parameter_structure(&custom_param, parameter, parameter_value);

    channelModify.fe_chan_map = channel_map;
    channelModify.conf.param_no = 1;
    channelModify.conf.params = &custom_param;

    rc = wanec_api_modify( device_name, libsng_hwec_verbosity_level, &channelModify );

    return rc;
}

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 rc;
    wanec_api_tone_t tone;

    memset(&tone, 0, sizeof(wanec_api_tone_t));

    tone.id     = tone_id;
    tone.enable = enable;
    tone.fe_chan_map = fe_chan_map;
    tone.port_map   = port_map;
    tone.type_map   = WAN_EC_TONE_PRESENT | WAN_EC_TONE_STOP;

    rc = wanec_api_tone( device_name, libsng_hwec_verbosity_level, &tone );

    return rc;
}

sangoma_status_t _LIBSNG_CALL sangoma_hwec_print_statistics(char *device_name, int full, unsigned int fe_chan)
{
    sangoma_status_t rc;
    wanec_api_stats_t stats;

    memset(&stats, 0, sizeof(wanec_api_stats_t));

    stats.full  = full;
    stats.fe_chan = fe_chan;
    stats.reset = 0;    /* do not reset */

    rc = wanec_api_stats( device_name, libsng_hwec_verbosity_level, &stats );

    return rc;
}

sangoma_status_t _LIBSNG_CALL sangoma_hwec_audio_buffer_load(char *device_name, char *filename, char pcmlaw, int *out_buffer_id)
{
    sangoma_status_t rc;
    wanec_api_bufferload_t bufferload;

    memset(&bufferload, 0, sizeof(wanec_api_bufferload_t));
    *out_buffer_id = -1;

    bufferload.buffer = filename;
    bufferload.pcmlaw = pcmlaw;

    rc = wanec_api_buffer_load( device_name, libsng_hwec_verbosity_level, &bufferload );
    if( rc ) {
        return rc;
    }

    *out_buffer_id = bufferload.buffer_id;

    return SANG_STATUS_SUCCESS;
}

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 rc;
    wanec_api_membufferload_t bufferload;

    memset(&bufferload, 0, sizeof(bufferload));
    *out_buffer_id = -1;

    bufferload.buffer = buffer;
    bufferload.size = in_size;
    bufferload.pcmlaw = pcmlaw;

    rc = wanec_api_mem_buffer_load( device_name, libsng_hwec_verbosity_level, &bufferload );
    if( rc ) {
          return rc;
    }

    *out_buffer_id = bufferload.buffer_id;

    return SANG_STATUS_SUCCESS;
}

sangoma_status_t _LIBSNG_CALL sangoma_hwec_audio_buffer_unload(char *device_name, int in_buffer_id)
{
    sangoma_status_t rc;
    wanec_api_bufferunload_t bufferunload;

    memset(&bufferunload, 0, sizeof(wanec_api_bufferunload_t));

    bufferunload.buffer_id  = (unsigned int)in_buffer_id;

    rc = wanec_api_buffer_unload( device_name, libsng_hwec_verbosity_level, &bufferunload);

    return rc;
}

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 rc;
    wanec_api_playout_t playout;

    memset(&playout, 0, sizeof(wanec_api_playout_t));

    playout.start       = start;
    playout.fe_chan     = fe_chan_map;
    playout.buffer_id   = in_buffer_id;
    playout.port        = port;
    playout.notifyonstop    = 1;
    playout.user_event_id   = 0xA5; /* dummy value */
    playout.repeat_cnt  = repeat_cnt;
    playout.duration    = (duration) ? duration : cOCT6100_INVALID_VALUE;   /* default is no duration */

    rc = wanec_api_playout( device_name, libsng_hwec_verbosity_level, &playout);

    return rc;
}

sangoma_status_t _LIBSNG_CALL sangoma_hwec_config_verbosity(int verbosity_level)
{
    if (verbosity_level >= 0 || verbosity_level <= 3) {
        libsng_hwec_verbosity_level = verbosity_level;
        wanec_api_set_lib_verbosity(verbosity_level);
        return SANG_STATUS_SUCCESS;
    }
    return SANG_STATUS_INVALID_PARAMETER;
}

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 err;
    wan_ec_api_t ec_api;

    memset(&ec_api, 0x00, sizeof(ec_api));

    ec_api.cmd = WAN_EC_API_CMD_STATS_FULL;

    ec_api.verbose = verbose;

    /* translate channel number into "single bit" bitmap */
    ec_api.fe_chan_map = (1 << fe_chan);

    /* user may want to reset (clear) Channel statistics */
    ec_api.u_chan_stats.reset = reset;

    err = sangoma_hwec_ioctl(fd, &ec_api);
    if (err) {
        /* error in IOCTL */
        return err;
    }
        
    /* copy stats from driver buffer to user buffer */
    memcpy(wanec_chan_stats, &ec_api.u_chan_stats, sizeof(*wanec_chan_stats));

    *hwec_api_return_code = ec_api.err;

    return SANG_STATUS_SUCCESS;
}

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 err;
    wan_ec_api_t ec_api;

    memset(&ec_api, 0x00, sizeof(ec_api));

    ec_api.cmd = WAN_EC_API_CMD_STATS_FULL;

    ec_api.verbose = verbose;

    /* indicate to Driver to get chip stats, not channel stats, by setting fe_chan_map to zero */
    ec_api.fe_chan_map = 0;

    /* user may want to reset (clear) Chip statistics */
    ec_api.u_chip_stats.reset = reset;

    err = sangoma_hwec_ioctl(fd, &ec_api);
    if (err) {
        /* error in IOCTL */
        return err;
    }

    /* copy stats from driver buffer to user buffer */
    memcpy(wanec_chip_stats, &ec_api.u_chip_stats, sizeof(*wanec_chip_stats));

    *hwec_api_return_code = ec_api.err;

    return SANG_STATUS_SUCCESS;

}

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)
{
    sangoma_status_t err;
    wan_ec_api_t ec_api;

    memset(&ec_api, 0x00, sizeof(ec_api));

    ec_api.cmd = WAN_EC_API_CMD_STATS_IMAGE;

    ec_api.verbose = verbose;

    /* driver will copy image information into wanec_chip_image->f_ChipImageInfo */
    ec_api.u_chip_image.f_ChipImageInfo = wanec_chip_image->f_ChipImageInfo;

    err = sangoma_hwec_ioctl(fd, &ec_api);
    if (err) {
        /* error in IOCTL */
        return err;
    }

    *hwec_api_return_code = ec_api.err;

    return SANG_STATUS_SUCCESS;
}


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)
{
    sangoma_status_t err;
    wan_ec_api_t ec_api;

    memset(&ec_api, 0x00, sizeof(ec_api));

    if (enable) {
        ec_api.cmd = WAN_EC_API_CMD_HWDTMF_REMOVAL_ENABLE;
    } else {
        ec_api.cmd = WAN_EC_API_CMD_HWDTMF_REMOVAL_DISABLE;
    }

    ec_api.verbose = verbose;

    /* translate channel number into "single bit" bitmap */
    ec_api.fe_chan_map = (1 << fe_chan);

    err = sangoma_hwec_ioctl(fd, &ec_api);
    if (err) {
        /* error in IOCTL */
        return err;
    }

    *hwec_api_return_code = ec_api.err;

    return SANG_STATUS_SUCCESS;
}

#endif /* WP_API_FEATURE_LIBSNG_HWEC */