/*

 * Copyright (c) 2004-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: 

 * Class declaration for CBulkOnlyTransportUsbcScLdd.

 *

 */

 /** 

  @file

  @internalTechnology

 */

 #ifndef __CBULKONLYTRANSPORTUSBCSCLDD_H__

 #define __CBULKONLYTRANSPORTUSBCSCLDD_H__

 #include "cbulkonlytransport.h"

 #include "cactivedevicestatenotifierbase.h"

 // This the length of every buffer corresponding to each Bulk endpoint. 

 // Length is to support double buffering, maximum size of host transfers(64 for Windows/128 for MAC) + 2K (to send CSW(IN ep's) and to recwive CBW's(OUT ep's))

 LOCAL_D const TUint KMaxScBufferSize = 258 * 1024; 

 LOCAL_D const TUint KMaxScReadSize = 64 * 1024;

 //Forward Declaration

 class CBulkOnlyTransportUsbcScLdd;

 /**

 Represent session with control endpoint (Ep0).

 handles the control interface, and responds to the class specific commands (RESET and GET_MAX_LUN).  

 */

 class CControlInterfaceUsbcScLdd : public CActive

 	{

 public:

 	enum TControlState

 		{

 		ENone,

 		EReadEp0Data,

 		ESendMaxLun

 		};

 public:

 	static CControlInterfaceUsbcScLdd* NewL(CBulkOnlyTransportUsbcScLdd& aParent);

 	~CControlInterfaceUsbcScLdd();

 	TInt Start();

 	void Stop();

 	virtual void RunL();

 	virtual void DoCancel();

 	TInt OpenEp0();

 private:

 	CControlInterfaceUsbcScLdd(CBulkOnlyTransportUsbcScLdd& aParent);

 	void ConstructL();

 	TInt ReadEp0Data();

 	void DecodeEp0Data();

 	TInt ReadUsbEp0();

 private:

 	TEndpointBuffer iEp0Buf;

 	TAny* iEp0Packet;

 	TUint iEp0Size;

 	TBool iEp0Zlp;

 	TUsbRequestHdr iRequestHeader;

 	/** reference to the  CBulkOnlyTransport*/

 	CBulkOnlyTransportUsbcScLdd& iParent;

 	/** represent carrent state for state mashine */

 	TControlState iCurrentState;

 	};

 /** Transport Class that accessess the SC LDD */

 class CBulkOnlyTransportUsbcScLdd : public CBulkOnlyTransport, public MLddDeviceStateNotification

 	{

 public:

 	CBulkOnlyTransportUsbcScLdd(TInt aNumDrives,CUsbMassStorageController& aController);

 	~CBulkOnlyTransportUsbcScLdd();

 	void ConstructL();

 	RDevUsbcScClient& Ldd();

 	TInt BytesAvailable(); // from Mtransport base class

 	TInt SetupConfigurationDescriptor(TBool aUnset = EFalse);

 	TInt SetupInterfaceDescriptors();

 	void ReleaseInterface();

 	void CancelControlInterface();

 	TInt StartControlInterface();

 	void ActivateDeviceStateNotifier();

 	void CancelDeviceStateNotifier();

 	void CancelReadWriteRequests();

 	void AllocateEndpointResources();

 	TInt GetDeviceStatus(TUsbcDeviceState& deviceStatus);

 	void FlushData();

 	void ReadAndDiscardData(TInt aBytes);

 	void ReadCBW();

 	void ExpireData(TAny* aAddress = NULL);

 	void ProcessCbwEvent();

 	void StallEndpointAndWaitForClear();

 	void ReadData(TUint aLength = 0);

 	void WriteUsb(TRequestStatus& aStatus, TPtrC8& aDes, TUint aLength, TBool aZlpRequired = EFalse);

 	void SetCbwPtr();

 	TPtr8& SetCommandBufPtr(TUint aLength);

 	TPtr8& SetDataBufPtr();

 	void SetPaddingBufPtr(TUint aLength);

 	void SetCswBufPtr(TUint aLength);

 	void ProcessReadingDataEvent();

 	void DiscardData(TUint aLength);

 	void WriteToClient(TUint aLength);

 	void SetReadDataBufPtr( TUint aLength);

 #ifdef MSDC_MULTITHREADED

 	virtual void GetBufferPointers(TPtr8& aDes1, TPtr8& aDes2);

 #endif

     void Activate(TRequestStatus& aStatus, TUint& aValue);

     void Cancel();

 private:

 	TInt ReadUsb(TUint aLength = 0);

 	TInt OpenEndpoints();

 	void ProcessDataFromHost(); // As USB Read API can return with KErrCompletion saying there is data already and 

 								// that we can process the data without queuong a request, this function effectively does

 								// what Runl() did earlier

 private:

 	RChunk* iChunk;

 	RDevUsbcScClient iLdd;

 	CControlInterfaceUsbcScLdd* iControlInterface;

 	CActiveDeviceStateNotifierBase* iDeviceStateNotifier;

 	/** To remember chunk specifics one defined, instead of walking it every time something required */

 	TUint iInEndpoint;

 	TUint iOutEndpoint;

 	TEndpointBuffer iSCReadEndpointBuf;

 	TEndpointBuffer iSCWriteEndpointBuf;

 	/** Pointer to the data in chunk which is read from the host */

 	TAny* iSCReadData;

 	/** Size of data read from the host in a 'transfer' */

 	TUint iSCReadSize;

 	/** If data read from host was termintated with a ZLP or not */

 	TBool iReadZlp;

 	/** Pointer to start of IN buffer in chunk which can be written into by protocol/media */

 	TAny* iDataPtr; 

 	/** Length of IN buffer */

 	TUint iInBufferLength;

 	};

 #endif