//

// * 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:  The CChannelMgrBase class defines a single 3GPP 27.010 based logical channel

// *               called DLC. This base class is inherited by derived control and data channel

// *               classes which add specific channel type behavior.

//

// ChannelMgrBase.cpp

/** @file ChannelMgrBase.cpp

 *

 */

#include "ChannelMgrBase.h"

#include "CsyMsgBufBpFrame.h"

#include "PortC32Interface.h"

#include "Mux0710Protocol.h"

#include "CsyDebugLogger.h"

#include "CommFrameWriterAo.h"

CChannelMgrBase::CChannelMgrBase(const TUint8 aDlcNum,

								 CPortFactory& aPortFactory,

								 CMux0710Protocol& aMux0710Protocol)

: iV24Signals(0x0D),

  iDlcNum(aDlcNum),

#ifndef __CSY_PROTOTYPE__

  iChannelState(ECsyChannelStateDisconnected),

#else

  iChannelState(ECsyChannelStateConnected),

#endif

  iPortFactory(aPortFactory),

  iPortC32Interface(NULL),

#ifndef __CSY_PROTOTYPE__

  iMux0710Protocol(aMux0710Protocol),

#else

  iMux0710Protocol(aMux0710Protocol),

  iChannelReady(ETrue),

  iInitFinished(ETrue),

#endif

  iModemAllowedToSendFrames(EFlowControlOff)

/**

 * Constructor.

 * @param aDlcNum - DLC number for the channel

 * @param aPortFactory - Reference to port factory

 * @param aMux0710Protocol - Reference to the Mux 27.010 object

 */

 	{

	}

CChannelMgrBase::~CChannelMgrBase()

/**

 * Destructor. Delete all resources and memory allocated by this object.

 */

	{

	_LOG_L4C1("CChannelMgrBase::~CChannelMgrBase");

	delete iChannelObserverAo;

	delete iTimeouter;

	}

void CChannelMgrBase::ConstructL()

/**

 * Create any instances and allocate any memory used by this object.

 */

 	{

	_LOG_L4C1("CChannelMgrBase::ConstructL");

	iChannelObserverAo = CChannelObserverAo::NewL();

	CActiveScheduler::Add(iChannelObserverAo); 

	iTimeouter = CActiveTimeouter::NewL(*this);

	iTimeoutVal = KOneSecond;

	iTxCountLimit = 10;

	}

TDes8& CChannelMgrBase::RefToMsgBuffer()

/**

 * This method returns a pointer to the message buffer to use

 * to format a message to send to the baseband.

 *

 * @return pointer

 */

	{

	// only one buffer is available for messages to the baseband

	return iDataToSendToModem;

	}

void CChannelMgrBase::ProcessRecvFrame(CCsyMsgBufBpFrame* aBpFrame)

/**

 * This method is called to process a frame that was received

 *

 * @param aBpFrame - Pointer to the frame buffer

 */

	{

	if (aBpFrame->GetFrameType() != KCsy0710CTLUIH)

		ProcessNonUihRecvFrame(aBpFrame);

	else

		ProcessRecvUihFrame(aBpFrame);

	}

TInt CChannelMgrBase::PlaceOnOutboundQueue()

/**

 * This method is called to process the "to baseband Message Q" event

 * for the channel. This event indicates that there is a message

 * that needs to be sent to the baseband.

 */

	{

	_LOG_L4C2(">>CChannelMgrBase::PlaceOnOutboundQueue [iDlcNum=%d]",iDlcNum);

	TInt ret = KErrNone;

	if (iCsyAllowedToSendFrames == EFlowControlOn)

		{

		_LOG_L4C1("Csy -> modem flow control = ON");

		iDelayedWriteToModem = ETrue;

		// We cannot fragment and place it on the write queue yet since

		// flow control in the direction of Csy to modem is set to ON.

		_LOG_L4C1("<<CChannelMgrBase::PlaceOnOutboundQueue - write delayed");

		return KErrNone;	

		}

	if (iChannelState != ECsyChannelStateConnected)

		{

		// this should not happen (should be caught by flow control above)

		// MAF __ASSERT_DEBUG(EFalse,PANIC(KPanicIllegalState));

		_LOG_L4C1("<<CChannelMgrBase::PlaceOnOutboundQueue - write ignored");

		return KErrNone;	

		}

	ret = iMux0710Protocol.Create0710DataFrames(iDataToSendToModem, iDlcNum);

	_LOG_L4C2("<<CChannelMgrBase::PlaceOnOutboundQueue [ret=%d]",ret);

	return ret;

	}

