Koders Code Search: otdialsc.cpp

/**************************************************************************
* OpenTel Telephony Server & Framework.
* Copyright (c) 1995-99 OpenComm do Brasil Ltda.
* Todos os direitos reservados.
* Este arquivo contem material confidencial de OpenComm dp Brasil, e deve
* darse tratamento como tal.
* -------------------------------------------------------------------------
* Descripcion:
* Implementao do OtBusSC e os Listeners e Transmitters para os boards
* QUe utilizam o sc bus.
*
* -------------------------------------------------------------------------
* Uso:
*
* -------------------------------------------------------------------------
* Ejemplos:
* -------------------------------------------------------------------------
* Problemas conocidos:
* -------------------------------------------------------------------------
* Historia del archivo:
*
* 03/09/98 - Creacion de la clase - JEB
* 25/03/00 - Starting adding support for bus configuration = JEB
**************************************************************************/

#ident "@(#) $Header: /cvsroot/opentel/opentel/server/drivers/dialogic/otdialsc.cpp,v 1.3 2000/04/21 20:27:30 jbernab Exp $"

#include <otconfig.h>

#ifdef _WINDOWS
#include <windows.h>
#include <io.h>
#endif

#ifdef __unix
#include <stdio.h>
#endif

extern "C" {
#include <srllib.h>
#ifdef CONFIG_DIALOGIC_DTI
#include <dtilib.h>
#endif
#include <dxxxlib.h>
#ifdef CONFIG_DIALOGIC_MSI
#include <msilib.h>
#endif
#ifdef CONFIG_DIALOGICGC
#include <gclib.h>
#include <gcerr.h>
#endif
#include <string.h>
#include <stdio.h>
#include <malloc.h>
};

#include <otarchive.includes>
#include <otbus.includes>

#include <dialogic/otdialogic.h>

#ifdef CONFIG_DIALOGIC_DXX
#include <dialogic/otdialdxx.h>
#endif

#ifdef CONFIG_DIALOGIC_MSI
#include <dialogic/otdialmsi.h>
#endif

#include <dialogic/otdialsc.h>
#include <otnum.includes>

#include <OtBusConfig.h>


OT_IMPLEMENT_DYNCREATE(OtBusSC, OtBus);

OtBusSC::OtBusSC() :
OtBus()
{
	int x;
	for(x=0;x<1024;x++) {                   // Creates Free TimeSlot Pool
		OtTimeSlot *t=new OtTimeSlotSC(this,x);
		m_freePool.add(t);
	}
}

OtBusSC::~OtBusSC(void)
///////////////////////
{
}

void
OtBusSC::initialize( OtBusConfig &busConfig )
/////////////////////////////////////////////
{
	OtBus::initialize( busConfig );
}



OtTimeSlotSC *OtBusSC::allocTimeSlotById(long id)
/////////////////////////////////////////////////
{
	OtTimeSlotSC *t=NULL;
	
    OtListCursor<OtTimeSlot> c(m_freePool);
	
    for(c.first();c.current()!=NULL;c.next()) {
        t=(OtTimeSlotSC *)c.current();
        if(t->getScBusTs()==id) {
			allocTimeSlotByTS(t);
			break;
		}
	}
	if(!t)
		throw OtException(OtString("OtBusSC::AllocTimeSlotById: Couldn't alloc time slot ") + OtString((char *)OtNum(id)) + OtString(", id not found in pool"));
	
	return t;
}

//
//
//      OtTimeSlotSC
//
//

OtTimeSlotSC::OtTimeSlotSC(OtBusSC *b, long id)
{
	OTASSERT(b!=NULL);
	m_bus=b;
	m_ts=id;
}

OtTimeSlotSC::~OtTimeSlotSC()
{
	m_bus=NULL;
	m_ts=ERROR;
}

int OtTimeSlotSC::isOnBus(OtBus *b) const
{
	return b==m_bus;
}

OtBus *OtTimeSlotSC::getBus(void)
{
	return m_bus;
}


//
//
//      OtTimeSlotListenerDxxSC
//  OtTimeSlotTransmitterDxxSC
//
#ifdef CONFIG_DIALOGIC_DXX

