/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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: 

*

*/

// RealSerialComm.cpp: implementation of the CRealSerialComm class.

//

//////////////////////////////////////////////////////////////////////

#include "stdafx.h"

#include "RealSerialComm.h"

//#include "pn_const.h"

//#include "OSTConstants.h"

#include "Connection.h"

#ifdef _DEBUG

static char sLogMsg[3000];

#endif

//////////////////////////////////////////////////////////////////////

// Construction/Destruction

//////////////////////////////////////////////////////////////////////

#ifdef _DEBUG

#define LogErrorText(err) { if (err > 0) GetErrorText(err); }

#define LogErrorText2(err) { if (err > 0) GetErrorText2(err); }

#else

#define LogErrorText(err) {}

#define LogErrorText2(err) {}

#endif

#ifdef _DEBUG

#define DUMPCOMSTAT(x) DumpComStat(x)

#define DUMPCOMSTATP(x) DumpComStatP(x)

#else

#define DUMPCOMSTAT(x)

#define DUMPCOMSTATP(x)

#endif

CRealSerialComm::CRealSerialComm()

{

#ifdef _DEBUG

	if (gDoLogging)

	{

		FILE* f = fopen("c:\\tcf\\rscommlog.txt", "at");

		fprintf(f, "CRealSerialComm::CRealSerialComm() (default constructor)\n");

		fclose(f);

	}

#endif

	m_hSerial = INVALID_HANDLE_VALUE;

	m_serialPortName[0] = 0;

	m_pBuffer = NULL;

	m_ProcDebugLog = NULL;

}

CRealSerialComm::CRealSerialComm(ConnectData* connectSettings, DWORD connectionId, CBaseProtocol* protocol)

{

#ifdef _DEBUG

	if (gDoLogging)

	{

		FILE* f = fopen("c:\\tcf\\rscommlog.txt", "at");

		fprintf(f, "connectSettings=%x connectionId=%d, protocol=%x\n", connectSettings, connectionId, protocol);

		fclose(f);

	}

#endif

	m_hSerial = INVALID_HANDLE_VALUE;

	m_serialPortName[0] = 0;

	m_pBuffer = NULL;

	m_connId = connectionId;

	m_Protocol = protocol;

	m_ConnectSettings = new ConnectData();

	memcpy(m_ConnectSettings, connectSettings, sizeof(ConnectData));

#if (defined(LOG_COMM) || defined(LOG_PROCCOMM)) && defined(_DEBUG)

	if (gDoLogging)

	{

		m_CommDebugLog = new TCDebugLog("TCF_Comm", connectionId, 2000L);

		m_ProcDebugLog = new TCDebugLog("TCF_CommP", connectionId, 2000L);

	}

#endif

}

CRealSerialComm::~CRealSerialComm()

{

#ifdef _DEBUG

	if (gDoLogging)

	{

		FILE* f = fopen("c:\\tcf\\rscommlog.txt", "at");

		fprintf(f, "CRealSerialComm::~CRealSerialComm()\n");

		fclose(f);

	}

#endif

	if (m_hSerial != INVALID_HANDLE_VALUE)

		::CloseHandle(m_hSerial);

	if (m_pBuffer)

		delete[] m_pBuffer;

}

long CRealSerialComm::OpenPort()

