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

 //

 /**

  @file

  @internalTechnology

 */

 #include <e32base.h>

 #include "shared.h"

 #include "msgservice.h"

 #include "msctypes.h"

 #include "mprotocol.h"

 #include "mblocktransferprotocol.h"

 #include "tspcclientinterface.h"

 #include "cscsiprotocol.h"

 #include "cusbhostmslogicalunit.h"

 #include "usbmshostpanic.h"

 #include "msdebug.h"

 #include "debug.h"

 CUsbHostMsLogicalUnit* CUsbHostMsLogicalUnit::NewL(TLun aLun)

     {

     __MSFNSLOG

 	CUsbHostMsLogicalUnit* r = new (ELeave) CUsbHostMsLogicalUnit(aLun);

 	CleanupStack::PushL(r);

 	r->ConstructL();

 	CleanupStack::Pop();

 	return r;

 	}

 void CUsbHostMsLogicalUnit::ConstructL()

     {

     __MSFNLOG

     const TInt KInitialDataBufSize = 0x200;

 	iDataBuf.CreateL(KInitialDataBufSize);

     }

 CUsbHostMsLogicalUnit::CUsbHostMsLogicalUnit(TLun aLun)

 :   iProtocol(NULL),

     iLun(aLun),

 	iSuspendRequest(EFalse)

     {

     __MSFNLOG

 	}

 CUsbHostMsLogicalUnit::~CUsbHostMsLogicalUnit()

     {

     __MSFNLOG

     iDataBuf.Close();

 	delete iProtocol;

 	}

 void CUsbHostMsLogicalUnit::InitL()

     {

     __MSFNLOG

 	iProtocol->InitialiseUnitL();

     }

 void CUsbHostMsLogicalUnit::UnInitL()

     {

     __MSFNLOG

 	iProtocol->UninitialiseUnitL();

     }

 void CUsbHostMsLogicalUnit::ReadL(const RMessage2& aMessage)

     {

     __MSFNLOG

 	TReadWrite p;

 	TPtr8 pReadWrite((TUint8*)&p,sizeof(TReadWrite));

 	aMessage.ReadL(0, pReadWrite);

     __HOSTPRINT2(_L("pos = 0x%lx len = %08x"), p.iPos, p.iLen);

     User::LeaveIfError(CheckPosition(p));

 	// check if buffer can hold requested data and resize if not

 	if (iDataBuf.MaxLength() < p.iLen)

         iDataBuf.ReAllocL(p.iLen);

     iProtocol->ReadL(p.iPos, iDataBuf, p.iLen);

     aMessage.WriteL(1, iDataBuf);

     }

 void CUsbHostMsLogicalUnit::WriteL(const RMessage2& aMessage)

     {

     __MSFNLOG

 	TReadWrite p;

 	TPtr8 pReadWrite((TUint8*)&p,sizeof(TReadWrite));

 	aMessage.ReadL(1, pReadWrite);

     __HOSTPRINT2(_L("pos = 0x%lx len = %08x"), p.iPos, p.iLen);

     User::LeaveIfError(CheckPosition(p));

     // check if buffer can hold requested data and resize if not

     if (iDataBuf.MaxLength() < p.iLen)

         iDataBuf.ReAllocL(p.iLen);

 	aMessage.ReadL(0, iDataBuf);

 	iProtocol->WriteL(p.iPos, iDataBuf, p.iLen);

     }

 void CUsbHostMsLogicalUnit::EraseL(const RMessage2& aMessage)

     {

     __MSFNLOG

 	TReadWrite p;

 	TPtr8 pReadWrite((TUint8*)&p,sizeof(TReadWrite));

 	aMessage.ReadL(0, pReadWrite);

     __HOSTPRINT2(_L("pos = 0x%lx len = %08x"), p.iPos, p.iLen);

     User::LeaveIfError(CheckPosition(p));

     // check if buffer can hold requested data and resize if not

     if (iDataBuf.MaxLength() < p.iLen)

         iDataBuf.ReAllocL(p.iLen);

     iDataBuf.FillZ(p.iLen);

 	iProtocol->WriteL(p.iPos, iDataBuf, p.iLen);

     }

 void CUsbHostMsLogicalUnit::CapsL(const RMessage2& aMessage)

     {

     __MSFNLOG

     TCapsInfo capsInfo;

     TPckg<TCapsInfo> pckg(capsInfo);

 	iProtocol->GetCapacityL(capsInfo);

     iSize = static_cast<TInt64>(capsInfo.iNumberOfBlocks) * capsInfo.iBlockLength;

 	aMessage.WriteL(0, pckg);

     }

 void CUsbHostMsLogicalUnit::NotifyChange(const RMessage2& aMessage)

     {

     __MSFNLOG

 	iProtocol->NotifyChange(aMessage);

     }

 void CUsbHostMsLogicalUnit::ForceCompleteNotifyChangeL()

     {

     __MSFNLOG

 	iProtocol->ForceCompleteNotifyChangeL();

     }

 void CUsbHostMsLogicalUnit::CancelChangeNotifierL()

     {

     __MSFNLOG

 	iProtocol->CancelChangeNotifierL();

     }

 TBool CUsbHostMsLogicalUnit::IsConnected()

 	{

 	return iProtocol->IsConnected() ? ETrue : EFalse;

 	}

 TBool CUsbHostMsLogicalUnit::IsReadyToSuspend()

     {

     __MSFNLOG

 	return iSuspendRequest ? ETrue : EFalse;

 	}

 void CUsbHostMsLogicalUnit::ReadyToSuspend()

     {

     __MSFNLOG

 	iSuspendRequest = ETrue;

     }

 void CUsbHostMsLogicalUnit::CancelReadyToSuspend()

     {

     __MSFNLOG

 	iSuspendRequest = EFalse;

     }

 void CUsbHostMsLogicalUnit::SuspendL()

     {

     __MSFNLOG

 	iProtocol->SuspendL();

     }

 void CUsbHostMsLogicalUnit::ResumeL()

 	{

     __MSFNLOG

 	// We do not cancel iSuspendRequest here

 	iProtocol->ResumeL();

 	}

 void CUsbHostMsLogicalUnit::DoLunReadyCheckL()

     {

     __MSFNLOG

 	iProtocol->DoScsiReadyCheckEventL();

     }

 TInt CUsbHostMsLogicalUnit::InitialiseProtocolL(TLun aLun,

                                                 THostMassStorageConfig& aConfig,

                                                 MTransport& aTransport)

     {

     __MSFNLOG

     __ASSERT_DEBUG(iProtocol == NULL, User::Panic(KUsbMsHostPanicCat, EProtocolNotFree));

 	switch(aConfig.iProtocolId)

         {

 	case ScsiProtocol:

 		iProtocol = CScsiProtocol::NewL(aLun, aTransport);

 		break;

 	default:

 		__HOSTPRINT(_L("Unsupported Transport class requested"));

 		iProtocol = NULL;

 		return KErrNotSupported;

         }

 	return KErrNone;

     }

 TInt CUsbHostMsLogicalUnit::CheckPosition(const TReadWrite& aReadWrite)

     {

     if (aReadWrite.iLen == 0)

         {

         if (aReadWrite.iPos == iSize)

             return KErrEof;

         else

             return KErrArgument;

         }

 	// detect drive not present

 	if (iSize == 0)

 		return KErrNotReady;

     if (aReadWrite.iPos >= iSize)

         return KErrArgument;

     return KErrNone;

     }