/*

* 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: Device driver for SVP Host file system access

*

*/

#ifdef __WINS__

#error - this driver cannot be built for emulation

#endif

#include <e32def.h>

#include <e32cmn.h>

#include <u32std.h>

#include <kernel.h>

#include <kern_priv.h>

#include <arm.h>

#include <cache.h>

#include <nkern.h>

#include <u32hal.h>

#include <system.h>

#include "rsvphostfsdriver.h"

#include "libfdt.h"

// Debug messages - uncomment define below

//#define SVPDBG 

#ifdef SVPDBG

#define DP(format...) Kern::Printf(format)

#else

#define DP(format...)

#endif

#define SVP_HOST_FS_DEVICE_ID  0xc51d0008

#define SVP_PLATFORM_DEVICE_ID 0xc51d1000

class DSVPHostFsDriverFactory : public DLogicalDevice

{

public:

	DSVPHostFsDriverFactory();

	virtual TInt Install();

	virtual void GetCaps(TDes8& aDes) const;

	virtual TInt Create(DLogicalChannelBase*& aChannel);

};

class DSVPHostFsChannel : public DLogicalChannel

{

public:

	DSVPHostFsChannel(DLogicalDevice* aLogicalDevice);

	~DSVPHostFsChannel();

	virtual TInt DoCreate(TInt aUnit, const TDesC* anInfo, const TVersion& aVer);	

	virtual void HandleMsg(TMessageBase* aMsg);

protected:

	virtual void DoCancel(TInt aReqNo);

	virtual TInt DoRequest(TInt aReqNo, TRequestStatus* aStatus, TAny* a1, TAny* a2);

	virtual TInt DoControl(TInt aFunction, TAny *a1, TAny *a2);

private:

	TInt MkDir(TSVPHostFsMkDirInfo* aInfo);

	TInt RmDir(TSVPHostFsRmDirInfo* aInfo);

	TInt Delete(TSVPHostFsDeleteInfo* aInfo);

	TInt Rename(TSVPHostFsRenameInfo* aInfo);

	TInt Replace(TSVPHostFsReplaceInfo* aInfo);

	TInt Entry(TSVPHostFsEntryInfo* aInfo);

	TInt SetEntry(TSVPHostFsSetEntryInfo* aInfo);

	TInt FileOpen(TSVPHostFsFileOpenInfo* aInfo);

	TInt FileClose(TUint32 aDrive, TUint32 aHandle);

	TInt FileRead(TSVPHostFsFileReadInfo* aInfo);

	TInt FileWrite(TSVPHostFsFileWriteInfo* aInfo);

	TInt FileSetSize(TSVPHostFsFileSetSizeInfo* aInfo);

	TInt FileSetEntry(TSVPHostFsSetEntryInfo* aInfo);

	TInt DirOpen(TSVPHostFsDirOpenInfo* aInfo);

	TInt Flush(TUint32 aDrive);

	TInt DirClose(TUint32 aDrive, TUint32 aHandle);

	TInt DirRead(TSVPHostFsDirReadInfo* aInfo);

	TInt GetID(TUint32 aDrive, TUint32 * aId);

        TInt SetUpDrives();

	TInt GetDriveMap(TAny * aMap);

private:

	DThread* iClientThread;

	TDfcQue* iDFCQue;

	TUint32 iDriveMap[DRIVE_MAP_SIZE] ; 

};

#define RET_IF_ERROR(v, e) { if ((v = (e)) != KErrNone) return v; }

#define	EDeviceID	0

#define	EOp		1

#define ETreeStart	1

#define	EResult		2

#define	EArg0		3

#define	EArg1		4

#define	EArg2		5

#define	EArg3		6

static inline TUint32 SVPReadReg(TUint32 dev, TUint32 aReg)

	{

	DP("** ReadReg @ 0x%08x (%d)",dev,aReg);

	return *(volatile TUint32 *)(dev + (aReg << 2));

	}

static inline void SVPWriteReg(TUint32 dev, TUint32 aReg, TUint32 aVal)

	{

	DP("** WriteReg @ 0x%08x (%d,%d)",dev,aReg,aVal);

	*(volatile TUint32*)(dev + (aReg << 2)) = aVal;

	}

static inline void SVPInvoke(TUint32 dev, TUint32 aVal)

	{

	DP("** Invoke @ 0x%08x (%d)",dev,aVal);

	*(TUint32*)(dev + (EOp << 2)) = aVal;

	}

/////////////////////////////////////////////////////////////////////////

//

// DSVPHostFsDriverFactory

//

/////////////////////////////////////////////////////////////////////////

