/*

* Copyright (c) 2006 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: 

*

*/

#ifdef __WINS__

#error - this driver cannot be built for emulation

#endif

#include <e32def.h>

#include <e32cmn.h>

#include <kernel.h>

#include <kern_priv.h>

#include <arm.h>

#include "TrkDccComm.h"

#include "TrkDccDriver.h"

//This macro turns on DCC3 mode, this is always turned on.

//To test DCC1 mode, comment this out and make sure to configure T32 to use DCC1 as well.

#define DCC3

//currenly both start and end bytes for the packet are the same

#define PKT_STRT_BYTE 0x7E

#define PKT_END_BYTE 0x7E

#define KTrkAppSecurUid 0x200170BB

#define KTrkExeSecurUid 0x200159E2

//

// Static function definitions

//

//

//

// DTrkDccDriverFactory implementation

//

//

//

// DTrkDccDriverFactory constructor

//

DTrkDccDriverFactory::DTrkDccDriverFactory()

{

    iVersion = TVersion(KMajorDccVersionNumber, KMinorDccVersionNumber, KBuildDccVersionNumber);    

}

//

// DTrkDccDriverFactory::Create

//

TInt DTrkDccDriverFactory::Create(DLogicalChannelBase*& aChannel)

{

	if (iOpenChannels != 0)

		return KErrInUse; // a channel is already open

	aChannel = new DTrkDccChannel(this);

	return aChannel ? KErrNone : KErrNoMemory;

}

//

// DTrkDccDriverFactory::Install

//

TInt DTrkDccDriverFactory::Install()

{

    return(SetName(&KTrkDccDriverName));

}

//

// DTrkDccDriverFactory::Install

//

void DTrkDccDriverFactory::GetCaps(TDes8& aDes) const

{

    TCapsTrkDccDriver b;

    b.iVersion = TVersion(KMajorDccVersionNumber, KMinorDccVersionNumber, KBuildDccVersionNumber);

    Kern::InfoCopy(aDes,(TUint8*)&b, sizeof(b));

}

//

//

// DTrkDccChannel implementation

//

//

//

// DTrkDccChannel constructor

//

DTrkDccChannel::DTrkDccChannel(DLogicalDevice* aLogicalDevice)

				: iRxTimer(DTrkDccChannel::RxTimerCallBack, this),

				  iRxBufSize(MAXMESSAGESIZE*2),

				  iRxGetIndx(0),

				  iRxPutIndx(0),

				  iRxCompleteDfc(DTrkDccChannel::RxTimerDfc, this, 2),

				  iInterruptId(76),

				  iPacketStarted(EFalse),

				  iPacketEnded(EFalse)

{

	LOG_MSG("DTrkDccChannel::DTrkDccChannel()");

	iDevice = aLogicalDevice;

	iClientThread = &Kern::CurrentThread();

	TInt err = iClientThread->Open();	

	iRxTimeOut = NKern::TimerTicks(1); 

}

//

// DTrkDccChannel destructor

//

DTrkDccChannel::~DTrkDccChannel()

{

	LOG_MSG("DTrkDccChannel::~DTrkDccChannel()");

	iRxTimer.Cancel();

	if (iRxBuffer)

	{

		delete iRxBuffer;

		iRxBuffer = NULL;

	}

	if (iLock)

		iLock->Close(NULL);

	Kern::SafeClose((DObject*&)iClientThread, NULL);	

}

//

// DTrkDccChannel::DoCreate

//

TInt DTrkDccChannel::DoCreate(TInt /*aUnit*/, const TDesC* /*anInfo*/, const TVersion& aVer)

{

	LOG_MSG("DTrkDccChannel::DoCreate()");

  	if (!Kern::QueryVersionSupported(TVersion(KMajorDccVersionNumber, KMinorDccVersionNumber, KBuildDccVersionNumber), aVer))

		return KErrNotSupported; 

	//Setup the driver for receiving client messages

	iDFCQue = NULL;

	TBuf8<KMaxInfoName> dccDFC = _L8("DCC DFC");;

	TInt err = Kern::DfcQCreate(iDFCQue, 27, &dccDFC);

	if (err == KErrNone)

	{

		SetDfcQ(iDFCQue);

	}

	else

	{

		SetDfcQ(Kern::DfcQue0());

	}

	iMsgQ.Receive();  	

	iRxCompleteDfc.SetDfcQ(Kern::TimerDfcQ());

	iRxBuffer=(TUint8*)Kern::Alloc(iRxBufSize);

	err = Kern::SemaphoreCreate(iLock, _L("TrkDccDriverWriteLock"), 1 /* Initial count */);

	if (err != KErrNone)

		return err;

	return KErrNone;

}

