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

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

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

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // wins/specific/serialpdd.cpp

    15 // 

    16 //

    17 

    18 #include "winscomm.h"

    19 #include "nk_priv.h"

    20 #include "nk_plat.h"

    21 #include <emulator.h>

    22 

    23 #define WIN32_LEAN_AND_MEAN

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

    25 #include <windows.h>

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

    27 

    28 #ifdef FAULT

    29 #undef FAULT

    30 #endif

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

    32 

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

    34 

    35 // needs ldd version..

    36 const TInt KMinimumLddMajorVersion=1;

    37 const TInt KMinimumLddMinorVersion=1;

    38 const TInt KMinimumLddBuild=1;		

    39 

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

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

    42 const TInt KSerialBufferMaxSize = 0x800000;

    43 const TInt KSerialBufferInitialSize = 0x10000;

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

    45 

    46 

    47 const DWORD KReadOneOrMoreTimeout = MAXDWORD-1;	//milliseconds

    48 

    49 

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

    51 const TInt KDefaultWinNTReadBufSize = 1024;

    52 const TInt KDefaultWinNTWriteBufSize = 1024;

    53 

    54 static DWORD dummyLen=0;

    55 

    56 enum TDCommWinsFault 

    57 	{

    58 	EWindowsUnexpectedError,

    59 	EUnknownCommand,

    60 	EBadIOLen,

    61 	EEofOnSerial,

    62 	EWriteEarlyCompletion,

    63 	ELineErrorNotReported,

    64 	ESerialBufferTooBig,

    65 	EReadLength,

    66 	};

    67 

    68 

    69 class DDriverComm : public DPhysicalDevice

    70 	{

    71 public:

    72 	DDriverComm();

    73 	virtual TInt Install();

    74 	virtual TInt Remove();

    75 	virtual void GetCaps(TDes8 &aDes) const;

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

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

    78 	};

    79 

    80 

    81 class DCommWins : public DComm

    82 	{

    83 public:

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

    85 						EGetSignals,ESetSignals,EConfigure,

    86 						EStop,EStopNoDrain,EStart,EDie,	ETransmitCancel,

    87 						EReceive, EReceiveOneOrMore, EReceiveCancel,ENotifyDataAvailable,

    88 						ENotifySignals, EInvalidCommand};

    89 public:

    90 	DCommWins();

    91 	~DCommWins();

    92 	virtual TInt Start();

    93 	virtual void Stop(TStopMode aMode);

    94 	virtual void Break(TBool aState);

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

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

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

    98 	virtual void NotifyDataAvailable();

    99 	virtual TUint Signals() const;

   100 	virtual void SetSignals(TUint aSetMask,TUint aClearMask);

   101 	virtual TInt ValidateConfig(const TCommConfigV01 &aConfig) const;

   102 	virtual void Configure(TCommConfigV01 &aConfig);

   103 	virtual void Caps(TDes8 &aCaps) const;

   104 	virtual void CheckConfig(TCommConfigV01& aConfig);

   105 	virtual TDfcQue* DfcQ(TInt aUnit);

   106 

   107 	inline void CheckTxBuffer();

   108 	inline TBool Transmitting();

   109 	virtual TInt RxCount();

   110 	virtual void ResetBuffers(TBool);

   111 	virtual TInt SetRxBufferSize(TInt aSize);

   112 	virtual TInt RxBufferSize();

   113 	virtual TDes8* RxBuffer();

   114 	virtual void DoConfigure();

   115 	virtual TBool AreAnyPending();

   116 	virtual void ReadCancel();

   117 	virtual void WriteCancel();

   118 	virtual void SignalChangeCancel();

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

   120 	void WaitForEvent();

   121 	void DriverCommand(TDriverCommand aCommand);

   122 	void DoWriteComplete(TInt aErr);

   123 	void DoReadComplete(TInt aErr, TInt aBytes);

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

   125 	void DoDataAvailableCompletion();

   126 	void RunCommThread(TDriverCommand aCommand);

   127 	inline void SignalDriverThread();

   128 	inline TBool LineFail();

   129 	

   130 private:

   131 	void ReleaseBuffers();

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

   133 	TBool IsATerminator(TText8 aChar);

   134 	void CompleteRead(TInt aLength);

   135 	void DataAvailableNotificationCancel();

   136 

   137 

   138 private:

   139 	TInt iWritePending;

   140 	TInt iReadPending;

   141 	TBool iStopping;

   142 	TBool iRunning;

   143 	TDriverCommand iCommand;

   144 	TCommConfigV01 *iConfig;

   145 	TUint iSignals;

   146 	TUint iFailSignals;

   147 	TUint iSavedSignals;

   148 	TBool iLineFail;

   149 	TBool iRXLineFail;

   150 	TBool iTXLineFail;

   151 

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

   153 	TInt iInBufLength;

   154 	TPtr8 iInDes;

   155 

   156 	TInt iReadSoFar;

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

   158 

   159 	TUint8 * iOutBufPtr;

   160 	TInt iOutBufLength;

   161 	TPtr8 iOutDes;

   162 

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

   164 							//used to determine xon and xoff levels

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

   166 	TUint iSignalsWanted;		//mask we are asked to check 

   167 	TBool iDataAvailableNotification;

   168 	HANDLE iThread;

   169 	HANDLE iCommThreadSem;

   170 	HANDLE iDriverThreadSem;

   171 	HANDLE iCommPort;

   172 	DWORD iThreadID;

   173 	DWORD iSignalStatus;

   174 	OVERLAPPED iReadOverLapped;

   175 	OVERLAPPED iWriteOverLapped;

   176 	OVERLAPPED iSignalOverLapped;

   177 

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

   179 	TBool		iBreakDetected;

   180 	};

   181 

   182 void Panic(TDCommWinsFault aFault)

   183 //

   184 // Panic the driver 

   185 //

   186 	{

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

   188 	}

   189 

   190 

   191 TUint commThread(DCommWins *comm)

   192 //

   193 // Comm thread entry point

   194 //

   195 	{

   196 

   197 	comm->WaitForEvent();

   198 	return 0;

   199 	}

   200 

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

   202 	{

   203 

   204 	aDrv->DoWriteComplete(aErr);

   205 	}

   206 

   207 

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

   209 	{

   210 

   211 	aDrv->DoReadComplete(aErr, numBytes);

   212 	}

   213 

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

   215 	{

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

   217 	}

   218 

   219 VOID WINAPI DataAvailableCompletion(DCommWins *aDrv)

   220 	{

   221 	aDrv->DoDataAvailableCompletion();

   222 	}

   223 

   224 

   225 

   226 BOOL WINAPI EscapeCommFunctionP(HANDLE hFile,DWORD dwFunc)

   227 	{

   228 	DWORD err;

   229 	DWORD lastError = 0;

   230 	BOOL res;

   231 	COMSTAT s;

   232 	

   233 	do

   234 		{

   235 		ClearCommError(hFile, &err, &s);

   236 		res = EscapeCommFunction(hFile,dwFunc);

   237 		if(!res)

   238 			lastError = GetLastError();

   239 		}

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

   241 

   242 	return(res);

   243 	}

   244 

   245 

   246 BOOL WINAPI GetCommModemStatusP(HANDLE hFile,LPDWORD lpModemStat)

   247 	{

   248 	DWORD err;

   249 	DWORD lastError = 0;

   250 	BOOL res;

   251 	COMSTAT s;

   252 	

   253 	do

   254 		{

   255 		ClearCommError(hFile, &err, &s);

   256 		res = GetCommModemStatus(hFile,lpModemStat);

   257 		if(!res)

   258 			lastError  = GetLastError();

   259 		}

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

   261 

   262 	return(res);

   263 	}

   264 

   265 

   266 BOOL WINAPI GetCommStateP(HANDLE hFile,LPDCB lpDCB)

   267 	{

   268 	DWORD err;

   269 	DWORD lastError = 0;

   270 	BOOL res;

   271 	COMSTAT s;

   272 	

   273 	do

   274 		{

   275 		ClearCommError(hFile,&err,&s);

   276 		res = GetCommState(hFile,lpDCB);

   277 		if (!res)

   278 			lastError = GetLastError();

   279 		}

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

   281 

   282 	return(res);

   283 	}

   284 

   285 BOOL WINAPI SetCommStateP(HANDLE hFile,LPDCB lpDCB)

   286 	{

   287 	DWORD err;

   288 	DWORD lastError = 0;

   289 	BOOL res;

   290 	COMSTAT s;

   291 	

   292 	do

   293 		{

   294 		ClearCommError(hFile, &err, &s);

   295 		res = SetCommState(hFile, lpDCB);

   296 		if (!res)

   297 			lastError = GetLastError();

   298 		}

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

   300 

   301 	return(res);

   302 	}

   303 

   304 BOOL WINAPI SetCommMaskP(HANDLE hFile,DWORD dwEvtMask)

   305 	{

   306 	DWORD err;

   307 	DWORD lastError = 0;

   308 	BOOL res;

   309 	COMSTAT s;

   310 	

   311 	do

   312 		{

   313 		ClearCommError(hFile, &err, &s);

   314 		res = SetCommMask(hFile, dwEvtMask);

   315 		if (!res)

   316 			lastError = GetLastError();

   317 		}

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

   319 

   320 	return(res);

   321 	}

   322 

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

   324 	{

   325 	DWORD err;

   326 	DWORD lastError = 0;

   327 	BOOL res;

   328 	COMSTAT s;

   329 	

   330 	do

   331 		{

   332 		ClearCommError(hFile, &err, &s);

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

   334 		if (!res)

   335 			lastError = GetLastError();

   336 		}

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

   338 

   339 	return(res);

   340 	}

   341 

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

   343 	{

   344 	DWORD err;

   345 	DWORD lastError = 0;

   346 	BOOL res;

   347 	COMSTAT s;

   348 	

   349 	do

   350 		{

   351 		ClearCommError(hFile, &err, &s);

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

   353 		if (!res)

   354 			lastError = GetLastError();

   355 		}

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

   357 

   358 	return(res);

   359 	}

   360 

   361 

   362 

   363 

   364 DDriverComm::DDriverComm()

   365 	{

   366 #if defined (__COM_ONE_ONLY__)

   367 	iUnitsMask=0x1; // Support units 0

   368 #elif defined (__COM_TWO_ONLY__)

   369 	iUnitsMask=0x2; // Support units 1

   370 #else

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

   372 #endif

   373 

   374 	iVersion=TVersion(KCommsMajorVersionNumber,KCommsMinorVersionNumber,KCommsBuildVersionNumber);

   375 	}

   376 

   377 TInt DDriverComm::Install()

   378 	{

   379 #if defined (__COM_ONE_ONLY__)

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

   381 	return(SetName(&buf));

   382 #elif defined (__COM_TWO_ONLY__)

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

   384 	return(SetName(&buf));

   385 #else

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

   387 	return(SetName(&buf));

   388 #endif

   389 	}

   390 

   391 TInt DDriverComm::Remove()

   392 	{

   393 	return(KErrNone);

   394 	}

   395 

   396 

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

   398 //

   399 //	Validate the requested configuration

   400 //

   401 	{

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

   403 		return KErrNotSupported;

   404 #if defined (__COM_ONE_ONLY__)

   405 	if (aUnit!=0)

   406 		return KErrNotSupported;

   407 #elif defined (__COM_TWO_ONLY__)

   408 	if (aUnit!=1)

   409 		return KErrNotSupported;

   410 #endif

   411 	// leave Unit check to CreateFile

   412 	return KErrNone;

   413 	}

   414 

   415 

   416 void GetWinsCommsCaps(TDes8 &aCaps)

   417 	{

   418 	TCommCaps3 capsBuf;

   419 	TCommCapsV03 &c=capsBuf();

   420 //

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

   422 //

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

   424 

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

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

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

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

   429 	c.iSignals=0x3f; // All signals

   430 	c.iSIR=0;//No Ir

   431 	c.iNotificationCaps=KNotifySignalsChangeSupported|KNotifyDataAvailableSupported;

   432 	c.iRoleCaps=0;

   433 	c.iFlowControlCaps=0;

   434 	c.iBreakSupported=ETrue;

   435 	aCaps.FillZ(aCaps.MaxLength());

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

   437 	}

   438 

   439 void DDriverComm::GetCaps(TDes8 &aDes) const

   440 	{

   441 	GetWinsCommsCaps(aDes);

   442 	}

   443 

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

   445 	{

   446 

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

   448 		return KErrNotSupported;

   449 

   450 	DCommWins *pD= new DCommWins;

   451 	if (!pD) return KErrNoMemory;

   452 

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

   454 

   455 	if (ret!=KErrNone)

   456 	{

   457 		delete pD;

   458 		return ret;

   459 	}

   460 	

   461 	aChannel = pD;

   462 

   463 	return KErrNone;

   464 	}

   465 

   466 void DCommWins::DoWriteComplete(TInt aErr)

   467 	{

   468 	iWritePending = 0;

   469 	iTransmitting = EFalse;

   470 	StartOfInterrupt();

   471 	iLdd->iTxError = aErr;

   472 	iLdd->iTxCompleteDfc.Add();

   473 	EndOfInterrupt();

   474 	}

   475 

   476 

   477 

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

   479 	{

   480 	//aValues contains the signal values.  EPOC constants

   481 	//aChanged contains the signals which have changed

   482 	//we return the signal values

   483 	TUint res = aValues & iSignalsWanted;

   484 	res |= (aChanged << 12);

   485 	

   486 	iLdd->iSignalResult = res;

   487 	iLdd->iSignalError = aError;

   488 	StartOfInterrupt();

   489 	iLdd->iSigNotifyDfc.Add();

   490 	EndOfInterrupt();

   491 	}

   492 

   493 void DCommWins::DoDataAvailableCompletion()

   494 	{

   495 	StartOfInterrupt();

   496 	iLdd->iRxDataAvailableDfc.Add();

   497 	EndOfInterrupt();

   498 	}

   499 

   500 

   501 

   502 void DCommWins::CompleteRead(TInt aLength)

   503 	{

   504 	iReadPending = 0;

   505 	iInDes.SetLength(aLength);

   506 	StartOfInterrupt();

   507 	iLdd->iRxCompleteDfc.Add();

   508 	EndOfInterrupt();

   509 	}

   510 

   511 

   512 

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

   514 	{

   515 	iLdd->iRxError = aErr;

   516 	//write back the length and the data

   517 	//process for any terminating characters.

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

   519 	//require reading one char at a time

   520 	if (iTerminatedRead && !aErr)

   521 		{

   522 		__NK_ASSERT_ALWAYS(aBytes <= 1);

   523 		if (aBytes == 0)

   524 			{

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

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

   527 			}

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

   529 			{

   530 			//got them all so complete it

   531 			CompleteRead(iReadSoFar);

   532 			}

   533 		else if (IsATerminator(iInBufPtr[iReadSoFar-1]))	//see if the char just read was the terminator

   534 			{

   535 			//it's a terminated read and we've found one of the terminbators

   536 			CompleteRead(iReadSoFar);

   537 			}

   538 		else if (iReadPending == EReceive)

   539 			{

   540 			//read another character

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

   542 			}

   543 		else

   544 			{

   545 			//it's a receive 1 or more with terminators, we've got 1 so that'll do

   546 			CompleteRead(iReadSoFar);

   547 			}

   548 		}

   549 	else

   550 		{

   551 		CompleteRead(aBytes);

   552 		}

   553 	}

   554 

   555 

   556 

   557 

   558 void DCommWins::RunCommThread(TDriverCommand aCommand)

   559 //

   560 // Wake up the comms thread

   561 //

   562 	{

   563 

   564 	__ASSERT_DEBUG(aCommand!=EInvalidCommand,Panic(EUnknownCommand));

   565 	iCommand=aCommand;

   566 //

   567 // Are we about to go re-entrant?

   568 //

   569 	if(GetCurrentThreadId()==iThreadID)

   570 		{

   571 		DriverCommand(aCommand);

   572 		WaitForSingleObject(iDriverThreadSem,INFINITE);

   573 		}

   574 	else

   575 		{

   576 		Sleep(0); // Possible deadlock solution - see MSDN Knowledge Base Article Q173260

   577 		if (ReleaseSemaphore(iCommThreadSem,1,NULL)==FALSE)

   578 			{

   579 			DWORD ret=GetLastError();

   580 			ret=ret;

   581 			Panic(EWindowsUnexpectedError);

   582 			}

   583 		WaitForSingleObject(iDriverThreadSem,INFINITE);

   584 		}

   585 	}

   586 

   587 inline void DCommWins::SignalDriverThread()

   588 //

   589 // Wake up the comms thread

   590 //

   591 	{

   592 	Sleep(0); // Possible deadlock solution - see MSDN Knowledge Base Article Q173260

   593 	if (ReleaseSemaphore(iDriverThreadSem,1,NULL)==FALSE)

   594 		{

   595 		DWORD ret=GetLastError();

   596 		ret=ret;

   597 		Panic(EWindowsUnexpectedError);

   598 		}

   599 	}

   600 

   601 

   602 

   603 //

   604 #pragma warning( disable : 4705 )	// statement has no effect

   605 DCommWins::DCommWins() :  iOutDes(0,0), iInDes(0,0), iRxBufferSize(KDefaultWinNTReadBufSize), iSignalsRequested(0)

   606 	{

   607 	__DECLARE_NAME(_S("DCommWins"));

   608 	}

   609 #pragma warning( default : 4705 )

   610 

   611 TInt DCommWins::DoCreate(TInt aUnit,const TDesC8 * /*aInfo*/)

   612 //

   613 // Create the comms driver.

   614 //

   615 	{

   616 

   617 #if defined (__COM_ONE_ONLY__)

   618 	if (aUnit!=0)

   619 		return KErrNotSupported;

   620 #elif defined (__COM_TWO_ONLY__)

   621 	if (aUnit!=1)

   622 		return KErrNotSupported;

   623 #endif

   624 

   625 	TBuf8<0x10> n;

   626 	n.Append(KComName);

   627 	n.AppendNum(aUnit+1);

   628 	n.Append('\0');

   629 

   630 	iCommPort=CreateFileA((LPCSTR)n.Ptr(),GENERIC_READ|GENERIC_WRITE,0,NULL,OPEN_EXISTING,FILE_FLAG_OVERLAPPED,NULL);

   631 	if (iCommPort==INVALID_HANDLE_VALUE)	

   632 		{	

   633 	//	Reused code from Emulator::LastError() rather than adding an extra case 

   634 	//	to Emulator::LastError() because mapping KErrNotSupported to the returned

   635 	//	FILE_NOT_FOUND is non-intuitive and special to this case only

   636 		DWORD winErr=GetLastError();

   637 		switch (winErr)

   638 			{

   639 			case ERROR_INVALID_USER_BUFFER:

   640 			case ERROR_NOT_ENOUGH_MEMORY:

   641 			case ERROR_INSUFFICIENT_BUFFER:

   642 				return(KErrNoMemory);

   643 			case ERROR_ACCESS_DENIED:

   644 				return(KErrAccessDenied);

   645 			case ERROR_FILE_NOT_FOUND:		//	Reflects value returned by

   646 				return(KErrNotSupported);	//	corresponding MARM Pdd  

   647 			case ERROR_NOT_SUPPORTED:

   648 				return(KErrNotSupported);

   649 			default:

   650 				return(KErrGeneral);

   651 			}

   652 		}

   653 	

   654 

   655 	//create the buffers.

   656 	//the buffers need to be as big as the client will ever use.  8mb reserved, but commit less

   657 	iInBufPtr = (TUint8*)VirtualAlloc(NULL, KSerialBufferMaxSize,MEM_RESERVE | MEM_TOP_DOWN, PAGE_READWRITE);

   658 	if (!iInBufPtr)

   659 		return(Emulator::LastError());

   660 

   661 	//commit the first bit of the buffer

   662 	if (!VirtualAlloc(iInBufPtr, KSerialBufferInitialSize, MEM_COMMIT,PAGE_READWRITE))

   663 		return(Emulator::LastError());

   664 

   665 	iInBufLength = KSerialBufferInitialSize;

   666 	iInDes.Set(iInBufPtr, 0, iInBufLength);

   667 

   668 	//reserve address space for the output buffer

   669 	iOutBufPtr = (TUint8*)VirtualAlloc(NULL, KSerialBufferMaxSize,MEM_RESERVE | MEM_TOP_DOWN, PAGE_READWRITE);

   670 	if (!iOutBufPtr)

   671 		return(Emulator::LastError());

   672 

   673 	//commit a smaller region of it

   674 	if (!VirtualAlloc(iOutBufPtr, KSerialBufferInitialSize, MEM_COMMIT,PAGE_READWRITE))

   675 		return(Emulator::LastError());

   676 

   677 	iOutBufLength = KSerialBufferInitialSize;

   678 	iOutDes.Set(iOutBufPtr, 0, iOutBufLength);

   679 	

   680 	DCB dcb;

   681 	//set the dcb size

   682 	dcb.DCBlength = sizeof(dcb);

   683 	if (!GetCommStateP(iCommPort,&dcb))

   684 		return(Emulator::LastError());

   685 

   686 	EscapeCommFunctionP(iCommPort,0);

   687 

   688 //

   689 	if (!SetCommMaskP(iCommPort,EV_BREAK|EV_CTS|EV_ERR|EV_DSR|EV_RLSD|EV_RXCHAR|EV_RING))

   690 		return(Emulator::LastError());

   691 

   692 	if(!SetupComm(iCommPort,KDefaultWinNTReadBufSize,KDefaultWinNTWriteBufSize))

   693 		return(Emulator::LastError());

   694 

   695 	if ((iCommThreadSem=CreateSemaphoreA(NULL,0,0x7fffffff,NULL))==NULL)

   696 		return(Emulator::LastError());

   697 

   698 	if ((iDriverThreadSem=CreateSemaphoreA(NULL,0,0x7fffffff,NULL))==NULL)

   699 		return(Emulator::LastError());

   700 

   701 //

   702 // The serial port seems to open with the error condition set

   703 //

   704 

   705 	DWORD err,res;

   706 	COMSTAT s;

   707 	if (ClearCommError(iCommPort,&err,&s)==FALSE)

   708 		res=GetLastError();

   709 

   710 	if ((iThread=CreateWin32Thread(EThreadEvent,(LPTHREAD_START_ROUTINE)commThread,(void *)this, FALSE))==NULL)

   711 		return(Emulator::LastError());

   712 

   713 	SetThreadPriority(iThread,THREAD_PRIORITY_HIGHEST);

   714 	return(KErrNone);

   715 	}

   716 

   717 

   718 	

   719 void DCommWins::ReleaseBuffers()

   720 	{

   721 	if (iInBufPtr)

   722 		{

   723 		//decommit the buffer

   724 		VirtualFree(iInBufPtr,KSerialBufferMaxSize, MEM_DECOMMIT);

   725 		//and release the region

   726 		VirtualFree(iInBufPtr, NULL, MEM_RELEASE);

   727 		iInBufPtr = NULL;

   728 		}

   729 	if (iOutBufPtr)

   730 		{

   731 		VirtualFree(iOutBufPtr,KSerialBufferMaxSize, MEM_DECOMMIT);

   732 		VirtualFree(iOutBufPtr, NULL, MEM_RELEASE);

   733 		iOutBufPtr = NULL;

   734 		}

   735 	}

   736 	

   737 

   738 DCommWins::~DCommWins()

   739 	{

   740 	if (iThread)

   741 		{

   742 		if (! iRunning)

   743 			{

   744 			__ASSERT_ALWAYS(

   745 				ResumeThread(iThread) != 0xffffffff,

   746 				Panic(EWindowsUnexpectedError)); 

   747 			}

   748 

   749 		iRunning=ETrue;

   750 		RunCommThread(EDie);

   751 		}

   752 

   753 	if (iCommPort)

   754 		CloseHandle(iCommPort);

   755 

   756 	if (iDriverThreadSem)

   757 		CloseHandle(iDriverThreadSem);

   758 

   759 	if (iCommThreadSem)

   760 		CloseHandle(iCommThreadSem);

   761 

   762 	if (iReadOverLapped.hEvent)

   763 		CloseHandle(iReadOverLapped.hEvent);

   764 

   765 	if (iWriteOverLapped.hEvent)

   766 		CloseHandle(iWriteOverLapped.hEvent);

   767 

   768 	if (iSignalOverLapped.hEvent)

   769 		CloseHandle(iSignalOverLapped.hEvent);

   770 

   771 	if (iThread)

   772 		CloseHandle(iThread);

   773 

   774 	//free up the memory

   775 	ReleaseBuffers();

   776 	}

   777 

   778 TInt DCommWins::Start()

   779 	{

   780 

   781 	__ASSERT_ALWAYS(ResumeThread(iThread)!=0xffffffff,Panic(EWindowsUnexpectedError));

   782 	iRunning=ETrue;

   783 	RunCommThread(EStart);

   784 	return(KErrNone);

   785 	}

   786 

   787 void DCommWins::Stop(TStopMode aMode)

   788 	{

   789 

   790 	RunCommThread((aMode==EStopEmergency) ? EStopNoDrain : EStop);

   791 	SuspendThread(iThread);

   792 	iRunning=EFalse;

   793 	}

   794 

   795 void DCommWins::Break(TBool aState)

   796 //

   797 // Assert a break signal

   798 //

   799 	{

   800 	if (aState)

   801 		RunCommThread(ESetBreak);

   802 	else

   803 		RunCommThread(EClearBreak);

   804 	}

   805 

   806 

   807 

   808 TInt DCommWins::RxCount()

   809 	{

   810 	DWORD err =0;

   811 	COMSTAT stat;

   812 	if (ClearCommError(iCommPort,&err, &stat))

   813 		return stat.cbInQue;

   814 	else

   815 		return Emulator::LastError();

   816 	}

   817 

   818 

   819 void DCommWins::ResetBuffers(TBool aTx)

   820 	{

   821 	PurgeComm(iCommPort, PURGE_RXCLEAR | (aTx ? PURGE_TXCLEAR : 0));

   822 	}

   823 

   824 

   825 TBool DCommWins::AreAnyPending()

   826 	{

   827 	return (iReadPending != 0) || (iWritePending != 0);

   828 	}

   829 

   830 

   831 void DCommWins::WriteCancel()

   832 	{

   833 	DriverCommand(ETransmitCancel);

   834 	}

   835 

   836 

   837 void DCommWins::ReadCancel()

   838 	{

   839 	DriverCommand(EReceiveCancel);

   840 	}

   841 

   842 void DCommWins::SignalChangeCancel()

   843 	{

   844 	if (iSignalsRequested)

   845 		{

   846 		iSignalsRequested = 0;

   847 		}

   848 

   849 	}

   850 

   851 void DCommWins::DataAvailableNotificationCancel()

   852 	{

   853 	if (iDataAvailableNotification)

   854 		{

   855 		iDataAvailableNotification = EFalse;

   856 		iLdd->iRxDAError = KErrCancel;

   857 		iLdd->iRxDataAvailableDfc.Enque();

   858 		}

   859 	}

   860 

   861 TDes8* DCommWins::RxBuffer()

   862 	{

   863 	return &iInDes;

   864 	}

   865 

   866 TInt DCommWins::SetRxBufferSize(TInt aSize)

   867 	{

   868 	aSize += aSize&1;	//round up to multiple of 2 bytes as windows complains if odd

   869 	TInt ret = SetupComm(iCommPort, aSize, KDefaultWinNTWriteBufSize);

   870 	if (ret)

   871 		{

   872 		iRxBufferSize = aSize;

   873 		

   874 		DCB dcb = {0};

   875 		dcb.DCBlength = sizeof(dcb);

   876 		

   877 		if (!GetCommStateP(iCommPort,&dcb))

   878 			return Emulator::LastError();

   879 

   880 		//use rx buffer size to configure xon/xoff limits

   881 		dcb.XoffLim = (WORD)(iRxBufferSize / 4);		//25%

   882 		if (iConfig->iParityError & KConfigXonXoffDebug)

   883 			dcb.XonLim = (WORD)((iRxBufferSize / 2) -5);	//50%-5

   884 		else

   885 			dcb.XonLim = (WORD)((iRxBufferSize / 4) * 3);	//75%

   886 

   887 		if (!SetCommStateP(iCommPort,&dcb))

   888 			return Emulator::LastError();

   889 

   890 		return KErrNone;

   891 		}

   892 	return Emulator::LastError();

   893 	}

   894 

   895 

   896 TInt DCommWins::RxBufferSize()

   897 	{

   898 	return iRxBufferSize;

   899 	}

   900 

   901 

   902 TBool DCommWins::IsATerminator(TText8 aChar)

   903 	{

   904 	TInt x;

   905 	for (x=0; x < iConfig->iTerminatorCount; x++)

   906 		if (aChar == iConfig->iTerminator[x])

   907 			return ETrue;

   908 	return EFalse;

   909 	}

   910 

   911 

   912 void DCommWins::ReSizeBuffer(TUint8*& aBuf, TInt& aBufLen, TPtr8& aDes, const TInt aNewLen)

   913 	{

   914 

   915 	if (aNewLen > KSerialBufferMaxSize)

   916 		Panic(ESerialBufferTooBig);

   917 

   918 	aBufLen = ((aNewLen + KSerialBufferIncrementSize-1) / KSerialBufferIncrementSize) * KSerialBufferIncrementSize;

   919 

   920 	if (aBufLen > KSerialBufferMaxSize)

   921 		aBufLen = KSerialBufferMaxSize;

   922 

   923 	if (!VirtualAlloc(aBuf, aBufLen, MEM_COMMIT,PAGE_READWRITE))

   924 		{

   925 		ReleaseBuffers();

   926 		Panic(ESerialBufferTooBig);

   927 		}

   928 	aDes.Set(aBuf, 0, aBufLen);

   929 	}

   930 

   931 

   932 void DCommWins::Write(DThread* aThread, TAny* aSrc, TInt aLength)

   933 

   934 	{

   935 	if (aLength==0)

   936 		{

   937 		RunCommThread(ETransmit0);

   938 		}

   939 	else

   940 		{

   941 		if (aLength > iOutBufLength)

   942 			ReSizeBuffer(iOutBufPtr, iOutBufLength, iOutDes, aLength);

   943 

   944 		//copy the data from the client

   945 		Kern::ThreadDesRead(aThread, aSrc, iOutDes, 0,0);

   946 		iOutDes.SetLength(aLength);

   947 		//tell the comms thread to write the data

   948 		RunCommThread(ETransmit);

   949 		}

   950 	}

   951 

   952 void DCommWins::NotifySignals(DThread* /*aThread*/, TInt aMask)

   953 	{

   954 	iSignalsWanted = aMask;

   955 	RunCommThread(ENotifySignals);

   956 	}

   957 

   958 

   959 void DCommWins::NotifyDataAvailable()

   960 	{

   961 	RunCommThread(ENotifyDataAvailable);

   962 	}

   963 

   964 

   965 void DCommWins::Read(DThread* /*aThread*/, TAny* /*aDest*/, TInt aLength)

   966 

   967 	{

   968 	TDriverCommand command;

   969 

   970 	if (aLength < 0)

   971 		{

   972 		iClientReadLength = Abs(aLength);

   973 		command = EReceiveOneOrMore;

   974 		}

   975 	else

   976 		{

   977 		iClientReadLength = aLength;

   978 		command = EReceive;

   979 		}

   980 

   981 	if (iClientReadLength > iInBufLength)

   982 		ReSizeBuffer(iInBufPtr, iInBufLength, iInDes, iClientReadLength);

   983 	

   984 	//tell the comms thread to read the data

   985 	RunCommThread(command);

   986 	}

   987 

   988 

   989 

   990 

   991 

   992 TUint DCommWins::Signals() const

   993 	{

   994 

   995 	ULONG signals=0;

   996 	GetCommModemStatusP(iCommPort,&signals);

   997 	TUint status=0;

   998 	if (signals&MS_CTS_ON)

   999 		status|=KSignalCTS;

  1000 	if (signals&MS_DSR_ON)

  1001 		status|=KSignalDSR;

  1002 	if (signals&MS_RING_ON)

  1003 		status|=KSignalRNG;

  1004 	if (signals&MS_RLSD_ON)

  1005 		status|=KSignalDCD;

  1006 	return(status|iSignals);

  1007 	}

  1008 

  1009 

  1010 void DCommWins::SetSignals(TUint aSetMask,TUint aClearMask)

  1011 	{

  1012 	if (aSetMask&KSignalRTS)

  1013 		{

  1014 		iSignals|=KSignalRTS;

  1015 		EscapeCommFunctionP(iCommPort,SETRTS);

  1016 		}

  1017 	if (aSetMask&KSignalDTR)

  1018 		{

  1019 		iSignals|=KSignalDTR;

  1020 		EscapeCommFunctionP(iCommPort,SETDTR);

  1021 		}

  1022 	if (aClearMask&KSignalRTS)

  1023 		{

  1024 		iSignals&=(~KSignalRTS);

  1025 		EscapeCommFunctionP(iCommPort,CLRRTS);

  1026 		}

  1027 	if (aClearMask&KSignalDTR)

  1028 		{

  1029 		iSignals&=(~KSignalDTR);

  1030 		EscapeCommFunctionP(iCommPort,CLRDTR);

  1031 		}

  1032 	}

  1033 

  1034 

  1035 

  1036 void DCommWins::CheckConfig(TCommConfigV01& /*aConfig*/)

  1037 	{

  1038 	// Do nothing

  1039 	}

  1040 

  1041 

  1042 

  1043 void DCommWins::Configure(TCommConfigV01 &aConfig)

  1044 //

  1045 // Ask comm thread to set up the serial port

  1046 //

  1047 	{

  1048 

  1049 	iConfig=&aConfig;

  1050 	if (iRunning)

  1051 		{

  1052 		RunCommThread(EConfigure);

  1053 		}

  1054 	else

  1055 		{

  1056 //		iCommand=EConfigure;

  1057 		DoConfigure();

  1058 		}

  1059 	}

  1060 

  1061 void DCommWins::DoConfigure()

  1062 //

  1063 // Set up the serial port

  1064 //

  1065 	{

  1066 

  1067 	DCB dcb = {0};

  1068 	//set the dcb size

  1069 	dcb.DCBlength = sizeof(dcb);

  1070 	if (!GetCommStateP(iCommPort,&dcb))

  1071 		return;

  1072 

  1073 			

  1074 	//stop if an error happens

  1075 	dcb.fAbortOnError = TRUE;

  1076 	

  1077 	//baud rate

  1078 	switch (iConfig->iRate)

  1079 		{

  1080 	case EBps75:

  1081 		dcb.BaudRate=75;

  1082 		break;

  1083 	case EBps110:

  1084 		dcb.BaudRate=110;

  1085 		break;

  1086 	case EBps134:

  1087 		dcb.BaudRate=134;

  1088 		break;

  1089 	case EBps150:

  1090 		dcb.BaudRate=150;

  1091 		break;

  1092 	case EBps300:

  1093 		dcb.BaudRate=300;

  1094 		break;

  1095 	case EBps600:

  1096 		dcb.BaudRate=600;

  1097 		break;

  1098 	case EBps1200:

  1099 		dcb.BaudRate=1200;

  1100 		break;

  1101 	case EBps1800:

  1102 		dcb.BaudRate=1800;

  1103 		break;

  1104 	case EBps2400:

  1105 		dcb.BaudRate=2400;

  1106 		break;

  1107 	case EBps4800:

  1108 		dcb.BaudRate=4800;

  1109 		break;

  1110 	case EBps7200:

  1111 		dcb.BaudRate=7200;

  1112 		break;

  1113 	case EBps9600:

  1114 		dcb.BaudRate=9600;

  1115 		break;

  1116 	case EBps19200:

  1117 		dcb.BaudRate=19200;

  1118 		break;

  1119 	case EBps38400:

  1120 		dcb.BaudRate=38400;

  1121 		break;

  1122 	case EBps57600:

  1123 		dcb.BaudRate=57600;

  1124 		break;

  1125 	case EBps115200:

  1126 		dcb.BaudRate=115200;

  1127 		break;

  1128 		}

  1129    

  1130 	switch (iConfig->iParity)

  1131 		{

  1132 	case EParityNone:

  1133 		dcb.Parity=NOPARITY;

  1134 		dcb.fParity = FALSE;

  1135 		break;