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