/*

* 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:

* Source file for USB Phonet Link starter.

*/

// INCLUDE FILES

#include    "usbpnstarter.h"    // For trace macros

#include    <rusbpnclient.h>    // For RUsbPnClient

#include    <e32std.h>          // For User

#include    <d32usbc.h>         // For RDevUsbcClient

#ifdef BSW_USB_DRC // flag for OTG support

#include    <d32otgdi.h>        // RUsbOtgDriver

#endif // BSW_USB_DRC

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

_LIT(KUsbLDDName, "eusbc");

#ifdef BSW_USB_DRC

_LIT(KOtgdiLddFilename, "otgdi");

#endif // BSW_USB_DRC

//Device Descriptor Offsets

const TInt KUsbSpecOffset                   = 2;

const TInt KUsbDeviceClassOffset            = 4;

const TInt KUsbDeviceSubClassOffset         = 5;

const TInt KUsbDeviceProtocolOffset         = 6;

const TInt KUsbVendorIdOffset               = 8;

const TInt KUsbProductIdOffset              = 10;

const TInt KUsbDevReleaseOffset             = 12;

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

// ============================= LOCAL FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// LoadUsbDriverL()

// -----------------------------------------------------------------------------

void LoadUsbDriverL( RDevUsbcClient& aDriver )

    {

    C_TRACE( ( _T("usbpnstarter # LoadUsbDriverL") ) );

    TInt error = User::LoadLogicalDevice(KUsbLDDName);

    if( error != KErrNone || error != KErrAlreadyExists )

        {

        C_TRACE( ( _T("usbpnstarter # LoadUsbDriverL - LDD load failed: %d"), error ) );

        User::Leave(error);

        }

    // Open channel to device driver.

    error = aDriver.Open(0);

    if ( error != KErrNone )

        {

        C_TRACE( ( _T("usbpnstarter # LoadUsbDriverL - aDriver.Open failed: %d"), error ) );

        User::Leave(error);

        }

#ifdef BSW_USB_DRC

    error = User::LoadLogicalDevice(KOtgdiLddFilename);

    if( error != KErrNone && error != KErrAlreadyExists )

        {

        C_TRACE( ( _T("usbpnstarter # Error %d on loading OTG LDD"), error ) );

        User::Leave(error);

        }

    RUsbOtgDriver otgDevice;

    error = otgDevice.Open();

    if (error != KErrNone)

        {

        C_TRACE( ( _T("usbpnstarter # Error %d on opening OTG port"), error ) );

        User::Leave(error);

        }

    error = otgDevice.StartStacks();

    if (error != KErrNone)

        {

        C_TRACE( ( _T("usbpnstarter # Error %d on starting USB stack"), error ) );

        User::Leave(error);

        }

#endif // BSW_USB_DRC

    }

// -----------------------------------------------------------------------------

// SetupDeviceDescriptors()

// -----------------------------------------------------------------------------

TInt SetupDeviceDescriptors( RDevUsbcClient& aDriver )

    {

    C_TRACE( ( _T( "usbpnstarter # SetupDeviceDescriptors") ) );

    // Simulates a physical removal of the USB cable

    TInt ret = aDriver.DeviceDisconnectFromHost();

    TBuf8<KUsbDescSize_Device> deviceDescriptor;

    ret = aDriver.GetDeviceDescriptor( deviceDescriptor );

    if( ret != KErrNone )

        {

        return KErrGeneral;

        }

    // Change the USB spec number to 2.00

    deviceDescriptor[ KUsbSpecOffset ]   = 0x00;

    deviceDescriptor[ KUsbSpecOffset+1 ] = 0x02;

    //Change the Device Class Codes

    deviceDescriptor[ KUsbDeviceClassOffset ] = 0x02;     // Class = 0x02;

    deviceDescriptor[ KUsbDeviceSubClassOffset ] = 0x00;  // SubClass = 0x00;

    deviceDescriptor[ KUsbDeviceProtocolOffset ] = 0x00;  // Protocol = 0x00;

    // Change the device vendor ID ( VID ) to 0x0421 ( Nokia Vendor ID )

    deviceDescriptor[ KUsbVendorIdOffset ]   = 0x21;

    deviceDescriptor[ KUsbVendorIdOffset+1 ] = 0x04;

    // Change the device product ID ( PID )( Generic Nokia ID ) to 0x00c8

    deviceDescriptor[ KUsbProductIdOffset ] = 0xC8;

    deviceDescriptor[ KUsbProductIdOffset+1 ] = 0x00;

    // Change the device release number to 0x0110

    deviceDescriptor[ KUsbDevReleaseOffset ] = 0x10;

    deviceDescriptor[ KUsbDevReleaseOffset+1 ] = 0x01;

    ret = aDriver.SetDeviceDescriptor( deviceDescriptor );

    if( ret != KErrNone )

        {

        return KErrGeneral;

        }

    C_TRACE( ( _T( "usbpnstarter # SetupDeviceDescriptors return %d"), ret) );

    return ret;

    }

// -----------------------------------------------------------------------------

// CreateGenericCdcInterface()

// -----------------------------------------------------------------------------

