FCL/sf/os/kernelhwsrv: comparison userlibandfileserver/fileserver/smassstorage/scsiprot.cpp

equal deleted inserted replaced

-:ff5437e4337c
+:48e57fb1237e
 // Contributors:
 //
 // Description:
 //
+#include <e32std.h>
+#include "mtransport.h"
+#include "mprotocol.h"
 #include "scsiprot.h"
 #ifdef MSDC_MULTITHREADED
 #include "rwdrivethread.h"
 #endif // MSDC_MULTITHREADED
-#include "massstoragedebug.h"
+#include "OstTraceDefinitions.h"
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "scsiprotTraces.h"
+#endif
 // Helper macros
 #define LBA(x) static_cast<TUint32>((x[3] << 24) | (x[4] << 16) | (x[5] << 8) | x[6])
 #define LEN(x) static_cast<TUint16>((x[8] << 8) | x[9])
-LOCAL_D const TUint KDefaultBlockSize = 0x200;  //default block size for FAT
+static const TUint32 KDefaultBlockSize = 0x200;  //default block size for FAT
-LOCAL_D const TUint KUndefinedLun = 0xFFFF;
+static const TUint KUndefinedLun = 0xFFFF;
-LOCAL_D const TUint8 KAllPages = 0x3F;
+static const TUint8 KAllPages = 0x3F;
-LOCAL_D const TUint8 KChangeableValues = 0x1;
+static const TUint8 KChangeableValues = 0x1;
-LOCAL_D const TUint8 KDefaultValues = 0x2;
+static const TUint8 KDefaultValues = 0x2;
 /**
 Default constructor for TSenseInfo
 */
 TSenseInfo::TSenseInfo()
-	: iSenseCode(ENoSense),
+: iSenseCode(ENoSense),
-	  iAdditional(EAscNull),
+iAdditional(EAscNull),
-	  iQualifier(EAscqNull)
+iQualifier(EAscqNull)
-	{}
+{}
 /**
 Set sense with no additional info.
 @param aSenseCode sense key
 */
 void TSenseInfo::SetSense(TSenseCode aSenseCode)
-	{
+{
-	iSenseCode = static_cast<TUint8>(aSenseCode);
+iSenseCode = static_cast<TUint8>(aSenseCode);
-	iAdditional = EAscNull;
+iAdditional = EAscNull;
-	iQualifier = EAscqNull;
+iQualifier = EAscqNull;
-	}
+OstTraceExt3(TRACE_SMASSSTORAGE_SCSI, CSCSIPROTOCOL_SETSENSE1, "    SENSE CODE %d ASC %d ASC %d", iSenseCode, iAdditional, iQualifier);
+}
 /**
 Set sense with additional info.
 @param aSenseCode sense key
 @param aAdditional additional sense code (ASC)
 */
 void TSenseInfo::SetSense(TSenseCode aSenseCode, TAdditionalCode aAdditional)
-	{
+{
-	iSenseCode = static_cast<TUint8>(aSenseCode);
+iSenseCode = static_cast<TUint8>(aSenseCode);
-	iAdditional = static_cast<TUint8>(aAdditional);
+iAdditional = static_cast<TUint8>(aAdditional);
-	iQualifier = EAscqNull;
+iQualifier = EAscqNull;
-	}
+OstTraceExt3(TRACE_SMASSSTORAGE_SCSI, CSCSIPROTOCOL_SETSENSE2, "    SENSE CODE %d ASC %d ASC %d", iSenseCode, iAdditional, iQualifier);
+}
 /**
 Set sense with additional info and qualifier.
 @param aSenseCode sense key
 @param aAdditional additional sense code (ASC)
 @param aQualifier additional sense code qualifier (ASCQ)
 */
 void TSenseInfo::SetSense(TSenseCode aSenseCode,
-						  TAdditionalCode aAdditional,
+TAdditionalCode aAdditional,
-						  TAdditionalSenseCodeQualifier aQualifier)
+TAdditionalSenseCodeQualifier aQualifier)
-	{
+{
-	iSenseCode = static_cast<TUint8>(aSenseCode);
+iSenseCode = static_cast<TUint8>(aSenseCode);
-	iAdditional = static_cast<TUint8>(aAdditional);
+iAdditional = static_cast<TUint8>(aAdditional);
-	iQualifier = static_cast<TUint8>(aQualifier);
+iQualifier = static_cast<TUint8>(aQualifier);
-	}
+OstTraceExt3(TRACE_SMASSSTORAGE_SCSI, CSCSIPROTOCOL_SETSENSE3, "    SENSE CODE %d ASC %d ASC %d", iSenseCode, iAdditional, iQualifier);
+}
 //-----------------------------------------------
 /**
 Creates the CScsiProtocol object.  Called during controller initialisation.
 @param aDriveManager reference to the drive manager object
 */
 CScsiProtocol* CScsiProtocol::NewL(CDriveManager& aDriveManager)
-	{
+{
-	CScsiProtocol* self = new (ELeave) CScsiProtocol(aDriveManager);
+CScsiProtocol* self = new (ELeave) CScsiProtocol(aDriveManager);
-	CleanupStack::PushL(self);
+CleanupStack::PushL(self);
-	self->ConstructL();
+self->ConstructL();
-	CleanupStack::Pop();
+CleanupStack::Pop();
-	return self;
+return self;
-	}
+}
 /**
 c'tor
 @param aDriveManager reference to the drive manager object
 */
 CScsiProtocol::CScsiProtocol(CDriveManager& aDriveManager):
-	iDriveManager(aDriveManager),
+iDriveManager(aDriveManager),
-	iLastCommand(EUndefinedCommand),
+iLastCommand(EUndefinedCommand),
-	iLastLun(KUndefinedLun),
+iLastLun(KUndefinedLun),
-	iMediaWriteSize(KDefaultMediaWriteSize)
+iMediaWriteSize(KDefaultMediaWriteSize)
-	{
+{
-	__FNLOG("CScsiProtocol::CScsiProtocol");
 #ifdef USB_TRANSFER_PUBLISHER
-	iWriteTransferPublisher = CUsbWriteTransferPublisher::NewL(iBytesWritten);
+iWriteTransferPublisher = CUsbWriteTransferPublisher::NewL(iBytesWritten);
-	iReadTransferPublisher = CUsbReadTransferPublisher::NewL(iBytesRead);
+iReadTransferPublisher = CUsbReadTransferPublisher::NewL(iBytesRead);
-	for (TUint i = 0; i < KUsbMsMaxDrives; i++)
+for (TUint i = 0; i < KUsbMsMaxDrives; i++)
-		{
+{
-		iBytesRead[i] = 0;
+iBytesRead[i] = 0;
-		iBytesWritten[i] = 0;
+iBytesWritten[i] = 0;
-		}
+}
 #else
-	iWriteTransferPublisher = CDriveWriteTransferPublisher::NewL(aDriveManager.iDrives);
+iWriteTransferPublisher = CDriveWriteTransferPublisher::NewL(aDriveManager.iDrives);
-	iReadTransferPublisher = CDriveReadTransferPublisher::NewL(aDriveManager.iDrives);
+iReadTransferPublisher = CDriveReadTransferPublisher::NewL(aDriveManager.iDrives);
 #endif
-	}
+}
 CScsiProtocol::~CScsiProtocol()
-	{
+{
-	__FNLOG("CScsiProtocol::~CScsiProtocol");
+#ifdef MSDC_MULTITHREADED
-#ifdef MSDC_MULTITHREADED
+OstTrace0(TRACE_SMASSSTORAGE, CSCSIPROTOCOL_DES, "Deleting Drive Threads");
-	__PRINT(_L("Deleting WriteDrive Thread"));
+delete iWriteDriveThread;
-	delete iWriteDriveThread;
+delete iReadDriveThread;
-	__PRINT(_L("Deleting ReadDrive Thread"));
-	delete iReadDriveThread;
 #endif // MSDC_MULTITHREADED
-	delete iWriteTransferPublisher;
+delete iWriteTransferPublisher;
-	delete iReadTransferPublisher;
+delete iReadTransferPublisher;
-	}
+}
 void CScsiProtocol::ConstructL()
-	{
+{
-	__FNLOG("CScsiProtocol::ConstructL");
+#ifdef MSDC_MULTITHREADED
-#ifdef MSDC_MULTITHREADED
+OstTrace0(TRACE_SMASSSTORAGE, _CSCSIPROTOCOL, "Creating Drive Threads");
-	__PRINT(_L("Creating WriteDrive Thread"));
+iWriteDriveThread = CWriteDriveThread::NewL();
-	iWriteDriveThread = CWriteDriveThread::NewL();
+iReadDriveThread = CReadDriveThread::NewL();
-	__PRINT(_L("Creating ReadDrive Thread"));
-	iReadDriveThread = CReadDriveThread::NewL();
 #endif // MSDC_MULTITHREADED
-	}
+}
 /**
 Associates the transport with the protocol. Called during initialisation of the controller.
 @param aTransport pointer to the transport object
 */
 void CScsiProtocol::RegisterTransport(MTransportBase* aTransport)
-	{
+{
-	__FNLOG("CScsiProtocol::RegisterTransport");
+iTransport = aTransport;
-	iTransport = aTransport;
+}
-	}
 /**
 Called by the Transport when it detects that the USB device is either running
 at High Speed or is at least capable of HS operation. The Protocol can use this
 This function is preferably called before actual MS data transfer operation
 starts, and usually only once.
 */
 void CScsiProtocol::ReportHighSpeedDevice()
-	{
+{
-	__FNLOG("CScsiProtocol::ReportHighSpeedDevice");
+iMediaWriteSize = KHsMediaWriteSize;
-	iMediaWriteSize = KHsMediaWriteSize;
+OstTrace1(TRACE_SMASSSTORAGE, CSCSIPROTOCOL_REPORTHIGHSPEEDDEVICE,
-	__PRINT1(_L("HS Device reported: SCSI will use %d bytes disk write size"), iMediaWriteSize);
+"HS Device reported: SCSI will use 0x%x bytes disk write size", iMediaWriteSize);
-	}
+}
 TInt CScsiProtocol::SetScsiParameters(TMassStorageConfig aConfig)
-	{
+{
-	__FNLOG("CScsiProtocol::SetScsiParameters");
+iConfig = aConfig;
-	iConfig = aConfig;
+return KErrNone;
-	return KErrNone;
+}
-	}
 #ifdef MSDC_MULTITHREADED
 void CScsiProtocol::ProcessWriteComplete (TUint8* aAddress, TAny* aPtr)
-	{
+{
-	((CScsiProtocol*)aPtr)->iTransport->ProcessReadData(aAddress);
+((CScsiProtocol*)aPtr)->iTransport->ProcessReadData(aAddress);
-	}
+}
 void CScsiProtocol::InitializeBufferPointers(TPtr8& aDes1, TPtr8& aDes2) // Todo Change name later - InitializeReadBufferSomething
-	{
+{
-	iReadDriveThread->iThreadContext->iBuffer.SetUpReadBuf(aDes1, aDes2);
+iReadDriveThread->iThreadContext->iBuffer.SetUpReadBuf(aDes1, aDes2);
-	}
+}
 #endif
 /**
 Called by the transport layer when a packet is available for decoding.
 If an error occurs, the sense code is updated and EFalse is returned.
 @param aData
 @return  ETrue if command was decoded and executed successfully
 */
 TBool CScsiProtocol::DecodePacket(TPtrC8& aData, TUint aLun)