{

	COMMLOGOPEN();

	COMMLOGS("CRealSerialComm::OpenPort\n");

	long err = TCAPI_ERR_NONE;

	char* comPort = m_ConnectSettings->realSerialSettings.comPort;

	DWORD baudRate = m_ConnectSettings->realSerialSettings.baudRate;

	DWORD dataBits = m_ConnectSettings->realSerialSettings.dataBits;

	eParity parity = m_ConnectSettings->realSerialSettings.parity;

	eStopBits stopBits = m_ConnectSettings->realSerialSettings.stopBits;

	eFlowControl flow = m_ConnectSettings->realSerialSettings.flowControl;

	COMMLOGA2("CRealSerialComm::OpenPort comPort=%s baudRate=%d\n", comPort, baudRate);

	COMMLOGA2("CRealSerialComm::OpenPort dataBits=%d parity=%d\n", dataBits, parity);

	COMMLOGA2("CRealSerialComm::OpenPort stopBits=%d flow=%d\n", stopBits, flow);

	// fill in DCB

	m_dcb.DCBlength = sizeof(DCB);

	m_dcb.BaudRate = baudRate;

	m_dcb.ByteSize = dataBits;

	// parity

	switch(parity)

	{

	default:

	case eParityNone:

		m_dcb.fParity = FALSE;

		m_dcb.Parity = NOPARITY;

		break;

	case eParityEven:

		m_dcb.fParity = TRUE;

		m_dcb.Parity = EVENPARITY;

		break;

	case eParityOdd:

		m_dcb.fParity = TRUE;

		m_dcb.Parity = ODDPARITY;

		break;

	}

	// stop bits

	switch(stopBits)

	{

	default:

	case eStopBits1:

		m_dcb.StopBits = ONESTOPBIT;

		break;

	case eStopBits15:

		m_dcb.StopBits = ONE5STOPBITS;

		break;

	case eStopBits2:

		m_dcb.StopBits = TWOSTOPBITS;

		break;

	}

	// flow control

	switch(flow)

	{

	default:

	case eFlowControlNone:

		m_dcb.fRtsControl = RTS_CONTROL_DISABLE;

		m_dcb.fOutxCtsFlow = FALSE;

		m_dcb.fInX = m_dcb.fOutX = FALSE;

		break;

	case eFlowControlHW:

		m_dcb.fRtsControl = RTS_CONTROL_HANDSHAKE;

		m_dcb.fOutxCtsFlow = TRUE;

		m_dcb.fInX = m_dcb.fOutX = FALSE;

		break;

	case eFlowControlSW:

		m_dcb.fRtsControl = RTS_CONTROL_DISABLE;

		m_dcb.fOutxCtsFlow = FALSE;

		m_dcb.fInX = m_dcb.fOutX = TRUE;

		m_dcb.XonChar = '\021';	// Ctrl-Q;

		m_dcb.XoffChar = '\023';	// Ctrl-S;

		m_dcb.XonLim = 100;

		m_dcb.XoffLim = 100;

		break;

	}

	// other things in DCB

	m_dcb.fDtrControl = DTR_CONTROL_ENABLE;	

	m_dcb.fDsrSensitivity = FALSE;

	m_dcb.fBinary = TRUE;

	m_dcb.fNull = FALSE;

	m_dcb.fAbortOnError = TRUE;		// reads & writes will terminate with errors if one occurs

	// translate serial port

	char p[20]; char* pp = p;

	strncpy(p, comPort, 20);

	int len = (int)strlen(p);

	for (int i = 0; i < len; i++)

	{

		p[i] = toupper(p[i]);

	}

	if (strncmp(p, "COM", 3) == 0)

	{

		pp+=3;

	}

	int val = atoi((const char*)pp);

	if (val == INT_MIN || val == INT_MAX)

	{

		err = TCAPI_ERR_INVALID_MEDIA_DATA;

	}

	else

	{

		// must translate for CreatFile

		_snprintf(m_serialPortName, MAX_COMPORT_SIZE, "\\\\.\\COM%d", val);

	}

	if (err == TCAPI_ERR_NONE)

	{

		m_hSerial = CreateFile(m_serialPortName,

			GENERIC_READ|GENERIC_WRITE,	// dwDesiredAccess = read & write

			0,							// dwSharedMode = 0 ==> device not shared

			NULL,						// lpSecurityAttributes = NULL ==> not inheritable

			OPEN_EXISTING,				// dwCreationDisposition ==> required for devices

			0,							// dwFlagsAndAttributes ==> no special flags or attributes (not overlapped)

			NULL );						// hTemplateFile = NULL ==> required for devices

		if (m_hSerial != INVALID_HANDLE_VALUE)

		{

			// TODO: this is really not needed as we're not doing overlapped IO

			//   and we're not creating an event nor waiting on that event

			if (!SetCommMask(m_hSerial, EV_RXCHAR))

			{

				::CloseHandle(m_hSerial);

				m_hSerial = INVALID_HANDLE_VALUE;

				m_lastCommError = GetLastError();

				err = TCAPI_ERR_WHILE_CONFIGURING_MEDIA;

			}

			else

			{

				// no error from SetCommMask

				if (!SetupComm(m_hSerial,MAX_MESSAGE_LENGTH,MAX_SERIAL_MESSAGE_BUFFER_LENGTH))

				{

					CloseHandle(m_hSerial);

					m_hSerial = INVALID_HANDLE_VALUE;

					m_lastCommError = GetLastError();

					err = TCAPI_ERR_WHILE_CONFIGURING_MEDIA;

				}

				else

				{

					// no error from SetupComm

					// Get rid of any junk that might be sitting there.

					PurgeComm( m_hSerial, PURGE_TXABORT | PURGE_RXABORT |

										  PURGE_TXCLEAR | PURGE_RXCLEAR );

					// Using these settings, the ReadFile command will return immediately

					// rather than waiting for a timeout.

					COMMTIMEOUTS lclCommTimeOuts;

					lclCommTimeOuts.ReadIntervalTimeout			= MAXDWORD;	// we don't care about time between chars

					lclCommTimeOuts.ReadTotalTimeoutMultiplier	= 100;

					lclCommTimeOuts.ReadTotalTimeoutConstant	= 0;

					lclCommTimeOuts.WriteTotalTimeoutMultiplier	= 100;

					lclCommTimeOuts.WriteTotalTimeoutConstant	= 0;

					if (!SetCommTimeouts( m_hSerial, &lclCommTimeOuts ))

					{

						CloseHandle(m_hSerial); 

						m_hSerial = INVALID_HANDLE_VALUE;

						m_lastCommError = GetLastError();

						err = TCAPI_ERR_WHILE_CONFIGURING_MEDIA;

					}

					else

					{

						// no error from SetCommTimeouts

						err = SetDCB();

						if (err != TCAPI_ERR_NONE)

						{

							CloseHandle(m_hSerial); 

							m_hSerial = INVALID_HANDLE_VALUE;

						}

						else

						{

							// no error from SetDCB 

							err = TCAPI_ERR_NONE;

							m_numberBytes = 0;

							m_lastCommError = 0;

							m_isConnected = true;

							m_pBuffer = new BYTE[MAX_SERIAL_MESSAGE_BUFFER_LENGTH];

						}

					}

				}

			}

		}

		else

		{

			// error from CreateFile

			// couldn't open serial port

			m_lastCommError = GetLastError();

			err = TCAPI_ERR_WHILE_CONFIGURING_MEDIA;

		}

	}

	COMMLOGA2("CRealSerialComm::OpenPort err=%d osError=%d\n", err, m_lastCommError);

	LogErrorText(m_lastCommError);

//	if (m_lastCommError > 0)

//		LogErrorText(m_lastCommError);

	COMMLOGCLOSE();

	return err;

}

