// Copyright (c) 2002-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:

// wins/specific/serialpdd.cpp

// 

//

#include "winscomm.h"

#include "nk_priv.h"

#include "nk_plat.h"

#include <emulator.h>

#define WIN32_LEAN_AND_MEAN

#pragma warning( disable : 4201 ) // nonstandard extension used : nameless struct/union

#include <windows.h>

#pragma warning( default : 4201 ) // nonstandard extension used : nameless struct/union

#ifdef FAULT

#undef FAULT

#endif

#define FAULT() Kern::Fault(__FILE__,__LINE__)

_LIT(KComName, "\\\\.\\com");

// needs ldd version..

const TInt KMinimumLddMajorVersion=1;

const TInt KMinimumLddMinorVersion=1;

const TInt KMinimumLddBuild=1;		

//used for the read and write buffers in the driver.

//large buffer reserved so any transfer to/from the client can fit into a driver buffer

const TInt KSerialBufferMaxSize = 0x800000;

const TInt KSerialBufferInitialSize = 0x10000;

const TInt KSerialBufferIncrementSize = 0x1000;	//granularity.  must be power of 2	

const DWORD KReadOneOrMoreTimeout = MAXDWORD-1;	//milliseconds

//buffer sizes passed to NT for setting its own driver buffer sizes

const TInt KDefaultWinNTReadBufSize = 1024;

const TInt KDefaultWinNTWriteBufSize = 1024;

static DWORD dummyLen=0;

enum TDCommWinsFault 

	{

	EWindowsUnexpectedError,

	EUnknownCommand,

	EBadIOLen,

	EEofOnSerial,

	EWriteEarlyCompletion,

	ELineErrorNotReported,

	ESerialBufferTooBig,

	EReadLength,

	};

class DDriverComm : public DPhysicalDevice

	{

public:

	DDriverComm();

	virtual TInt Install();

	virtual TInt Remove();

	virtual void GetCaps(TDes8 &aDes) const;

	virtual TInt Create(DBase*& aChannel, TInt aUnit, const TDesC8* aInfo, const TVersion& aVer);

	virtual TInt Validate(TInt aUnit, const TDesC8* aInfo, const TVersion &aVer);

	};