void CChannelMgrBase::WriteCancel()

/**

 * The client has requested the write by this DLC be cancelled.

 */

	{

	_LOG_L4C1(">>CChannelMgrBase::WriteCancel");

	if (iDelayedWriteToModem)

		{

		_LOG_L4C1("Delayed write has been cancelled");

		iDelayedWriteToModem = EFalse;

		}

	_LOG_L4C1("Remove any frames on write queue");

	// remove any frames (if any exist) from the writer Ao and

	// place them on the free queue

	CCommFrameWriterAo* writer = iPortFactory.GetCommWriterAo();

	writer->RemoveAnyDlcFramesOnWriteList(iDlcNum, EFalse);

	writer->RemoveAnyDlcFramesFromWaitList(iDlcNum, EFalse);

	_LOG_L4C1("<<CChannelMgrBase::WriteCancel");

	}

TInt CChannelMgrBase::Connect()

/**

 * Request to connect the channel. If the channel state is not "Connected"

 * then issue a SABM frame and change the channel state to "Connecting".

 *

 * @return KErrNone or KErrGeneral

 */

    {

    _LOG_L4C3(">>CChannelMgrBase::Connect [iDlcNum=%d,iChannelState=%d]",

		iDlcNum,iChannelState);

	TInt ret = KErrNone;

	if (iChannelState != ECsyChannelStateConnected)

		{

		_LOG_L4C1("Dlc is not currently connected");

		ret = iMux0710Protocol.Create0710ControlFrame(CMux0710Protocol::ESABM, iDlcNum);

		if (ret == KErrNone)

			{

			iChannelState = ECsyChannelStateConnecting;

			iInitFinished = EFalse;

			iTimeouter->Stop();

			iTimeouter->Start(iTimeoutVal);

			iTxCount = iTxCountLimit;

			}

		else

			{

			_LOG_L1C1("** Cannot send SABM **");

			}

		}

	else

		{

		_LOG_L2C1("** Ignored Connect **");

		ret = KErrGeneral;

		}

    _LOG_L4C2("<<CChannelMgrBase::Connect [ret=%d]",ret);

	return ret;

	}

TInt CChannelMgrBase::ParameterNegotiate()

/**

 * Request to parameter negotiation for the channel. If the channel state is not 

 * "Connected" then issue a UIH frame and with the parameter negotiation.

 *

 * @return KErrNone or KErrGeneral

 */

    {

    _LOG_L4C3(">>CChannelMgrBase::ParameterNegotiate [iDlcNum=%d,iChannelState=%d]",

		iDlcNum,iChannelState);

	TInt ret = KErrNone;

	if (iChannelState != ECsyChannelStateConnected) 

		{

		_LOG_L4C1("Dlc is not currently connected");

		if (iMux0710Protocol.Create0710ControlFrame(CMux0710Protocol::EUIH, iDlcNum) == KErrNone)

			{

			iChannelState = ECsyChannelStateParameterNegotiating;

			iTimeouter->Stop();

			iTimeouter->Start(iTimeoutVal);

			iTxCount = iTxCountLimit;

			}

		else

			{

			_LOG_L1C1("** Cannot send EUIH Param Neg. **");

			ret = KErrGeneral;

			}

		}

	else

		{

		_LOG_L2C1("** Ignored ParameterNegotiate **");

		}

    _LOG_L4C2("<<CChannelMgrBase::ParameterNegotiate [ret=%d]",ret);

	return ret;

	}

TInt CChannelMgrBase::Disconnect()