long CRealSerialComm::SetDCB()

{

	// assumes serial port is open

	long err = TCAPI_ERR_NONE;

	if (m_hSerial == INVALID_HANDLE_VALUE)

		return err;

	// setup DCB

	DCB lcldcb;

	lcldcb.DCBlength = sizeof(DCB);

	if (!GetCommState( m_hSerial, &lcldcb ))

	{

		m_lastCommError = GetLastError();

		err = TCAPI_ERR_WHILE_CONFIGURING_MEDIA;

	}

//	LogDCB(pInfo);

	// copy only the ones that Connect() set initially

	lcldcb.BaudRate = m_dcb.BaudRate;

	lcldcb.ByteSize = m_dcb.ByteSize;

	lcldcb.Parity = m_dcb.Parity;

	lcldcb.StopBits = m_dcb.StopBits;

	lcldcb.fRtsControl = m_dcb.fRtsControl;

	lcldcb.fOutxCtsFlow = m_dcb.fOutxCtsFlow;

	lcldcb.fDtrControl = m_dcb.fDtrControl;

	lcldcb.fDsrSensitivity = m_dcb.fDsrSensitivity;

	lcldcb.fInX = m_dcb.fInX;

	lcldcb.fOutX = m_dcb.fOutX;

	lcldcb.XonChar = m_dcb.XonChar;

	lcldcb.XoffChar = m_dcb.XoffChar;

	lcldcb.XonLim = m_dcb.XonLim;

	lcldcb.XoffLim = m_dcb.XoffLim;

	lcldcb.fBinary = m_dcb.fBinary;

	lcldcb.fParity = m_dcb.fParity;

	lcldcb.fNull = m_dcb.fNull;

	lcldcb.fAbortOnError = m_dcb.fAbortOnError;

	// DCB has been changed

	// If setting the port went well then we are connected properly!

	if (!SetCommState( m_hSerial, &lcldcb))

	{

		m_lastCommError = GetLastError();

		err = TCAPI_ERR_WHILE_CONFIGURING_MEDIA;

	}

	return err;

}

long CRealSerialComm::ClosePort()

{

	COMMLOGOPEN();

	COMMLOGS("CRealSerialComm::ClosePort\n");

	long err = TCAPI_ERR_NONE;

	if (!IsConnected()) 

	{

		err = TCAPI_ERR_MEDIA_NOT_OPEN;

	}

	else if (m_hSerial != INVALID_HANDLE_VALUE)

	{

		// disable event notification 

		SetCommMask( m_hSerial, 0 );

		// drop DTR

		EscapeCommFunction( m_hSerial, CLRDTR );

		// purge any outstanding reads/writes and close device handle

		PurgeComm(	m_hSerial, 

					PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR );

		CloseHandle( m_hSerial );

		m_hSerial = INVALID_HANDLE_VALUE;

		if (m_pBuffer)

		{

			delete[] m_pBuffer;

			m_pBuffer = NULL;

		}

		m_isConnected = false;

	}

	COMMLOGCLOSE();

	return err;

}