//

// DSVPHostFsDriverFactory constructor

//

DSVPHostFsDriverFactory::DSVPHostFsDriverFactory()

	{

	DP("** (SVPHOSTFSDRIVER) DSVPHostFsDriverFactory::DSVPHostFsDriverFactory()");

	iVersion = TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber);    

	}

//

// DSVPHostFsDriverFactory::Create

//

TInt DSVPHostFsDriverFactory::Create(DLogicalChannelBase*& aChannel)

	{

	DP("** (SVPHOSTFSDRIVER) DSVPHostFsDriverFactory::Create()");

	aChannel = new DSVPHostFsChannel(this);

	return aChannel ? KErrNone : KErrNoMemory;

	}

//

// DSVPHostFsDriverFactory::Install

//

TInt DSVPHostFsDriverFactory::Install()

	{

	DP("** (SVPHOSTFSDRIVER) DSVPHostFsDriverFactory::Install()");

	return(SetName(&KSVPHostFsDriverName));

	}

//

// DSVPHostFsDriverFactory::Install

//

void DSVPHostFsDriverFactory::GetCaps(TDes8& aDes) const

	{

	DP("** (SVPHOSTFSDRIVER) DSVPHostFsDriverFactory::GetCaps()");

	TCapsSVPHostFsDriver b;

	b.iVersion = TVersion(KMajorVersionNumber, KMinorVersionNumber, KBuildVersionNumber);

	aDes.FillZ(aDes.MaxLength());

	aDes.Copy((TUint8 *)&b, Min(aDes.MaxLength(), sizeof(b)));

	}

/////////////////////////////////////////////////////////////////////////

//

// DSVPHostFsChannel implementation

//

/////////////////////////////////////////////////////////////////////////

//

// DSVPHostFsChannel constructor

//

DSVPHostFsChannel::DSVPHostFsChannel(DLogicalDevice* aLogicalDevice)

	{

	DP("** (SVPHOSTFSDRIVER) DSVPHostFsChannel::DSVPHostFsChannel()");

	iDevice = aLogicalDevice;

	iClientThread = &Kern::CurrentThread();

	iClientThread->Open();

	}

//

// DSVPHostFsChannel destructor

//

DSVPHostFsChannel::~DSVPHostFsChannel()

	{

	DP("** (SVPHOSTFSDRIVER) DSVPHostFsChannel::~DSVPHostFsChannel()");

	Kern::SafeClose((DObject*&)iClientThread, NULL);

	}

//

// DSVPHostFsChannel::DoCreate

//

TInt DSVPHostFsChannel::DoCreate(TInt /*aUnit*/, const TDesC* anInfo, const TVersion& aVer)

	{

	DP("** (SVPHOSTFSDRIVER) DSVPHostFsChannel::DoCreate()");

  	if (!Kern::QueryVersionSupported(TVersion(KMajorVersionNumber, KMinorVersionNumber, KBuildVersionNumber), aVer))

		return KErrNotSupported; 

	//Setup the driver for receiving client messages

	SetDfcQ(Kern::DfcQue0());

	iMsgQ.Receive();  	

	SetUpDrives();

	DP("** (SVPHOSTFSDRIVER) DSVPHostFsChannel::DoCreate()- checking device");

	TUint id = SVPReadReg(KHwSVPHostFileSystemDevice, EDeviceID);

	DP("** (SVPHOSTFSDRIVER) DSVPHostFsChannel::DoCreate()- checked device- 0x%08x -expected 0x%08x", 

		id, SVP_HOST_FS_DEVICE_ID);

	return id == SVP_HOST_FS_DEVICE_ID ? KErrNone :	KErrHardwareNotAvailable;

	}

