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

// e32\memmodel\emul\nvram.cpp

// 

//

#include "plat_priv.h"

#include <assp.h>

#include <emulator.h>

#include "execs.h"

_LIT(KLitMachineConfigMutex,"MCConfMutex");

_LIT(KLitRamDriveMutex,"RamDriveMutex");

void K::InitNvRam()

	{

	__KTRACE_OPT(KBOOT,Kern::Printf("K::InitNvRam"));

	if (K::MutexCreate(K::MachineConfigMutex, KLitMachineConfigMutex, NULL, EFalse, KMutexOrdMachineConfig) != KErrNone)

		K::Fault(K::EMachineConfigMutexCreateFailed);

	TInt r=TInternalRamDrive::Create();

	if (r!=KErrNone)

		K::Fault(K::ERamDriveInitFailed);

	__KTRACE_OPT(KBOOT,Kern::Printf("K::InitNvRam() completed"));

	}

// Internal RAM Drive

// We emulated this on WINS by memory mapping a 2MB+4KB file (IRAMLDRV.BIN in the EmulatorMediaPath)

// The word of the last page of this file contains the nominal size of the RAM drive 'chunk'

const CHAR KIRamFileName[] = "IRAMLDRV.BIN";

TInt TInternalRamDrive::Create()

	{

	__KTRACE_OPT(KBOOT, Kern::Printf("TInternalRamDrive::Create()"));

	// create the RAM drive mutex

	TInt r = K::MutexCreate((DMutex*&)Mutex, KLitRamDriveMutex, NULL, EFalse, KMutexOrdRamDrive);

	if (r != KErrNone)

		return r;

	__KTRACE_OPT(KBOOT, Kern::Printf("RAM drive mutex created at %08x",Mutex));

	// locate/open the RAM drive

	CHAR filename[MAX_PATH];

	strcpy(filename, Arch::TheAsic()->EmulatorMediaPath());

	if (!Emulator::CreateAllDirectories(filename))

		return Emulator::LastError();

	strcat(filename, KIRamFileName);

	PP::RamDriveFile = CreateFileA(filename, GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_ALWAYS, FILE_FLAG_RANDOM_ACCESS, NULL);

	if (PP::RamDriveFile == INVALID_HANDLE_VALUE)

		return Emulator::LastError();

	TInt filesize = GetFileSize(PP::RamDriveFile, NULL);

	TInt size = 0;

	// deal with ram drives that were created on a real device and opened in the emulator

	// and also with ones created with a different max size setting

	if ((filesize&0x1ff) == 0)

		{

		// the file is from a real internal drive on a device

		size = filesize;

		}

	else if ((filesize&0x1ff) == sizeof(TRamDriveInfo))

		{

		// created by us

		DWORD bytes;

		if (SetFilePointer(PP::RamDriveFile, -4, NULL, FILE_END) == 0xffffffff

			|| !ReadFile(PP::RamDriveFile, &size, sizeof(size), &bytes, NULL))

			return Emulator::LastError();

		}

	if (size > PP::RamDriveMaxSize)

		PP::RamDriveMaxSize = size;

	// deal with a resized ram drive file

	if (filesize != PP::RamDriveMaxSize + TInt(sizeof(TRamDriveInfo)))

		{

		DWORD bytes;

		if (SetFilePointer(PP::RamDriveFile, PP::RamDriveMaxSize, NULL, FILE_BEGIN) == 0xffffffff

			|| !WriteFile(PP::RamDriveFile, &size, sizeof(size), &bytes, NULL)

			|| !SetEndOfFile(PP::RamDriveFile))

			return Emulator::LastError();

		}

	PP::RamDriveFileMapping = CreateFileMappingA(PP::RamDriveFile, NULL, PAGE_READWRITE, 0, PP::RamDriveMaxSize + sizeof(TRamDriveInfo), NULL);

	if (PP::RamDriveFileMapping == NULL)

		return Emulator::LastError();

	PP::RamDriveStartAddress = (TLinAddr)MapViewOfFile(PP::RamDriveFileMapping, FILE_MAP_WRITE, 0, 0, PP::RamDriveMaxSize + sizeof(TRamDriveInfo));

	if (PP::RamDriveStartAddress == NULL)

		return Emulator::LastError();

	PP::RamDriveInfo = (TRamDriveInfo*)(PP::RamDriveStartAddress + PP::RamDriveMaxSize);

	TheSuperPage().iRamDriveSize = size;

	return KErrNone;

	}

EXPORT_C TLinAddr TInternalRamDrive::Base()

//

// Return the Internal Ram Drive base address

//

	{

	return PP::RamDriveStartAddress;

	}

EXPORT_C TInt TInternalRamDrive::Size()

//

// Return the Internal Ram Drive size

//

	{

	return PP::RamDriveInfo->iSize;

	}

EXPORT_C TInt TInternalRamDrive::Adjust(TInt aNewSize)

//

// Adjust the size of the internal ram drive

//

	{

	if (aNewSize<0)

		return KErrArgument;

	if (aNewSize>PP::RamDriveMaxSize)

		return KErrDiskFull;

	if (aNewSize != PP::RamDriveInfo->iSize)

		PP::RamDriveInfo->iSize = aNewSize;

	return KErrNone;

	}

EXPORT_C void TInternalRamDrive::Wait()

	{

	Kern::MutexWait(*Mutex);

	}

EXPORT_C void TInternalRamDrive::Signal()

	{

	Kern::MutexSignal(*Mutex);

	}

void ExecHandler::UnlockRamDrive()

	{

	}

EXPORT_C void TInternalRamDrive::Unlock()

	{}

EXPORT_C void TInternalRamDrive::Lock()

	{}