-	{
+{
-	__FNLOG("CScsiProtocol::DecodePacket");
+TUint command = aData[1];
-	TUint8 command = aData[1];
+if (command != ERequestSense)
+{
-	if (command != ERequestSense)
+iSenseInfo.SetSense(TSenseInfo::ENoSense);
-		{
+}
-		iSenseInfo.SetSense(TSenseInfo::ENoSense);
-		}
+OstTraceExt2(TRACE_SMASSSTORAGE_SCSI, CSCSIPROTOCOL_DECODEPACKET, "Command=0x%x LUN=%d", command, aLun);
+switch (command)
-	__PRINT2(_L("command = 0x%x lun=%d"), command, aLun);
+{
-	switch (command)
+case ETestUnitReady:
-		{
+HandleUnitReady(aLun);
-		case ETestUnitReady:
+break;
-			HandleUnitReady(aLun);
-			break;
+case ERequestSense:
+HandleRequestSense(aData);
-		case ERequestSense:
+break;
-			HandleRequestSense(aData);
-			break;
+case EInquiry:
+HandleInquiry(aData, aLun);
-		case EInquiry:
+break;
-			HandleInquiry(aData, aLun);
-			break;
+case EModeSense6:
+HandleModeSense6(aData, aLun);
-		case EModeSense6:
+break;
-			HandleModeSense6(aData, aLun);
-			break;
 case EModeSense10:
 HandleModeSense10(aData, aLun);
 break;
-		case EStartStopUnit:
+case EStartStopUnit:
-			HandleStartStopUnit(aData, aLun);
+HandleStartStopUnit(aData, aLun);
-			break;
+break;
-		case EPreventMediaRemoval:
+case EPreventMediaRemoval:
-			HandlePreventMediaRemoval(aData, aLun);
+HandlePreventMediaRemoval(aData, aLun);
-			break;
+break;
-		case EReadCapacity:
+case EReadCapacity:
-			HandleReadCapacity(aData, aLun);
+HandleReadCapacity(aData, aLun);
-			break;
+break;
-		case ERead10:
+case ERead10:
-			HandleRead10(aData, aLun);
+HandleRead10(aData, aLun);
-			break;
+break;
-		case EWrite10:
+case EWrite10:
-			HandleWrite10(aData,aLun);
+HandleWrite10(aData,aLun);
-			break;
+break;
-		case EVerify10:
+case EVerify10:
-			HandleVerify10(aData, aLun);
+HandleVerify10(aData, aLun);
-			break;
+break;
-		case EReadFormatCapacities:
+case EReadFormatCapacities:
-			HandleReadFormatCapacities(aLun);
+HandleReadFormatCapacities(aLun);
-			break;
+break;
-		default:
+default:
-			iSenseInfo.SetSense(TSenseInfo::EIllegalRequest, TSenseInfo::EInvalidCmdCode);
+iSenseInfo.SetSense(TSenseInfo::EIllegalRequest, TSenseInfo::EInvalidCmdCode);
-		}
+}
-	__PRINT1(_L("DecodePacket result = %d"), iSenseInfo.SenseOk());
+return(iSenseInfo.SenseOk());
-	return(iSenseInfo.SenseOk());
+}
-	}
 /**
 Checks if drive ready
 @param aLun Logic unit number
 @return pointer to drive correspondent to LUN if drive mounted and ready, NULL otherwise
 */
 CMassStorageDrive* CScsiProtocol::GetCheckDrive(TUint aLun)
-	{
+{
-	__FNLOG("CScsiProtocol::GetCheckDrive");
+TInt err=KErrNone;
-	TInt err=KErrNone;
+#ifdef MSDC_MULTITHREADED
-#ifdef MSDC_MULTITHREADED
+// check for deferred errors
-	// check for deferred errors
+if (iWriteDriveThread->DeferredError())
-	if (iWriteDriveThread->DeferredError())
+{
-		{
+iWriteDriveThread->ClearDeferredError();
-		iWriteDriveThread->ClearDeferredError();
+iDeferredSenseInfo.SetSense(TSenseInfo::EMediumError);
-		iDeferredSenseInfo.SetSense(TSenseInfo::EMediumError);
+return NULL;
-		return NULL;
+}
-		}
+#endif
-#endif
+CMassStorageDrive* drive= iDriveManager.Drive(aLun, err);
-	CMassStorageDrive* drive= iDriveManager.Drive(aLun, err);
+if (err !=KErrNone || drive == NULL)
-	if (err !=KErrNone || drive == NULL)
+{
-		{
+OstTrace0(TRACE_SMASSSTORAGE, CSCSIPROTOCOL_GETCHECKDRIVE1, "No drive available");
-		__PRINT(_L("No drive available\n"));
+iSenseInfo.SetSense(TSenseInfo::EIllegalRequest, TSenseInfo::ELuNotSupported);
-		iSenseInfo.SetSense(TSenseInfo::EIllegalRequest, TSenseInfo::ELuNotSupported);
+return NULL;
-		return NULL;
+}
-		}
+CMassStorageDrive::TMountState mountState = drive->MountState();
-	CMassStorageDrive::TMountState mountState = drive->MountState();
+if (mountState == CMassStorageDrive::EDisconnected || mountState == CMassStorageDrive::EConnecting)
-	if (mountState == CMassStorageDrive::EDisconnected || mountState == CMassStorageDrive::EConnecting)
+{
-		{
+OstTrace0(TRACE_SMASSSTORAGE, CSCSIPROTOCOL_GETCHECKDRIVE2, "Drive disconnected");
-		__PRINT(_L("Drive disconnected\n"));
+iSenseInfo.SetSense(TSenseInfo::ENotReady,
-		iSenseInfo.SetSense(TSenseInfo::ENotReady,
+TSenseInfo::EMediaNotPresent);
-							TSenseInfo::EMediaNotPresent);
+return NULL;
-		return NULL;
+}
-		}
+CMassStorageDrive::TDriveState state = drive->CheckDriveState();
-	CMassStorageDrive::TDriveState state = drive->CheckDriveState();
+if (state == CMassStorageDrive::EMediaNotPresent || state == CMassStorageDrive::ELocked)
-	if (state == CMassStorageDrive::EMediaNotPresent || state == CMassStorageDrive::ELocked)
+{
-		{
+OstTrace1(TRACE_SMASSSTORAGE, CSCSIPROTOCOL_GETCHECKDRIVE3, "Media not present or locked. state =0x%X", state);
-		__PRINT1(_L("Media not present or locked. (state =0x%X)\n"),state);
+iSenseInfo.SetSense(TSenseInfo::ENotReady, TSenseInfo::EMediaNotPresent);
-		iSenseInfo.SetSense(TSenseInfo::ENotReady, TSenseInfo::EMediaNotPresent);
+return NULL;
-		return NULL;
+}
-		}
+if (drive->IsMediaChanged(ETrue))  //reset "media changed" status
-	if (drive->IsMediaChanged(ETrue))  //reset "media changed" status
+{
-		{
+OstTrace0(TRACE_SMASSSTORAGE, CSCSIPROTOCOL_GETCHECKDRIVE4, "Media was changed");
-		__PRINT(_L("Media was changed\n"));
+// SAM-2 Section 5.9.5 Unit Attention Condition
-		// SAM-2 Section 5.9.5 Unit Attention Condition
+iSenseInfo.SetSense(TSenseInfo::EUnitAttention, TSenseInfo::ENotReadyToReadyChange);
-		iSenseInfo.SetSense(TSenseInfo::EUnitAttention, TSenseInfo::ENotReadyToReadyChange);
+iDriveManager.Connect(aLun);   //publish event to USB app
-		iDriveManager.Connect(aLun);   //publish event to USB app
+return NULL;
-		return NULL;
+}
-		}
+if (mountState == CMassStorageDrive::EDisconnecting)
-	if (mountState == CMassStorageDrive::EDisconnecting)
+{
-		{
+OstTrace0(TRACE_SMASSSTORAGE, CSCSIPROTOCOL_GETCHECKDRIVE5, "Drive disconnecting");
-		__PRINT(_L("Drive disconnecting\n"));
+iSenseInfo.SetSense(TSenseInfo::ENotReady,
-		iSenseInfo.SetSense(TSenseInfo::ENotReady,
+TSenseInfo::EMediaNotPresent);
-							TSenseInfo::EMediaNotPresent);
+return NULL;
-		return NULL;
+}
-		}
+return drive;
-	return drive;
+}
-	}
 /**
 Command Parser for the UNIT READY command (0x00)
 @param aLun Logic unit number
 @return ETrue if successful,
 */
 TBool CScsiProtocol::HandleUnitReady(TUint aLun)
-	{
+{
-	__FNLOG("CScsiProtocol::HandleUnitReady");
+OstTrace0(TRACE_SMASSSTORAGE_SCSI, CSCSIPROTOCOL_TESTUNITREADY, ">>> TEST UNIT READY");
 #ifdef MSDC_MULTITHREADED
-	iWriteDriveThread->WaitForWriteEmpty();
+iWriteDriveThread->WaitForWriteEmpty();
 #endif
-	return GetCheckDrive(aLun) ? (TBool)ETrue : (TBool)EFalse;
+return GetCheckDrive(aLun) ? (TBool)ETrue : (TBool)EFalse;
-	}
+}
 /**
 Command Parser for the REQUEST SENSE command (0x03)
 @return ETrue if successful,
 */
 TBool CScsiProtocol::HandleRequestSense(TPtrC8& aData)
-	{
+{
-	__FNLOG("CScsiProtocol::HandleRequestSense");
+OstTrace0(TRACE_SMASSSTORAGE_SCSI, CSCSIPROTOCOL_REQUESTSENSE, ">>> REQUEST SENSE");
-	TUint length = aData[5];
+TUint length = aData[5];
-	__PRINT1(_L("length = %d\n"), length);
+OstTrace1(TRACE_SMASSSTORAGE_SCSI, CSCSIPROTOCOL_REQUESTSENSE1, "    length = %d", length);
-	TPtr8 writeBuf(NULL, 0);
+TPtr8 writeBuf(NULL, 0);
-	iTransport->GetCommandBufPtr(writeBuf, KRequestSenseCommandLength);
+iTransport->GetCommandBufPtr(writeBuf, KRequestSenseCommandLength);
-	writeBuf.FillZ(KRequestSenseCommandLength);
+writeBuf.FillZ(KRequestSenseCommandLength);
-	TSenseInfo* senseInfo;
+TSenseInfo* senseInfo;
 #ifdef MSDC_MULTITHREADED
-	if (!iDeferredSenseInfo.SenseOk())
+if (!iDeferredSenseInfo.SenseOk())
-		{
+{
-		writeBuf[00] = 0x71; //(deferred errors)
+writeBuf[00] = 0x71; //(deferred errors)
-		senseInfo = &iDeferredSenseInfo;
+senseInfo = &iDeferredSenseInfo;
-		}
+}
-	else
+else
-		{
+{
-		writeBuf[00] = 0x70; //(current errors)
+writeBuf[00] = 0x70; //(current errors)
-		senseInfo = &iSenseInfo;
+senseInfo = &iSenseInfo;
-		}
+}
 #else
-	senseInfo = &iSenseInfo;
+senseInfo = &iSenseInfo;
-	writeBuf[00] = 0x70; //(current errors)
+writeBuf[00] = 0x70; //(current errors)
 #endif
-	writeBuf[02] = static_cast<TUint8>(senseInfo->iSenseCode & 0x0F);
+writeBuf[02] = static_cast<TUint8>(senseInfo->iSenseCode & 0x0F);
-	writeBuf[12] = senseInfo->iAdditional;
+writeBuf[12] = senseInfo->iAdditional;
-	writeBuf[13] = senseInfo->iQualifier;
+writeBuf[13] = senseInfo->iQualifier;
-	if (length<18 && length >=8)
+if (length<18 && length >=8)
-		{
+{
-		writeBuf.SetLength(length);  //length of response code data
+writeBuf.SetLength(length);  //length of response code data
-		writeBuf[07] = TUint8(length - 8);  //additional sence length
+writeBuf[07] = TUint8(length - 8);  //additional sence length
-		}
+}
-	else if (length >= KRequestSenseCommandLength)
+else if (length >= KRequestSenseCommandLength)
-		{
+{
-		writeBuf[07] = KRequestSenseCommandLength - 8;	// we have max 18 byte to send
+writeBuf[07] = KRequestSenseCommandLength - 8;  // we have max 18 byte to send
-		}
+}
-	__PRINT4(_L("Response=0x%x Sense=0x%x, Additional=0x%x, Qualifier=0x%x\n"),
+OstTraceExt4(TRACE_SMASSSTORAGE_SCSI, CSCSIPROTOCOL_REQUESTSENSE2,
-				writeBuf[0], writeBuf[02], writeBuf[12], writeBuf[13]);
+"    Response=0x%x Sense=0x%x, Additional=0x%x, Qualifier=0x%x",
+(TUint)writeBuf[0], (TUint)writeBuf[02], (TUint)writeBuf[12], (TUint)writeBuf[13]);
-	TPtrC8 writeBuf1 = writeBuf.Left(length);
+TPtrC8 writeBuf1 = writeBuf.Left(length);
-	iTransport->SetupWriteData(writeBuf1);
+iTransport->SetupWriteData(writeBuf1);
-	// clear the sense info
-	iSenseInfo.SetSense(TSenseInfo::ENoSense);
+// clear the sense info
+iSenseInfo.SetSense(TSenseInfo::ENoSense);
-#ifdef MSDC_MULTITHREADED
-	iDeferredSenseInfo.SetSense(TSenseInfo::ENoSense);
+#ifdef MSDC_MULTITHREADED
-#endif
+iDeferredSenseInfo.SetSense(TSenseInfo::ENoSense);
+#endif
-	return ETrue;
-	}
+return ETrue;
+}
 /**
 Command Parser for the INQUIRY command (0x12)
 @param aLun Logic unit number
 @return ETrue if successful,
 */
 TBool CScsiProtocol::HandleInquiry(TPtrC8& aData, TUint  aLun )