class DCommWins : public DComm

	{

public:

	enum TDriverCommand {ESetBreak=1,EClearBreak,ETransmit,ETransmit0,

						EGetSignals,ESetSignals,EConfigure,

						EStop,EStopNoDrain,EStart,EDie,	ETransmitCancel,

						EReceive, EReceiveOneOrMore, EReceiveCancel,ENotifyDataAvailable,

						ENotifySignals, EInvalidCommand};

public:

	DCommWins();

	~DCommWins();

	virtual TInt Start();

	virtual void Stop(TStopMode aMode);

	virtual void Break(TBool aState);

	virtual void Write(DThread* aThread, TAny *aTxDes, TInt aLength);

	virtual void Read(DThread* aThread, TAny *aTxDes, TInt aLength);

	virtual void NotifySignals(DThread* aThread, TInt aMask);

	virtual void NotifyDataAvailable();

	virtual TUint Signals() const;

	virtual void SetSignals(TUint aSetMask,TUint aClearMask);

	virtual TInt ValidateConfig(const TCommConfigV01 &aConfig) const;

	virtual void Configure(TCommConfigV01 &aConfig);

	virtual void Caps(TDes8 &aCaps) const;

	virtual void CheckConfig(TCommConfigV01& aConfig);

	virtual TDfcQue* DfcQ(TInt aUnit);

	inline void CheckTxBuffer();

	inline TBool Transmitting();

	virtual TInt RxCount();

	virtual void ResetBuffers(TBool);

	virtual TInt SetRxBufferSize(TInt aSize);

	virtual TInt RxBufferSize();

	virtual TDes8* RxBuffer();

	virtual void DoConfigure();

	virtual TBool AreAnyPending();

	virtual void ReadCancel();

	virtual void WriteCancel();

	virtual void SignalChangeCancel();

	TInt DoCreate(TInt aUnit,const TDesC8 *aInfo);

	void WaitForEvent();

	void DriverCommand(TDriverCommand aCommand);

	void DoWriteComplete(TInt aErr);

	void DoReadComplete(TInt aErr, TInt aBytes);

	void DoSignalCompletion(TInt aError, TUint changed, TUint aValues);

	void DoDataAvailableCompletion();

	void RunCommThread(TDriverCommand aCommand);

	inline void SignalDriverThread();

	inline TBool LineFail();

private:

	void ReleaseBuffers();

	void ReSizeBuffer(TUint8*& aBuf, TInt& iBufLen, TPtr8& aDes, const TInt aNewLen);

	TBool IsATerminator(TText8 aChar);

	void CompleteRead(TInt aLength);

	void DataAvailableNotificationCancel();

private:

	TInt iWritePending;

	TInt iReadPending;

	TBool iStopping;

	TBool iRunning;

	TDriverCommand iCommand;

	TCommConfigV01 *iConfig;

	TUint iSignals;

	TUint iFailSignals;

	TUint iSavedSignals;

	TBool iLineFail;

	TBool iRXLineFail;

	TBool iTXLineFail;

	TUint8 * iInBufPtr;		//input buffer used by driver.

	TInt iInBufLength;

	TPtr8 iInDes;

	TInt iReadSoFar;

	TBool iTerminatedRead;	//true if we are reading with 1 or more terminating characters

	TUint8 * iOutBufPtr;

	TInt iOutBufLength;

	TPtr8 iOutDes;

	TInt iRxBufferSize;		//size of receivebuffer passed to windows & set by calls to SetReceiveBufferSize 

							//used to determine xon and xoff levels

	TUint iSignalsRequested;  //mask of signals we are waiting for

	TUint iSignalsWanted;		//mask we are asked to check 

	TBool iDataAvailableNotification;

	HANDLE iThread;

	HANDLE iCommThreadSem;

	HANDLE iDriverThreadSem;

	HANDLE iCommPort;

	DWORD iThreadID;

	DWORD iSignalStatus;

	OVERLAPPED iReadOverLapped;

	OVERLAPPED iWriteOverLapped;

	OVERLAPPED iSignalOverLapped;

	TInt iClientReadLength;		//how much data the client has requested in a read

	TBool		iBreakDetected;

	};

void Panic(TDCommWinsFault aFault)

//

// Panic the driver 

//

	{

	Kern::PanicCurrentThread(_L("DCommWins"), aFault);

	}

TUint commThread(DCommWins *comm)

//

// Comm thread entry point

//

	{

	comm->WaitForEvent();

	return 0;

	}

VOID WINAPI WriteCompletion(DCommWins *aDrv, DWORD aErr,DWORD /*numBytes*/)

	{

	aDrv->DoWriteComplete(aErr);

	}

VOID WINAPI ReadCompletion(DCommWins *aDrv, DWORD aErr,DWORD numBytes)

	{

	aDrv->DoReadComplete(aErr, numBytes);

	}

VOID WINAPI SignalCompletion(DCommWins *aDrv, TInt aError, TUint aChanged, TUint aValues)

	{

	aDrv->DoSignalCompletion(aError, aChanged, aValues);

	}

VOID WINAPI DataAvailableCompletion(DCommWins *aDrv)

	{

	aDrv->DoDataAvailableCompletion();

	}

BOOL WINAPI EscapeCommFunctionP(HANDLE hFile,DWORD dwFunc)

	{

	DWORD err;

	DWORD lastError = 0;

	BOOL res;

	COMSTAT s;

	do

		{

		ClearCommError(hFile, &err, &s);

		res = EscapeCommFunction(hFile,dwFunc);

		if(!res)

			lastError = GetLastError();

		}

	while((!res) && (lastError == ERROR_OPERATION_ABORTED));

	return(res);

	}

BOOL WINAPI GetCommModemStatusP(HANDLE hFile,LPDWORD lpModemStat)

	{

	DWORD err;

	DWORD lastError = 0;

	BOOL res;

	COMSTAT s;

	do

		{

		ClearCommError(hFile, &err, &s);

		res = GetCommModemStatus(hFile,lpModemStat);

		if(!res)

			lastError  = GetLastError();

		}

	while((!res) && (lastError == ERROR_OPERATION_ABORTED));

	return(res);

	}

