// Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// 

//

/**

 @file

*/

#include <nifman.h>

#include <nifvar.h>

#include <nifutl.h>

#include <es_mbuf.h>

#include "PKTDRV.H"

#include "ETHINTER.H"

#include "Cardctl.h"

#ifdef __DebugCardLo__

// TCP packet tracing debug

const TUint8 ETHER2_TYPE_IP_MSB = 0x08;

const TUint8 ETHER2_TYPE_IP_LSB = 0x00;

const TUint8 IP_TYPE_TCP        = 0x06;

static inline TBool IsTcp(TDesC8 &aFrame)

{

	return (aFrame[12] == ETHER2_TYPE_IP_MSB && aFrame[13] == ETHER2_TYPE_IP_LSB && aFrame[23] == IP_TYPE_TCP);

}

static TInt GetTcpSeqNumber(TDesC8 &aFrame)

	{

	TInt seqNum = 0;

	if (IsTcp(aFrame))

		seqNum = aFrame[38] << 24 | aFrame[39] << 16 | aFrame[40] << 8| aFrame[41];

	return seqNum;

	}

static TInt GetTcpAckNumber(TDesC8 &aFrame)

	{

	TInt ackNum = 0;

	if (IsTcp(aFrame))

		ackNum = aFrame[42] << 24 | aFrame[43] << 16 | aFrame[44] << 8| aFrame[45];

	return ackNum;

	}

#endif

/**

Send active object class

When CIOBuffer's are passed to SendL() the class takes ownership and is

therefore resposible for freeing them in the RunL()

@internalComponent

*/

const TInt KTxQueueThreshold = 40;

/**

Constructor.

*/

CPcCardSender::CPcCardSender() : CActive(EPriorityStandard)

{

}

/**

Destructor.

Could be buffers on the transmit queue, free them as this class should be sole owner.

*/

CPcCardSender::~CPcCardSender()

{

	EmptyQueue();

	Cancel();

}

/**

Standard CActive construction.

@param aParent Pointer to the parent CPcCardControlEngine class.

@return A pointer to CPcCardSender object.

*/

CPcCardSender* CPcCardSender::NewL(CPcCardControlEngine* aParent)

{

	CPcCardSender *sd=new (ELeave) CPcCardSender;

	CleanupStack::PushL(sd);

	sd->InitL(aParent);

	CActiveScheduler::Add(sd);

	CleanupStack::Pop();

	return sd;

}

/**

Add the newly created object to an object container.

@param aParent Pointer to the parent CPcCardControlEngine class.

*/

void CPcCardSender::InitL(CPcCardControlEngine* aParent)

{

	iParent=aParent;

	iTxQueue.SetOffset(CIOBuffer::LinkOffset());

	iQueueLength = 0;

	iStopSending = EFalse;

}

/** 

Protocol inspects return

It blocks sending if it receives a return <= 0

This value should be propogated up through the stack

@internalComponent

*/

const TInt KStopSending		= 0;

/**

Protocol inspects return to indicate Keep sending the data.

@internalComponent

*/

const TInt KContinueSending	= 1;

/**

Writes the data to buffer.

@param aBuffer The data to be send.

@return 0 Tells the higher layer to stop sending the data.

		1 Tells higher layer that it can continue sending more data.

*/

TInt CPcCardSender::Send(CIOBuffer *aBuffer)

{

	// Check to see if we need to start transmission

	// Pseudo interrupt queue

	TBool startTx = iTxQueue.IsEmpty();

	iTxQueue.AddLast(*aBuffer);

	iQueueLength++;

	if(startTx)

		{

		// Transmitter was idle start next transmit

		iParent->iCard.Write(iStatus,aBuffer->Ptr());

		SetActive();

		}

	else

	{

	}	

	// The stack could saturate us with data

	// Tell the stack to send no more

	// We will unblock the stack when the queue size drops below

	// the the threshold

	if(iQueueLength >= KTxQueueThreshold)

		{

		iStopSending = ETrue;

		return KStopSending;

		}

	else

		{

		return KContinueSending;

		}

}

/**

Free all queued buffers. Should be safe as this class owns them

*/

void CPcCardSender::EmptyQueue()

{

	while(!iTxQueue.IsEmpty())

		{

		CIOBuffer* buf = iTxQueue.First();

		iTxQueue.Remove(*buf);

		delete buf;

		}

	iQueueLength = 0;

	iStopSending = EFalse;

}

/**

Write completion from the LDD. Pseudo transmit interrupt handler

*/

void CPcCardSender::RunL()

{

	// Check for error, all we can do is free the buffers

	if(iStatus.Int()!=KErrNone)

		{

		EmptyQueue();

		return;

		}

	if(!iTxQueue.IsEmpty())

		{

		// Head of the queue has been transmitted

		// Remove it and free it

		CIOBuffer* buf = iTxQueue.First();

		iTxQueue.Remove(*buf);

		iQueueLength--;

		delete buf;

		// Check to see if there are still buffers queued.

		// Start next transmit if there are

		TBool startTx;

		(iTxQueue.IsEmpty()) ? (startTx = EFalse) : (startTx = ETrue);

		if(startTx)

			{

			buf = iTxQueue.First();

			iParent->iCard.Write(iStatus,buf->Ptr());

			SetActive();

			}

		else

		{

		}

		// Resume sending if the protocol was previously blocked

		if(iStopSending && iQueueLength < KTxQueueThreshold)

			{

			iStopSending = EFalse;

			iParent->ResumeSending();

			}

		}

}

/**

cancellation of an outstanding request.

*/

