diff -r 000000000000 -r 1e05558e2206 usbclasses/usbphoneasmodem/classimplementation/mscfileserver/src/bulkonlytransport.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/usbclasses/usbphoneasmodem/classimplementation/mscfileserver/src/bulkonlytransport.cpp	Thu Dec 17 09:14:30 2009 +0200
@@ -0,0 +1,1493 @@
+// Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "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
+ */
+#include "bulkonlytransport.h"
+#include "mscfileserver.h"
+#include "usbmscfileshared.h"
+#include "debug.h"
+#define InEndpoint EEndpoint1
+#define OutEndpoint EEndpoint2
+//This value defined in USB Mass Storage Bulk Only Transrt spec and not supposed to be changed
+LOCAL_D const TInt KRequiredNumberOfEndpoints = 2; // in addition to endpoint 0. 
+
+
+//CBW offsets
+LOCAL_D const TInt KCbwSignatureOffset = 0;
+LOCAL_D const TInt KCbwTagOffset = 4;
+LOCAL_D const TInt KCbwDataTransferLengthOffset = 8;
+LOCAL_D const TInt KCbwFlagOffset = 12;
+LOCAL_D const TInt KCbwLunOffset = 13;
+LOCAL_D const TInt KCbwCbLengthOffset = 14;
+LOCAL_D const TInt KMaxCbwcbLength = 16;
+// CSW offsets
+LOCAL_D const TInt KCswSingnatureOffset = 0;
+LOCAL_D const TInt KCswTagOffset = 4;
+LOCAL_D const TInt KCswDataResidueOffset = 8;
+LOCAL_D const TInt KCswStatusOffset = 12;
+LOCAL_D const TInt KCswLength = 13;
+LOCAL_D const TInt KUsbNumInterfacesOffset = 4;
+
+/**
+ This function unpacks into the TUsbRequestHdr class from a descriptor with 
+ the alignment that would be introduced on the USB bus.
+ 
+ @param aBuffer Input buffer
+ @param aTarget Unpacked header.
+ @return Error.
+ */
+TInt TUsbRequestHdr::Decode(const TDesC8& aBuffer)
+
+    {
+    if (aBuffer.Length() < static_cast<TInt> (KRequestHdrSize))
+        {
+        TRACE_ERROR((_L("TUsbRequestHdr::Decode buffer invalid length %d"),aBuffer.Length()))
+        return KErrGeneral;
+        }
+
+    // Decode as SPEC 1.3.3
+    iRequestType = aBuffer[0];
+    iRequest = static_cast<TEp0Request>(aBuffer[1]);
+    iValue = static_cast<TUint16>(aBuffer[2] + (aBuffer[3] << 8));
+    iIndex = static_cast<TUint16>(aBuffer[4] + (aBuffer[5] << 8));
+    iLength = static_cast<TUint16>(aBuffer[6] + (aBuffer[7] << 8));
+    TRACE_INFO((_L("type=%d request=%d value=%d index=%d length=%d"), iRequestType,iRequest,iValue,iIndex,iLength))
+
+    return KErrNone;
+    }
+
+/**
+ This function determines whether data is required by the host in response 
+ to a message header.
+
+ @return TBool	Flag indicating whether a data response required.
+ */
+TBool TUsbRequestHdr::IsDataResponseRequired() const
+
+    {
+    return (iRequestType & 0x80) ? ETrue : EFalse;
+    }
+
+//
+/**
+ Called by CBulkOnlyTransport to create an instance of CControlInterface
+
+ @param aParent reference to the CBulkOnlyTransport
+ */
+CControlInterface* CControlInterface::NewL(CBulkOnlyTransport& aParent)
+    {
+    CControlInterface* self = new (ELeave) CControlInterface(aParent);
+    CleanupStack::PushL(self);
+    self->ConstructL();
+    CActiveScheduler::Add(self);
+    CleanupStack::Pop();
+    return self;
+    }
+
+void CControlInterface::ConstructL()
+    {
+    }
+
+/**
+ c'tor
+
+ @param aParent reference to the CBulkOnlyTransport
+ */
+CControlInterface::CControlInterface(CBulkOnlyTransport& aParent) :
+	CActive(EPriorityStandard),
+	iParent(aParent),
+	iCurrentState(ENone)
+    {
+    }
+
+/**
+ d'tor
+ */
+CControlInterface::~CControlInterface()
+    {
+    TRACE_FUNC
+	Cancel();
+    }
+
+/**
+ Called by  CBulkOnlyTransportStart to start control interface
+ */
+TInt CControlInterface::Start()
+    {
+    TRACE_FUNC
+    TInt res = ReadEp0Data();
+    return (res);
+    }
+
+/**
+ Called by CBulkOnlyTransportStart to stop control interface
+ */
+void CControlInterface::Stop()
+    {
+    TRACE_FUNC
+    // Don't need to be any thing if we're not in active state
+    if (!IsActive())
+        {
+        TRACE_INFO((_L("Not active")))
+        return;
+        }
+
+    TRACE_INFO((_L("Stopping...")))
+
+    // Stop by cancel
+    Cancel();
+    iCurrentState = ENone;
+    }
+
+/**
+ Cancel outstanding request (if any)
+ */
+void CControlInterface::DoCancel()
+    {
+    TRACE_FUNC
+    switch(iCurrentState)
+        {
+        case EReadEp0Data:
+        iParent.Ldd().ReadCancel(EEndpoint0);
+        break;
+        case ESendMaxLun:
+        iParent.Ldd().WriteCancel(EEndpoint0);
+        break;
+        default:
+        TRACE_ERROR((_L("\nWrong state !")))
+        __ASSERT_DEBUG(EFalse, User::Panic(KUsbMsSvrPncCat, EMsControlInterfaceBadState));
+        }
+    }
+
+/**
+ Implement CControlInterface state machine
+ */
+void CControlInterface::RunL()
+    {
+    TRACE_FUNC
+    if (iStatus != KErrNone)
+        {
+        TRACE_ERROR(( _L( "Error %d in RunL" ), iStatus.Int() ))
+
+        //read EP0  again 
+        ReadEp0Data();
+        return;
+        }
+
+    switch (iCurrentState)
+        {
+        case ESendMaxLun:
+            ReadEp0Data();
+            break;
+
+        case EReadEp0Data:
+            DecodeEp0Data();
+            break;
+
+        default:
+            TRACE_ERROR(( _L( "error: (Shouldn't end up here...)" ) ))
+            __ASSERT_DEBUG(EFalse, User::Panic(KUsbMsSvrPncCat, EMsControlInterfaceBadState));
+            break;
+        }
+    return;
+    }
+
+/**
+ Post a read request to EEndpoint0 to read request header
+ */
+TInt CControlInterface::ReadEp0Data()
+    {
+    TRACE_FUNC
+    if ( IsActive() )
+        {
+        TRACE_ERROR(( _L( "Still active" ) ))
+        return KErrServerBusy;
+        }
+
+    iParent.Ldd().Read(iStatus, EEndpoint0, iData, KRequestHdrSize);
+
+    iCurrentState = EReadEp0Data;
+
+    SetActive();
+    return KErrNone;
+    }
+
+/**
+ Decode request header and do appropriate action - get max LUN info or post a reset request
+ */
+void CControlInterface::DecodeEp0Data()
+    {
+    TRACE_FUNC
+    if ( IsActive() )
+        {
+        TRACE_ERROR(( _L( "Still active" ) ))
+        __ASSERT_DEBUG(EFalse, User::Panic(KUsbMsSvrPncCat, EMsControlInterfaceStillActive));
+        return;
+        }
+
+    TInt err = iRequestHeader.Decode(iData);
+
+    if (err != KErrNone)
+        {
+        TRACE_WARNING((_L("Decode header error : err=%d"), err))
+        return;
+        }
+
+    switch(iRequestHeader.iRequest)
+        {
+        // GET MAX LUN (0xFE)
+        case TUsbRequestHdr::EReqGetMaxLun:
+            {
+            TRACE_INFO((_L("DecodeEp0Data : 'Get Max LUN' Request MaxLun = %d" ),
+                            iParent.MaxLun() ))
+
+            if ( iRequestHeader.iRequestType != 0xA1 //value from USB MS BOT spec
+                    || iRequestHeader.iIndex> 15 || iRequestHeader.iValue != 0 || iRequestHeader.iLength != 1)
+                {
+                TRACE_ERROR((_L("GetMaxLun command packet check error")))
+                iParent.Ldd().EndpointZeroRequestError();
+                break;
+                }
+
+            iData.FillZ(1); //Return only 1 byte to host 
+            iData[0] = static_cast<TUint8>(iParent.MaxLun()); // Supported Units
+            iParent.Ldd().Write(iStatus, EEndpoint0, iData, 1);
+
+            iCurrentState = ESendMaxLun;
+            SetActive();
+
+            return;
+            }
+
+        // RESET (0xFF)
+        case TUsbRequestHdr::EReqReset:
+            {
+            TRACE_INFO((_L("DecodeEp0Data : 'Mass Storage Reset' Request")))
+
+            if ( iRequestHeader.iRequestType != 0x21 //value from USB MS BOT spec
+                    || iRequestHeader.iIndex> 15 || iRequestHeader.iValue != 0 || iRequestHeader.iLength != 0)
+                {
+                TRACE_ERROR((_L("MSC Reset command packet check error")))
+                iParent.Ldd().EndpointZeroRequestError();
+                break;
+                }
+
+            iParent.HwStop();
+            iParent.Controller().Reset();
+            iParent.HwStart(ETrue);
+
+            err = iParent.Ldd().SendEp0StatusPacket();
+            TRACE_INFO((_L("SendEp0StatusPacket: err=%d"), err))
+
+            return;
+            }
+        // Unknown?
+        default:
+            {
+            TRACE_ERROR((_L("DecodeEp0Data : Unknown Request")))
+            }
+        }
+    ReadEp0Data(); //try to get another request 
+    }
+
+//-------------------------------------
+/**
+ Create CBulkOnlyTransport object
+ @param aNumDrives - The number of drives available for MS
+ @param aController - reference to the parent
+ @return pointer to newly created object
+ */
+CBulkOnlyTransport* CBulkOnlyTransport::NewL(TInt aNumDrives,CMscFileController& aController)
+    {
+	CBulkOnlyTransport* self = new(ELeave) CBulkOnlyTransport(aNumDrives, aController);
+    CleanupStack::PushL(self);
+    self->ConstructL();
+    CleanupStack::Pop(self);
+    return self;
+    }
+
+/**
+ c'tor 
+ @param aNumDrives - The number of drives available for MS
+ @param aController - reference to the parent
+ */
+CBulkOnlyTransport::CBulkOnlyTransport(TInt aNumDrives,CMscFileController& aController):
+	CActive(EPriorityStandard),
+	iMaxLun(aNumDrives-1),
+	iController(aController),
+	iReadBuf(NULL,0),
+	iWriteBuf(NULL,0),
+	iStallAllowed(ETrue)
+    {
+    }
+
+/**
+ Constructs the CBulkOnlyTranspor object
+ */
+void CBulkOnlyTransport::ConstructL()
+    {
+    TRACE_FUNC
+    iControlInterface = CControlInterface::NewL(*this);
+    iDeviceStateNotifier = CActiveDeviceStateNotifier::NewL(*this);
+    CActiveScheduler::Add(this);
+    }
+
+/**
+ Destructor
+ */
+CBulkOnlyTransport::~CBulkOnlyTransport()
+    {
+    TRACE_FUNC
+    if (iInterfaceConfigured)
+        {
+        Stop();
+        }
+    delete iControlInterface;
+    delete iDeviceStateNotifier;
+    }
+
+/**
+ Set or unset configuration descriptor for USB MassStorage Bulk Only transport
+
+ @param aUnset indicate whether set or unset descriptor
+ @return KErrNone if operation was completed successfully, errorcode otherwise
+ */
+TInt CBulkOnlyTransport::SetupConfigurationDescriptor(TBool aUnset)
+    {
+    TRACE_FUNC
+    TInt ret(KErrNone);
+    TInt configDescriptorSize(0);
+
+    iLdd.GetConfigurationDescriptorSize(configDescriptorSize);
+    if (static_cast<TUint> (configDescriptorSize) != KUsbDescSize_Config)
+        {
+        return KErrCorrupt;
+        }
+
+    TBuf8<KUsbDescSize_Config> configDescriptor;
+    ret = iLdd.GetConfigurationDescriptor(configDescriptor);
+    if (ret != KErrNone)
+        {
+        return ret;
+        }
+
+    // I beleive that other fields setted up during LDD initialisation
+    if (aUnset)
+        {
+        --configDescriptor[KUsbNumInterfacesOffset];
+        }
+    else
+        {
+        ++configDescriptor[KUsbNumInterfacesOffset];
+        }
+    ret = iLdd.SetConfigurationDescriptor(configDescriptor);
+
+    return ret;
+    }
+
+/**
+ Set up interface descriptor
+
+ @return KErrNone if operation was completed successfully, errorcode otherwise
+ */
+TInt CBulkOnlyTransport::SetupInterfaceDescriptors()
+    {
+    TRACE_FUNC
+    // Device caps
+    TUsbDeviceCaps d_caps;
+    TInt ret = iLdd.DeviceCaps(d_caps);
+    if (ret != KErrNone)
+        {
+        return ret;
+        }
+    TInt totalEndpoints = d_caps().iTotalEndpoints;
+    if (totalEndpoints < KRequiredNumberOfEndpoints)
+        {
+        return KErrHardwareNotAvailable;
+        }
+
+    // Endpoint caps
+    TUsbcEndpointData data[KUsbcMaxEndpoints];
+	TPtr8 dataptr(reinterpret_cast<TUint8*>(data), sizeof(data), sizeof(data));
+    ret = iLdd.EndpointCaps(dataptr);
+    if (ret != KErrNone)
+        {
+        return ret;
+        }
+
+    // Set the active interface
+    TUsbcInterfaceInfoBuf ifc;
+    TInt ep_found = 0;
+    TBool foundBulkIN = EFalse;
+    TBool foundBulkOUT = EFalse;
+
+    for (TInt i = 0; i < totalEndpoints; i++)
+        {
+        const TUsbcEndpointCaps* caps = &data[i].iCaps;
+        const TInt maxPacketSize = caps->MaxPacketSize();
+		if (!foundBulkIN &&
+			(caps->iTypesAndDir & (KUsbEpTypeBulk | KUsbEpDirIn)) == (KUsbEpTypeBulk | KUsbEpDirIn))
+            {
+            // InEndpoint is going to be our TX (IN, write) endpoint
+            ifc().iEndpointData[0].iType = KUsbEpTypeBulk;
+            ifc().iEndpointData[0].iDir = KUsbEpDirIn;
+            ifc().iEndpointData[0].iSize = maxPacketSize;
+            ifc().iEndpointData[0].iInterval_Hs = 0;
+			ifc().iEndpointData[0].iFeatureWord1 = KUsbcEndpointInfoFeatureWord1_DMA;
+            foundBulkIN = ETrue;
+            if (++ep_found == KRequiredNumberOfEndpoints)
+                {
+                break;
+                }
+            continue;
+            }
+		if (!foundBulkOUT &&
+			(caps->iTypesAndDir & (KUsbEpTypeBulk | KUsbEpDirOut)) == (KUsbEpTypeBulk | KUsbEpDirOut))
+            {
+            // OutEndpoint is going to be our RX (OUT, read) endpoint
+            ifc().iEndpointData[1].iType = KUsbEpTypeBulk;
+            ifc().iEndpointData[1].iDir = KUsbEpDirOut;
+            ifc().iEndpointData[1].iSize = maxPacketSize;
+            ifc().iEndpointData[1].iInterval_Hs = 0;
+			ifc().iEndpointData[1].iFeatureWord1 = KUsbcEndpointInfoFeatureWord1_DMA;
+            foundBulkOUT = ETrue;
+            if (++ep_found == KRequiredNumberOfEndpoints)
+                {
+                break;
+                }
+            continue;
+            }
+        }
+    if (ep_found != KRequiredNumberOfEndpoints)
+        {
+        return KErrHardwareNotAvailable;
+        }
+    _LIT16(string, "USB Mass Storage Interface");
+    ifc().iString = const_cast<TDesC16*> (&string);
+    ifc().iTotalEndpointsUsed = KRequiredNumberOfEndpoints;
+    ifc().iClass.iClassNum = 0x08; // Mass Storage
+    ifc().iClass.iSubClassNum = 0x06; // SCSI Transparent Command Set
+    ifc().iClass.iProtocolNum = 0x50; // Bulk Only Transport
+
+	TUint bandwidth_priority = (EUsbcBandwidthOUTDefault | EUsbcBandwidthINDefault);
+    if (d_caps().iHighSpeed)
+        {
+        // If this device supports USB High-speed, then we request 64KB buffers
+        // (otherwise the default 4KB ones will do).
+        bandwidth_priority = (EUsbcBandwidthOUTPlus2 | EUsbcBandwidthINPlus2);
+        // Also, tell the Protocol about it, because it might want to do some
+        // optimizing too.
+        iProtocol->ReportHighSpeedDevice();
+        }
+    ret = iLdd.SetInterface(0, ifc, bandwidth_priority);
+    return ret;
+    }
+
+/**
+ Called by the protocol after processing the packet to indicate that more data is required.  
+
+ @param aData reference to the data buffer. 
+ */
+void CBulkOnlyTransport::SetupReadData(TPtr8& aData)
+    {
+    TRACE_FUNC
+    TRACE_INFO((_L("Length = %d  (bytes)"), aData.Length()))
+    iReadBuf.Set(aData);
+    iReadSetUp = ETrue;
+    }
+
+/**
+ Called by the protocol after processing the packet to indicate that data should be written to the host.  
+
+ @param aData reference to the data buffer. 
+ */
+void CBulkOnlyTransport::SetupWriteData(TPtrC8& aData)
+    {
+    TRACE_FUNC
+    TRACE_INFO((_L("Length = %d  (bytes)"), aData.Length()))
+    iWriteBuf.Set(aData);
+    iWriteSetUp = ETrue;
+    }
+
+TInt CBulkOnlyTransport::Start()
+    {
+    TRACE_FUNC_ENTRY
+
+    TInt err = KErrNone;
+
+    if (!iProtocol)
+        {
+        return KErrBadHandle; //protocol should be set up before start
+        }
+
+    if (IsActive())
+        {
+        TRACE_ERROR((_L("Active before start!")))
+        return KErrInUse;
+        }
+
+    if ((err = iLdd.Open(0)) != KErrNone )
+        {
+        TRACE_ERROR((_L("Error during open ldd!")))
+        return err;
+        }
+
+    if ((err = SetupConfigurationDescriptor()) != KErrNone ||
+            (err = SetupInterfaceDescriptors()) != KErrNone )
+        {
+        iLdd.Close();
+        TRACE_ERROR((_L("Error during descriptors setup!")))
+        return err;
+        }
+
+    iDeviceStateNotifier->Activate(); // activate notifier wich will wait until USB became configured
+    TUsbcDeviceState deviceStatus = EUsbcDeviceStateDefault;
+    err = iLdd.DeviceStatus(deviceStatus);
+    TRACE_INFO((_L("Device status = %d"), deviceStatus))
+    if (err == KErrNone && deviceStatus == EUsbcDeviceStateConfigured)
+        {
+        TRACE_INFO(_L("Starting bulk only transport\n"));
+        err = HwStart();
+        }
+    iInterfaceConfigured = ETrue;
+    TRACE_FUNC_EXIT
+    return err;
+    }
+
+TInt CBulkOnlyTransport::HwStart(TBool aDiscard)
+    {
+    TRACE_FUNC_ENTRY
+
+    TInt res = iControlInterface->Start();
+
+    iCurrentState = ENone;
+    iWriteSetUp = EFalse;
+    iReadSetUp = EFalse;
+    iStarted = ETrue;
+
+    if (aDiscard)
+        {
+        TInt bytes;
+        const TInt err = iLdd.QueryReceiveBuffer(OutEndpoint, bytes);
+        if (err != KErrNone || bytes <= 0)
+            {
+            TRACE_ERROR((_L("Error: err=%d bytes=%d"), bytes))
+            }
+        else
+            {
+            TRACE_ERROR((_L("RxBuffer has %d bytes"), bytes))
+            ReadAndDiscardData(bytes);
+            }
+        }
+
+    ReadCBW();
+    TRACE_FUNC_EXIT
+    return res;
+    }
+
+TInt CBulkOnlyTransport::HwStop()
+    {
+    TRACE_FUNC
+
+    if (iStarted)
+        {
+        Cancel();
+        iControlInterface->Cancel();
+        iProtocol->Cancel();
+        iStarted = EFalse;
+        }
+    return KErrNone;
+    }
+
+TInt CBulkOnlyTransport::HwSuspend()
+    {
+    TRACE_FUNC
+    return KErrNone;
+    }
+
+TInt CBulkOnlyTransport::HwResume()
+    {
+    TRACE_FUNC
+    return KErrNone;
+    }
+
+/**
+ Stops the Bulk Only Transport
+ */
+TInt CBulkOnlyTransport::Stop()
+    {
+    TRACE_FUNC
+    iControlInterface->Cancel();
+    iDeviceStateNotifier->Cancel();
+    Cancel();
+    if (iInterfaceConfigured)
+        {
+        iLdd.ReleaseInterface(0);
+        SetupConfigurationDescriptor(ETrue);
+        iLdd.Close();
+        }
+    iCurrentState = ENone;
+    iInterfaceConfigured = EFalse;
+
+    return KErrNone;
+    }
+
+/**
+ Read aLength bytes of data from the host into the read buffer.
+ @param aLength The number of bytes to read from the host.
+ */
+void CBulkOnlyTransport::ReadCBW()
+    {
+    TRACE_FUNC
+    if (IsActive())
+        {
+        TRACE_ERROR(( _L( "Still active" ) ))
+        __ASSERT_DEBUG(EFalse, User::Panic(KUsbMsSvrPncCat, EMsBulkOnlyStillActive));
+        return;
+        }
+
+    iCbwBuf.SetMax();
+    iLdd.ReadUntilShort(iStatus, OutEndpoint, iCbwBuf, iCbwBuf.Length());
+
+    iCurrentState = EWaitForCBW;
+    SetActive();
+    }
+
+void CBulkOnlyTransport::DoCancel()
+    {
+    TRACE_FUNC
+    iLdd.WriteCancel(InEndpoint);
+    iLdd.ReadCancel(OutEndpoint);
+    }
+
+void CBulkOnlyTransport::Activate(TInt aReason)
+    {
+    SetActive();
+    TRequestStatus* r = &iStatus;
+    User::RequestComplete(r, aReason);
+    }
+
+void CBulkOnlyTransport::RunL()
+    {
+    TRACE_FUNC
+    if (iStatus != KErrNone)
+        {
+        TRACE_ERROR((_L("Error %d in RunL, halt endpoints \n"), iStatus.Int()))
+        SetPermError(); //halt endpoints for reset recovery
+        return;
+        }
+
+    switch (iCurrentState)
+        {
+        case EWaitForCBW:
+            TRACE_INFO((_L("EWaitForCBW")))
+            DecodeCBW();
+            break;
+
+        case EWritingData:
+            TRACE_INFO((_L("EWritingData")))
+            iWriteSetUp = EFalse; //the buffer was used
+
+            if (iDataResidue && iStallAllowed)
+                {
+                StallEndpointAndWaitForClear(InEndpoint);
+                }
+
+            SendCSW(iCbwTag, iDataResidue, iCmdStatus);
+            break;
+
+        case EReadingData:
+            {
+            TRACE_INFO((_L("EReadingData")))
+
+            TInt ret = KErrNone;
+            FOREVER
+                {
+                if (iReadSetUp)
+                    {
+                    ret = iProtocol->ReadComplete(KErrNone);
+                    }
+
+                TUint deviceDataLength = static_cast<TUint>(iReadBuf.Length());
+                if(ret == KErrCompletion)
+                    {
+                    // The protocol has indicated with KErrCompletion that sufficient
+                    // data is available in the buffer to process the transfer immediately.
+                    iDataResidue -= deviceDataLength;
+                    iLdd.Read(iStatus, OutEndpoint, iReadBuf, deviceDataLength);
+                    User::WaitForRequest(iStatus);
+                    if (iStatus != KErrNone)
+                        {
+                        // An error occurred - halt endpoints for reset recovery
+                        TRACE_ERROR((_L("Error %d in EReadingData, halt endpoints"),
+                                        iStatus.Int()))
+                        SetPermError();
+                        return;
+                        }
+                    }
+                else if(ret == KErrNotReady)
+                    {
+                    // The protocol has indicated with KErrNotReady that insufficient
+                    // data is available in the buffer, so should wait for it to arrive
+                    ReadData(deviceDataLength);
+                    break;
+                    }
+                else
+                    {
+                    // The protocol has indicated that transfer is 
+                    // complete, so send the CSW response to the host.
+                    iReadSetUp = EFalse;
+
+                    if (ret != KErrNone)
+                        {
+                        iCmdStatus = ECommandFailed;
+                        }
+
+                    if (iDataResidue)
+                        {
+                        TRACE_INFO((_L("Discarding residue")))
+                        // we have to read as much data as available that host PC sends;
+                        // otherwise, bulk-out endpoint will need to keep sending NAK back.
+                        ReadAndDiscardData(iDataResidue);
+                        }
+                    SendCSW(iCbwTag, iDataResidue, iCmdStatus);
+                    break;
+                    }
+                }
+            }
+        break;
+
+        case ESendingCSW:
+        TRACE_INFO((_L("ESendingCSW")))
+        ReadCBW();
+        break;
+
+        case EPermErr:
+        TRACE_INFO((_L("EPermErr")))
+        StallEndpointAndWaitForClear(InEndpoint);
+        break;
+
+        default:
+        SetPermError(); // unexpected state
+        }
+    }
+
+/**
+ Prepare incase we need to read data from host
+ Called in DecodeCBW(...)
+ @param aHostDataLength The number of bytes to read from the host.
+ */
+void CBulkOnlyTransport::PrepareReadFromHost(TUint aHostDataLength)
+    {
+    if (!iReadSetUp)
+        {
+			iDataResidue =aHostDataLength;
+			TRACE_INFO((_L("Read buffer was not setup\n")))
+            //Use next block instead of StallEndpointAndWaitForClear(OutEndpoint); 
+            {
+            iBuf.SetLength(KBOTMaxBufSize);
+            TUint c =0;
+            TRequestStatus status;
+            while (c<aHostDataLength)
+                {
+                TInt len;
+                if (aHostDataLength - c> KBOTMaxBufSize)
+                    {
+                    len = KBOTMaxBufSize;
+                    }
+                else
+                    {
+                    len = aHostDataLength - c;
+                    }
+
+                iLdd.Read(status, OutEndpoint, iBuf, len);
+                User::WaitForRequest(status);
+                c += KBOTMaxBufSize;
+                }
+            }
+
+        if (iWriteSetUp) //case (10)
+            {
+            TRACE_INFO((_L("case 10\n")))
+            SendCSW(iCbwTag, aHostDataLength, EPhaseError);
+            }
+        else // case (9)
+
+            {
+            TRACE_INFO((_L("Case 9\n")))
+            SendCSW(iCbwTag, aHostDataLength, iCmdStatus);
+            }
+
+        return;
+        }
+    else
+        {
+        TUint deviceDataLength = static_cast<TUint>(iReadBuf.Length());
+        iDataResidue =aHostDataLength - deviceDataLength;
+        TRACE_INFO((_L("deviceDataLength=%d, DataResidue (read from host) =%d\n"),
+                        deviceDataLength,iDataResidue))
+
+        if (deviceDataLength <= aHostDataLength) // case (11) and (12)
+
+            {
+            TRACE_INFO((_L("Case 11 or 12\n")))
+            ReadData(deviceDataLength);
+            return;
+            }
+
+        if (deviceDataLength> aHostDataLength) // case  (13)
+
+            {
+            TRACE_INFO((_L("Case 13\n")))
+            /**
+             * Comment following line in order to pass compliant test.
+             * As spec said in case 13:"The device may receive data up to a
+             * total of dCBWDataTransferLength."
+             * Here we choose to ignore incoming data.
+             */
+            //StallEndpointAndWaitForClear(OutEndpoint); //Stall Out endpoint
+            if (iReadSetUp)
+                {
+                iLdd.Read(iStatus, OutEndpoint, iReadBuf, aHostDataLength);
+                User::WaitForRequest(iStatus);
+                iProtocol->ReadComplete(KErrGeneral);
+                iReadSetUp = EFalse;
+                }
+            SendCSW(iCbwTag, aHostDataLength, EPhaseError);
+            return;
+            }
+        }
+    }
+
+/**
+ Prepare incase we need to read data from host
+ Called in DecodeCBW(...)
+ @param aHostDataLength The number of bytes to write to the host.
+ */
+void CBulkOnlyTransport::PrepareWriteToHost(TUint aHostDataLength)
+    {
+    if (!iWriteSetUp) //write buffer was not set up 
+        {
+        TRACE_INFO((_L("Write buffer was not setup")))
+        iDataResidue =aHostDataLength;
+        TRACE_INFO((_L("DataResidue (write to host)=%d"),iDataResidue))
+
+        //------------------------------------
+        if (aHostDataLength <= KBOTMaxBufSize)
+            {
+            TRACE_INFO((_L("Case 4 or 8\n")))
+            iBuf.FillZ(aHostDataLength);
+            iLdd.Write(iStatus, InEndpoint, iBuf, aHostDataLength);
+            SetActive();
+            iCurrentState = EWritingData;
+            iStallAllowed = EFalse;
+            if (iReadSetUp) //read buffer WAS set up - case (8)
+
+                {
+                TRACE_INFO((_L("It is Case 8")))
+                iCmdStatus = EPhaseError;
+                }
+            return;
+            }
+        else
+        //------------------------------------
+        //					Use next block instead of StallEndpointAndWaitForClear(InEndpoint);
+
+            {
+            iBuf.FillZ(KBOTMaxBufSize);
+            TUint c =0;
+            TRequestStatus status;
+            while (c<aHostDataLength)
+                {
+                TInt len;
+                if (aHostDataLength - c> KBOTMaxBufSize)
+                    {
+                    len = KBOTMaxBufSize;
+                    }
+                else
+                    {
+                    len = aHostDataLength - c;
+                    }
+
+                iLdd.Write(status, InEndpoint, iBuf, len);
+                User::WaitForRequest(status);
+                c += KBOTMaxBufSize;
+                }
+            }
+
+        if (iReadSetUp) //read buffer WAS set up - case (8)
+            {
+            TRACE_INFO(_L("Case 8"));
+            SendCSW(iCbwTag, aHostDataLength, EPhaseError);
+            //don't care to reset any flag - should get reset recovery
+            }
+        else // case (4)
+            {
+            TRACE_INFO((_L("Case 4")))
+            SendCSW(iCbwTag, aHostDataLength, iCmdStatus);
+            }
+        return;
+        }
+    else
+        {
+        //================== 
+        TUint deviceDataLength = static_cast<TUint>(iWriteBuf.Length());
+        iDataResidue =aHostDataLength - deviceDataLength;
+        TRACE_INFO((_L("Device data length = %d, DataResidue (write to host)=%d"),
+                        deviceDataLength, iDataResidue))
+
+        if (deviceDataLength < aHostDataLength &&
+                aHostDataLength < KBOTMaxBufSize )
+            {
+            TRACE_INFO((_L("Case 5 (padding)\n")))
+            iBuf.Zero();
+            iBuf.Append(iWriteBuf);
+            iBuf.SetLength(aHostDataLength);
+            iStallAllowed = EFalse;
+            TRACE_INFO((_L("iBuf.Length=%d\n"),iBuf.Length()))
+            iLdd.Write(iStatus, InEndpoint, iBuf, aHostDataLength);
+            SetActive();
+            iCurrentState = EWritingData;
+            return;
+            }
+
+        //===================
+
+        if (deviceDataLength == aHostDataLength) //case (6)[==]
+
+            {
+            TRACE_INFO((_L("Case 6\n")))
+            WriteData(deviceDataLength);
+            return;
+            }
+        else if (deviceDataLength < aHostDataLength) //case (5)[<]
+
+            {
+            TRACE_INFO((_L("Case 5\n")))
+            WriteData(deviceDataLength, ETrue); // Send ZLP
+            return;
+            }
+        else // deviceDataLength > aHostDataLength - case (7)
+
+            {
+            TRACE_INFO((_L("Case 7\n")))
+            iCmdStatus = EPhaseError;
+            iDataResidue = 0;
+            WriteData(aHostDataLength);
+            return;
+            }
+        }
+    }
+
+/**
+ Decode the CBW received from the host via OutEndpoint
+
+ - If the header is valid, the data content is passed to the parser.
+ - Depending on the command, more data may be transmitted/received.
+ - ...or the CSW is sent (if not a data command).
+
+ */
+void CBulkOnlyTransport::DecodeCBW()
+    {
+    TRACE_FUNC
+    if (!CheckCBW()) //check if CBW valid and meaningful
+
+        {
+        // CBW not valid or meaningful
+        // Specification says: "If the CBW is not valid, the device shall STALL
+        // the Bulk-In pipe. Also, the device shall either STALL the Bulk-Out pipe,
+        // or the device shall accept and discard any Bulk-Out data. The device
+        // shall maintain this state until a Reset Recovery."
+        // Here we keep bulk-in ep stalled and ignore bulk-out ep.
+        SetPermError();
+        return;
+        }
+
+    TPtrC8 aData;
+    aData.Set(&iCbwBuf[KCbwCbLengthOffset], KMaxCbwcbLength + 1); //prepare data for protocol starting form Length 
+    TUint8 lun = static_cast<TUint8> (iCbwBuf[13] & 0x0f);
+
+	iCbwTag  =	static_cast<TUint32>(iCbwBuf[KCbwTagOffset])		| 
+				static_cast<TUint32>(iCbwBuf[KCbwTagOffset+1])	<<8 | 
+				static_cast<TUint32>(iCbwBuf[KCbwTagOffset+2])	<<16| 
+				static_cast<TUint32>(iCbwBuf[KCbwTagOffset+3])	<<24;
+
+    TInt i = KCbwDataTransferLengthOffset;
+	TUint hostDataLength = 	static_cast<TUint32>(iCbwBuf[i  ])		| 
+							static_cast<TUint32>(iCbwBuf[i+1]) <<8 	| 
+							static_cast<TUint32>(iCbwBuf[i+2]) <<16	| 
+							static_cast<TUint32>(iCbwBuf[i+3]) <<24;
+
+    TBool dataToHost = iCbwBuf[KCbwFlagOffset] & 0x80;
+
+    TRACE_INFO((_L("lun =%d, hostDataLength=%d, CBWtag = 0x%X\n, dataToHost=%d"),
+                    lun, hostDataLength, iCbwTag, dataToHost))
+    //
+    TBool ret = iProtocol->DecodePacket(aData, lun);
+    //
+
+    iStallAllowed = ETrue;
+
+    if (!ret)
+        {
+        TRACE_INFO((_L("Command Failed")))
+        iCmdStatus = ECommandFailed;
+        }
+    else
+        {
+        TRACE_INFO((_L("Command Passed")))
+        iCmdStatus = ECommandPassed;
+        }
+
+    if (hostDataLength == 0)
+        {
+        TRACE_INFO((_L("No data transfer expected\n")))
+        iDataResidue = 0;
+        if (iWriteSetUp || iReadSetUp) // case (2) and (3)
+
+            {
+            TRACE_INFO((_L("Case 2 or 3\n")))
+            SendCSW(iCbwTag, 0, EPhaseError);
+            }
+        else
+            {
+            TRACE_INFO((_L("Case 1\n")))
+            SendCSW(iCbwTag, 0, iCmdStatus); //case (1)
+            }
+
+        return;
+        }
+    else
+        {
+        // Data Direction, To or From Host
+        if (dataToHost)
+            {
+            PrepareWriteToHost(hostDataLength);
+            }
+        else
+            {
+            PrepareReadFromHost(hostDataLength);
+            }
+        }
+    }
+
+/**
+ Check if CBW Valid and Meaningful.  
+
+ @return ETrue if CBW is Valid and Meaningful, EFalse otherwise
+ */
+TBool CBulkOnlyTransport::CheckCBW()
+    {
+    TRACE_FUNC
+
+    // Check valid
+
+    // Check length
+    if (iCbwBuf.Length() != KCbwLength)
+        {
+        TRACE_INFO((_L("Bad length: %d"), iCbwBuf.Length()))
+        return EFalse;
+        }
+
+    // Check signature
+    TInt i = KCbwSignatureOffset;
+	if (iCbwBuf[i  ] != 0x55 ||         // CBW Singature from USB Bulk-Only Transport spec
+		iCbwBuf[i+1] != 0x53 ||
+		iCbwBuf[i+2] != 0x42 ||
+		iCbwBuf[i+3] != 0x43)
+        {
+        TRACE_INFO((_L("Bad signature")))
+        TRACE_INFO((_L(" 0x%x, 0x%x, 0x%x, 0x%x"),
+                        iCbwBuf[i], iCbwBuf[i+1], iCbwBuf[i+2],iCbwBuf[i+3]))
+        return EFalse;
+        }
+
+    // Check meaningful
+
+    // Check reserved bits ( must be zero )
+    if ((iCbwBuf[KCbwLunOffset] & 0xF0) || (iCbwBuf[KCbwCbLengthOffset] & 0xE0))
+        {
+        TRACE_INFO((_L("Reserved bits not zero\n")))
+        return EFalse;
+        }
+
+    // check command block length
+    TInt cbwcbLength = iCbwBuf[KCbwCbLengthOffset] & 0x1F;
+    if (cbwcbLength>KMaxCbwcbLength)
+        {
+        TRACE_INFO((_L("Incorrect block length\n")))
+        return EFalse;
+        }
+
+    //check LUN
+    TInt8 lun = static_cast<TUint8>(iCbwBuf[KCbwLunOffset] & 0x0f);
+    if (iMaxLun < lun)
+        {
+        TRACE_INFO((_L("bad lun: %d"), lun))
+        return EFalse;
+        }
+
+    return ETrue;
+    }
+
+/**
+ Initiate stalling of bulk IN endpoint.
+ Used when protocol wants to force host to initiate a reset recovery.
+ */
+void CBulkOnlyTransport::SetPermError()
+    {
+    TRACE_FUNC
+    iCurrentState = EPermErr;
+    Activate(KErrNone);
+    }
+
+/**
+ Send data provided by protocol to the host
+
+ @param aLength amount of data (in bytes) to be send to host
+ */
+void CBulkOnlyTransport::WriteData(TUint aLength, TBool aZlpRequired)
+    {
+    TRACE_FUNC
+
+    if (IsActive())
+        {
+        TRACE_INFO((_L("Still active")))
+        __ASSERT_DEBUG(EFalse, User::Panic(KUsbMsSvrPncCat, EMsBulkOnlyStillActive));
+        return;
+        }
+    iLdd.Write(iStatus, InEndpoint, iWriteBuf, aLength, aZlpRequired);
+    iCurrentState = EWritingData;
+    SetActive();
+    }
+
+/**
+ Request data form the host for the protocol
+
+ @param aLength amount of data (in bytes) to be received from the host
+ */
+void CBulkOnlyTransport::ReadData(TUint aLength)
+    {
+    TRACE_FUNC
+    if (IsActive())
+        {
+        TRACE_INFO((_L("Still active")))
+        __ASSERT_DEBUG(EFalse, User::Panic(KUsbMsSvrPncCat, EMsBulkOnlyStillActive));
+        return;
+        }
+    iLdd.Read(iStatus, OutEndpoint, iReadBuf, aLength);
+    SetActive();
+    iCurrentState = EReadingData;
+    }
+
+/**
+ Send Command Status Wrapper to the host
+
+ @param aTag Echo of Command Block Tag sent by the host.
+ @param aDataResidue the difference between the amount of data expected by the
+ host, and the actual amount of data processed by the device.
+ @param aStatus indicates the success or failure of the command.
+ */
+void CBulkOnlyTransport::SendCSW(TUint aTag, TUint aDataResidue, TCswStatus aStatus)
+    {
+    TRACE_FUNC
+    TRACE_INFO((_L("DataResidue = %d, Status = %d \n"), aDataResidue, aStatus))
+
+    if (IsActive())
+        {
+        TRACE_INFO((_L("Still active")))
+        __ASSERT_DEBUG(EFalse, User::Panic(KUsbMsSvrPncCat, EMsBulkOnlyStillActive));
+        return;
+        }
+    TBuf8<KCswLength> csw(KCswLength);
+
+    TInt i = KCswSingnatureOffset;
+    csw[i] = 0x55; // CSW Singature from USB Bulk-Only Transport spec
+    csw[i + 1] = 0x53;
+    csw[i + 2] = 0x42;
+    csw[i + 3] = 0x53;
+
+    i = KCswTagOffset;
+
+    csw[i] = static_cast<TUint8> ((aTag & 0x000000FF));
+    csw[i + 1] = static_cast<TUint8> ((aTag & 0x0000FF00) >> 8);
+    csw[i + 2] = static_cast<TUint8> ((aTag & 0x00FF0000) >> 16);
+    csw[i + 3] = static_cast<TUint8> ((aTag & 0xFF000000) >> 24);
+
+    i = KCswDataResidueOffset;
+    csw[i] = static_cast<TUint8> ((aDataResidue & 0x000000FF));
+    csw[i + 1] = static_cast<TUint8> ((aDataResidue & 0x0000FF00) >> 8);
+    csw[i + 2] = static_cast<TUint8> ((aDataResidue & 0x00FF0000) >> 16);
+    csw[i + 3] = static_cast<TUint8> ((aDataResidue & 0xFF000000) >> 24);
+
+    csw[KCswStatusOffset] = static_cast<TUint8> (aStatus);
+
+    iLdd.Write(iStatus, InEndpoint, csw, KCswLength);
+
+    iCurrentState = ESendingCSW;
+
+    SetActive();
+    }
+
+/**
+ Associates the transport with the protocol.  Called during initialization of the controller.
+
+ @param aProtocol reference to the protocol
+ */
+void CBulkOnlyTransport::RegisterProtocol(MProtocolBase& aProtocol)
+    {
+    TRACE_FUNC
+    iProtocol = &aProtocol;
+    }
+
+/**
+ Used by CControlInterface
+
+ @return reference to the controller which instantiate the CBulkOnlyTransport
+ */
+CMscFileController& CBulkOnlyTransport::Controller()
+    {
+    return iController;
+    }
+
+/**
+ @return the number of logical units supported by the device. 
+ Logical Unit Numbers on the device shall be numbered contiguously starting from LUN
+ 0 to a maximum LUN of 15 (Fh).
+ */
+TInt CBulkOnlyTransport::MaxLun()
+    {
+    return iMaxLun;
+    }
+
+/**
+ Used by CControlInterface
+ @return reference to USB logical driver
+ */
+RDevUsbcClient& CBulkOnlyTransport::Ldd()
+    {
+    return iLdd;
+    }
+
+
+void CBulkOnlyTransport::StallEndpointAndWaitForClear(TEndpointNumber aEndpoint)
+    {
+    TRACE_FUNC
+    __ASSERT_DEBUG(aEndpoint != EEndpoint0, User::Panic(KUsbMsSvrPncCat, EMsWrongEndpoint));
+
+    // Now stall this endpoint
+    TRACE_INFO((_L("Stalling endpoint %d"), aEndpoint))
+    TInt r = iLdd.HaltEndpoint(aEndpoint);
+    if (r != KErrNone)
+        {
+        TRACE_ERROR((_L("Error: stalling ep %d failed: %d"), aEndpoint, r))
+        }
+    TEndpointState ep_state;
+    TInt i = 0;
+    do
+        {
+        // Wait for 10ms before checking the ep status
+        User::After(10000);
+        iLdd.EndpointStatus(aEndpoint, ep_state);
+        if (++i >= 1000)
+            {
+            // 10 secs should be enough
+            TRACE_ERROR((_L("Error: Checked for ep %d de-stall %d seconds - giving up now..."),
+                            aEndpoint, i / 100))
+            // We can only hope for a Reset Recovery
+            return;
+            }
+        }while ((ep_state == EEndpointStateStalled) && iStarted);
+    TRACE_INFO((_L("Checked for ep %d de-stall: %d time(s)"), aEndpoint, i))
+    }
+
+/**
+ * Read out rest data from OutEndpoint and discard them
+ */
+void CBulkOnlyTransport::ReadAndDiscardData(TInt aBytes)
+    {
+    TRACE_FUNC
+    const TUint bufsize = static_cast<TUint>(iReadBuf.Length());
+    __ASSERT_ALWAYS(bufsize> 0, User::Panic(_L("Buffer size is zero"), bufsize));
+    TRequestStatus status;
+    while (aBytes> 0)
+        {
+        TRACE_INFO((_L("Bytes still to be read: %d\n"), aBytes))
+        iLdd.ReadOneOrMore(status, OutEndpoint, iReadBuf, bufsize);
+        User::WaitForRequest(status);
+        TInt err = status.Int();
+        if (err != KErrNone)
+            {
+            // Bad.
+            break;
+            }
+        aBytes -= iReadBuf.Length();
+        }
+    iReadBuf.SetLength(bufsize);
+    }
+
+/**
+ Called by the protocol to determine how many bytes of data are available in the read buffer. 
+
+ @return The number of bytes available in the read buffer
+ */
+TInt CBulkOnlyTransport::BytesAvailable()
+    {
+    TInt bytes = 0;
+    TInt err = iLdd.QueryReceiveBuffer(OutEndpoint, bytes);
+    if (err != KErrNone)
+        bytes = 0;
+    return bytes;
+    }
+
+//
+// --- class CActiveDeviceStateNotifier ---------------------------------------------------------
+//
+CActiveDeviceStateNotifier::CActiveDeviceStateNotifier(CBulkOnlyTransport& aParent)
+/**
+ *
+ */
+	: CActive(EPriorityStandard),
+	  iParent(aParent),
+	  iDeviceState(EUsbcNoState),
+            iOldDeviceState(EUsbcNoState)
+    {
+
+    }
+
+
+CActiveDeviceStateNotifier* CActiveDeviceStateNotifier::NewL(CBulkOnlyTransport& aParent)
+/**
+ *
+ */
+    {
+	CActiveDeviceStateNotifier* self = new (ELeave) CActiveDeviceStateNotifier(aParent);
+    CleanupStack::PushL(self);
+    self->ConstructL();
+    CActiveScheduler::Add(self);
+    CleanupStack::Pop(); // self
+    return (self);
+    }
+
+void CActiveDeviceStateNotifier::ConstructL()
+/**
+ *
+ */
+    {
+    TRACE_FUNC
+	}
+
+CActiveDeviceStateNotifier::~CActiveDeviceStateNotifier()
+/**
+ *
+ */
+    {
+    TRACE_FUNC
+    Cancel();												// base class
+    }
+
+void CActiveDeviceStateNotifier::DoCancel()
+/**
+ *
+ */
+    {
+    TRACE_FUNC
+    iParent.Ldd().AlternateDeviceStatusNotifyCancel();
+    }
+
+void CActiveDeviceStateNotifier::RunL()
+/**
+ *
+ */
+    {
+    TRACE_FUNC
+    // This displays the device state.
+    // In a real world program, the user could take here appropriate action (cancel a
+    // transfer request or whatever).
+    if (!(iDeviceState & KUsbAlternateSetting))
+        {
+
+        switch (iDeviceState)
+            {
+            case EUsbcDeviceStateUndefined:
+            TRACE_INFO((_L("Device State notifier: Undefined\n")))
+            iParent.HwStop();
+            break;
+            case EUsbcDeviceStateAttached:
+            TRACE_INFO((_L("Device State notifier: Attached\n")))
+            iParent.HwStop();
+            break;
+            case EUsbcDeviceStatePowered:
+            TRACE_INFO((_L("Device State notifier: Powered\n")))
+            iParent.HwStop();
+            break;
+            case EUsbcDeviceStateDefault:
+            TRACE_INFO((_L("Device State notifier: Default\n")))
+            iParent.HwStop();
+            break;
+            case EUsbcDeviceStateAddress:
+            TRACE_INFO((_L("Device State notifier: Address\n")))
+            iParent.HwStop();
+            break;
+            case EUsbcDeviceStateConfigured:
+            TRACE_INFO((_L("Device State notifier: Configured\n")))
+            if (iOldDeviceState == EUsbcDeviceStateSuspended)
+                {
+                iParent.HwResume();
+                }
+            else
+                {
+                iParent.HwStart();
+                }
+            break;
+            case EUsbcDeviceStateSuspended:
+            TRACE_INFO((_L("Device State notifier: Suspended\n")))
+            if (iOldDeviceState == EUsbcDeviceStateConfigured)
+                {
+                iParent.HwSuspend();
+                }
+            break;
+            default:
+            TRACE_INFO((_L("Device State notifier: ***BAD***\n")))
+            iParent.HwStop();
+            break;
+            }
+        iOldDeviceState = iDeviceState;
+        }
+    else if (iDeviceState & KUsbAlternateSetting)
+        {
+        TRACE_INFO((_L("Device State notifier: Alternate interface setting has changed: now %d\n"),
+                        iDeviceState & ~KUsbAlternateSetting))
+        }
+    Activate();
+    }
+
+void CActiveDeviceStateNotifier::Activate()
+/**
+ *
+ */
+    {
+    TRACE_FUNC
+    if (IsActive())
+        {
+        TRACE_INFO((_L("Still active")))
+        return;
+        }
+    iParent.Ldd().AlternateDeviceStatusNotify(iStatus, iDeviceState);
+    SetActive();
+    }
+