-	{
+{
-	__FNLOG("CScsiProtocol::HandleInquiry");
+OstTrace0(TRACE_SMASSSTORAGE_SCSI, CSCSIPROTOCOL_INQUIRY, ">>> INQUIRY");
+TBool cmdDt = aData[2] & 0x2;
-	TBool cmdDt = aData[2] & 0x2;
+TBool evpd  = aData[2] & 0x1;
-	TBool evpd  = aData[2] & 0x1;
+TUint8 page = aData[3];
-	TUint8 page = aData[3];
+if (cmdDt || evpd || page || aLun >= KUsbMsMaxDrives)
-	if (cmdDt || evpd || page || aLun >= KUsbMsMaxDrives)
+{
-		{
+iSenseInfo.SetSense(TSenseInfo::EIllegalRequest, TSenseInfo::EInvalidFieldInCdb);
-		iSenseInfo.SetSense(TSenseInfo::EIllegalRequest, TSenseInfo::EInvalidFieldInCdb);
+return EFalse;
-		return EFalse;
+}
-		}
+TPtr8 writeBuf(NULL, 0);
-	TPtr8 writeBuf(NULL, 0);
+iTransport->GetCommandBufPtr(writeBuf, KInquiryCommandLength);
-	iTransport->GetCommandBufPtr(writeBuf, KInquiryCommandLength);
+writeBuf.FillZ(KInquiryCommandLength);
-	writeBuf.FillZ(KInquiryCommandLength);
+writeBuf[1] = 0x80; // MSB: RMB : Removable
-	writeBuf[1] = 0x80;	// MSB: RMB : Removable
+writeBuf[3] = 0x02; // AERC, TrmTsk, NormACA, Response Data Format
-	writeBuf[3] = 0x02;	// AERC, TrmTsk, NormACA, Response Data Format
+writeBuf[4] = 0x1F; // Additional Length
-	writeBuf[4] = 0x1F;	// Additional Length
+TPtr8 vendorId(&writeBuf[8], 8, 8);     // Vendor ID (Vendor Specific/Logged by T10)
-	TPtr8 vendorId(&writeBuf[8], 8, 8);		// Vendor ID (Vendor Specific/Logged by T10)
+vendorId.Fill(' ', 8);
-	vendorId.Fill(' ', 8);
+vendorId.Copy(iConfig.iVendorId);
-	vendorId.Copy(iConfig.iVendorId);
+TPtr8 productId(&writeBuf[16], 16, 16); // Product ID (Vendor Specific)
-	TPtr8 productId(&writeBuf[16], 16, 16);	// Product ID (Vendor Specific)
+productId.Fill(' ', 16);
-	productId.Fill(' ', 16);
+productId.Copy(iConfig.iProductId);
-	productId.Copy(iConfig.iProductId);
+TPtr8 productRev(&writeBuf[32], 4, 4);      // Product Revision Level (Vendor Specific)
-	TPtr8 productRev(&writeBuf[32], 4, 4);		// Product Revision Level (Vendor Specific)
+productRev.Fill(' ', 4);
-	productRev.Fill(' ', 4);
+productRev.Copy(iConfig.iProductRev);
-	productRev.Copy(iConfig.iProductRev);
+OstTraceData(TRACE_SMASSSTORAGE_SCSI, CSCSIPROTOCOL_INQUIRY1, "Vendor ID %s", vendorId.Ptr(), vendorId.Length());
+OstTraceData(TRACE_SMASSSTORAGE_SCSI, CSCSIPROTOCOL_INQUIRY2, "Product ID %s", productId.Ptr(), productId.Length());
+OstTraceData(TRACE_SMASSSTORAGE_SCSI, CSCSIPROTOCOL_INQUIRY3, "Product Rev %s", productRev.Ptr(), productRev.Length());
 TUint length = aData[5];
-	TPtrC8 writeBuf1 = writeBuf.Left(length);
+TPtrC8 writeBuf1 = writeBuf.Left(length);
-	iTransport->SetupWriteData(writeBuf1);
+iTransport->SetupWriteData(writeBuf1);
-	iSenseInfo.SetSense(TSenseInfo::ENoSense);
+iSenseInfo.SetSense(TSenseInfo::ENoSense);
-	return ETrue;
+return ETrue;
-	}
+}
 /**
 Command Parser for the START STOP UNIT command (0x1B)
 @param aData command data (started form position 1)
 @param aLun Logic unit number
 @return ETrue if successful, TFalse otherwise
 */
 TBool CScsiProtocol::HandleStartStopUnit(TPtrC8& aData, TUint aLun)
-	{
+{
-	__FNLOG("CScsiProtocol::HandleStartStopUnit");
+OstTrace0(TRACE_SMASSSTORAGE_SCSI, CSCSIPROTOCOL_STARTSTOPUNIT, ">>> START STOP UNIT");
+const TUint8 KStartMask = 0x01;
-	const TUint8 KStartMask = 0x01;
+const TUint8 KImmedMask = 0x01;
-	const TUint8 KImmedMask = 0x01;
+const TUint8 KLoejMask = 0x02;
-	const TUint8 KLoejMask = 0x02;
+TBool immed = aData[2] & KImmedMask ? (TBool)ETrue : (TBool)EFalse;
-	TBool immed = aData[2] & KImmedMask ? (TBool)ETrue : (TBool)EFalse;
+TBool start = aData[5] & KStartMask ? (TBool)ETrue : (TBool)EFalse;
-	TBool start = aData[5] & KStartMask ? (TBool)ETrue : (TBool)EFalse;
+TBool loej = aData[5] & KLoejMask ? (TBool)ETrue : (TBool)EFalse;
-	TBool loej = aData[5] & KLoejMask ? (TBool)ETrue : (TBool)EFalse;
+OstTrace1(TRACE_SMASSSTORAGE_SCSI, CSCSIPROTOCOL_STARTSTOPUNIT1, "    IMMED = %d", immed);
-	__PRINT2(_L("Data %X %X\n"), aData[2], aData[5]);
+OstTrace1(TRACE_SMASSSTORAGE_SCSI, CSCSIPROTOCOL_STARTSTOPUNIT2, "    START = %d", start);
-	__PRINT1(_L("IMMED = %d\n"), immed);
+OstTrace1(TRACE_SMASSSTORAGE_SCSI, CSCSIPROTOCOL_STARTSTOPUNIT3, "    LOEJ = %d", loej);
-	__PRINT1(_L("START = %d\n"), start);
+TInt err(KErrNone);
-	__PRINT1(_L("LOEJ = %d\n"), loej);
+if (loej)
+{
-	TInt err(KErrNone);
+if(start)   //Start unit
-	if (loej)
+{
-		{
+err = iDriveManager.Connect(aLun);
-		if(start)	//Start unit
-			{
-			err = iDriveManager.Connect(aLun);
-			__PRINT(_L("Load media\n"));
 #ifdef USB_TRANSFER_PUBLISHER
-			iBytesRead[aLun] = 0;
+iBytesRead[aLun] = 0;
-			iBytesWritten[aLun] = 0;
+iBytesWritten[aLun] = 0;
 #endif
-			// publish the initial values
+// publish the initial values
-			iWriteTransferPublisher->DoPublishDataTransferredEvent();
+iWriteTransferPublisher->DoPublishDataTransferredEvent();
-			iReadTransferPublisher->DoPublishDataTransferredEvent();
+iReadTransferPublisher->DoPublishDataTransferredEvent();
-			}
+}
-		else		//Stop unit
+else        //Stop unit
-			{
+{
-			iDriveManager.SetCritical(aLun, EFalse);
+iDriveManager.SetCritical(aLun, EFalse);
-			err = iDriveManager.Disconnect(aLun);
+err = iDriveManager.Disconnect(aLun);
-			__PRINT(_L("Unload media\n"));
+}
-			}
+}
-		}
+if (err !=KErrNone)  //actually we have error here only if the LUN is incorrect
-	if (err !=KErrNone)  //actually we have error here only if the LUN is incorrect
+{
-		{
+iSenseInfo.SetSense(TSenseInfo::EIllegalRequest, TSenseInfo::ELuNotSupported);
-		iSenseInfo.SetSense(TSenseInfo::EIllegalRequest, TSenseInfo::ELuNotSupported);
+return EFalse;
-		return EFalse;
+}
-		}
+if (immed)
-	if (immed)
+{
-		{
+return ETrue;
-		return ETrue;
+}
-		}
+CMassStorageDrive* drive= iDriveManager.Drive(aLun, err);
-	CMassStorageDrive* drive= iDriveManager.Drive(aLun, err);
+if (err !=KErrNone || drive == NULL)
-	if (err !=KErrNone || drive == NULL)
+{
-		{
+iSenseInfo.SetSense(TSenseInfo::EIllegalRequest, TSenseInfo::ELuNotSupported);
-		iSenseInfo.SetSense(TSenseInfo::EIllegalRequest, TSenseInfo::ELuNotSupported);
+return EFalse;
-		return EFalse;
+}
-		}
+TInt  timeLeft (20);   // 1 sec timeout
-	TInt  timeLeft (20);   // 1 sec timeout
+CMassStorageDrive::TMountState mountState;
-	CMassStorageDrive::TMountState mountState;
+do
-	do
+{
-		{
+User::After(1000 * 50);     // 50 mSec
-		User::After(1000 * 50);		// 50 mSec
+--timeLeft;
-		--timeLeft;
+mountState = drive->MountState();
-		mountState = drive->MountState();
+if ((!start && mountState != CMassStorageDrive::EConnected)
-		if ((!start && mountState != CMassStorageDrive::EConnected)
+||
-			 ||
+(start &&
-			 (start &&
+(mountState == CMassStorageDrive::EDisconnecting ||
-				(mountState == CMassStorageDrive::EDisconnecting ||
+mountState == CMassStorageDrive::EConnected))
-				mountState == CMassStorageDrive::EConnected))
+)
-			)
+{
-			{
+return ETrue;
-			return ETrue;
+}
-			}
+} while (timeLeft>0);
-		} while (timeLeft>0);
+//timeout happend
-	//timeout happend
+iSenseInfo.SetSense(TSenseInfo::ENotReady,
-	iSenseInfo.SetSense(TSenseInfo::ENotReady,
+TSenseInfo::EAscLogicalUnitDoesNotRespondToSelection);
-						TSenseInfo::EAscLogicalUnitDoesNotRespondToSelection);
+return EFalse;
-	return EFalse;
+}
-	}
 /**
 Command Parser for the PREVENT/ALLOW MEDIA REMOVAL command (0x1E)
 @param aData command data (started form position 1)
 @param aLun Logic unit number
 @return ETrue if successful.
 */
 TBool CScsiProtocol::HandlePreventMediaRemoval(TPtrC8& aData, TUint aLun)