void CRealSerialComm::DeleteMsg(DWORD inMsgLength)

{

	if (!IsConnected())

		return;

	// inMsgLength includes header

	// delete from beginning of buffer

	if (inMsgLength == 0)

		return;

	if (m_numberBytes > 0 && m_numberBytes >= inMsgLength)

	{

		size_t moveLen = m_numberBytes - inMsgLength;

		if (moveLen > 0)

			memcpy(&m_pBuffer[0], &m_pBuffer[inMsgLength], moveLen);

		m_numberBytes -= inMsgLength;

	}

}

long CRealSerialComm::SendDataToPort(DWORD inSize, const void *inData)

{

	long err = TCAPI_ERR_NONE;

	DWORD lclNumBytes=0;

	COMMLOGOPEN();

	COMMLOGS("CRealSerialComm::SendDataToPort\n");

	COMMLOGCLOSE();

	if (!IsConnected())

	{

		COMMLOGOPEN();

		COMMLOGS("CRealSerialComm::SendDataToPort notConnected\n");

		COMMLOGCLOSE();

		return TCAPI_ERR_MEDIA_NOT_OPEN;

	}

	if (WriteFile(m_hSerial, inData, inSize, &lclNumBytes, NULL))

	{

		// we were successful, but did we send all data? (i.e., a timeout occurred)

		// we are not doing overlapped I/O so if not all data went, then we timed out

		//   and there was some kind of error

		if (lclNumBytes != inSize)

		{

			COMMLOGOPEN();

			COMMLOGA3("CRealSerialComm::SendDataToPort WriteFile not all bytes sent: lclNumBytes=%d inSize=%d err=%d\n", lclNumBytes, inSize, GetLastError());

			COMMLOGCLOSE();

			COMSTAT lclComStat;

			DWORD lclErrorFlags = 0;

			if (!ClearCommError(m_hSerial, &lclErrorFlags, &lclComStat))

			{

				// clear comm error returned error (this doesn't normally happen if the handle is valid and port is still open)

				m_lastCommError = GetLastError();

				err = TCAPI_ERR_COMM_ERROR;

				COMMLOGOPEN();

				COMMLOGA1("CRealSerialComm::SendDataToPort ClearCommError failed=%d\n", m_lastCommError);

				COMMLOGCLOSE();

			}

			else

			{

				// clear comm error returned OK

				// check error flags

				if (lclErrorFlags)

				{

					// there really was an error

					m_lastCommError = lclErrorFlags;

					err = TCAPI_ERR_COMM_ERROR;

					COMMLOGOPEN();

					COMMLOGA1("CRealSerialComm::SendDataToPort ClearCommError succeeded lclErrorFlags=%d\n", m_lastCommError);

					COMMLOGCLOSE();

				}

				else

				{

					// No OS error returned, but WriteFile failed to write out all bytes

					//  therefore, since we are not doing overlapped I/O, this is an error.

					err = TCAPI_ERR_COMM_ERROR;

					COMMLOGOPEN();

					COMMLOGS("CRealSerialComm::SendDataToPort ClearCommError succeeded lclErrorFlags=0\n");

					COMMLOGCLOSE();

//					DUMPCOMSTAT(&lclComStat);

				}

			}

		}

		else

		{

			// we sent all the data we requested

			err = TCAPI_ERR_NONE;

#ifdef _DEBUG

			COMMLOGOPEN();

			COMMLOGS("CRealSerialComm::SendDataToPort WriteFile successful\n");

			BYTE* ptr = (BYTE*)inData;

			long numBytes = (inSize > 20) ? 20 : inSize;

			char msg[200];

			sprintf(msg, "CRealSerialComm::SendDataToPort = ");

			for (int i = 0; i < numBytes; i++)

			{

				sprintf(msg, "%s %02.2x", msg, ptr[i]);

			}

			sprintf(msg, "%s\n", msg);

			COMMLOGS(msg);

			COMMLOGCLOSE();

#endif

		}

	}

	else

	{

		// write failed

		m_lastCommError = GetLastError();

		err = TCAPI_ERR_COMM_ERROR;

		COMMLOGOPEN();

		COMMLOGA1("CRealSerialComm::SendDataToPort WriteFile failed = %d\n", m_lastCommError);

		COMMLOGCLOSE();

	}

	return err;

}

long CRealSerialComm::PollPort(DWORD &outSize)

{

	long err = TCAPI_ERR_NONE;

	outSize = 0;

	COMSTAT lclComStat;

	DWORD lclErrorFlags=0;

	if (!IsConnected())

		return TCAPI_ERR_MEDIA_NOT_OPEN;