/**

 * Request to disconnect the channel. If the channel is not "Disconnected"

 * then issue a DISC frame and change the channel state to "Disconnecting".

 *

 * @return KErrNone or error code

 */

    {

    _LOG_L4C3(">>CChannelMgrBase::Disconnect [iDlcNum=%d,iChannelState=%d]",

		iDlcNum,iChannelState);

	TInt ret = KErrNone;

	if (iChannelState == ECsyChannelStateConnected)

		{

		_LOG_L4C1("Dlc is currently connected");

		if (iMux0710Protocol.Create0710ControlFrame(CMux0710Protocol::EDISC, iDlcNum) == KErrNone)

			{

			iChannelState = ECsyChannelStateDisconnecting;

			_LOG_L1C2("** Setting Channel Ready to False for DLC %d **",iDlcNum);

			iChannelReady = EFalse;

			iTimeouter->Stop();

			// Allow time for the channel to disconnect...

			User::After(1);

			}

		else

			{

			_LOG_L1C1("** Cannot send EDISC **");

			ret = KErrGeneral;

			}

		}

	else if (iChannelState == ECsyChannelStateTransmitError)

		{

		_LOG_L2C1("** Disconnect request for channel with transmit error **");

		ret = KErrNone;

		}

	else

		{

		_LOG_L2C1("** Ignored disconnect **");

		ret = KErrGeneral;

		}

    _LOG_L4C2("<<CChannelMgrBase::Disconnect [ret=%d]",ret);

	return ret;

	}

void CChannelMgrBase::ProcessNonUihRecvFrame(CCsyMsgBufBpFrame* aBpFrame)

/**

 * This method is called to process a Non-UIH frame which the channel

 * has received from the baseband for the channel.

 *

 * @param aBpFrame - Pointer to the received Non-UIH frame

 */

	{

	_LOG_L4C2(">>CChannelMgrBase::ProcessNonUihRecvFrame [iDlcNum=%d]", iDlcNum);

	TUint8 frameType = aBpFrame->GetFrameType();

	iMux0710Protocol.AddFrameFreeQ(aBpFrame);

	switch (frameType)

		{

	case KCsy0710CTLSABM:

		_LOG_L4C1("SABM");

		// MAF we should respond to this

		break;

	case KCsy0710CTLUA:

		{

		_LOG_L4C1("UA");

		iTimeouter->Stop();

		if (iChannelState == ECsyChannelStateConnecting)

			{

			_LOG_L4C1("SABM received by remote end - send MSC command");

			if (SendMscCommand(iV24Signals) == KErrNone)

				iChannelState = ECsyChannelStateMSCsent;

			}

		else if (iChannelState == ECsyChannelStateDisconnecting)

			{

			_LOG_L4C2("Channel disconnected %d", iDlcNum);

			iChannelState = ECsyChannelStateDisconnected;

			if (iPortFactory.DecrementNumOfOpenPorts())

				{

				NotifyChannelReady();

				}

			}

		}

		break;

	case KCsy0710CTLDM:    // 0x0F

		_LOG_L4C1("DM");

		break;

	case KCsy0710CTLDISC:  // 0x43

		_LOG_L4C1("DISC");

		// MAF we should respond to this

		break;

	case KCsy0710CTLUIH:

	case KCsy0710CTLUI:

		// MAF __ASSERT_DEBUG(EFalse,PANIC(KPanicIllegalState)); here

		break;

	default:

		_LOG_L1C2("** Unknown FrameType = 0x%02x **", frameType);

		break;

		}

	_LOG_L4C1("<<CChannelMgrBase::ProcessNonUihRecvFrame");

	}

TInt CChannelMgrBase::SendMscCommand(TUint8 aV24Signals)

/**

 * Sends an MSC command

 *

 * @param aV24Signals

 * @return error if failed to send

 */

	{

	_LOG_L4C2(">>CChannelMgrBase::SendMscCommand [aV24Signals=0x%02x]",

		aV24Signals);

	if (iMscReplyExpected)

		{

		_LOG_L4C1("<<CChannelMgrBase::SendMscCommand - already doing MSC");

		return KErrNotReady;

		}

	// Keep the signals in case of resend

	iV24Signals = aV24Signals;

	TInt ret = iMux0710Protocol.Create0710ControlFrame(

		CMux0710Protocol::EUIH, iDlcNum, CMux0710Protocol::EMSC, iV24Signals);

	if (ret != KErrNone)

		{

		_LOG_L1C1("** Could not send MSC command **");

		}

	else

		{

		iTimeouter->Stop();

		iTimeouter->Start(iTimeoutVal);

		iTxCount = iTxCountLimit;

		iMscReplyExpected = ETrue;

		}

	_LOG_L4C2("<<CChannelMgrBase::SendMscCommand [ret=%d]",ret);

	return ret;

	}

void CChannelMgrBase::MscReceived(TUint8 aV24Signals)