//

// DTrkDccChannel::DoCancel

//

void DTrkDccChannel::DoCancel(TInt aReqNo)

{

	LOG_MSG("DTrkDccChannel::DoCancel()");

	switch(aReqNo)

	{

		case RTrkDccDriver::ERequestReadCancel:

		{

			Kern::RequestComplete(iClientThread, iRxRequestStatus, KErrCancel);

			iRxClientBuffer = NULL;

			iRxRequestStatus = NULL;

			iRxClientBufferLength = 0;

			iRxTimer.Cancel();

		}

		break;

	}

}

//

// DTrkDccChannel::DoRequest

//

void DTrkDccChannel::DoRequest(TInt aReqNo, TRequestStatus* aStatus, TAny* a1, TAny* a2)

{

	LOG_MSG("DTrkDccChannel::DoRequest()");

	switch(aReqNo)

	{

		case RTrkDccDriver::ERequestRead:

		{

			iRxRequestStatus = aStatus;

			iRxClientBuffer = a1;

			iRxClientBufferLength = (TUint32)a2;

			//start the polling timer...

			iRxTimer.OneShot(iRxTimeOut);

			break;

		}		

		default:

			Kern::RequestComplete(iClientThread, aStatus, KErrNotSupported);

	}

}

//

// DTrkDccChannel::DoControl

//

TInt DTrkDccChannel::DoControl(TInt aFunction, TAny* a1, TAny* a2)

{

	LOG_MSG("DTrkDccChannel::DoControl()");

	TInt err = KErrNone;

	switch(aFunction)

	{

		case RTrkDccDriver::EControlWrite:

		{

			//lock the Semaphore so that write doesn't happen when a write is already in progress.

			Kern::SemaphoreWait(*iLock);

			err = DoWrite((TUint32)a1, a2);			

			Kern::SemaphoreSignal(*iLock);			

			break;

		}

		default:

		{

			return KErrGeneral;

		}

	}

	if (KErrNone != err)

	{

		LOG_MSG2("Error %d from control function", err);

	}

	return err;

}

//

// DTrkDccChannel::HandleMsg

//

void DTrkDccChannel::HandleMsg(TMessageBase* aMsg)

{

	LOG_MSG("DTrkDccChannel::HandleMsg()");

	TThreadMessage& m = *(TThreadMessage*)aMsg;

	TInt id = m.iValue;

	if (id == (TInt)ECloseMsg)

	{

		m.Complete(KErrNone, EFalse);

		return;

	}

	if (id == KMaxTInt)

	{

		// DoCancel

		DoCancel(m.Int0());

		m.Complete(KErrNone, ETrue); 

		return;

	}

	if (id < 0)

	{

		// DoRequest

		TRequestStatus* pStatus = (TRequestStatus*)m.Ptr0();

		DoRequest(~id, pStatus, m.Ptr1(), m.Ptr2());

		m.Complete(KErrNone, ETrue);

	}

	else

	{

		// DoControl

		TInt err = DoControl(id, m.Ptr0(), m.Ptr1());

		m.Complete(err, ETrue);

	}

}

//

// DTrkDccChannel::DoWrite

//

TInt DTrkDccChannel::DoWrite(TUint32 aLength, TAny* a2)

{

	LOG_MSG("DTrkDccChannel::DoWrite()");

	TInt err = KErrNone;

	err = Kern::ThreadDesRead(iClientThread, a2, iTxBuffer, 0, KChunkShiftBy0);

	if (err == KErrNone)

	{	

		err = WriteDccChannel(iTxBuffer);

	}

	return err;

}

//

// DTrkDccChannel::DoRead

//

TInt DTrkDccChannel::DoRead()

{	

	TInt err = KErrNone;

	ReadDccChannel();

	if (iRxPutIndx != iRxGetIndx)

	{

		if (iPacketEnded)

		{

			iPacketStarted = EFalse;

			iPacketEnded = EFalse;

		}

		//there is some data, complete the read request if there is one pending

		DoCompleteRx();

		if (iRxPutIndx == iRxGetIndx)

		{

			iRxPutIndx = iRxGetIndx = 0;

		}

	}

	else

	{

		err = -1;

		//start the timer again since we didn't complete the request

		iRxTimer.OneShot(iRxTimeOut);

	}

	return err;			

}

//

// DTrkDccChannel::WriteDccChannel

//

// This function writes all the data in the descriptor word by word.

// DCC3 mode is used for transferring the data to the DCC channel.

// With DCC3, the number of bytes in the word is encoded in its MSB.

// DCC3 mode can be turned of by commenting the DCC3 macro at the 

// beginning of this file.

//

