/*
* 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;
    }