OtTimeSlotListenerDxxSC::OtTimeSlotListenerDxxSC(OtDialogicDxx *dxx,OtBusSC *bus) :
m_dxx(dxx),
m_bus(bus)
{
	
}

OtTimeSlotListenerDxxSC::~OtTimeSlotListenerDxxSC()
{
	m_dxx=NULL;
	m_bus=NULL;
}

void OtTimeSlotListenerDxxSC::listenOn(OtTimeSlot *t)
{
	OTASSERT(t!=NULL);
	
	if(!t->isOnBus(m_bus))
		throw OtException("OtTimeSlotListenerDxxSC::ListenOn(): TimeSlot not on same bus");
	
	SC_TSINFO tsinfo;
	long scts;
	OtTimeSlotSC *tssc=(OtTimeSlotSC *)t;
	
	scts = tssc->getScBusTs();
	tsinfo.sc_numts = 1;
	tsinfo.sc_tsarrayp = &scts;
	
	OtDebug(OT_DEBUG_SC, "DxxSC(%s)::listenOn(bus=%s, ts=%d)\n",(char *)m_dxx->getName(),(char *)m_bus->getName(),scts);
	
	if(dx_listen(m_dxx->getFd(), &tsinfo)<0)
		throw OtDialogicException(m_dxx->getFd());
	
	// Framework Stuff
	m_ListenTS=tssc;
	tssc->addListener(this);
}

void OtTimeSlotListenerDxxSC::unListen()
{
	OtDebug(OT_DEBUG_SC, "DxxSC(%s)::UnListen()\n",(char *)m_dxx->getName());
	
	// Dialogic Stuff
	if(dx_unlisten(m_dxx->getFd())<0)
		throw OtDialogicException(m_dxx->getFd());
	
	// Framework Stuff
	if(m_ListenTS)
		m_ListenTS->removeListener(this);
	
	m_ListenTS=NULL;
}

OtTimeSlot *OtTimeSlotListenerDxxSC::getLsTimeSlot(void) const
{
	return m_ListenTS;
}

int OtTimeSlotListenerDxxSC::isListenFixed(void) const
{
	return false;           // Every Resource in SCBus has the listen ts mobile
}

//
//

OtTimeSlotTransmitterDxxSC::OtTimeSlotTransmitterDxxSC(OtDialogicDxx *dxx, OtBusSC *bus) :
m_dxx(dxx),
m_bus(bus)
{
	loadTsInfo();           // Load ts from the board and set thing up
}

OtTimeSlotTransmitterDxxSC::~OtTimeSlotTransmitterDxxSC()
{
	if(m_TransmitTS) {
		if(m_TransmitTS->getTransmitter()!=this)
			throw OtException("~OtTimeSlotTransmitterDxxSC: Something wrong");
		m_TransmitTS->setTransmitter(NULL);
	}
	m_dxx=NULL;
	m_bus=NULL;
}

void OtTimeSlotTransmitterDxxSC::transmitOn(OtTimeSlot *t)
{
	throw OtException("OtTimeSlotTransmitterDxxSC::transmitOn(): Transmit Timeslot is fixed on this device");
}

void OtTimeSlotTransmitterDxxSC::unTransmit()
{
	throw OtException("OtTimeSlotTransmitterDxxSC::transmitOn(): Transmit Timeslot is fixed on this device");
}

OtTimeSlot *OtTimeSlotTransmitterDxxSC::getTxTimeSlot(void) const
{
	return m_TransmitTS;
}

int OtTimeSlotTransmitterDxxSC::isTransmitFixed(void) const
{
	return true;            // Every Resource in SCBus has the transmit ts fix
}

void OtTimeSlotTransmitterDxxSC::loadTsInfo()
{
	// get ts from board
	long ts;
	SC_TSINFO tsinfo;
	
	tsinfo.sc_numts = 1;
	tsinfo.sc_tsarrayp = &ts;
	
	if(dx_getxmitslot(m_dxx->getFd(),&tsinfo)<0)
		throw OtDialogicException(m_dxx->getFd());
	
	// Alloc that timeslot from the bus
	m_TransmitTS = m_bus->allocTimeSlotById(ts);
	m_TransmitTS->setTransmitter(this);
}

#endif

//
//
//      OtTimeSlotListenerMsiSC
//  OtTimeSlotTransmitterMsiSC
//