-	{
+{
-	__FNLOG("CScsiProtocol::HandlePreventMediaRemoval");
+OstTrace0(TRACE_SMASSSTORAGE_SCSI, CSCSIPROTOCOL_PREVENTMEDIAREMOVAL, ">>> PREVENT MEDIA REMOVAL");
-	CMassStorageDrive* drive=GetCheckDrive(aLun);
+CMassStorageDrive* drive=GetCheckDrive(aLun);
-	if (drive == NULL)
+if (drive == NULL)
-		{
+{
-		return EFalse;
+return EFalse;
-		}
+}
-	TInt prevent = aData[5] & 0x01;
+TInt prevent = aData[5] & 0x01;
-	__PRINT1(_L("prevent = %d\n"), prevent);
+OstTrace1(TRACE_SMASSSTORAGE_SCSI, CSCSIPROTOCOL_PREVENTMEDIAREMOVAL1, "    prevent = %d", prevent);
-	iDriveManager.SetCritical(aLun, prevent);
+iDriveManager.SetCritical(aLun, prevent);
+return ETrue;
-	return ETrue;
+}
-	}
 /** Cancel active state, Invoked by transnport when it stops */
 TInt CScsiProtocol::Cancel()
-	{
+{
-	iDriveManager.SetCritical(CDriveManager::KAllLuns, EFalse);
+iDriveManager.SetCritical(CDriveManager::KAllLuns, EFalse);
-	return KErrNone;
+return KErrNone;
-	}
+}
 TBool CScsiProtocol::HandleReadFormatCapacities(TUint aLun)
 /**
 * Command Parser for the READ FORMAT CAPACITIES command (0x23)
 *
 * @return ETrue if successful, else a standard Symbian OS error code.
 */
-	{
+{
-	__FNLOG("CScsiProtocol::HandleReadFormatCapacities");
+OstTrace0(TRACE_SMASSSTORAGE_SCSI, CSCSIPROTOCOL_READFORMATCAPACITIES, ">>> READ FORMAT CAPACITIES");
+CMassStorageDrive* drive=GetCheckDrive(aLun);
-	CMassStorageDrive* drive=GetCheckDrive(aLun);
+if (drive == NULL)
-	if (drive == NULL)
+{
-		{
+return EFalse;
-		return EFalse;
+}
-		}
+TLocalDriveCapsV4 driveInfo;
-	TLocalDriveCapsV4 driveInfo;
+TInt err = drive->Caps(driveInfo);
-	TInt err = drive->Caps(driveInfo);
+if(err != KErrNone)
-	if(err != KErrNone)
+{
-		{
+OstTrace1(TRACE_SMASSSTORAGE, CSCSIPROTOCOL_HANDLEREADFORMATCAPACITIES, "Can't obtain drive Caps. Err=%d", err);
-		__PRINT1(_L("Can't obtain drive Caps. Err=%d \n"),err);
+iSenseInfo.SetSense(TSenseInfo::ENotReady, TSenseInfo::EMediaNotPresent);
-		iSenseInfo.SetSense(TSenseInfo::ENotReady, TSenseInfo::EMediaNotPresent);
+return EFalse;
-		return EFalse;
+}
-		}
+TInt64 driveBlocks = (driveInfo.iDriveAtt & KDriveAttLogicallyRemovable) ? driveInfo.iSize : driveInfo.MediaSizeInBytes();
-	TInt64 driveBlocks = (driveInfo.iDriveAtt & KDriveAttLogicallyRemovable) ? driveInfo.iSize : driveInfo.MediaSizeInBytes();
+driveBlocks /= MAKE_TINT64(0, KDefaultBlockSize);
-	driveBlocks /= MAKE_TINT64(0, KDefaultBlockSize);
+TPtr8 writeBuf(NULL, 0);
-	TPtr8 writeBuf(NULL, 0);
+iTransport->GetCommandBufPtr(writeBuf, KReadFormatCapacitiesCommandLength);
-	iTransport->GetCommandBufPtr(writeBuf, KReadFormatCapacitiesCommandLength);
+writeBuf.FillZ(KReadFormatCapacitiesCommandLength);
-	writeBuf.FillZ(KReadFormatCapacitiesCommandLength);
+writeBuf[3] = 0x08; // Capacity List Length
-	writeBuf[3] = 0x08;	// Capacity List Length
+TUint32 numBlocks = I64LOW(driveBlocks);
-	TUint32 numBlocks = I64LOW(driveBlocks);
+writeBuf[4] = static_cast<TUint8>((numBlocks & 0xFF000000) >> 24);  // Number of blocks
-	writeBuf[4] = static_cast<TUint8>((numBlocks & 0xFF000000) >> 24);	// Number of blocks
+writeBuf[5] = static_cast<TUint8>((numBlocks & 0x00FF0000) >> 16);  //
-	writeBuf[5] = static_cast<TUint8>((numBlocks & 0x00FF0000) >> 16);	//
+writeBuf[6] = static_cast<TUint8>((numBlocks & 0x0000FF00) >> 8);   //
-	writeBuf[6] = static_cast<TUint8>((numBlocks & 0x0000FF00) >> 8);	//
+writeBuf[7] = static_cast<TUint8>((numBlocks & 0x000000FF));        //
-	writeBuf[7] = static_cast<TUint8>((numBlocks & 0x000000FF));		//
+writeBuf[8] = 0x02; // Formatted size
-	writeBuf[8] = 0x02;	// Formatted size
+writeBuf[9]  = 0x00;    // 512 Byte Blocks
-	writeBuf[9]  = 0x00;	// 512 Byte Blocks
+writeBuf[10] = 0x02;    //
-	writeBuf[10] = 0x02;	//
+writeBuf[11] = 0x00;    //
-	writeBuf[11] = 0x00;	//
+TPtrC8 writeBuf1 = writeBuf;
-	TPtrC8 writeBuf1 = writeBuf;
+iTransport->SetupWriteData(writeBuf1);
-	iTransport->SetupWriteData(writeBuf1);
+return ETrue;
-	return ETrue;
+}
-	}
 /**
 Command Parser for the READ CAPACITY(10) command (0x25)
-@param aData command data (started form position 1)
-@param aLun Logic unit number
-@return ETrue if successful.
-*/
-TBool CScsiProtocol::HandleReadCapacity(TPtrC8& aData, TUint aLun)
-	{
-	__FNLOG("CScsiProtocol::HandleReadCapacity");
-	CMassStorageDrive* drive=GetCheckDrive(aLun);
-	if (drive == NULL)
-		{
-		return EFalse;
-		}
-	TInt pmi = aData[9] & 0x01;
-	TInt lba = aData[3] | aData[4] | aData[5] | aData[6];
-	if (pmi || lba)   //do not support partial medium indicator
-		{
-		iSenseInfo.SetSense(TSenseInfo::EIllegalRequest, TSenseInfo::EInvalidFieldInCdb);
-		return EFalse;
-		}
-	TLocalDriveCapsV4 driveInfo;
-	TInt err = drive->Caps(driveInfo);
-	if(err != KErrNone)
-		{
-		__PRINT1(_L("Can't obtain drive Caps. Err=%d \n"),err);
-		iSenseInfo.SetSense(TSenseInfo::ENotReady, TSenseInfo::EMediaNotPresent);
-		return EFalse;
-		}
-	TInt64 driveBlocks = 0;
-	if (driveInfo.iDriveAtt & KDriveAttLogicallyRemovable)
-		{
-		// Partition Access only
-		driveBlocks = driveInfo.iSize / MAKE_TINT64(0, KDefaultBlockSize);
-		}
-	else
-		{
-		// whole Media Access
-		driveBlocks = driveInfo.MediaSizeInBytes() / MAKE_TINT64(0, KDefaultBlockSize) - 1;
-		}
-	TPtr8 writeBuf(NULL, 0);
-	iTransport->GetCommandBufPtr(writeBuf, KReadCapacityCommandLength);
-	writeBuf.FillZ(KReadCapacityCommandLength);
-	if (I64HIGH(driveBlocks) == 0)
-		{
-		TUint32 numBlocks = I64LOW(driveBlocks);
-		__PRINT2(_L("Block size=%d, NumBlocks=%d\n"), KDefaultBlockSize, numBlocks);
-		writeBuf[0] = static_cast<TUint8>((numBlocks & 0xFF000000) >> 24);	// Number of blocks
-		writeBuf[1] = static_cast<TUint8>((numBlocks & 0x00FF0000) >> 16);
-		writeBuf[2] = static_cast<TUint8>((numBlocks & 0x0000FF00) >> 8);
-		writeBuf[3] = static_cast<TUint8>((numBlocks & 0x000000FF));
-		}
-	else
-		{
-		writeBuf[0] = writeBuf[1] = writeBuf[2] = writeBuf[3] = 0xFF;  // indicate that size more then )0xFFFFFFFF
-		}
-	writeBuf[4] = static_cast<TUint8>((KDefaultBlockSize & 0xFF000000) >> 24);	// Block Size
-	writeBuf[5] = static_cast<TUint8>((KDefaultBlockSize & 0x00FF0000) >> 16);
-	writeBuf[6] = static_cast<TUint8>((KDefaultBlockSize & 0x0000FF00) >> 8);
-	writeBuf[7] = static_cast<TUint8>((KDefaultBlockSize & 0x000000FF));
-	TPtrC8 writeBuf1 = writeBuf;
-	iTransport->SetupWriteData(writeBuf1);
-	return KErrNone;
-	}
-/**
-Command Parser for the READ10 command (0x28)
 @param aData command data (started form position 1)
 @param aLun Logic unit number
 @return ETrue if successful.
 */
