diff -r 14460bf2a402 -r f50f4094acd7 cbsref/csyrefplugins/csy27010/src/PortFactory.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cbsref/csyrefplugins/csy27010/src/PortFactory.cpp	Tue Jul 06 15:36:38 2010 +0300
@@ -0,0 +1,982 @@
+//
+// * Copyright 2004 Neusoft America Inc.
+// * All rights reserved.
+// * This component and the accompanying materials are made available
+// * under the terms of the Eclipse Public License v1.0
+// * which accompanies this distribution, and is available
+// * at the URL "http://www.eclipse.org/legal/epl-v10.html".
+// *
+// * Contributors:
+// * Keith Collins (Neusoft America Inc.)  original software development and additional code and modifications.
+// * Thomas Gahagen (Neusoft America Inc.)  additional code and modifications.
+// * Zhen Yuan (Neusoft America Inc.)  additional code and modifications.
+// *
+// * Description:  This file contains the implementation for the class CPortFactory.
+// *               This class is used to create C32 port interface instances.
+//
+
+// PortFactory.cpp
+
+/** @file PortFactory.cpp
+ *
+ */
+
+/*! \mainpage CSY 27.010 Documentation
+ *
+ * \section intro Introduction
+ *
+ * This CSY has been designed and implemented by TapRoot Systems.
+ * This CSY is part of the TapRoot Systems Communications Platform (CommP)
+ * product family for Symbian OS. Please contact TapRoot Systems for 
+ * information on CommP.
+ * <p>
+ * A CSY is a specialized type of DLL that implements API interfaces
+ * required by the C32 Serial Communications Server. "CSY" is the file
+ * name extension used by CSY modules as in "ecuart.csy", which is the
+ * name of Symbian's generic CSY for non-multiplexed serial ports.  
+ * TapRoot Systems 27.010 CSY (gsm0701.csy) is compatible with the
+ * 3GPP 27.010 v5.0.0 specification.
+ * <p>
+ * The CSY has been designed and tested with the Intel Lubbock application
+ * processor, TI Condat baseband processor and Symbian OS 8.0a.
+ * The CSY is not guaranteed to work with other AP's, BP's or Symbian OS versions.
+ * The CSY has been integrated with Symbian OS supplied TSY and NIF IP.
+ * The CSY is not guaranteed to work with other TSY's and NIF's.
+ *
+ * \section feat Features
+ *
+ * The CSY supports the 27.010 Basic Option. The 3GPP 27.010 specification 
+ * is derived from the GSM 07.10 specification. 3GPP 27.010 defines a mechanism
+ * whereby multiple commands and data streams can be carried over the same
+ * physical link. This specification defines a multiplexing protocol between
+ * a Terminal Equipment (TE) and a Mobile Station (MS) allowing multiple 
+ * simultaneous sessions over a single start-stop, framed, serial link. 
+ * Each session (channel) can carry different types of data including voice,
+ * fax, data, SMS, CBS, phonebook maintenance, battery status, GPRS, USSD, etc.
+ * <p>
+ * The multiplexer has three operating options, basic, advanced without error
+ * recovery and advanced with error recovery. CSY 27.010 supports the
+ * basic option. The basic option is recommended on highly reliable links. 
+ * Advanced options are not supported by the CSY. The characteristics of the 
+ * basic option are:
+ * <li> Length indicator used instead of the HDLC transparency mechanism
+ * <li> Different flag octet from that used by HDLC
+ * <li> Cannot be used on links that use XON/XOFF flow control
+ * <li> May have longer recovery procedure from loss of synchronization
+ * <p>
+ * Each channel between the TE and MS is called a Data Link Connection (DLC).
+ * A special DLC called "control channel" is used to exchange management 
+ * information (e.g. parameter negotiation), power saving control information,
+ * testing, flow control, close down, etc. between the TE and MS.
+ * <p>
+ * The multiplexer is activated with the 3GPP 27.007 AT+CMUX command.
+ * <p>
+ * 
+ * \section install Installation
+ *
+ * Refer to the readme.txt file for installation and build instructions.
+ * <br>
+ * Please contact TapRoot Systems for information on product updates and
+ * additional support.
+ */
+
+/** @file PortFactory.cpp
+ * This file contains the implementation for the class CPortFactory.
+ * This class is used to create C32 port interface instances.
+ */
+
+#include <cs_port.h>
+#include <f32file.h>
+#include <commsdattypesv1_1.h>
+#include <commsdat_partner.h>
+using namespace CommsDat;
+#include "Portfactory.h"
+#include "CsyGlobals.h"
+#include "Mux0710Protocol.h"
+#include "ChannelMgrCtrl.h"
+#include "ChannelMgrCmdData.h"
+#include "PortC32InterfaceBase.h"
+#include "PortC32Interface.h"
+#include "PortC32InterfaceIp.h"
+#include "CommFrameWriterAo.h"
+#include "CommFrameReaderAo.h"
+#include "CsyDebugLogger.h"
+
+CPortFactory* CPortFactory::NewL()
+/**
+ * This method uses two phase construction and the cleanup stack to create
+ * an instance of class CPortFactory. This method is invoked when the user
+ * invokes the C32 comm server's LoadCommModule() method to load the CSY.
+ * Note that multiple instances of CPortFactory can be created by C32,
+ * so no memory allocation or objects should be created when the 
+ * port factory is first created.
+ *
+ * @return Pointer to the created instance of CPortFactory
+ */
+	{
+	_LOG_L4C1("CPortFactory::NewL");
+
+	CPortFactory* self = new(ELeave) CPortFactory;
+	TCleanupItem closeSelf(CPortFactory::CloseObject, self);
+	CleanupStack::PushL(closeSelf);
+	self->ConstructL();
+	CleanupStack::Pop(self);
+	return (self);
+	}
+
+CPortFactory::CPortFactory()
+: iPortC32InterfaceList(_FOFF(CPortC32Interface, iLink)),
+  iPortC32InterfaceIter(iPortC32InterfaceList),
+  iDataChannelList(_FOFF(CChannelMgrCmdData, iLink)),
+  iDataChannelIter(iDataChannelList)
+/**
+ * Constructor.
+ */
+	{
+	_LOG_L4C1("CPortFactory::CPortFactory");
+	}
+
+CPortFactory::~CPortFactory()
+/**
+ * Destructor. Delete all objects and memory created/allocated by this class.
+ */
+	{
+	_LOG_L4C1(">>CPortFactory::~CPortFactory");
+
+	// check if the CSY's objects have been created 
+	// C32 creates a new instance of the port factory each time a client
+	// loads the CSY. The C32 recognizes a redundant CSerial name and promptly
+	// destroys the redundant CSY.
+	if (iMuxObjectsCreated)
+		{
+		// client channels
+		CChannelMgrCmdData* anyChannel = NULL;
+		iDataChannelIter.SetToFirst();
+		while ((anyChannel = iDataChannelIter++) != NULL)
+			{
+			iDataChannelList.Remove(*anyChannel);
+			delete anyChannel;
+			}
+
+		// control channel
+		delete iChannelCtrl;
+
+		delete iCommWriterAo;
+		delete iCommReaderAo;
+
+		delete iMux0710Protocol;
+
+		// may not be necessary ???
+		// MAF /\ what does this comment mean
+
+		// delete any remaining C32 port objects that were not closed by the client
+		CPortC32InterfaceBase* port = NULL;
+		iPortC32InterfaceIter.SetToFirst();
+		while ((port = iPortC32InterfaceIter++) != NULL)
+			{
+			delete port;
+			}
+
+		iCommPort.Close();
+		}
+
+	//iMuxObjectsCreated = EFalse;
+
+	_LOG_L4C1("<<CPortFactory::~CPortFactory");
+	_LOG_L3C1(" ");
+	}
+
+void CPortFactory::ConstructL()
+/**
+ * 2nd-phase construction. Registers the CSY Name with C32.
+ */
+	{
+	_LOG_L4C1("CPortFactory::ConstructL");
+
+#ifdef _DEBUG
+	TInt usedCellCount;
+	TInt freeCellCount;
+	usedCellCount = User::CountAllocCells(freeCellCount);
+	_LOG_L4C3("Cell Counts Used = %d   Free = %d", usedCellCount, freeCellCount);
+#endif
+
+	// inform C32 of the CSY name
+	TName name(KCSY_Gsm0710ServerName);
+	TInt retVal1 = SetName(&name);
+	if (retVal1 != KErrNone)
+		{
+		_LOG_L1C3("** Failed to set CSY:%S in C32. Err: %d **", &name, retVal1);
+		User::Leave(retVal1);
+		}
+	iVersion = TVersion(KCSY_Gsm0710MinorVersionNumber,
+						KCSY_Gsm0710MajorVersionNumber,
+						KCSY_Gsm0710BuildVersionNumber);
+	}
+
+void CPortFactory::CreateCsyObjectsL()
+/**
+ * This method is called to create the CSY objects for the multiplexing channels,
+ * message queues, i/o interface, etc.  This method should be called when the
+ * 1st client request to create a port is received by the CSY via NewPortL().
+ */
+	{
+	_LOG_L4C1(">>CPortFactory::CreateCsyObjectsL");
+
+	// set flag
+	iMuxObjectsCreated = ETrue;
+	iOpenPortFailed = EFalse;
+
+	// load physical device drivers for serial port(s)
+
+#ifdef __WINS__
+	// 1st make sure the file server is running
+	RFs fileServer;
+	User::LeaveIfError(fileServer.Connect());
+	fileServer.Close();
+
+	_LIT(KPDDName, "ECDRV");
+	TInt retVal1 = User::LoadPhysicalDevice(KPDDName);
+	if ((retVal1 != KErrNone) && (retVal1 != KErrAlreadyExists))
+		User::Leave(retVal1);
+
+#else  // target
+
+	TBuf<20> commPddName;
+	TInt retVal1;
+
+	commPddName.Copy(KCsyDefaultPDDNameComm1);
+	retVal1 = User::LoadPhysicalDevice(commPddName);
+	if ((retVal1 != KErrNone) && (retVal1 != KErrAlreadyExists))
+		User::Leave(retVal1);
+	// only load 2nd PDD if debugging is enabled 
+
+#ifdef __DEBUGSERIALPORT__
+	commPddName.Copy(KCsyDefaultPDDNameComm2);
+	retVal1 = User::LoadPhysicalDevice(commPddName);
+	if ((retVal1 != KErrNone) && (retVal1 != KErrAlreadyExists))
+		User::Leave(retVal1);
+#endif //__DEBUGSERIALPORT__
+
+#endif  //__WINS__
+
+	// load logical device driver for serial ports
+	_LIT(KLDDName, "ECOMM");
+	retVal1 = User::LoadLogicalDevice(KLDDName);
+	if ((retVal1 != KErrNone) && (retVal1 != KErrAlreadyExists))
+		User::Leave(retVal1);
+
+	ConfigurePhysicalCommPortL();
+	
+	// create 27.010 framer and comm i/o objects
+	iMux0710Protocol = CMux0710Protocol::NewL(*this);
+	iCommWriterAo    = CCommFrameWriterAo::NewL(this, iMux0710Protocol);
+	iMux0710Protocol->SetCommWriter(iCommWriterAo);
+
+	iCommReaderAo    = CCommFrameReaderAo::NewL(this, iMux0710Protocol);
+	iCommReaderAo->Read();  // start it
+	
+	// create the Multiplexer Control Channel
+	iChannelCtrl = CChannelMgrCtrl::NewL(*this, *iMux0710Protocol);
+
+	// create All Multiplexer Channels	
+	for (TUint8 i=1; i < KCsyDefaultMaxDLCChannels; i++)
+		{
+		CChannelMgrCmdData* channelMgrCmd =
+			CChannelMgrCmdData::NewL(i, *this, *iMux0710Protocol);
+		iDataChannelList.AddLast(*channelMgrCmd);
+		}
+
+	// switch to multiplexer mode
+	iMux0710Protocol->SwitchToMuxMode();
+
+#ifdef _DEBUG
+	TInt usedCellCount;
+	TInt freeCellCount;
+	usedCellCount = User::CountAllocCells(freeCellCount);
+	_LOG_L4C3("Cell Counts Used = %d   Free = %d", usedCellCount, freeCellCount);
+#endif
+
+	_LOG_L4C1("<<CPortFactory::CreateCsyObjectsL");
+	}
+
+void CPortFactory::CloseObject(TAny* aObject)
+/**
+ * Utility to close objects created by the port factory. 
+ * Used during construction with the cleanup stack.
+ *
+ * @param aObject - The CObject to close.
+ * @return void
+ */
+	{
+	reinterpret_cast<CObject*>(aObject)->Close();
+	}
+
+CPort* CPortFactory::NewPortL(const TUint aUnit)
+/**
+ * This method is called by C32 when a port is opened via RComm::Open().
+ * An instance of the CSY's class CPortC32Interface is created.
+ * The instance is assigned a channel manager and then is added to
+ * the list of C32 port interface objects.
+ *
+ * @param aUnit - Numeric portion of the port identifier
+ * @return Pointer to the created C32 port interface object
+ */
+	{
+	_LOG_L4C2(">>CPortFactory::NewPortL [aUnit=%d]", aUnit);
+
+	TC32PortInfo portInfo;
+
+	portInfo.iClientType = GetClientType(aUnit);
+	portInfo.iPortNumber = aUnit;
+
+	// check if port number is valid and translates to a client type
+	if (portInfo.iClientType == EC32ClientUndefined)
+		{
+		_LOG_L4C1("<<CPortFactory::NewPortL - ** Unknown client **");
+		return NULL;
+		}
+
+	// check if this is the 1st port to be opened
+	if (!iMuxObjectsCreated)
+		{
+		_LOG_L4C1("first port to be opened");
+		CreateCsyObjectsL();
+		}
+	else if (iChannelCtrl->GetChannelReady() == EFalse)
+		{
+		_LOG_L4C1("CSY objects already exist");
+		// switch to multiplexer mode
+		iMux0710Protocol->SwitchToMuxMode();
+		}
+
+	// first make sure control channel is already connected
+	iChannelCtrl->WaitForChannelReady();
+	
+	if (! iOpenPortFailed)
+		{
+		// create a new C32 Interface Port based on port number
+		CPortC32InterfaceBase* port = NULL;
+	
+		if (portInfo.iClientType == EC32ClientIpNif)
+			{
+			_LOG_L4C1("Raw IP port");
+ 			port = CPortC32InterfaceIp::NewL(*this, portInfo);
+ 			}
+		else
+			{
+			_LOG_L4C1("Normal port");
+ 			port = CPortC32Interface::NewL(*this, portInfo);
+ 			}
+	
+		CleanupStack::PushL(port);
+		CChannelMgrCmdData* channel = FindChannelMgr(aUnit);
+
+		if (channel == NULL)
+			{
+			_LOG_L2C1("** channel is null, delete interface **");
+			CleanupStack::PopAndDestroy(port);
+			User::Leave(KErrNotFound);
+			}
+		TName name;
+		name.Format(_L("%d"), aUnit);
+		port->SetName(&name);
+
+		// channel->Open() will add this port to it's port list, and connect channel if needed
+		// Make sure that during channel init we do not tx/rx through channel
+		channel->Open(port);
+	
+		iNumOfOpenPorts++;
+		_LOG_L4C2("No. of ports = %d",iNumOfOpenPorts);
+ 		
+		port->SetMuxChannel(channel);
+
+		channel->WaitForChannelReady();
+
+		//Need to wait for the channel to be ready. How to wait for something without blocking whole thread?
+		// add it to list of ports
+		iPortC32InterfaceList.AddLast(*port);	
+		CleanupStack::Pop(port);
+
+#ifdef _DEBUG
+		TInt usedCellCount;
+		TInt freeCellCount;
+		usedCellCount = User::CountAllocCells(freeCellCount);
+		_LOG_L4C3("Cell Counts Used = %d   Free = %d", usedCellCount, freeCellCount);
+#endif
+
+		_LOG_L4C2("<<CPortFactory::NewPortL [port=%d]", port);
+		return port;
+		}
+	else //iPortOpenFailed == ETrue
+		{
+		_LOG_L4C1("<<CPortFactory::NewPortL [port=NULL]");
+		User::Leave(KErrTimedOut);
+		return NULL;
+		}
+	}
+ 
+void CPortFactory::Info(TSerialInfo& aSerialInfo)
+/**
+ * Called by C32 to identify the CSY module.
+ * @param aSerialInfo - Reference holder for information to be populated by the function.
+ * @return void
+ */
+	{
+	_LOG_L4C1("CPortFactory::Info");
+
+	aSerialInfo.iDescription	= KCSY_Description;
+	aSerialInfo.iName			= KCSY_Gsm0710ServerName;
+	aSerialInfo.iLowUnit		= KCSY_Gsm0710LowUnit;
+	aSerialInfo.iHighUnit		= KCSY_Gsm0710HighUnit;
+	}
+
+CPortFactory::TC32ClientType CPortFactory::GetClientType(TInt aC32PortNum)
+/**
+ * Returns the ClientType for the specified C32 port number.
+ * @param aC32PortNum -  C32 port number
+ * @return Client type - TSY or NIF
+ */
+	{ 
+	_LOG_L4C2("CPortFactory::GetClientType [aC32PortNum=%d]", aC32PortNum);
+
+	if (aC32PortNum >= KCOMMP_IP_NIF_OFFSET)
+		{
+		_LOG_L4C1("Raw Ip");
+		return CPortFactory::EC32ClientIpNif;
+		}
+	else if (aC32PortNum == KCOMMP_CSD_PPP_NUMBER)
+		{ 
+		_LOG_L4C1("Csd PPP");
+		return CPortFactory::EC32ClientNif;
+		}
+
+	_LOG_L4C1("Tsy");
+	return CPortFactory::EC32ClientTsy;
+	}
+
+CPortC32InterfaceBase* CPortFactory::FindPortC32Interface(const TUint8 aDlcNum)
+/**
+ * This method returns a pointer to the C32 port interface object 
+ * that is associated with the specified DLC number.
+ *
+ * @param aDlcNum - DLC number
+ * @return Pointer to C32 port interface object or NULL if not found
+ */
+	{
+	_LOG_L4C2(">>CPortFactory::FindPortC32Interface [aDlcNum=%d]", aDlcNum);
+
+	CPortC32InterfaceBase* port = NULL;
+
+	CChannelMgrCmdData* anyChannel = NULL;
+	iDataChannelIter.SetToFirst();
+	while ((anyChannel = iDataChannelIter++) != NULL)
+		{
+		if (anyChannel->GetDlcNumber() == aDlcNum)
+			{
+			_LOG_L4C1("AT channel");
+			port = anyChannel->GetC32Port();
+			break;
+			}
+		}
+	
+	_LOG_L4C2("<<CPortFactory::FindPortC32Interface [port=0x%x]",port);
+	return port;
+	}
+
+CChannelMgrCmdData* CPortFactory::FindChannelMgr(const TUint aC32PortNum)
+/**
+ * This method is only called when a port is created.
+ *
+ * @param aC32PortNum - C32 port number
+ * @return Pointer to the channel manager object or NULL
+ */
+	{
+	_LOG_L4C2(">>CPortFactory::FindChannelMgr [aC32PortNum=%d]", aC32PortNum);
+
+	TUint dlcNum = ++iLastDlcNum;
+	_LOG_L4C2("iLastDlcNum: %d", iLastDlcNum);
+
+	//
+	// MAF Horrible
+	// This just counts through the array of channel pointers
+	// and returns a pointer when the count gets to the correct value.
+	// 
+	// We should be able to use an array here and directly access it using
+	// the dlc number!?!?
+	//
+
+	TUint count  = 1;
+	CChannelMgrCmdData* anyChannelCmd;
+
+	iDataChannelIter.SetToFirst();
+	while ((anyChannelCmd = iDataChannelIter++) != NULL)
+		{
+		if (count == dlcNum)
+			{
+			_LOG_L4C2("<<CPortFactory::FindChannelMgr() - found, count %d",count);
+			return anyChannelCmd;
+			}
+		count++;
+		}
+
+	_LOG_L4C1("<<CPortFactory::FindChannelMgr() - *** NOT FOUND ***");
+	return NULL;
+	}
+
+CChannelMgrCmdData* CPortFactory::FindChannelMgrByDlcNum(const TUint8 aDlcNum)
+/**
+ * This method returns a pointer to the channel manager object 
+ * that has the specified  DLC number.
+ *
+ * @param aDlcNum -  DLC number
+ * @return Pointer to the channel manager object or NULL
+ */
+	{
+	_LOG_L4C2(">>CPortFactory::FindChannelMgrByDlcNum [aDlcNum=%d]", aDlcNum);
+
+    CChannelMgrCmdData* channel = NULL;
+	iDataChannelIter.SetToFirst();
+	while ((channel = iDataChannelIter++) != NULL)
+		{
+		if (channel->GetDlcNumber() == aDlcNum)
+			{
+			_LOG_L4C1("AT channel");
+			return channel;
+			}
+		}
+
+	_LOG_L2C1("<<CPortFactory::FindChannelMgrByDlcNum() - NOT FOUND");
+	return NULL;
+	}
+
+TInt CPortFactory::ConfigurePhysicalCommPortL()
+/**
+ * This method is used to configure the specified physical comm port.
+ * The parameters are read from CommDb or supplied by C32.
+ * @param aPhysPortNum - Physical port number
+ * @return KErrorNone or KErrAccessDenied.
+ */
+	{
+	_LOG_L4C1(">>CPortFactory::ConfigurePhysicalCommPortL");
+
+	// create a package pointer
+	TPckgBuf<TCommConfigV01> newCfg;
+	TInt ret, len;
+
+	// get the modem table	- Get port settings from CommDB.
+	CMDBSession* db = CMDBSession::NewL(KCDLatestVersion);
+
+	CleanupStack::PushL(db);
+
+	TUint32 modemId = 0;
+
+	// We are using the same modem as TSY
+	// Accessing the ModemPhoneServicesSMS field in the Global Settings Table
+	CMDBField<TUint32>* globalSettingsField = new(ELeave) CMDBField<TUint32>(KCDTIdModemPhoneServicesSMS);
+	CleanupStack::PushL(globalSettingsField);
+	globalSettingsField->SetRecordId(1);
+	globalSettingsField->LoadL(*db);
+	modemId = *globalSettingsField;	// The field value gives the record id in the Modem Bearer Table.
+	CleanupStack::PopAndDestroy(globalSettingsField);
+	
+	_LOG_L4C2("Accessing modem entry %d in the modem table", modemId);
+
+	TUint32 rate;
+	TUint32 dataBits;
+	TUint32 stopBits;
+	TUint32 parity;
+	TUint32 handshake;
+	TPckgBuf<TCommConfigV01> config;
+	
+	TUint port = 0;
+	TBuf<KCommsDbSvrMaxFieldLength> controlPort;
+	
+	// Accessing the ControlChannelPort Name from the ModemBearer Table in the record number 
+	//corresponding to modemId
+	CMDBField<TDesC>* portField = new(ELeave) CMDBField<TDesC>(KCDTIdControlChannelPortName);
+	CleanupStack::PushL(portField);
+	portField->SetRecordId(modemId);
+	portField->SetMaxLengthL(KMaxTextLength);
+	portField->LoadL(*db);
+	controlPort = *portField;
+	CleanupStack::PopAndDestroy(portField);
+	// Diagnostics - control port
+	if (controlPort.Length())
+		{
+		TBuf8<16> portName;
+		portName.Copy(controlPort.Left(16));
+		_LOG_L4C2("Control port(MODEM_CONTROL_CHANNEL_PORT_NAME) '%S'",
+			&portName);
+
+		// Get number of port out of the port descriptor.
+		_LIT(KDoubleColon, "::");
+		TInt len = controlPort.Find(KDoubleColon);
+		if (len < KErrNone)
+			{
+			_LOG_L1C1("** finding :: in control port failed **");
+			User::Leave(KErrGeneral);
+			}
+		TUint numPos = len + KDoubleColon.iTypeLength;
+		TPtrC numPtr(&controlPort[numPos], controlPort.Length() - numPos);
+		TLex lexer(numPtr);
+		TInt ret = lexer.Val(port);
+		if (ret)
+			{
+			_LOG_L1C1("** lexing to get port number failed **");
+			User::Leave(ret);
+			}
+		}
+	else
+		{
+		_LOG_L1C1("** Control port not set in commDb **");
+		User::Leave(KErrGeneral);
+		}
+	
+	// Accessing the Rate from the ModemBearer Table in the record number 
+	//corresponding to modemId
+	CMDBField<TUint32>* rateField = new(ELeave) CMDBField<TUint32>(KCDTIdRate);
+	CleanupStack::PushL(rateField);
+	rateField->SetRecordId(modemId);
+	rateField->LoadL(*db);
+	rate = *rateField;
+	CleanupStack::PopAndDestroy(rateField);
+	
+	// Accessing the DataBits from the ModemBearer Table in the record number 
+	//corresponding to modemId
+	CMDBField<TUint32>* dataBitsField = new(ELeave) CMDBField<TUint32>(KCDTIdDataBits);
+	CleanupStack::PushL(dataBitsField);
+	dataBitsField->SetRecordId(modemId);
+	dataBitsField->LoadL(*db);
+	dataBits = *dataBitsField;
+	CleanupStack::PopAndDestroy(dataBitsField);
+
+	// Accessing the StopBits from the ModemBearer Table in the record number 
+	//corresponding to modemId
+	CMDBField<TUint32>* stopBitsField = new(ELeave) CMDBField<TUint32>(KCDTIdStopBits);
+	CleanupStack::PushL(stopBitsField);
+	stopBitsField->SetRecordId(modemId);
+	stopBitsField->LoadL(*db);
+	stopBits = *stopBitsField;
+	CleanupStack::PopAndDestroy(stopBitsField);
+	
+	// Accessing the Parity from the ModemBearer Table in the record number 
+	//corresponding to modemId
+	CMDBField<TUint32>* parityField = new(ELeave) CMDBField<TUint32>(KCDTIdParity);
+	CleanupStack::PushL(parityField);
+	parityField->SetRecordId(modemId);
+	parityField->LoadL(*db);
+	parity = *parityField;
+	CleanupStack::PopAndDestroy(parityField);
+	
+	// Accessing the HandShake from the ModemBearer Table in the record number 
+	//corresponding to modemId
+	CMDBField<TUint32>* handshakeField = new(ELeave) CMDBField<TUint32>(KCDTIdHandshaking);
+	CleanupStack::PushL(handshakeField);
+	handshakeField->SetRecordId(modemId);
+	handshakeField->LoadL(*db);
+	handshake = *handshakeField;
+	CleanupStack::PopAndDestroy(handshakeField);
+
+	config().iRate		  = (TBps)rate;
+	config().iDataBits    = (TDataBits)dataBits;
+	config().iStopBits    = (TStopBits)stopBits;
+	config().iParity      = (TParity)parity;
+	config().iHandshake   = (TUint)handshake;
+	config().iParityError = KConfigParityErrorIgnore;
+	config().iFifo        = static_cast<TUint>(EFifoEnable);
+
+	newCfg.Copy(config);
+
+	ret = iCommPort.Open(port);
+	if (ret)
+		{
+		_LOG_L1C3("** Failed CommPort.Open(%d) ret=%d **", port,ret);
+		User::Leave(ret);
+		}
+
+	// Configure the port
+	len = iCommPort.ReceiveBufferLength();
+	
+	if (len < KErrNone)
+		{
+		_LOG_L1C2("** Leave: CommPort.ReceiveBufferLength() len=%d **", len);
+		User::Leave(KErrGeneral);
+		}
+
+	// Increase the receive buffer to make sure we can operate as slowly as we 
+	// can without filling up the LDD's receive buffer with incoming signals 
+	len *= KCSY_ReceiveBufferSizeIncreaseFactor; 
+	ret = iCommPort.SetReceiveBufferLength(len);
+
+	TCommConfig cbuf;
+	TCommConfigV01 &cfg = cbuf();
+	iCommPort.Config(cbuf);					// Get the Configuration Parameters
+
+	cfg.iRate        = newCfg().iRate;
+	cfg.iDataBits    = newCfg().iDataBits;
+	cfg.iStopBits    = newCfg().iStopBits;
+	cfg.iParity      = newCfg().iParity;
+	cfg.iHandshake   = newCfg().iHandshake;
+	cfg.iParityError = newCfg().iParityError;
+	cfg.iFifo        = newCfg().iFifo;
+
+	_LOG_L4C2("  Set Phys Port Config for Port %d", port);
+	_LOG_L4C2("    Rate = 0x%x", cfg.iRate);
+	_LOG_L4C2("    DataBits = 0x%x", cfg.iDataBits);
+	_LOG_L4C2("    Stop Bits = 0x%x", cfg.iStopBits);
+	_LOG_L4C2("    Parity = 0x%x", cfg.iParity);
+	_LOG_L4C2("    Handshake = 0x%x", cfg.iHandshake);
+	_LOG_L4C2("    Parity Error = 0x%x", cfg.iParityError);
+	_LOG_L4C2("    Fifo = 0x%x", cfg.iFifo);
+
+	ret = iCommPort.SetConfig(cbuf);		// Set the Configuration Parameters
+	if (ret)
+		{
+		_LOG_L1C2("** CommPort.SetConfig ret=%d **", ret);
+		User::Leave(KErrNotSupported);
+		}
+
+	// Clean up the stack
+	CleanupStack::PopAndDestroy(db);
+
+	_LOG_L4C2("<<CPortFactory::ConfigurePhysicalCommPortL [ret=%d]", ret);
+	return ret;
+	}
+
+void CPortFactory::ConnectControlChannel()
+/**
+ * This method is called to connect the 27.010 control channel,
+ * which is DLC 0.
+ */
+	{
+	_LOG_L4C1("CPortFactory::ConnectControlChannel");
+
+	TInt ret = 	iChannelCtrl->Connect();	
+	if (ret != KErrNone)
+		{
+		_LOG_L4C2(("<<CCPortFactory::ConnectControlChannel ret=%d"),ret);
+		}
+	}
+
+void CPortFactory::DisconnectControlChannel()
+/**
+ * This method is called to set the 27.010 control channel to the "disconnect" state.
+ */
+	{
+	_LOG_L4C1("CPortFactory::DisconnectAllChannels");
+	iChannelCtrl->Disconnect();
+	}
+
+void CPortFactory::ChannelCtrlDoCancel()
+/**
+ * This method is called when the port has been opened and the max number of retries has been reached.
+ */
+	{
+	_LOG_L4C1(">>CPortFactory::ChannelCtrlDoCancel");
+	
+	iOpenPortFailed = ETrue;
+	iChannelCtrl->NotifyChannelReady();
+
+	_LOG_L4C1("<<CPortFactory::ChannelCtrlDoCancel");
+	}
+	
+
+void CPortFactory::RemoveC32Port(CPortC32InterfaceBase* aPort)
+/**
+ * This method removes the specified C32 port object from the
+ * port factory's list of current/open C32 port objects.
+ * This will allow another client to open that port.
+ * @param aPort - Pointer to C32 port object
+ * @return void
+ */
+	{
+	_LOG_L4C2(">>CPortFactory::RemoveC32Port [aPort=%d]", aPort->GetPortNumber());
+
+	CPortC32InterfaceBase* port = NULL;
+	iPortC32InterfaceIter.SetToFirst();
+	while ((port = iPortC32InterfaceIter++) != NULL)
+		{
+		if (port == aPort)
+			{
+			iPortC32InterfaceList.Remove(*port);
+			_LOG_L4C1("<<CPortFactory::RemoveC32Port - okay");
+			return;
+			}
+		}
+
+	// MAF this is a bad condition
+	_LOG_L4C1("<<CPortFactory::RemoveC32Port ** Not Removed? **");
+	}
+
+void CPortFactory::ConnectIpNifPort(const TUint8 aDlcNum)
+/**
+ * This method connects the port interface object
+ * in the CSY that are used for a data interface to a NIF.
+ * @param void
+ */
+	{
+	_LOG_L4C2("CPortFactory::ConnectIpNifPort [aDlcNum=%d]",aDlcNum);
+
+	CPortC32InterfaceBase* port = FindPortC32Interface(aDlcNum);
+
+	if (port)
+		{
+		CChannelMgrCmdData* iMuxChannel = port->GetMuxChannel();
+		if (iMuxChannel)
+			{
+			
+			TInt err = iMuxChannel->Connect();
+			if (err != KErrNone)
+				{
+				_LOG_L1C2("iMuxChannel->Connect() error =%d",err);
+				}
+			}
+		else
+			{
+			// MAF assert here
+			_LOG_L1C2("** Could not find channel for port [0x%x] **",port);
+			}
+		}
+	else
+		{
+		// MAF assert here
+		_LOG_L1C1("** Could not find port for dlcnumber **");
+		}
+	}
+
+TBool CPortFactory::FindDlcToEnable()
+/**
+ * We have resources again. Find a dlc that has had its flow control
+ * set and re-enable.
+ *
+ * @return ETrue if there are still dlcs that are stopped due to flow control.
+ */
+	{
+	_LOG_L4C1(">>CPortFactory::FindDlcToEnable");
+
+	TInt numberOfStopped = 0;
+	TBool dlcsStillToEnable = EFalse;
+
+    CChannelMgrCmdData* channel = NULL;
+
+	iDataChannelIter.SetToFirst();
+	while ((channel = iDataChannelIter++) != NULL)
+		{
+		if (channel->CsyToModemFlowControl() == EFlowControlOn)
+			{
+			numberOfStopped++;
+			if (numberOfStopped == 1)
+				{
+				_LOG_L4C1("Found a dlc to re-enable");
+				if (channel->SetCsyToModemFlowControl(EFlowControlOff))
+					{
+					_LOG_L4C1("Re-enable failed");
+					dlcsStillToEnable = ETrue;
+					break;
+					}
+				}
+			else
+				{
+				_LOG_L4C1("Other dlc still to re-enable");
+				dlcsStillToEnable = ETrue;
+				}
+			}
+		}
+
+	_LOG_L4C2("<<CPortFactory::FindDlcToEnable numberOfStopped=%d",numberOfStopped);
+	return dlcsStillToEnable;
+	}
+
+void CPortFactory::FindActiveDataDlcToStop()
+/**
+ * MAF come up with a better algorithm. Currently this scans sequentially for a data
+ * DLC to stop.
+ * Check the data dlcs to see if one of them can be stopped
+ */
+	{
+	_LOG_L4C1(">>CPortFactory::FindActiveDataDlcToStop");
+
+    CChannelMgrCmdData* channel = NULL;
+	CPortC32InterfaceBase* port = NULL;
+
+	iDataChannelIter.SetToFirst();
+	while ((channel = iDataChannelIter++) != NULL)
+		{
+		port = channel->GetC32Port();
+		if ((port)&&(port->GetClientType() == EC32ClientIpNif))
+			{
+			if (channel->CsyToModemFlowControl() == EFlowControlOff)
+				{
+				_LOG_L4C1("Found a data dlc to stop");
+				if (channel->SetCsyToModemFlowControl(EFlowControlOn))
+					{
+					_LOG_L4C1("Failed to stop dlc");
+					}
+				else
+					break;
+				}
+			}
+		}
+
+	_LOG_L4C1("<<CPortFactory::FindActiveDataDlcToStop");
+	}
+
+void CPortFactory::StopAnyDlc()
+/**
+ * Time for drastic action - enforce flow control on any DLC (except ctrl).
+ */
+	{
+	_LOG_L4C1(">>CPortFactory::StopAnyDlc");
+
+    CChannelMgrCmdData* channel = NULL;
+
+	iDataChannelIter.SetToFirst();
+	while ((channel = iDataChannelIter++) != NULL)
+		{
+		if (channel->CsyToModemFlowControl() == EFlowControlOff)
+			{
+			_LOG_L4C1("Found a dlc to stop");
+			if (channel->SetCsyToModemFlowControl(EFlowControlOn))
+				{
+				_LOG_L4C1("Failed to stop dlc");
+				}
+			else
+				break;
+			}
+		}
+
+	_LOG_L4C1("<<CPortFactory::StopAnyDlc");
+	}
+
+TBool CPortFactory::DecrementNumOfOpenPorts()
+/**
+ * Used to decrement the number of open ports and disconnect if number = 0
+ *
+ * aReturn returns EFalse if Num of Ports is 0; ETrue otherwise
+ */
+{
+	if (iNumOfOpenPorts==0)
+		return EFalse;
+	else if (--iNumOfOpenPorts == 0)
+		{
+		_LOG_L4C1("******* DISCONNECT ALL *********");
+		DisconnectControlChannel();
+		iLastDlcNum = 0;
+		return EFalse;
+		}	
+	return ETrue;
+}
+
+
+TSecurityPolicy CPortFactory::PortPlatSecCapability(TUint /*aPort*/) const
+/**
+ * This method returns the capabilities required to open the given port number
+ * This 27.010 CSY requires the same capabilities for all port numbers
+ *
+ * @param aPort - The port number to check against
+ * @return TSecurityPolicy - containing the required capabilities to use this CSY
+ */
+{
+	return TSecurityPolicy(ECapabilityNetworkServices, ECapabilityNetworkControl, ECapabilityReadUserData, ECapabilityWriteUserData);
+}
+