diff -r 000000000000 -r dfb7c4ff071f serialserver/c32serialserver/Test/TE_C32/dummy.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/serialserver/c32serialserver/Test/TE_C32/dummy.h Thu Dec 17 09:22:25 2009 +0200 @@ -0,0 +1,374 @@ +// 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: +// + +#ifndef DUMMY_H__ +#define DUMMY_H__ + +/** @file + * + * Dummy CSY for testing. + */ + +#include +#include + +const TInt KDummyCompleteDelayFast = 600000L; +const TInt KDummyCompleteDelaySlow = 1200000L; + +const TInt KDummy12ReadWait=28000000; + +class CDummyPort; +class CDummyCompleter; + +_LIT8(KC32LoggingName,"C32SerComms"); + +/* +* Macros are defined in respective mmp files for different csys +*/ + +#if defined(DUMMYCSY1) + #define SERIAL_DESCRIPTION _L("DummyCsy1 3 wire raw") //< CSY description + #define SERIAL_NAME _S("DummyCsy1") //< name of prefix for each com port + _LIT8(KCSYLoggingName,"DummyCsy1"); +#elif defined(DUMMYCSY2) + #define SERIAL_DESCRIPTION _L("DummyCsy2 3 wire raw") + #define SERIAL_NAME _S("DummyCsy2") + _LIT8(KCSYLoggingName,"DummyCsy2"); +#elif defined(DUMMYCSY3) + #define SERIAL_DESCRIPTION _L("DummyCsy3 3 wire raw") + #define SERIAL_NAME _S("DummyCsy3") + _LIT8(KCSYLoggingName,"DummyCsy3"); +#elif defined(DUMMYCSY4) + #define SERIAL_DESCRIPTION _L("DummyCsy4 3 wire raw") + #define SERIAL_NAME _S("DummyCsy4") + _LIT8(KCSYLoggingName,"DummyCsy4"); +#elif defined(DUMMYCSY5) + #define SERIAL_DESCRIPTION _L("DummyCsy5 3 wire raw") + #define SERIAL_NAME _S("DummyCsy5") + _LIT8(KCSYLoggingName,"DummyCsy5"); +#elif defined(DUMMYCSY6) + #define SERIAL_DESCRIPTION _L("DummyCsy6 3 wire raw") + #define SERIAL_NAME _S("DummyCsy6") + _LIT8(KCSYLoggingName,"DummyCsy6"); +#elif defined(DUMMYCSY7) + #define SERIAL_DESCRIPTION _L("DummyCsy7 3 wire raw") + #define SERIAL_NAME _S("DummyCsy7") + _LIT8(KCSYLoggingName,"DummyCsy7"); +#elif defined(DUMMYCSY8) + #define SERIAL_DESCRIPTION _L("DummyCsy8 3 wire raw") + #define SERIAL_NAME _S("DummyCsy8") + _LIT8(KCSYLoggingName,"DummyCsy8"); +#elif defined(DUMMYCSY9) + #define SERIAL_DESCRIPTION _L("DummyCsy9 3 wire raw") + #define SERIAL_NAME _S("DummyCsy9") + _LIT8(KCSYLoggingName,"DummyCsy9"); +#elif defined(DUMMYCSY10) + #define SERIAL_DESCRIPTION _L("DummyCsy10 3 wire raw") + #define SERIAL_NAME _S("DummyCsy10") + _LIT8(KCSYLoggingName,"DummyCsy10"); +#elif defined(DUMMYCSY12) + #define SERIAL_DESCRIPTION _L("DummyCsy12 3 wire raw") + #define SERIAL_NAME _S("DummyCsy12") + _LIT8(KCSYLoggingName,"DummyCsy12"); + /* + KMaxBlockingTestWrites = 4; + attempt to perform four read/write operation in loopback while waiting for blocking dummy12, + 4 being enough to simulate quite a bit of "work". + + KMicroSecWaitBetnLoopbackWrites = 1000000; + 1 sec is reasonable time to wait between loopback writes + to ensure processing interference is miniscule + + KMaxExpectedLoopbackWriteTime = + KMicroSecWaitBetnLoopbackWrites * KMaxBlockingTestWrites; + 1000000 * 4 = 4000000 + + KDummy12ReadWaitContingency = 2 * KMicroSecWaitBetnLoopbackWrites; + allow 2 extra wait times for loopback writes to complete before releasing dummy12 to compensate for any processing time + 2 * 1000000 = 2000000 + + //KDummy12ReadWait = KMaxExpectedLoopbackWriteTime + KDummy12ReadWaitContingency; + // dummy12 waits about 6 seconds + // 4000000 + 2000000 = 6000000 + const TInt KDummyCompleteDelayFast = 600000L; + const TInt KDummyCompleteDelaySlow = 1200000L; + + KDummy12ReadWait=(KDummyCompleteDelayFast * KMaxBlockingTestWrites) + + (KDummy12ReadWaitContingency * 2); + + 600000 * 4 + (200000 * 2) = 2800000 + */ + +#elif defined(DUMMYCSY15) + #define SERIAL_DESCRIPTION _L("DummyCsy15 3 wire raw") + #define SERIAL_NAME _S("DummyCsy15") + _LIT8(KCSYLoggingName,"DummyCsy15"); +#elif defined(DUMMYCSY16) + #define SERIAL_DESCRIPTION _L("DummyCsy16 3 wire raw") + #define SERIAL_NAME_SMALL _S("DummyCsy16") + #define SERIAL_NAME _S("DummyCsy16LongPortNameeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee") + _LIT8(KCSYLoggingName,"DummyCsy16"); +#elif defined(DUMMYCSY17) + #define SERIAL_DESCRIPTION _L("DummyCsy17 3 wire raw") + #define SERIAL_NAME _S("DummyCsy17") + _LIT8(KCSYLoggingName,"DummyCsy17"); +#else + #define SERIAL_DESCRIPTION _L("Dummy 3 wire raw") // default c32 dummy csy + #define SERIAL_NAME _S("Dummy") + _LIT8(KCSYLoggingName,"Dummy"); +#endif + +_LIT8(testbufRead, "0123456789abcdefghijklmnopqrstuvxyxABCDEFGHIJKLMNOPQRSTUVXYZ[]\r\n"); +_LIT8(testbufWrite, "This string has to be exactly like this othervice write returns KErrCommsLineFail."); + +const TInt PORT_0_NOCAPS = 0; +const TInt PORT_1_NETWORKSERVICES = 1; +const TInt PORT_2_NOTSUPPORT = 2; +const TInt PORT_3_ALLCAPS = 3; +const TInt PORT_6_NOCAPS = 6; + +/** +unique numbers used for message passing between +client and C32 comms server. +@internalAll +*/ +enum TCommMess +{ + ECommLoadCommModule, //< 0 Load a CSY comms module + ECommCloseCommModule, //< 1 Unload a CSY comms module + ECommPortInfo, + ECommPortInfoByName, //< 3 Get information on serial ports by name + ECommPortInfoByNumber, //< 4 Get information on serial ports by number + ECommNumPorts, //< 5 Get how many CSY's are loaded + ECommStartServerThread, //< 6 Start another thread in the C32 process + ECommOpen, //< 7 Open a comm port + ECommRead, //< 8 Read from the comm port + ECommReadCancel, //< 9 Cancel an outstanding read + ECommQueryReceiveBuffer, //< 10 Get number of bytes in received buffer + + ECommResetBuffers, //< 11 Reset the serial port buffers + ECommWrite, //< 12 Write to the comm port + ECommWriteCancel, //< 13 Cancel an outstanding write + ECommBreak, //< 14 Send a break + ECommBreakCancel, //< 15 Cancel sending of break + ECommCancel, //< 16 Cancel any outstanding reads or writes + ECommConfig, //< 17 Get comm port configuration + ECommSetConfig, //< 18 Set comm port configuration + ECommCaps, //< 19 Get the capabilities of the comm port + ECommSetMode, //< 20 Set server buffering mode + + ECommGetMode, //< 21 Get server buffering mode + ECommSignals, //< 22 Read serial port control lines + ECommSetSignalsToMark, //< 23 Set control lines high (1) + ECommSetSignalsToSpace, //< 24 Set control line low (0) + ECommReceiveBufferLength, //< 25 Get the size of the receive buffer + ECommSetReceiveBufferLength, //< 26 Set the size of the receive buffer + ECommClose, //< 27 Close the comm port + ECommDbgMarkHeap, //< 28 Set a heap mark in the Comms server + ECommDbgCheckHeap, //< 29 Check the heap mark in the Comms server + ECommDbgMarkEnd, //< 30 Set the heap mark end in the Comms server + + ECommDbgFailNext, //< 31 Emulate fail next heap allocation in the comm server + ECommDbgSetDebugPrintMask, //< 32 Set the debug print mask + ECommDbgDoDumpDebugInfo, //< 33 Dump debug info + + // Here starts version 02 extensions + ECommGetRole, //< 34 Get the current role + ECommNotifySignals, //< 35 Notify when signals change + ECommNotifySignalsCancel, //< 36 Cancel an outstanding signals notify + ECommNotifyFlowControl, //< 37 Notify when flow control changes + ECommNotifyFlowControlCancel, //< 38 Cancel an outstanding flow control notify + ECommGetFlowControl, //< 39 Get the current status of flow control + ECommNotifyConfigChange, //< 40 Notify when config change + + ECommNotifyConfigChangeCancel, //< 41 Cancel an outstanding config notify + ECommNotifyBreak, //< 42 Send break + ECommNotifyBreakCancel, //< 43 Cancel an outstanding sending of break + ECommNotifyDataAvailable, //< 44 Notify when data available in Rx buffer + ECommNotifyDataAvailableCancel, //< 45 Cancel an outstanding notify data available + ECommNotifyOutputEmpty, //< 46 Notify when Tx buffer is empty + ECommNotifyOutputEmptyCancel, //< 47 Cancel an outstanding output empty notify + // Here ends version 02 extensions + + ECommSetAccess, //< 48 Set the access mode defined by TCommAccess + ECommDebugState, //< 49 Get the debug state + ECommOpenWhenAvailable //< 50 Open port when it is available + }; + + +/** + * a dummy class for completing asynchronour requests + */ +class CDummyCompleter : public CActive + { + public: + // construction + CDummyCompleter(CDummyPort& aPort); + + // destruction + ~CDummyCompleter(); + + // Completes async call + void Complete(TCommMess aMess, TTimeIntervalMicroSeconds32 anInterval, TInt aReason, TUint aValue = 0); + void Complete(TCommMess aMess, TTimeIntervalMicroSeconds32 anInterval, TInt aReason, const TDesC8& aDescriptor); + void CancelComplete(); + + private: + void DoCancel(); /* stop object activity */ + void RunL(); /* active object callback */ + + private: + TCommMess iMess; + RTimer iTimer; + CDummyPort& iPort; + TInt iReason; + TUint iValue; + TCommNotificationV01 iPeerConfig; + + }; + + +/** + * "Entry point object" makes the objects which do the work + */ +class CDummyPortFactory : public CSerial + { + enum {KMajorVersion=1,KMinorVersion=0,KBuild=92}; +public: + static CDummyPortFactory* NewL(); + virtual CPort * NewPortL(const TUint aUnit); + virtual void Info(TSerialInfo &aSerialInfo); +#ifdef DUMMYCSY10 + void LoadAnotherCSY(); +#endif +#ifdef DUMMYCSY17 + void LoadAnotherCSYNoClose(); +#endif + +public: //CSerial + TSecurityPolicy PortPlatSecCapability(TUint aPort) const; +private: + void ConstructL(); + CDummyPortFactory(); + }; + + +/** + * CPort is the object which interfaces to the commserver + */ +class CDummyPort : public CPort + { +public: + static CDummyPort * NewL(TUint aUint); +public: + virtual void StartRead(const TAny *aClientBuffer,TInt aLength); + virtual void ReadCancel(); + virtual TInt QueryReceiveBuffer(TInt& aLength) const; + virtual void ResetBuffers(TUint aFlags); + virtual void StartWrite(const TAny *aClientBuffer,TInt aLength); + virtual void WriteCancel(); + virtual void Break(TInt aTime); + virtual void BreakCancel(); + virtual TInt GetConfig(TDes8& aPackage) const; + virtual TInt SetConfig(const TDesC8& aPackage); + virtual TInt SetServerConfig(const TDesC8& aPackage); + virtual TInt GetServerConfig(TDes8& aPackage); + virtual TInt GetCaps(TDes8& aPackage); + virtual TInt GetSignals(TUint& aSignals); + virtual TInt SetSignalsToMark(TUint aSignals); + virtual TInt SetSignalsToSpace(TUint aSignals); + virtual TInt GetReceiveBufferLength(TInt& aLength) const; + virtual TInt SetReceiveBufferLength(TInt aLength); + virtual ~CDummyPort(); + + // Version 02 additions to IrCOMM starts from here + virtual void NotifySignalChange(TUint aSignalMask); + virtual void NotifySignalChangeCancel(); + virtual void NotifyConfigChange(); + virtual void NotifyConfigChangeCancel(); + virtual void NotifyFlowControlChange(); + virtual void NotifyFlowControlChangeCancel(); + virtual void NotifyBreak(); + virtual void NotifyBreakCancel(); + virtual void NotifyDataAvailable(); + virtual void NotifyDataAvailableCancel(); + virtual void NotifyOutputEmpty(); + virtual void NotifyOutputEmptyCancel(); + virtual TInt GetFlowControlStatus(TFlowControl& aFlowControl); + virtual TInt GetRole(TCommRole& aRole); + virtual TInt SetRole(TCommRole aRole); + // Version 02 additions to IrCOMM ends to here + + void Destruct(); + +private: + CDummyPort(); + void ConstructL(TUint aUint); + +private: + + TUint iBufFlags; //< buffer flags + TInt iBufSize; //< buffer size + + TInt iBreakDelay; //< time of break delay + + TUint8* iDataIn; //< pointer to data in buffer + TPtr8 iPtrDataIn; //< descriptor pointer to data in buffer + + TUint8* iDataOut; //< pointer to data out buffer + TPtr8 iPtrDataOut; //< descriptor pointer to data out buffer + + TUint8* iCompData; //< pointer to compare data + TPtr8 iPtrCompData; //< descriptor pointer to compare data + + TAny* iClientPtr; //< pointer to client buffer + TInt iClientLength; //< length of client buffer + TInt iLength; //< length count of client buffer + TUint iSignals; //< RS232 signals + TCommConfigV01 iConfig; //< port configuration + TDeltaTimerEntry iBreakTimer; //< break timer entry + TCommRole iRole; //< current role, DTE or DCE + TUint iNotifySignalMask; //< signals notification mask + TFlowControl iFlowControl; //< flow control settings + TPckg *iCapsPtr; //< pointer to capabilities package + TCommNotificationV01 iPeerConfig; //< peer configuration + CDummyCompleter *iCompleteSigPtr; //< pointer to signal completer + CDummyCompleter *iCompleteFlowPtr; //< pointer to flow control completer + CDummyCompleter *iCompleteConfPtr; //< pointer to configuration completer + CDummyCompleter *iCompleteCapsPtr; //< pointer to capabilities completer + CDummyCompleter *iCompleteReadPtr; //< pointer to data read completer + CDummyCompleter *iCompleteWritePtr; //< pointer to data write completer + CDummyCompleter *iCompleteSetBreakPtr; //< pointer to set break completer + CDummyCompleter *iCompleteBreakPtr; //< pointer to break completer + CDummyCompleter *iCompleteDataAvailablePtr; //< pointer to data available completer + CDummyCompleter *iCompleteOutputEmptyPtr; //< pointer to output empty completer + CDummyCompleter *iCompleteClosePtr; //< pointer to close completer + + TTimeIntervalMicroSeconds32 iDummyCompleteDelayFast; //< fast complete delay + TTimeIntervalMicroSeconds32 iDummyCompleteDelaySlow; //< slow complete delay + }; + +/** + * faults in the CSY + */ +enum TCSYFaults + { + E_ParametersCorrupted, //< wrong parameter + E_UnknownAsynchronousCall //< not used + }; + + +#endif // DUMMY_H__ +