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

// Hardware Configuration Respoitory Platform Independent Layer (PIL)

//

// -- INCLUDES ----------------------------------------------------------------

#include "hcr_debug.h"

#include <e32def.h>

#include <e32err.h>

#include <e32des8.h>

#include <e32cmn.h>

#include <nkern/nkern.h>

#include <kernel/kernel.h>

#include <e32rom.h>

#include <plat_priv.h>

#include <kernel/kernboot.h>

#include "hcr_hai.h"

#include "hcr_pil.h"

// -- GLOBALS -----------------------------------------------------------------

GLDEF_C HCR::HCRInternal gHCR;

#ifdef HCR_TRACE

GLDEF_C TBuf<81> gTraceBuffer;

#endif

// -- Local functions prototypes

/**

Retrive Repository file address stored in the iHcrFileAddress field of ROM Image header.

If this filed is zero or it is equal with a special value then it keeps the original vaule of 

aRepos parameter and signals it with the retun value.

@param aRepos     		The reference to a repository variable    

@return	KErrNone 		if successful, the aRepos parameter references to the file in ROM Image.

        KErrNotFound 	if the ROM Image header contains zero or a special value as the repository file address

*/    

LOCAL_C TInt LocateCoreImgRepository(HCR::TRepository*& aRepos);

/**

This method transfer the value of aFileName to ROM Image conform file name string. 

Retrive the variant dependent ROM Root directory address.

Search the file in \sys\bin directory and if it doesn't exists there it try to find it in \sys\Data.

@param 	aRepos     			The reference to a repository variable.

				aFileName			  The name of the new repository file without path. '\0' terminated c-style string.

@return	KErrNone 			if successful

        KErrNotFound 		if file not found in \sys\bin or \sys\Data

*/    

LOCAL_C TInt SearchCoreImgRepository(HCR::TRepository* & aRepos, const TText * aFileName);

/**

Scanning a given directory for the given entry name. The entry name can be sub-directory or file.

@param 	aActDir     		Pointer to curretn directory in the ROM Image directory tree

		aFileName			File to be search

		aEntry				If the file found this referenced to proper directory entry

@return	 KErrNone		 			if the entry found

         KErrNotFound					if the entry not found

*/    

LOCAL_C TInt SearchEntryInTRomDir(const TRomDir* aActDir, const TPtrC aFileName, TRomEntry* &aEntry);

// -- WINS Specific ----------------------------------------------------------

#ifdef __WINS__

// Set to ensure Rom Hdr dependency does not break compilation in 

// LocateCoreImgRepository() at the end of this file.

// Undef incase it is set in MMP file, avoids compiler warning.

//

#undef HCRTEST_COREIMG_DONTUSE_ROMHDR

#define HCRTEST_COREIMG_DONTUSE_ROMHDR

#endif

// -- FUNCTIONS ---------------------------------------------------------------

/**

 Returns 1 when a1 > a2

 Returns -1 when a1 < a2

 Returns 0 when identical.

 */

TInt CompareSSettingIds(const HCR::TSettingId& a1, const HCR::SSettingId& a2)    

	{

    // HCR_FUNC("CompareSSettingIds");

    if (a1.iCat > a2.iCat)

        return (1); // HCR_TRACE_RETURN(1);

    if (a1.iCat < a2.iCat)

        return (-1); // HCR_TRACE_RETURN(-1);

    // Categories are the same at this point, check keys.

    if (a1.iKey > a2.iKey)

        return (1); // HCR_TRACE_RETURN(1);

    if (a1.iKey < a2.iKey)

        return (-1); // HCR_TRACE_RETURN(-1);

    // Both Categories and jeys are the same here.

    return (0); // HCR_TRACE_RETURN(0);

    }

#ifdef __EPOC32__

TBool ROMAddressIsInUnpagedSection(const TLinAddr address)

	{

    HCR_FUNC("ROMAddressIsInUnpagedSection");

	const TRomHeader& romHdr = Epoc::RomHeader();

	TLinAddr romBase = romHdr.iRomBase;

	HCR_TRACE1("--- address to check if in unpaged ROM section = 0x%8x", address);

	HCR_TRACE2("--- iRomSize (0x%8x), iPageableRomStart (0x%8x), ", romHdr.iRomSize, romHdr.iPageableRomStart);

	if ((address < romBase) || (romBase > romBase+romHdr.iRomSize))

		return EFalse;

	if (romHdr.iPageableRomStart == 0)

		return ETrue;

	if (address < romBase+romHdr.iPageableRomStart)

		return ETrue;

	return EFalse;

	}