TInt CreateGenericCdcInterface( RDevUsbcClient& aDriver )

    {

    C_TRACE( ( _T( "usbpnstarter # CreateGenericCdcInterface()") ) );

    TInt ret = KErrNone;

    TUsbDeviceCaps deviceCaps;

    ret = aDriver.DeviceCaps(deviceCaps);

    if ( KErrNone == ret )

        {

        TInt totalEndpoints = deviceCaps().iTotalEndpoints;

        C_TRACE( ( _T( "usbpnstarter # CreateGenericCdcInterface Number of endpoints: %d"), totalEndpoints) );

        // Endpoints

        TUsbcEndpointData data[KUsbcMaxEndpoints];

        TPtr8 dataptr(reinterpret_cast<TUint8*>(data), sizeof(data), sizeof(data));

        ret = aDriver.EndpointCaps(dataptr);

        if ( KErrNone == ret )

            {

            TUsbcInterfaceInfoBuf ifc;

            TInt endPointsFound = 0;

            TBool foundBulkIN = EFalse;

            TBool foundBulkOUT = EFalse;

            TInt i = 0;

            ret = KErrNotFound;

            while ( i < totalEndpoints && endPointsFound < 2 )

                {

                const TUsbcEndpointCaps* caps = &data[i].iCaps;

                const TInt maxPacketSize = caps->MaxPacketSize();

                if ( !foundBulkIN &&

                    (caps->iTypesAndDir & (KUsbEpTypeBulk | KUsbEpDirIn)) == (KUsbEpTypeBulk | KUsbEpDirIn) )

                    {

                    C_TRACE( ( _T( "usbpnstarter # CreateGenericCdcInterface EEndpoint%d is going to be our TX (IN, write) endpoint"), i) );

                    // EEndpoint1 is going to be our TX (IN, write) endpoint

                    ifc().iEndpointData[0].iType = KUsbEpTypeBulk;

                    ifc().iEndpointData[0].iDir  = KUsbEpDirIn;

                    ifc().iEndpointData[0].iSize = maxPacketSize;

                    foundBulkIN = ETrue;

                    endPointsFound++;

                    }

                if ( !foundBulkOUT &&

                    (caps->iTypesAndDir & (KUsbEpTypeBulk | KUsbEpDirOut)) == (KUsbEpTypeBulk | KUsbEpDirOut) )

                    {

                    C_TRACE( ( _T( "usbpnstarter # CreateGenericCdcInterface EEndpoint%d is going to be our RX (OUT, read) endpoint"), i) );

                    // EEndpoint2 is going to be our RX (OUT, read) endpoint

                    ifc().iEndpointData[1].iType = KUsbEpTypeBulk;

                    ifc().iEndpointData[1].iDir  = KUsbEpDirOut;

                    ifc().iEndpointData[1].iSize = maxPacketSize;

                    foundBulkOUT = ETrue;

                    endPointsFound++;

                    }

                i++;

                }

            if ( endPointsFound == 2 )

                {

                _LIT16(KUSBName, "HS USB Test Interface");

                TBufC16<30> string(KUSBName);

                ifc().iString = &string;

                ifc().iTotalEndpointsUsed = 2;

                ifc().iClass.iClassNum    = 0xff;

                ifc().iClass.iSubClassNum = 0xff;

                ifc().iClass.iProtocolNum = 0xff;

                ret = aDriver.SetInterface(0, ifc);

                }

            }

        }

    C_TRACE( ( _T( "usbpnstarter # CreateGenericCdcInterface return %d"), ret) );

    return ret;

    }

// ============================ MEMBER FUNCTIONS ===============================

// ========================== OTHER EXPORTED FUNCTIONS =========================

// -----------------------------------------------------------------------------

// E32Main()

// -----------------------------------------------------------------------------

GLDEF_C TInt E32Main()

    {

    C_TRACE( ( _T( "usbpnstarter # E32Main()") ) );

    RDevUsbcClient usbDriver;

    TRAPD( ret, LoadUsbDriverL( usbDriver ) );

    if( ret != KErrNone )

        {

        C_TRACE( ( _T( "usbpnstarter # E32Main() - LoadUsbDriverL failed.") ) );

        return ret;

        }

    ret = SetupDeviceDescriptors( usbDriver );

    if( ret != KErrNone )

        {

        C_TRACE( ( _T( "usbpnstarter # E32Main() - SetupDeviceDescriptors failed.") ) );

        return ret;

        }

    RUsbPnClient usbPnClient;

    TRAPD( ret, usbPnClient.ConnectL() );

    if ( ret != KErrNone )

        {

        C_TRACE( ( _T( "usbpnstarter # E32Main() - ConnectL failed.") ) );

        return ret;

        }

    usbDriver.PowerUpUdc();

    usbDriver.DeviceConnectToHost();

    ret = CreateGenericCdcInterface( usbDriver );

    if( ret != KErrNone )

        {

        C_TRACE( ( _T( "usbpnstarter # E32Main() - CreateGenericCdcInterface failed.") ) );

        return ret;

        }

    C_TRACE( ( _T( "usbpnstarter # E32Main() - Going to infinite loop") ) );

    while( 1 ); // Stay on forever. Usbpnserver will destroy itself when there are no clients.

    }

//  End of File