// Copyright (c) 1995-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\include\d32locd.h
// 
// WARNING: This file contains some APIs which are internal and are subject
//          to change without notice. Such APIs should therefore not be used
//          outside the Kernel and Hardware Services package.
//

#ifndef __D32LOCD_H__
#define __D32LOCD_H__
#include <e32cmn.h>
#include <partitions.h>


/**
@publishedPartner
@released

Local media IDs.

A media ID is passed to LocDrv::RegisterMediaDevice() when registering
a media driver with the local media subsystem.
*/
enum TMediaDevice { EFixedMedia0, EFixedMedia1, EFixedMedia2, EFixedMedia3,
					EFixedMedia4, EFixedMedia5, EFixedMedia6, EFixedMedia7,
					ERemovableMedia0, ERemovableMedia1, ERemovableMedia2, ERemovableMedia3,
					EInvalidMedia
				};

#define __IS_REMOVABLE(aDevice) (aDevice>=ERemovableMedia0 && aDevice<=ERemovableMedia3)
#define __IS_FIXED(aDevice) ((TUint)aDevice<=EFixedMedia7)
#define MEDIA_DEVICE_IRAM EFixedMedia0
#define MEDIA_DEVICE_LFFS EFixedMedia1
#define MEDIA_DEVICE_NAND EFixedMedia2
#define MEDIA_DEVICE_MMC ERemovableMedia0
#define MEDIA_DEVICE_PCCARD ERemovableMedia1
#define MEDIA_DEVICE_CSA ERemovableMedia2

typedef signed int TSocket;

class TLDriveAssignInfo
/**
No longer used
@internalComponent
@removed
*/
	{
public:
	TMediaDevice iDevice;
	TInt iPriority;
	};

class TMediaDeviceAssignInfo
/**
No longer used
@internalComponent
@removed
*/
	{
public:
	TInt iFirstMedia;
	TInt iLastMedia;	
	};

class TLocalDriveCaps
/**
Drives media capabilities fields

@publishedPartner
@released
*/
	{
public:
	IMPORT_C TLocalDriveCaps();
public:
	/**
	Size of drive
	
	Note : This is the size of the partition, not the entire media.
		   The entire media size can be obtained from TLocalDriveCapsV4::MediaSizeInBytes()
	*/
	TInt64 iSize;
	/**
	Media Type of drive
	*/
	TMediaType iType;
	/**
	Connection type used to interface to the media
	*/
	TConnectionBusType iConnectionBusType;
	/**
	Attributes of the drive
	*/
	TUint iDriveAtt;
	/**
	Attributes of underlying media 
	*/
	TUint iMediaAtt;
	/**
	Base address of media
	*/
    TUint8* iBaseAddress;
	/**
	Identity of the file system used for this media
	*/
	TUint16 iFileSystemId;
	/**
	Partition type of media
	*/
	TUint16	iPartitionType;
	};
typedef TPckgBuf<TLocalDriveCaps> TLocalDriveCapsBuf;
//
class TLocalDriveCapsV2 : public TLocalDriveCaps
/**
Extension to Capabilities fields mainly to support Nor flash

@publishedPartner
@released
*/
	{
public:
	/**
	Number of hidden sectors on drive
	*/
	TUint iHiddenSectors;
	/**
	Size of erase unit on media
	*/
	TUint iEraseBlockSize;
    };
typedef TPckgBuf<TLocalDriveCapsV2> TLocalDriveCapsV2Buf;
//



/**
This class is used to provide file system-specific parameters for media formatting.
@see TInt RFormat::Open(RFs &aFs, const TDesC &aName, TUint aFormatMode, TInt &aCount, const TDesC8 &anInfo);"

For example, for FAT file system it is possible to specify FAT type(12/16/32), 
cluster size, number of FATs and number of reserved sectors. Note that not all 
combinations of custom parameters can be compatible; some media types, like SD 
can reject formatting with user-defined parameters.

@publishedPartner
@released

*/
class TLDFormatInfo
	{
public:
    inline TLDFormatInfo();
public:

    TInt64 iCapacity;				///< Format Capacity
	TUint16 iSectorsPerCluster;		///< Specified sectors per cluster
	TUint16 iSectorsPerTrack;		///< Specified sectors per track
	TUint16 iNumberOfSides;			///< Specified number of sides

	enum TFATBits {EFBDontCare, EFB12 = 12, EFB16 = 16, EFB32 = 32};
	TFATBits iFATBits;				///< Specified bits per fat table entry

	TUint16 iReservedSectors;	///< Reserved sector count, required for SD card compliance
	
	// Flags field. Allows the number of FAT tables to be specified: set both bits to zero to use the default.
	enum TFlags {EOneFatTable = 0x01, ETwoFatTables = 0x02};
	TUint8 iFlags;

	TUint8 iPad;				///< Padding for offset alignment  between kernel and user code

	};
