--- /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 <cs_port.h>
+#include <comms-infras/commsdebugutility.h>
+
+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<TCommCapsV02> *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__
+