#endif

TInt CompareByCategory(const HCR::TCategoryUid aCatId, const HCR::SSettingId& aSetId)    

    {

    //HCR_FUNC("CompareByCategory");

    if (aCatId > aSetId.iCat)

        return (1); // HCR_TRACE_RETURN(1);

    if (aCatId < aSetId.iCat)

        return (-1); // HCR_TRACE_RETURN(-1);

    // Both Categories and jeys are the same here.

    return (0); 

    }

/*

 * SafeArray TSa class object destructor. It delets the allocated in the heap

 * memory and set the instance pointer to NULL. See also TSa class definition

 * in hcr_pil.h.

 */

template<typename T>

    HCR::TSa<T>::~TSa()

    {

    delete[] iSa;

    iSa = NULL;

    }

/**

 * operator=() changes the memory ownership by   

 * reinitiazing SafeArray class object with the address to   

 * already allocated array.

 */

template<typename T>

   HCR::TSa<T>& HCR::TSa<T>::operator=(T* aP)

    {

    delete[] iSa;

    iSa = aP; 

    return (*this);

    }

// -- METHODS -----------------------------------------------------------------

//

// HCRInternal

HCR::HCRInternal::HCRInternal()

   : iStatus(EStatConstructed), iVariant(0), iVariantStore(0), iCoreImgStore(0), iOverrideStore(0)

    {

    HCR_FUNC("HCRInternal(Defualt)");

    }

HCR::HCRInternal::HCRInternal(HCR::MVariant* aVar)

   : iVariant(aVar), iVariantStore(0), iCoreImgStore(0), iOverrideStore(0)

    {

    HCR_FUNC("HCRInternal");

    }

HCR::HCRInternal::~HCRInternal()

    {

    HCR_FUNC("~HCRInternal");

    }

TUint32 HCR::HCRInternal::GetStatus()

    {

    HCR_FUNC("GetStatus");

    return iStatus;

    }

TInt HCR::HCRInternal::Initialise()

    {

    HCR_FUNC("HCRInternal::Initialise");

    TAny* store = 0; 

    TInt err = 0;

	// Variant PSL object must exist before PIL initalised.

	if (iVariant == 0) {

 			err = KErrGeneral; goto failed; }

	// Inform the PSL that we are initialising, give them an opportunity to do

	// initialisation work too.

    err = iVariant->Initialise(); 

    if (err != KErrNone)

    	goto failed;

    iStatus = EStatVariantInitialised;

    // Ask the PSL for the address of the SRepositoryCompiled object. PSL 

    // can return KErrNotSupported & NULL if compiled repository not 

	// used/support by PSL.

    err = iVariant->GetCompiledRepositoryAddress(store);

    if (err == KErrNone)

        {

        if (store == 0) { // Programming error in PSL, ptr/rc mismatch

 			err = KErrArgument; goto failed; }

        iVariantStore = TRepositoryCompiled::New(reinterpret_cast<const HCR::SRepositoryCompiled *>(store));

        if (iVariantStore == 0) { 

			err = KErrNoMemory; goto failed; }

        }

    else if (err != KErrNotSupported)

    	goto failed;       

    // Ask the PSL if it wants the PIL not to search for the Core Image 

	// SRepositoryFile settings.

    iCoreImgStore = 0;

    if (!iVariant->IgnoreCoreImgRepository())

    	{

    	err = LocateCoreImgRepository(iCoreImgStore);

    	if (err == KErrNone)

     	   {

        	if (iCoreImgStore == 0) {

				err = KErrNoMemory; goto failed; }	

        	}

    	else if (err != KErrNotFound)

    		goto failed;

		}       

    // Ask the PSL for the address of the SRepositoryFile object. PSL 

    // can return KErrNotSupported & NULL if a local media based file 

	// repository is not used/support by PSL.  

    store = 0;

    err = iVariant->GetOverrideRepositoryAddress(store);

    if (err == KErrNone)

        {

        if (store == 0) { // Programming error in PSL, ptr/rc mismatch

 			err = KErrArgument; goto failed; }       

        iOverrideStore = TRepositoryFile::New(reinterpret_cast<const HCR::SRepositoryFile *>(store));

        if (iOverrideStore == 0) {

			err = KErrNoMemory; goto failed; }

        }

    else if (err != KErrNotSupported)

    	goto failed;       

	iStatus = EStatInitialised;

    // Sanity check here to ensure we have atleast one repository to use and run

    // sanity check on their contents to look for ordering issues and duplicates.

	HCR_TRACE3("=== HCR Ready: compiled:%x, coreimg:%x, override:%x", iVariantStore, iCoreImgStore, iOverrideStore);

    if ((iVariantStore == 0) && (iCoreImgStore == 0) && (iOverrideStore == 0)) {

 		err = KErrArgument; goto failed; }

#ifdef _DEBUG

	err = CheckIntegrity();

	if (err != KErrNone)

		goto failed;	

#endif

	iStatus = EStatReady;

	return KErrNone;

failed:

    iStatus = (iStatus & EStatMinorMask) | EStatFailed;

	HCR_TRACE_RETURN(err);

    }

