// Copyright (c) 1999-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:

 // hal\src\hal_main.cpp

 // 

 //

 #include <kernel/hal_int.h>

 _LIT(KLitHal,"HAL");

 void HalInternal::Panic(HalInternal::THalPanic aPanic)

 	{

 	User::Panic(KLitHal,aPanic);

 	}

 void HalInternal::InitialiseData()

 	{

 	TInt i;

 	_LIT_SECURITY_POLICY_PASS(KPassPolicy);

 	_LIT_SECURITY_POLICY_C1(KWriteDevDataPolicy, ECapabilityWriteDeviceData);

 	for (i=0; i<HAL::ENumHalAttributes; i++)                // for every attribute,

 		{

 		if (Properties[i]&HAL::EValid && !Implementation[i] && (Properties[i] & HAL::ESettable)) 

 			// if it's implemented, not a constant and not a user function

 			{

 			 TInt r = RProperty::Define(KUidSystemCategory, KUidHalPropertyKeyBase+i, RProperty::EInt,

 					KPassPolicy, KWriteDevDataPolicy); 

 			 __ASSERT_ALWAYS(r==KErrNone || r==KErrAlreadyExists,Panic(EInitialAllocFailed1)); 

 			 if (r==KErrAlreadyExists)

 				break;

 			 // This will panic if the first instance of the DLL to start does not have WriteDeviceData

 			 // capability.  Again, there isn't anything we can do about this.  It shouldn't ever happen.

 			 r = RProperty::Set(KUidSystemCategory, KUidHalPropertyKeyBase+i, InitialValue[i]);

 			 __ASSERT_ALWAYS(r==KErrNone,Panic(EInitialAllocFailed2));

 			}

 		}

 	}

 TInt HalInternal::ReadWord(TInt aKey)

 	{

 	 TInt result;

 	// This is a slow way of doing it, but it is light on memory as it doesn't

 	// need an offset array.

 	if(aKey>=HAL::ENumHalAttributes)

 		return KErrNotFound;

 	TInt r=RProperty::Get(KUidSystemCategory, KUidHalPropertyKeyBase+aKey, result);

 	if (r!=KErrNone)

 		{

 		InitialiseData();

 		r=RProperty::Get(KUidSystemCategory, KUidHalPropertyKeyBase+aKey, result);

 		}

 	__ASSERT_ALWAYS(r==KErrNone,Panic(EGetPropFailed)); 

 	return (result);

 	}

 TInt HalInternal::WriteWord(TInt aKey, TInt aValue)

 	{

 	TInt r;

 	if(aKey>=HAL::ENumHalAttributes)

 		return KErrArgument;

 	r=RProperty::Set(KUidSystemCategory, KUidHalPropertyKeyBase+aKey, aValue);

 	if (r!=KErrNone && r!=KErrPermissionDenied) 

 		{

 		InitialiseData();

 		r=RProperty::Set(KUidSystemCategory, KUidHalPropertyKeyBase+aKey, aValue);

 		}

 	__ASSERT_ALWAYS(r==KErrNone || r==KErrPermissionDenied,Panic(ESetPropFailed));

 	return r;

 	}

 EXPORT_C TInt HAL::Get(HAL::TAttribute aAttribute, TInt& aValue)

 	{

 	return HAL::Get(0,aAttribute,aValue);

 	}

 EXPORT_C TInt HAL::Set(HAL::TAttribute aAttribute, TInt aValue)

 	{

 	return HAL::Set(0,aAttribute,aValue);

 	}

 EXPORT_C TInt HAL::GetAll(TInt& aNumEntries, SEntry*& aData)

 	{

 	TInt max_devices=1;

 	HAL::Get(EDisplayNumberOfScreens,max_devices);

 	TInt size=max_devices*(TInt)ENumHalAttributes*(TInt)sizeof(SEntry);

 	SEntry* pE=(SEntry*)User::Alloc(size);

 	if (!pE)

 		{

 		aNumEntries=0;

 		aData=NULL;

 		return KErrNoMemory;

 		}

 	TInt device;

 	for(device=0;device<max_devices;device++)

 		{

 		TInt r;

 		TInt i=ENumHalAttributes-1;

 		for (; i>=0; --i)

 			{

 			TInt offset = device*(TInt)ENumHalAttributes + i;

 			TInt properties=HalInternal::Properties[i];

 			if (properties & HAL::EValid)

 				{

 				THalImplementation f=HalInternal::Implementation[i];

 				if (f)

 					{

 					// Initialise the value before getting it, for consistancy

 					// when functions take an argument. (-1 is also likely to be

 					// an invalid argument and return an error in these cases, which

 					// is probably the safest result.)

 					pE[offset].iValue = -1;

 					r=(*f)(device,i,EFalse,&pE[offset].iValue);

 					if (r==KErrNone)

 						{

 						pE[offset].iProperties=EEntryValid|EEntryDynamic;

 						continue;

 						}

 					// drop through to clear EEntryValid

 					}

 				else

 					{

 					//these attributes do not support multiple devices

 					if(device==0)

 						{

 						TInt p;

 						if (!(properties & HAL::ESettable))

 							{

 							pE[offset].iValue = HalInternal::InitialValue[i];

 							p=EEntryValid;

 							}

 						else

 							{

 							r=RProperty::Get(KUidSystemCategory, KUidHalPropertyKeyBase+i, pE[offset].iValue);

 							if (r!=KErrNone)

 								{

 								HalInternal::InitialiseData();

 								r=RProperty::Get(KUidSystemCategory, KUidHalPropertyKeyBase+i, pE[offset].iValue);

 								}

 							p=(r==KErrNone?EEntryValid:0);

 							p|=EEntryDynamic;

 							}

 						pE[offset].iProperties=p;

 						continue;

 						}

 					// drop through to clear EEntryValid

 					}

 				}

 			pE[offset].iProperties=0;

 			pE[offset].iValue=0;

 			}

 		}

 	aNumEntries=max_devices*(TInt)ENumHalAttributes;

 	aData=pE;

 	return KErrNone;

 	}

 EXPORT_C TInt HAL::Get(TInt aDeviceNumber, HAL::TAttribute aAttribute, TInt& aValue)

 	{

 	if (TUint(aAttribute)>=TUint(ENumHalAttributes))

 		return KErrNotSupported;

 	TUint8 properties=HalInternal::Properties[aAttribute];

 	if (!(properties & HAL::EValid))

 		return KErrNotSupported;

 	THalImplementation f=HalInternal::Implementation[aAttribute];

 	if (f)

 		return (*f)(aDeviceNumber,aAttribute,EFalse,&aValue);

 	if (!(properties & HAL::ESettable))

 	{

 		aValue=HalInternal::InitialValue[aAttribute];

 		return KErrNone;

 	}

 	aValue=HalInternal::ReadWord(aAttribute);

 	return KErrNone;

 	}

 EXPORT_C TInt HAL::Set(TInt aDeviceNumber, HAL::TAttribute aAttribute, TInt aValue)

 	{

      if (TUint(aAttribute)>=TUint(ENumHalAttributes))

 		return KErrNotSupported;

 	TUint8 properties=HalInternal::Properties[aAttribute];

 	if (!(properties & HAL::EValid) || !(properties & HAL::ESettable))

 		return KErrNotSupported;

 	THalImplementation f=HalInternal::Implementation[aAttribute];

 	if (f)

 		return (*f)(aDeviceNumber,aAttribute,ETrue,(TAny*)aValue);

 	return HalInternal::WriteWord(aAttribute,aValue);

 	}