libhpsangoma.c

/*****************************************************************************
 * libhpsangoma.c:  Sangoma High Performance TDM API - Span Based Library
 *
 * Author(s):   Nenad Corbic <ncorbic@sangoma.com>
 *
 * Copyright:   (c) 2008 Nenad Corbic <ncorbic@sangoma.com>
 *
 *              This program is free software; you can redistribute it and/or
 *              modify it under the terms of the GNU General Public License
 *              as published by the Free Software Foundation; either version
 *              2 of the License, or (at your option) any later version.
 * ============================================================================
 *
 */

#include "libhpsangoma.h"
#include "libhpsangoma_priv.h"

/*---------------------------------------------------------
  PRIVATE STRUCTURES
 ----------------------------------------------------------*/

void (*lib_log)(int level, FILE *fp, char *file, const char *func, int line, char *fmt, ...)=NULL;


static int sangoma_hp_tdm_chan_push(struct sangoma_hptdm_chan *chan, char *data, int len)
{
        hp_tmd_chunk_t *tx_chunk;
        int free_slots;

        if (!chan->init) {
                return -2;
        }

        if (len >= SMG_HP_MAX_CHAN_DATA) {
                /* Data Too Big */
                lib_printf(0,NULL,"chan_push c%i tx chunk len %i too big\n",
                                chan->span_no+1,chan->chan_no+1,chan->tx_idx_in,len);
                return -1;
        }

        /* Lock */
        if (chan->tx_idx_in >= chan->tx_idx_out) {
                free_slots=SMG_HP_TDM_CHUNK_IDX_SZ-(chan->tx_idx_in-chan->tx_idx_out);
        } else {
                free_slots=chan->tx_idx_out-chan->tx_idx_in;
        }
        /* Un Lock */

        if (!free_slots) {
                /* We have just overruned the tx buffer */
                lib_printf(0,NULL,"chan_push c%i failed no free slots in %i out %i\n",
                                chan->span_no+1,chan->chan_no+1, chan->tx_idx_in,chan->tx_idx_out);
                return 1;
        }

        tx_chunk = &chan->tx_idx[chan->tx_idx_in];
        if (tx_chunk->init) {
                /* This should NEVER happen the chunk should be free */
                lib_printf(15,NULL,"chan_push s%ic%i tx chunk overrun in %i \n",
                                chan->span_no+1,chan->chan_no+1,chan->tx_idx_in);
                return 1;
        }

        memset(tx_chunk,0,sizeof(hp_tmd_chunk_t));
        memcpy(&tx_chunk->data,data,len);
        tx_chunk->len=len;
        tx_chunk->init=1;

        lib_printf(15,NULL,"chan_push s%ic%i tx chunk in %i \n",
                                chan->span_no+1,chan->chan_no+1,chan->tx_idx_in);

        chan->tx_idx_in++;
        if (chan->tx_idx_in >= SMG_HP_TDM_CHUNK_IDX_SZ) {
                chan->tx_idx_in=0;
        }

        return 0;
}

/*-------------------------------------------------
  Internal Span Methods
 -------------------------------------------------*/


static int sangoma_hp_tdm_open_chan(sangoma_hptdm_span_t *span,
                              sangoma_hptdm_chan_reg_t *cfg,
                              unsigned int chan_no,
                              sangoma_hptdm_chan_t **chan_ptr)
{
        sangoma_hptdm_chan_t *chan;

        if (!span->init) {
                return -1;
        }

        if (chan_no >= SMG_HP_TDM_MAX_CHANS) {
                lib_printf(0,NULL,"open_chan failed chan_no %i >= max chans %i\n",
                                chan_no, SMG_HP_TDM_MAX_CHANS);
                return -1;
        }

        if (!cfg->rx_data || !cfg->p) {
                return -1;
        }

        if (span->chan_idx[chan_no].chan_no_hw < 0) {
                lib_printf(0,NULL,"open_chan failed chan_no s%ic%i is not mapped to hardware\n",
                                span->span_no+1,chan_no+1);
                return -1;
        }

        chan = &span->chan_idx[chan_no].chan;
        if (chan->init) {
                /* Chan Busy */
                lib_printf(0,NULL,"open_chan failed chan_no s%ic%i is busy\n",
                                span->span_no+1,chan_no+1);
                return 1;
        }

        memset(chan,0,sizeof(sangoma_hptdm_chan_t));

        chan->chan_no = chan_no;
        chan->span = span;
        memcpy(&chan->chan_reg, cfg, sizeof(sangoma_hptdm_chan_reg_t));

        chan->push = sangoma_hp_tdm_chan_push;

        chan->init=1;
        lib_printf(15,NULL,"open_chan chan_no s%ic%i ok\n",
                                span->span_no+1,chan_no+1);

        *chan_ptr = chan;

        return 0;

}


