// 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__