typedef TPckgBuf<TLDFormatInfo> TSpecialFormatInfoBuf;


//
class TLocalDriveCapsV3 : public TLocalDriveCapsV2
/**
Extension to Capabilities fields mainly to support removable media format specifications

@publishedPartner
@released
*/
	{
public:
	/**
	Format specification
	*/
	TLDFormatInfo iFormatInfo;
	/**
	Set if iFormatInfo is valid
	*/
	TBool iExtraInfo;
	/**
	*/
	TInt iMaxBytesPerFormat;
    };
//The following ASSERTs checks for offset of any TInt64 member be a multiple of 8 as per DEF045510
__ASSERT_COMPILE(_FOFF(TLocalDriveCaps,iSize)%8 == 0);
__ASSERT_COMPILE(_FOFF(TLocalDriveCapsV3,iFormatInfo.iCapacity) % 8 == 0);


typedef TPckgBuf<TLocalDriveCapsV3> TLocalDriveCapsV3Buf;
//
class TLocalDriveCapsV4 : public TLocalDriveCapsV3
/**
Extension to Capabilities fields mainly to support Nand flash

@publishedPartner
@released
*/
	{
public:
	union
		{
		/**
		Number of blocks (for NAND flash)
		 - The entire capacity of NAND media can be calculated using:
		   capacity = iNumOfBlocks * iNumPagesPerBlock * iNumBytesMain
		*/
		TInt iNumOfBlocks;
		/**
		Number of sectors (for other types of media)
		 - The entire capacity of sector based media can be calculated using:
		   capacity = iNumberOfSectors * iSectorSizeInBytes
		*/
		TUint32 iNumberOfSectors;
		};

	/**
	Number of pages per block
	*/
	TInt iNumPagesPerBlock;

	union
		{
		/**
		Number of Bytes in the main array (for NAND flash)
		 - The entire capacity of NAND media can be calculated using:
		   capacity = iNumOfBlocks * iNumPagesPerBlock * iNumBytesMain
		*/
		TInt iNumBytesMain;
		/**
		Number of Bytes in a sector (for other types of media)
		 - The entire capacity of sector based media can be calculated using:
		   capacity = iNumberOfSectors * iSectorSizeInBytes
		*/
		TUint32 iSectorSizeInBytes;
		};

	/**
	Number of Bytes in the spare array
	*/
	TInt iNumBytesSpare;
	/**
	Effective usable blocks
	*/
	TInt iEffectiveBlks;
	/**
	Start page of drive
	*/
	TInt iStartPage;
public:
	inline TInt64 MediaSizeInBytes();
    };
typedef TPckgBuf<TLocalDriveCapsV4> TLocalDriveCapsV4Buf;
//
class TLocalDriveCapsV5 : public TLocalDriveCapsV4
/**
Add serial number support for certain media.

@publishedPartner
@released
*/
	{
public:
	/**
    Serial number buffer length, 0 if not supported
	*/
    TUint iSerialNumLength;
	/**
    Serial number buffer
	*/
	TUint8 iSerialNum[KMaxSerialNumLength];
	};
typedef TPckgBuf<TLocalDriveCapsV5> TLocalDriveCapsV5Buf;

//
/**
Extension to Capabilities fields mainly to support reporting block size 
information of underlying media.
    
@publishedPartner
@released
*/
class TLocalDriveCapsV6 : public TLocalDriveCapsV5
	{
public:
	/**
	Block size information of underlying media is required to assist in chosing 
	efficient size of buffers for reading and writing.
	This information can also be accessed through the function
	- RFs::VolumeIOParam

	These functions retrieve this blocksize information by calling the media
	driver's Caps() function.
	*/
    TUint 	iBlockSize;
    
private:
    /**
    Reserved space for future use.
    */
    TUint32	iSpare[4];
	};
typedef TPckgBuf<TLocalDriveCapsV6> TLocalDriveCapsV6Buf;


class TLocalDriveCapsV7 : public TLocalDriveCapsV6
/**
Add control mode, object mode, partition size for M18 NOR Flash.
*/
	{
public:
    TUint32 iWriteBufferSize;
	TUint32 iPartitionSize;
    TUint32 iControlModeSize;
    TUint32 iObjectModeSize;
	};