TInt HCR::HCRInternal::SwitchRepository(const TText * aFileName, const TReposId aId)

	{

	HCR_FUNC("HCRInternal::SwitchRepository");

	TInt retVal = KErrNone;

	TRepository* store = NULL;

	if( aFileName != NULL)

		{

		retVal = SearchCoreImgRepository(store, aFileName);

		HCR_TRACE2("--- SearchCoreImgRepository()->%d (0x%08x)", retVal, retVal);

		}

	if( retVal == KErrNone )

		{

		switch(aId)

			{

			case ECoreRepos:

			    HCR_TRACE0("--- ECoreRepos");

				if( iCoreImgStore )

					{

					NKern::ThreadEnterCS();

					delete iCoreImgStore;

					NKern::ThreadLeaveCS();

					}

				iCoreImgStore = store;

				break;

			case EOverrideRepos:

			    HCR_TRACE0("--- EOverrideRepos");

				if( iOverrideStore )

    				{

	    			NKern::ThreadEnterCS();

					delete iOverrideStore;

					NKern::ThreadLeaveCS();

					}

				iOverrideStore = store;

				break;

			default:

			    HCR_TRACE0("--- default:");

				retVal = KErrNotSupported;

				break;		

			}

		}

	HCR_TRACE_RETURN(retVal);

    }

TInt HCR::HCRInternal::CheckIntegrity()

	{

	HCR_FUNC("HCRInternal::CheckIntegrity");

	TInt err = KErrNone;

	if (iVariantStore)

		{

		err = iVariantStore->CheckIntegrity();

		if (err != KErrNone)

			HCR_TRACEMSG_RETURN("HCR iVariantStore failed integrity check", err);

		}

	if (iCoreImgStore)

		{

		err = iCoreImgStore->CheckIntegrity();

		if (err != KErrNone)

			HCR_TRACEMSG_RETURN("HCR iCoreImgStore failed integrity check", err);

		}	

	if (iOverrideStore)

		{

		err = iOverrideStore->CheckIntegrity();

		if (err != KErrNone)

			HCR_TRACEMSG_RETURN("HCR iOverrideStore failed integrity check", err);

		}

	HCR_TRACE0("=== HCR Repository integrity checks PASSED!");

	return KErrNone;	

	}