TInt DSVPHostFsChannel::SetUpDrives()

	{

	DP("** (SVPHOSTFSDRIVER) DSVPHostFsChannel::SetUpDrives() @ 0x%08x", KHwSVPPlatformDevice) ;

	TUint32 platId = SVPReadReg(KHwSVPPlatformDevice, EDeviceID); 

	DP("** (SVPHOSTFSDRIVER) DSVPHostFsChannel::SetUpDrives()- checked device- 0x%08x -expected 0x%08x", 

		platId, SVP_PLATFORM_DEVICE_ID);

	if (platId != SVP_PLATFORM_DEVICE_ID) return KErrHardwareNotAvailable;

	TUint32 * fdt = (TUint32 *)((char *)(SVPReadReg(KHwSVPPlatformDevice, ETreeStart) + KHwSVPPlatformDevice)); 

	DP("** (SVPHOSTFSDRIVER) DSVPHostFsChannel::SetUpDrives()- device tree @ 0x%08x", fdt);

	// Iteratate over the tree looking for "syborg,hostfs" nodes.

	const char * compatible = "syborg,hostfs" ; 

	int offset = fdt_node_offset_by_compatible(fdt, -1, compatible);

	while (offset != -FDT_ERR_NOTFOUND) 

		{

		if (offset < 0)

			{

			DP("FDT: Node not found %d", offset) ;

			return KErrHardwareNotAvailable	; 

			}

		int lenp1, lenp2 = 0; 

		TUint32 * deviceAddressp = (TUint32 *)fdt_getprop(fdt,offset,"reg",&lenp1); 

		if (!deviceAddressp)

			{

			DP("FDT format error: reg %d", lenp1);

			return KErrHardwareNotAvailable	; 

			}

		TUint32 * driveNumberp = (TUint32 *)fdt_getprop(fdt,offset,"drive-number",&lenp2);

		if (!driveNumberp)

			{

			DP("FDT format error: drive-number %d", lenp2);

			return KErrHardwareNotAvailable	; 

			}

		TUint32 deviceAddressPhys = bswap_32(*deviceAddressp);

#define PhysicalToLinear(addr) ((addr & (~(Epoc::LinearToPhysical(KPrimaryIOBase)))) | KPrimaryIOBase)

		TUint32 deviceAddressLin = PhysicalToLinear(deviceAddressPhys) ; 

		TUint32 driveNumber = bswap_32(*driveNumberp) ;

		DP("FDT: dev address phys 0x%08x lin 0x%08x len1 %d drive number %08x len2 %d", 

			deviceAddressPhys, deviceAddressLin, lenp1, driveNumber, lenp2) ; 

		TUint32 fsId = SVPReadReg(deviceAddressLin, EDeviceID) ; 

		DP("FDT: dev id 0x%08x", fsId) ; 

		if (fsId != SVP_HOST_FS_DEVICE_ID) return KErrHardwareNotAvailable ;

		// we have a disagreement about the base number of the drives: 0 or 1?

		iDriveMap[driveNumber-1] = deviceAddressLin ; 

		offset = fdt_node_offset_by_compatible(fdt, offset, compatible);

		}

	return KErrNone;

	}

//

// DSVPHostFsChannel::DoCancel

//

void DSVPHostFsChannel::DoCancel(TInt aReqNo)

	{

	DP("** (SVPHOSTFSDRIVER) DSVPHostFsChannel::DoCancel() %x(%d)", aReqNo, aReqNo);

	}

//

// DSVPHostFsChannel::DoRequest

//

TInt DSVPHostFsChannel::DoRequest(TInt aReqNo, TRequestStatus* aStatus, TAny* a1, TAny* a2)

	{

	DP("** (SVPHOSTFSDRIVER) DSVPHostFsChannel::DoRequest() %x(%d)", aReqNo, aReqNo);

	TInt err = KErrGeneral;         

	(void)aStatus;

	switch(aReqNo)

		{

	        case RSVPHostFsDriver::EMkDir:

			{

			err = MkDir((TSVPHostFsMkDirInfo*)a1);

			break;

			}

	        case RSVPHostFsDriver::ERmDir:

			{

			err = RmDir((TSVPHostFsRmDirInfo*)a1);

			break;

			}

	        case RSVPHostFsDriver::EDelete:

			{

			err = Delete((TSVPHostFsDeleteInfo*)a1);

			break;

			}

	        case RSVPHostFsDriver::ERename:

			{

			err = Rename((TSVPHostFsRenameInfo*)a1);

			break;

			}

	        case RSVPHostFsDriver::EReplace:

			{

			err = Replace((TSVPHostFsReplaceInfo*)a1);

			break;

			}

	        case RSVPHostFsDriver::EEntry:

			{

			err = Entry((TSVPHostFsEntryInfo*)a1);

			break;

			}

	        case RSVPHostFsDriver::ESetEntry:

			{

			err = SetEntry((TSVPHostFsSetEntryInfo*)a1);

			break;

			}

	        case RSVPHostFsDriver::EFileOpen:

			{

			err = FileOpen((TSVPHostFsFileOpenInfo*)a1);

			break;

			}

	        case RSVPHostFsDriver::EDirOpen:

			{

			err = DirOpen((TSVPHostFsDirOpenInfo*)a1);

			break;

			}

	        case RSVPHostFsDriver::EFileClose:

			{

			err = FileClose((TUint32)a1, (TUint32)a2);

			break;

			}

	        case RSVPHostFsDriver::EFileRead:

			{

			err = FileRead((TSVPHostFsFileReadInfo*)a1);

			break;

			}

	        case RSVPHostFsDriver::EFileWrite:

			{

			err = FileWrite((TSVPHostFsFileWriteInfo*)a1);

			break;

			}

	        case RSVPHostFsDriver::EFileSetSize:

			{

			err = FileSetSize((TSVPHostFsFileSetSizeInfo*)a1);

			break;

			}

	        case RSVPHostFsDriver::EFileFlushAll:

			{

		    err = Flush((TUint32)a1);

			break;

			}

	        case RSVPHostFsDriver::EDirClose:

			{

		        err = DirClose((TUint32)a1, (TUint32)a2);

			break;

			}

	        case RSVPHostFsDriver::EDirRead:

			{

		        err = DirRead((TSVPHostFsDirReadInfo*)a1);

			break;

			}

	        case RSVPHostFsDriver::EGetDeviceID:

			{

		  err = GetID((TUint32)a1, (TUint32*)a2); 

			break;

			}

	        case RSVPHostFsDriver::EGetDriveMap:

			{

		        err = GetDriveMap((TUint32*)a1);

			break;

			}

		default:

			{

			err = KErrGeneral;

			}

		}

	if (KErrNone != err)

		{

		if (err == KErrNotSupported)

			{

			err = KErrNone; // trap KErrNotSupported

			}

		DP("Error %d from DoRequest %d", err, aReqNo);

		}

	return err;

	}