#ifdef CONFIG_DIALOGIC_MSI

OtTimeSlotListenerMsiSC::OtTimeSlotListenerMsiSC(OtDialogicMsiDev *msi,OtBusSC *bus) :
m_msi(msi),
m_bus(bus)
{
	
}

OtTimeSlotListenerMsiSC::~OtTimeSlotListenerMsiSC()
{
	m_msi=NULL;
	m_bus=NULL;
}

void OtTimeSlotListenerMsiSC::listenOn(OtTimeSlot *t)
{
	if(!t->isOnBus(m_bus))
		throw OtException("OtTimeSlotListenerMsiSC::listenOn(): TimeSlot not on same bus");
	
	SC_TSINFO tsinfo;
	long scts;
	OtTimeSlotSC *tssc=(OtTimeSlotSC *)t;
	
	scts = tssc->getScBusTs();
	tsinfo.sc_numts = 1;
	tsinfo.sc_tsarrayp = &scts;
	
	OtDebug(OT_DEBUG_SC, "MsiSC(%s)::listenOn(bus=%s, ts=%d)\n",(char *)m_msi->getName(),(char *)m_bus->getName(),scts);
	
	if(ms_listen(m_msi->getFd(), &tsinfo)<0)
		throw OtDialogicException(m_msi->getFd());
	
	// Framework Stuff
	m_ListenTS=tssc;
	tssc->addListener(this);
}

void OtTimeSlotListenerMsiSC::unListen()
{
	OtDebug(OT_DEBUG_SC, "MsiSC(%s)::unListen()\n",(char *)m_msi->getName());
	// Dialogic Stuff
	if(ms_unlisten(m_msi->getFd())<0)
		throw OtDialogicException(m_msi->getFd());
	
	// Framework Stuff
	if(m_ListenTS)
		m_ListenTS->removeListener(this);
	
	m_ListenTS=NULL;
}

OtTimeSlot *OtTimeSlotListenerMsiSC::getLsTimeSlot(void) const
{
	return m_ListenTS;
}

int OtTimeSlotListenerMsiSC::isListenFixed(void) const
{
	return false;           // Every Resource in SCBus has the listen ts mobile
}

//
//

OtTimeSlotTransmitterMsiSC::OtTimeSlotTransmitterMsiSC(OtDialogicMsiDev *msi, OtBusSC *bus) :
m_msi(msi),
m_bus(bus)
{
	loadTsInfo();           // Load ts from the board and set thing up
}

OtTimeSlotTransmitterMsiSC::~OtTimeSlotTransmitterMsiSC()
{
	if(m_TransmitTS) {
		if(m_TransmitTS->getTransmitter()!=this)
			throw OtException("~OtTimeSlotTransmitterMsiSC: Something wrong");
		m_TransmitTS->setTransmitter(NULL);
	}
	m_msi=NULL;
	m_bus=NULL;
}

void OtTimeSlotTransmitterMsiSC::transmitOn(OtTimeSlot *t)
{
	throw OtException("OtTimeSlotTransmitterMsiSC::transmitOn(): Transmit Timeslot is fixed on this device");
}

void OtTimeSlotTransmitterMsiSC::unTransmit()
{
	throw OtException("OtTimeSlotTransmitterMsiSC::transmitOn(): Transmit Timeslot is fixed on this device");
}

OtTimeSlot *OtTimeSlotTransmitterMsiSC::getTxTimeSlot(void) const
{
	return m_TransmitTS;
}

int OtTimeSlotTransmitterMsiSC::isTransmitFixed(void) const
{
	return true;            // Every Resource in SCBus has the transmit ts fix
}

void OtTimeSlotTransmitterMsiSC::loadTsInfo()
{
	// get ts from board
	long ts;
	SC_TSINFO tsinfo;
	
	tsinfo.sc_numts = 1;
	tsinfo.sc_tsarrayp = &ts;
	
	if(ms_getxmitslot(m_msi->getFd(),&tsinfo)<0)
		throw OtDialogicException(m_msi->getFd());
	
	// Alloc that timeslot from the bus
	m_TransmitTS = m_bus->allocTimeSlotById(ts);
	m_TransmitTS->setTransmitter(this);
}

#endif

//
//
//      OtTimeSlotListenerDtiSC
//  OtTimeSlotTransmitterDtiSC
//