/**

 * Processes a received MSC command

 *

 * @param aV24Signals

 */

	{

	_LOG_L4C2(">>CChannelMgrBase::MscReceived [aV24Signals=0x%x]",

		aV24Signals);

	if (!iMscReplyExpected)

		{

		_LOG_L2C1("*** Not expecting MscReceived? ***");

		return;

		}

	iMscReplyExpected = EFalse;

	iTimeouter->Stop();

	if (iChannelState == ECsyChannelStateMSCsent)

		{

		_LOG_L4C1("MSC cmd part of start up sequence");

		iChannelState = ECsyChannelStateWaitingForChannelReady;

		//different type of channel may need different init process.

		if (iPortC32Interface)

			{

#ifdef _27010ADVANCEOPTION

			if (iPortC32Interface->GetClientType() == CPortFactory::EC32ClientIpNif)

				{

				_LOG_L4C1(" IpNif Channel Initialized");

				// Don't need to wait for AT command interpreter ready since not AT

				iChannelState = ECsyChannelStateConnected;

				NotifyChannelReady();

				ModemAndCsyToClientFlowCtrl(EFlowControlOff);

				}

#endif

			}

		else

			{

			// Command channel

			iChannelState = ECsyChannelStateConnected;

			NotifyChannelReady();

			}

		}

	if ((iDlcNum)&&(iV24Signals != aV24Signals))

		{

		_LOG_L4C3("Data Dlc - Response different to sent [%x != %x]",

			iV24Signals, aV24Signals);

		ReceivedV24Signals(aV24Signals);

		}

	_LOG_L4C1("<<CChannelMgrBase::MscReceived");

	}

void CChannelMgrBase::ModemAndCsyToClientFlowCtrl(const TFlowControl aFlowControl)

/**

 * Set the channel's flow control to the specified value.

 * Update the associate port object's flow control if the port object 

 * exists.

 *

 * @param aFlowControl - New flow control state

 */

 	{

	_LOG_L4C3(">>CChannelMgrBase::ModemAndCsyToClientFlowCtrl [aFlowControl=%d,iDlcNum=%d]", 

		aFlowControl,iDlcNum);

	iCsyAllowedToSendFrames = aFlowControl;

	if ((aFlowControl == EFlowControlOff)&&(iDelayedWriteToModem))

		{

		_LOG_L4C1("Flow control now OFF - delayed frame to send");

		TInt ret = iMux0710Protocol.Create0710DataFrames(iDataToSendToModem, iDlcNum);

		if (ret)

			{

			_LOG_L1C2("** Fragmentation failed [ret=%d] **",ret);

			}

		else

			{

			_LOG_L4C1("Delayed write placed on write queue");

			iDelayedWriteToModem = EFalse;

			}

		}

	CPortC32InterfaceBase* port = GetC32Port();

	if (port)

		port->ModemAndCsyToClientFlowCtrl(aFlowControl);

	else

		{

		_LOG_L2C1("** GetC32Port() returned NULL **");

		}

	_LOG_L4C1("<<CChannelMgrBase::ModemAndCsyToClientFlowCtrl");

	}

void CChannelMgrBase::ReceivedV24Signals(const TUint8 aV24Signals)

/**

 * Set the channel's signals to the specified value.

 * Update the associate port object's flow control if the port object 

 * exists.

 *

 * @param aSignals - new signal state

 */

 	{

	_LOG_L4C3(">>CChannelMgrBase::ReceivedV24Signals [aV24Signals=0x%x,iDlcNum=%d]", 

		aV24Signals,iDlcNum);

	CPortC32InterfaceBase* port = GetC32Port();

	if (port)

		{

		// Flow control

		TFlowControl flowControl = EFlowControlOff;

		// FC (bit 2)

		if (aV24Signals & 0x02)

			{

			_LOG_L4C2("FC=1 - modem dlc %d unable to accept frames",iDlcNum);

			flowControl = EFlowControlOn;

			_LOG_L4C1("flowControl On  (i.e stop flow)");

			// move frames for this dlc from write list to wait list

			iPortFactory.GetCommWriterAo()->RemoveAnyDlcFramesOnWriteList(iDlcNum);

			}

		else

			{

			// move any frames for this dlc from wait to write list

			iPortFactory.GetCommWriterAo()->RemoveAnyDlcFramesFromWaitList(iDlcNum);