typedef TPckgBuf<TLocalDriveCapsV7> TLocalDriveCapsV7Buf;

//
class TFormatInfo
/**
Format information class

@publishedPartner
@released
*/
	{
public:
	IMPORT_C TFormatInfo();
public:
	TBool iFormatIsCurrent;
	TInt i512ByteSectorsFormatted; 
	TInt iMaxBytesPerFormat;
	};
//
class TErrorInfo
/**
@internalTechnology
  */
	{
public:
	enum TReasonCode
		{
		ENoError=0,			//No error
		EBadSector=1,	//Error due to corrupt sector
		};
public:
    TReasonCode iReasonCode;
	union
		{
		// holds position error occurred for KErrCorrupt
		// It numerically equals number of bytes succesfully read/written during
		// last disk operation.
		TInt64 iErrorPos;
        TInt iOtherInfo;
		};
    };
typedef TPckgBuf<TErrorInfo> TErrorInfoBuf;
//
class TLocalDriveMessageData
/**
@internalTechnology
*/
	{
public:
	inline TLocalDriveMessageData()
		{}
	inline TLocalDriveMessageData(TInt64 aPos, TInt aLength, const TAny* aPtr, TInt aHandle, TInt anOffset, TInt aFlags)
		: iPos(aPos), iLength(aLength), iPtr(aPtr), iHandle(aHandle), iOffset(anOffset), iFlags(aFlags)
		{}
public:
	TInt64 iPos;
	TInt iLength;
	const TAny* iPtr;
	TInt iHandle;
	TInt iOffset;
	TInt iFlags;
	};

class TLocalDriveControlIOData
/**
Control IO data class

@internalTechnology
*/
	{
public:
	inline TLocalDriveControlIOData()
		{}
	inline TLocalDriveControlIOData(TInt aCommand, TAny* aParam1, TAny* aParam2, TInt aHandle)
		: iCommand(aCommand), iParam1(aParam1), iParam2(aParam2), iHandle(aHandle)
		{}
	inline TLocalDriveControlIOData(TInt aCommand, TUint8* aBuf, TInt aParam, TInt aLength)
		: iCommand(aCommand), iParam1(aBuf), iParam2((TAny*) aParam), iHandle(aLength)
		{}
public:
	TInt iCommand;
	TAny* iParam1;
	TAny* iParam2;
	TInt iHandle;
	};

class TLocalDrivePasswordData
/**
Password store for password protected media

@internalTechnology
*/
	{
public:
	TLocalDrivePasswordData(const TDesC8& aOldPasswd, const TDesC8& aNewPasswd, TBool aStorePasswd)
		: iOldPasswd(&aOldPasswd), iNewPasswd(&aNewPasswd), iStorePasswd(aStorePasswd)
		{}
	TLocalDrivePasswordData()
		: iOldPasswd(&KNullDesC8), iNewPasswd(&KNullDesC8), iStorePasswd(EFalse)
		{}
public:
	const TDesC8 *iOldPasswd;
	const TDesC8 *iNewPasswd;
	TBool iStorePasswd;
	};
typedef TPckgBuf<TLocalDrivePasswordData> TLocalDrivePasswordDataPckg;


class TPasswordStore
/**
@internalTechnology
*/
	{
public:
	virtual TInt Init()=0;
	virtual TInt ReadPasswordData(TDes8 &aBuf)=0;
	virtual TInt WritePasswordData(TDesC8 &aBuf)=0;
	virtual TInt PasswordStoreLengthInBytes()=0;
	enum {EMaxPasswordLength=1024}; /**< Size of the password store write buffer, which may contain multiple password mappings */
	};

class TMountInfoData
/**
@internalTechnology
*/
	{
public:
	TDesC8* iInfo;
	TAny* iThread;
	};


const TInt KLocalDriveMajorVersion=1;
const TInt KLocalDriveMinorVersion=0;
const TInt KLocalDriveBuildVersion=160;
_LIT(KLitLocalDriveLddName,"LocDrv");

const TInt KLocalMessageHandle=-1;


enum TMediaPagingStats
	{
	EMediaPagingStatsAll,
	EMediaPagingStatsRomAndCode = EMediaPagingStatsAll,	// @deprecated - use EMediaPagingStatsAll instead
	EMediaPagingStatsRom,
	EMediaPagingStatsCode,
	EMediaPagingStatsDataIn,
	EMediaPagingStatsDataOut,
	};