BOOL WINAPI GetCommStateP(HANDLE hFile,LPDCB lpDCB)

	{

	DWORD err;

	DWORD lastError = 0;

	BOOL res;

	COMSTAT s;

	do

		{

		ClearCommError(hFile,&err,&s);

		res = GetCommState(hFile,lpDCB);

		if (!res)

			lastError = GetLastError();

		}

	while((!res) && (lastError == ERROR_OPERATION_ABORTED));

	return(res);

	}

BOOL WINAPI SetCommStateP(HANDLE hFile,LPDCB lpDCB)

	{

	DWORD err;

	DWORD lastError = 0;

	BOOL res;

	COMSTAT s;

	do

		{

		ClearCommError(hFile, &err, &s);

		res = SetCommState(hFile, lpDCB);

		if (!res)

			lastError = GetLastError();

		}

	while((!res) && (lastError == ERROR_OPERATION_ABORTED));

	return(res);

	}

BOOL WINAPI SetCommMaskP(HANDLE hFile,DWORD dwEvtMask)

	{

	DWORD err;

	DWORD lastError = 0;

	BOOL res;

	COMSTAT s;

	do

		{

		ClearCommError(hFile, &err, &s);

		res = SetCommMask(hFile, dwEvtMask);

		if (!res)

			lastError = GetLastError();

		}

	while((!res) && (lastError == ERROR_OPERATION_ABORTED));

	return(res);

	}

BOOL WINAPI WriteFileP(HANDLE hFile,LPCVOID lpBuffer,DWORD nNumberOfBytesToWrite,LPDWORD lpNumberOfBytesWritten,LPOVERLAPPED lpOverlapped)

	{

	DWORD err;

	DWORD lastError = 0;

	BOOL res;

	COMSTAT s;

	do

		{

		ClearCommError(hFile, &err, &s);

		res = WriteFile(hFile, lpBuffer, nNumberOfBytesToWrite, lpNumberOfBytesWritten, lpOverlapped);

		if (!res)

			lastError = GetLastError();

		}

	while((!res) && (lastError == ERROR_OPERATION_ABORTED));

	return(res);

	}

BOOL WINAPI ReadFileP(HANDLE hFile,LPVOID lpBuffer,DWORD nNumberOfBytesToRead,LPDWORD lpNumberOfBytesRead,LPOVERLAPPED lpOverlapped)

	{

	DWORD err;

	DWORD lastError = 0;

	BOOL res;

	COMSTAT s;

	do

		{

		ClearCommError(hFile, &err, &s);

		res = ReadFile(hFile, lpBuffer, nNumberOfBytesToRead, lpNumberOfBytesRead, lpOverlapped);

		if (!res)

			lastError = GetLastError();

		}

	while((!res) && (lastError == ERROR_OPERATION_ABORTED));

	return(res);

	}

DDriverComm::DDriverComm()

	{

#if defined (__COM_ONE_ONLY__)

	iUnitsMask=0x1; // Support units 0

#elif defined (__COM_TWO_ONLY__)

	iUnitsMask=0x2; // Support units 1

#else

	iUnitsMask=0x3ff; // Support units 0 to 9

#endif

	iVersion=TVersion(KCommsMajorVersionNumber,KCommsMinorVersionNumber,KCommsBuildVersionNumber);

	}

TInt DDriverComm::Install()

	{

#if defined (__COM_ONE_ONLY__)

	TPtrC buf=_L("Comm.Wins1");

	return(SetName(&buf));

#elif defined (__COM_TWO_ONLY__)

	TPtrC buf=_L("Comm.Wins2");

	return(SetName(&buf));

#else

	TPtrC buf=_L("Comm.Wins");

	return(SetName(&buf));

#endif

	}

TInt DDriverComm::Remove()

	{

	return(KErrNone);

	}

TInt DDriverComm::Validate(TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& aVer)

//

//	Validate the requested configuration

//

	{

	if ((!Kern::QueryVersionSupported(iVersion,aVer)) || (!Kern::QueryVersionSupported(aVer,TVersion(KMinimumLddMajorVersion,KMinimumLddMinorVersion,KMinimumLddBuild))))

		return KErrNotSupported;

#if defined (__COM_ONE_ONLY__)

	if (aUnit!=0)

		return KErrNotSupported;

#elif defined (__COM_TWO_ONLY__)

	if (aUnit!=1)

		return KErrNotSupported;

#endif

	// leave Unit check to CreateFile

	return KErrNone;

	}