TInt HCR::HCRInternal::FindSetting(const TSettingId& aId, TSettingType aType, 

        TSettingRef& aSetting)

    {

    HCR_FUNC("HCRInternal::FindSetting");

    TInt err = 0;

    TBool found = EFalse;

    HCR_TRACE3("--- Repository state: %x, %x, %x", iOverrideStore, iCoreImgStore, iVariantStore);

    if (iOverrideStore && 

        ((err = iOverrideStore->FindSetting(aId, aSetting)) == KErrNone))

        found = ETrue;

    if ((err != KErrNone) && (err != KErrNotFound))

        HCR_TRACE_RETURN(err);

    if (!found &&

        iCoreImgStore &&

        ((err = iCoreImgStore->FindSetting(aId, aSetting)) == KErrNone))

        found = ETrue;

    if ((err != KErrNone) && (err != KErrNotFound))

        HCR_TRACE_RETURN(err);

    if (!found &&

        iVariantStore &&

        ((err = iVariantStore->FindSetting(aId, aSetting)) == KErrNone))

        found = ETrue;

    if ((err != KErrNone) && (err != KErrNotFound))

        HCR_TRACE_RETURN(err);

    HCR_TRACE3("--- Search results: %d, %d, %x", found, err, aSetting.iSet);

    if (!found || (aSetting.iSet == 0))

        HCR_TRACE_RETURN(KErrNotFound);

    // Setting found at this point in the function

    //

    TSettingType type=static_cast<TSettingType>(aSetting.iRep->GetType(aSetting)); 

    if (type & ~aType)

        HCR_TRACE_RETURN(KErrArgument); // Wrong setting type

    HCR_TRACE3("--- Setting found! ID: (%d,%d) Type: %d", aId.iCat, aId.iKey, type);

    return KErrNone;

    }

TInt HCR::HCRInternal::FindSettingWithType(const TSettingId& aId, TSettingType& aType, 

      TSettingRef& aSetting)

    {

    HCR_FUNC("HCRInternal::FindSettingWithType");

    TInt err = 0;

    TBool found = EFalse;

    HCR_TRACE3("--- Repository state: %x, %x, %x", iOverrideStore, iCoreImgStore, iVariantStore);

    if (iOverrideStore && 

        ((err = iOverrideStore->FindSetting(aId, aSetting)) == KErrNone))

        found = ETrue;

    if ((err != KErrNone) && (err != KErrNotFound))

        HCR_TRACE_RETURN(err);

    if (!found &&

        iCoreImgStore &&

        ((err = iCoreImgStore->FindSetting(aId, aSetting)) == KErrNone))

        found = ETrue;

    if ((err != KErrNone) && (err != KErrNotFound))

        HCR_TRACE_RETURN(err);

    if (!found &&

        iVariantStore &&

        ((err = iVariantStore->FindSetting(aId, aSetting)) == KErrNone))

        found = ETrue;

    if ((err != KErrNone) && (err != KErrNotFound))

        HCR_TRACE_RETURN(err);

    HCR_TRACE3("--- Search results: %d, %d, %x", found, err, aSetting.iSet);

    if (!found || (aSetting.iSet == 0))

        {

        aType = ETypeUndefined;

        HCR_TRACE_RETURN(KErrNotFound);

        }

    // Setting found at this point in the function

    //

    aType=static_cast<TSettingType>(aSetting.iRep->GetType(aSetting)); 

    HCR_TRACE3("--- Setting found! ID: (%d,%d) Type: %d", aId.iCat, aId.iKey, aType);

    return KErrNone;

    }

TInt HCR::HCRInternal::GetWordSettings(TInt aNum, const SSettingId aIds[], 

        TInt32 aValues[], TSettingType aTypes[], TInt aErrors[])

    {

    HCR_FUNC("++ HCRInternal::GetWordSettings");

    HCR_TRACE3("--- Repository state: %x, %x, %x", iOverrideStore, iCoreImgStore, iVariantStore);

    if(aNum <= 0 || aIds == NULL || aErrors == NULL)

        HCR_TRACE_RETURN(KErrArgument);

    TInt err = 0;

    //If the user only supplies a single setting then there is no reasons to 

    //continue with multiple searach and it should be limited by internal 

    //invocation of FindSettingWithType.

    if(aNum == 1)

        {

        TSettingRef sref(0,0);

        TSettingType* pTypes;

        //aTypes array is optional and user may not provided it for us. So we

        //need to be sure it's not a null pointer

        if(aTypes == NULL)

            {

            //If this is a null pointer then just create our own element and 

            //assign it to the pTypes pointer

            TSettingType types[1];

            pTypes = types;

            }

        else

            {

            //else we use the user supplied array

            pTypes = aTypes;

            }

        //Let's find this setting

        err = HCRSingleton->FindSettingWithType(aIds[0], *pTypes, sref);

        //and analyse the result of operation