--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/e32test/hcr/d_hcrsim.cpp Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,661 @@
+// 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:
+// e32test/hcr/d_hcrsim.cpp
+//
+
+#include "d_hcrsim.h"
+#include <kernel/kernel.h>
+#include <plat_priv.h>
+#include "hcr_debug.h"
+#include "hcr_hai.h"
+#include "hcr_pil.h"
+
+#define TEST(a) CheckPoint(a, __LINE__)
+#define TEST_KERRNONE(a) CheckPointError(a, __LINE__)
+
+TInt InitExtension();
+extern TUint32 PslConfigurationFlags;
+
+class DHcrSimTestDrvFactory : public DLogicalDevice
+ {
+public:
+ DHcrSimTestDrvFactory();
+ ~DHcrSimTestDrvFactory();
+ virtual TInt Install();
+ virtual void GetCaps(TDes8& aDes) const;
+ virtual TInt Create(DLogicalChannelBase*& aChannel);
+public:
+ TDynamicDfcQue* iDfcQ;
+ };
+
+class DHcrSimTestDrvChannel : public DLogicalChannel
+ {
+public:
+ DHcrSimTestDrvChannel();
+ ~DHcrSimTestDrvChannel();
+ // Inherited from DLogicalChannel
+ virtual TInt DoCreate(TInt aUnit, const TDesC8* anInfo, const TVersion& aVer);
+ TInt DoControl(TInt aReqNo, TAny* a1, TAny* a2);
+ virtual void HandleMsg(TMessageBase* aMsg);
+public:
+ DThread* iClient;
+ };
+
+void CheckPoint(TInt aCondition, TInt aLine)
+ {
+ if (!aCondition)
+ {
+ Kern::Printf("Device driver test failed (line %d)", aLine);
+ }
+ }
+
+void CheckPointError(TInt aErrorCode, TInt aLine)
+ {
+ if (aErrorCode != KErrNone)
+ {
+ Kern::Printf("Device driver error %d (line %d)", aErrorCode, aLine);
+ }
+ }
+
+DECLARE_EXTENSION_LDD()
+ {
+ return new DHcrSimTestDrvFactory;
+ }
+
+DHcrSimTestDrvFactory::DHcrSimTestDrvFactory()
+ {
+ iParseMask = 0;
+ iUnitsMask = 0;
+ iVersion = TVersion(1,0,KE32BuildVersionNumber);
+ }
+
+DHcrSimTestDrvFactory::~DHcrSimTestDrvFactory()
+ {
+ if (iDfcQ)
+ iDfcQ->Destroy();
+ }
+
+const TInt KHcrSimTestThreadPriority = 1;
+_LIT(KHcrSimTestThread,"HcrSimTestThread");
+
+TInt DHcrSimTestDrvFactory::Install()
+ {
+ TInt r = Kern::DynamicDfcQCreate(iDfcQ, KHcrSimTestThreadPriority, KHcrSimTestThread);
+ if (r != KErrNone)
+ return r;
+ return(SetName(&KTestHcrSim));
+ }
+
+void DHcrSimTestDrvFactory::GetCaps(TDes8& /*aDes*/) const
+ {
+ // Get capabilities - overriding pure virtual
+ }
+
+TInt DHcrSimTestDrvFactory::Create(DLogicalChannelBase*& aChannel)
+ {
+ aChannel=new DHcrSimTestDrvChannel;
+ return aChannel?KErrNone:KErrNoMemory;
+ }
+
+// ----------------------------------------------------------------------------
+
+DHcrSimTestDrvChannel::DHcrSimTestDrvChannel()
+ {
+ iClient=&Kern::CurrentThread();
+ iClient->Open();
+ }
+
+DHcrSimTestDrvChannel::~DHcrSimTestDrvChannel()
+ {
+ Kern::SafeClose((DObject*&)iClient, NULL);
+ }
+
+TInt DHcrSimTestDrvChannel::DoCreate(TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& /*aVer*/)
+ {
+ SetDfcQ(((DHcrSimTestDrvFactory*)iDevice)->iDfcQ);
+ iMsgQ.Receive();
+ return KErrNone;
+ }
+
+void DHcrSimTestDrvChannel::HandleMsg(TMessageBase* aMsg)
+ {
+ TInt r=KErrNone;
+ TThreadMessage& m=*(TThreadMessage*)aMsg;
+ TInt id=m.iValue;
+ if (id==(TInt)ECloseMsg)
+ {
+ m.Complete(KErrNone,EFalse);
+ return;
+ }
+ else
+ {
+ r=DoControl(id,m.Ptr0(),m.Ptr1());
+ }
+ m.Complete(r,ETrue);
+ }
+
+TInt DHcrSimTestDrvChannel::DoControl(TInt aReqNo, TAny* a1, TAny* a2)
+ {
+ TInt r=KErrNotSupported;
+ switch (aReqNo)
+ {
+ case RHcrSimTestChannel::EHcrGetLinAddr:
+ {
+ HCR::TSettingId setting;
+ TLinAddr value;
+ Kern::ThreadRawRead(iClient, a1, &setting, sizeof(HCR::TSettingId));
+ r = HCR::GetLinAddr(setting, value);
+ Kern::ThreadRawWrite(iClient, a2, &value, sizeof(value));
+ break;
+ }
+ case RHcrSimTestChannel::EHcrFindNumSettingsInCategory:
+ {
+ r = HCR::FindNumSettingsInCategory((HCR::TCategoryUid) a1);
+ break;
+ }
+ case RHcrSimTestChannel::EHcrFindSettingsCategory:
+ {
+ // Get list of pointers
+ TAny* args[6];
+ Kern::ThreadRawRead(iClient, a1, args, sizeof(args));
+ TInt aMaxNum = (TInt) args[1];
+ // Allocate temporary memory
+ TUint32 numfound;
+ HCR::TElementId* ids;
+ HCR::TSettingType* types = NULL;
+ TUint16* lens = NULL;
+ ids = (HCR::TElementId*) Kern::Alloc(aMaxNum * sizeof(HCR::TElementId));
+ if (ids == NULL)
+ {
+ r = KErrNoMemory;
+ }
+ else
+ {
+ if (args[4]) // aTypes
+ {
+ types = (HCR::TSettingType*) Kern::Alloc(aMaxNum * sizeof(HCR::TSettingType));
+ }
+ if (types == NULL && args[4])
+ {
+ r = KErrNoMemory;
+ }
+ else
+ {
+ if (args[5]) // aLens
+ {
+ lens = (TUint16*) Kern::Alloc(aMaxNum * sizeof(TUint16));
+ }
+ if (lens == NULL && args[5])
+ {
+ r = KErrNoMemory;
+ }
+ else
+ {
+ // Actual API call
+ r = HCR::FindSettings((HCR::TCategoryUid) args[0],
+ aMaxNum, numfound, ids, types, lens);
+ TEST_KERRNONE(r);
+ // Send values back to client
+ if (!r)
+ {
+ Kern::ThreadRawWrite(iClient, args[2], &numfound, sizeof(TUint32));
+ Kern::ThreadRawWrite(iClient, args[3], ids, aMaxNum * sizeof(HCR::TElementId));
+ if (args[4])
+ {
+ Kern::ThreadRawWrite(iClient, args[4], types, aMaxNum * sizeof(HCR::TSettingType));
+ }
+ if (args[5])
+ {
+ Kern::ThreadRawWrite(iClient, args[5], lens, aMaxNum * sizeof(TUint16));
+ }
+ }
+ if (args[5])
+ {
+ Kern::Free(lens);
+ }
+ }
+ if (args[4])
+ {
+ Kern::Free(types);
+ }
+ }
+ Kern::Free(ids);
+ }
+ break;
+ }
+ case RHcrSimTestChannel::EHcrFindSettingsPattern:
+ {
+ // Get list of pointers
+ TAny* args[9];
+ Kern::ThreadRawRead(iClient, a1, args, sizeof(args));
+ TInt aMaxNum = (TInt) args[1];
+ // Allocate temporary memory
+ TUint32 numfound;
+ HCR::TElementId* ids;
+ HCR::TSettingType* types = NULL;
+ TUint16* lens = NULL;
+ ids = (HCR::TElementId*) Kern::Alloc(aMaxNum * sizeof(HCR::TElementId));
+ if (ids == NULL)
+ {
+ r = KErrNoMemory;
+ }
+ else
+ {
+ if (args[7]) // aTypes
+ {
+ types = (HCR::TSettingType*) Kern::Alloc(aMaxNum * sizeof(HCR::TSettingType));
+ }
+ if (types == NULL && args[7])
+ {
+ r = KErrNoMemory;
+ }
+ else
+ {
+ if (args[8]) // aLens
+ {
+ lens = (TUint16*) Kern::Alloc(aMaxNum * sizeof(TUint16));
+ }
+ if (lens == NULL && args[8])
+ {
+ r = KErrNoMemory;
+ }
+ else
+ {
+ // Actual API call
+ r = HCR::FindSettings((HCR::TCategoryUid) args[0],
+ aMaxNum, (TUint32) args[2], (TUint32) args[3], (TUint32) args[4],
+ numfound, ids, types, lens);
+ TEST_KERRNONE(r);
+ // Send values back to client
+ if (!r)
+ {
+ Kern::ThreadRawWrite(iClient, args[5], &numfound, sizeof(TUint32));
+ Kern::ThreadRawWrite(iClient, args[6], ids, aMaxNum * sizeof(HCR::TElementId));
+ if (args[7])
+ {
+ Kern::ThreadRawWrite(iClient, args[7], types, aMaxNum * sizeof(HCR::TSettingType));
+ }
+ if (args[8])
+ {
+ Kern::ThreadRawWrite(iClient, args[8], lens, aMaxNum * sizeof(TUint16));
+ }
+ }
+ if (args[8])
+ {
+ Kern::Free(lens);
+ }
+ }
+ if (args[7])
+ {
+ Kern::Free(types);
+ }
+ }
+ Kern::Free(ids);
+ }
+ break;
+ }
+ case RHcrSimTestChannel::EHcrGetTypeAndSize:
+ {
+ // Get list of pointers
+ TAny* args[3];
+ Kern::ThreadRawRead(iClient, a1, args, sizeof(args));
+ HCR::TSettingId id;
+ Kern::ThreadRawRead(iClient, args[0], &id, sizeof(HCR::TSettingId));
+ HCR::TSettingType type;
+ TUint16 len;
+ TEST_KERRNONE(r = HCR::GetTypeAndSize(id, type, len));
+ Kern::ThreadRawWrite(iClient, args[1], &type, sizeof(HCR::TSettingType));
+ Kern::ThreadRawWrite(iClient, args[2], &len, sizeof(TUint16));
+ break;
+ }
+ case RHcrSimTestChannel::EHcrGetWordSettings:
+ {
+ // Get list of pointers
+ TAny* args[5];
+ Kern::ThreadRawRead(iClient, a1, args, sizeof(args));
+ TInt aNum = (TInt) args[0];
+ // Allocate temporary memory
+ HCR::SSettingId* ids;
+ TInt32* vals;
+ HCR::TSettingType* types= NULL;
+ TInt* errors = NULL;
+ ids = (HCR::SSettingId*) Kern::Alloc(aNum * sizeof(HCR::SSettingId*));
+ if (ids == NULL)
+ {
+ r = KErrNoMemory;
+ }
+ else
+ {
+ vals = (TInt32*) Kern::Alloc(aNum * sizeof(TInt32));
+ if (vals == NULL)
+ {
+ r = KErrNoMemory;
+ }
+ else
+ {
+ if (args[3]) // aTypes
+ {
+ types = (HCR::TSettingType*) Kern::Alloc(aNum * sizeof(HCR::TSettingType));
+ }
+ if (types == NULL && args[3])
+ {
+ r = KErrNoMemory;
+ }
+ else
+ {
+ if (args[4]) // aErrors
+ {
+ errors = (TInt*) Kern::Alloc(aNum * sizeof(TInt));
+ }
+ if (errors == NULL && args[4])
+ {
+ r = KErrNoMemory;
+ }
+ else
+ {
+ // Actual API call
+ TEST_KERRNONE(r = HCR::GetWordSettings(aNum, ids, vals, types, errors));
+ // Send values back to client
+ if (!r)
+ {
+ Kern::ThreadRawWrite(iClient, args[1], ids, aNum * sizeof(HCR::SSettingId));
+ Kern::ThreadRawWrite(iClient, args[2], vals, aNum * sizeof(TInt32));
+ if (args[3])
+ {
+ Kern::ThreadRawWrite(iClient, args[3], types, aNum * sizeof(HCR::TSettingType));
+ }
+ if (args[4])
+ {
+ Kern::ThreadRawWrite(iClient, args[4], errors, aNum * sizeof(TInt));
+ }
+ }
+ if (args[4])
+ {
+ Kern::Free(errors);
+ }
+ }
+ if (args[3])
+ {
+ Kern::Free(types);
+ }
+ }
+ Kern::Free(vals);
+ }
+ Kern::Free(ids);
+ }
+ break;
+ }
+ case RHcrSimTestChannel::EHcrGetInt64:
+ {
+ HCR::TSettingId setting;
+ TInt64 value;
+ Kern::ThreadRawRead(iClient, a1, &setting, sizeof(HCR::TSettingId));
+ r = HCR::GetInt(setting, value);
+ Kern::ThreadRawWrite(iClient, a2, &value, sizeof(value));
+ break;
+ }
+ case RHcrSimTestChannel::EHcrGetInt32:
+ {
+ HCR::TSettingId setting;
+ TInt32 value;
+ Kern::ThreadRawRead(iClient, a1, &setting, sizeof(HCR::TSettingId));
+ r = HCR::GetInt(setting, value);
+ Kern::ThreadRawWrite(iClient, a2, &value, sizeof(value));
+ break;
+ }
+ case RHcrSimTestChannel::EHcrGetInt16:
+ {
+ HCR::TSettingId setting;
+ TInt16 value;
+ Kern::ThreadRawRead(iClient, a1, &setting, sizeof(HCR::TSettingId));
+ r = HCR::GetInt(setting, value);
+ Kern::ThreadRawWrite(iClient, a2, &value, sizeof(value));
+ break;
+ }
+ case RHcrSimTestChannel::EHcrGetInt8:
+ {
+ HCR::TSettingId setting;
+ TInt8 value;
+ Kern::ThreadRawRead(iClient, a1, &setting, sizeof(HCR::TSettingId));
+ r = HCR::GetInt(setting, value);
+ Kern::ThreadRawWrite(iClient, a2, &value, sizeof(value));
+ break;
+ }
+ case RHcrSimTestChannel::EHcrGetBool:
+ {
+ HCR::TSettingId setting;
+ TBool value;
+ Kern::ThreadRawRead(iClient, a1, &setting, sizeof(HCR::TSettingId));
+ r = HCR::GetBool(setting, value);
+ Kern::ThreadRawWrite(iClient, a2, &value, sizeof(value));
+ break;
+ }
+ case RHcrSimTestChannel::EHcrGetDataArray:
+ {
+ // Get list of pointers
+ TAny* args[4];
+ Kern::ThreadRawRead(iClient, a1, args, sizeof(args));
+ TUint maxlen = (TUint) args[1];
+ // Retrieve structures from client
+ HCR::TSettingId id;
+ Kern::ThreadRawRead(iClient, args[0], &id, sizeof(HCR::TSettingId));
+ // Allocate temporary memory
+ TUint16 len;
+ TUint8* value;
+ value = (TUint8*) Kern::Alloc(maxlen * sizeof(TUint8));
+ if (value == NULL)
+ {
+ r = KErrNoMemory;
+ }
+ else
+ {
+ // Actual API call
+ r = HCR::GetData(id, (TUint16) maxlen,
+ value, len);
+ // Send value back to client
+ if (!r)
+ {
+ Kern::ThreadRawWrite(iClient, args[2], value, maxlen * sizeof(TUint8));
+ Kern::ThreadRawWrite(iClient, args[3], &len, sizeof(TUint16));
+ }
+ Kern::Free(value);
+ }
+ break;
+ }
+ case RHcrSimTestChannel::EHcrGetDataDes:
+ {
+ HCR::TSettingId setting;
+ TBuf8<HCR::KMaxSettingLength> value;
+ Kern::ThreadRawRead(iClient, a1, &setting, sizeof(HCR::TSettingId));
+ r = HCR::GetData(setting, value);
+ Kern::ThreadDesWrite(iClient, a2, value, 0);
+ break;
+ }
+ case RHcrSimTestChannel::EHcrGetUInt64:
+ {
+ HCR::TSettingId setting;
+ TUint64 value;
+ Kern::ThreadRawRead(iClient, a1, &setting, sizeof(HCR::TSettingId));
+ r = HCR::GetUInt(setting, value);
+ Kern::ThreadRawWrite(iClient, a2, &value, sizeof(value));
+ break;
+ }
+ case RHcrSimTestChannel::EHcrGetUInt32:
+ {
+ HCR::TSettingId setting;
+ TUint32 value;
+ Kern::ThreadRawRead(iClient, a1, &setting, sizeof(HCR::TSettingId));
+ r = HCR::GetUInt(setting, value);
+ Kern::ThreadRawWrite(iClient, a2, &value, sizeof(value));
+ break;
+ }
+ case RHcrSimTestChannel::EHcrGetUInt16:
+ {
+ HCR::TSettingId setting;
+ TUint16 value;
+ Kern::ThreadRawRead(iClient, a1, &setting, sizeof(HCR::TSettingId));
+ r = HCR::GetUInt(setting, value);
+ Kern::ThreadRawWrite(iClient, a2, &value, sizeof(value));
+ break;
+ }
+ case RHcrSimTestChannel::EHcrGetUInt8:
+ {
+ HCR::TSettingId setting;
+ TUint8 value;
+ Kern::ThreadRawRead(iClient, a1, &setting, sizeof(HCR::TSettingId));
+ r = HCR::GetUInt(setting, value);
+ Kern::ThreadRawWrite(iClient, a2, &value, sizeof(value));
+ break;
+ }
+ case RHcrSimTestChannel::EHcrGetArrayInt:
+ {
+ // Get list of pointers
+ TAny* args[4];
+ Kern::ThreadRawRead(iClient, a1, args, sizeof(args));
+ TUint maxlen = (TUint) args[1];
+ // Retrieve structures from client
+ HCR::TSettingId id;
+ Kern::ThreadRawRead(iClient, args[0], &id, sizeof(HCR::TSettingId));
+ // Allocate temporary memory
+ TUint16 len;
+ TInt32* value;
+ value = (TInt32*) Kern::Alloc(maxlen);
+ if (value == NULL)
+ {
+ r = KErrNoMemory;
+ }
+ else
+ {
+ // Actual API call
+ r = HCR::GetArray(id, (TUint16) maxlen,
+ value, len);
+ // Send value back to client
+ if (!r)
+ {
+ Kern::ThreadRawWrite(iClient, args[2], value, maxlen);
+ Kern::ThreadRawWrite(iClient, args[3], &len, sizeof(TUint16));
+ }
+ Kern::Free(value);
+ }
+ break;
+ }
+ case RHcrSimTestChannel::EHcrGetArrayUInt:
+ {
+ // Get list of pointers
+ TAny* args[4];
+ Kern::ThreadRawRead(iClient, a1, args, sizeof(args));
+ TUint maxlen = (TUint) args[1];
+ // Retrieve structures from client
+ HCR::TSettingId id;
+ Kern::ThreadRawRead(iClient, args[0], &id, sizeof(HCR::TSettingId));
+ // Allocate temporary memory
+ TUint16 len;
+ TUint32* value;
+ value = (TUint32*) Kern::Alloc(maxlen);
+ if (value == NULL)
+ {
+ r = KErrNoMemory;
+ }
+ else
+ {
+ // Actual API call
+ r = HCR::GetArray(id, (TUint16) maxlen,
+ value, len);
+ // Send value back to client
+ if (!r)
+ {
+ Kern::ThreadRawWrite(iClient, args[2], value, maxlen);
+ Kern::ThreadRawWrite(iClient, args[3], &len, sizeof(TUint16));
+ }
+ Kern::Free(value);
+ }
+ break;
+ }
+ case RHcrSimTestChannel::EHcrGetStringArray:
+ {
+ // Get list of pointers
+ TAny* args[4];
+ Kern::ThreadRawRead(iClient, a1, args, sizeof(args));
+ TUint maxlen = (TUint) args[1];
+ // Retrieve structures from client
+ HCR::TSettingId id;
+ Kern::ThreadRawRead(iClient, args[0], &id, sizeof(HCR::TSettingId));
+ // Allocate temporary memory
+ TUint16 len;
+ TText8* value;
+ value = (TText8*) Kern::Alloc(maxlen * sizeof(TText8));
+ if (value == NULL)
+ {
+ r = KErrNoMemory;
+ }
+ else
+ {
+ // Actual API call
+ r = HCR::GetString(id, (TUint16) maxlen,
+ value, len);
+ // Send value back to client
+ if (!r)
+ {
+ Kern::ThreadRawWrite(iClient, args[2], value, maxlen * sizeof(TText8));
+ Kern::ThreadRawWrite(iClient, args[3], &len, sizeof(TUint16));
+ }
+ Kern::Free(value);
+ }
+ break;
+ }
+ case RHcrSimTestChannel::EHcrGetStringDes:
+ {
+ HCR::TSettingId setting;
+ TBuf8<HCR::KMaxSettingLength> value;
+ Kern::ThreadRawRead(iClient, a1, &setting, sizeof(HCR::TSettingId));
+ r = HCR::GetString(setting, value);
+ Kern::ThreadDesWrite(iClient, a2, value, 0);
+ break;
+ }
+ case RHcrSimTestChannel::EHcrInitExtension:
+ {
+ PslConfigurationFlags = (TInt) a1;
+ r = InitExtension();
+ break;
+ }
+ case RHcrSimTestChannel::EHcrSwitchRepository:
+ {
+ TBuf8<80> filename;
+ Kern::ThreadDesRead(iClient, a1, filename, 0);
+ TText8 filestr[81];
+ memcpy(filestr, filename.Ptr(), filename.Length());
+ filestr[filename.Length()] = 0; // Zero-terminate string
+ TText8* pfile = filestr;
+ if (filename.Length() == 0)
+ {
+ pfile = NULL;
+ }
+ if ((TUint) a2 == HCR::HCRInternal::ECoreRepos)
+ {
+ r = HCRSingleton->SwitchRepository(pfile, HCR::HCRInternal::ECoreRepos);
+ }
+ else if ((TUint) a2 == HCR::HCRInternal::EOverrideRepos)
+ {
+ r = HCRSingleton->SwitchRepository(pfile, HCR::HCRInternal::EOverrideRepos);
+ }
+ break;
+ }
+ case RHcrSimTestChannel::EHcrCheckIntegrity:
+ {
+ r = HCRSingleton->CheckIntegrity();
+ break;
+ }
+ }
+ return r;
+ }