// 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