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

// Thread for reading and writing to a drive.

// 

//

/**

 @file

 @internalTechnology

*/

#ifndef __RWDRIVETHREAD_H__

#define __RWDRIVETHREAD_H__

#ifdef MSDC_MULTITHREADED

typedef void (*ProcessWriteCompleteFunc)(TUint8* aAddress, TAny* aPtr);

/**

Class contains buffer for data with associated drive offset and length in bytes.

*/

class TBlockDesc

{

public:

	TBlockDesc();

	void SetPtr(TPtr8& aDes);

	TPtr8 GetReadBuffer();

	TPtr8 GetReadBuffer(TUint aLength, const TInt64& aOffset);

public:

	TInt64 iByteOffset;

	TUint iLength;

	TPtr8 iBuf;

};

/**

Class contains two buffers. Whilst one buffer is being read the

other buffer can be written to. The buffers should be accessed 

by the buffer pointers iDescReadPtr and iDescWritePtr.

*/

class TBlockDescBuffer

{

public:

	TBlockDescBuffer();

	void SwapDesc();

	TInt MaxLength() const {return iDesc2.iBuf.MaxLength();}

	TInt GetBufferNumber(const TPtr8* aBufferPtr) const;

	void SetUpReadBuf(TPtr8& aDes1, TPtr8& aDes2);

public:

	/** Points to block descriptor containing buffer to read from */

	TBlockDesc* iDescReadPtr;

	/** Points to block descriptor containing buffer to write to */

	TBlockDesc* iDescWritePtr;

private:

	/** Block descriptor for read/write operations */

	TBlockDesc iDesc1;

	/** Block descriptor for read/write operations */

	TBlockDesc iDesc2;

};

/**

Provides the common thread context used by CReadDriveThread and CWriteDriveThread 

classes.

*/

class CThreadContext : public CBase

{

public:

	static CThreadContext* NewL(const TDesC& aName,

								TThreadFunction aThreadFunction,

								TAny* aOwner);

	~CThreadContext();

private:

	CThreadContext();

	void ConstructL(const TDesC& aName, TThreadFunction aThreadFunction, TAny* aOwner);

public:

	void Resume() {iThread.Resume();}

	TInt MaxBufferLength() const {return iBuffer.MaxLength();} 

	TPtr8 GetReadBuffer();

	TPtr8 GetReadBuffer(TInt aLength);

	TPtrC8 WriteBuf();

public:

	/** Used to tell thread which drive to use */

	CMassStorageDrive* iDrive;

	/** Used by the thread to return error code */

	TInt iError;

	/** CS to regulate read/write buffer access */

	RCriticalSection iCritSect;

	/** buffer for reading and writing */

	TBlockDescBuffer iBuffer;

public:

	RThread iThread;

};

/**

Separate disk writer thread, used to implement OUT transfer double-buffering.

*/

class CWriteDriveThread : public CBase

	{

public:

	static CWriteDriveThread* NewL();

	~CWriteDriveThread();

private:

	CWriteDriveThread();

	void ConstructL();

public:

	TBlockDesc* GetReadDesc();

	TInt WriteDriveData(CMassStorageDrive* aDrive, const TInt64& aOffset, TPtrC8& aDes, ProcessWriteCompleteFunc aFunc, TAny* aPtr);

	TUint WriteBufferLength() const {return iThreadContext->iBuffer.iDescWritePtr->iBuf.Length();}

	TUint ReadBufferLength() const {return iThreadContext->iBuffer.iDescReadPtr->iBuf.Length();}

	TInt DeferredError() const {return iThreadContext->iError;}

	void ClearDeferredError() {iThreadContext->iError = KErrNone;}

	void WaitForWriteEmpty();

	TBool IsRecentlyWritten(TInt64 aOffset, TInt aLength);

	inline void SetCommandWrite10(TBool aIsWriteCommand) {iIsCommandWrite10 = aIsWriteCommand;};

private:

	static TInt ThreadFunction(TAny* aSelf);

	TInt WriteToDrive();

public:

	/** Thread context */

	CThreadContext* iThreadContext;

	TInt iWriteCounter;

private:

	/** Semaphore for reading USB */

	RSemaphore iProducerSem;

	/** Semaphore for writing to drive */

	RSemaphore iConsumerSem;

	/* Call back to tell transport that 'transfer' was written and the corresponding buffer can be overwriiten (mainly for SC LDD) */

	ProcessWriteCompleteFunc iCallback;

	TAny* iCallbackParameter;

	/* Flag set to true if the command is Write10. Used in Read10 to ignore pre-read if the previous command was Write10 */

	TBool iIsCommandWrite10;

	};

/**

Separate disk reader thread, used to implement IN transfer double-buffering.

*/

class CReadDriveThread : public CBase

	{

public:

	static CReadDriveThread* NewL();

	~CReadDriveThread();

private:

	CReadDriveThread();

	void ConstructL();

public:

	TBool ReadDriveData(CMassStorageDrive* aDrive, const TInt64& aOffset, TUint32 aLength, TBool aIgnoreCache);

	void DiscardRead();

private:

	static TInt ThreadFunction(TAny* aSelf);

	TInt ReadFromDrive();

public:

	/** Thread context */

	CThreadContext* iThreadContext;

	TBool iCompleted;

private:

	TBool iThreadRunning;

	};

//-----------------------------------------------

/**

Swap the buffer which the read and write buffer pointers are pointing to.

*/

inline void TBlockDescBuffer::SwapDesc()

{

	TBlockDesc* const tmp = iDescReadPtr;

	iDescReadPtr = iDescWritePtr;

	iDescWritePtr = tmp;

}

inline TPtr8 TBlockDesc::GetReadBuffer()

{

	return iBuf.LeftTPtr(iBuf.Length());

}

inline TPtr8 TBlockDesc::GetReadBuffer(TUint aLength, const TInt64& aOffset)

{

	iByteOffset = aOffset;

	iLength = aLength;

	iBuf.SetLength(aLength);

	return GetReadBuffer();

}

//-----------------------------------------------

/**

Returns the id of the buffer

@param bufferPtr pointer to the buffer.

@return  returns the buffer ID or -1 if the buffer is not found.

*/

inline TInt TBlockDescBuffer::GetBufferNumber(const TPtr8* aBufferPtr) const

{

	TInt no = -1;

	if (aBufferPtr == &iDesc1.iBuf)

		no = 1;

	else if (aBufferPtr == &iDesc2.iBuf)

		no = 2;

	return no;

}

//-----------------------------------------------

inline TPtr8 CThreadContext::GetReadBuffer()

{

	TInt len = iBuffer.iDescReadPtr->iBuf.Length();

	return iBuffer.iDescReadPtr->iBuf.LeftTPtr(len);

}

inline TPtr8 CThreadContext::GetReadBuffer(TInt aLength)

{

	iBuffer.iDescReadPtr->iBuf.SetLength(aLength);

	return GetReadBuffer();

}

inline TPtrC8 CThreadContext::WriteBuf()

{

	return iBuffer.iDescWritePtr->iBuf;

}

//-----------------------------------------------

inline TBlockDesc* CWriteDriveThread::GetReadDesc()

{

	return iThreadContext->iBuffer.iDescReadPtr;

}

//-----------------------------------------------

#endif //  MSDC_MULTITHREADED

#endif // __RWDRIVETHREAD_H__