void CPcCardSender::DoCancel()

{

	iParent->iCard.WriteCancel();

}

/**

Read active object class.

Read kept permanently on the LDD

Read completion is notified immediately up through the stack

with the one receive buffer therefore no Q.

*/

CPcCardReceiver::CPcCardReceiver() : CActive(EPriorityMore)  , iRecvBufPtr(NULL,0) 

{

}

/**

Constructor.

*/

CPcCardReceiver::~CPcCardReceiver()

{

	Cancel();

	// One buffer only

	delete iRecvBuffer;

}

/**

Standard CActive construction.

@param aParent Pointer to the parent CPcCardControlEngine class.

@return A pointer to CPcCardReceiver object.

*/

CPcCardReceiver* CPcCardReceiver::NewL(CPcCardControlEngine* aParent)

{

	CPcCardReceiver *rv=new (ELeave) CPcCardReceiver;

	CleanupStack::PushL(rv);

	rv->InitL(aParent);

	CActiveScheduler::Add(rv);

	CleanupStack::Pop();

	return rv;

}

/**

Allocate the one and only read buffer.

@param aParent Pointer to the parent CPcCardControlEngine class.

*/

void CPcCardReceiver::InitL(CPcCardControlEngine* aParent)

{

	iParent=aParent;

	iRecvBufLength=KEtherBufSize;

	iRecvBuffer=HBufC8::NewMaxL(iRecvBufLength);

	TPtr8 temp=iRecvBuffer->Des();

	iRecvBufPtr.Set(temp);

}

/**

Pass the receive buffer to the Card.

*/

void CPcCardReceiver::QueueRead()

{

	iRecvBufPtr.SetMax();

	iParent->iCard.Read(iStatus,iRecvBufPtr);

	SetActive();

}

/**

Pseudo read interrupt handler.

*/

void CPcCardReceiver::RunL()

{

	if (iParent->CardOpen())

		{

		if (iStatus.Int()!=KErrNone)

			{

			QueueRead();

			return;

			}

		// Pass the buffer up the stack

		// and queue the next read, safe to reuse the buffer.

		if(iRecvBufPtr.Length())

			{

			iParent->ProcessReceivedPacket(iRecvBufPtr);

			}

		QueueRead();

		}

	else

	{

	}

}

/**

Cancellation of an outstanding request.

*/

void CPcCardReceiver::DoCancel()

{

	iParent->iCard.ReadCancel();

}

/**

Constructor.

*/

CPcCardEventHandler::CPcCardEventHandler() : CActive(EPriorityStandard) 

{

}

/**

Destructor.

*/

CPcCardEventHandler::~CPcCardEventHandler()

{

	Cancel();

}

/**

Allocate the one and only read buffer.

@param aParent Pointer to the parent CPcCardControlEngine class.

*/

void CPcCardEventHandler::InitL(CPcCardControlEngine* aParent)

{

	iParent = aParent;

}

/**

Standard CActive construction

@param aParent Pointer to the parent CPcCardControlEngine class.

@return A pointer to the CPcCardEventHandler object.

*/

CPcCardEventHandler* CPcCardEventHandler::NewL(CPcCardControlEngine* aParent)

{

	CPcCardEventHandler *p=new (ELeave) CPcCardEventHandler;

	CleanupStack::PushL(p);

	p->InitL(aParent);

	CActiveScheduler::Add(p);

	CleanupStack::Pop();

	return p;

}

/**

Handles an active object’s request completion event.

*/

void CPcCardEventHandler::RunL()

{

	// TODO Parse code in iStatus for type of event

}

/**

Cancellation of an outstanding request.

*/

void CPcCardEventHandler::DoCancel()

{

}

/**

Gets the Event generated by the device drivers.

*/

void CPcCardEventHandler::GetEvent()

{

	// Tell the device driver we want ALL Events

	iEventBuffer.SetLength(1);

	iEventBuffer[0] = 0xFF;

	SetActive();

}

/**

Constructor.

*/

CPcCardIOCTL::CPcCardIOCTL() : CActive(EPriorityStandard) 

{

}

/**

Destructor.

*/

CPcCardIOCTL::~CPcCardIOCTL()

{

	Cancel();

}

/**

Add the newly created object to an object container.

@param aParent Pointer to the parent CPcCardControlEngine class.

*/

void CPcCardIOCTL::InitL(CPcCardControlEngine* aParent)

{

	iParent = aParent;

}

TInt CPcCardIOCTL::Ioctl(const TUint8 aIOCTLCode)

{

	if(IsActive())

		return KErrNotReady;

	iIOCTLBuffer.SetLength(1);

	iIOCTLBuffer[0] = aIOCTLCode;

	iCurrentIOCTL = aIOCTLCode;

	SetActive();

	return KErrNone;

}

/**

Standard CActive construction.

@param aParent Pointer to the parent CPcCardControlEngine class.

@return A pointer to CPcCardIOCTL object.

*/

CPcCardIOCTL* CPcCardIOCTL::NewL(CPcCardControlEngine* aParent)

{

	CPcCardIOCTL *p=new (ELeave) CPcCardIOCTL;

	CleanupStack::PushL(p);

	p->InitL(aParent);

	CActiveScheduler::Add(p);

	CleanupStack::Pop();

	return p;

}

/**

Handles an active object’s request completion event.

*/

void CPcCardIOCTL::RunL()

{

			{

			iParent->iReceiver->QueueRead();

			iParent->LinkLayerUp();

			}

}

/**

Cancellation of an outstanding request.

*/

void CPcCardIOCTL::DoCancel()

{

}