static int sangoma_hp_tdm_close_chan(sangoma_hptdm_chan_t *chan)
{
        chan->init=0;
        chan->chan_reg.p=NULL;
        lib_printf(15,NULL,"close_chan chan_no s%ic%i ok\n",
                                chan->span_no+1,chan->chan_no+1);
        return 0;
}


static int sangoma_hp_tdm_is_chan_closed (sangoma_hptdm_chan_t *chan)
{
        return (chan->init == 0) ? 1:0;
}

static int sangoma_hp_tdm_close_span(sangoma_hptdm_span_t *span)
{
        int i;
        sangoma_hptdm_chan_t *chan=NULL;

        for (i=0;i<SMG_HP_TDM_MAX_CHANS;i++) {
                chan = &span->chan_idx[i].chan;
                if (chan->init) {
                        chan->init=0;
                }
        }

        close(span->sock);
        span->sock=-1;

        return 0;
}

static int sangoma_hp_tdm_event_ctrl_span(sangoma_hptdm_span_t *span, hp_tdmapi_tx_event_t *event)
{
        int err;

        if (!span->init || span->sock < 0) {
                return -1;
        }

        err = ioctl(span->sock,SIOC_WANPIPE_API,event);
        if (err < 0){
                lib_printf(0,NULL,"Error: SPAN %i Failed to execute event!\n",
                                span->span_no+1);
                return -1;
        }

        return 0;
}

static int sangoma_hp_tdm_event_get_cfg(sangoma_hptdm_span_t *span, wan_if_cfg_t *if_cfg)
{
        memcpy(if_cfg,&span->span_cfg,sizeof(if_cfg));
        return 0;
}

static int sangoma_hp_tdm_run_span(sangoma_hptdm_span_t *span)
{
        int err=0;
        fd_set  sock_read,sock_write,sock_oob;

        if (!span->init) {
                lib_printf(0, NULL, "Span %i not initialized %i\n",span->span_no+1);
                return -1;
        }

        lib_printf(15, NULL, "Starting RUN SPAN %i Sock=%i\n",span->span_no+1, span->sock);

        if (span->sock < 0) {
                err=sangoma_hptdm_span_open(span);
                if (err) {
                        usleep(500000);
                        err=-2;
                        goto sangoma_hp_tdm_run_span_exit;
                }
        }

        /* Initialize all select() descriptors */
        FD_ZERO(&sock_read);
        FD_ZERO(&sock_write);
        FD_ZERO(&sock_oob);

        FD_SET(span->sock,&sock_oob);
        FD_SET(span->sock,&sock_read);
        FD_SET(span->sock,&sock_write);

        err=select(span->sock + 1,&sock_read, NULL, &sock_oob, NULL);

        if (err > 0) {

                if (FD_ISSET(span->sock,&sock_oob)){
                        err=sangoma_hp_tdm_handle_oob_event(span);
                        if (err) {
                                lib_printf(0, NULL, "RUN SPAN: %i oob err %i\n",
                                        span->span_no+1, err);
                                err=-3;
                                goto sangoma_hp_tdm_run_span_exit;
                        }
                }
                if (FD_ISSET(span->sock,&sock_read)){
                        err=sangoma_hp_tdm_handle_read_event(span);
                        if (err) {
                                lib_printf(0, NULL, "RUN SPAN: %i read err %i\n",
                                        span->span_no+1, err);
                                err=-4;
                                goto sangoma_hp_tdm_run_span_exit;
                        }

                        err=sangoma_hp_tdm_handle_write_event(span);
                        if (err) {
                                lib_printf(0, NULL, "RUN SPAN: %i write err %i\n",
                                        span->span_no+1, err);
                                err=-5;
                                goto sangoma_hp_tdm_run_span_exit;
                        }
                }

        } else if (err==0) {
                /* Timeout continue */
                return 0;

        } else {
                /* Error */
                if (errno == EAGAIN) {
                        goto sangoma_hp_tdm_run_span_exit;
                }

                err=-6;
        }

sangoma_hp_tdm_run_span_exit:

        if (err < 0) {
                if (span->sock) {
                        close(span->sock);
                        span->sock=-1;
                }
        }

        return err;
}