TInt DTrkDccChannel::WriteDccChannel(const TDesC8& aDes)

{

	TInt err = KErrNone;

	const TText8* pStart = aDes.Ptr();

	const TText8* pEnd = pStart + aDes.Length();

	if (pStart != pEnd)

	{

		while (pStart < pEnd)

		{			

			TUint retries = 10;

		#ifdef DCC3

			TUint32 data = 0;

			//for DCC3 support

			if ((pEnd-pStart) >= 3)

			{

				data = ((TUint32)(*pStart++)) | ((TUint32)(*pStart++))<<8 | ((TUint32)(*pStart++))<<16 | (0x02<<24);

			}

			else if ((pEnd-pStart) == 2)

			{

				data = ((TUint32)(*pStart++)) | ((TUint32)(*pStart++))<<8 |  (0x01<<24);

			}

			else if ((pEnd-pStart) == 1)

			{

				data = (TUint32)(*pStart++);

			}

		#endif

			while (retries--)

			{

			#ifdef DCC3

				err = Arm::DebugOutJTAG(data);		

			#else

				err = Arm::DebugOutJTAG(*pStart);		

			#endif

				//if we get timeout error, try three times sending the same byte

				if (err == KErrTimedOut)

				{

					LOG_MSG("Write timed out, trying again\n");

					continue;

				}

				else

					break;

			}

			if (err)

			{

				LOG_MSG2("WriteDccChannel() failed %d", err);

				return err;

			}

		#ifndef DCC3

			pStart++;

		#endif

		}

	}

	return err;

}

//

// DTrkDccChannel::ReadDccChannel

//

// Strictly reads packet by packets since TRK expects the host debugger 

// to wait for the response for the cmd sent. 

// This function will return if 

// 	- the packet is completely read

//  - if out of band data, i.e. data not conforming to TRK protocol packets

//	- if an error other than KErrNotReady happens in while in the middle of 

//    reading a packet.

// Also the function uses DCC3 mode, where the no of bytes sent in the word

// is encoded in the MSB and the actual data bytes in the remaining bytes.

// Like for sending three bytes, the word will be 0x02CCBBAA.

// For sending three bytes, the MSB should be 2.

// For two bytes, the MSB should be 1.

// For one bytes, the MSB should be 0.

//

void DTrkDccChannel::ReadDccChannel()

{

	TInt err = KErrNone;

	TInt err1 = KErrNone;

	TUint i = iRxPutIndx;

	TUint32 data;

	err = err1 = Arm::DebugInJTAG(data);	

	while (KErrNone == err)

	{	

		if (KErrNone == err1)

		{	

			TUint8 nBytes = 0;

			nBytes = TUint8(data>>24);

			for (int j=0; j<=nBytes; j++)

			{									

				iRxBuffer[i] = (TUint8)(data>>(j*8));	

				if (iRxBuffer[i] == PKT_STRT_BYTE)	

				{

					if (!iPacketStarted)

					{

						iPacketStarted = ETrue;

					}

					else

					{

						iPacketEnded = ETrue;

					}

				}

				i++; //increment i here so that put index can be appriopriately set later 

			}

			if (i == iRxBufSize)

			{

				i = 0;

				break;

			}

			//if cmd packet ended, send the data to the engine.

			if (iPacketEnded)

			{

				break;

			}

		}

		//read again to see if there is data already available

		err = err1 = Arm::DebugInJTAG(data);	

		//if the packet is started, try to read the whole packet

		//so set the err value to KErrNone so that we can continue reading

		if ((err == KErrNotReady) && iPacketStarted && !iPacketEnded)

			err = KErrNone; 				

		if (err != KErrNone && err != KErrNotReady)

			LOG_MSG2("Read Error %d\n", err);

	}

	iRxPutIndx=i;	

}

//

// DTrkDccChannel::RxTimerCallBack

//

void DTrkDccChannel::RxTimerCallBack(TAny* aPtr)

{

	// called from ISR when timer completes

	DTrkDccChannel *pChannel = (DTrkDccChannel*)aPtr;

	pChannel->iRxCompleteDfc.Add();

}

//

// DTrkDccChannel::RxTimerDfc

//

void DTrkDccChannel::RxTimerDfc(TAny* aPtr)

{

	DTrkDccChannel *pChannel = (DTrkDccChannel*)aPtr;	

	pChannel->DoRead();

}

//

// DTrkDccChannel::DoCompleteRx

//

void DTrkDccChannel::DoCompleteRx()

{

	LOG_MSG("DTrkDccChannel::DoCompleteRx()");

	if (iRxRequestStatus)

	{

		TInt avail = 0;

		if (iRxPutIndx > iRxGetIndx)