// 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 <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);

// -- 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);

    }

// -- 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_LOG_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 )

					{

					delete iCoreImgStore;

					}

				iCoreImgStore = store;

				break;

			case EOverrideRepos:

			    HCR_TRACE0("--- EOverrideRepos");

				if( iCoreImgStore )

    				{

					delete iOverrideStore;

					}

				iOverrideStore = store;

				break;

			default:

			    HCR_TRACE0("--- default:");

				retVal = KErrNotSupported;

				break;		

			}

		}

	HCR_LOG_RETURN(retVal);

    }

TInt HCR::HCRInternal::CheckIntegrity()

	{

	HCR_FUNC("HCRInternal::CheckIntegrity");

	TInt err = KErrNone;

	if (iVariantStore)

		{

		err = iVariantStore->CheckIntegrity();

		if (err != KErrNone)

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

		}

	if (iCoreImgStore)

		{

		err = iCoreImgStore->CheckIntegrity();

		if (err != KErrNone)

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

		}	

	if (iOverrideStore)

		{

		err = iOverrideStore->CheckIntegrity();

		if (err != KErrNone)

			HCR_LOGMSG_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_LOG_RETURN(err);

    if (!found &&

        iCoreImgStore &&

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

        found = ETrue;

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

        HCR_LOG_RETURN(err);

    if (!found &&

        iVariantStore &&

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

        found = ETrue;

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

        HCR_LOG_RETURN(err);

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

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

        HCR_LOG_RETURN(KErrNotFound);

    // Setting found at this point in the function

    //

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

    if (type & ~aType)

        HCR_LOG_RETURN(KErrArgument); // Wrong setting type

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

    return KErrNone;

    }

TInt HCR::HCRInternal::FindWordSettings(TInt /*aNum*/, const TSettingId* /*aIds*/, 

                        TInt32* /*aValues*/, TSettingType* /*aTypes*/, TInt* /*aErrors*/)

    {

    HCR_FUNC("HCRInternal::FindWordSettings");

    return KErrNotSupported;

    }

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

//

// TRepository

TBool HCR::TRepository::IsWordValue(const TSettingRef& aRef)

    {

    HCR_FUNC("TRepository::IsWordValue");

    return ((aRef.iSet->iType & KMaskWordTypes) != 0);

    }

TBool HCR::TRepository::IsLargeValue(const TSettingRef& aRef)

    {

    HCR_FUNC("TRepository::IsLargeValue");

    return ((aRef.iSet->iType & KMaskLargeTypes) != 0);

    }

void HCR::TRepository::GetId(const TSettingRef& aRef, TCategoryUid& aCat, TElementId& aKey)

    {

    HCR_FUNC("TRepository::GetId1");

    aCat = aRef.iSet->iId.iCat;

    aKey = aRef.iSet->iId.iKey;

    }

void HCR::TRepository::GetId(const TSettingRef& aRef, SSettingId& aId)

    {

    HCR_FUNC("TRepository::GetId2");

    aId = aRef.iSet->iId;

    }

TInt32 HCR::TRepository::GetType(const TSettingRef& aRef)

    {

    HCR_FUNC("TRepository::GetType");

    return (aRef.iSet->iType);

    }

TUint16 HCR::TRepository::GetLength(const TSettingRef& aRef)

    {

    HCR_FUNC("TRepository::GetLength");

	// Assume large value, will be caught when value retreived if not correct.

	// Saves some CPU cycles...

	// if (IsLargeValue(aRef))

    return (aRef.iSet->iLen);

    }

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

//

// TRepositoryCompiled

HCR::TRepository* HCR::TRepositoryCompiled::New(const SRepositoryCompiled* aRepos)

    {

    HCR_FUNC("TRepositoryCompiled::New");

    return new TRepositoryCompiled(aRepos);

    }

HCR::TRepositoryCompiled::TRepositoryCompiled(const SRepositoryCompiled* aRepos)

 : iRepos(aRepos)

    {

    HCR_FUNC("TRepositoryCompiled");

    }

HCR::TRepositoryCompiled::~TRepositoryCompiled()

    {

    HCR_FUNC("~TRepositoryCompiled");

    }

TInt HCR::TRepositoryCompiled::Initialise()

    {

    HCR_FUNC("TRepositoryCompiled::Initialise");

    return KErrNone;

    }

TInt HCR::TRepositoryCompiled::CheckIntegrity()

    {

    HCR_FUNC("TRepositoryCompiled::CheckIntegrity");

	if (iRepos->iOrderedSettingList == 0)

        HCR_LOGMSG_RETURN("Compiled Repository header missing setting array list", KErrNotFound);

	HCR_TRACE2("Compiled repository 0x%x contains %05d entries", iRepos, iRepos->iHdr->iNumSettings);

    SSettingC* arr = iRepos->iOrderedSettingList;

    TSettingId prev(0,0);

    TInt rc=0;

    for (int i=0; i < iRepos->iHdr->iNumSettings; i++, arr++)

    	{

    	HCR_TRACE3("Checking entry %05d - (0x%x,%d)", i, arr->iName.iId.iCat,  arr->iName.iId.iKey);

    	rc = CompareSSettingIds(prev, arr->iName.iId);

		// Check for duplicates that reside next to each other

    	if ((i > 0) && (rc == 0))

    		HCR_TRACE_RETURN (KErrAlreadyExists);

    	// Check that the entries are in ascending order	

    	if (rc != -1)

    		HCR_TRACE_RETURN (KErrCorrupt);

    	prev = arr->iName.iId;

		}

    return KErrNone; 

    }

TInt HCR::TRepositoryCompiled::FindSetting(const TSettingId& aId, TSettingRef& aSetting)

    {

    HCR_FUNC("TRepositoryCompiled::FindSetting");

    if ((iRepos->iHdr->iNumSettings == 0) || 

        (iRepos->iOrderedSettingList == 0))

        HCR_LOG_RETURN(KErrNotFound);

    SSettingC* arr = iRepos->iOrderedSettingList;

    int low = 0;

    int high = iRepos->iHdr->iNumSettings-1;

    int mid;

    int com;

    while (low<=high)

        {

        mid = (low+high) >> 1;

        com = CompareSSettingIds(aId, arr[mid].iName.iId);

        if (com < 0)

            high = mid-1;

        else if (com > 0)

            low = mid+1;

        else

            {

            aSetting.iRep = this;

            aSetting.iSet = &((arr[mid]).iName);

            return KErrNone;

            }    

        } 

    aSetting.iRep = 0;

	aSetting.iSet = 0; 

    return KErrNotFound;

    }

TInt HCR::TRepositoryCompiled::GetValue(const TSettingRef& aRef, UValueWord& aValue)

    {

    HCR_FUNC("TRepositoryCompiled::GetValue");

    if (!IsWordValue(aRef))

        HCR_LOG_RETURN(KErrArgument);

	SSettingC* sptr = (SSettingC*)(aRef.iSet);

    aValue = sptr->iValue.iLit;

	return KErrNone;

    }

TInt HCR::TRepositoryCompiled::GetLargeValue(const TSettingRef& aRef, UValueLarge& aValue)

    {

    HCR_FUNC("TRepositoryCompiled::GetLargeValue");

    if (!IsLargeValue(aRef))

        HCR_LOG_RETURN(KErrArgument);