diff -r 000000000000 -r 63b37f68c1ce connectivitylayer/usbphonetlink/usbpnserver_exe/src/cusbpninterface.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/connectivitylayer/usbphonetlink/usbpnserver_exe/src/cusbpninterface.cpp	Fri Nov 06 17:28:23 2009 +0000
@@ -0,0 +1,566 @@
+/*
+* 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 the License "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+*
+*/
+
+// INCLUDE FILES
+#include "cusbpninterface.h"
+#include "cusbpnalt.h"
+#include "cusbpnpacket.h"
+#include "cusbpnisareceiver.h"
+#include "cusbpnusbreceiver.h"
+#include "musbpncontrolobserver.h"
+#include "usbpndefinitions.h"       // For constants
+#include "usbpntrace.h"
+
+#include "osttracedefinitions.h"
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "cusbpninterfaceTraces.h"
+#endif
+
+#include <d32usbc.h>                // For RDevUsbcClient
+#include <iscapi.h>                 // For RIscApi
+#include <iscnokiadefinitions.h>    // For Channel ID
+
+// EXTERNAL DATA STRUCTURES
+// EXTERNAL FUNCTION PROTOTYPES
+// CONSTANTS
+// MACROS
+// LOCAL CONSTANTS AND MACROS
+// MODULE DATA STRUCTURES
+// LOCAL FUNCTION PROTOTYPES
+// FORWARD DECLARATIONS
+
+// ============================= LOCAL FUNCTIONS ===============================
+// ============================ MEMBER FUNCTIONS ===============================
+
+// -----------------------------------------------------------------------------
+// CUsbPnInterface::CUsbPnInterface
+// C++ default constructor can NOT contain any code, that
+// might leave.
+// -----------------------------------------------------------------------------
+//
+CUsbPnInterface::CUsbPnInterface()
+    {
+    OstTrace0( TRACE_NORMAL, CUSBPNINTERFACE_CUSBPNINTERFACE_ENTRY, "CUsbPnInterface::CUsbPnInterface" );
+    OstTrace0( TRACE_NORMAL, CUSBPNINTERFACE_CUSBPNINTERFACE_EXIT, "CUsbPnInterface::CUsbPnInterface - return" );
+    C_TRACE( ( _T( "CUsbPnInterface::CUsbPnInterface()" ) ) );
+    C_TRACE( ( _T( "CUsbPnInterface::CUsbPnInterface() - return" ) ) );
+    }
+
+// -----------------------------------------------------------------------------
+// CUsbPnInterface::ConstructL
+// Symbian 2nd phase constructor can leave.
+// -----------------------------------------------------------------------------
+//
+void CUsbPnInterface::ConstructL()
+    {
+    OstTrace0( TRACE_NORMAL, CUSBPNINTERFACE_CONSTRUCTL_ENTRY, "CUsbPnInterface::ConstructL" );
+    C_TRACE( ( _T( "CUsbPnInterface::ConstructL()" ) ) );
+
+    iAlt = CUsbPnAlt::NewL( *this, iPnDataLdd, iIscApi );
+    iIsaReceiver = CUsbPnIsaReceiver::NewL( iIscApi, iPnDataLdd );
+    iUsbReceiver = CUsbPnUsbReceiver::NewL( iPnDataLdd, iIscApi );
+
+    // Open ISC Channel
+    TRequestStatus openStatus;
+    iIscApi.Open( EIscNokiaUsbPhonetLink, openStatus );
+    User::WaitForRequest( openStatus );
+    User::LeaveIfError( openStatus.Int() );
+
+    // Start ISA receiver without forward
+    iIsaReceiver->Receive( EFalse );
+
+    InitialiseInterfaceL();
+
+    OstTrace0( TRACE_NORMAL, CUSBPNINTERFACE_CONSTRUCTL_EXIT, "CUsbPnInterface::ConstructL - return void" );
+    C_TRACE( ( _T( "CUsbPnInterface::ConstructL() - return void" ) ) );
+    }
+
+// -----------------------------------------------------------------------------
+// CUsbPnInterface::NewL
+// Two-phased constructor.
+// -----------------------------------------------------------------------------
+//
+CUsbPnInterface* CUsbPnInterface::NewL()
+    {
+    OstTrace0( TRACE_NORMAL, CUSBPNINTERFACE_NEWL_ENTRY, "CUsbPnInterface::NewL" );
+    C_TRACE( ( _T( "CUsbPnInterface::NewL()" ) ) );
+
+    CUsbPnInterface* self = new( ELeave ) CUsbPnInterface();
+
+    CleanupStack::PushL( self );
+    self->ConstructL();
+    CleanupStack::Pop( self );
+
+    OstTrace1( TRACE_NORMAL, CUSBPNINTERFACE_NEWL_EXIT, "CUsbPnInterface::NewL - return;self=%x", self );
+    C_TRACE( ( _T( "CUsbPnInterface::NewL() - return 0x%x" ), self ) );
+    return self;
+    }
+
+// -----------------------------------------------------------------------------
+// CUsbPnInterface::~CUsbPnInterface
+// Two-phased constructor.
+// -----------------------------------------------------------------------------
+//
+CUsbPnInterface::~CUsbPnInterface()
+    {
+    OstTrace0( TRACE_NORMAL, CUSBPNINTERFACE_CUSBPNINTERFACE_DESTRUCTOR_ENTRY, "CUsbPnInterface::~CUsbPnInterface" );
+    C_TRACE( ( _T( "CUsbPnInterface::~CUsbPnInterface()" ) ) );
+
+    if( iUsbReceiver )
+        {
+        delete iUsbReceiver;
+        }
+
+    if( iIsaReceiver )
+        {
+        delete iIsaReceiver;
+        }
+    iIscApi.Close();
+
+    if( iInitialised )
+        {
+        ReleaseInterface();
+        }
+
+    if( iAlt )
+        {
+        delete iAlt;
+        }
+
+    OstTrace0( TRACE_NORMAL, CUSBPNINTERFACE_CUSBPNINTERFACE_DESTRUCTOR_EXIT, "CUsbPnInterface::~CUsbPnInterface - return" );
+    C_TRACE( ( _T( "CUsbPnInterface::~CUsbPnInterface() - return" ) ) );
+    }
+
+// -----------------------------------------------------------------------------
+// CUsbPnInterface::HandleDeviceStateChange
+// ?implementation_description
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CUsbPnInterface::HandleDeviceStateChange( TUint aDeviceState )
+    {
+    OstTrace1( TRACE_API, CUSBPNINTERFACE_HANDLEDEVICESTATECHANGE_ENTRY, "CUsbPnInterface::HandleDeviceStateChange;aDeviceState=%u", aDeviceState );
+    A_TRACE( ( _T( "CUsbPnInterface::HandleDeviceStateChange( aDeviceState:%d )"), aDeviceState ));
+
+    if(aDeviceState & KUsbAlternateSetting)
+        {
+        OstTrace0( TRACE_API, CUSBPNINTERFACE_HANDLEDEVICESTATECHANGE, "CUsbPnInterface::HandleDeviceStateChange - Change alternate setting" );
+        A_TRACE( ( _T( "CUsbPnInterface::HandleDeviceStateChange - Change alternate setting")));
+        TUint altSetNbr( aDeviceState & ~KUsbAlternateSetting );
+
+        SetAltSetting( altSetNbr );
+        }
+    else
+        {
+        OstTrace0( TRACE_DETAILED, CUSBPNINTERFACE_HANDLEDEVICESTATECHANGE_DUP1, "CUsbPnInterface::HandleDeviceStateChange - Normal state change" );
+        E_TRACE( ( _T( "CUsbPnInterface::HandleDeviceStateChange - Normal state change")));
+        switch( aDeviceState )
+            {
+            case EUsbcDeviceStateUndefined:
+                {
+                OstTrace0( TRACE_API, CUSBPNINTERFACE_HANDLEDEVICESTATECHANGE_DUP4, "CUsbPnInterface::HandleDeviceStateChange - EUsbcDeviceStateUndefined" );
+                A_TRACE( ( _T( "CUsbPnInterface::HandleDeviceStateChange - EUsbcDeviceStateUndefined")));
+                // Cancel async USB operations
+                iUsbReceiver->SetEnumerated( EFalse );
+                iUsbReceiver->Cancel();
+                break;
+                }
+            case EUsbcDeviceStateDefault:
+                {
+                OstTrace0( TRACE_API, CUSBPNINTERFACE_HANDLEDEVICESTATECHANGE_DUP5, "CUsbPnInterface::HandleDeviceStateChange - EUsbcDeviceStateDefault" );
+                A_TRACE( ( _T( "CUsbPnInterface::HandleDeviceStateChange - EUsbcDeviceStateDefault")));
+                // Cancel async USB operations
+                iUsbReceiver->SetEnumerated( EFalse );
+                iUsbReceiver->Cancel();
+                break;
+                }
+            default:
+                {
+                OstTrace0( TRACE_API, CUSBPNINTERFACE_HANDLEDEVICESTATECHANGE_DUP6, "CUsbPnInterface::HandleDeviceStateChange - State of no interest" );
+                A_TRACE( ( _T( "CUsbPnInterface::HandleDeviceStateChange - State of no interest")));
+                break;
+                }
+            }
+        }
+
+    OstTrace0( TRACE_API, CUSBPNINTERFACE_HANDLEDEVICESTATECHANGE_EXIT, "CUsbPnInterface::HandleDeviceStateChange - return void" );
+    A_TRACE( ( _T( "CUsbPnInterface::HandleDeviceStateChange() - return void")));
+    }
+
+// -----------------------------------------------------------------------------
+// CUsbPnInterface::SetAltSetting
+// ?implementation_description
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CUsbPnInterface::SetAltSetting( TUint aAltSetNumber )
+    {
+    OstTrace1( TRACE_API, CUSBPNINTERFACE_SETALTSETTING_ENTRY, "CUsbPnInterface::SetAltSetting;aAltSetNumber=%u", aAltSetNumber );
+    A_TRACE( ( _T( "CUsbPnInterface::SetAltSetting( aAltSetNumber:%d )" ), aAltSetNumber ) );
+
+    if( aAltSetNumber )
+        {
+        // Receive from ISA with forwarding
+        iIsaReceiver->SetForwardFlag( ETrue );
+
+        iUsbReceiver->SetEnumerated( ETrue );
+        iUsbReceiver->Receive( ETrue /*dummy*/ );
+        }
+    else
+        {
+        // Receive from ISA without forwarding
+        iIsaReceiver->SetForwardFlag( EFalse );
+
+        iUsbReceiver->SetEnumerated( EFalse );
+        iUsbReceiver->Cancel();
+        }
+
+    OstTrace0( TRACE_API, CUSBPNINTERFACE_SETALTSETTING_EXIT, "CUsbPnInterface::SetAltSetting - return void" );
+    A_TRACE( ( _T( "CUsbPnInterface::SetAltSetting() - return void")));
+    }
+
+// -----------------------------------------------------------------------------
+// CUsbPnInterface::InitialiseInterfaceL
+// ?implementation_description
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CUsbPnInterface::InitialiseInterfaceL()
+    {
+    OstTrace0( TRACE_API, CUSBPNINTERFACE_INITIALISEINTERFACEL_ENTRY, "CUsbPnInterface::InitialiseInterfaceL" );
+    A_TRACE( ( _T( "CUsbPnInterface::InitialiseInterfaceL()" ) ) );
+
+    TInt ret = iCommLdd.Open(0);
+    if (ret != KErrNone)
+        {
+        // Maybe the device is not loaded yet.
+        _LIT(KUsbLDDName, "eusbc");
+        ret = User::LoadLogicalDevice( KUsbLDDName );
+
+        OstTrace1( TRACE_DETAILED, DUP100_CUSBPNINTERFACE_INITIALISEINTERFACEL, "CUsbPnInterface::InitialiseInterfaceL - Tried loading the device with status %d", ret );
+        E_TRACE( ( _T("CUsbPnInterface::InitialiseInterfaceL - Tried loading the device with status %d"), ret ) );
+
+        if (ret == KErrNone || ret == KErrAlreadyExists)
+            {
+            ret = iCommLdd.Open(0);
+            }
+
+        if (ret != KErrNone)
+            {
+            OstTrace1( TRACE_DETAILED, CUSBPNINTERFACE_INITIALISEINTERFACEL, "CUsbPnInterface::InitialiseInterfaceL - USBPN - Cannot open Comm LDD %d", ret );
+            E_TRACE( ( _T( "USBPN - Cannot open Comm LDD %d" ), ret ) );
+            User::Leave( KErrNotReady );
+            }
+        }
+
+    ret = iPnDataLdd.Open(0);
+    if (ret != KErrNone)
+        {
+        OstTrace0( TRACE_DETAILED, CUSBPNINTERFACE_INITIALISEINTERFACEL_DUP1, "CUsbPnInterface::InitialiseInterfaceL - USBPN - Cannot open PnData LDD" );
+        E_TRACE( ( _T( "USBPN - Cannot open PnData LDD" ) ) );
+        User::Leave( KErrNotReady );
+        }
+
+
+//////////////////////////////////////////////////////////////////////
+// Comm interface
+//////////////////////////////////////////////////////////////////////
+
+    OstTrace0( TRACE_DETAILED, CUSBPNINTERFACE_INITIALISEINTERFACEL_DUP2, "CUsbPnInterface::InitialiseInterfaceL - USBPN - Setup Comm interface" );
+    E_TRACE( ( _T( "USBPN - Setup Comm interface" ) ) );
+
+    TUsbcInterfaceInfoBuf ifc;
+
+    ifc().iString = const_cast<TDesC16*> (&KUsbPnCommIfc);
+    ifc().iTotalEndpointsUsed = 0;
+    ifc().iClass.iClassNum    = KCommInterfaceClass;
+    ifc().iClass.iSubClassNum = KCommInterfaceSubClass;
+    ifc().iClass.iProtocolNum = KCommInterfaceProtocol;
+
+    OstTrace0( TRACE_DETAILED, CUSBPNINTERFACE_INITIALISEINTERFACEL_DUP3, "CUsbPnInterface::InitialiseInterfaceL - USBPN - Call SetInterface 0" );
+    E_TRACE( ( _T( "USBPN - Call SetInterface 0" ) ) );
+
+    ret = iCommLdd.SetInterface(0, ifc);
+    if (ret != KErrNone)
+        {
+        TRACE_ASSERT_ALWAYS;
+        User::Leave( ret );
+        }
+
+    //Get the interface number for later
+    TBuf8<100> interfaceDescriptor;
+    iCommLdd.GetInterfaceDescriptor(0, interfaceDescriptor);
+    TUint8 interfaceNum;
+    interfaceNum = interfaceDescriptor.Ptr()[2];
+
+    HBufC8* descBuf = HBufC8::NewLC( 64 );
+    TPtr8 desc( descBuf->Des() );
+
+    //Comms Class Header Functional Descriptor
+    desc.Append(KPnHeaderFunctionalDescriptorLength);
+    desc.Append(KUsbDescType_CS_Interface);
+    desc.Append(KHeaderDescriptorSubType);
+    desc.Append(KCDCVersionNumber[0]);
+    desc.Append(KCDCVersionNumber[1]);
+
+    // PHONET Functional Descriptor
+    desc.Append(KPnFunctionalDescriptorLength);
+    desc.Append(KUsbDescType_CS_Interface);
+    desc.Append(KFunctionalDescriptorSubType);
+
+    // Union Functional Descriptor
+    desc.Append(KPnUnionFunctionalDescriptorLength);
+    desc.Append(KUsbDescType_CS_Interface);
+    desc.Append(KUnionDescriptorSubType);
+    desc.Append(interfaceNum);
+    TInt dataInt;
+    dataInt = interfaceNum + 1;
+    desc.Append(static_cast<TUint8>(dataInt));
+
+    // Vendor DMA FD
+    desc.Append(KVendorDMAFDDescriptorLength);
+    desc.Append(KUsbDescType_CS_Interface);
+    desc.Append(KVendorDMADescriptorSubType);
+    desc.Append(KDmaCapabilities);      // Is zero. Meaning interface is DMA incapable
+
+    OstTrace0( TRACE_DETAILED, CUSBPNINTERFACE_INITIALISEINTERFACEL_DUP4, "CUsbPnInterface::InitialiseInterfaceL - USBPN - SetCSInterfaceDescriptorBlock" );
+    E_TRACE( ( _T( "USBPN - SetCSInterfaceDescriptorBlock" ) ) );
+    ret = iCommLdd.SetCSInterfaceDescriptorBlock(0, desc);
+
+    CleanupStack::PopAndDestroy( descBuf );
+
+    if (ret != KErrNone)
+        {
+        TRACE_ASSERT_ALWAYS;
+        User::Leave( ret );
+        }
+
+
+//////////////////////////////////////////////////////////////////////
+// PHONET data interface alt 0
+//////////////////////////////////////////////////////////////////////
+
+    OstTrace0( TRACE_DETAILED, CUSBPNINTERFACE_INITIALISEINTERFACEL_DUP5, "CUsbPnInterface::InitialiseInterfaceL - USBPN - Register PHONET Data IF (alt 0)" );
+    E_TRACE( ( _T( "USBPN - Register PHONET Data IF (alt 0)" ) ) );
+    TUsbcInterfaceInfoBuf dataifc;
+
+    dataifc().iString = const_cast<TDesC16*> (&KUsbPnDataAlt0Ifc);
+    dataifc().iClass.iClassNum = KDataInterfaceClass;
+    dataifc().iClass.iSubClassNum = KDataInterfaceSubClass;
+    dataifc().iClass.iProtocolNum = KDataInterfaceProtocol;
+    dataifc().iTotalEndpointsUsed = 0;
+
+    OstTrace0( TRACE_DETAILED, CUSBPNINTERFACE_INITIALISEINTERFACEL_DUP6, "CUsbPnInterface::InitialiseInterfaceL - USBPN - Setup PHONET Data IF (alt 0)" );
+    E_TRACE( ( _T( "USBPN - Setup PHONET Data IF (alt 0)" ) ) );
+
+    ret = iPnDataLdd.SetInterface(0, dataifc);
+    if (ret != KErrNone)
+        {
+        TRACE_ASSERT_ALWAYS;
+        User::Leave( ret );
+        }
+
+
+
+//////////////////////////////////////////////////////////////////////
+// data interface alt 1
+//////////////////////////////////////////////////////////////////////
+
+    OstTrace0( TRACE_DETAILED, CUSBPNINTERFACE_INITIALISEINTERFACEL_DUP7, "CUsbPnInterface::InitialiseInterfaceL - USBPN - Register PHONET Data IF (alt 1)" );
+    E_TRACE( ( _T( "USBPN - Register PHONET Data IF (alt 1)" ) ) );
+    //Register Data Interface 1
+    TUsbcInterfaceInfoBuf dataifc1;
+    // Fill in dataifc1
+    dataifc1().iString = const_cast<TDesC16*> (&KUsbPnDataAlt1Ifc);;
+    dataifc1().iClass.iClassNum = KDataInterfaceClass;
+    dataifc1().iClass.iSubClassNum = KDataInterfaceSubClass;
+    dataifc1().iClass.iProtocolNum = KDataInterfaceProtocol;
+    dataifc1().iTotalEndpointsUsed = KUsbPnRequiredNumberOfEndpoints;
+
+    TUsbDeviceCaps dCaps1;
+    ret = iPnDataLdd.DeviceCaps(dCaps1);
+    OstTrace0( TRACE_DETAILED, CUSBPNINTERFACE_INITIALISEINTERFACEL_DUP8, "CUsbPnInterface::InitialiseInterfaceL - USBPN - Checking result of DeviceCaps" );
+    E_TRACE( ( _T( "USBPN - Checking result of DeviceCaps" ) ) );
+    if ( ret )
+        {
+        TRACE_ASSERT_ALWAYS;
+        User::Leave( ret );
+        }
+
+    const TUint totalEndpoints1 = static_cast<TUint>(dCaps1().iTotalEndpoints);
+    OstTrace1( TRACE_DETAILED, CUSBPNINTERFACE_INITIALISEINTERFACEL_DUP9, "CUsbPnInterface::InitialiseInterfaceL - USBPN - TotalEndpoints1=%d", totalEndpoints1 );
+    E_TRACE( ( _T( "USBPN - TotalEndpoints1 %d" ), totalEndpoints1 ) );
+    if (totalEndpoints1 < KUsbPnRequiredNumberOfEndpoints)
+        {
+        TRACE_ASSERT_ALWAYS;
+        User::Leave( KErrGeneral );
+        }
+
+
+    TUsbcEndpointData data1[KUsbcMaxEndpoints];
+    TPtr8 dataptr1 = TPtr8(reinterpret_cast<TUint8*>(data1), sizeof(data1), sizeof(data1));
+    ret = iPnDataLdd.EndpointCaps(dataptr1);
+    OstTrace0( TRACE_DETAILED, CUSBPNINTERFACE_INITIALISEINTERFACEL_DUP10, "CUsbPnInterface::InitialiseInterfaceL - USBPN - Checking result of EndpointCaps" );
+    E_TRACE( ( _T( "USBPN - Checking result of EndpointCaps" ) ) );
+    if (ret)
+        {
+        TRACE_ASSERT_ALWAYS;
+        User::Leave( ret );
+        }
+
+    // Set data interface 1
+    TBool outFound = EFalse;
+    TBool inFound = EFalse;
+
+    for (TUint ii = 0 ; ii < totalEndpoints1; ii++)
+        {
+        OstTrace0( TRACE_DETAILED, CUSBPNINTERFACE_INITIALISEINTERFACEL_DUP11, "CUsbPnInterface::InitialiseInterfaceL - USBPN - Set data interface 1" );
+        E_TRACE( ( _T( "USBPN - Set data interface 1" ) ) );
+        const TUsbcEndpointCaps* caps;
+        caps = &data1[ii].iCaps;
+
+        OstTraceExt2( TRACE_DETAILED, CUSBPNINTERFACE_INITIALISEINTERFACEL_DUP12, "CUsbPnInterface::InitialiseInterfaceL - USBPN - iTypesAndDir=%d, epSize=%d", caps->iTypesAndDir, caps->MaxPacketSize() );
+        E_TRACE( ( _T( "USBPN - iTypesAndDir %d, epSize:%d" ), caps->iTypesAndDir, caps->MaxPacketSize() ) );
+
+#ifdef EXTENDED_TRACE_FLAG
+        if(((caps->iTypesAndDir & (KUsbEpDirIn)) == (KUsbEpDirIn) ) )
+            {
+            OstTrace0( TRACE_DETAILED, CUSBPNINTERFACE_INITIALISEINTERFACEL_DUP13, "CUsbPnInterface::InitialiseInterfaceL - USBPN - IN" );
+            E_TRACE( ( _T( "USBPN - IN" )));
+            }
+        if(((caps->iTypesAndDir & (KUsbEpDirOut)) == (KUsbEpDirOut) ) )
+            {
+            OstTrace0( TRACE_DETAILED, CUSBPNINTERFACE_INITIALISEINTERFACEL_DUP14, "CUsbPnInterface::InitialiseInterfaceL - USBPN - OUT" );
+            E_TRACE( ( _T( "USBPN - OUT" )));
+            }
+        if(((caps->iTypesAndDir & (KUsbEpTypeBulk)) == (KUsbEpTypeBulk)))
+            {
+            OstTrace0( TRACE_DETAILED, CUSBPNINTERFACE_INITIALISEINTERFACEL_DUP15, "CUsbPnInterface::InitialiseInterfaceL - USBPN - BULK" );
+            E_TRACE( ( _T( "USBPN - BULK" )));
+            }
+#endif // EXTENDED_TRACE_FLAG
+
+        if(data1[ii].iInUse)
+            {
+            OstTrace0( TRACE_DETAILED, CUSBPNINTERFACE_INITIALISEINTERFACEL_DUP16, "CUsbPnInterface::InitialiseInterfaceL - USBPN - Ep in use. Next..." );
+            E_TRACE( ( _T( "USBPN - Ep in use. Next...")));
+            continue;
+            }
+
+        //changes to bulk in ep
+        if (((caps->iTypesAndDir & (KUsbEpTypeBulk | KUsbEpDirIn)) ==
+            (KUsbEpTypeBulk | KUsbEpDirIn)) && !inFound)
+            {
+            OstTrace0( TRACE_DETAILED, CUSBPNINTERFACE_INITIALISEINTERFACEL_DUP17, "CUsbPnInterface::InitialiseInterfaceL - USBPN - Bulk IN found for EEndpoint1" );
+            E_TRACE( ( _T( "USBPN - Bulk IN found for EEndpoint1" ) ) );
+            // EEndpoint1 is bulk in endpoint
+            dataifc1().iEndpointData[0].iType       = KUsbEpTypeBulk;
+            dataifc1().iEndpointData[0].iDir        = KUsbEpDirIn;
+            //dataifc1().iEndpointData[0].iInterval   = 0;
+
+            dataifc1().iEndpointData[0].iSize       = caps->MaxPacketSize();
+            inFound = ETrue;
+            }
+        else if (((caps->iTypesAndDir & (KUsbEpTypeBulk | KUsbEpDirOut)) ==
+            (KUsbEpTypeBulk | KUsbEpDirOut)) && !outFound)
+            {
+            OstTrace0( TRACE_DETAILED, CUSBPNINTERFACE_INITIALISEINTERFACEL_DUP18, "CUsbPnInterface::InitialiseInterfaceL - USBPN - Bulk OUT found for EEndpoint2" );
+            E_TRACE( ( _T( "USBPN - Bulk OUT found for EEndpoint2" ) ) );
+            // EEndpoint2 is bulk out endpoint
+            dataifc1().iEndpointData[1].iType       = KUsbEpTypeBulk;
+            dataifc1().iEndpointData[1].iDir        = KUsbEpDirOut;
+            //dataifc1().iEndpointData[1].iInterval   = 0;
+
+            dataifc1().iEndpointData[1].iSize       = caps->MaxPacketSize();
+            outFound = ETrue;
+            }
+
+        if (outFound && inFound)
+            {
+            break;
+            }
+        } // end for ( ... )
+    OstTrace0( TRACE_DETAILED, CUSBPNINTERFACE_INITIALISEINTERFACEL_DUP19, "CUsbPnInterface::InitialiseInterfaceL - USBPN - Checking epFound" );
+    E_TRACE( ( _T( "USBPN - Checking epFound" ) ) );
+    if (!outFound || !inFound )
+        {
+        TRACE_ASSERT_ALWAYS;
+        User::Leave( KErrGeneral );
+        }
+
+    OstTrace0( TRACE_DETAILED, CUSBPNINTERFACE_INITIALISEINTERFACEL_DUP20, "CUsbPnInterface::InitialiseInterfaceL - USBPN - Setting LCIF Data IF (alt 1)" );
+    E_TRACE( ( _T( "USBPN - Setting LCIF Data IF (alt 1)" ) ) );
+
+    ret = iPnDataLdd.SetInterface(1, dataifc1);
+    if (ret != KErrNone)
+        {
+        TRACE_ASSERT_ALWAYS;
+        User::Leave( ret );
+        }
+
+    iAlt->ListenStateChange();
+    iInitialised = ETrue;
+
+    OstTrace0( TRACE_NORMAL, CUSBPNINTERFACE_INITIALISEINTERFACEL_EXIT, "CUsbPnInterface::InitialiseInterfaceL - return void" );
+    C_TRACE( ( _T( "CUsbPnInterface::InitialiseInterfaceL() - return void")));
+    }
+
+// -----------------------------------------------------------------------------
+// CUsbInterface::ReleaseInterface
+// Release and close all LDD in reverse order as in setup
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CUsbPnInterface::ReleaseInterface()
+    {
+    OstTrace0( TRACE_API, CUSBPNINTERFACE_RELEASEINTERFACE_ENTRY, "CUsbPnInterface::ReleaseInterface" );
+    A_TRACE( ( _T( "CUsbPnInterface::ReleaseInterface()" ) ) );
+
+    iAlt->Cancel();
+
+    TInt ret;
+
+    ret = iPnDataLdd.ReleaseInterface(1);
+    if (ret != KErrNone)
+        {
+        TRACE_ASSERT_ALWAYS;
+        }
+
+    ret = iPnDataLdd.ReleaseInterface(0);
+    if (ret != KErrNone)
+        {
+        TRACE_ASSERT_ALWAYS;
+        }
+
+    iPnDataLdd.Close();
+
+    ret = iCommLdd.ReleaseInterface(0);
+    if (ret != KErrNone)
+        {
+        TRACE_ASSERT_ALWAYS;
+        }
+
+    iCommLdd.Close();
+
+    iInitialised = EFalse;
+
+    OstTrace0( TRACE_NORMAL, CUSBPNINTERFACE_RELEASEINTERFACE_EXIT, "CUsbPnInterface::ReleaseInterface - return void" );
+    C_TRACE( ( _T( "CUsbPnInterface::ReleaseInterface() - return void" ) ) );
+    }
+
+// ========================== OTHER EXPORTED FUNCTIONS =========================
+
+//  End of File