//

// DSVPHostFsChannel::DoControl

//

TInt DSVPHostFsChannel::DoControl(TInt aFunction, TAny* a1, TAny* a2)

	{

	DP("** (SVPHOSTFSDRIVER) DSVPHostFsChannel::DoControl()");

	DP("DoControl Function %d", aFunction);

	TInt err = KErrGeneral;         

	/* There should be a good reason to use a control rather than a request. */

	if (KErrNone != err)

		{

		if (err == KErrNotSupported)

			{

			err = KErrNone; // trap KErrNotSupported

			}

		DP("** (SVPHOSTFSDRIVER) Error %d from control function", err);

		}

	return err;

	}

void DSVPHostFsChannel::HandleMsg(TMessageBase* aMsg)

	{

	TThreadMessage& m = *(TThreadMessage*)aMsg;

	TInt id = m.iValue;

	DP("** (SVPHOSTFSDRIVER) DSVPHostFsChannel::HandleMsg() %x(%d)", id, id);

	if (id == (TInt)ECloseMsg)

		{

		m.Complete(KErrNone, EFalse); 

		return;

		}

	if (id == KMaxTInt)

		{

		// DoCancel

		DoCancel(m.Int0());

		m.Complete(KErrNone, ETrue); 

		return;

		}

	if (id < 0)

		{

		// DoRequest

		TRequestStatus* pStatus = (TRequestStatus*)m.Ptr0();

		TInt r = DoRequest(~id, pStatus, m.Ptr1(), m.Ptr2());

		//		if (r != KErrNone)

		Kern::RequestComplete(iClientThread,pStatus,r);

		m.Complete(KErrNone, ETrue);

		}

	else

		{

		// DoControl

		TInt r = DoControl(id, m.Ptr0(), m.Ptr1());

		m.Complete(r, ETrue);

		}

	}

TInt DSVPHostFsChannel::MkDir(TSVPHostFsMkDirInfo* aInfo)

	{

	DP("** (SVPHOSTFSDRIVER) DSVPHostFsChannel::MkDir()");

	TSVPHostFsMkDirInfo info;

	TInt err = KErrNone;

	RET_IF_ERROR(err, Kern::ThreadRawRead(iClientThread, aInfo, (TUint8*)&info, sizeof(TSVPHostFsMkDirInfo)));

	if (!info.iName)

		return KErrArgument;

	TUint16 pathData[KMaxPath];

	RET_IF_ERROR(err, Kern::ThreadRawRead(iClientThread, info.iName, (TUint8*)pathData, info.iLength*2));

	TUint32 device = iDriveMap[info.iDrive];

	SVPWriteReg(device, EArg0, Epoc::LinearToPhysical((TUint32)pathData));

	SVPWriteReg(device, EArg1, info.iLength);

	SVPWriteReg(device, EArg2, info.iFlags);

	SVPInvoke(device, RSVPHostFsDriver::EMkDir);

	//return SVPReadReg(device, EResult);

	err = SVPReadReg(device, EResult);

	if(err == KErrPathNotFound)

		err = KErrNotFound;

	return err;