/**
* \brief Initialises a range of wanpipe channels
* \param span FreeTDM span
* \param spanno Wanpipe span number
* \param start Initial wanpipe channel number
* \param end Final wanpipe channel number
* \param type FreeTDM channel type
* \param name FreeTDM span name
* \param number FreeTDM span number
* \param cas_bits CAS bits
* \return number of spans configured
*/
static unsigned wp_open_range(ftdm_span_t *span, unsigned spanno, unsigned start, unsigned end, ftdm_chan_type_t type, char *name, char *number, unsigned char cas_bits)
{
unsigned configured = 0, x;
#ifdef LIBSANGOMA_VERSION
sangoma_status_t sangstatus;
sangoma_wait_obj_t *sangoma_wait_obj;
#endif
if (type == FTDM_CHAN_TYPE_CAS) {
ftdm_log(FTDM_LOG_DEBUG, "Configuring Wanpipe CAS channels with abcd == 0x%X\n", cas_bits);
}
for(x = start; x < end; x++) {
ftdm_channel_t *chan;
ftdm_socket_t sockfd = FTDM_INVALID_SOCKET;
const char *dtmf = "none";
if (!strncasecmp(span->name, "smg_prid_nfas", 8) && span->trunk_type == FTDM_TRUNK_T1 && x == 24) {
#ifdef LIBSANGOMA_VERSION
sockfd = __tdmv_api_open_span_chan(spanno, x);
#else
ftdm_log(FTDM_LOG_ERROR, "span %d channel %d cannot be configured as smg_prid_nfas, you need to compile freetdm with newer libsangoma\n", spanno, x);
#endif
} else {
sockfd = tdmv_api_open_span_chan(spanno, x);
}
if (sockfd == FTDM_INVALID_SOCKET) {
ftdm_log(FTDM_LOG_ERROR, "Failed to open wanpipe device span %d channel %d\n", spanno, x);
continue;
}
if (ftdm_span_add_channel(span, sockfd, type, &chan) == FTDM_SUCCESS) {
wanpipe_tdm_api_t tdm_api;
memset(&tdm_api, 0, sizeof(tdm_api));
#ifdef LIBSANGOMA_VERSION
/* we need SANGOMA_DEVICE_WAIT_OBJ_SIG and not SANGOMA_DEVICE_WAIT_OBJ alone because we need to call
* sangoma_wait_obj_sig to wake up any I/O waiters when closing the channel (typically on ftdm shutdown)
* this adds an extra pair of file descriptors to the waitable object
* */
sangstatus = sangoma_wait_obj_create(&sangoma_wait_obj, sockfd, SANGOMA_DEVICE_WAIT_OBJ_SIG);
if (sangstatus != SANG_STATUS_SUCCESS) {
ftdm_log(FTDM_LOG_ERROR, "failure create waitable object for s%dc%d\n", spanno, x);
continue;
}
chan->mod_data = sangoma_wait_obj;
#endif
chan->physical_span_id = spanno;
chan->physical_chan_id = x;
chan->rate = 8000;
if (type == FTDM_CHAN_TYPE_FXS || type == FTDM_CHAN_TYPE_FXO || type == FTDM_CHAN_TYPE_B) {
int err;
dtmf = "software";
err = sangoma_tdm_get_hw_coding(chan->sockfd, &tdm_api);
if (tdm_api.wp_tdm_cmd.hw_tdm_coding) {
chan->native_codec = chan->effective_codec = FTDM_CODEC_ALAW;
} else {
chan->native_codec = chan->effective_codec = FTDM_CODEC_ULAW;
}
err = sangoma_tdm_get_hw_dtmf(chan->sockfd, &tdm_api);
if (err > 0) {
ftdm_channel_set_feature(chan, FTDM_CHANNEL_FEATURE_DTMF_DETECT);
dtmf = "hardware";
}
}
#ifdef LIBSANGOMA_VERSION
if (type == FTDM_CHAN_TYPE_FXS) {
if (sangoma_tdm_disable_ring_trip_detect_events(chan->sockfd, &tdm_api)) {
/* we had problems of on-hook/off-hook detection due to how ring trip events were handled
* if this fails, I believe we will still work ok as long as we dont handle them incorrectly */
ftdm_log(FTDM_LOG_WARNING, "Failed to disable ring trip events in channel s%dc%d\n", spanno, x);
}
}
#endif
#if 0
if (type == FTDM_CHAN_TYPE_FXS || type == FTDM_CHAN_TYPE_FXO) {
/* Enable FLASH/Wink Events */
int err=sangoma_set_rm_rxflashtime(chan->sockfd, &tdm_api, wp_globals.flash_ms);
if (err == 0) {
ftdm_log(FTDM_LOG_ERROR, "flash enabled s%dc%d\n", spanno, x);
} else {
ftdm_log(FTDM_LOG_ERROR, "flash disabled s%dc%d\n", spanno, x);
}
}
#endif
if (type == FTDM_CHAN_TYPE_CAS || type == FTDM_CHAN_TYPE_EM) {
#ifdef LIBSANGOMA_VERSION
sangoma_tdm_write_rbs(chan->sockfd,&tdm_api,chan->physical_chan_id, wanpipe_swap_bits(cas_bits));
/* this should probably be done for old libsangoma but I am not sure if the API is available and I'm lazy to check,
The poll rate is hard coded to 100 per second (done in the driver, is the max rate of polling allowed by wanpipe)
*/
if (sangoma_tdm_enable_rbs_events(chan->sockfd, &tdm_api, 100)) {
ftdm_log(FTDM_LOG_ERROR, "Failed to enable RBS/CAS events in device %d:%d fd:%d\n", chan->span_id, chan->chan_id, sockfd);
continue;
}
/* probably done by the driver but lets write defensive code this time */
sangoma_flush_bufs(chan->sockfd, &tdm_api);
#else
/*
* With wanpipe 3.4.4.2 I get failure even though the events are enabled, /var/log/messages said:
* wanpipe4: WARNING: Event type 9 is already pending!
* wanpipe4: Failed to add new fe event 09 ch_map=FFFFFFFF!
* may be we should not send an error until that is fixed in the driver
*/
if (sangoma_tdm_enable_rbs_events(chan->sockfd, &tdm_api, 100)) {
ftdm_log(FTDM_LOG_ERROR, "Failed to enable RBS/CAS events in device %d:%d fd:%d\n", chan->span_id, chan->chan_id, sockfd);
}
/* probably done by the driver but lets write defensive code this time */
sangoma_tdm_flush_bufs(chan->sockfd, &tdm_api);
sangoma_tdm_write_rbs(chan->sockfd,&tdm_api, wanpipe_swap_bits(cas_bits));
#endif
}
if (!ftdm_strlen_zero(name)) {
ftdm_copy_string(chan->chan_name, name, sizeof(chan->chan_name));
}
if (!ftdm_strlen_zero(number)) {
ftdm_copy_string(chan->chan_number, number, sizeof(chan->chan_number));
}
configured++;
ftdm_log_chan(chan, FTDM_LOG_INFO, "configured wanpipe device s%dc%d as FreeTDM channel %d:%d fd:%d DTMF: %s\n",
spanno, x, chan->span_id, chan->chan_id, sockfd, dtmf);
} else {
ftdm_log(FTDM_LOG_ERROR, "ftdm_span_add_channel failed for wanpipe span %d channel %d\n", spanno, x);
}
}
return configured;
}
/**
* \brief Executes an FreeTDM command on a Wanpipe channel
* \param ftdmchan Channel to execute command on
* \param command FreeTDM command to execute
* \param obj Object (unused)
* \return Success or failure
*/
static FIO_COMMAND_FUNCTION(wanpipe_command)
{
wanpipe_tdm_api_t tdm_api;
int err = 0;
memset(&tdm_api, 0, sizeof(tdm_api));
switch(command) {
case FTDM_COMMAND_OFFHOOK:
{
err=sangoma_tdm_txsig_offhook(ftdmchan->sockfd,&tdm_api);
if (err) {
snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "OFFHOOK Failed");
return FTDM_FAIL;
}
ftdm_set_flag_locked(ftdmchan, FTDM_CHANNEL_OFFHOOK);
}
break;
case FTDM_COMMAND_ONHOOK:
{
err=sangoma_tdm_txsig_onhook(ftdmchan->sockfd,&tdm_api);
if (err) {
snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "ONHOOK Failed");
return FTDM_FAIL;
}
ftdm_clear_flag_locked(ftdmchan, FTDM_CHANNEL_OFFHOOK);
}
break;
case FTDM_COMMAND_GENERATE_RING_ON:
{
err=sangoma_tdm_txsig_start(ftdmchan->sockfd,&tdm_api);
if (err) {
snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "Ring Failed");
return FTDM_FAIL;
}
ftdm_set_flag_locked(ftdmchan, FTDM_CHANNEL_RINGING);
ftdm_set_pflag_locked(ftdmchan, WP_RINGING);
ftdmchan->ring_time = ftdm_current_time_in_ms() + wp_globals.ring_on_ms;
}
break;
case FTDM_COMMAND_GENERATE_RING_OFF:
{
err=sangoma_tdm_txsig_offhook(ftdmchan->sockfd,&tdm_api);
if (err) {
snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "Ring-off Failed");
return FTDM_FAIL;
}
ftdm_clear_pflag_locked(ftdmchan, WP_RINGING);
ftdm_clear_flag_locked(ftdmchan, FTDM_CHANNEL_RINGING);
}
break;
case FTDM_COMMAND_GET_INTERVAL:
{
err=sangoma_tdm_get_usr_period(ftdmchan->sockfd, &tdm_api);
if (err > 0 ) {
FTDM_COMMAND_OBJ_INT = err;
err=0;
}
}
break;
case FTDM_COMMAND_ENABLE_ECHOCANCEL:
{
err=sangoma_tdm_enable_hwec(ftdmchan->sockfd, &tdm_api);
if (err) {
snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "HWEC Enable Failed");
return FTDM_FAIL;
}
}
break;
case FTDM_COMMAND_DISABLE_ECHOCANCEL:
{
err=sangoma_tdm_disable_hwec(ftdmchan->sockfd, &tdm_api);
if (err) {
snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "HWEC Disable Failed");
return FTDM_FAIL;
}
}
break;
case FTDM_COMMAND_ENABLE_DTMF_DETECT:
{
#ifdef WP_API_FEATURE_DTMF_EVENTS
err = sangoma_tdm_enable_dtmf_events(ftdmchan->sockfd, &tdm_api);
if (err) {
ftdm_log_chan_msg(ftdmchan, FTDM_LOG_WARNING, "Enabling of Sangoma HW DTMF failed\n");
snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "HW DTMF Enable Failed");
return FTDM_FAIL;
}
ftdm_log_chan_msg(ftdmchan, FTDM_LOG_DEBUG, "Enabled DTMF events\n");
#else
return FTDM_NOTIMPL;
#endif
}
break;
case FTDM_COMMAND_DISABLE_DTMF_DETECT:
{
#ifdef WP_API_FEATURE_DTMF_EVENTS
err = sangoma_tdm_disable_dtmf_events(ftdmchan->sockfd, &tdm_api);
if (err) {
ftdm_log_chan_msg(ftdmchan, FTDM_LOG_WARNING, "Disabling of Sangoma HW DTMF failed\n");
snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "HW DTMF Disable Failed");
return FTDM_FAIL;
}
ftdm_log_chan_msg(ftdmchan, FTDM_LOG_DEBUG, "Disabled DTMF events\n");
#else
return FTDM_NOTIMPL;
#endif
}
break;
case FTDM_COMMAND_ENABLE_LOOP:
{
#ifdef WP_API_FEATURE_LOOP
err=sangoma_tdm_enable_loop(ftdmchan->sockfd, &tdm_api);
if (err) {
snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "Loop Enable Failed");
return FTDM_FAIL;
}
#endif
}
break;
case FTDM_COMMAND_DISABLE_LOOP:
{
#ifdef WP_API_FEATURE_LOOP
err=sangoma_tdm_disable_loop(ftdmchan->sockfd, &tdm_api);
if (err) {
snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "Loop Disable Failed");
return FTDM_FAIL;
}
#endif
}
break;
case FTDM_COMMAND_SET_INTERVAL:
{
err=sangoma_tdm_set_usr_period(ftdmchan->sockfd, &tdm_api, FTDM_COMMAND_OBJ_INT);
ftdmchan->packet_len = ftdmchan->native_interval * (ftdmchan->effective_codec == FTDM_CODEC_SLIN ? 16 : 8);
}
break;
case FTDM_COMMAND_SET_CAS_BITS:
{
#ifdef LIBSANGOMA_VERSION
err = sangoma_tdm_write_rbs(ftdmchan->sockfd,&tdm_api, ftdmchan->physical_chan_id, wanpipe_swap_bits(FTDM_COMMAND_OBJ_INT));
#else
err = sangoma_tdm_write_rbs(ftdmchan->sockfd, &tdm_api, wanpipe_swap_bits(FTDM_COMMAND_OBJ_INT));
#endif
}
break;
case FTDM_COMMAND_GET_CAS_BITS:
{
#ifdef LIBSANGOMA_VERSION
unsigned char rbsbits;
err = sangoma_tdm_read_rbs(ftdmchan->sockfd, &tdm_api, ftdmchan->physical_chan_id, &rbsbits);
if (!err) {
FTDM_COMMAND_OBJ_INT = wanpipe_swap_bits(rbsbits);
}
#else
// does sangoma_tdm_read_rbs is available here?
FTDM_COMMAND_OBJ_INT = ftdmchan->rx_cas_bits;
#endif
}
break;
case FTDM_COMMAND_SET_LINK_STATUS:
{
ftdm_channel_hw_link_status_t status = FTDM_COMMAND_OBJ_INT;
char sangoma_status = status == FTDM_HW_LINK_CONNECTED ? FE_CONNECTED : FE_DISCONNECTED;
err = sangoma_tdm_set_fe_status(ftdmchan->sockfd, &tdm_api, sangoma_status);
}
break;
case FTDM_COMMAND_GET_LINK_STATUS:
{
unsigned char sangoma_status = 0;
err = sangoma_tdm_get_fe_status(ftdmchan->sockfd, &tdm_api, &sangoma_status);
if (!err) {
FTDM_COMMAND_OBJ_INT = sangoma_status == FE_CONNECTED ? FTDM_HW_LINK_CONNECTED : FTDM_HW_LINK_DISCONNECTED;
}
}
break;
default:
break;
};
if (err) {
snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "%s", strerror(errno));
return FTDM_FAIL;
}
return FTDM_SUCCESS;
}
/**
* \brief Executes an Openzap command on a Wanpipe channel
* \param zchan Channel to execute command on
* \param command Openzap command to execute
* \param obj Object (unused)
* \return Success or failure
*/
static ZIO_COMMAND_FUNCTION(wanpipe_command)
{
wanpipe_tdm_api_t tdm_api;
int err = 0;
memset(&tdm_api, 0, sizeof(tdm_api));
switch(command) {
case ZAP_COMMAND_OFFHOOK:
{
err=sangoma_tdm_txsig_offhook(zchan->sockfd,&tdm_api);
if (err) {
snprintf(zchan->last_error, sizeof(zchan->last_error), "OFFHOOK Failed");
return ZAP_FAIL;
}
zap_set_flag_locked(zchan, ZAP_CHANNEL_OFFHOOK);
}
break;
case ZAP_COMMAND_ONHOOK:
{
err=sangoma_tdm_txsig_onhook(zchan->sockfd,&tdm_api);
if (err) {
snprintf(zchan->last_error, sizeof(zchan->last_error), "ONHOOK Failed");
return ZAP_FAIL;
}
zap_clear_flag_locked(zchan, ZAP_CHANNEL_OFFHOOK);
}
break;
case ZAP_COMMAND_GENERATE_RING_ON:
{
err=sangoma_tdm_txsig_start(zchan->sockfd,&tdm_api);
if (err) {
snprintf(zchan->last_error, sizeof(zchan->last_error), "Ring Failed");
return ZAP_FAIL;
}
zap_set_flag_locked(zchan, ZAP_CHANNEL_RINGING);
zap_set_pflag_locked(zchan, WP_RINGING);
zchan->ring_time = zap_current_time_in_ms() + wp_globals.ring_on_ms;
}
break;
case ZAP_COMMAND_GENERATE_RING_OFF:
{
err=sangoma_tdm_txsig_offhook(zchan->sockfd,&tdm_api);
if (err) {
snprintf(zchan->last_error, sizeof(zchan->last_error), "Ring-off Failed");
return ZAP_FAIL;
}
zap_clear_pflag_locked(zchan, WP_RINGING);
zap_clear_flag_locked(zchan, ZAP_CHANNEL_RINGING);
}
break;
case ZAP_COMMAND_GET_INTERVAL:
{
err=sangoma_tdm_get_usr_period(zchan->sockfd, &tdm_api);
if (err > 0 ) {
ZAP_COMMAND_OBJ_INT = err;
err=0;
}
}
break;
case ZAP_COMMAND_ENABLE_ECHOCANCEL:
{
err=sangoma_tdm_enable_hwec(zchan->sockfd, &tdm_api);
if (err) {
snprintf(zchan->last_error, sizeof(zchan->last_error), "HWEC Enable Failed");
return ZAP_FAIL;
}
}
break;
case ZAP_COMMAND_DISABLE_ECHOCANCEL:
{
err=sangoma_tdm_disable_hwec(zchan->sockfd, &tdm_api);
if (err) {
snprintf(zchan->last_error, sizeof(zchan->last_error), "HWEC Disable Failed");
return ZAP_FAIL;
}
}
break;
case ZAP_COMMAND_ENABLE_DTMF_DETECT:
{
#ifdef WP_API_FEATURE_DTMF_EVENTS
err = sangoma_tdm_enable_dtmf_events(zchan->sockfd, &tdm_api);
if (err) {
zap_log(ZAP_LOG_WARNING, "Enabling of Sangoma HW DTMF failed\n");
snprintf(zchan->last_error, sizeof(zchan->last_error), "HW DTMF Enable Failed");
return ZAP_FAIL;
}
zap_log(ZAP_LOG_DEBUG, "Enabled DTMF events on chan %d:%d\n", zchan->span_id, zchan->chan_id);
#else
return ZAP_NOTIMPL;
#endif
}
break;
case ZAP_COMMAND_DISABLE_DTMF_DETECT:
{
#ifdef WP_API_FEATURE_DTMF_EVENTS
err = sangoma_tdm_disable_dtmf_events(zchan->sockfd, &tdm_api);
if (err) {
zap_log(ZAP_LOG_WARNING, "Disabling of Sangoma HW DTMF failed\n");
snprintf(zchan->last_error, sizeof(zchan->last_error), "HW DTMF Disable Failed");
return ZAP_FAIL;
}
zap_log(ZAP_LOG_DEBUG, "Disabled DTMF events on chan %d:%d\n", zchan->span_id, zchan->chan_id);
#else
return ZAP_NOTIMPL;
#endif
}
break;
case ZAP_COMMAND_ENABLE_LOOP:
{
#ifdef WP_API_FEATURE_LOOP
err=sangoma_tdm_enable_loop(zchan->sockfd, &tdm_api);
if (err) {
snprintf(zchan->last_error, sizeof(zchan->last_error), "Loop Enable Failed");
return ZAP_FAIL;
}
#endif
}
break;
case ZAP_COMMAND_DISABLE_LOOP:
{
#ifdef WP_API_FEATURE_LOOP
err=sangoma_tdm_disable_loop(zchan->sockfd, &tdm_api);
if (err) {
snprintf(zchan->last_error, sizeof(zchan->last_error), "Loop Disable Failed");
return ZAP_FAIL;
}
#endif
}
break;
case ZAP_COMMAND_SET_INTERVAL:
{
err=sangoma_tdm_set_usr_period(zchan->sockfd, &tdm_api, ZAP_COMMAND_OBJ_INT);
zchan->packet_len = zchan->native_interval * (zchan->effective_codec == ZAP_CODEC_SLIN ? 16 : 8);
}
break;
case ZAP_COMMAND_SET_CAS_BITS:
{
#ifdef LIBSANGOMA_VERSION
err = sangoma_tdm_write_rbs(zchan->sockfd,&tdm_api, zchan->physical_chan_id, wanpipe_swap_bits(ZAP_COMMAND_OBJ_INT));
#else
err = sangoma_tdm_write_rbs(zchan->sockfd, &tdm_api, wanpipe_swap_bits(ZAP_COMMAND_OBJ_INT));
#endif
}
break;
case ZAP_COMMAND_GET_CAS_BITS:
{
#ifdef LIBSANGOMA_VERSION
unsigned char rbsbits;
err = sangoma_tdm_read_rbs(zchan->sockfd, &tdm_api, zchan->physical_chan_id, &rbsbits);
if (!err) {
ZAP_COMMAND_OBJ_INT = wanpipe_swap_bits(rbsbits);
}
#else
// does sangoma_tdm_read_rbs is available here?
ZAP_COMMAND_OBJ_INT = zchan->rx_cas_bits;
#endif
}
break;
default:
break;
};
if (err) {
snprintf(zchan->last_error, sizeof(zchan->last_error), "%s", strerror(errno));
return ZAP_FAIL;
}
return ZAP_SUCCESS;
}