/**
Paging media details - for testing purposes only
This is a structure used to communicate paging-related information
from the paging media driver to an application.

@internalTechnology
@prototype
*/
class TPageDeviceInfo
	{
public:
	TInt	iReservoirBlockCount;	// number of blocks in replacement reservoir (used & unused)
	TInt	iBadBlockCount;			// numer of bad blocks
	};
typedef TPckgBuf<TPageDeviceInfo> TPageDeviceInfoBuf;

class RLocalDrive : public RBusLogicalChannel
/**
Interface class to local media

@internalTechnology
*/
	{
public:
	enum TControl
		{
		EControlRead=0,							/**< Read request */
		EControlWrite=1,						/**< Write request */
		EControlCaps=2,							/**< Caps request */
		EControlFormat=3,						/**< Format request */
		EControlEnlarge=4,						/**< Enlarge drive request */
		EControlReduce=5,						/**< Reduce Drive  request */
		EControlForceMediaChange=6,				/**< Force media change request */
		EControlMediaDevice=7,					/**< Return the media device request */
		EControlPasswordLock=8,					/**< Password lock media request */
		EControlPasswordUnlock=9,				/**< Password unlock media request */
		EControlPasswordClear=10,				/**< Password clear request */
		EControlNotifyChange=11,				/**< Notify change request */
		EControlNotifyChangeCancel=12,			/**< Notify change cancel request */
		EControlReadPasswordStore=13,			/**< Read password request */
		EControlWritePasswordStore=14,			/**< Write password request */
		EControlPasswordStoreLengthInBytes=15,	/**< Password request */
		EControlIsRemovable=16,					/**< Query removable request */
		EControlSetMountInfo=17,				/**< Set mount info request */
		EControlControlIO=18,					/**< Control IO request */
		EControlPasswordErase=19,				/**< Password erase media request */
		EControlDeleteNotify=20,				/**< Delete notification */
		EControlGetLastErrorInfo=21,			/**< Get last error info request */
		EControlQueryDevice=22,					/**< Query device  request*/
		};

	enum TRemountFlags
		{
		ELocDrvRemountNotifyChange	   = 0,		/**< Notify clients of media change but don't remount */
		ELocDrvRemountForceMediaChange = 1,		/**< Notify clients of media change and remount	*/
		};

	enum TReadWriteFlags
		{
		ELocDrvMetaData					= 0x80000000,	/**< Set if read/write request is for metadata */
		ELocDrvWholeMedia				= 0x40000000	/**< Set to access whole media, rather than partition */
		};

	enum TQueryDevice
		{ 
		// Symbian publishedPartner range
		EQuerySymbianPublishedPartnerFirst	= 0x0000,
		EQuerySymbianPublishedPartnerLast	= 0x3FFF,
		
		// Symbian test range
		EQuerySymbianTestFirst				= 0x4000,
		EQuerySymbianTestLast				= 0x7FFF,
		
		// Licensee range
		EQueryLicenseeFirst					= 0x8000,
		EQueryLicenseeLast					= 0xBFFF,
		
		EQueryPageDeviceInfo = EQuerySymbianTestFirst,	/**< @see TPageDeviceInfo */
		};
public:
	inline TVersion VersionRequired() const;
	inline TInt Connect(TInt aDriveNumber, TBool& aChangedFlag);
	inline TInt Enlarge(TInt aLength);
	inline TInt Reduce(TInt aPos, TInt aLength);
	inline TInt Read(TInt64 aPos, TInt aLength, const TAny* aTrg, TInt aMessageHandle, TInt aOffset, TInt aFlags);
	inline TInt Read(TInt64 aPos, TInt aLength, const TAny* aTrg, TInt aMessageHandle, TInt anOffset);
	inline TInt Read(TInt64 aPos, TInt aLength, TDes8& aTrg);
	inline TInt Write(TInt64 aPos, TInt aLength, const TAny* aSrc, TInt aMessageHandle, TInt aOffset, TInt aFlags);
	inline TInt Write(TInt64 aPos, TInt aLength, const TAny* aSrc, TInt aMessageHandle, TInt anOffset);
	inline TInt Write(TInt64 aPos, const TDesC8& aSrc);
	inline TInt Caps(TDes8& anInfo);
	inline TInt Format(TInt64 aPos, TInt aLength);
	inline TInt ForceMediaChange(TInt aMode=0);
	inline void NotifyChange(TRequestStatus* aStatus);
	inline void NotifyChangeCancel();
	inline TInt SetMountInfo(const TDesC8* aInfo,TInt aMessageHandle);
	inline TMediaDevice MediaDevice();
	inline TInt IsRemovable(TInt& aSocketNum);
	inline TInt ControlIO(TInt aCommand, TAny* aParam1, TAny* aParam2);
	inline TInt ControlIO(TInt aCommand, TDes8& aBuf, TInt aParam);
	inline TInt ControlIO(TInt aCommand, TDesC8& aBuf, TInt aParam);
	inline TInt ControlIO(TInt aCommand, TInt aParam1, TInt aParam2);
	inline TInt Unlock(const TDesC8& aPassword, TBool aStorePassword);
	inline TInt SetPassword(const TDesC8& aOldPassword, const TDesC8& aNewPassword, TBool aStorePassword);
	inline TInt Clear(const TDesC8& aPassword);
	inline TInt ErasePassword();
	inline TInt ReadPasswordData(TDesC8& aStoreData);
	inline TInt WritePasswordData(const TDesC8& aStoreData);
	inline TInt PasswordStoreLengthInBytes();
	inline TInt DeleteNotify(TInt64 aPos, TInt aLength);
	inline TInt GetLastErrorInfo(TDesC8& aErrorInfo);
	inline TInt QueryDevice(TQueryDevice aQueryDevice, TDes8 &aBuf);
	};
