/*

 * 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:

 // This file is part of the NE1_TB Variant Base Port

 // Hardware Configuration Respoitory Platform Specific Layer (PSL) 

 //

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

 #include "hcr_debug.h"

 #include "hcr_hai.h"

 #include "hcr_uids.h"

 #include <plat_priv.h>

 #include <kernel/kernboot.h>

 #ifdef __WINS__

 // On WINS the EMapAttrSupRo and EMapAttrCachedMax doesn't exists

 #define EMapAttrSupRo       0x01

 #define EMapAttrCachedMax   0xF000

 #endif

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

 GLREF_C HCR::SRepositoryCompiled gRepository;

 #define BUFFER_OFFSET_ZERO  0

 // -- CLASSES- ----------------------------------------------------------------

 class HCRVariant : public HCR::MVariant

     {    

 public:

     HCRVariant();

     virtual ~HCRVariant();

 public:    

     TInt Initialise();

     TBool IgnoreCoreImgRepository();

 	TInt GetCompiledRepositoryAddress( TAny* & aAddr);

     TInt GetOverrideRepositoryAddress( TAny* & aAddr);

 private:

     DChunk * iChunk;    

     };

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

 HCRVariant::HCRVariant()

     : iChunk(0)

     {

     HCR_FUNC("HCRVariant");

     }

 HCRVariant::~HCRVariant()

     {

     HCR_FUNC("~HCRVariant");

     if (iChunk != 0)

         {

         NKern::ThreadEnterCS();    

         TInt r = Kern::ChunkClose(iChunk);

         __NK_ASSERT_ALWAYS(r!=0);

         NKern::ThreadLeaveCS(); 

         }

     }

 TInt HCRVariant::Initialise()

     {

     HCR_FUNC("HCRVariant::Initialise");

     HCR_TRACE_RETURN(KErrNone);

     }

 TInt HCRVariant::GetCompiledRepositoryAddress( TAny* & aAddr)

     {

     HCR_FUNC("HCRVariant::GetCompiledRepositoryAddress");

     aAddr = static_cast<TAny*>(&gRepository);

     HCR_TRACE_RETURN(KErrNone);

     }

 TBool HCRVariant::IgnoreCoreImgRepository()

     {

     HCR_FUNC("HCRVariant::IgnoreCoreImgRepository");

     HCR_TRACE_RETURN(EFalse);

     }

 TInt HCRVariant::GetOverrideRepositoryAddress( TAny* & aAddr)

     {

     HCR_FUNC("HCRVariant::GetRAMRepositoryAddress");

     aAddr = 0;

 	// Note: the SMR feature by which we obtain the address of the override

 	// repository is only supported in the ARM bootstrap, not X86 or WINS so 

 	// this test code needs conditional compilation.

 #if !defined(__WINS__) && !defined(__X86__)

     // Note to future implementor:

 	// #include <kernel\kernboot.h>

 	// First check to see if SMRIB was created during boot time. 

     // If SSuperPageBase::iSmrData == KSuperPageAddressFieldUndefined (i.e. -1) 

 	// it does not exist, return KErrNotSupported, SMR not support by base port

     // or it is not available due to boot scenario, i.e. boot from MMC

     //

     // If it does exist (i.e. boot from NAND) then read and process the 

 	// SMR entries listed in the SMRIB looking for KHCRUID_SMRPayloadUID.

 	// Next using the internal sizes from the HCR dat file within the SMR image

 	// determine if the RAM holding the SMR image can be shrunk to return 

 	// unused RAM pages at the end of the image.

 	// 

 	// Finally allocate the reserved RAM identified in the SMR entry to a 

 	// DChunk and return the virtual address of the HCR data file payload

 	// within the SMR image, i.e. iBase+(sizeof(SSmrRomHeader)>>2).

     // Locate SMRIB 

     const TSuperPage& superpage = Kern::SuperPage();

    	TUint32* smrIB;

    	smrIB = (TUint32 *) superpage.iSmrData;

    	HCR_TRACE2("--- Superpage: 0x%08x, SMRIB: 0x%08x", &superpage, smrIB);

    	if( (smrIB == NULL) || (smrIB == (TUint32*)KSuperPageAddressFieldUndefined))

    	    {

         HCR_TRACE_RETURN(KErrNotSupported);   	        

    	    }

    	HCR_HEX_DUMP_ABS((TUint8 *)smrIB, 8*sizeof(SSmrBank) );

     SSmrBank * smrBank = (SSmrBank *) smrIB;

     // T_HCRUT designed to work ith the second HCR SMR image as the first 

 	// is used by the t_hcr test suite.

     int smrInst = 2;

     while( smrBank->iBase != 0 ) 

         {

         HCR_TRACE2("--- smrBank: 0x%08x, smrBank->iPayloadUID: 0x%08x", smrBank, smrBank->iPayloadUID);

         if (smrBank->iPayloadUID == KHCRUID_SMRPayloadUID)

             {

             smrInst--;

 			if (smrInst == 0) // PSL to use only the 2nd HCR SMR image

 			    {

 	            HCR_TRACE2("--- smrPhysAddr: 0x%08x, size:0x%08x", smrBank->iBase, smrBank->iSize);

 	            NKern::ThreadEnterCS();

 	            TChunkCreateInfo info;

 	            info.iType = TChunkCreateInfo::ESharedKernelSingle;

 	            info.iMaxSize = smrBank->iSize;

 	            // Enable to give supervisor read only access and maximum caching at both L1 and L2.

 	            info.iMapAttr = EMapAttrSupRo|EMapAttrCachedMax;  

 	            info.iOwnsMemory = EFalse; 

 	            info.iDestroyedDfc = NULL;

 	            TUint32 mapAttr;

 	            TLinAddr chunkKernAddr;

 	            TInt r = Kern::ChunkCreate(info, iChunk, chunkKernAddr, mapAttr);

 	            if( r != KErrNone )

 	                {

 	                HCR_TRACE1("--- Kern::ChunkCreate failed: 0x%08x", r);

 	                NKern::ThreadLeaveCS();

 	                HCR_TRACE_RETURN(r);

 	                }

 	            r = Kern::ChunkCommitPhysical(iChunk, BUFFER_OFFSET_ZERO, smrBank->iSize, smrBank->iBase);

 	            if( r != KErrNone)

 	                {

 	                HCR_TRACE1("--- Kern::ChunkCommitPhysical failed: 0x%08x", r);

 	                TInt r2 = Kern::ChunkClose(iChunk);

 	                __NK_ASSERT_ALWAYS(r2!=0);

 	                NKern::ThreadLeaveCS();

 	                HCR_TRACE_RETURN(r);    

 	                }   

 	            NKern::ThreadLeaveCS();

 	            HCR_TRACE1("--- iChunkKernAddr: 0x%08x", chunkKernAddr);    

 	            // It should contains SMR and HCR image headers and some settings

 	            HCR_HEX_DUMP_ABS((TUint8 *)chunkKernAddr, 1024 );  

 	            // Skip the SMR header, so we return the address of the first byte in the Repository

 	            aAddr = (TAny *) (chunkKernAddr + sizeof(SSmrRomHeader));  

 	            HCR_TRACE_RETURN(KErrNone);

 	            }

 	        }

         ++smrBank;    

         }

 #endif // !__WINS__ && !__X86__

     HCR_TRACE_RETURN(KErrNotSupported);

     }

 // -- ENTRY POINTS ------------------------------------------------------------

 GLDEF_C HCR::MVariant* CreateHCRVariant()

     {

     HCR_FUNC("CreateHCRVariant");

     return new HCRVariant;

     }