void GetWinsCommsCaps(TDes8 &aCaps)

	{

	TCommCaps3 capsBuf;

	TCommCapsV03 &c=capsBuf();

//

// All rates except 50,2000, 3600 and special

//

	c.iRate=KCapsBps75|KCapsBps110|KCapsBps134|KCapsBps150|KCapsBps300|KCapsBps600|KCapsBps1200|KCapsBps1800|KCapsBps2400|KCapsBps4800|KCapsBps7200|KCapsBps9600|KCapsBps19200|KCapsBps38400|KCapsBps57600|KCapsBps115200;

	c.iDataBits=0xf; // All data sizes

	c.iStopBits=0x3; // 1 and 2 stop bits

	c.iParity=0x7; // None, Even and Odd

	c.iHandshake = 0x3BF;	//all except KConfigObeyDCD

	c.iSignals=0x3f; // All signals

	c.iSIR=0;//No Ir

	c.iNotificationCaps=KNotifySignalsChangeSupported|KNotifyDataAvailableSupported;

	c.iRoleCaps=0;

	c.iFlowControlCaps=0;

	c.iBreakSupported=ETrue;

	aCaps.FillZ(aCaps.MaxLength());

	aCaps=capsBuf.Left(Min(capsBuf.Length(),aCaps.MaxLength()));

	}

void DDriverComm::GetCaps(TDes8 &aDes) const

	{

	GetWinsCommsCaps(aDes);

	}

TInt DDriverComm::Create(DBase*& aChannel, TInt aUnit,const TDesC8* aInfo,const TVersion& aVer)

	{

	if (!Kern::QueryVersionSupported(iVersion,aVer))

		return KErrNotSupported;

	DCommWins *pD= new DCommWins;

	if (!pD) return KErrNoMemory;

	TInt ret=pD->DoCreate(aUnit,aInfo);

	if (ret!=KErrNone)

	{

		delete pD;

		return ret;

	}

	aChannel = pD;

	return KErrNone;

	}

void DCommWins::DoWriteComplete(TInt aErr)

	{

	iWritePending = 0;

	iTransmitting = EFalse;

	StartOfInterrupt();

	iLdd->iTxError = aErr;

	iLdd->iTxCompleteDfc.Add();

	EndOfInterrupt();

	}

void DCommWins::DoSignalCompletion(TInt aError, TUint aChanged, TUint aValues)

	{

	//aValues contains the signal values.  EPOC constants

	//aChanged contains the signals which have changed

	//we return the signal values

	TUint res = aValues & iSignalsWanted;

	res |= (aChanged << 12);

	iLdd->iSignalResult = res;

	iLdd->iSignalError = aError;

	StartOfInterrupt();

	iLdd->iSigNotifyDfc.Add();

	EndOfInterrupt();

	}

void DCommWins::DoDataAvailableCompletion()

	{

	StartOfInterrupt();

	iLdd->iRxDataAvailableDfc.Add();

	EndOfInterrupt();

	}

void DCommWins::CompleteRead(TInt aLength)

	{

	iReadPending = 0;

	iInDes.SetLength(aLength);

	StartOfInterrupt();

	iLdd->iRxCompleteDfc.Add();

	EndOfInterrupt();

	}

void DCommWins::DoReadComplete(TInt aErr, TInt aBytes)

	{

	iLdd->iRxError = aErr;

	//write back the length and the data

	//process for any terminating characters.

	//win32 only does binary reads and ignores the eofchar, so terminated reads

	//require reading one char at a time

	if (iTerminatedRead && !aErr)

		{

		__NK_ASSERT_ALWAYS(aBytes <= 1);

		if (aBytes == 0)

			{

			// not sure why we get this somtimes, but handle it anyway : read another character

			ReadFileP(iCommPort,(void*)(iInBufPtr+iReadSoFar), 1, &dummyLen, &iReadOverLapped);

			}

		else if (++iReadSoFar == iClientReadLength)	//see if we have read enough characters into the buffer