//
#ifndef __KERNEL_MODE__
class TBusLocalDrive : public RLocalDrive
/**
@internalTechnology
*/
	{
public:
	IMPORT_C TBusLocalDrive();
	IMPORT_C TInt Connect(TInt aDriveNumber, TBool& aChangedFlag);
	IMPORT_C void Disconnect();
	IMPORT_C TInt Enlarge(TInt aLength);
	IMPORT_C TInt ReduceSize(TInt aPos, TInt aLength);
	IMPORT_C TInt Read(TInt64 aPos,TInt aLength,const TAny* aTrg,TInt aMessageHandle,TInt aOffset,TInt aFlags);
	IMPORT_C TInt Read(TInt64 aPos,TInt aLength,const TAny* aTrg,TInt aMessageHandle,TInt anOffset);
	IMPORT_C TInt Read(TInt64 aPos,TInt aLength,TDes8& aTrg);
	IMPORT_C TInt Write(TInt64 aPos,TInt aLength,const TAny* aSrc,TInt aMessageHandle,TInt aOffset,TInt aFlags);
	IMPORT_C TInt Write(TInt64 aPos,TInt aLength,const TAny* aSrc,TInt aMessageHandle,TInt anOffset);
	IMPORT_C TInt Write(TInt64 aPos,const TDesC8& aSrc);
	IMPORT_C TInt Caps(TDes8& anInfo);
	IMPORT_C TInt Format(TFormatInfo& anInfo);
	IMPORT_C TInt Format(TInt64 aPos,TInt aLength);
	IMPORT_C TInt SetMountInfo(const TDesC8* aMountInfo,TInt aMessageHandle);
	IMPORT_C TInt ForceRemount(TUint aFlags=0);
	IMPORT_C TInt ControlIO(TInt aCommand, TAny* aParam1, TAny* aParam2);
	IMPORT_C TInt ControlIO(TInt aCommand, TDes8& aBuf, TInt aParam);
	IMPORT_C TInt ControlIO(TInt aCommand, TDesC8& aBuf, TInt aParam);
	IMPORT_C TInt ControlIO(TInt aCommand, TInt aParam1, TInt aParam2);

	IMPORT_C TInt Unlock(const TDesC8& aPassword, TBool aStorePassword);
	IMPORT_C TInt SetPassword(const TDesC8& aOldPassword, const TDesC8& aNewPassword, TBool aStorePassword);
	IMPORT_C TInt Clear(const TDesC8& aPassword);
	IMPORT_C TInt ErasePassword();
	IMPORT_C TInt ReadPasswordData(TDes8 &aBuf);
	IMPORT_C TInt WritePasswordData(const TDesC8 &aBuf);
	IMPORT_C TInt PasswordStoreLengthInBytes();
	IMPORT_C TInt DeleteNotify(TInt64 aPos, TInt aLength);
	IMPORT_C TInt GetLastErrorInfo(TDes8& aErrorInfo);

	IMPORT_C TInt QueryDevice(TQueryDevice aQueryDevice, TDes8 &aBuf);

public:
	inline TInt& Status() {return(iStatus);}
private:
	TInt CheckMount();
private:
	TInt iStatus;
	};
#endif

#define _LOCKABLE_MEDIA

#include <d32locd.inl>
#endif