/*---------------------------------------------------------
  PUBLIC STRUCTURES
 ----------------------------------------------------------*/


/*
  \brief Initialize and Configure Span - private functions not to be used directly!
  \param span_no span number - integer
  \param cfg span registration struct
  \param version library version number added by the macro
  \return NULL: fail,  Span Object: pass
 *
 * The __sangoma_hptdm_api_span_init() function must NOT be called directly!
 *  One MUST use defined sangoma_hptdm_api_span_init() macro instead
 */

sangoma_hptdm_span_t * __sangoma_hptdm_api_span_init(int span_no, sangoma_hptdm_span_reg_t *cfg, int version)
{
        int err,i,ch=0;
        sangoma_hptdm_span_t *span;

        span = malloc(sizeof(sangoma_hptdm_span_t));
        if (!span) {
                return NULL;
        }

        memset(span,0,sizeof(sangoma_hptdm_span_t));

        span->span_no=span_no;
        sprintf(span->if_name,"w%ig1",span_no+1);

        if (cfg) {
                memcpy(&span->span_reg,cfg,sizeof(sangoma_hptdm_span_reg_t));
                if (!lib_log) {
                        lib_log=cfg->log;
                }
        }

        err=sangoma_hptdm_span_open(span);
        if (err) {
                free(span);
                return NULL;
        }

        if (span->span_cfg.media == WAN_MEDIA_E1) {
                span->span_cfg.active_ch = span->span_cfg.active_ch >> 1;
        }

        lib_printf(0,NULL,"Span %i Configuration\n",span->span_no+1);
        lib_printf(0,NULL,"Used By\t:%i\n",span->span_cfg.usedby);
        lib_printf(0,NULL,"Media\t:%i\n",span->span_cfg.media);
        lib_printf(0,NULL,"Active Ch\t:0x%08X\n",span->span_cfg.active_ch);
        lib_printf(0,NULL,"Chunk Sz\t:%i\n",span->span_cfg.chunk_sz);
        lib_printf(0,NULL,"HW Coding\t:%i\n",span->span_cfg.hw_coding);
        lib_printf(0,NULL,"If Number\t:%i\n",span->span_cfg.interface_number);


        /* Map all channels to the actually configued on hardware */
        for (i=0;i<SMG_HP_TDM_MAX_CHANS;i++) {
                span->chan_idx[i].chan_no_hw=-1;
                if (span->span_cfg.active_ch & (1<<i)) {
                        span->chan_idx[i].chan_no_hw=ch;
                        lib_printf(0,NULL,"Chan %i Mapped to %i",i,ch);
                        ch++;
                        span->max_chans++;
                } else {
                        lib_printf(0,NULL,"Chan %i Not Mapped",i);
                }
        }

        lib_printf(0,NULL,"Total Chans\t:%i\n",span->max_chans);

        /* Must be configurable */
        span->chunk_sz=span->span_cfg.chunk_sz;
        span->tx_size=span->max_chans*span->chunk_sz;

        span->init=1;
        span->idle=0xFF;

        span->open_chan = sangoma_hp_tdm_open_chan;
        span->close_chan = sangoma_hp_tdm_close_chan;
        span->is_chan_closed = sangoma_hp_tdm_is_chan_closed;
        span->run_span =sangoma_hp_tdm_run_span;
        span->close_span = sangoma_hp_tdm_close_span;
        span->event_ctrl = sangoma_hp_tdm_event_ctrl_span;
        span->get_cfg = sangoma_hp_tdm_event_get_cfg;

        lib_printf(5, NULL, "Span %i Initialized\n",span->span_no+1);

        return span;
}

/*
  \brief Free, Un-Initialize Span
  \param span_no span object
  \return 0 = pass, non zero fail
 */

int sangoma_hptdm_api_span_free(sangoma_hptdm_span_t *span)
{
        if (span->sock >= 0) {
                span->close_span(span);
        }

        free(span);
        span=NULL;

        return 0;
}

---