#ifdef CONFIG_DIALOGIC_DTI

OtTimeSlotListenerDtiSC::OtTimeSlotListenerDtiSC(OtDialogicDti *dti,OtBusSC *bus) :
m_dti(dti),
m_bus(bus),
m_ListenTS(NULL)
{
	
}

OtTimeSlotListenerDtiSC::~OtTimeSlotListenerDtiSC()
{
	unListen();
	
	m_dti=NULL;
	m_bus=NULL;
}

void OtTimeSlotListenerDtiSC::listenOn(OtTimeSlot *t)
{
	if(!t->isOnBus(m_bus))
		throw OtException("OtTimeSlotListenerDtiSC::listenOn(): TimeSlot not on same bus");
	
	SC_TSINFO tsinfo;
	long scts;
	OtTimeSlotSC *tssc=(OtTimeSlotSC *)t;
	
	scts = tssc->getScBusTs();
	tsinfo.sc_numts = 1;
	tsinfo.sc_tsarrayp = &scts;
	
	OtDebug(OT_DEBUG_SC, "DtiSC(%s)::listenOn(bus=%s, ts=%d)\n",(char *)m_dti->getName(),(char *)m_bus->getName(),scts);
	
	if(dt_listen(m_dti->getFd(), &tsinfo)<0)
		throw OtDialogicException(m_dti->getFd());
	
	// Framework Stuff
	m_ListenTS=tssc;
	tssc->addListener(this);
}

void OtTimeSlotListenerDtiSC::unListen()
{
	OtDebug(OT_DEBUG_SC, "DtiSC(%s)::unListen()\n",(char *)m_dti->getName());
	// Dialogic Stuff
	if(dt_unlisten(m_dti->getFd())<0)
		throw OtDialogicException(m_dti->getFd());
	
	// Framework Stuff
	if(m_ListenTS)
		m_ListenTS->removeListener(this);
	
	m_ListenTS=NULL;
}

OtTimeSlot *OtTimeSlotListenerDtiSC::getLsTimeSlot(void) const
{
	return m_ListenTS;
}

int OtTimeSlotListenerDtiSC::isListenFixed(void) const
{
	return false;           // Every Resource in SCBus has the listen ts mobile
}

//
//

OtTimeSlotTransmitterDtiSC::OtTimeSlotTransmitterDtiSC(OtDialogicDti *dti, OtBusSC *bus) :
m_dti(dti),
m_bus(bus)
{
	loadTsInfo();           // Load ts from the board and set thing up
}

OtTimeSlotTransmitterDtiSC::~OtTimeSlotTransmitterDtiSC()
{
	if(m_TransmitTS) {
		if(m_TransmitTS->getTransmitter()!=this)
			throw OtException("~OtTimeSlotTransmitterDtiSC: Something wrong");
		m_TransmitTS->setTransmitter(NULL);
	}
	m_dti=NULL;
	m_bus=NULL;
}

void OtTimeSlotTransmitterDtiSC::transmitOn(OtTimeSlot *t)
{
	throw OtException("OtTimeSlotTransmitterDtiSC::transmitOn(): Transmit Timeslot is fixed on this device");
}

void OtTimeSlotTransmitterDtiSC::unTransmit()
{
	throw OtException("OtTimeSlotTransmitterDtiSC::unTransmit(): Transmit Timeslot is fixed on this device");
}

OtTimeSlot *OtTimeSlotTransmitterDtiSC::getTxTimeSlot(void) const
{
	return m_TransmitTS;
}

int OtTimeSlotTransmitterDtiSC::isTransmitFixed(void) const
{
	return true;            // Every Resource in SCBus has the transmit ts fix
}

void OtTimeSlotTransmitterDtiSC::loadTsInfo()
{
	// get ts from board
	long ts;
	SC_TSINFO tsinfo;
	
	tsinfo.sc_numts = 1;
	tsinfo.sc_tsarrayp = &ts;
	
	if(dt_getxmitslot(m_dti->getFd(),&tsinfo)<0)
		throw OtDialogicException(m_dti->getFd());
	
	// Alloc that timeslot from the bus
	m_TransmitTS = m_bus->allocTimeSlotById(ts);
	m_TransmitTS->setTransmitter(this);
}
#endif