-TBool CScsiProtocol::HandleRead10(TPtrC8& aData, TUint aLun)
+TBool CScsiProtocol::HandleReadCapacity(TPtrC8& aData, TUint aLun)
-	{
+{
-	__FNLOG("CScsiProtocol::HandleRead10");
+OstTrace0(TRACE_SMASSSTORAGE_SCSI, CSCSIPROTOCOL_READCAPACITY, ">>> READ CAPACITY");
-	CMassStorageDrive* drive = GetCheckDrive(aLun);
+CMassStorageDrive* drive=GetCheckDrive(aLun);
-	if (drive == NULL)
-		{
+if (drive == NULL)
-		return EFalse;
+{
-		}
+return EFalse;
-	TInt rdProtect = aData[2] >> 5;
+}
-	if (rdProtect)
-		{
+TInt pmi = aData[9] & 0x01;
-		iSenseInfo.SetSense(TSenseInfo::EIllegalRequest, TSenseInfo::EInvalidFieldInCdb);
+TInt lba = aData[3] | aData[4] | aData[5] | aData[6];
-		return EFalse;
-		}
+if (pmi || lba)   //do not support partial medium indicator
+{
-	const TUint32 lba = LBA(aData);
+iSenseInfo.SetSense(TSenseInfo::EIllegalRequest, TSenseInfo::EInvalidFieldInCdb);
-	const TUint16 len = LEN(aData);
+return EFalse;
+}
-	__PRINT2(_L("READ(10) : LBA = 0x%x, Length = %d  (blocks)\n"), lba, len);
+TLocalDriveCapsV4 driveInfo;
-	if (!len)
-		{
+TInt err = drive->Caps(driveInfo);
-		return ETrue; // do nothing - this is not an error
-		}
+if(err != KErrNone)
+{
-	TLocalDriveCapsV4 driveInfo;
+OstTrace1(TRACE_SMASSSTORAGE, CSCSIPROTOCOL_HANDLEREADCAPACITY1, "ERROR: Can't obtain drive Caps Err=%d", err);
-	TInt err = drive->Caps(driveInfo);
+iSenseInfo.SetSense(TSenseInfo::ENotReady, TSenseInfo::EMediaNotPresent);
-	if (err != KErrNone)
+return EFalse;
-		{
+}
-		__PRINT1(_L("Can't obtain drive Caps. Err=%d \n"), err);
-		iSenseInfo.SetSense(TSenseInfo::ENotReady, TSenseInfo::EMediaNotPresent);
+TInt64 driveBlocks = 0;
-		return EFalse;
+if (driveInfo.iDriveAtt & KDriveAttLogicallyRemovable)
-		}
+{
+// Partition Access only
-	const TInt64 bOffset = MAKE_TINT64(0, lba) * KDefaultBlockSize;
+driveBlocks = driveInfo.iSize / MAKE_TINT64(0, KDefaultBlockSize);
-	const TInt bLength = len * KDefaultBlockSize;
+}
-	const TInt64 theEnd = bOffset + MAKE_TINT64(0, bLength);
+else
-	const TInt64 mediaSize = (driveInfo.iDriveAtt & KDriveAttLogicallyRemovable) ? driveInfo.iSize : driveInfo.MediaSizeInBytes() ;
+{
+// whole Media Access
-	if (theEnd > mediaSize)  //check if media big enough for this request
+driveBlocks = driveInfo.MediaSizeInBytes() / MAKE_TINT64(0, KDefaultBlockSize) - 1;
-		{
+}
-		__PRINT(_L("err - Request ends out of media\n"));
-		iSenseInfo.SetSense(TSenseInfo::EIllegalRequest, TSenseInfo::ELbaOutOfRange);
-		return EFalse;
+TPtr8 writeBuf(NULL, 0);
-		}
+iTransport->GetCommandBufPtr(writeBuf, KReadCapacityCommandLength);
+writeBuf.FillZ(KReadCapacityCommandLength);
-#ifdef MSDC_MULTITHREADED
-	iWriteDriveThread->WaitForWriteEmpty();
+if (I64HIGH(driveBlocks) == 0)
+{
-	// check if our buffer can hold requested data
+TUint32 numBlocks = I64LOW(driveBlocks);
-	if (iReadDriveThread->iThreadContext->MaxBufferLength() < bLength)
-		{
+OstTraceExt2(TRACE_SMASSSTORAGE_SCSI, CSCSIPROTOCOL_HANDLEREADCAPACITY2,
-		__PRINT(_L("err - Buffer too small\n"));
+"    Block size=0x%x, NumBlocks=0x%x",
-		iSenseInfo.SetSense(TSenseInfo::EIllegalRequest, TSenseInfo::EInvalidFieldInCdb);
+KDefaultBlockSize, numBlocks);
-		return EFalse;
+writeBuf[0] = static_cast<TUint8>((numBlocks & 0xFF000000) >> 24);  // Number of blocks
-		}
+writeBuf[1] = static_cast<TUint8>((numBlocks & 0x00FF0000) >> 16);
+writeBuf[2] = static_cast<TUint8>((numBlocks & 0x0000FF00) >> 8);
-// Optimisation note : If the host is reading from sectors it just wrote to,
+writeBuf[3] = static_cast<TUint8>((numBlocks & 0x000000FF));
-// then we have to force a cache-miss so that the real data is read from the
+}
-// drive. It would be possible to service the read from the write buffers,
+else
-// but as the host is probably trying to verify the write data, we don't do
+{
-// that for now.
+writeBuf[0] = writeBuf[1] = writeBuf[2] = writeBuf[3] = 0xFF;  // indicate that size more then )0xFFFFFFFF
-	if (!iReadDriveThread->ReadDriveData(drive, bOffset, bLength, iWriteDriveThread->IsRecentlyWritten(bOffset,bLength)))
+}
-		{
-		iSenseInfo.SetSense(TSenseInfo::ENotReady, TSenseInfo::EMediaNotPresent);
+writeBuf[4] = static_cast<TUint8>((KDefaultBlockSize & 0xFF000000) >> 24);  // Block Size
-		return EFalse;
+writeBuf[5] = static_cast<TUint8>((KDefaultBlockSize & 0x00FF0000) >> 16);
-		}
+writeBuf[6] = static_cast<TUint8>((KDefaultBlockSize & 0x0000FF00) >> 8);
+writeBuf[7] = static_cast<TUint8>((KDefaultBlockSize & 0x000000FF));
-	iWriteDriveThread->SetCommandWrite10(EFalse);
-	TBlockDesc* &desc = iReadDriveThread->iThreadContext->iBuffer.iDescReadPtr;
+TPtrC8 writeBuf1 = writeBuf;
-	TPtrC8 writeBuf1 = desc->iBuf;
+iTransport->SetupWriteData(writeBuf1);
-#else
+return KErrNone;
-	TPtr8 writeBuf(NULL, 0);
+}
-	iTransport->GetReadDataBufPtr(writeBuf);
-	// check if our buffer can hold requested data
-	if (writeBuf.MaxLength() < bLength)
+/**
-		{
+Command Parser for the READ10 command (0x28)
-		__PRINT(_L("err - Buffer too small\n"));
-		iSenseInfo.SetSense(TSenseInfo::EIllegalRequest, TSenseInfo::EInvalidFieldInCdb);
-		return EFalse;
-		}
-	err = drive->Read(bOffset, bLength, writeBuf, drive->IsWholeMediaAccess());
-	if (err != KErrNone)
-		{
-		__PRINT1(_L("Read failed, err=%d\n"), err);
-		iSenseInfo.SetSense(TSenseInfo::ENotReady, TSenseInfo::EMediaNotPresent);
-		return EFalse;
-		}
-	TPtrC8 writeBuf1 = writeBuf;
-#endif // MSDC_MULTITHREADED
-#ifdef USB_TRANSFER_PUBLISHER
-	iBytesRead[aLun] += writeBuf1.Length();
-#endif
-	iReadTransferPublisher->StartTimer();
-	// Set up data write to the host
-	iTransport->SetupWriteData(writeBuf1);
-	return ETrue;
-	}
-/**
-Command Parser for the WRITE(10) command (0x2A)
 @param aData command data (started form position 1)
 @param aLun Logic unit number
 @return ETrue if successful.
 */
-TBool CScsiProtocol::HandleWrite10(TPtrC8& aData, TUint aLun)
+TBool CScsiProtocol::HandleRead10(TPtrC8& aData, TUint aLun)
-	{
+{
-	__FNLOG("CScsiProtocol::HandleWrite10");
+OstTrace0(TRACE_SMASSSTORAGE_SCSI, CSCSIPROTOCOL_READ10, ">>> READ(10)");
-	CMassStorageDrive* drive = GetCheckDrive(aLun);
+CMassStorageDrive* drive = GetCheckDrive(aLun);
-	if (drive == NULL)
+if (drive == NULL)
-		{
+{
-		return EFalse;
+return EFalse;
-		}
+}
-	TInt wrProtect = aData[2] >> 5;
+TInt rdProtect = aData[2] >> 5;
-	if (wrProtect)
+if (rdProtect)
-		{
+{
-		iSenseInfo.SetSense(TSenseInfo::EIllegalRequest, TSenseInfo::EInvalidFieldInCdb);
+iSenseInfo.SetSense(TSenseInfo::EIllegalRequest, TSenseInfo::EInvalidFieldInCdb);
-		return EFalse;
+return EFalse;
-		}
+}
-	const TUint32 lba = LBA(aData);
+const TUint32 lba = LBA(aData);
-	const TUint16 len = LEN(aData);
+const TUint32 len = LEN(aData);
-	__PRINT2(_L("WRITE(10) : LBA = 0x%x, Length = %d (blocks)\n"), lba, len);
-	if (!len)
+OstTraceExt2(TRACE_SMASSSTORAGE_SCSI, CSCSIPROTOCOL_HANDLEREAD10_1,
-		{
+"    LBA = 0x%x Transfer Len = 0x%x", lba, len);
-		return ETrue; // do nothing - this is not an error
-		}
+if (!len)
+{
-	TLocalDriveCapsV4 driveInfo;
+return ETrue; // do nothing - this is not an error
-	TInt err = drive->Caps(driveInfo);
+}
-	if (err != KErrNone)
-		{
+TLocalDriveCapsV4 driveInfo;
-		__PRINT1(_L("Can't obtain drive Caps. Err=%d \n"), err);
+TInt err = drive->Caps(driveInfo);
-		iSenseInfo.SetSense(TSenseInfo::ENotReady, TSenseInfo::EMediaNotPresent);
+if (err != KErrNone)
-		return EFalse;
+{
-		}
+OstTrace1(TRACE_SMASSSTORAGE, CSCSIPROTOCOL_HANDLEREAD10_2, "Can't obtain drive Caps. Err=%d", err);
-	if (driveInfo.iMediaAtt & KMediaAttWriteProtected ||
+iSenseInfo.SetSense(TSenseInfo::ENotReady, TSenseInfo::EMediaNotPresent);
-		driveInfo.iMediaAtt & KMediaAttLocked)
+return EFalse;
-		{
+}
-		iSenseInfo.SetSense(TSenseInfo::EDataProtection, TSenseInfo::EWriteProtected);
-		return EFalse;
+const TInt64 bOffset = MAKE_TINT64(0, lba) * KDefaultBlockSize;
-		}
+const TInt bLength = len * KDefaultBlockSize;
+const TInt64 theEnd = bOffset + MAKE_TINT64(0, bLength);
-	const TInt64 bOffset = MAKE_TINT64(0, lba) * KDefaultBlockSize;
+const TInt64 mediaSize = (driveInfo.iDriveAtt & KDriveAttLogicallyRemovable) ? driveInfo.iSize : driveInfo.MediaSizeInBytes() ;
-	iBytesRemain = len * KDefaultBlockSize;
-	const TInt64 theEnd = bOffset + MAKE_TINT64(0, iBytesRemain);
+if (theEnd > mediaSize)  //check if media big enough for this request
-	const TInt64 mediaSize = (driveInfo.iDriveAtt & KDriveAttLogicallyRemovable) ? driveInfo.iSize : driveInfo.MediaSizeInBytes() ;
+{
+OstTrace0(TRACE_SMASSSTORAGE, CSCSIPROTOCOL_HANDLEREAD10_3, "ERROR: Requested size is out of media range");
-	if (theEnd > mediaSize)  //check if media big enough for this request
+iSenseInfo.SetSense(TSenseInfo::EIllegalRequest, TSenseInfo::ELbaOutOfRange);
-		{
+return EFalse;
-		__PRINT(_L("err - Request ends out of media\n"));
+}
-		iSenseInfo.SetSense(TSenseInfo::EIllegalRequest, TSenseInfo::ELbaOutOfRange);
-		return EFalse;
+#ifdef MSDC_MULTITHREADED
-		}
+iWriteDriveThread->WaitForWriteEmpty();
-#ifdef MSDC_MULTITHREADED
+// check if our buffer can hold requested data
-	iWriteDriveThread->SetCommandWrite10(ETrue);
+if (iReadDriveThread->iThreadContext->MaxBufferLength() < bLength)
-#endif
+{
+OstTrace0(TRACE_SMASSSTORAGE, CSCSIPROTOCOL_HANDLEREAD10_4, "ERROR: Buffer too small");
-	// Set up the first request for data from the host - either
+iSenseInfo.SetSense(TSenseInfo::EIllegalRequest, TSenseInfo::EInvalidFieldInCdb);
-	// KMaxBufSize or the entire transfer length, whichever is smallest.
+return EFalse;
-	TUint thisLength = (iBytesRemain > KMaxBufSize) ? KMaxBufSize : iBytesRemain;
+}
-	thisLength = (thisLength > iMediaWriteSize) ? iMediaWriteSize : thisLength;
+// Optimisation note : If the host is reading from sectors it just wrote to,
-	iOffset = bOffset;
+// then we have to force a cache-miss so that the real data is read from the
-	iLastCommand = EWrite10;
+// drive. It would be possible to service the read from the write buffers,
-	iLastLun = aLun;
+// but as the host is probably trying to verify the write data, we don't do
+// that for now.
-	iWriteTransferPublisher->StartTimer();
+if (!iReadDriveThread->ReadDriveData(drive, bOffset, bLength, iWriteDriveThread->IsRecentlyWritten(bOffset,bLength)))
-	iTransport->SetupReadData(thisLength);
+{
+iSenseInfo.SetSense(TSenseInfo::ENotReady, TSenseInfo::EMediaNotPresent);
-	return ETrue;
+return EFalse;
-	}
+}
+iWriteDriveThread->SetCommandWrite10(EFalse);
-/**
+TBlockDesc* &desc = iReadDriveThread->iThreadContext->iBuffer.iDescReadPtr;
-Command Parser for the VERIFY(10) command (0x2F)
+TPtrC8 writeBuf1 = desc->iBuf;
+#else
+TPtr8 writeBuf(NULL, 0);
+iTransport->GetReadDataBufPtr(writeBuf);
+// check if our buffer can hold requested data
+if (writeBuf.MaxLength() < bLength)
+{
+iSenseInfo.SetSense(TSenseInfo::EIllegalRequest, TSenseInfo::EInvalidFieldInCdb);
+return EFalse;
+}
+err = drive->Read(bOffset, bLength, writeBuf, drive->IsWholeMediaAccess());
+if (err != KErrNone)
+{
+OstTrace1(TRACE_SMASSSTORAGE, CSCSIPROTOCOL_HANDLEREAD10_5, "ERROR: Read failed err=%d", err);
+iSenseInfo.SetSense(TSenseInfo::ENotReady, TSenseInfo::EMediaNotPresent);
+return EFalse;
+}
+TPtrC8 writeBuf1 = writeBuf;
+#endif // MSDC_MULTITHREADED
+#ifdef USB_TRANSFER_PUBLISHER
+iBytesRead[aLun] += writeBuf1.Length();
+#endif
+iReadTransferPublisher->StartTimer();
+// Set up data write to the host
+iTransport->SetupWriteData(writeBuf1);
+return ETrue;
+}
+/**
+Command Parser for the WRITE(10) command (0x2A)
 @param aData command data (started form position 1)
 @param aLun Logic unit number
 @return ETrue if successful.
 */
+TBool CScsiProtocol::HandleWrite10(TPtrC8& aData, TUint aLun)
+{
+OstTrace0(TRACE_SMASSSTORAGE_SCSI, CSCSIPROTOCOL_WRITE10, ">>> WRITE(10)");
+CMassStorageDrive* drive = GetCheckDrive(aLun);
+if (drive == NULL)
+{
+return EFalse;
+}
+TInt wrProtect = aData[2] >> 5;
+if (wrProtect)
+{
+iSenseInfo.SetSense(TSenseInfo::EIllegalRequest, TSenseInfo::EInvalidFieldInCdb);
+return EFalse;
+}
+const TUint32 lba = LBA(aData);
+const TUint32 len = LEN(aData);
+OstTraceExt2(TRACE_SMASSSTORAGE_SCSI, CSCSIPROTOCOL_HANDLEWRITE10_1, "LBA = 0x%x, Transfer Len = 0x%x", lba, len);
+if (!len)
+{
+return ETrue; // do nothing - this is not an error
+}
+TLocalDriveCapsV4 driveInfo;
+TInt err = drive->Caps(driveInfo);
+if (err != KErrNone)
+{
+OstTrace1(TRACE_SMASSSTORAGE, CSCSIPROTOCOL_WRITE10_2, "ERROR: Can't obtain drive Caps Err=%d", err);
+iSenseInfo.SetSense(TSenseInfo::ENotReady, TSenseInfo::EMediaNotPresent);
+return EFalse;
+}
+if (driveInfo.iMediaAtt & KMediaAttWriteProtected ||
+driveInfo.iMediaAtt & KMediaAttLocked)
+{
+iSenseInfo.SetSense(TSenseInfo::EDataProtection, TSenseInfo::EWriteProtected);
+return EFalse;
+}
+const TInt64 bOffset = MAKE_TINT64(0, lba) * KDefaultBlockSize;
+iBytesRemain = len * KDefaultBlockSize;
+const TInt64 theEnd = bOffset + MAKE_TINT64(0, iBytesRemain);
+const TInt64 mediaSize = (driveInfo.iDriveAtt & KDriveAttLogicallyRemovable) ? driveInfo.iSize : driveInfo.MediaSizeInBytes() ;
+if (theEnd > mediaSize)  //check if media big enough for this request
+{
+OstTrace0(TRACE_SMASSSTORAGE, CSCSIPROTOCOL_HANDLEWRITE10_3, "Requested size is out of media range");
+iSenseInfo.SetSense(TSenseInfo::EIllegalRequest, TSenseInfo::ELbaOutOfRange);
+return EFalse;
+}
+#ifdef MSDC_MULTITHREADED
+iWriteDriveThread->SetCommandWrite10(ETrue);
+#endif
+// Set up the first request for data from the host - either
+// KMaxBufSize or the entire transfer length, whichever is smallest.
+TUint thisLength = (iBytesRemain > KMaxBufSize) ? KMaxBufSize : iBytesRemain;
+thisLength = (thisLength > iMediaWriteSize) ? iMediaWriteSize : thisLength;
+iOffset = bOffset;
+iLastCommand = EWrite10;
+iLastLun = aLun;
+iWriteTransferPublisher->StartTimer();
+iTransport->SetupReadData(thisLength);
+return ETrue;
+}
+/**
+Command Parser for the VERIFY(10) command (0x2F)
+@param aData command data (started form position 1)
+@param aLun Logic unit number
+@return ETrue if successful.
+*/
 TBool CScsiProtocol::HandleVerify10(TPtrC8& aData, TUint aLun)
-	{
+{
-	__FNLOG("CScsiProtocol::HandleVerify10");
+OstTrace0(TRACE_SMASSSTORAGE_SCSI, CSCSIPROTOCOL_VERIFY10, ">>> VERIFY(10)");
-	CMassStorageDrive* drive = GetCheckDrive(aLun);
+CMassStorageDrive* drive = GetCheckDrive(aLun);
-	if (drive == NULL)
+if (drive == NULL)
-		{
+{
-		return EFalse;
+return EFalse;
-		}
+}
-	TInt vrProtect = aData[2] >> 5;
+TInt vrProtect = aData[2] >> 5;
-	if (vrProtect)
+if (vrProtect)
-		{
+{
-		iSenseInfo.SetSense(TSenseInfo::EIllegalRequest, TSenseInfo::EInvalidFieldInCdb);
+iSenseInfo.SetSense(TSenseInfo::EIllegalRequest, TSenseInfo::EInvalidFieldInCdb);
-		return EFalse;
+return EFalse;
-		}
+}
-	const TUint32 lba = LBA(aData);
+const TUint32 lba = LBA(aData);
-	const TUint16 len = LEN(aData);
+const TUint32 len = LEN(aData);
-	__PRINT2(_L("VERIFY(10) : LBA = %d, Length = %d  (blocks)\n"), lba, len);
+OstTraceExt2(TRACE_SMASSSTORAGE_SCSI, CSCSIPROTOCOL_VERIFY10_1, "VERIFY(10) : LBA = 0x%x Transfer Len = 0x%x", lba, len);
-	TInt bytChk = aData[2] & 0x02;
+TInt bytChk = aData[2] & 0x02;
-	if (!len)
+if (!len)
-		{
+{
-		return ETrue; // do nothing - this is not an error
+return ETrue; // do nothing - this is not an error
-		}
+}
-	TLocalDriveCapsV4 driveInfo;
+TLocalDriveCapsV4 driveInfo;
-	TInt err = drive->Caps(driveInfo);
+TInt err = drive->Caps(driveInfo);
-	if (err != KErrNone)
+if (err != KErrNone)
-		{
+{
-		__PRINT1(_L("Can't obtain drive Caps. Err=%d \n"), err);
+OstTrace1(TRACE_SMASSSTORAGE, CSCSIPROTOCOL_VERIFY10_2, "ERROR: Can't obtain drive Caps Err=%d", err);
-		iSenseInfo.SetSense(TSenseInfo::ENotReady, TSenseInfo::EMediaNotPresent);
+iSenseInfo.SetSense(TSenseInfo::ENotReady, TSenseInfo::EMediaNotPresent);
-		return EFalse;
+return EFalse;
-		}
+}
-	const TInt64 bOffset = MAKE_TINT64(0, lba) * KDefaultBlockSize;
+const TInt64 bOffset = MAKE_TINT64(0, lba) * KDefaultBlockSize;
-	const TInt bLength = len * KDefaultBlockSize;
+const TInt bLength = len * KDefaultBlockSize;
-	const TInt64 theEnd = bOffset + MAKE_TINT64(0, bLength);
+const TInt64 theEnd = bOffset + MAKE_TINT64(0, bLength);
-	const TInt64 mediaSize = (driveInfo.iDriveAtt & KDriveAttLogicallyRemovable) ? driveInfo.iSize : driveInfo.MediaSizeInBytes() ;
+const TInt64 mediaSize = (driveInfo.iDriveAtt & KDriveAttLogicallyRemovable) ? driveInfo.iSize : driveInfo.MediaSizeInBytes() ;
-	// check if media big enough for this request
+// check if media big enough for this request
-	if (theEnd > mediaSize)
+if (theEnd > mediaSize)
-		{
+{
-		iSenseInfo.SetSense(TSenseInfo::EIllegalRequest, TSenseInfo::ELbaOutOfRange);
+iSenseInfo.SetSense(TSenseInfo::EIllegalRequest, TSenseInfo::ELbaOutOfRange);
-		return EFalse;
+return EFalse;
-		}
+}
-	// check if our buffer can hold requested data
+// check if our buffer can hold requested data
 #ifdef MSDC_MULTITHREADED
-	if (iWriteDriveThread->iThreadContext->MaxBufferLength() < bLength)
+if (iWriteDriveThread->iThreadContext->MaxBufferLength() < bLength)
 #else
-	TPtr8 writeBuf(NULL, 0);
+TPtr8 writeBuf(NULL, 0);
-	iTransport->GetReadDataBufPtr(writeBuf);
+iTransport->GetReadDataBufPtr(writeBuf);
-	if (writeBuf.MaxLength() < bLength)
+if (writeBuf.MaxLength() < bLength)
 #endif
-		{
+{
-		iSenseInfo.SetSense(TSenseInfo::EIllegalRequest, TSenseInfo::EInvalidFieldInCdb);
+iSenseInfo.SetSense(TSenseInfo::EIllegalRequest, TSenseInfo::EInvalidFieldInCdb);
-		return EFalse;
+return EFalse;
-		}
+}
-	if (!bytChk)
+if (!bytChk)
-		{
+{
-		// BYTCHK==0 : Perform a medium verification with no data comparison and not transfer any data from the application client data-out buffer.
+// BYTCHK==0 : Perform a medium verification with no data comparison and not transfer any data from the application client data-out buffer.
-		// The device should attempt to read from the specified locations
+// The device should attempt to read from the specified locations
 #ifdef MSDC_MULTITHREADED
-		TPtr8 writeBuf = iWriteDriveThread->iThreadContext->GetReadBuffer(bLength);
+TPtr8 writeBuf = iWriteDriveThread->iThreadContext->GetReadBuffer(bLength);
 #else
-		writeBuf.SetLength(bLength);
+writeBuf.SetLength(bLength);
 #endif
-		err = drive->Read(bOffset, bLength, writeBuf, drive->IsWholeMediaAccess());
+err = drive->Read(bOffset, bLength, writeBuf, drive->IsWholeMediaAccess());
-		if (err != KErrNone)
+if (err != KErrNone)
-			{
+{
-			iSenseInfo.SetSense(TSenseInfo::EMisCompare);
+iSenseInfo.SetSense(TSenseInfo::EMisCompare);
-			return EFalse;
+return EFalse;
-			}
+}
-		return ETrue;
+return ETrue;
-		}
+}
-	// BYTCHK==1 : perform a byte-by-byte comparison of user data read from the medium & user data transferred from the application client data-out buffer.
+// BYTCHK==1 : perform a byte-by-byte comparison of user data read from the medium & user data transferred from the application client data-out buffer.
-	// The host sends data in the data-transport phase, and the device should verify that the received data matches what is stored in the device.
+// The host sends data in the data-transport phase, and the device should verify that the received data matches what is stored in the device.
-	iOffset = bOffset;
+iOffset = bOffset;
-	iLastCommand = EVerify10;
+iLastCommand = EVerify10;
-	iLastLun = aLun;
+iLastLun = aLun;
-	iTransport->SetupReadData(bLength);
+iTransport->SetupReadData(bLength);
-	return ETrue;
+return ETrue;
-	}
+}
 /**
 Called by the transport when the requested data has been read or an error has
 occurred during the read.
 the transfer immediately, KErrNotReady if insufficient data is
 available in the buffer so the transport should wait for it to arrive,
 KErrNone if command processing is complete and was successful.
 */
 TInt CScsiProtocol::ReadComplete(TInt aError)
-	{
+{
-	__FNLOG("CScsiProtocol::ReadComplete");
+OstTrace1(TRACE_SMASSSTORAGE_MEDIA, CSCSIPROTOCOL_READCOMPLETE0, "ReadComplete = 0x%X", aError);
-	__PRINT1(_L("Error = 0x%X \n"), aError);
+const TInt64 bOffset = iOffset;
-	const TInt64 bOffset = iOffset;
+TUint8 lastCommand = iLastCommand;
-	TUint8 lastCommand = iLastCommand;
+TUint lastLun = iLastLun;
-	TUint lastLun = iLastLun;
+iOffset = 0;
-	iOffset = 0;
+iLastCommand = EUndefinedCommand;
-	iLastCommand = EUndefinedCommand;
+iLastLun = KUndefinedLun;
-	iLastLun = KUndefinedLun;
+//  OstTrace1(TRACE_SMASSSTORAGE_MEDIA, CSCSIPROTOCOL_READCOMPLETE1, "lastCommand = d", lastCommand);
-	__PRINT1(_L("Last command was: %s\n"),
-			 (lastCommand == EUndefinedCommand) ? _S("Undefined") :
+if (aError != KErrNone ||
-			 ((lastCommand == EWrite10) ? _S("EWrite10") :
+lastCommand == EUndefinedCommand ||
-			  ((lastCommand == EVerify10) ? _S("EVerify10") :
+lastLun == KUndefinedLun)
-			   _S("Unknown"))));
+{
+iSenseInfo.SetSense(TSenseInfo::EAbortedCommand);
-	if (aError != KErrNone ||
+return KErrAbort;
-		lastCommand == EUndefinedCommand ||
+}
-		lastLun == KUndefinedLun)
-		{
+CMassStorageDrive* drive = GetCheckDrive(lastLun);
-		iSenseInfo.SetSense(TSenseInfo::EAbortedCommand);
+if (drive == NULL)
-		return KErrAbort;
+{
-		}
+return KErrAbort;
+}
-	CMassStorageDrive* drive = GetCheckDrive(lastLun);
-	if (drive == NULL)
+if (lastCommand == EWrite10)
-		{
+{
-		return KErrAbort;
+TPtrC8 writeBuf(NULL, 0);
-		}
+iTransport->GetWriteDataBufPtr(writeBuf);
-	if (lastCommand == EWrite10)
-		{
-		TPtrC8 writeBuf(NULL, 0);
-		iTransport->GetWriteDataBufPtr(writeBuf);
 #ifdef USB_TRANSFER_PUBLISHER
-	iBytesWritten[lastLun] += writeBuf.Length();
+iBytesWritten[lastLun] += writeBuf.Length();
 #endif
 #ifdef MSDC_MULTITHREADED
-		TInt err = iWriteDriveThread->WriteDriveData(drive, bOffset, writeBuf, ProcessWriteComplete, this);
+TInt err = iWriteDriveThread->WriteDriveData(drive, bOffset, writeBuf, ProcessWriteComplete, this);
-		if (err != KErrNone)
+if (err != KErrNone)
-			{
+{
-			iDeferredSenseInfo.SetSense(TSenseInfo::EMediumError);
+iDeferredSenseInfo.SetSense(TSenseInfo::EMediumError);
-			}
+}
-		TUint thisLength = iWriteDriveThread->WriteBufferLength();
+TUint thisLength = iWriteDriveThread->WriteBufferLength();
 #else
-#ifdef MEASURE_AND_DISPLAY_WRITE_TIME
+OstTrace1(TRACE_SMASSSTORAGE_MEDIA, CSCSIPROTOCOL_READCOMPLETE2, "SCSI: writing 0x%x bytes", writeBuf.Length());
-		RDebug::Print(_L("SCSI: writing %d bytes\n"), writeBuf.Length());
+TInt err = drive->Write(bOffset, writeBuf, drive->IsWholeMediaAccess());
-		TTime t0, t1;
+if (err != KErrNone)
-		t0.HomeTime();
+{
+OstTrace1(TRACE_SMASSSTORAGE_MEDIA, CSCSIPROTOCOL_READCOMPLETE3, "Error after write = 0x%x", err);
+iSenseInfo.SetSense(TSenseInfo::EAbortedCommand);
+return KErrAbort;
+}
+TUint thisLength = writeBuf.Length();
+#endif // MSDC_MULTITHREADED
+iOffset = bOffset + MAKE_TINT64(0, thisLength);
+iBytesRemain -= thisLength;
+if ((TInt)iBytesRemain > 0)
+{
+// More data is expected - set up another request to read from the host
+iLastCommand = EWrite10;
+iLastLun = lastLun;
+TUint minLength = (iBytesRemain < iMediaWriteSize) ? iBytesRemain : iMediaWriteSize;
+TUint bytesAvail = iTransport->BytesAvailable() & ~(KDefaultBlockSize-1);
+TBool wait = EFalse;
+thisLength = bytesAvail ? bytesAvail : minLength;
+if (thisLength < minLength)
+{
+// Not enough data is available at the transport to satisfy the request,
+// so return KErrNotReady to indicate that the transport should wait.
+thisLength = minLength;
+wait = ETrue;
+}
+thisLength = (thisLength > KMaxBufSize) ? KMaxBufSize : thisLength;
+iTransport->SetupReadData(thisLength);
+return wait ? KErrNotReady : KErrCompletion;
+}
+}
+else if (lastCommand == EVerify10)
+{
+HBufC8* hostData = NULL;
+TPtrC8 writeBuf(NULL, 0);
+iTransport->GetWriteDataBufPtr(writeBuf);
+#ifdef MSDC_MULTITHREADED
+TRAPD(err, hostData = HBufC8::NewL(writeBuf.Length()));
 #else
-		__PRINT1(_L("SCSI: writing %d bytes\n"), writeBuf.Length());
+TRAPD(err, hostData = HBufC8::NewL(writeBuf.Length()));
 #endif
+if (err != KErrNone || hostData == NULL)
-#ifdef INJECT_ERROR
+{
-		if (writeBuf[0] == '2')
+iSenseInfo.SetSense(TSenseInfo::EAbortedCommand, TSenseInfo::EInsufficientRes);
-		{
+return KErrAbort;
-			writeBuf[0] = 'x';
+}
-			RDebug::Printf("Injecting error");
-		}
+#ifdef MSDC_MULTITHREADED
+// copy the data
-		RDebug::Printf("%08lx %x [%x] [%x]", bOffset,writeBuf.Length(),
+*hostData = writeBuf;
-			writeBuf[0],
+TPtr8 readBuf = iWriteDriveThread->iThreadContext->GetReadBuffer();
-			writeBuf[writeBuf.Length()-1]);
+err = drive->Read(bOffset, writeBuf.Length(), readBuf, drive->IsWholeMediaAccess());
-#endif
+if (err == KErrNone)
+{
-		TInt err = drive->Write(bOffset, writeBuf, drive->IsWholeMediaAccess());
+err = (hostData->Compare(readBuf) == 0) ? KErrNone : KErrCorrupt;
+}
-#ifdef INJECT_ERROR
-		if (writeBuf[0] == 'x')
-		{
-			err = KErrUnknown;
-		}
-#endif
-#ifdef MEASURE_AND_DISPLAY_WRITE_TIME
-		t1.HomeTime();
-		const TTimeIntervalMicroSeconds time = t1.MicroSecondsFrom(t0);
-		const TUint time_ms = I64LOW(time.Int64() / 1000);
-		RDebug::Print(_L("SCSI: write took %d ms\n"), time_ms);
-#endif
-		if (err != KErrNone)
-			{
-			__PRINT1(_L("Error after write = 0x%X \n"), err);
-			iSenseInfo.SetSense(TSenseInfo::EAbortedCommand);
-			return KErrAbort;
-			}
-		TUint thisLength = writeBuf.Length();
-#endif // MSDC_MULTITHREADED
-		iOffset = bOffset + MAKE_TINT64(0, thisLength);
-		iBytesRemain -= thisLength;
-		if ((TInt)iBytesRemain > 0)
-			{
-			// More data is expected - set up another request to read from the host
-			iLastCommand = EWrite10;
-			iLastLun = lastLun;
-			TUint minLength = (iBytesRemain < iMediaWriteSize) ? iBytesRemain : iMediaWriteSize;
-			TUint bytesAvail = iTransport->BytesAvailable() & ~(KDefaultBlockSize-1);
-			TBool wait = EFalse;
-			thisLength = bytesAvail ? bytesAvail : minLength;
-			if (thisLength < minLength)
-				{
-				// Not enough data is available at the transport to satisfy the request,
-				// so return KErrNotReady to indicate that the transport should wait.
-				thisLength = minLength;
-				wait = ETrue;
-				}
-			thisLength = (thisLength > KMaxBufSize) ? KMaxBufSize : thisLength;
-			iTransport->SetupReadData(thisLength);
-			return wait ? KErrNotReady : KErrCompletion;
-			}
-		}
-	else if (lastCommand == EVerify10)
-		{
-		HBufC8* hostData = NULL;
-		TPtrC8 writeBuf(NULL, 0);
-		iTransport->GetWriteDataBufPtr(writeBuf);
-#ifdef MSDC_MULTITHREADED
-		TRAPD(err, hostData = HBufC8::NewL(writeBuf.Length()));
 #else
-		TRAPD(err, hostData = HBufC8::NewL(writeBuf.Length()));
+*hostData = writeBuf;
-#endif
+TPtr8 readBuf((TUint8*) writeBuf.Ptr(), writeBuf.Length());
-		if (err != KErrNone || hostData == NULL)
+err = drive->Read(bOffset, writeBuf.Length(), readBuf, drive->IsWholeMediaAccess());
-			{
+if (err == KErrNone)
-			iSenseInfo.SetSense(TSenseInfo::EAbortedCommand, TSenseInfo::EInsufficientRes);
+{
-			return KErrAbort;
+err = (hostData->Compare(readBuf) == 0) ? KErrNone : KErrCorrupt;
-			}
+}
+#endif
-#ifdef MSDC_MULTITHREADED
-		// copy the data
+if (err != KErrNone)
-		*hostData = writeBuf;
+{
-		TPtr8 readBuf = iWriteDriveThread->iThreadContext->GetReadBuffer();
+iSenseInfo.SetSense(TSenseInfo::EMisCompare);
-		err = drive->Read(bOffset, writeBuf.Length(), readBuf, drive->IsWholeMediaAccess());
+}
-		if (err == KErrNone)
-			{
+delete hostData;
-			err = (hostData->Compare(readBuf) == 0) ? KErrNone : KErrCorrupt;
+}
-			}
+else // unknown command
-#else
+{
-		*hostData = writeBuf;
+iSenseInfo.SetSense(TSenseInfo::EAbortedCommand);
-		TPtr8 readBuf((TUint8*) writeBuf.Ptr(), writeBuf.Length());
+}
-		err = drive->Read(bOffset, writeBuf.Length(), readBuf, drive->IsWholeMediaAccess());
+return iSenseInfo.SenseOk() ? KErrNone : KErrAbort;
-		if (err == KErrNone)
+}
-			{
-			err = (hostData->Compare(readBuf) == 0) ? KErrNone : KErrCorrupt;
-			}
-#endif
-		if (err != KErrNone)
-			{
-			iSenseInfo.SetSense(TSenseInfo::EMisCompare);
-			}
-		delete hostData;
-		}
-	else // unknown command
-		{
-		iSenseInfo.SetSense(TSenseInfo::EAbortedCommand);
-		}
-	return iSenseInfo.SenseOk() ? KErrNone : KErrAbort;
-	}
 /**
 Command Parser for the MODE SENSE(06) command (0x1A)
 @return ETrue if successful.
 */
 TBool CScsiProtocol::HandleModeSense6(TPtrC8& aData, TUint aLun)
-	{
+{
-	__FNLOG("CScsiProtocol::HandleModeSense6");
+OstTrace0(TRACE_SMASSSTORAGE_SCSI, CSCSIPROTOCOL_MODESENSE6, ">>> MODESENSE(06)");
+TInt pageCode = aData[3] & 0x3F;
-	TInt pageCode = aData[3] & 0x3F;
+TUint8 pageControl= static_cast<TUint8>(aData[3] >>6);
-	TUint8 pageControl= static_cast<TUint8>(aData[3] >>6);
+if (pageCode != KAllPages || pageControl == KChangeableValues)
-	if (pageCode != KAllPages || pageControl == KChangeableValues)
+{
-		{
+iSenseInfo.SetSense(TSenseInfo::EIllegalRequest,TSenseInfo::EInvalidFieldInCdb);
-		__PRINT(_L("TSenseInfo::EIllegalRequest,TSenseInfo::EInvalidFieldInCdb"));
+return EFalse;
-		iSenseInfo.SetSense(TSenseInfo::EIllegalRequest,TSenseInfo::EInvalidFieldInCdb);
+}
-		return EFalse;
-		}
+// reserve 4 bytes for Length, Media type, Device-specific parameter and Block descriptor length
+TPtr8 writeBuf(NULL, 0);
-	// reserve 4 bytes for Length, Media type, Device-specific parameter and Block descriptor length
+iTransport->GetCommandBufPtr(writeBuf, KModeSense6CommandLength);
-	TPtr8 writeBuf(NULL, 0);
+writeBuf.FillZ(KModeSense6CommandLength);
-	iTransport->GetCommandBufPtr(writeBuf, KModeSense6CommandLength);
-	writeBuf.FillZ(KModeSense6CommandLength);
+if (pageControl != KDefaultValues)
+{
-	if (pageControl != KDefaultValues)
+//check if drive write protected
-		{
+CMassStorageDrive* drive=GetCheckDrive(aLun);
-		//check if drive write protected
+if (drive == NULL)
-		CMassStorageDrive* drive=GetCheckDrive(aLun);
+{
-		if (drive == NULL)
+OstTrace0(TRACE_SMASSSTORAGE, CSCSIPROTOCOL_HANDLEMODESENSE6_1, "drive == null");
-			{
+return EFalse;
-			__PRINT(_L("drive == null"));
+}
-			return EFalse;
-			}
+TLocalDriveCapsV4 driveInfo;
+TInt err = drive->Caps(driveInfo);
-		TLocalDriveCapsV4 driveInfo;
+if (err != KErrNone)
-		TInt err = drive->Caps(driveInfo);
+{
-		if (err != KErrNone)
+OstTrace1(TRACE_SMASSSTORAGE, CSCSIPROTOCOL_MODESENSE6_2, "ERROR: Can't obtain drive Caps Err=%d", err);
-			{
+iSenseInfo.SetSense(TSenseInfo::ENotReady, TSenseInfo::EMediaNotPresent);
-			__PRINT(_L("TSenseInfo::ENotReady"));
+return EFalse ;
-			iSenseInfo.SetSense(TSenseInfo::ENotReady, TSenseInfo::EMediaNotPresent);
+}
-			return EFalse ;
-			}
+if (driveInfo.iMediaAtt & KMediaAttWriteProtected)
+{
-		if (driveInfo.iMediaAtt & KMediaAttWriteProtected)
+writeBuf[2] = 1<<7;  // set SWP bit at the Device Specific parameters
-			{
+}
-			writeBuf[2] = 1<<7;  // set SWP bit at the Device Specific parameters
+}
-			}
-		}
+writeBuf[0]=3;  //Sending only Mode parameter header
-	writeBuf[0]=3;  //Sending only Mode parameter header
+TPtrC8 writeBuf1 = writeBuf;
-	TPtrC8 writeBuf1 = writeBuf;
+iTransport->SetupWriteData(writeBuf1);
-	iTransport->SetupWriteData(writeBuf1);
+return (iSenseInfo.SenseOk());
+}
-	return (iSenseInfo.SenseOk());
-	}
 /**
 Command Parser for the MODE SENSE(10) command (0x5A)
 @return ETrue if successful.
 */
 TBool CScsiProtocol::HandleModeSense10(TPtrC8& aData, TUint aLun)
-	{
+{
-	__FNLOG("CScsiProtocol::HandleModeSense10");
+OstTrace0(TRACE_SMASSSTORAGE_SCSI, CSCSIPROTOCOL_MODESENSE10, ">>> MODESENSE(10)");
+TInt pageCode = aData[3] & 0x3F;
-	TInt pageCode = aData[3] & 0x3F;
+TUint8 pageControl= static_cast<TUint8>(aData[3] >>6);
-	TUint8 pageControl= static_cast<TUint8>(aData[3] >>6);
+if (pageCode != KAllPages || pageControl == KChangeableValues)
-	if (pageCode != KAllPages || pageControl == KChangeableValues)
+{
-		{
+iSenseInfo.SetSense(TSenseInfo::EIllegalRequest,TSenseInfo::EInvalidFieldInCdb);
-		__PRINT(_L("TSenseInfo::EIllegalRequest,TSenseInfo::EInvalidFieldInCdb"));
+return EFalse;
-		iSenseInfo.SetSense(TSenseInfo::EIllegalRequest,TSenseInfo::EInvalidFieldInCdb);
+}
-		return EFalse;
-		}
+// reserve 8 bytes for Length, Media type, Device-specific parameter and Block descriptor length
+TPtr8 writeBuf(NULL, 0);
-	// reserve 8 bytes for Length, Media type, Device-specific parameter and Block descriptor length
+iTransport->GetCommandBufPtr(writeBuf, KModeSense10CommandLength);
-	TPtr8 writeBuf(NULL, 0);
+writeBuf.FillZ(KModeSense10CommandLength);
-	iTransport->GetCommandBufPtr(writeBuf, KModeSense10CommandLength);
-	writeBuf.FillZ(KModeSense10CommandLength);
+if (pageControl != KDefaultValues)
+{
-	if (pageControl != KDefaultValues)
+//check if drive write protected
-		{
+CMassStorageDrive* drive=GetCheckDrive(aLun);
-		//check if drive write protected
+if (drive == NULL)
-		CMassStorageDrive* drive=GetCheckDrive(aLun);
+{
-		if (drive == NULL)
+OstTrace0(TRACE_SMASSSTORAGE, CSCSIPROTOCOL_HANDLEMODESENSE10_1, "drive == null");
-			{
+return EFalse;
-			__PRINT(_L("drive == null"));
+}
-			return EFalse;
-			}
+TLocalDriveCapsV4 driveInfo;
+TInt err = drive->Caps(driveInfo);
-		TLocalDriveCapsV4 driveInfo;
+if (err != KErrNone)
-		TInt err = drive->Caps(driveInfo);
+{
-		if (err != KErrNone)
+OstTrace1(TRACE_SMASSSTORAGE, CSCSIPROTOCOL_MODESENSE10_1, "ERROR: Can't obtain drive Caps Err=%d", err);
-			{
+iSenseInfo.SetSense(TSenseInfo::ENotReady, TSenseInfo::EMediaNotPresent);
-			__PRINT(_L("TSenseInfo::ENotReady"));
+return EFalse ;
-			iSenseInfo.SetSense(TSenseInfo::ENotReady, TSenseInfo::EMediaNotPresent);
+}
-			return EFalse ;
-			}
+if (driveInfo.iMediaAtt & KMediaAttWriteProtected)
+{
-		if (driveInfo.iMediaAtt & KMediaAttWriteProtected)
+writeBuf[3] = 1<<7;  // set SWP bit at the Device Specific parameters
-			{
+}
-			writeBuf[3] = 1<<7;  // set SWP bit at the Device Specific parameters
+}
-			}
-		}
+writeBuf[1]=6;  //Sending only Mode parameter header
-	writeBuf[1]=6;  //Sending only Mode parameter header
+TPtrC8 writeBuf1 = writeBuf;
-	TPtrC8 writeBuf1 = writeBuf;
+iTransport->SetupWriteData(writeBuf1);
-	iTransport->SetupWriteData(writeBuf1);
+return (iSenseInfo.SenseOk());
+}
-	return (iSenseInfo.SenseOk());
-	}

changeset 286	48e57fb1237e
parent 90	947f0dc9f7a8